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