xref: /onnv-gate/usr/src/uts/sun4u/sunfire/io/sysctrl_dr.c (revision 1341:6d7c4f090a72)

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