sunfire/io/sysctrl_dr.c

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

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

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/ddi_impldefs.h>
#include <sys/ndi_impldefs.h>
#include <sys/obpdefs.h>
#include <sys/cmn_err.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <sys/ivintr.h>
#include <sys/autoconf.h>
#include <sys/intreg.h>
#include <sys/proc.h>
#include <sys/machsystm.h>
#include <sys/modctl.h>
#include <sys/callb.h>
#include <sys/file.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/fhc.h>
#include <sys/sysctrl.h>
#include <sys/jtag.h>
#include <sys/ac.h>
#include <sys/simmstat.h>
#include <sys/clock.h>
#include <sys/promif.h>
#include <sys/promimpl.h>
#include <sys/cpr.h>
#include <sys/cpuvar.h>
#include <sys/machcpuvar.h>
#include <sys/x_call.h>

#ifdef DEBUG
struct  regs_data {
    caddr_t msg;
    u_longlong_t physaddr;
    uint_t pre_dsct;
    uint_t post_dsct;
    uint_t eflag;
    uint_t oflag;
};

static  struct regs_data reg_tmpl[] = {
    "AC  Control and Status reg = 0x", AC_BCSR(0), 0, 0, 0, 0,
    "FHC Control and Status reg = 0x", FHC_CTRL(0), 0, 0, 0, 0,
    "JTAG Control reg = 0x", FHC_JTAG_CTRL(0), 0, 0, 0, 0,
    "Interrupt Group Number reg = 0x", FHC_IGN(0), 0, 0, 0, 0,
    "System Interrupt Mapping reg = 0x", FHC_SIM(0), 0, 0, 0, 0,
    "System Interrupt State reg = 0x", FHC_SSM(0), 0, 0, 0, 0,
    "UART Interrupt Mapping reg = 0x", FHC_UIM(0), 0, 0, 0, 0,
    "UART Interrupt State reg = 0x", FHC_USM(0), 0, 0, 0, 0
};

#define NUM_REG  (sizeof (reg_tmpl)/sizeof (reg_tmpl[0]))
static  struct regs_data reg_dt[MAX_BOARDS][NUM_REG];

int sysctrl_enable_regdump = 0;

static void precache_regdump(int board);
static void display_regdump(void);
static void boardstat_regdump(void);

#endif /* DEBUG */

extern void bd_remove_poll(struct sysctrl_soft_state *);
extern int sysctrl_getsystem_freq(void);
extern enum power_state compute_power_state(struct sysctrl_soft_state *, int);
extern enum temp_state fhc_env_temp_state(int);
extern int sysctrl_hotplug_disabled;
/* Let user disable Sunfire Dynamic Reconfiguration */
int enable_dynamic_reconfiguration = 1;

int enable_redist = 1;

static void sysc_dr_err_decode(sysc_dr_handle_t *, dev_info_t *, int);
static uint_t
sysc_policy_enough_cooling(struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat, uint_t ps_mutex_is_held);
static uint_t
sysc_policy_enough_precharge(struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat);
static uint_t
sysc_policy_enough_power(struct sysctrl_soft_state *softsp,
    int plus_load, uint_t ps_mutex_is_held);
static uint_t
sysc_policy_hardware_compatible(struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat, sysc_cfga_pkt_t *pkt);
static void sysc_policy_empty_condition(
    struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat, uint_t failure,
    uint_t ps_mutex_is_held);
static void sysc_policy_disconnected_condition(
    struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat, uint_t failure,
    uint_t ps_mutex_is_held);
static void sysc_policy_connected_condition(struct sysctrl_soft_state *softsp,
        sysc_cfga_stat_t *sysc_stat,
        uint_t ps_mutex_is_held);
static void sysc_policy_set_condition(void *sp, sysc_cfga_stat_t *sysc_stat,
                uint_t ps_mutex_is_held);
static void sysc_policy_audit_messages(sysc_audit_evt_t event,
        sysc_cfga_stat_t *sysc_stat);

static void sysctrl_post_config_change(struct sysctrl_soft_state *softsp);
static int sysc_bd_connect(int, sysc_cfga_pkt_t *);
static int sysc_bd_disconnect(int, sysc_cfga_pkt_t *);
static int sysc_bd_configure(int, sysc_cfga_pkt_t *);
static int sysc_bd_unconfigure(int, sysc_cfga_pkt_t *);

static void sysc_dr_init(sysc_dr_handle_t *handle);
static void sysc_dr_uninit(sysc_dr_handle_t *handle);
static int sysc_dr_attach(sysc_dr_handle_t *handle, int board);
static int sysc_dr_detach(sysc_dr_handle_t *handle, int board);

static int sysc_prom_select(pnode_t pnode, void *arg, uint_t flag);
static void sysc_branch_callback(dev_info_t *rdip, void *arg, uint_t flags);

static int find_and_setup_cpu(int);

static int sysc_board_connect_supported(enum board_type);

static int find_and_setup_cpu_start(void *cpuid_arg, int has_changed);
/*
 * This function will basically do a prediction on the power state
 * based on adding one additional load to the equation implemented
 * by the function compute_power_state.
 */
/*ARGSUSED*/
static uint_t
sysc_policy_enough_power(struct sysctrl_soft_state *softsp,
    int plus_load, uint_t ps_mutex_is_held)
{
    int retval = 0;

    ASSERT(softsp);

    if (!ps_mutex_is_held) {
        mutex_enter(&softsp->ps_fail_lock);
    }

    /*
     * note that we add one more load
     * to the equation in compute_power_state
     * and the answer better be REDUNDANT or
     * MINIMUM before proceeding.
     */
    switch (compute_power_state(softsp, plus_load)) {
        case REDUNDANT:
        case MINIMUM:
            retval = 1;
            break;
        case BELOW_MINIMUM:
        default:
            break;
    }

    if (!ps_mutex_is_held) {
        mutex_exit(&softsp->ps_fail_lock);
    }
    return (retval);
}

/*
 * This function gropes through the shadow registers in the sysctrl soft_state
 * for the core power supply status, since fan status for them are ORed into
 * the same status bit, and all other remaining fans.
 */
static uint_t
sysc_policy_enough_cooling(struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat, uint_t ps_mutex_is_held)
{
    int retval = 0;

    if (!ps_mutex_is_held) {
        mutex_enter(&softsp->ps_fail_lock);
    }

    /*
     * check the power supply in the slot in question
     * for fans then check all the common fans.
     */
    retval = ((softsp->ps_stats[FHC_BOARD2PS(sysc_stat->board)].pshadow ==
            PRES_IN) &&
        (softsp->ps_stats[FHC_BOARD2PS(sysc_stat->board)].dcshadow ==
            PS_OK));
    if (!ps_mutex_is_held) {
        mutex_exit(&softsp->ps_fail_lock);
    }
    return (retval);
}

/*
 * This function will check all precharge voltage status.
 */
/*ARGSUSED*/
static uint_t
sysc_policy_enough_precharge(struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat)
{
    int retval = 0;
    int ppsval = 0;

    mutex_enter(&softsp->ps_fail_lock);

        /*
         *  note that we always have to explicitly check
         *  the peripheral power supply for precharge since it
         *  supplies all of the precharge voltages.
         */
    ppsval = (softsp->ps_stats[SYS_PPS0_INDEX].pshadow == PRES_IN) &&
        (softsp->ps_stats[SYS_PPS0_INDEX].dcshadow == PS_OK);

        /*
         *  check all the precharge status
         */
    retval = ((softsp->ps_stats[SYS_V3_PCH_INDEX].pshadow == PRES_IN) &&
        (softsp->ps_stats[SYS_V3_PCH_INDEX].dcshadow == PS_OK) &&
        (softsp->ps_stats[SYS_V5_PCH_INDEX].pshadow == PRES_IN) &&
        (softsp->ps_stats[SYS_V5_PCH_INDEX].dcshadow == PS_OK));

    mutex_exit(&softsp->ps_fail_lock);
    return (retval&&ppsval);
}

static int Fsys;

/*
 * This function should only be called once as we may
 * zero the clock board registers to indicate a configuration change.
 * The code to calculate the bus frequency has been removed and we
 * read the eeprom property instead. Another static Fmod (module
 * frequency may be needed later but so far it is commented out.
 */
void
set_clockbrd_info(void)
{
    uint_t clock_freq = 0;

    pnode_t root = prom_nextnode((pnode_t)0);
    (void) prom_getprop(root, "clock-frequency", (caddr_t)&clock_freq);
    Fsys = clock_freq / 1000000;
}

#define abs(x)  ((x) < 0 ? -(x) : (x))

/*ARGSUSED*/
static uint_t
sysc_policy_hardware_compatible(struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat, sysc_cfga_pkt_t *pkt)
{
    int status;

    ASSERT(Fsys > 0);

    /* Only allow DR operations on supported hardware */
    switch (sysc_stat->type) {
    case CPU_BOARD: {
#ifdef RFE_4174486
        int i;
        int cpu_freq;
        int sram_mode;

        ASSERT(Fmod > 0);

        cpu_freq = CPU->cpu_type_info.pi_clock;

        if (abs(cpu_freq - Fmod) < 8)
            sram_mode = 1;
        else
            sram_mode = 2;

        status = TRUE;
        for (i = 0; i < 2; i++) {
            /*
             * XXX: Add jtag code which rescans disabled boards.
             * For the time being disabled boards are not
             * checked for compatibility when cpu_speed is 0.
             */
            if (sysc_stat->bd.cpu[i].cpu_speed == 0)
                continue;

            if (sysc_stat->bd.cpu[i].cpu_speed < cpu_freq) {
                cmn_err(CE_WARN, "board %d, cpu module %c "
                    "rated at %d Mhz, system freq %d Mhz",
                    sysc_stat->board, (i == 0) ? 'A' : 'B',
                    sysc_stat->bd.cpu[i].cpu_speed,
                    cpu_freq);
                status = FALSE;
            }

            if (sram_mode != sysc_stat->bd.cpu[i].cpu_sram_mode) {
                cmn_err(CE_WARN, "board %d, cpu module %c "
                    "incompatible sram mode of %dx, "
                    "system is %dx", sysc_stat->board,
                    (i == 0) ? 'A' : 'B',
                    sysc_stat->bd.cpu[i].cpu_sram_mode,
                    sram_mode);
                status = FALSE;
            }
        }
        break;
#endif /* RFE_4174486 */
    }

    case MEM_BOARD:
    case IO_2SBUS_BOARD:
    case IO_SBUS_FFB_BOARD:
    case IO_PCI_BOARD:
    case IO_2SBUS_SOCPLUS_BOARD:
    case IO_SBUS_FFB_SOCPLUS_BOARD:
        status = TRUE;
        break;

    case CLOCK_BOARD:
    case DISK_BOARD:
    default:
        status = FALSE;     /* default is not supported */
        break;
    }

    if (status == FALSE)
        return (status);

    /* Check for Sunfire boards in a Sunfire+ system */
    if (status == TRUE && Fsys > 84 && !fhc_bd_is_plus(sysc_stat->board)) {
        (void) snprintf(pkt->errbuf, SYSC_OUTPUT_LEN,
            "not 100 MHz capable   ");
        cmn_err(CE_WARN, "board %d, is not capable of running at "
            "current system clock (%dMhz)", sysc_stat->board, Fsys);

        status = FALSE;
    }

    return (status);
}

/*
 * This function is called to check the policy for a request to transition
 * to the connected state from the disconnected state. The generic policy
 * is to do sanity checks again before going live.
 */
/*ARGSUSED*/
int
sysc_policy_connect(struct sysctrl_soft_state *softsp,
        sysc_cfga_pkt_t *pkt, sysc_cfga_stat_t *sysc_stat)
{
    int retval;

    ASSERT(fhc_bdlist_locked());

    DPRINTF(SYSC_DEBUG, ("Previous RState: %d\n", sysc_stat->rstate));
    DPRINTF(SYSC_DEBUG, ("Previous OState: %d\n", sysc_stat->ostate));

    switch (sysc_stat->rstate) {
    case SYSC_CFGA_RSTATE_DISCONNECTED:
        /*
         * Safety policy: only allow connect if board is UNKNOWN cond.
         * cold start board will be demoted to UNKNOWN cond when
         * disconnected
         */
        if (sysc_stat->condition != SYSC_CFGA_COND_UNKNOWN) {
            SYSC_ERR_SET(pkt, SYSC_ERR_COND);
            return (EINVAL);
        }

        if (!enable_dynamic_reconfiguration) {
            SYSC_ERR_SET(pkt, SYSC_ERR_NON_DR_PROM);
            return (ENOTSUP);
        }

        if (sysctrl_hotplug_disabled) {
            SYSC_ERR_SET(pkt, SYSC_ERR_HOTPLUG);
            return (ENOTSUP);
        }

        /* Check PROM support. */
        if (!sysc_board_connect_supported(sysc_stat->type)) {
            cmn_err(CE_WARN, "%s board %d connect"
                " is not supported by firmware.",
                fhc_bd_typestr(sysc_stat->type), sysc_stat->board);
            SYSC_ERR_SET(pkt, SYSC_ERR_HW_COMPAT);
            return (ENOTSUP);
        }

        if (!sysc_policy_enough_power(softsp, TRUE, FALSE)) {
            SYSC_ERR_SET(pkt, SYSC_ERR_POWER);
            return (EAGAIN);
        }

        if (!sysc_policy_enough_precharge(softsp, sysc_stat)) {
            SYSC_ERR_SET(pkt, SYSC_ERR_PRECHARGE);
            return (EAGAIN);
        }

        if (!sysc_policy_enough_cooling(softsp, sysc_stat, FALSE)) {
            SYSC_ERR_SET(pkt, SYSC_ERR_COOLING);
            return (EAGAIN);
        }

        if (!sysc_policy_hardware_compatible(softsp, sysc_stat, pkt)) {
            SYSC_ERR_SET(pkt, SYSC_ERR_HW_COMPAT);
            return (ENOTSUP);
        }
        sysc_policy_audit_messages(SYSC_AUDIT_RSTATE_CONNECT,
            sysc_stat);

        retval = sysc_bd_connect(sysc_stat->board, pkt);
        if (!retval) {
            sysc_stat->rstate = SYSC_CFGA_RSTATE_CONNECTED;
            sysc_policy_connected_condition(softsp,
                sysc_stat, FALSE);
            sysc_policy_audit_messages(SYSC_AUDIT_RSTATE_SUCCEEDED,
                sysc_stat);
        } else {
            uint_t prom_failure;

            prom_failure = (retval == EIO &&
                pkt->cmd_cfga.errtype == SYSC_ERR_PROM) ?
                TRUE : FALSE;
            sysc_policy_disconnected_condition(softsp,
                sysc_stat, prom_failure, FALSE);
            sysc_policy_audit_messages(
                SYSC_AUDIT_RSTATE_CONNECT_FAILED,
                sysc_stat);
        }
        break;
    case SYSC_CFGA_RSTATE_EMPTY:
    case SYSC_CFGA_RSTATE_CONNECTED:
    default:
        SYSC_ERR_SET(pkt, SYSC_ERR_RSTATE);
        retval = EINVAL;
        break;
    }

    DPRINTF(SYSC_DEBUG, ("Current RState: %d\n", sysc_stat->rstate));
    DPRINTF(SYSC_DEBUG, ("Current OState: %d\n", sysc_stat->ostate));
    DPRINTF(SYSC_DEBUG, ("Current Condition: %d\n", sysc_stat->condition));

    return (retval);
}

/*
 * This function is called to check the policy for a request to transition
 * to the disconnected state from the connected/unconfigured state only.
 * All other requests are invalid.
 */
/*ARGSUSED*/
int
sysc_policy_disconnect(struct sysctrl_soft_state *softsp,
            sysc_cfga_pkt_t *pkt, sysc_cfga_stat_t *sysc_stat)
{
    int retval;

    ASSERT(fhc_bdlist_locked());

    DPRINTF(SYSC_DEBUG, ("Previous RState: %d\n", sysc_stat->rstate));
    DPRINTF(SYSC_DEBUG, ("Previous OState: %d\n", sysc_stat->ostate));

    switch (sysc_stat->rstate) {
    case SYSC_CFGA_RSTATE_CONNECTED:
        switch (sysc_stat->ostate) {
        case SYSC_CFGA_OSTATE_UNCONFIGURED:
            if (!enable_dynamic_reconfiguration) {
                SYSC_ERR_SET(pkt, SYSC_ERR_NON_DR_PROM);
                return (ENOTSUP);
            }

            /* Check PROM support. */
            if (!sysc_board_connect_supported(sysc_stat->type)) {
                cmn_err(CE_WARN, "%s board %d disconnect"
                    " is not supported by firmware.",
                    fhc_bd_typestr(sysc_stat->type),
                    sysc_stat->board);
                SYSC_ERR_SET(pkt, SYSC_ERR_HW_COMPAT);
                return (ENOTSUP);
            }

            if (!sysc_policy_hardware_compatible(softsp,
                sysc_stat, pkt)) {
                cmn_err(CE_WARN, "%s board %d disconnect"
                " is not yet supported.",
                fhc_bd_typestr(sysc_stat->type),
                    sysc_stat->board);
                SYSC_ERR_SET(pkt, SYSC_ERR_HW_COMPAT);
                return (ENOTSUP);
            }

            if (fhc_bd_is_jtag_master(sysc_stat->board)) {
                sysc_policy_update(softsp, sysc_stat,
                    SYSC_EVT_BD_CORE_RESOURCE_DISCONNECT);
                SYSC_ERR_SET(pkt, SYSC_ERR_CORE_RESOURCE);
                return (EINVAL);
            }

            sysc_policy_audit_messages(SYSC_AUDIT_RSTATE_DISCONNECT,
                sysc_stat);

            retval = sysc_bd_disconnect(sysc_stat->board, pkt);
            if (!retval) {
                sysc_stat->rstate =
                    SYSC_CFGA_RSTATE_DISCONNECTED;
                DPRINTF(SYSCTRL_ATTACH_DEBUG,
                    ("disconnect starting bd_remove_poll()"));
                bd_remove_poll(softsp);
                sysc_policy_disconnected_condition(
                    softsp,
                    sysc_stat, FALSE, FALSE);
                sysc_policy_audit_messages(
                    SYSC_AUDIT_RSTATE_SUCCEEDED,
                    sysc_stat);
                cmn_err(CE_NOTE,
                    "board %d is ready to remove",
                    sysc_stat->board);
            } else {
                sysc_policy_connected_condition(
                    softsp, sysc_stat, FALSE);
                sysc_policy_audit_messages(
                    SYSC_AUDIT_RSTATE_DISCONNECT_FAILED,
                    sysc_stat);
            }
            break;
        case SYSC_CFGA_OSTATE_CONFIGURED:
        default:
            SYSC_ERR_SET(pkt, SYSC_ERR_OSTATE);
            retval = EINVAL;
            break;
        }
        break;
    case SYSC_CFGA_RSTATE_EMPTY:
    case SYSC_CFGA_RSTATE_DISCONNECTED:
    default:
        SYSC_ERR_SET(pkt, SYSC_ERR_RSTATE);
        retval = EINVAL;
        break;
    }

    DPRINTF(SYSC_DEBUG, ("Current RState: %d\n", sysc_stat->rstate));
    DPRINTF(SYSC_DEBUG, ("Current OState: %d\n", sysc_stat->ostate));
    DPRINTF(SYSC_DEBUG, ("Current Condition: %d\n", sysc_stat->condition));

    return (retval);
}

/*
 * This function is called to check the policy for a request to transition
 * from the connected/configured state to the connected/unconfigured state only.
 * All other requests are invalid.
 */
/*ARGSUSED*/
int
sysc_policy_unconfigure(struct sysctrl_soft_state *softsp,
            sysc_cfga_pkt_t *pkt, sysc_cfga_stat_t *sysc_stat)
{
    int retval;

    ASSERT(fhc_bdlist_locked());

    DPRINTF(SYSC_DEBUG, ("Previous RState: %d\n", sysc_stat->rstate));
    DPRINTF(SYSC_DEBUG, ("Previous OState: %d\n", sysc_stat->ostate));

    switch (sysc_stat->ostate) {
    case SYSC_CFGA_OSTATE_CONFIGURED:
        if (!enable_dynamic_reconfiguration) {
            SYSC_ERR_SET(pkt, SYSC_ERR_NON_DR_PROM);
            return (ENOTSUP);
        }

        if (!sysc_policy_hardware_compatible(softsp, sysc_stat, pkt)) {
            cmn_err(CE_WARN, "%s board %d unconfigure"
            " is not yet supported.",
            fhc_bd_typestr(sysc_stat->type), sysc_stat->board);
            SYSC_ERR_SET(pkt, SYSC_ERR_HW_COMPAT);
            return (ENOTSUP);
        }

        sysc_policy_audit_messages(SYSC_AUDIT_OSTATE_UNCONFIGURE,
            sysc_stat);

        retval = sysc_bd_unconfigure(sysc_stat->board, pkt);
        if (!retval) {
            sysc_stat->ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
            sysc_policy_audit_messages(
            SYSC_AUDIT_OSTATE_SUCCEEDED,
            sysc_stat);
        } else {
            sysc_policy_audit_messages(
            SYSC_AUDIT_OSTATE_UNCONFIGURE_FAILED,
            sysc_stat);
        }
        sysc_policy_connected_condition(softsp, sysc_stat, FALSE);
        break;
    case SYSC_CFGA_OSTATE_UNCONFIGURED:
    default:
        SYSC_ERR_SET(pkt, SYSC_ERR_OSTATE);
        retval = EINVAL;
        break;
    }

    DPRINTF(SYSC_DEBUG, ("Current RState: %d\n", sysc_stat->rstate));
    DPRINTF(SYSC_DEBUG, ("Current OState: %d\n", sysc_stat->ostate));
    DPRINTF(SYSC_DEBUG, ("Current Condition: %d\n", sysc_stat->condition));

    return (retval);
}

/*
 * This function is called to check the policy for a requested transition
 * from either the connected/unconfigured state or the connected/configured
 * state to the connected/configured state.  The redundant state transition
 * is permitted for partially configured set of devices.  Basically, we
 * retry the configure.
 */
/*ARGSUSED*/
int
sysc_policy_configure(struct sysctrl_soft_state *softsp,
            sysc_cfga_pkt_t *pkt, sysc_cfga_stat_t *sysc_stat)
{
    int retval;

    ASSERT(fhc_bdlist_locked());

    DPRINTF(SYSC_DEBUG, ("Previous RState: %d\n", sysc_stat->rstate));
    DPRINTF(SYSC_DEBUG, ("Previous OState: %d\n", sysc_stat->ostate));

    switch (sysc_stat->rstate) {
    case SYSC_CFGA_RSTATE_CONNECTED:
        switch (sysc_stat->ostate) {
        case SYSC_CFGA_OSTATE_UNCONFIGURED:
            if (sysc_stat->condition != SYSC_CFGA_COND_OK) {
                SYSC_ERR_SET(pkt, SYSC_ERR_COND);
                return (EINVAL);
            }

            sysc_policy_audit_messages(SYSC_AUDIT_OSTATE_CONFIGURE,
                sysc_stat);
            retval = sysc_bd_configure(sysc_stat->board, pkt);
            sysc_stat->ostate = SYSC_CFGA_OSTATE_CONFIGURED;
            sysc_policy_connected_condition(softsp,
                sysc_stat, FALSE);
            if (!retval) {
                sysc_policy_audit_messages(
                    SYSC_AUDIT_OSTATE_SUCCEEDED,
                    sysc_stat);
            } else {
                sysc_policy_audit_messages(
                    SYSC_AUDIT_OSTATE_CONFIGURE_FAILED,
                    sysc_stat);
            }
            break;
        case SYSC_CFGA_OSTATE_CONFIGURED:
            SYSC_ERR_SET(pkt, SYSC_ERR_OSTATE);
            retval = ENOTSUP;
            break;
        default:
            SYSC_ERR_SET(pkt, SYSC_ERR_OSTATE);
            retval = EINVAL;
            break;
        }
        break;
    case SYSC_CFGA_RSTATE_EMPTY:
    case SYSC_CFGA_RSTATE_DISCONNECTED:
    default:
        SYSC_ERR_SET(pkt, SYSC_ERR_RSTATE);
        retval = EINVAL;
        break;
    }


    DPRINTF(SYSC_DEBUG, ("Current RState: %d\n", sysc_stat->rstate));
    DPRINTF(SYSC_DEBUG, ("Current OState: %d\n", sysc_stat->ostate));
    DPRINTF(SYSC_DEBUG, ("Current Condition: %d\n", sysc_stat->condition));

    return (retval);
}

/*ARGSUSED*/
static void
sysc_policy_empty_condition(struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat, uint_t failure,
    uint_t ps_mutex_is_held)
{
    ASSERT(fhc_bdlist_locked());

    switch (sysc_stat->condition) {
    case SYSC_CFGA_COND_UNKNOWN:
    case SYSC_CFGA_COND_OK:
    case SYSC_CFGA_COND_FAILING:
    case SYSC_CFGA_COND_FAILED:
    /* nothing in the slot so just check power supplies */
    case SYSC_CFGA_COND_UNUSABLE:
        if (sysc_policy_enough_cooling(softsp, sysc_stat,
        ps_mutex_is_held) &&
        sysc_policy_enough_power(softsp, FALSE,
        ps_mutex_is_held)) {
        sysc_stat->condition = SYSC_CFGA_COND_UNKNOWN;
        } else {
        sysc_stat->condition = SYSC_CFGA_COND_UNUSABLE;
        }
        sysc_stat->last_change = gethrestime_sec();
        break;
    default:
        ASSERT(FALSE);
        break;
    }
}
/*ARGSUSED*/
static void
sysc_policy_disconnected_condition(struct sysctrl_soft_state *softsp,
    sysc_cfga_stat_t *sysc_stat, uint_t failure,
    uint_t ps_mutex_is_held)
{
    ASSERT(fhc_bdlist_locked());

    if (failure) {
        sysc_stat->condition = SYSC_CFGA_COND_FAILED;
        sysc_stat->last_change = gethrestime_sec();
        return;
    }
    switch (sysc_stat->condition) {
    /*
     * if unknown, we have come from hotplug case so do a quick
     * reevaluation.
     */
    case SYSC_CFGA_COND_UNKNOWN:
    /*
     * if ok, we have come from connected to disconnected and we stay
     * ok until removed or reevaluate when reconnect.  We might have
     * experienced a ps fail so reevaluate the condition.
     */
    case SYSC_CFGA_COND_OK:
    /*
     * if unsuable, either power supply was missing or
     * hardware was not compatible.  Check to see if
     * this is still true.
     */
    case SYSC_CFGA_COND_UNUSABLE:
    /*
     * failing must transition in the disconnected state
     * to either unusable or unknown.  We may have come here
     * from cfgadm -f -c disconnect after a power supply failure
     * in an attempt to protect the board.
     */
    case SYSC_CFGA_COND_FAILING:
        if (sysc_policy_enough_cooling(softsp, sysc_stat,
        ps_mutex_is_held) &&
        sysc_policy_enough_power(softsp, FALSE,
        ps_mutex_is_held)) {
        sysc_stat->condition = SYSC_CFGA_COND_UNKNOWN;
        } else {
        sysc_stat->condition = SYSC_CFGA_COND_UNUSABLE;
        }
        sysc_stat->last_change = gethrestime_sec();
        break;
    /*
     * if failed, we have failed POST and must stay in this
     * condition until the board has been removed
     * before ever coming back into another condition
     */
    case SYSC_CFGA_COND_FAILED:
        break;
    default:
        ASSERT(FALSE);
        break;
    }
}

/*ARGSUSED*/
static void
sysc_policy_connected_condition(struct sysctrl_soft_state *softsp,
        sysc_cfga_stat_t *sysc_stat,
        uint_t ps_mutex_is_held)
{
    ASSERT(fhc_bdlist_locked());

    switch (sysc_stat->condition) {
    case SYSC_CFGA_COND_UNKNOWN:
    case SYSC_CFGA_COND_OK:
    case SYSC_CFGA_COND_FAILING:
    case SYSC_CFGA_COND_UNUSABLE:
        if (sysc_policy_enough_cooling(softsp, sysc_stat,
        ps_mutex_is_held) &&
        sysc_policy_enough_power(softsp, FALSE,
        ps_mutex_is_held) &&
        (fhc_env_temp_state(sysc_stat->board) == TEMP_OK)) {
            sysc_stat->condition = SYSC_CFGA_COND_OK;
        } else {
            sysc_stat->condition = SYSC_CFGA_COND_FAILING;
        }
        sysc_stat->last_change = gethrestime_sec();
        break;
    case SYSC_CFGA_COND_FAILED:
        break;
    default:
        ASSERT(FALSE);
        break;
    }
}

static void
sysc_policy_set_condition(void *sp, sysc_cfga_stat_t *sysc_stat,
        uint_t ps_mutex_is_held)
{
    struct sysctrl_soft_state *softsp = (struct sysctrl_soft_state *)sp;

    ASSERT(fhc_bdlist_locked());

    switch (sysc_stat->rstate) {
    case SYSC_CFGA_RSTATE_EMPTY:
        sysc_policy_empty_condition(softsp, sysc_stat,
            FALSE, ps_mutex_is_held);
        break;
    case SYSC_CFGA_RSTATE_DISCONNECTED:
        sysc_policy_disconnected_condition(softsp, sysc_stat,
            FALSE, ps_mutex_is_held);
        break;
    case SYSC_CFGA_RSTATE_CONNECTED:
        sysc_policy_connected_condition(softsp, sysc_stat,
            ps_mutex_is_held);
        break;
    default:
        ASSERT(FALSE);
        break;
    }
}

void
sysc_policy_update(void *softsp, sysc_cfga_stat_t *sysc_stat,
    sysc_evt_t event)
{
    fhc_bd_t *list;

    ASSERT(event == SYSC_EVT_BD_HP_DISABLED || fhc_bdlist_locked());

    switch (event) {
    case SYSC_EVT_BD_EMPTY:
        sysc_stat->rstate = SYSC_CFGA_RSTATE_EMPTY;
        sysc_stat->ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
        sysc_stat->condition = SYSC_CFGA_COND_UNKNOWN;
        sysc_policy_empty_condition(softsp, sysc_stat, FALSE, FALSE);
        break;
    case SYSC_EVT_BD_PRESENT:
        if (sysc_stat->type == DISK_BOARD) {
            sysc_stat->rstate = SYSC_CFGA_RSTATE_DISCONNECTED;
            sysc_stat->ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
            sysc_stat->condition = SYSC_CFGA_COND_UNKNOWN;
        } else {
            sysc_stat->rstate = SYSC_CFGA_RSTATE_CONNECTED;
            sysc_stat->ostate = SYSC_CFGA_OSTATE_CONFIGURED;
            sysc_stat->condition = SYSC_CFGA_COND_OK;
        }
        sysc_stat->last_change = gethrestime_sec();
        break;
    case SYSC_EVT_BD_DISABLED:
        sysc_stat->rstate = SYSC_CFGA_RSTATE_DISCONNECTED;
        sysc_stat->ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
        sysc_stat->condition = SYSC_CFGA_COND_UNKNOWN;
        sysc_policy_disconnected_condition(softsp,
            sysc_stat, FALSE, FALSE);
        cmn_err(CE_NOTE,
            "disabled %s board in slot %d",
            fhc_bd_typestr(sysc_stat->type),
            sysc_stat->board);
        break;
    case SYSC_EVT_BD_FAILED:
        sysc_stat->rstate = SYSC_CFGA_RSTATE_DISCONNECTED;
        sysc_stat->ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
        sysc_stat->condition = SYSC_CFGA_COND_UNUSABLE;
        sysc_policy_disconnected_condition(softsp, sysc_stat,
            TRUE, FALSE);
        cmn_err(CE_WARN,
            "failed %s board in slot %d",
            fhc_bd_typestr(sysc_stat->type),
            sysc_stat->board);
        break;
    case SYSC_EVT_BD_OVERTEMP:
    case SYSC_EVT_BD_TEMP_OK:
        sysc_policy_set_condition((void *)softsp, sysc_stat, FALSE);
        break;
    case SYSC_EVT_BD_PS_CHANGE:
        for (list = fhc_bd_first(); list; list = fhc_bd_next(list)) {
            sysc_stat = &(list->sc);
            sysc_policy_set_condition((void *)softsp,
                sysc_stat, TRUE);
        }
        break;
    case SYSC_EVT_BD_INS_FAILED:
        cmn_err(CE_WARN, "powerdown of board %d failed",
            sysc_stat->board);
        break;
    case SYSC_EVT_BD_INSERTED:
        sysc_stat->rstate = SYSC_CFGA_RSTATE_DISCONNECTED;
        sysc_stat->ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
        sysctrl_post_config_change(softsp);
        sysc_policy_disconnected_condition(softsp,
            sysc_stat, FALSE, FALSE);
        cmn_err(CE_NOTE, "%s board has been inserted into slot %d",
            fhc_bd_typestr(sysc_stat->type), sysc_stat->board);
        cmn_err(CE_NOTE,
            "board %d can be removed", sysc_stat->board);
        break;
    case SYSC_EVT_BD_REMOVED:
        sysc_stat->rstate = SYSC_CFGA_RSTATE_EMPTY;
        sysc_stat->ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
        sysc_stat->condition = SYSC_CFGA_COND_UNKNOWN;

        /* now it is ok to free the ac pa memory database */
        fhc_del_memloc(sysc_stat->board);

        /* reinitialize sysc_cfga_stat structure */
        sysc_stat->type = UNKNOWN_BOARD;
        sysc_stat->fhc_compid = 0;
        sysc_stat->ac_compid = 0;
        (void) bzero(&(sysc_stat->prom_rev),
            sizeof (sysc_stat->prom_rev));
        (void) bzero(&(sysc_stat->bd),
            sizeof (union bd_un));
        sysc_stat->no_detach = sysc_stat->plus_board = 0;
        sysc_policy_disconnected_condition(softsp,
            sysc_stat, FALSE, FALSE);
        cmn_err(CE_NOTE, "board %d has been removed",
            sysc_stat->board);
        break;
    case SYSC_EVT_BD_HP_DISABLED:
        cmn_err(CE_NOTE, "Hot Plug not supported in this system");
        break;
    case SYSC_EVT_BD_CORE_RESOURCE_DISCONNECT:
        cmn_err(CE_WARN, "board %d cannot be disconnected because it"
            " is a core system resource", sysc_stat->board);
        break;
    default:
        ASSERT(FALSE);
        break;
    }

}

/*
 * signal to POST that the system has been reconfigured and that
 * the system configuration status information should be invalidated
 * the next time through POST
 */
static void
sysctrl_post_config_change(struct sysctrl_soft_state *softsp)
{
    /*
     * We are heading into a configuration change!
     * Tell post to invalidate its notion of the system configuration.
     * This is done by clearing the clock registers...
     */
    *softsp->clk_freq1 = 0;
    *softsp->clk_freq2 &=
        ~(CLOCK_FREQ_8 | CLOCK_DIV_1 | CLOCK_RANGE | CLOCK_DIV_0);
}

static int
sysc_attach_board(void *arg)
{
    int board = *(int *)arg;

    return (prom_sunfire_attach_board((uint_t)board));
}

static int
sysc_bd_connect(int board, sysc_cfga_pkt_t *pkt)
{
    int error = 0;
    fhc_bd_t *bdp;
    sysc_dr_handle_t *sh;
    uint64_t mempa;
    int del_kstat = 0;

    ASSERT(fhc_bd_busy(board));

    bdp = fhc_bd(board);

    /* find gap for largest supported simm in advance */
#define MAX_BANK_SIZE_MB    (2 * 1024)
#define BANKS_PER_BOARD     2
    mempa = fhc_find_memloc_gap(BANKS_PER_BOARD * MAX_BANK_SIZE_MB);

    fhc_bdlist_unlock();

    /* TODO: Is mempa vulnerable to re-use here? */

    sysctrl_suspend_prepare();

    if ((error = sysctrl_suspend(pkt)) == DDI_SUCCESS) {
        /* ASSERT(jtag not held) */
        error = prom_tree_update(sysc_attach_board, &board);
        if (error) {
            error = EIO;
            SYSC_ERR_SET(pkt, SYSC_ERR_PROM);
        } else {
            /* attempt to program the memory while frozen */
            fhc_program_memory(board, mempa);
        }
        sysctrl_resume(pkt);
    }

    if (error) {
        goto done;
    }

    /*
     * Must not delete kstat used by prtdiag until the PROM
     * has successfully connected to board.
     */
    del_kstat = 1;

    sh = &bdp->sh[SYSC_DR_HANDLE_FHC];
    sh->flags |= SYSC_DR_FHC;
    sh->errstr = pkt->errbuf;

    sysc_dr_init(sh);

    error = sysc_dr_attach(sh, board);
    if (error)
        SYSC_ERR_SET(pkt, SYSC_ERR_NDI_ATTACH);

    sysc_dr_uninit(sh);

    if (enable_redist) {
        mutex_enter(&cpu_lock);
        intr_redist_all_cpus();
        mutex_exit(&cpu_lock);
    }
done:
    if (del_kstat && bdp->ksp) {
        kstat_delete(bdp->ksp);
        bdp->ksp = NULL;
    }

    (void) fhc_bdlist_lock(-1);

    return (error);
}

static int
sysc_detach_board(void * arg)
{
    int rt;
    cpuset_t xcset;
    struct jt_mstr *jtm;
    int board = *(int *)arg;

    (void) fhc_bdlist_lock(-1);

#ifdef DEBUG
    /* it is important to have fhc_bdlist_lock() earlier */
    if (sysctrl_enable_regdump)
        precache_regdump(board);
#endif /* DEBUG */

    jtm = jtag_master_lock();
    CPUSET_ALL(xcset);
    promsafe_xc_attention(xcset);

#ifdef DEBUG
    if (sysctrl_enable_regdump)
        boardstat_regdump();
#endif /* DEBUG */

    rt =  prom_sunfire_detach_board((uint_t)board);

#ifdef DEBUG
    if (sysctrl_enable_regdump)
        display_regdump();
#endif /* DEBUG */

    xc_dismissed(xcset);
    jtag_master_unlock(jtm);
    fhc_bdlist_unlock();
    return (rt);
}

static int
sysc_bd_disconnect(int board, sysc_cfga_pkt_t *pkt)
{
    int error;
    fhc_bd_t *bdp;
    sysc_dr_handle_t *sh;
    void fhc_bd_ks_alloc(fhc_bd_t *);

    ASSERT(fhc_bd_busy(board));
    ASSERT(!fhc_bd_is_jtag_master(board));


    bdp = fhc_bd(board);

    bdp->flags |= BDF_DETACH;

    fhc_bdlist_unlock();

    sh = &bdp->sh[SYSC_DR_HANDLE_FHC];
    sh->errstr = pkt->errbuf;

    ASSERT(sh->dip_list == NULL);

    sh->flags |= SYSC_DR_FHC;
    sysc_dr_init(sh);

    error = sysc_dr_detach(sh, board);
    sh->flags &= ~SYSC_DR_REMOVE;

    sysc_dr_uninit(sh);
    if (error) {
        SYSC_ERR_SET(pkt, SYSC_ERR_NDI_DETACH);
        goto done;
    }
    error = prom_tree_update(sysc_detach_board, &board);

    if (error) {
        error = EIO;
        SYSC_ERR_SET(pkt, SYSC_ERR_PROM);
        goto done;
    }

    if (enable_redist) {
        mutex_enter(&cpu_lock);
        intr_redist_all_cpus();
        mutex_exit(&cpu_lock);
    }

    fhc_bd_ks_alloc(bdp);
done:
    (void) fhc_bdlist_lock(-1);

    return (error);
}

static int
sysc_bd_configure(int board, sysc_cfga_pkt_t *pkt)
{
    int error = 0;
    fhc_bd_t *bdp;
    sysc_dr_handle_t *sh;

    ASSERT(fhc_bd_busy(board));

    bdp = fhc_bd(board);

    fhc_bdlist_unlock();


    sh = &bdp->sh[SYSC_DR_HANDLE_DEVS];
    sh->errstr = pkt->errbuf;

    ASSERT(sh->dip_list == NULL);

    sysc_dr_init(sh);

    sh->flags |= SYSC_DR_DEVS;
    error = sysc_dr_attach(sh, board);
    if (error) {
        SYSC_ERR_SET(pkt, SYSC_ERR_NDI_ATTACH);
        sysc_dr_uninit(sh);
        goto done;
    }

    sysc_dr_uninit(sh);

    if (enable_redist) {
        mutex_enter(&cpu_lock);
        intr_redist_all_cpus();
        mutex_exit(&cpu_lock);
    }
done:
    if (bdp->sc.type == CPU_BOARD) {
        /*
         * Value of error gets lost for CPU boards.
         */
        mutex_enter(&cpu_lock);

        error = find_and_setup_cpu(FHC_BOARD2CPU_A(board));
        if ((error == 0) || (error == ENODEV)) {
            int retval_b;

            retval_b = find_and_setup_cpu(FHC_BOARD2CPU_B(board));
            if (retval_b != ENODEV)
                error = retval_b;
        }

        mutex_exit(&cpu_lock);
    }

    (void) fhc_bdlist_lock(-1);

    return (error);
}

static int
sysc_bd_unconfigure(int board, sysc_cfga_pkt_t *pkt)
{
    int error;
    fhc_bd_t *bdp;
    sysc_dr_handle_t *sh;

    ASSERT(fhc_bdlist_locked());
    ASSERT(fhc_bd_busy(board));

    bdp = fhc_bd(board);

    if (bdp->sc.type == CPU_BOARD || bdp->sc.type == MEM_BOARD) {
        struct ac_soft_state *acsp;

        /*
         * Check that any memory on board is not in use.
         * This must be done while the board list lock is held
         * as memory state can change while fhc_bd_busy() is true
         * even though a memory operation cannot be started
         * if fhc_bd_busy() is true.
         */
        if ((acsp = (struct ac_soft_state *)bdp->ac_softsp) != NULL) {
            if (acsp->bank[Bank0].busy != 0 ||
                acsp->bank[Bank0].ostate ==
                SYSC_CFGA_OSTATE_CONFIGURED) {
                cmn_err(CE_WARN, "memory bank %d in "
                    "slot %d is in use.", Bank0, board);
                (void) snprintf(pkt->errbuf,
                    SYSC_OUTPUT_LEN,
                    "memory bank %d in use",
                    Bank0);
                return (EBUSY);
            }

            if (acsp->bank[Bank1].busy != 0 ||
                acsp->bank[Bank1].ostate ==
                SYSC_CFGA_OSTATE_CONFIGURED) {
                cmn_err(CE_WARN, "memory bank %d in "
                    "slot %d is in use.", Bank1, board);
                (void) snprintf(pkt->errbuf,
                    SYSC_OUTPUT_LEN,
                    "memory bank %d in use",
                    Bank1);
                return (EBUSY);
            }
            /*
             * Nothing more to do here. The memory interface
             * will not make any transitions while
             * fhc_bd_busy() is true. Once the ostate
             * becomes unconfigured, the memory becomes
             * invisible.
             */
        }
        error = 0;
        if (bdp->sc.type == CPU_BOARD) {
            struct cpu *cpua, *cpub;
            int cpu_flags = 0;

            if (pkt->cmd_cfga.force)
                cpu_flags = CPU_FORCED;

            fhc_bdlist_unlock();

            mutex_enter(&cpu_lock); /* protects CPU states */

            error = fhc_board_poweroffcpus(board, pkt->errbuf,
                cpu_flags);

            cpua = cpu_get(FHC_BOARD2CPU_A(board));
            cpub = cpu_get(FHC_BOARD2CPU_B(board));

            if ((error == 0) && (cpua != NULL)) {
                error = cpu_unconfigure(cpua->cpu_id);
                if (error != 0) {
                    (void) snprintf(pkt->errbuf,
                        SYSC_OUTPUT_LEN,
                        "processor %d unconfigure failed",
                        cpua->cpu_id);
                }
            }
            if ((error == 0) && (cpub != NULL)) {
                error = cpu_unconfigure(cpub->cpu_id);
                if (error != 0) {
                    (void) snprintf(pkt->errbuf,
                        SYSC_OUTPUT_LEN,
                        "processor %d unconfigure failed",
                        cpub->cpu_id);
                }
            }

            mutex_exit(&cpu_lock);

            (void) fhc_bdlist_lock(-1);
        }

        if (error != 0)
            return (error);
    }

    fhc_bdlist_unlock();

    sh = &bdp->sh[SYSC_DR_HANDLE_DEVS];
    sh->errstr = pkt->errbuf;

    ASSERT(sh->dip_list == NULL);

    sysc_dr_init(sh);

    sh->flags |= SYSC_DR_DEVS;
    error = sysc_dr_detach(sh, board);
    sh->flags &= ~SYSC_DR_REMOVE;
    if (error) {
        SYSC_ERR_SET(pkt, SYSC_ERR_NDI_DETACH);
        sysc_dr_uninit(sh);
        goto done;
    }

    sysc_dr_uninit(sh);

    if (enable_redist) {
        mutex_enter(&cpu_lock);
        intr_redist_all_cpus();
        mutex_exit(&cpu_lock);
    }

done:
    (void) fhc_bdlist_lock(-1);

    return (error);
}


typedef struct sysc_prom {
    sysc_dr_handle_t *handle;   /* DR handle            */
    int board;          /* board id         */
    dev_info_t **dipp;      /* next slot for storing dip    */
} sysc_prom_t;

/*
 * Attaching devices on a board.
 */
static int
sysc_dr_attach(sysc_dr_handle_t  *handle, int board)
{
    int         i;
    int         err;
    sysc_prom_t     arg;
    devi_branch_t       b = {0};

    arg.handle = handle;
    arg.board = board;
    arg.dipp = handle->dip_list;

    b.arg = &arg;
    b.type = DEVI_BRANCH_PROM;
    b.create.prom_branch_select = sysc_prom_select;
    b.devi_branch_callback = sysc_branch_callback;

    handle->error = e_ddi_branch_create(ddi_root_node(), &b,
        NULL, DEVI_BRANCH_CHILD);

    if (handle->error)
        return (handle->error);

    for (i = 0, arg.dipp = handle->dip_list;
        i < handle->dip_list_len; i++, arg.dipp++) {

        err = e_ddi_branch_configure(*arg.dipp, NULL, 0);
        /*
         * Error only if we fail for fhc dips
         */
        if (err && (handle->flags & SYSC_DR_FHC)) {
            handle->error = err;
            sysc_dr_err_decode(handle, *arg.dipp, TRUE);
            return (handle->error);
        }
    }

    return (0);
}

/*ARGSUSED*/
static int
sysc_make_list(void *arg, int has_changed)
{
    dev_info_t *rdip;
    sysc_prom_t *wp = (sysc_prom_t *)arg;
    pnode_t nid = prom_childnode(prom_rootnode());

    if (wp == NULL)
        return (EINVAL);

    for (; nid != OBP_NONODE && nid != OBP_BADNODE;
        nid = prom_nextnode(nid)) {
        if (sysc_prom_select(nid, arg, 0) != DDI_SUCCESS)
            continue;
        if (wp->handle->dip_list_len < SYSC_DR_MAX_NODE) {
            rdip = wp->handle->dip_list[wp->handle->dip_list_len] =
                e_ddi_nodeid_to_dip(nid);
            if (rdip != NULL) {
                wp->handle->dip_list_len++;
                /*
                 * Branch rooted at dip already held, so
                 * release hold acquired in e_ddi_nodeid_to_dip
                 */
                ddi_release_devi(rdip);
                ASSERT(e_ddi_branch_held(rdip));
#ifdef  DEBUG
            } else {
                DPRINTF(SYSC_DEBUG, ("sysc_make_list:"
                    " e_ddi_nodeid_to_dip() failed for"
                    " nodeid: %d\n", nid));
#endif
            }
        } else {
#ifdef  DEBUG
            cmn_err(CE_WARN, "sysc_make_list: list overflow\n");
#endif
            return (EFAULT);
        }
    }

    return (0);
}

/*
 * Detaching devices on a board.
 */
static int
sysc_dr_detach(sysc_dr_handle_t *handle, int board)
{
    int     i;
    uint_t      flags;
    sysc_prom_t arg;

    ASSERT(handle->dip_list);
    ASSERT(handle->dip_list_len == 0);
    ASSERT(*handle->dip_list == NULL);

    arg.handle = handle;
    arg.board = board;
    arg.dipp = NULL;

    handle->error = prom_tree_access(sysc_make_list, &arg, NULL);
    if (handle->error)
        return (handle->error);

    flags = DEVI_BRANCH_DESTROY | DEVI_BRANCH_EVENT;

    for (i = handle->dip_list_len; i > 0; i--) {
        ASSERT(e_ddi_branch_held(handle->dip_list[i - 1]));
        handle->error = e_ddi_branch_unconfigure(
            handle->dip_list[i - 1], NULL, flags);
        if (handle->error)
            return (handle->error);
    }

    return (0);
}

static void
sysc_dr_init(sysc_dr_handle_t *handle)
{
    handle->dip_list = kmem_zalloc(sizeof (dev_info_t *) * SYSC_DR_MAX_NODE,
        KM_SLEEP);
    handle->dip_list_len = 0;
}

/*ARGSUSED2*/
static int
sysc_prom_select(pnode_t pnode, void *arg, uint_t flag)
{
    int     bd_id;
    char        name[OBP_MAXDRVNAME];
    int     len;
    int     *regp;
    sysc_prom_t *wp = (sysc_prom_t *)arg;

    bd_id = -1;
    len = prom_getproplen(pnode, OBP_REG);
    if (len > 0) {
        regp = kmem_alloc(len, KM_SLEEP);
        (void) prom_getprop(pnode, OBP_REG, (caddr_t)regp);
        /*
         * Get board id for EXXXX platforms where
         * 0x1c0 is EXXXX platform specific data to
         * acquire board id.
         */
        bd_id = (*regp - 0x1c0) >> 2;
        kmem_free(regp, len);
    }

    (void) prom_getprop(pnode, OBP_NAME, (caddr_t)name);
    if ((bd_id == wp->board) &&
        ((wp->handle->flags & SYSC_DR_FHC) ?
        (strcmp(name, "fhc") == 0):
        (strcmp(name, "fhc") != 0)) &&
        (strcmp(name, "central") != 0)) {
        return (DDI_SUCCESS);
    }

    return (DDI_FAILURE);
}

/*ARGSUSED*/
static void
sysc_branch_callback(dev_info_t *rdip, void *arg, uint_t flags)
{
    sysc_prom_t *wp = (sysc_prom_t *)arg;

    ASSERT(wp->dipp != NULL);
    ASSERT(*wp->dipp == NULL);
    ASSERT((wp->handle->flags & SYSC_DR_REMOVE) == 0);

    if (wp->handle->dip_list_len < SYSC_DR_MAX_NODE) {
        *wp->dipp = rdip;
        wp->dipp++;
        wp->handle->dip_list_len++;
    } else {
        cmn_err(CE_PANIC, "sysc_branch_callback: list overflow");
    }
}

/*
 * Uninitialize devices for the state of a board.
 */
static void
sysc_dr_uninit(sysc_dr_handle_t *handle)
{
    kmem_free(handle->dip_list,
        sizeof (dev_info_t *) * SYSC_DR_MAX_NODE);
    handle->dip_list = NULL;
    handle->dip_list_len = 0;
}

static void
sysc_dr_err_decode(sysc_dr_handle_t *handle, dev_info_t *dip, int attach)
{
    char    *p;

    ASSERT(handle->error != 0);

    switch (handle->error) {
    case ENOMEM:
        break;
    case EBUSY:
        (void) ddi_pathname(dip, handle->errstr);
        break;
    default:
        handle->error = EFAULT;
        if (attach)
            (void) ddi_pathname(ddi_get_parent(dip),
                handle->errstr);
        else
            (void) ddi_pathname(dip, handle->errstr);
        if (attach) {
            p = "/";
            (void) strcat(handle->errstr, p);
            (void) strcat(handle->errstr, ddi_node_name(dip));
        }
        break;
    }
}

static char *
sysc_rstate_typestr(sysc_cfga_rstate_t rstate, sysc_audit_evt_t event)
{
    char *type_str;

    switch (rstate) {
    case SYSC_CFGA_RSTATE_EMPTY:
        switch (event) {
        case SYSC_AUDIT_RSTATE_EMPTY:
            type_str = "emptying";
            break;
        case SYSC_AUDIT_RSTATE_SUCCEEDED:
            type_str = "emptied";
            break;
        case SYSC_AUDIT_RSTATE_EMPTY_FAILED:
            type_str = "empty";
            break;
        default:
            type_str = "empty?";
            break;
        }
        break;
    case SYSC_CFGA_RSTATE_DISCONNECTED:
        switch (event) {
        case SYSC_AUDIT_RSTATE_DISCONNECT:
            type_str = "disconnecting";
            break;
        case SYSC_AUDIT_RSTATE_SUCCEEDED:
            type_str = "disconnected";
            break;
        case SYSC_AUDIT_RSTATE_DISCONNECT_FAILED:
            type_str = "disconnect";
            break;
        default:
            type_str = "disconnect?";
            break;
        }
        break;
    case SYSC_CFGA_RSTATE_CONNECTED:
        switch (event) {
        case SYSC_AUDIT_RSTATE_CONNECT:
            type_str = "connecting";
            break;
        case SYSC_AUDIT_RSTATE_SUCCEEDED:
            type_str = "connected";
            break;
        case SYSC_AUDIT_RSTATE_CONNECT_FAILED:
            type_str = "connect";
            break;
        default:
            type_str = "connect?";
            break;
        }
        break;
    default:
        type_str = "undefined receptacle state";
        break;
    }
    return (type_str);
}

static char *
sysc_ostate_typestr(sysc_cfga_ostate_t ostate, sysc_audit_evt_t event)
{
    char *type_str;

    switch (ostate) {
    case SYSC_CFGA_OSTATE_UNCONFIGURED:
        switch (event) {
        case SYSC_AUDIT_OSTATE_UNCONFIGURE:
            type_str = "unconfiguring";
            break;
        case SYSC_AUDIT_OSTATE_SUCCEEDED:
        case SYSC_AUDIT_OSTATE_UNCONFIGURE_FAILED:
            type_str = "unconfigured";
            break;
        default:
            type_str = "unconfigure?";
            break;
        }
        break;
    case SYSC_CFGA_OSTATE_CONFIGURED:
        switch (event) {
        case SYSC_AUDIT_OSTATE_CONFIGURE:
            type_str = "configuring";
            break;
        case SYSC_AUDIT_OSTATE_SUCCEEDED:
        case SYSC_AUDIT_OSTATE_CONFIGURE_FAILED:
            type_str = "configured";
            break;
        default:
            type_str = "configure?";
            break;
        }
        break;

    default:
        type_str = "undefined occupant state";
        break;
    }
    return (type_str);
}

static void
sysc_policy_audit_messages(sysc_audit_evt_t event, sysc_cfga_stat_t *sysc_stat)
{
    switch (event) {
        case SYSC_AUDIT_RSTATE_CONNECT:
            cmn_err(CE_NOTE,
                "%s %s board in slot %d",
                sysc_rstate_typestr(SYSC_CFGA_RSTATE_CONNECTED,
                event),
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board);
            break;
        case SYSC_AUDIT_RSTATE_DISCONNECT:
            cmn_err(CE_NOTE,
                "%s %s board in slot %d",
                sysc_rstate_typestr(
                    SYSC_CFGA_RSTATE_DISCONNECTED,
                    event),
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board);
            break;
        case SYSC_AUDIT_RSTATE_SUCCEEDED:
            cmn_err(CE_NOTE,
                "%s board in slot %d is %s",
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board,
                sysc_rstate_typestr(sysc_stat->rstate,
                    event));
            break;
        case SYSC_AUDIT_RSTATE_CONNECT_FAILED:
            cmn_err(CE_NOTE,
                "%s board in slot %d failed to %s",
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board,
                sysc_rstate_typestr(SYSC_CFGA_RSTATE_CONNECTED,
                    event));
            break;
        case SYSC_AUDIT_RSTATE_DISCONNECT_FAILED:
            cmn_err(CE_NOTE,
                "%s board in slot %d failed to %s",
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board,
                sysc_rstate_typestr(
                    SYSC_CFGA_RSTATE_DISCONNECTED,
                    event));
            break;
        case SYSC_AUDIT_OSTATE_CONFIGURE:
            cmn_err(CE_NOTE,
                "%s %s board in slot %d",
                sysc_ostate_typestr(SYSC_CFGA_OSTATE_CONFIGURED,
                event),
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board);
            break;
        case SYSC_AUDIT_OSTATE_UNCONFIGURE:
            cmn_err(CE_NOTE,
                "%s %s board in slot %d",
                sysc_ostate_typestr(
                    SYSC_CFGA_OSTATE_UNCONFIGURED,
                    event),
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board);
            break;
        case SYSC_AUDIT_OSTATE_SUCCEEDED:
            cmn_err(CE_NOTE,
                "%s board in slot %d is %s",
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board,
                sysc_ostate_typestr(sysc_stat->ostate,
                    event));
            break;
        case SYSC_AUDIT_OSTATE_CONFIGURE_FAILED:
            cmn_err(CE_NOTE,
                "%s board in slot %d partially %s",
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board,
                sysc_ostate_typestr(
                    SYSC_CFGA_OSTATE_CONFIGURED,
                    event));
            break;
        case SYSC_AUDIT_OSTATE_UNCONFIGURE_FAILED:
            cmn_err(CE_NOTE,
                "%s board in slot %d partially %s",
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board,
                sysc_ostate_typestr(
                    SYSC_CFGA_OSTATE_UNCONFIGURED,
                    event));
            break;
        default:
            cmn_err(CE_NOTE,
                "unknown audit of a %s %s board in"
                " slot %d",
                sysc_rstate_typestr(sysc_stat->rstate,
                    event),
                fhc_bd_typestr(sysc_stat->type),
                sysc_stat->board);
            break;
    }
}

#define MAX_PROP_LEN    33  /* must be > strlen("cpu") */

static int
find_and_setup_cpu(int cpuid)
{
    return (prom_tree_access(find_and_setup_cpu_start, &cpuid, NULL));
}

/* ARGSUSED */
static int
find_and_setup_cpu_start(void *cpuid_arg, int has_changed)
{
    pnode_t nodeid;
    int upaid;
    char type[MAX_PROP_LEN];
    int cpuid = *(int *)cpuid_arg;

    nodeid = prom_childnode(prom_rootnode());
    while (nodeid != OBP_NONODE) {
        if (prom_getproplen(nodeid, "device_type") < MAX_PROP_LEN)
            (void) prom_getprop(nodeid, "device_type",
                (caddr_t)type);
        else
            type[0] = '\0';
        (void) prom_getprop(nodeid, "upa-portid", (caddr_t)&upaid);
        if ((strcmp(type, "cpu") == 0) && (upaid == cpuid)) {
            return (cpu_configure(cpuid));
        }
        nodeid = prom_nextnode(nodeid);
    }
    return (ENODEV);
}

#define MAX_BOARD_TYPE  IO_SBUS_FFB_SOCPLUS_BOARD

static char sysc_supp_conn[MAX_BOARD_TYPE + 1];

static int
sysc_board_connect_supported(enum board_type type)
{
    if (type > MAX_BOARD_TYPE)
        return (0);
    return (sysc_supp_conn[type]);
}

void
sysc_board_connect_supported_init(void)
{
    pnode_t openprom_node;
    char sup_list[16];
    int proplen;
    int i;
    char tstr[3 * 5 + 1];

    /* Check the firmware for Dynamic Reconfiguration support */
    if (prom_test("SUNW,Ultra-Enterprise,rm-brd") != 0) {
        /* The message was printed in platmod:set_platform_defaults */
        enable_dynamic_reconfiguration = 0;
    }

    openprom_node = prom_finddevice("/openprom");
    if (openprom_node != OBP_BADNODE) {
        proplen = prom_bounded_getprop(openprom_node,
            "add-brd-supported-types",
            sup_list, sizeof (sup_list) - 1);
    } else {
        proplen = -1;
    }

    if (proplen < 0) {
        /*
         * This is an old prom which may cause a fatal reset,
         * so don't allow any DR operations.
         * If enable_dynamic_reconfiguration is 0
         * we have already printed a similar message.
         */
        if (enable_dynamic_reconfiguration) {
            cmn_err(CE_WARN, "Firmware does not support"
                " Dynamic Reconfiguration");
            enable_dynamic_reconfiguration = 0;
        }
        return;
    }
    for (i = 0; i < proplen; i++) {
        switch (sup_list[i]) {
        case '0':
            sysc_supp_conn[CPU_BOARD] = 1;
            sysc_supp_conn[MEM_BOARD] = 1;
            break;
        case '1':
            sysc_supp_conn[IO_2SBUS_BOARD] = 1;
            break;
        case '2':
            sysc_supp_conn[IO_SBUS_FFB_BOARD] = 1;
            break;
        case '3':
            sysc_supp_conn[IO_PCI_BOARD] = 1;
            break;
        case '4':
            sysc_supp_conn[IO_2SBUS_SOCPLUS_BOARD] = 1;
            break;
        case '5':
            sysc_supp_conn[IO_SBUS_FFB_SOCPLUS_BOARD] = 1;
            break;
        default:
            /* Ignore other characters. */
            break;
        }
    }
    if (sysc_supp_conn[CPU_BOARD]) {
        cmn_err(CE_NOTE, "!Firmware supports Dynamic Reconfiguration"
            " of CPU/Memory boards.");
    } else {
        cmn_err(CE_NOTE, "Firmware does not support Dynamic"
            " Reconfiguration of CPU/Memory boards.");
    }

    tstr[0] = '\0';
    if (sysc_supp_conn[IO_2SBUS_BOARD])
        (void) strcat(tstr, ", 1");
    if (sysc_supp_conn[IO_SBUS_FFB_BOARD])
        (void) strcat(tstr, ", 2");
    if (sysc_supp_conn[IO_PCI_BOARD])
        (void) strcat(tstr, ", 3");
    if (sysc_supp_conn[IO_2SBUS_SOCPLUS_BOARD])
        (void) strcat(tstr, ", 4");
    if (sysc_supp_conn[IO_SBUS_FFB_SOCPLUS_BOARD])
        (void) strcat(tstr, ", 5");
    if (tstr[0] != '\0') {
        /* Skip leading ", " using &tstr[2]. */
        cmn_err(CE_NOTE, "!Firmware supports Dynamic Reconfiguration"
            " of I/O board types %s.", &tstr[2]);
    } else {
        cmn_err(CE_NOTE, "Firmware does not support Dynamic"
            " Reconfiguration of I/O boards.");
    }
}

#ifdef DEBUG

static void
precache_regdump(int board)
{
    fhc_bd_t *curr_bdp;
    int bd_idx;
    int reg_idx;

    for (bd_idx = 0; bd_idx < fhc_max_boards(); bd_idx++) {
        bcopy((void *) reg_tmpl, (void *) &reg_dt[bd_idx][0],
            (sizeof (struct regs_data))*NUM_REG);
        curr_bdp = fhc_bd(bd_idx);
        if (curr_bdp->sc.rstate == SYSC_CFGA_RSTATE_CONNECTED) {
            for (reg_idx = 0; reg_idx < NUM_REG; reg_idx++) {
                reg_dt[bd_idx][reg_idx].eflag = TRUE;
                if (bd_idx != board)
                    reg_dt[bd_idx][reg_idx].oflag = TRUE;
                reg_dt[bd_idx][reg_idx].physaddr +=
                    (FHC_BOARD_SPAN*2*bd_idx);
                reg_dt[bd_idx][reg_idx].pre_dsct =
                    ldphysio(reg_dt[bd_idx][reg_idx].physaddr);
            }
        }
    }


}

static void
boardstat_regdump(void)
{
    int bd_idx;

    prom_printf("\nBoard status before disconnect.\n");
    for (bd_idx = 0; bd_idx < fhc_max_boards(); bd_idx++) {
        if (reg_dt[bd_idx][0].eflag == 0) {
            prom_printf("Board #%d is idle.\n", bd_idx);
        } else {
            prom_printf("Board #%d is on.\n", bd_idx);
        }
    }

    for (bd_idx = 0; bd_idx < fhc_max_boards(); bd_idx++) {
        if (reg_dt[bd_idx][0].eflag) {
            prom_printf("\nRegisters for Board #%d", bd_idx);
            prom_printf(" (before disconnect).\n");
            prom_printf("AC_BCSR   FHC_CTRL  JTAG      IGN   SIM"
                "       SISM  UIM       USM\n");
            prom_printf("%08x  %08x  %08x  %04x"
                "  %08x  %04x  %08x  %04x\n",
                reg_dt[bd_idx][0].pre_dsct,
                reg_dt[bd_idx][1].pre_dsct,
                reg_dt[bd_idx][2].pre_dsct,
                reg_dt[bd_idx][3].pre_dsct,
                reg_dt[bd_idx][4].pre_dsct,
                reg_dt[bd_idx][5].pre_dsct,
                reg_dt[bd_idx][6].pre_dsct,
                reg_dt[bd_idx][7].pre_dsct);
        }
    }

}

static void
display_regdump(void)
{
    int bd_idx;
    int reg_idx;

    prom_printf("Board status after disconnect.\n");
    for (bd_idx = 0; bd_idx < fhc_max_boards(); bd_idx++) {
        if (reg_dt[bd_idx][0].oflag == 0) {
            prom_printf("Board #%d is idle.\n", bd_idx);
        } else {
            prom_printf("Board #%d is on.\n", bd_idx);
            for (reg_idx = 0; reg_idx < NUM_REG; reg_idx++)
                reg_dt[bd_idx][reg_idx].post_dsct =
                    ldphysio(reg_dt[bd_idx][reg_idx].physaddr);
        }
    }

    for (bd_idx = 0; bd_idx < fhc_max_boards(); bd_idx++) {
        if (reg_dt[bd_idx][0].eflag) {
            prom_printf("\nRegisters for Board #%d", bd_idx);
            prom_printf(" (before and after disconnect).\n");
            prom_printf("AC_BCSR   FHC_CTRL  JTAG      IGN   SIM"
                "       SISM  UIM       USM\n");
            prom_printf("%08x  %08x  %08x  %04x"
                "  %08x  %04x  %08x  %04x\n",
                reg_dt[bd_idx][0].pre_dsct,
                reg_dt[bd_idx][1].pre_dsct,
                reg_dt[bd_idx][2].pre_dsct,
                reg_dt[bd_idx][3].pre_dsct,
                reg_dt[bd_idx][4].pre_dsct,
                reg_dt[bd_idx][5].pre_dsct,
                reg_dt[bd_idx][6].pre_dsct,
                reg_dt[bd_idx][7].pre_dsct);
            if (reg_dt[bd_idx][0].oflag) {
                prom_printf("%08x  %08x  %08x  %04x"
                    "  %08x  %04x  %08x  %04x\n",
                    reg_dt[bd_idx][0].post_dsct,
                    reg_dt[bd_idx][1].post_dsct,
                    reg_dt[bd_idx][2].post_dsct,
                    reg_dt[bd_idx][3].post_dsct,
                    reg_dt[bd_idx][4].post_dsct,
                    reg_dt[bd_idx][5].post_dsct,
                    reg_dt[bd_idx][6].post_dsct,
                    reg_dt[bd_idx][7].post_dsct);
            } else {
                prom_printf("no data (board got"
                    " disconnected)-------------------"
                    "---------------\n");
            }
        }

    }

}

#endif /* DEBUG */