xref: /onnv-gate/usr/src/uts/sun4u/starcat/io/schpc.c (revision 11311:639e7bc0b42f)

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


/*
 * Starcat IOSRAM/Tunnel PCI Hot Plug Controller Driver
 */

#define	CPCI_ENUM

#include <sys/note.h>
#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/kmem.h>
#include <sys/errno.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/cmn_err.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/ddi_impldefs.h>
#include <sys/ndi_impldefs.h>
#include <sys/modctl.h>
#include <sys/disp.h>
#include <sys/async.h>
#include <sys/hotplug/hpcsvc.h>
#include <sys/mboxsc.h>
#include <sys/schpc_msg.h>
#include <sys/schpc.h>
#include <post/scat_dcd.h>
#include <sys/taskq.h>

#ifdef DEBUG
int schpc_dump_save_regs = 0;
static uint_t schpc_debug_flags = 0;
#define	SCHPC_DEBUG0(f, s) if ((f)& schpc_debug_flags) \
	cmn_err(CE_CONT, "schpc: " s "\n")
#define	SCHPC_DEBUG1(f, s, a) if ((f)& schpc_debug_flags) \
	cmn_err(CE_CONT, "schpc: " s "\n", a)
#define	SCHPC_DEBUG2(f, s, a, b) if ((f)& schpc_debug_flags) \
	cmn_err(CE_CONT, "schpc: " s "\n", a, b)
#define	SCHPC_DEBUG3(f, s, a, b, c) if ((f)& schpc_debug_flags) \
	cmn_err(CE_CONT, "schpc: " s "\n", a, b, c)
#define	SCHPC_DEBUG4(f, s, a, b, c, d) if ((f)& schpc_debug_flags) \
	cmn_err(CE_CONT, "schpc: " s "\n", a, b, c, d)
#define	SCHPC_DEBUG5(f, s, a, b, c, d, e) if ((f)& schpc_debug_flags) \
	cmn_err(CE_CONT, "schpc: " s "\n", a, b, c, d, e)
#define	SCHPC_DEBUG6(f, s, a, b, c, d, e, ff) if ((f)& schpc_debug_flags) \
	cmn_err(CE_CONT, "schpc: " s "\n", a, b, c, d, e, ff)
#else

#define	SCHPC_DEBUG0(f, s)
#define	SCHPC_DEBUG1(f, s, a)
#define	SCHPC_DEBUG2(f, s, a, b)
#define	SCHPC_DEBUG3(f, s, a, b, c)
#define	SCHPC_DEBUG4(f, s, a, b, c, d)
#define	SCHPC_DEBUG5(f, s, a, b, c, d, e)
#define	SCHPC_DEBUG6(f, s, a, b, c, d, e, ff)

#endif

#define	D_IDENTIFY	0x00000001
#define	D_ATTACH	0x00000002
#define	D_DETACH	0x00000004
#define	D_OPEN		0x00000008
#define	D_GETSLOTSTATUS	0x00000010
#define	D_SETSLOTSTATUS	0x00000020
#define	D_IOCTL		0x00010000
#define	D_IOC_CONNECT	0x00020000
#define	D_IOC_CONTROL	0x00040000
#define	D_IOC_CONFIG	0x00080000
#define	D_IOC_STATUS	0x00100000
#define	D_IOC_MSG	0x00200000
#define	D_IOC_TEST	0x00400000
#define	D_IOC_LED	0x00800000
#define	D_EVENT		0x01000000
#define	D_THREAD	0x02000000
#define	D_TRANSID	0x04000000
#define	D_SLOTTABLE	0x08000000
#define	D_FREQCHG	0x10000000
#define	D_APID		0x20000000

/*
 * driver global data:
 */
static void *per_schpc_state;		/* soft state head */
dev_info_t *schpc_devi;
static schpc_t	*schpc_p;

clock_t schpc_timeout_putmsg = 60 * 1000; /* 60 seconds */
clock_t schpc_timeout_getmsg = 60 * 1000; /* 60 seconds */
clock_t schpc_timeout_event = 60 * 5 * 1000; /* 5 minutes */

int schpc_use_legacy_apid = 0;

static mboxsc_timeout_range_t schpc_putmsg_timeout_range;
static mboxsc_timeout_range_t schpc_getmsg_timeout_range;

static taskq_t *schpc_event_taskq = NULL;

/*
 * replies to mboxsc_getmsg() are handled asynchronously by the
 * schpc_msg_thread using a linked list of schpc_replylist_t
 * elements
 */
typedef struct schpc_replylist {
	struct schpc_replylist	*prev;		/* link to previous entry */
	struct schpc_replylist	*next;		/* link to next entry */
	kcondvar_t		reply_cv;	/* condvar for getting reply */
	kmutex_t		reply_lock;	/* mutex for getting reply */
	uint32_t		type;		/* mboxsc_xxxmsg() msg type */
	uint32_t		cmd;		/* mboxsc_xxxmsg() cmd */
	uint64_t		transid;	/* mboxsc_xxxmsg() trans id */
	uint32_t		length;		/* mboxsc_xxxmsg() length */
	pcimsg_t		reply;		/* mboxsc_xxxmsg() reply msg */
	boolean_t		reply_recvd;	/* msg reply received */
	boolean_t		reply_cexit;	/* client early exit */
} schpc_replylist_t;

static kmutex_t schpc_replylist_mutex; /* replylist mutex */
static uint32_t schpc_replylist_count; /* replylist size */
static schpc_replylist_t *schpc_replylist_first; /* replylist 1st elem */
static schpc_replylist_t *schpc_replylist_last; /* replylist last elem */
static boolean_t slots_registered = B_FALSE; /* slots registered? */

typedef struct {
	char		*cname;
	char		*caddr;
	char		schizo;
	char		leaf;
	dev_info_t	*dip;
} find_dev_t;

/*
 * Function prototypes for local functions
 */
static int schpc_getexpander(dev_info_t *);
static int schpc_getboard(dev_info_t *);
static void schpc_event_handler(void *);
static void schpc_event_filter(pcimsg_t	*msg);
static void schpc_reply_handler(pcimsg_t *pmsg, uint32_t type, uint32_t cmd,
				uint64_t transid, uint32_t length);
static uint64_t schpc_gettransid(schpc_t *, int);
static int schpc_slot_get_index(schpc_t *, hpc_slot_t);
static void schpc_register_all_slots(schpc_t *);
static void schpc_setslotled(int, int, int, uint32_t);
static void schpc_init_setslot_message(pci_setslot_t *);
static void schpc_test(caddr_t, int, void *, uint_t);
static int schpc_getslotstatus(uint32_t, uint32_t, uint32_t, pci_getslot_t *);
static int schpc_setslotstatus(uint32_t, uint32_t, uint32_t,  pci_setslot_t *);
static int schpc_match_dip(dev_info_t *, void *);
static void schpc_buildapid(dev_info_t *, int, char *);
static int schpc_get_slot_status(uint_t, uint_t, uint_t);
static void schpc_replylist_unlink(schpc_replylist_t *entry);
static schpc_replylist_t *schpc_replylist_link(uint32_t cmd, uint64_t transid,
						uint32_t length);
static void schpc_msg_thread(void);
static int schpc_putrequest(uint32_t key, uint32_t type, uint32_t cmd,
				uint64_t *transidp, uint32_t length,
				void *datap, clock_t timeout,
				schpc_replylist_t **entryp);
static int schpc_getreply(uint32_t key, uint32_t *typep, uint32_t *cmdp,
			uint64_t *transidp, uint32_t *lengthp, void *datap,
			clock_t timeout, schpc_replylist_t *listp);

static int schpc_slot_freq(pci_getslot_t *);
static int schpc_find_dip(dev_info_t *, void *);

static int schpc_save_leaf(int slot);
static void schpc_restore_leaf(int slot);
static int schpc_is_leaf_reset_required(int slot);
static int schpc_is_freq_switchable(int slot);
static void schpc_save_entry(int slot, int list_entry, int save_entry);
static void schpc_restore_entry(int slot, int list_entry, int save_entry);

/*
 * Function prototype for Hot Plug Services
 */
static int schpc_connect(caddr_t, hpc_slot_t, void *, uint_t);
static int schpc_disconnect(caddr_t, hpc_slot_t, void *, uint_t);
static int schpc_cpci_control(caddr_t, hpc_slot_t, int, caddr_t);
static int schpc_pci_control(caddr_t, hpc_slot_t, int, caddr_t);

extern int iosram_rd(uint32_t, uint32_t, uint32_t, caddr_t);

/*
 * cb_ops and dev_ops:
 */
static struct cb_ops schpc_cb_ops = {
	nodev,			/* open */
	nodev,			/* close */
	nodev,			/* strategy */
	nodev,			/* print */
	nodev,			/* dump */
	nodev,			/* read */
	nodev,			/* write */
	nodev,			/* ioctl */
	nodev,			/* devmap */
	nodev,			/* mmap */
	nodev,			/* segmap */
	nochpoll,		/* poll */
	ddi_prop_op,		/* prop_op */
	0,			/* streamtab  */
	D_NEW | D_MP | D_HOTPLUG /* Driver compatibility flag */
};

/*
 * Function prototype for dev_ops
 */
static int schpc_attach(dev_info_t *, ddi_attach_cmd_t);
static int schpc_detach(dev_info_t *, ddi_detach_cmd_t);
static int schpc_info(dev_info_t *, ddi_info_cmd_t, void *, void **);

static struct dev_ops schpc_dev_ops = {
	DEVO_REV,			/* devo_rev, */
	0,				/* refcnt  */
	schpc_info,			/* get_dev_info */
	nulldev,			/* identify */
	nulldev,			/* probe */
	schpc_attach,			/* attach */
	schpc_detach,			/* detach */
	nodev,				/* reset */
	&schpc_cb_ops,			/* driver operations */
	(struct bus_ops *)0,		/* no bus operations */
	NULL,				/* power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};

/*
 * loadable module declarations:
 */
static struct modldrv modldrv = {
	&mod_driverops,
	"PCI Hot Plug Controller Driver (schpc)",
	&schpc_dev_ops,
};

static struct modlinkage modlinkage = {
	MODREV_1,
	(void *)&modldrv,
	NULL
};

int
_init(void)
{
	int		ret;
	int		rv;

	SCHPC_DEBUG0(D_ATTACH, "_init() installing module");

	ret = ddi_soft_state_init(&per_schpc_state, sizeof (schpc_t), 1);
	if (ret != 0) {
		return (ret);
	}

	/*
	 * Initialize Outgoing Mailbox.
	 */
	ret = mboxsc_init(KEY_PCSC, MBOXSC_MBOX_OUT, NULL);

	if (ret != 0) {
		ddi_soft_state_fini(&per_schpc_state);
		return (ret);
	}

	ret = mboxsc_ctrl(KEY_PCSC, MBOXSC_CMD_PUTMSG_TIMEOUT_RANGE,
	    (void *) &schpc_putmsg_timeout_range);

	if (ret != 0) {
		ddi_soft_state_fini(&per_schpc_state);
		return (ret);
	}

	if (schpc_timeout_putmsg < schpc_putmsg_timeout_range.min_timeout) {
		schpc_timeout_putmsg = schpc_putmsg_timeout_range.min_timeout;
		cmn_err(CE_WARN, " schpc: resetting putmsg timeout to %ld\n",
		    schpc_timeout_putmsg);
	}

	if (schpc_timeout_putmsg > schpc_putmsg_timeout_range.max_timeout) {
		schpc_timeout_putmsg = schpc_putmsg_timeout_range.max_timeout;
		cmn_err(CE_WARN, " schpc: resetting putmsg timeout to %ld\n",
		    schpc_timeout_putmsg);
	}

	/*
	 * Create the schpc_event_taskq for MBOXSC_MSG_EVENT processing.
	 */
	schpc_event_taskq = taskq_create("schpc_event_taskq", 2,
	    minclsyspri, 4, 4, TASKQ_PREPOPULATE);

	/*
	 * Initialize Incoming Mailbox.
	 * NOTE: the callback is null because the schpc_msg_thread will
	 * handle all incoming MBOXSC_MSG_EVENT and MBOXSC_MSG_REPLY
	 * messages.
	 */
	ret = mboxsc_init(KEY_SCPC, MBOXSC_MBOX_IN, NULL);

	if (ret != 0) {
		cmn_err(CE_WARN, "schpc: can not initialize KEY_SCPC as "
		    "MBOXSC_MBOX_IN");
		ddi_soft_state_fini(&per_schpc_state);
		return (ret);
	}

	ret = mboxsc_ctrl(KEY_SCPC, MBOXSC_CMD_GETMSG_TIMEOUT_RANGE,
	    (void *) &schpc_getmsg_timeout_range);

	if (ret != 0) {
		ddi_soft_state_fini(&per_schpc_state);
		return (ret);
	}

	if (schpc_timeout_getmsg < schpc_getmsg_timeout_range.min_timeout) {
		schpc_timeout_getmsg = schpc_getmsg_timeout_range.min_timeout;
		cmn_err(CE_WARN, " schpc: resetting getmsg timeout to %ld\n",
		    schpc_timeout_getmsg);
	}

	if (schpc_timeout_getmsg > schpc_getmsg_timeout_range.max_timeout) {
		schpc_timeout_getmsg = schpc_getmsg_timeout_range.max_timeout;
		cmn_err(CE_WARN, " schpc: resetting putmsg timeout to %ld\n",
		    schpc_timeout_putmsg);
	}

	if (schpc_timeout_event < schpc_getmsg_timeout_range.min_timeout) {
		schpc_timeout_event = schpc_getmsg_timeout_range.min_timeout;
		cmn_err(CE_WARN, " schpc: resetting event timeout to %ld\n",
		    schpc_timeout_event);
	}

	if (schpc_timeout_event > schpc_getmsg_timeout_range.max_timeout) {
		schpc_timeout_event = schpc_getmsg_timeout_range.max_timeout;
		cmn_err(CE_WARN, " schpc: resetting event timeout to %ld\n",
		    schpc_timeout_event);
	}

	ret = mod_install(&modlinkage);
	if (ret != 0) {
		if ((rv = mboxsc_fini(KEY_PCSC)) != 0) {
			cmn_err(CE_WARN, "schpc: _init() - "
			    "mboxsc_fini(KEY_PCSC) failed: 0x%x", rv);
		}
		if ((rv = mboxsc_fini(KEY_SCPC)) != 0) {
			cmn_err(CE_WARN, "schpc: _init() - "
			    "mboxsc_fini(KEY_SCPC) failed: 0x%x", rv);
		}
		taskq_destroy(schpc_event_taskq);
		ddi_soft_state_fini(&per_schpc_state);
		return (ret);
	}

	SCHPC_DEBUG0(D_ATTACH, "_init() module installed");

	/*
	 * Start the schpc_msg_thread to continuously monitor the
	 * MBOXSC_MBOX_IN mailbox for incoming MBOXSC_MSG_EVENTs and
	 * MBOXSC_MSG_REPLYs.
	 */
	mutex_init(&schpc_replylist_mutex, NULL, MUTEX_DRIVER, NULL);
	(void) thread_create(NULL, 0, schpc_msg_thread,
	    NULL, 0, &p0, TS_RUN, minclsyspri);

	SCHPC_DEBUG0(D_ATTACH, "_init() started schpc_msg_thread");

	return (ret);
}

int
_fini(void)
{
	SCHPC_DEBUG0(D_ATTACH, "_fini()");

	return (DDI_FAILURE);
}

int
_info(struct modinfo *modinfop)
{
	SCHPC_DEBUG0(D_ATTACH, "_info() called.");

	return (mod_info(&modlinkage, modinfop));
}

static int
schpc_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
	int		instance = ddi_get_instance(devi);
	int		rval;

	SCHPC_DEBUG1(D_ATTACH, "attach(%x) ATTACH", instance);

	switch (cmd) {
	case DDI_ATTACH:

		/*
		 * Allocate the soft state structure for this instance.
		 */
		rval = ddi_soft_state_zalloc(per_schpc_state, instance);

		if (rval != DDI_SUCCESS) {
			SCHPC_DEBUG1(D_ATTACH,
			    "schpc_attach(%x) Can not allocate "
			    "soft state structure", instance);
			return (DDI_FAILURE);
		}

		schpc_p = (schpc_t *)ddi_get_soft_state(per_schpc_state,
		    instance);

		if (schpc_p == NULL) {
			return (DDI_FAILURE);
		}

		mutex_init(&schpc_p->schpc_mutex, NULL, MUTEX_DRIVER, NULL);
		cv_init(&schpc_p->schpc_cv, NULL, CV_DRIVER, NULL);

		/*
		 * Put schpc structure on global linked list.
		 */

		/*
		 * Initialize starting transaction ID.
		 */
		schpc_p->schpc_transid = 0;

		schpc_p->schpc_number_of_slots = STARCAT_MAX_SLOTS;

		SCHPC_DEBUG2(D_ATTACH, "schpc_attach(%x) slot-table property "
		    "describes %d slots", instance,
		    schpc_p->schpc_number_of_slots);

		schpc_p->schpc_hotplugmodel = ddi_getprop(DDI_DEV_T_ANY,
		    devi, 0, "hot-plug-model", SCHPC_HOTPLUGTYPE_CPCIHOTPLUG);

		SCHPC_DEBUG2(D_ATTACH, "attach(%x) ATTACH - Hot Plug Model=%x",
		    instance, schpc_p->schpc_hotplugmodel);

		/*
		 * What type of hot plug do these slots support?  The only
		 * types of slots we support is the cPCI Hot Plug Model
		 * and Not Hot Pluggable.
		 */
		if (schpc_p->schpc_hotplugmodel !=
		    SCHPC_HOTPLUGTYPE_CPCIHOTPLUG) {
			schpc_p->schpc_hotplugmodel =
			    SCHPC_HOTPLUGTYPE_NOTHOTPLUGGABLE;
		}

		schpc_p->schpc_slot = (schpc_slot_t *)kmem_zalloc((size_t)
		    (schpc_p->schpc_number_of_slots * sizeof (schpc_slot_t)),
		    KM_SLEEP);

		schpc_p->schpc_devi = devi;
		schpc_p->schpc_instance = instance;

		/*
		 * Start thread to search the device tree and register
		 * all found pci slots.
		 */
		(void) thread_create(NULL, 0, schpc_register_all_slots,
		    (void *)schpc_p, 0, &p0, TS_RUN, minclsyspri);

		break;

	case DDI_PM_RESUME:
	case DDI_RESUME:
		return (DDI_SUCCESS);
	default:
		cmn_err(CE_WARN, "schpc%d: Cmd != DDI_ATTACH/DDI_RESUME",
		    instance);

		return (DDI_FAILURE);
	}

	SCHPC_DEBUG1(D_ATTACH,
	    "schpc_attach(%x) Attach - DDI_SUCCESS", instance);

	return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
schpc_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
	int	instance = ddi_get_instance(devi);

	SCHPC_DEBUG1(D_DETACH, "detach(%x) DETACH", instance);

	return (DDI_FAILURE);
}

/*ARGSUSED*/
static int
schpc_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
	void **result)
{
	int	error;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		*result = (void *)schpc_devi;
		error = DDI_SUCCESS;
		break;
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)0;
		error = DDI_SUCCESS;
		break;
	default:
		error = DDI_FAILURE;
	}
	return (error);
}

/*
 * schpc_connect()
 *
 * Called by Hot Plug Services to connect a slot to the bus.
 */

/*ARGSUSED*/
static int
schpc_connect(caddr_t ops_arg, hpc_slot_t slot_hdl, void *data, uint_t flags)
{
	int		rval;
	int		expander, board;
	pci_setslot_t	setslot;
	pci_getslot_t	getslot;
	int		slot;

	SCHPC_DEBUG2(D_IOC_CONNECT, "schpc_connect( ops_arg=%p slot_hdl=%p)",
	    (void *)ops_arg, (void *)slot_hdl);

	mutex_enter(&schpc_p->schpc_mutex);

	slot = schpc_slot_get_index(schpc_p, slot_hdl);

	if (!(schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_HPCINITED)) {
		SCHPC_DEBUG0(D_IOC_CONNECT, "schpc_connect - HPC Not Inited");
		mutex_exit(&schpc_p->schpc_mutex);
		return (HPC_ERR_FAILED);
	}

	/*
	 * Check to see if the slot is already connected.
	 */
	if (schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_CONNECTED) {
		mutex_exit(&schpc_p->schpc_mutex);
		return (0);
	}

	/*
	 * Block if another thread is executing a HPC command.
	 */
	while (schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_EXECUTING) {
		cv_wait(&schpc_p->schpc_cv, &schpc_p->schpc_mutex);
	}

	schpc_p->schpc_slot[slot].state |= SCHPC_SLOTSTATE_EXECUTING;

	mutex_exit(&schpc_p->schpc_mutex);

	expander = schpc_p->schpc_slot[slot].expander; /* get expander */
	board = schpc_p->schpc_slot[slot].board; /* get board */

	SCHPC_DEBUG3(D_IOC_CONNECT,
	    "schpc_connect Expander=%x Board=%x Slot=%x",
	    expander, board, SCHPC_SLOT_NUM(slot));


	if (!(schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_OCC_GOOD)) {
		cmn_err(CE_WARN, "schpc: Hot Plug - Unable to complete "
		    "connection on Expander %d Board %d Slot %d - "
		    "Ap_Id=%s : Occupant is in failed state",
		    expander, board, SCHPC_SLOT_NUM(slot),
		    schpc_p->schpc_slot[slot].ap_id);

		/* Fault LED should already be illuminated */

		goto failed;
	}

	if (!(schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_REC_GOOD)) {
		cmn_err(CE_WARN, "schpc: Hot Plug - Unable to complete "
		    "connection on Expander %d Board %d Slot %d - "
		    "Ap_Id=%s : Receptacle is in failed state",
		    expander, board, SCHPC_SLOT_NUM(slot),
		    schpc_p->schpc_slot[slot].ap_id);

		/* Fault LED should already be illuminated */

		goto failed;
	}

	rval = schpc_getslotstatus(expander, board, slot, &getslot);

	if (rval) {
		/*
		 * System Controller/Mailbox failure.
		 */
		cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed on "
		    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : Unable to "
		    "Communicate with System Controller", expander, board,
		    SCHPC_SLOT_NUM(slot), schpc_p->schpc_slot[slot].ap_id);

		schpc_setslotled(expander, board, slot, FAULT_LED_ON);

		goto failed;
	}

	if (getslot.slot_replystatus != PCIMSG_REPLY_GOOD) {

		cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed on "
		    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : Unable to "
		    "Read Slot Status", expander, board,
		    SCHPC_SLOT_NUM(slot), schpc_p->schpc_slot[slot].ap_id);

		schpc_setslotled(expander, board, slot, FAULT_LED_ON);

		goto failed;
	}

	if (getslot.slot_empty) {
		/*
		 * If the slot is empty - fail the connection request.
		 */
		goto failed;
	}

	SCHPC_DEBUG3(D_FREQCHG, "Slot %d - slot_freq_setting %d "
	    "slot_freq_cap %d", slot, getslot.slot_freq_setting,
	    getslot.slot_freq_cap);

	if (!schpc_is_freq_switchable(slot) &&
	    (getslot.slot_freq_setting > getslot.slot_freq_cap)) {

		cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed "
		    "on Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
		    "Bus Speed Mismatch", expander,
		    board, SCHPC_SLOT_NUM(slot),
		    schpc_p->schpc_slot[slot].ap_id);

		schpc_setslotled(expander, board, slot, FAULT_LED_ON);

		goto failed;
	}

	if (schpc_is_leaf_reset_required(slot) &&
	    (schpc_p->schpc_slot[slot].saved_regs == NULL)) {

		SCHPC_DEBUG1(D_FREQCHG, "Slot %d - Save Regs before connect",
		    slot);

		/*
		 * A prior disconnect had not saved off the leaf so lets
		 * save it now. This is probably due to the domain being
		 * booted with a slot with no cassette.
		 */
		if (schpc_save_leaf(slot) != 0) {
			cmn_err(CE_WARN, "schpc - Unable to save leaf regs on "

			    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : ",
			    expander, board, slot & 3,
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot, FAULT_LED_ON);

			goto failed;
		}
	}

	/*
	 * Initialize Set Slot Command.
	 */
	schpc_init_setslot_message(&setslot);

	setslot.slot_power_on = PCIMSG_ON;	   /* Turn slot power on */

	setslot.slot_led_fault = PCIMSG_LED_FLASH; /* Flash Fault LED */

	rval = schpc_setslotstatus(expander, board, slot, &setslot);

	if (rval != 0) {
		/*
		 * System Controller/Mailbox failure.
		 */
		cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed on "
		    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : Unable to "
		    "Communicate with System Controller", expander, board,
		    SCHPC_SLOT_NUM(slot), schpc_p->schpc_slot[slot].ap_id);

		schpc_setslotled(expander, board, slot, FAULT_LED_ON);

		goto failed;
	}

	if (setslot.slot_replystatus == PCIMSG_REPLY_GOOD) {

		/*
		 * The Request was successfully completed.
		 */

		SCHPC_DEBUG0(D_IOC_CONNECT, "schpc_connect() - setslotstatus "
		    "succeeded");

		/*
		 * Need to check HEALTHY# signal.
		 */
		rval = schpc_getslotstatus(expander, board, slot, &getslot);

		if (rval) {
			/*
			 * System Controller/Mailbox failure.
			 */
			cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed "
			    "on Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
			    "Unable to Communicate with System Controller",
			    expander, board, SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot, FAULT_LED_ON);

			goto failed;
		}

		if (getslot.slot_replystatus != PCIMSG_REPLY_GOOD) {

			cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed "
			    "on Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
			    "Unable to Read Slot Status", expander, board,
			    SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot, FAULT_LED_ON);

			goto failed;
		}

		if ((getslot.slot_powergood != PCIMSG_ON) ||
		    (getslot.slot_powerfault == PCIMSG_ON)) {
			cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed "
			    "on Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
			    "Power failure detected", expander, board,
			    SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			/*
			 * Initialize Set Slot Command.
			 */
			schpc_init_setslot_message(&setslot);

			/*
			 * Turn slot power off.
			 */
			setslot.slot_power_off = PCIMSG_ON;

			(void) schpc_setslotstatus(expander, board,
			    slot, &setslot);

			schpc_setslotled(expander, board, slot,
			    (SERVICE_LED_ON | FAULT_LED_ON));

			goto failed;
		}

		if (!getslot.slot_HEALTHY) {
			cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed "
			    "on Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
			    "Adapter did not assert HEALTHY#", expander, board,
			    SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			/*
			 * Initialize Set Slot Command.
			 */
			schpc_init_setslot_message(&setslot);

			/*
			 * Turn slot power off.
			 */
			setslot.slot_power_off = PCIMSG_ON;

			(void) schpc_setslotstatus(expander, board, slot,
			    &setslot);

			schpc_setslotled(expander, board, slot,
			    (SERVICE_LED_ON | FAULT_LED_ON));

			goto failed;
		}

		/*
		 * Initialize Set Slot Command.
		 */
		schpc_init_setslot_message(&setslot);

		/*
		 * Start monitoring ENUM# and HEALTHY#
		 */
		setslot.slot_enable_HEALTHY = PCIMSG_ON;
		setslot.slot_enable_ENUM = PCIMSG_ON;

		rval = schpc_setslotstatus(expander, board, slot, &setslot);

		if (rval != 0) {
			/*
			 * System Controller/Mailbox failure.
			 */
			cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed "
			    "on Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
			    "Unable to Communicate with System Controller",
			    expander, board, SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot, FAULT_LED_ON);

			goto failed;
		}
		if (setslot.slot_replystatus == PCIMSG_REPLY_GOOD) {

			int		freq;
			find_dev_t	find_dev;

			/*
			 * The Request was successfully completed.
			 */

			SCHPC_DEBUG0(D_IOC_CONNECT,
			    "schpc_connect() - setslotstatus succeeded");

			schpc_p->schpc_slot[slot].state |=
			    SCHPC_SLOTSTATE_CONNECTED;

			schpc_setslotled(expander, board, slot,
			    (POWER_LED_ON | SERVICE_LED_OFF | FAULT_LED_OFF));

			find_dev.cname = schpc_p->schpc_slot[slot].nexus_path;
			find_dev.caddr = (char *)kmem_alloc(MAXPATHLEN,
			    KM_SLEEP);
			find_dev.dip = NULL;

			/* root node doesn't have to be held */
			ddi_walk_devs(ddi_root_node(), schpc_find_dip,
			    &find_dev);
			if (find_dev.dip != NULL) {
				/*
				 * Update the clock-frequency property to
				 * reflect the new slot-frequency.
				 */
				freq = schpc_slot_freq(&getslot);
				SCHPC_DEBUG2(D_FREQCHG,
				    "schpc_connect: updating dip=%p freq=%dHZ",
				    (void *)find_dev.dip, freq);
				if (ndi_prop_update_int(DDI_DEV_T_NONE,
				    find_dev.dip, "clock-frequency", freq)
				    != DDI_SUCCESS) {
					cmn_err(CE_WARN,
					    "schpc: - failed to update "
					    "clock-frequency property for %s",
					    find_dev.cname);
				}
				ndi_rele_devi(find_dev.dip);
			} else {
				cmn_err(CE_WARN,
				    "schpc: couldn't find dip for %s ",
				    find_dev.cname);
			}
			kmem_free(find_dev.caddr, MAXPATHLEN);

			mutex_enter(&schpc_p->schpc_mutex);
			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_EXECUTING;

			/*
			 * If leaf registers were saved off, then they
			 * need to be restored.
			 */
			schpc_restore_leaf(slot);

			/*
			 * Since the device saw a PCI Reset, we need to
			 * wait 2^25 clock cycles before the first
			 * Configuration access. The worst case is 33MHz,
			 * which is a 1 second wait.
			 */
			drv_usecwait(1000000);

			cv_signal(&schpc_p->schpc_cv);
			mutex_exit(&schpc_p->schpc_mutex);

			return (0);
		} else {
			/*
			 * The System Controller Rejected the
			 * connection request.
			 */
			cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed "
			    "on Expander %d Board %d PCI Slot %d - Ap_Id=%s :"
			    "System Controller failed connection request",
			    expander, board, SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot, FAULT_LED_ON);

			goto failed;
		}
	}

	/*
	 * The System Controller Rejected the connection request.
	 */
	cmn_err(CE_WARN, "schpc - Hot Plug Connection Failed on "
	    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : System Controller "
	    "failed connection request", expander, board, SCHPC_SLOT_NUM(slot),
	    schpc_p->schpc_slot[slot].ap_id);

	schpc_setslotled(expander, board, slot, FAULT_LED_ON);

failed:
	mutex_enter(&schpc_p->schpc_mutex);
	schpc_p->schpc_slot[slot].state &=
	    ~SCHPC_SLOTSTATE_EXECUTING;
	cv_signal(&schpc_p->schpc_cv);
	mutex_exit(&schpc_p->schpc_mutex);

	return (HPC_ERR_FAILED);
}

/*
 * schpc_disconnect()
 *
 * Called by Hot Plug Services to disconnect a slot to the bus.
 */

/*ARGSUSED*/
static int
schpc_disconnect(caddr_t ops_arg, hpc_slot_t slot_hdl, void *data,
	uint_t flags)
{
	int		rval;
	int		expander, board, slot;
	pci_setslot_t	setslot;

	SCHPC_DEBUG2(D_IOC_CONNECT,
	    "schpc_disconnect( ops_arg=%p slot_hdl=%p)", (void *)ops_arg,
	    slot_hdl);

	mutex_enter(&schpc_p->schpc_mutex);

	slot = schpc_slot_get_index(schpc_p, slot_hdl);

	if (!(schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_HPCINITED)) {
		SCHPC_DEBUG0(D_IOC_CONNECT,
		    "schpc_disconnect - HPC Not Inited");
		mutex_exit(&schpc_p->schpc_mutex);
		return (HPC_ERR_FAILED);
	}

	/*
	 * Check to see if we are already disconnected.
	 */
	if (!(schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_CONNECTED)) {
		mutex_exit(&schpc_p->schpc_mutex);
		return (0);
	}

	/*
	 * Block if another thread is executing a HPC command.
	 */
	while (schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_EXECUTING) {
		cv_wait(&schpc_p->schpc_cv, &schpc_p->schpc_mutex);
	}

	schpc_p->schpc_slot[slot].state |= SCHPC_SLOTSTATE_EXECUTING;

	mutex_exit(&schpc_p->schpc_mutex);

	expander = schpc_p->schpc_slot[slot].expander; /* get expander */
	board = schpc_p->schpc_slot[slot].board; /* get board */

	/*
	 * If a leaf reset is going to be asserted due to a mode/freq.
	 * change, then the leaf registers of the XMITS bridge will need
	 * to be saved off prior to the connect.
	 */
	if (schpc_is_leaf_reset_required(slot)) {
		if (schpc_save_leaf(slot) != 0) {

			cmn_err(CE_WARN, "schpc - Unable to save leaf regs on "
			    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : ",
			    expander, board, slot & 3,
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot, FAULT_LED_ON);

			goto failed;
		}
	}

	/*
	 * Initialize Set Slot Command.
	 */
	schpc_init_setslot_message(&setslot);

	setslot.slot_power_off = PCIMSG_ON;	   /* Turn Power Off */

	setslot.slot_led_fault = PCIMSG_LED_FLASH; /* Flash the Fault LED */

	setslot.slot_disable_ENUM = PCIMSG_ON;	   /* Mask the ENUM# signal */
	setslot.slot_disable_HEALTHY = PCIMSG_ON;  /* Mask the HEALTHY# sig */

	rval = schpc_setslotstatus(expander, board, slot, &setslot);

	SCHPC_DEBUG1(D_IOC_CONNECT, "schpc_disconnect() - "
	    "setslotstatus returned 0x%x", rval);

	if (rval != 0) {
		/*
		 * System Controller/Mailbox failure.
		 */
		cmn_err(CE_WARN, "schpc - Hot Plug Disconnection Failed on "
		    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : Unable to "
		    "Communicate with System Controller", expander, board,
		    SCHPC_SLOT_NUM(slot), schpc_p->schpc_slot[slot].ap_id);

		schpc_setslotled(expander, board, slot, FAULT_LED_ON);

		goto failed;
	}

	SCHPC_DEBUG1(D_IOC_CONNECT, "schpc_disconnect() - "
	    "slot_replystatus returned 0x%x", setslot.slot_replystatus);

	if (setslot.slot_replystatus == PCIMSG_REPLY_GOOD) {

		/*
		 * The Request was successfully completed.
		 */
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_CONNECTED;

		schpc_setslotled(expander, board, slot,
		    (POWER_LED_OFF | SERVICE_LED_ON | FAULT_LED_OFF));

		SCHPC_DEBUG0(D_IOC_CONNECT,
		    "schpc_disconnect() - setslotstatus succeeded");

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);
	}
	/*
	 * System Controller/Mailbox failure.
	 */
	cmn_err(CE_WARN, "schpc - Hot Plug Disconnection Failed on "
	    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : System Controller "
	    "failed disconnection request", expander, board,
	    SCHPC_SLOT_NUM(slot),
	    schpc_p->schpc_slot[slot].ap_id);

	schpc_setslotled(expander, board, slot, FAULT_LED_ON);

failed:
	schpc_restore_leaf(slot);
	mutex_enter(&schpc_p->schpc_mutex);
	schpc_p->schpc_slot[slot].state &=
	    ~SCHPC_SLOTSTATE_EXECUTING;
	cv_signal(&schpc_p->schpc_cv);
	mutex_exit(&schpc_p->schpc_mutex);

	return (HPC_ERR_FAILED);
}

/*
 * schpc_cpci_control
 *
 * Called by Hot Plug Services to perform a attachment point specific
 * on a Hot Pluggable Compact PCI Slot.
 */
/*ARGSUSED*/
static int
schpc_cpci_control(caddr_t ops_arg, hpc_slot_t slot_hdl, int request,
    caddr_t arg)
{
	int		rval;
	int		expander, board, slot;
	pci_setslot_t	setslot;
	pci_getslot_t   slotstatus;
	hpc_led_info_t	*hpc_led_info;

	SCHPC_DEBUG3(D_IOC_CONTROL,
	    "schpc_cpci_control(op_args=%p slot_hdl=%p request=%x)",
	    (void *)ops_arg, (void *)slot_hdl, request);

	mutex_enter(&schpc_p->schpc_mutex);

	slot = schpc_slot_get_index(schpc_p, slot_hdl);

	if (!(schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_HPCINITED)) {
		SCHPC_DEBUG0(D_IOC_CONNECT,
		    "schpc_disconnect - HPC Not Inited");
		mutex_exit(&schpc_p->schpc_mutex);
		return (HPC_ERR_FAILED);
	}

	/*
	 * Block if another thread is executing a HPC command.
	 */
	while (schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_EXECUTING) {
		cv_wait(&schpc_p->schpc_cv, &schpc_p->schpc_mutex);
	}

	schpc_p->schpc_slot[slot].state |= SCHPC_SLOTSTATE_EXECUTING;

	mutex_exit(&schpc_p->schpc_mutex);

	expander = schpc_p->schpc_slot[slot].expander; /* get expander */
	board = schpc_p->schpc_slot[slot].board; /* get board */

	/*
	 * Initialize Set Slot Command.
	 */
	schpc_init_setslot_message(&setslot);

	/*
	 * Initialize LED to last know state.
	 */
	switch (schpc_p->schpc_slot[slot].led.led_power) {
	case LED_ON:
		setslot.slot_led_power = PCIMSG_LED_ON;
		break;
	case LED_OFF:
		setslot.slot_led_power = PCIMSG_LED_OFF;
		break;
	case LED_FLASH:
		setslot.slot_led_power = PCIMSG_LED_FLASH;
		break;
	}

	switch (schpc_p->schpc_slot[slot].led.led_service) {
	case LED_ON:
		setslot.slot_led_service = PCIMSG_LED_ON;
		break;
	case LED_OFF:
		setslot.slot_led_service = PCIMSG_LED_OFF;
		break;
	case LED_FLASH:
		setslot.slot_led_service = PCIMSG_LED_FLASH;
		break;
	}

	switch (schpc_p->schpc_slot[slot].led.led_fault) {
	case LED_ON:
		setslot.slot_led_fault = PCIMSG_LED_ON;
		break;
	case LED_OFF:
		setslot.slot_led_fault = PCIMSG_LED_OFF;
		break;
	case LED_FLASH:
		setslot.slot_led_fault = PCIMSG_LED_FLASH;
		break;
	}

	switch (request) {

	case HPC_CTRL_GET_LED_STATE:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_GET_LED_STATE");
		hpc_led_info = (hpc_led_info_t *)arg;

		switch (hpc_led_info->led) {
		case HPC_FAULT_LED:
			switch (schpc_p->schpc_slot[slot].led.led_fault) {
			case LED_OFF:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_ON:
				hpc_led_info->state = HPC_LED_ON;
				break;
			case LED_FLASH:
				hpc_led_info->state = HPC_LED_BLINK;
				break;
			}
			break;

		case HPC_POWER_LED:
			switch (schpc_p->schpc_slot[slot].led.led_power) {
			case LED_OFF:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_ON:
				hpc_led_info->state = HPC_LED_ON;
				break;
			case LED_FLASH:
				hpc_led_info->state = HPC_LED_BLINK;
				break;
			}
			break;
		case HPC_ATTN_LED:
			switch (schpc_p->schpc_slot[slot].led.led_fault) {
			case LED_OFF:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_ON:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_FLASH:
				hpc_led_info->state = HPC_LED_ON;
				break;
			}
			break;
		case HPC_ACTIVE_LED:
			switch (schpc_p->schpc_slot[slot].led.led_service) {
			case LED_OFF:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_ON:
				hpc_led_info->state = HPC_LED_ON;
				break;
			case LED_FLASH:
				hpc_led_info->state = HPC_LED_BLINK;
				break;
			}
			break;
		default:
			SCHPC_DEBUG1(D_IOC_CONTROL, "schpc_cpci_control() - "
			    "Invalid LED %x", hpc_led_info->led);

			mutex_enter(&schpc_p->schpc_mutex);
			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_EXECUTING;
			cv_signal(&schpc_p->schpc_cv);
			mutex_exit(&schpc_p->schpc_mutex);

			return (HPC_ERR_FAILED);
		}

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_SET_LED_STATE:
		hpc_led_info = (hpc_led_info_t *)arg;

		SCHPC_DEBUG1(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_SET_LED_STATE hpc_led_info=%p",
		    (void *)hpc_led_info);

		switch (hpc_led_info->led) {
		case HPC_FAULT_LED:
			switch (hpc_led_info->state) {
			case HPC_LED_OFF:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_OFF;
				setslot.slot_led_fault = PCIMSG_LED_OFF;
				break;
			case HPC_LED_ON:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_ON;
				setslot.slot_led_fault = PCIMSG_LED_ON;
				break;
			case HPC_LED_BLINK:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_FLASH;
				setslot.slot_led_fault = PCIMSG_LED_FLASH;
				break;
			}
			break;
		case HPC_POWER_LED:
			switch (hpc_led_info->state) {
			case HPC_LED_OFF:
				schpc_p->schpc_slot[slot].led.led_power =
				    LED_OFF;
				setslot.slot_led_power = PCIMSG_LED_OFF;
				break;
			case HPC_LED_ON:
				schpc_p->schpc_slot[slot].led.led_power =
				    LED_ON;
				setslot.slot_led_power = PCIMSG_LED_ON;
				break;
			case HPC_LED_BLINK:
				schpc_p->schpc_slot[slot].led.led_power =
				    LED_FLASH;
				setslot.slot_led_power = PCIMSG_LED_FLASH;
				break;
			}
			break;
		case HPC_ATTN_LED:
			switch (hpc_led_info->state) {
			case HPC_LED_OFF:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_OFF;
				setslot.slot_led_fault = PCIMSG_LED_OFF;
				break;
			case HPC_LED_ON:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_FLASH;
				setslot.slot_led_fault = PCIMSG_LED_FLASH;
				break;
			case HPC_LED_BLINK:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_FLASH;
				setslot.slot_led_fault = PCIMSG_LED_FLASH;
				break;
			}
			break;
		case HPC_ACTIVE_LED:
			switch (hpc_led_info->state) {
			case HPC_LED_OFF:
				schpc_p->schpc_slot[slot].led.led_service =
				    LED_OFF;
				setslot.slot_led_service = PCIMSG_LED_OFF;
				break;
			case HPC_LED_ON:
				schpc_p->schpc_slot[slot].led.led_service =
				    LED_ON;
				setslot.slot_led_service = PCIMSG_LED_ON;
				break;
			case HPC_LED_BLINK:
				schpc_p->schpc_slot[slot].led.led_service =
				    LED_FLASH;
				setslot.slot_led_service = PCIMSG_LED_FLASH;
				break;
			}
			break;
		default:
			mutex_enter(&schpc_p->schpc_mutex);
			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_EXECUTING;
			cv_signal(&schpc_p->schpc_cv);
			mutex_exit(&schpc_p->schpc_mutex);

			return (0);
		}

		(void) schpc_setslotstatus(expander, board, slot, &setslot);

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_GET_SLOT_STATE: {
		hpc_slot_state_t	*hpc_slot_state;

		hpc_slot_state = (hpc_slot_state_t *)arg;

		SCHPC_DEBUG1(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_GET_SLOT_STATE hpc_slot_state=%p",
		    (void *)hpc_slot_state);

		rval = schpc_getslotstatus(expander, board, slot, &slotstatus);

		if (!rval) {

			if (slotstatus.slot_replystatus != PCIMSG_REPLY_GOOD) {
				return (HPC_ERR_FAILED);
			}

			if (slotstatus.slot_empty == PCIMSG_ON) {
				*hpc_slot_state = HPC_SLOT_EMPTY;
				SCHPC_DEBUG0(D_IOC_CONTROL, "Slot Empty");
			} else if (slotstatus.slot_power_on == PCIMSG_ON) {
				*hpc_slot_state = HPC_SLOT_CONNECTED;
				SCHPC_DEBUG0(D_IOC_CONTROL, "Slot Connected");
				schpc_p->schpc_slot[slot].state |=
				    SCHPC_SLOTSTATE_CONNECTED;
			} else {
				*hpc_slot_state = HPC_SLOT_DISCONNECTED;
				SCHPC_DEBUG0(D_IOC_CONTROL,
				    "Slot Disconnected");
				schpc_p->schpc_slot[slot].state &=
				    ~SCHPC_SLOTSTATE_CONNECTED;
			}
		} else {
			SCHPC_DEBUG0(D_IOC_CONTROL, "Mailbox Command failed");

			mutex_enter(&schpc_p->schpc_mutex);
			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_EXECUTING;
			cv_signal(&schpc_p->schpc_cv);
			mutex_exit(&schpc_p->schpc_mutex);

			return (HPC_ERR_FAILED);
		}

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);
	}
	case HPC_CTRL_GET_BOARD_TYPE: {
		hpc_board_type_t	*hpc_board_type;

		hpc_board_type = (hpc_board_type_t *)arg;

		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_GET_BOARD_TYPE");

		/*
		 * The HPC driver does not know what board type
		 * is plugged in.
		 */
		*hpc_board_type = HPC_BOARD_CPCI_HS;

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	}
	case HPC_CTRL_DEV_CONFIGURED:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_DEV_CONFIGURED");

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_DEV_UNCONFIGURED:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_DEV_UNCONFIGURED");

		if (schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_ENUM) {
			/*
			 * When the occupant is unconfigured, power
			 * down the slot.
			 */
			rval = schpc_disconnect((caddr_t)schpc_p,
			    schpc_p->schpc_slot[slot].slot_handle,
			    0, 0);

			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_ENUM;
		}

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_ENABLE_AUTOCFG:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_ENABLE_AUTOCFG");

		schpc_p->schpc_slot[slot].state |=
		    SCHPC_SLOTSTATE_AUTOCFG_ENABLE;

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_DISABLE_AUTOCFG:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_DISABLE_AUTOCFG");
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_AUTOCFG_ENABLE;

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_DISABLE_ENUM:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_DISABLE_ENUM");

		setslot.slot_disable_ENUM = PCIMSG_ON;

		rval = schpc_setslotstatus(expander, board, slot, &setslot);

		if (rval)
			rval = HPC_ERR_FAILED;

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (rval);

	case HPC_CTRL_ENABLE_ENUM:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "HPC_CTRL_ENABLE_ENUM");

		setslot.slot_enable_ENUM = PCIMSG_ON;

		rval = schpc_setslotstatus(expander, board, slot, &setslot);

		if (rval)
			rval = HPC_ERR_FAILED;

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (rval);

	default:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_cpci_control() - "
		    "****NOT SUPPORTED CONTROL CMD");

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (HPC_ERR_NOTSUPPORTED);
	}
}

/*
 * schpc_pci_control
 *
 * Called by Hot Plug Services to perform a attachment point specific
 * on a Hot Pluggable Standard PCI Slot.
 */
/*ARGSUSED*/
static int
schpc_pci_control(caddr_t ops_arg, hpc_slot_t slot_hdl, int request,
    caddr_t arg)
{
	int		rval;
	int		expander, board, slot;
	pci_setslot_t	setslot;
	pci_getslot_t   slotstatus;
	hpc_led_info_t	*hpc_led_info;

	SCHPC_DEBUG3(D_IOC_CONTROL,
	    "schpc_pci_control(op_args=%p slot_hdl=%p request=%x)",
	    (void *)ops_arg, (void *)slot_hdl, request);

	mutex_enter(&schpc_p->schpc_mutex);

	slot = schpc_slot_get_index(schpc_p, slot_hdl);

	if (!(schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_HPCINITED)) {
		SCHPC_DEBUG0(D_IOC_CONNECT,
		    "schpc_disconnect - HPC Not Inited");
		mutex_exit(&schpc_p->schpc_mutex);
		return (HPC_ERR_FAILED);
	}

	/*
	 * Block if another thread is executing a HPC command.
	 */
	while (schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_EXECUTING) {
		cv_wait(&schpc_p->schpc_cv, &schpc_p->schpc_mutex);
	}

	schpc_p->schpc_slot[slot].state |= SCHPC_SLOTSTATE_EXECUTING;

	mutex_exit(&schpc_p->schpc_mutex);

	expander = schpc_p->schpc_slot[slot].expander; /* get expander */
	board = schpc_p->schpc_slot[slot].board; /* get board */

	/*
	 * Initialize Set Slot Command.
	 */
	schpc_init_setslot_message(&setslot);

	/*
	 * Initialize LED to last know state.
	 */
	switch (schpc_p->schpc_slot[slot].led.led_power) {
	case LED_ON:
		setslot.slot_led_power = PCIMSG_LED_ON;
		break;
	case LED_OFF:
		setslot.slot_led_power = PCIMSG_LED_OFF;
		break;
	case LED_FLASH:
		setslot.slot_led_power = PCIMSG_LED_FLASH;
		break;
	}

	switch (schpc_p->schpc_slot[slot].led.led_service) {
	case LED_ON:
		setslot.slot_led_service = PCIMSG_LED_ON;
		break;
	case LED_OFF:
		setslot.slot_led_service = PCIMSG_LED_OFF;
		break;
	case LED_FLASH:
		setslot.slot_led_service = PCIMSG_LED_FLASH;
		break;
	}

	switch (schpc_p->schpc_slot[slot].led.led_fault) {
	case LED_ON:
		setslot.slot_led_fault = PCIMSG_LED_ON;
		break;
	case LED_OFF:
		setslot.slot_led_fault = PCIMSG_LED_OFF;
		break;
	case LED_FLASH:
		setslot.slot_led_fault = PCIMSG_LED_FLASH;
		break;
	}

	switch (request) {


	case HPC_CTRL_GET_SLOT_STATE: {
		hpc_slot_state_t	*hpc_slot_state;

		hpc_slot_state = (hpc_slot_state_t *)arg;

		SCHPC_DEBUG1(D_IOC_CONTROL, "schpc_pci_control() - "
		    "HPC_CTRL_GET_SLOT_STATE hpc_slot_state=%p",
		    (void *)hpc_slot_state);

		rval = schpc_getslotstatus(expander, board, slot, &slotstatus);

		if (!rval) {

			if (slotstatus.slot_replystatus != PCIMSG_REPLY_GOOD) {

				mutex_enter(&schpc_p->schpc_mutex);
				schpc_p->schpc_slot[slot].state &=
				    ~SCHPC_SLOTSTATE_EXECUTING;
				cv_signal(&schpc_p->schpc_cv);
				mutex_exit(&schpc_p->schpc_mutex);

				return (HPC_ERR_FAILED);
			}

			if (slotstatus.slot_empty == PCIMSG_ON) {
				*hpc_slot_state = HPC_SLOT_EMPTY;
				SCHPC_DEBUG0(D_IOC_CONTROL, "Slot Empty");
			} else if (slotstatus.slot_power_on == PCIMSG_ON) {
				*hpc_slot_state = HPC_SLOT_CONNECTED;
				SCHPC_DEBUG0(D_IOC_CONTROL, "Slot Connected");
				schpc_p->schpc_slot[slot].state |=
				    SCHPC_SLOTSTATE_CONNECTED;
			} else {
				*hpc_slot_state = HPC_SLOT_DISCONNECTED;
				SCHPC_DEBUG0(D_IOC_CONTROL,
				    "Slot Disconnected");
				schpc_p->schpc_slot[slot].state &=
				    ~SCHPC_SLOTSTATE_CONNECTED;
			}
		} else {
			SCHPC_DEBUG0(D_IOC_CONTROL, "Mailbox Command failed");

			mutex_enter(&schpc_p->schpc_mutex);
			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_EXECUTING;
			cv_signal(&schpc_p->schpc_cv);
			mutex_exit(&schpc_p->schpc_mutex);

			return (HPC_ERR_FAILED);
		}

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);
	}
	case HPC_CTRL_GET_BOARD_TYPE: {
		hpc_board_type_t	*hpc_board_type;

		hpc_board_type = (hpc_board_type_t *)arg;

		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_pci_control() - "
		    "HPC_CTRL_GET_BOARD_TYPE");


		/*
		 * The HPC driver does not know what board type
		 * is plugged in.
		 */
		*hpc_board_type = HPC_BOARD_PCI_HOTPLUG;

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	}
	case HPC_CTRL_DEV_UNCONFIG_START:
	case HPC_CTRL_DEV_CONFIG_START:
	case HPC_CTRL_DEV_CONFIGURED:
	case HPC_CTRL_DEV_UNCONFIGURED:
		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_GET_LED_STATE:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_pci_control() - "
		    "HPC_CTRL_GET_LED_STATE");
		hpc_led_info = (hpc_led_info_t *)arg;

		switch (hpc_led_info->led) {
		case HPC_FAULT_LED:
			switch (schpc_p->schpc_slot[slot].led.led_fault) {
			case LED_OFF:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_ON:
				hpc_led_info->state = HPC_LED_ON;
				break;
			case LED_FLASH:
				hpc_led_info->state = HPC_LED_BLINK;
				break;
			}
			break;

		case HPC_POWER_LED:
			switch (schpc_p->schpc_slot[slot].led.led_power) {
			case LED_OFF:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_ON:
				hpc_led_info->state = HPC_LED_ON;
				break;
			case LED_FLASH:
				hpc_led_info->state = HPC_LED_BLINK;
				break;
			}
			break;
		case HPC_ATTN_LED:
			switch (schpc_p->schpc_slot[slot].led.led_fault) {
			case LED_OFF:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_ON:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_FLASH:
				hpc_led_info->state = HPC_LED_ON;
				break;
			}
			break;
		case HPC_ACTIVE_LED:
			switch (schpc_p->schpc_slot[slot].led.led_service) {
			case LED_OFF:
				hpc_led_info->state = HPC_LED_OFF;
				break;
			case LED_ON:
				hpc_led_info->state = HPC_LED_ON;
				break;
			case LED_FLASH:
				hpc_led_info->state = HPC_LED_BLINK;
				break;
			}
			break;
		default:
			SCHPC_DEBUG1(D_IOC_CONTROL, "schpc_pci_control() - "
			    "Invalid LED %x", hpc_led_info->led);

			mutex_enter(&schpc_p->schpc_mutex);
			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_EXECUTING;
			cv_signal(&schpc_p->schpc_cv);
			mutex_exit(&schpc_p->schpc_mutex);

			return (HPC_ERR_FAILED);
		}

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_SET_LED_STATE:
		hpc_led_info = (hpc_led_info_t *)arg;

		SCHPC_DEBUG1(D_IOC_CONTROL, "schpc_pci_control() - "
		    "HPC_CTRL_SET_LED_STATE hpc_led_info=%p",
		    (void *)hpc_led_info);

		switch (hpc_led_info->led) {
		case HPC_FAULT_LED:
			switch (hpc_led_info->state) {
			case HPC_LED_OFF:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_OFF;
				setslot.slot_led_fault = PCIMSG_LED_OFF;
				break;
			case HPC_LED_ON:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_ON;
				setslot.slot_led_fault = PCIMSG_LED_ON;
				break;
			case HPC_LED_BLINK:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_FLASH;
				setslot.slot_led_fault = PCIMSG_LED_FLASH;
				break;
			}
			break;
		case HPC_POWER_LED:
			switch (hpc_led_info->state) {
			case HPC_LED_OFF:
				schpc_p->schpc_slot[slot].led.led_power =
				    LED_OFF;
				setslot.slot_led_power = PCIMSG_LED_OFF;
				break;
			case HPC_LED_ON:
				schpc_p->schpc_slot[slot].led.led_power =
				    LED_ON;
				setslot.slot_led_power = PCIMSG_LED_ON;
				break;
			case HPC_LED_BLINK:
				schpc_p->schpc_slot[slot].led.led_power =
				    LED_FLASH;
				setslot.slot_led_power = PCIMSG_LED_FLASH;
				break;
			}
			break;
		case HPC_ATTN_LED:
			switch (hpc_led_info->state) {
			case HPC_LED_OFF:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_OFF;
				setslot.slot_led_fault = PCIMSG_LED_OFF;
				break;
			case HPC_LED_ON:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_FLASH;
				setslot.slot_led_fault = PCIMSG_LED_FLASH;
				break;
			case HPC_LED_BLINK:
				schpc_p->schpc_slot[slot].led.led_fault =
				    LED_FLASH;
				setslot.slot_led_fault = PCIMSG_LED_FLASH;
				break;
			}
			break;
		case HPC_ACTIVE_LED:
			switch (hpc_led_info->state) {
			case HPC_LED_OFF:
				schpc_p->schpc_slot[slot].led.led_service =
				    LED_OFF;
				setslot.slot_led_service = PCIMSG_LED_OFF;
				break;
			case HPC_LED_ON:
				schpc_p->schpc_slot[slot].led.led_service =
				    LED_ON;
				setslot.slot_led_service = PCIMSG_LED_ON;
				break;
			case HPC_LED_BLINK:
				schpc_p->schpc_slot[slot].led.led_service =
				    LED_FLASH;
				setslot.slot_led_service = PCIMSG_LED_FLASH;
				break;
			}
			break;
		default:
			mutex_enter(&schpc_p->schpc_mutex);
			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_EXECUTING;
			cv_signal(&schpc_p->schpc_cv);
			mutex_exit(&schpc_p->schpc_mutex);

			return (0);
		}

		(void) schpc_setslotstatus(expander, board, slot, &setslot);

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_ENABLE_AUTOCFG:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_pci_control() - "
		    "HPC_CTRL_ENABLE_AUTOCFG");

		schpc_p->schpc_slot[slot].state |=
		    SCHPC_SLOTSTATE_AUTOCFG_ENABLE;

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_DISABLE_AUTOCFG:
		SCHPC_DEBUG0(D_IOC_CONTROL, "schpc_pci_control() - "
		    "HPC_CTRL_DISABLE_AUTOCFG");
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_AUTOCFG_ENABLE;

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (0);

	case HPC_CTRL_DISABLE_ENUM:
	case HPC_CTRL_ENABLE_ENUM:
	default:
		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		return (HPC_ERR_NOTSUPPORTED);
	}
}

/*
 * schpc_test
 *
 * Tests the slot.
 */
/*ARGSUSED*/
static void
schpc_test(caddr_t ops_arg, int slot, void *data, uint_t flags)
{
	pci_getslot_t	slotstatus;
	pci_setslot_t	setslot;
	int		expander, board;
	int		rval;
	int		retry = 1;

	SCHPC_DEBUG2(D_IOC_TEST, "schpc_test(op_args=%p slot=%x)",
	    (void *)ops_arg, SCHPC_SLOT_NUM(slot));

	SCHPC_DEBUG3(D_IOC_TEST,
	    "    schpc_test() Expander=%d Board=%d Slot=%d",
	    schpc_p->schpc_slot[slot].expander,
	    schpc_p->schpc_slot[slot].board, SCHPC_SLOT_NUM(slot));

	expander = schpc_p->schpc_slot[slot].expander;
	board = schpc_p->schpc_slot[slot].board;

restart_test:
	/*
	 * Initial the slot with its occupant and receptacle in good condition.
	 */
	schpc_p->schpc_slot[slot].state |=  SCHPC_SLOTSTATE_REC_GOOD;
	schpc_p->schpc_slot[slot].state |=  SCHPC_SLOTSTATE_OCC_GOOD;


	rval = schpc_getslotstatus(expander, board, slot, &slotstatus);

	if (rval) {
		/*
		 * System Controller/Mailbox failure.
		 */
		cmn_err(CE_WARN, "schpc - Hot Plug Slot Test Failed on "
		    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : Unable to "
		    "Communicate with System Controller", expander, board,
		    SCHPC_SLOT_NUM(slot), schpc_p->schpc_slot[slot].ap_id);

		schpc_p->schpc_slot[slot].state &=  ~SCHPC_SLOTSTATE_REC_GOOD;
		return;
	}

	if (slotstatus.slot_replystatus != PCIMSG_REPLY_GOOD) {

		cmn_err(CE_WARN, "schpc - Expander %d Board %d PCI Slot %d "
		    "is not hot pluggable\n", expander, board,
		    SCHPC_SLOT_NUM(slot));

		schpc_p->schpc_slot[slot].state &=  ~SCHPC_SLOTSTATE_REC_GOOD;
		return;
	}

	switch (slotstatus.slot_condition) {
	case PCIMSG_SLOTCOND_OCC_FAIL:
		cmn_err(CE_WARN, "schpc - Hot Plug Slot Test Failed on "
		    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
		    "System Controller/Occupant Failed",
		    expander, board, SCHPC_SLOT_NUM(slot),
		    schpc_p->schpc_slot[slot].ap_id);

		schpc_setslotled(expander, board, slot,
		    (POWER_LED_OFF | SERVICE_LED_ON | FAULT_LED_ON));

		schpc_p->schpc_slot[slot].state &=  ~SCHPC_SLOTSTATE_OCC_GOOD;
		return;
	case PCIMSG_SLOTCOND_REC_FAIL:
		cmn_err(CE_WARN, "schpc - Hot Plug Slot Test Failed on "
		    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
		    "System Controller/Receptacle Failed",
		    expander, board, SCHPC_SLOT_NUM(slot),
		    schpc_p->schpc_slot[slot].ap_id);

		schpc_setslotled(expander, board, slot,
		    (POWER_LED_OFF | SERVICE_LED_OFF | FAULT_LED_ON));

		schpc_p->schpc_slot[slot].state &=  ~SCHPC_SLOTSTATE_REC_GOOD;
		return;
	case PCIMSG_SLOTCOND_NOHOTPLUG:
		cmn_err(CE_WARN, "schpc - Expander %d Board %d PCI Slot %d "
		    "is not hot pluggable\n", expander, board,
		    SCHPC_SLOT_NUM(slot));

		schpc_p->schpc_slot[slot].state &=  ~SCHPC_SLOTSTATE_REC_GOOD;
		return;
	}

	if (slotstatus.slot_power_on) {
		schpc_p->schpc_slot[slot].led.led_power = PCIMSG_LED_ON;

		if (!slotstatus.slot_HEALTHY) {
			/*
			 * cPCI Adapter is not asserting HEALTHY#.
			 */
			cmn_err(CE_WARN, "schpc - Hot Plug Slot Test Failed on "
			    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
			    "PCI adapter not HEALTHY", expander, board,
			    SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot,
			    (POWER_LED_ON | SERVICE_LED_OFF | FAULT_LED_ON));

			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_OCC_GOOD;

			return;
		}

		if (!slotstatus.slot_powergood) {
			/*
			 * PCI Power Input is not good.
			 */
			cmn_err(CE_WARN, "schpc - Hot Plug Slot Test Failed on "
			    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
			    "System Controller PCI Power Input Not Good",
			    expander, board, SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot,
			    (POWER_LED_ON | SERVICE_LED_OFF | FAULT_LED_ON));

			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_OCC_GOOD;

			return;
		}

		if (slotstatus.slot_powerfault) {
			/*
			 * PCI Power Fault.
			 */
			cmn_err(CE_WARN, "schpc - Hot Plug Slot Test Failed on "
			    "Expander %d Board %d PCI Slot %d - Ap_Id=%s : "
			    "System Controller PCI Power Fault",
			    expander, board, SCHPC_SLOT_NUM(slot),
			    schpc_p->schpc_slot[slot].ap_id);

			schpc_setslotled(expander, board, slot,
			    (POWER_LED_ON | SERVICE_LED_OFF | FAULT_LED_ON));

			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_OCC_GOOD;

			return;
		}
	}

	SCHPC_DEBUG0(D_IOC_TEST, "schpc_test() Test Successful - ret 0");

	/*
	 * Is the slot empty?
	 */
	if (slotstatus.slot_empty) {
		SCHPC_DEBUG0(D_IOC_TEST, "schpc_test() Slot Empty");

		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_PRESENT;

		if (slotstatus.slot_power_on) {

			SCHPC_DEBUG0(D_IOC_TEST, "schpc_test() Empty Slot "
			    "is powered ON");

			/*
			 * Tests will be retried once after powering off
			 * an empty slot.
			 */
			if (retry) {

				/*
				 * Turn off the slot and restart test.
				 */
				SCHPC_DEBUG0(D_IOC_TEST, "schpc_test() "
				    "Turning Empty Slot OFF");

				schpc_init_setslot_message(&setslot);
				setslot.slot_power_off = PCIMSG_ON;
				(void) schpc_setslotstatus(
				    expander, board, slot, &setslot);

				retry = 0;

				goto restart_test;
			}
		}
	} else {
		SCHPC_DEBUG0(D_IOC_TEST, "schpc_test() Adapter Present");

		if (!slotstatus.slot_power_on) {
			if (retry) {
				/*
				 * If there is a cassette present and the
				 * power is off, try turning the power on and
				 * restart the test. This allows access to
				 * the FRUID when an empty cassette is
				 * installed.
				 */
				SCHPC_DEBUG0(D_IOC_TEST,
				    "schpc_test() Power On Adapter");
				schpc_init_setslot_message(&setslot);
				setslot.slot_power_on = PCIMSG_ON;
				(void) schpc_setslotstatus(
				    expander, board, slot, &setslot);
				retry = 0;
				goto restart_test;
			}
		}

		schpc_p->schpc_slot[slot].state |=
		    SCHPC_SLOTSTATE_PRESENT;
	}

	/*
	 * Is the slot powered up?
	 */
	schpc_init_setslot_message(&setslot);

	if (slotstatus.slot_power_on) {
		SCHPC_DEBUG0(D_IOC_TEST, "schpc_test() Slot Power On");

		schpc_p->schpc_slot[slot].state |=
		    SCHPC_SLOTSTATE_CONNECTED;

		setslot.slot_led_power = PCIMSG_LED_ON;
		setslot.slot_led_service = PCIMSG_LED_OFF;
		setslot.slot_enable_ENUM = PCIMSG_ON;
		setslot.slot_enable_HEALTHY = PCIMSG_ON;
	} else {
		SCHPC_DEBUG0(D_IOC_TEST, "schpc_test() Slot Power Off");

		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_CONNECTED;

		setslot.slot_led_power = PCIMSG_LED_OFF;
		setslot.slot_led_service = PCIMSG_LED_ON;
		setslot.slot_disable_ENUM = PCIMSG_ON;
		setslot.slot_disable_HEALTHY = PCIMSG_ON;
	}

	setslot.slot_led_fault = PCIMSG_LED_OFF;

	(void) schpc_setslotstatus(expander, board, slot, &setslot);

	/*
	 * Save LED State.
	 */
	switch (setslot.slot_led_power) {
	case PCIMSG_LED_ON:
		schpc_p->schpc_slot[slot].led.led_power = LED_ON;
		break;
	case PCIMSG_LED_OFF:
		schpc_p->schpc_slot[slot].led.led_power = LED_OFF;
		break;
	case PCIMSG_LED_FLASH:
		schpc_p->schpc_slot[slot].led.led_power = LED_FLASH;
		break;
	}
	switch (setslot.slot_led_service) {
	case PCIMSG_LED_ON:
		schpc_p->schpc_slot[slot].led.led_service = LED_ON;
		break;
	case PCIMSG_LED_OFF:
		schpc_p->schpc_slot[slot].led.led_service = LED_OFF;
		break;
	case PCIMSG_LED_FLASH:
		schpc_p->schpc_slot[slot].led.led_service = LED_FLASH;
		break;
	}
	switch (setslot.slot_led_fault) {
	case PCIMSG_LED_ON:
		schpc_p->schpc_slot[slot].led.led_fault = LED_ON;
		break;
	case PCIMSG_LED_OFF:
		schpc_p->schpc_slot[slot].led.led_fault = LED_OFF;
		break;
	case PCIMSG_LED_FLASH:
		schpc_p->schpc_slot[slot].led.led_fault = LED_FLASH;
		break;
	}
}


/*
 * schpc_event_handler
 *
 * Placed on the schpc_event_taskq by schpc_event_filter when an
 * unsolicited MBOXSC_MSG_EVENT is received from the SC.  It handles
 * things like power insertion/removal, ENUM#, etc.
 */
static void
schpc_event_handler(void *arg)
{
	pci_getslot_t	slotstatus;
	uint8_t		expander, board, slot;
	int		rval;
	pcimsg_t *event = (pcimsg_t *)arg;

	/*
	 * OK, we got an event message. Since the event message only tells
	 * us something has changed and not changed to what, we need to get
	 * the current slot status to find how WHAT was change to WHAT.
	 */

	slot = event->pcimsg_slot;
	expander = event->pcimsg_node; /* get expander */
	board = event->pcimsg_board; /* get board */

	SCHPC_DEBUG3(D_EVENT,
	    "schpc_event_handler() - exp=%d board=%d slot=%d",
	    expander, board, slot);

	/* create a slot table index */
	slot = SCHPC_MAKE_SLOT_INDEX2(expander, slot);

	SCHPC_DEBUG1(D_EVENT,
	    "schpc_event_handler() - expanded slot %d", slot);

	if (schpc_p == NULL) {
		cmn_err(CE_WARN, "schpc/Event Handler - Can not find schpc");
		kmem_free(event, sizeof (pcimsg_t));
		return;
	}

	mutex_enter(&schpc_p->schpc_mutex);

	if (!(schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_HPCINITED)) {
		SCHPC_DEBUG0(D_EVENT, "schpc_event_handler - HPC Not Inited");
		mutex_exit(&schpc_p->schpc_mutex);
		kmem_free(event, sizeof (pcimsg_t));
		return;
	}
	/*
	 * Block if another thread is executing a HPC command.
	 */
	while (schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_EXECUTING) {
		SCHPC_DEBUG0(D_EVENT, "schpc_event_handler - Slot is busy");
		cv_wait(&schpc_p->schpc_cv, &schpc_p->schpc_mutex);
	}

	schpc_p->schpc_slot[slot].state |= SCHPC_SLOTSTATE_EXECUTING;

	mutex_exit(&schpc_p->schpc_mutex);

	rval = schpc_getslotstatus(expander, board, slot, &slotstatus);

	if (rval) {
		cmn_err(CE_WARN, "schpc/Event Handler - Can not get status "
		    "for expander=%d board=%d slot=%d\n",
		    expander, board, SCHPC_SLOT_NUM(slot));

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);
		kmem_free(event, sizeof (pcimsg_t));
		return;
	}

	if (slotstatus.slot_replystatus != PCIMSG_REPLY_GOOD) {
		cmn_err(CE_WARN, "schpc/Event Handler - Can not get good "
		    "status for expander=%d board=%d slot=%d\n",
		    expander, board, SCHPC_SLOT_NUM(slot));

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		kmem_free(event, sizeof (pcimsg_t));
		return;
	}

	SCHPC_DEBUG3(D_EVENT, "Event Received - Expander %d Board %d Slot %d",
	    expander, board, SCHPC_SLOT_NUM(slot));

	if (schpc_p->schpc_slot[slot].slot_ops == NULL) {
		SCHPC_DEBUG3(D_EVENT, "schpc/Event Handler - Received event "
		    "for unregistered slot for expander=%d board=%d slot=%d",
		    expander, board, SCHPC_SLOT_NUM(slot));

		mutex_enter(&schpc_p->schpc_mutex);
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_EXECUTING;
		cv_signal(&schpc_p->schpc_cv);
		mutex_exit(&schpc_p->schpc_mutex);

		kmem_free(event, sizeof (pcimsg_t));
		return;
	}

	/* Slot Power Event */

	if (event->pcimsg_type.pcimsg_slotevent.slot_power) {
		SCHPC_DEBUG0(D_EVENT, "Event Type: Slot Power Event");
		/*
		 * The SC may have changed to slot power status.
		 */
		if (slotstatus.slot_power_on) {
			schpc_p->schpc_slot[slot].state |=
			    SCHPC_SLOTSTATE_CONNECTED;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_POWER_ON, 0);
		} else {
			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_CONNECTED;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_POWER_OFF, 0);
		}
	}

	/* Adapter Insertion/Removal Event */

	if (event->pcimsg_type.pcimsg_slotevent.slot_presence) {
		if (slotstatus.slot_empty == PCIMSG_ON) {

			/* Adapter Removed */

			SCHPC_DEBUG0(D_EVENT, "Event Type: Adapter Removed");

			if (schpc_p->schpc_slot[slot].state &
			    SCHPC_SLOTSTATE_CONNECTED) {
				/*
				 * If the adapter has been removed while
				 * there the slot is connected, it could be
				 * due to a ENUM handling.
				 */
				cmn_err(CE_WARN, "Card removed from "
				    "powered on slot at "
				    "expander=%d board=%d slot=%d\n",
				    expander, board, SCHPC_SLOT_NUM(slot));

				schpc_p->schpc_slot[slot].state &=
				    ~SCHPC_SLOTSTATE_EXECUTING;
				rval = schpc_disconnect((caddr_t)schpc_p,
				    schpc_p->schpc_slot[slot].slot_handle,
				    0, 0);
				mutex_enter(&schpc_p->schpc_mutex);
				while (schpc_p->schpc_slot[slot].state &
				    SCHPC_SLOTSTATE_EXECUTING) {
					SCHPC_DEBUG0(D_EVENT,
					    "schpc_event_handler - "
					    "Slot is busy");
					cv_wait(&schpc_p->schpc_cv,
					    &schpc_p->schpc_mutex);
				}

				schpc_p->schpc_slot[slot].state |=
				    SCHPC_SLOTSTATE_EXECUTING;

				mutex_exit(&schpc_p->schpc_mutex);
			}
			schpc_p->schpc_slot[slot].state |=
			    SCHPC_SLOTSTATE_OCC_GOOD;

			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_PRESENT;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_REMOVAL, 0);
		} else {

			/* Adapter Inserted */

			SCHPC_DEBUG0(D_EVENT, "Event Type: Adapter Inserted");

			if (schpc_p->schpc_slot[slot].state &
			    SCHPC_SLOTSTATE_PRESENT) {
				/*
				 * If the adapter is already present
				 * throw the this event away.
				 */

				SCHPC_DEBUG0(D_EVENT,
				    "Adapter is already present");

				mutex_enter(&schpc_p->schpc_mutex);
				schpc_p->schpc_slot[slot].state &=
				    ~SCHPC_SLOTSTATE_EXECUTING;
				cv_signal(&schpc_p->schpc_cv);
				mutex_exit(&schpc_p->schpc_mutex);

				kmem_free(event, sizeof (pcimsg_t));
				return;
			}

			schpc_p->schpc_slot[slot].state |=
			    SCHPC_SLOTSTATE_PRESENT;

			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_CONNECTED;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_INSERTION, 0);

			if (schpc_p->schpc_slot[slot].state &
			    SCHPC_SLOTSTATE_AUTOCFG_ENABLE) {
				SCHPC_DEBUG0(D_EVENT, "Auto Configuration "
				    "(Connect/Configure) Started");

				schpc_p->schpc_slot[slot].state &=
				    ~SCHPC_SLOTSTATE_EXECUTING;

				rval = schpc_connect((caddr_t)schpc_p,
				    schpc_p->schpc_slot[slot].slot_handle,
				    0, 0);

				if (rval) {
					cmn_err(CE_WARN, "schpc/Event Handler -"
					    " Can not connect");

					mutex_enter(&schpc_p->schpc_mutex);
					schpc_p->schpc_slot[slot].state &=
					    ~SCHPC_SLOTSTATE_EXECUTING;
					cv_signal(&schpc_p->schpc_cv);
					mutex_exit(&schpc_p->schpc_mutex);

					kmem_free(event, sizeof (pcimsg_t));
					return;
				}
				mutex_enter(&schpc_p->schpc_mutex);
				while (schpc_p->schpc_slot[slot].state &
				    SCHPC_SLOTSTATE_EXECUTING) {
					SCHPC_DEBUG0(D_EVENT,
					    "schpc_event_handler - "
					    "Slot is busy");
					cv_wait(&schpc_p->schpc_cv,
					    &schpc_p->schpc_mutex);
				}

				schpc_p->schpc_slot[slot].state |=
				    SCHPC_SLOTSTATE_EXECUTING;

				mutex_exit(&schpc_p->schpc_mutex);

				(void) hpc_slot_event_notify(
				    schpc_p->schpc_slot[slot].slot_handle,
				    HPC_EVENT_SLOT_CONFIGURE, 0);
			} else {
				schpc_setslotled(expander, board, slot,
				    SERVICE_LED_ON);
			}
		}
	}

	/* ENUM# signal change event */

	if (event->pcimsg_type.pcimsg_slotevent.slot_ENUM) {
		/*
		 * ENUM should only be received to the adapter remove
		 * procedure.
		 */

		SCHPC_DEBUG0(D_EVENT, "Event Type: ENUM Asserted");

		schpc_setslotled(expander, board, slot, FAULT_LED_FLASH);

		schpc_p->schpc_slot[slot].state |= SCHPC_SLOTSTATE_ENUM;

		(void) hpc_slot_event_notify(
		    schpc_p->schpc_slot[slot].slot_handle,
		    HPC_EVENT_SLOT_ENUM, 0);
	}

	/* HEALTHY# signal change event */

	if (event->pcimsg_type.pcimsg_slotevent.slot_HEALTHY) {

		if (!slotstatus.slot_HEALTHY) {

			SCHPC_DEBUG0(D_EVENT, "Event Type: !HEALTHY ASSERTED");

			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_OCC_GOOD;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_NOT_HEALTHY, 0);

			schpc_setslotled(expander, board, slot, FAULT_LED_ON);
		} else {
			SCHPC_DEBUG0(D_EVENT, "Event Type: HEALTHY OK");

			schpc_p->schpc_slot[slot].state |=
			    SCHPC_SLOTSTATE_OCC_GOOD;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_HEALTHY_OK, 0);

			schpc_setslotled(expander, board, slot,
			    FAULT_LED_OFF);
		}
	}

	/* Good Power change event */

	if (event->pcimsg_type.pcimsg_slotevent.slot_powergood) {
		if (slotstatus.slot_powergood == PCIMSG_ON) {

			SCHPC_DEBUG0(D_EVENT,
			    "Event Type: Slot Power Good Detected");

			schpc_p->schpc_slot[slot].state |=
			    SCHPC_SLOTSTATE_OCC_GOOD;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_HEALTHY_OK, 0);

			schpc_setslotled(expander, board, slot,
			    FAULT_LED_OFF);
		} else {
			SCHPC_DEBUG0(D_EVENT, "Event Type: Slot Power Not Good "
			    "Detected");

			if (schpc_p->schpc_slot[slot].state &
			    SCHPC_SLOTSTATE_CONNECTED) {

				SCHPC_DEBUG0(D_EVENT, "Slot Power Not Good: "
				    "power failed");

				schpc_p->schpc_slot[slot].state &=
				    ~SCHPC_SLOTSTATE_OCC_GOOD;

				(void) hpc_slot_event_notify(
				    schpc_p->schpc_slot[slot].slot_handle,
				    HPC_EVENT_SLOT_NOT_HEALTHY, 0);

				schpc_setslotled(expander, board, slot,
				    FAULT_LED_ON);
			}
		}
	}

	/* Power Fault change event */

	if (event->pcimsg_type.pcimsg_slotevent.slot_powerfault) {
		if (slotstatus.slot_powerfault == PCIMSG_ON) {

			SCHPC_DEBUG0(D_EVENT, "Event Type: Slot Power Fault "
			    "Detected");

			schpc_p->schpc_slot[slot].state &=
			    ~SCHPC_SLOTSTATE_OCC_GOOD;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_NOT_HEALTHY, 0);

			schpc_setslotled(expander, board, slot, FAULT_LED_ON);
		} else {
			SCHPC_DEBUG0(D_EVENT, "Event Type: Slot Power Fault "
			    "Cleared");

			schpc_p->schpc_slot[slot].state |=
			    SCHPC_SLOTSTATE_OCC_GOOD;

			(void) hpc_slot_event_notify(
			    schpc_p->schpc_slot[slot].slot_handle,
			    HPC_EVENT_SLOT_HEALTHY_OK, 0);

			schpc_setslotled(expander, board, slot,
			    FAULT_LED_OFF);
		}
	}
	mutex_enter(&schpc_p->schpc_mutex);
	schpc_p->schpc_slot[slot].state &=
	    ~SCHPC_SLOTSTATE_EXECUTING;
	cv_signal(&schpc_p->schpc_cv);
	mutex_exit(&schpc_p->schpc_mutex);

	kmem_free(event, sizeof (pcimsg_t));
}


/*
 * schpc_event_filter
 *
 * The schpc_event_filter enqueues MBOXSC_MSG_EVENTs into the
 * schpc_event_taskq for processing by the schpc_event_handler _if_
 * hotpluggable pci slots have been registered; otherwise, the
 * MBOXSC_MSG_EVENTs are discarded in order to keep the incoming mailbox
 * open for future messages.
 */
static void
schpc_event_filter(pcimsg_t *pmsg)
{
	if (slots_registered == B_TRUE) {

		pcimsg_t *pevent;

		/*
		 * If hotpluggable pci slots have been registered then enqueue
		 * the event onto the schpc_event_taskq for processing.
		 */

		SCHPC_DEBUG0(D_EVENT, "schpc_event_filter() - "
		    "slots_registered = B_TRUE");

		pevent = (pcimsg_t *)kmem_zalloc(sizeof (pcimsg_t), KM_SLEEP);
		bcopy(pmsg, pevent, sizeof (pcimsg_t));

		SCHPC_DEBUG0(D_EVENT, "schpc_event_filter() - "
		    "event alloc'd");

		if (taskq_dispatch(schpc_event_taskq, schpc_event_handler,
		    (void *)pevent, TQ_SLEEP) == NULL) {
			cmn_err(CE_WARN, "schpc: schpc_event_filter - "
			    "taskq_dispatch failed to enqueue event");
			kmem_free(pevent, sizeof (pcimsg_t));
			return;
		}

		SCHPC_DEBUG0(D_EVENT, "schpc_event_filter() - "
		    "event was taskq_dispatch'ed to schpc_event_handler");
	} else {
		/*
		 * Oops, schpc received an event _before_ the slots have been
		 * registered. In that case there is no choice but to toss
		 * the event.
		 */
		cmn_err(CE_WARN, "schpc: schpc_event_filter - discarding "
		    "premature event");
	}
}


/*
 * schpc_msg_thread
 * A stand-alone thread that monitors the incoming mailbox for
 * MBOXSC_MSG_REPLYs and MBOXSC_MSG_EVENTs, and removes them from
 * the mailbox for processing.
 *
 * MBOXSC_MSG_REPLYs are matched against outstanding REPLYs in the
 * schpc_replylist, and the waiting thread is notified that its REPLY
 * message has arrived; otherwise, if no REPLY match is found, then it is
 * discarded.
 *
 * MBOXSC_MSG_EVENTs are enqueued into the schpc_event_taskq and processed
 * by the schpc_event_handler.
 *
 * The schpc_msg_thread is started in _init().
 */
void
schpc_msg_thread(void)
{
	int			err;
	uint32_t		type;
	uint32_t		cmd;
	uint64_t		transid;
	uint32_t		length;
	pcimsg_t		msg;

	SCHPC_DEBUG0(D_THREAD, "schpc_msg_thread() running");

	/* CONSTCOND */
	while (1) {

		/* setup wildcard arguments */
		type = 0;
		cmd = 0;
		transid = 0;
		length = sizeof (pcimsg_t);
		bzero(&msg, sizeof (pcimsg_t));

		err = mboxsc_getmsg(KEY_SCPC, &type, &cmd,
		    &transid, &length, (void *)&msg,
		    schpc_timeout_getmsg);

		if (err) {
			switch (err) {

			/*FALLTHROUGH*/
			case ETIMEDOUT:
			case EAGAIN:
				continue;

			default:
				/*
				 * unfortunately, we can't do very much here
				 * because we're wildcarding mboxsc_getmsg
				 * so if it encounters an error, we can't
				 * identify which transid it belongs to.
				 */
				cmn_err(CE_WARN,
				"schpc - mboxsc_getmsg failed, err=0x%x", err);
				delay(drv_usectohz(100000));
				continue;
			}
		}

		if (msg.pcimsg_revision != PCIMSG_REVISION) {
			/*
			 * This version of the schpc driver only understands
			 * version 1.0 of the PCI Hot Plug Message format.
			 */
			cmn_err(CE_WARN, " schpc: schpc_msg_thread - "
			    "discarding event w/ unknown message version %x",
			    msg.pcimsg_revision);
			continue;
		}

		switch (type) {

		case MBOXSC_MSG_EVENT:
			schpc_event_filter(&msg);
			break;

		case MBOXSC_MSG_REPLY:
			schpc_reply_handler(&msg, type, cmd, transid, length);
			break;

		default:
			cmn_err(CE_WARN,
			    "schpc - mboxsc_getmsg unknown msg"
			    " type=0x%x", type);
			break;
		}
	}
	/* this thread never exits */
}


void
schpc_reply_handler(pcimsg_t *pmsg, uint32_t type, uint32_t cmd,
			uint64_t transid, uint32_t length)
{
	schpc_replylist_t	*entry;

	mutex_enter(&schpc_replylist_mutex);
	entry = schpc_replylist_first;
	while (entry != NULL) {
		if (entry->transid == transid) {
			break;
		} else
			entry = entry->next;
	}
	if (entry) {
		SCHPC_DEBUG1(D_GETSLOTSTATUS|D_SETSLOTSTATUS,
		    "schpc_reply_handler() - 0x%lx transid reply "
		    "received", transid);

		mutex_enter(&entry->reply_lock);
		if (entry->reply_cexit == B_FALSE) {
			SCHPC_DEBUG1(D_GETSLOTSTATUS|D_SETSLOTSTATUS,
			    "schpc_reply_handler() - 0x%lx transid"
			    " cv_signal waiting thread", transid);

			/*
			 * emulate mboxsc_getmsg by copying the reply
			 */
			entry->type = type;
			entry->cmd = cmd;
			entry->transid = transid;
			entry->length = length;
			bcopy((caddr_t)pmsg, &entry->reply, length);

			/* reply was received */
			entry->reply_recvd = B_TRUE;

			/*
			 * wake up thread waiting for reply with transid
			 */
			cv_signal(&entry->reply_cv);
		}
		mutex_exit(&entry->reply_lock);
	} else {
		cmn_err(CE_WARN, "schpc - no match for transid 0x%lx",
		    transid);
	}
	mutex_exit(&schpc_replylist_mutex);
}


/*
 * schpc_putrequest
 *
 * A wrapper around the synchronous call mboxsc_putmsg().
 */
int
schpc_putrequest(uint32_t key, uint32_t type, uint32_t cmd, uint64_t *transidp,
		uint32_t length, void *datap, clock_t timeout,
		schpc_replylist_t **entryp)
{
	int rval;

	/* add the request to replylist to keep track of outstanding requests */
	*entryp = schpc_replylist_link(cmd, *transidp, length);

	SCHPC_DEBUG1(D_GETSLOTSTATUS|D_SETSLOTSTATUS, "schpc_putrequest() - "
	    "0x%lx transid mboxsc_putmsg called", *transidp);

	/* wait synchronously for request to be sent */
	rval = mboxsc_putmsg(key, type, cmd, transidp, length,
	    (void *)datap, timeout);

	SCHPC_DEBUG2(D_GETSLOTSTATUS|D_SETSLOTSTATUS, "schpc_putrequest() - "
	    "0x%lx transid mboxsc_putmsg returned 0x%x", *transidp, rval);

	/* if problem is encountered then remove the request from replylist */
	if (rval)
		schpc_replylist_unlink(*entryp);

	return (rval);
}


/*
 * schpc_getreply
 *
 * Wait for the schpc_msg_thread to respond that a matching reply has
 * arrived; otherwise, timeout and remove the entry from the schpc_replylist.
 */
/*ARGSUSED*/
int
schpc_getreply(uint32_t key, uint32_t *typep, uint32_t *cmdp,
		uint64_t *transidp, uint32_t *lengthp, void *datap,
		clock_t timeout, schpc_replylist_t *listp)
{
	int rc = 0;

	SCHPC_DEBUG1(D_GETSLOTSTATUS|D_SETSLOTSTATUS,
	    "schpc_getreply() - 0x%lx transid waiting for reply",
	    *transidp);

	/*
	 * wait here until schpc_msg_thread because it's always
	 * looking for reply messages
	 */
	mutex_enter(&listp->reply_lock);

	while (listp->reply_recvd == B_FALSE) {
		/*
		 * wait for reply or timeout
		 */
		rc = cv_timedwait(&listp->reply_cv, &listp->reply_lock,
		    ddi_get_lbolt() + drv_usectohz(timeout * 1000));
		switch (rc) {
		case -1: /* most likely a timeout, but check anyway */

			/* message was received after all */
			if (listp->reply_recvd == B_TRUE)
				break;

			/* no, it's really a timeout */
			listp->reply_cexit = B_TRUE;
			mutex_exit(&listp->reply_lock);
			cmn_err(CE_WARN,
			"schpc - 0x%lx transid reply timed out", *transidp);
			schpc_replylist_unlink(listp);
			return (ETIMEDOUT);

		default:
			break;
		}
	}

	*typep = listp->type;
	*cmdp = listp->cmd;
	*transidp = listp->transid;
	*lengthp = listp->length;
	bcopy((caddr_t)&listp->reply, datap, *lengthp);
	mutex_exit(&listp->reply_lock);
	SCHPC_DEBUG1(D_GETSLOTSTATUS|D_SETSLOTSTATUS,
	    "schpc_getreply() - 0x%lx transid received", *transidp);
	schpc_replylist_unlink(listp);
	return (0);
}


/*
 * schpc_replylist_unlink
 *
 * Deallocate a schpc_replylist_t element.
 */
void
schpc_replylist_unlink(schpc_replylist_t *entry)
{
#if DEBUG
	schpc_replylist_t *dbg_entry;
#endif	/* DEBUG */

	SCHPC_DEBUG1(D_GETSLOTSTATUS|D_SETSLOTSTATUS,
	    "schpc_replylist_unlink() - 0x%lx transid deleted from replylist",
	    entry->transid);

	mutex_enter(&schpc_replylist_mutex);
	if (entry->prev) {
		entry->prev->next = entry->next;
		if (entry->next)
			entry->next->prev = entry->prev;
	} else {
		schpc_replylist_first = entry->next;
		if (entry->next)
			entry->next->prev = NULL;
	}
	if (entry == schpc_replylist_last) {
		schpc_replylist_last = entry->prev;
	}
	kmem_free(entry, sizeof (schpc_replylist_t));
	schpc_replylist_count--;

#if DEBUG
	if (schpc_debug_flags & (D_GETSLOTSTATUS|D_SETSLOTSTATUS)) {
		dbg_entry = schpc_replylist_first;
		cmn_err(CE_CONT, "schpc: schpc_replylist_unlink() - replylist "
		    "count = %d\n", schpc_replylist_count);
		while (dbg_entry != NULL) {
			cmn_err(CE_CONT, "schpc: schpc_replylist_unlink() - "
			    "0x%lx transid\n", dbg_entry->transid);
			dbg_entry = dbg_entry->next;
		}
	}
#endif	/* DEBUG  */

	mutex_exit(&schpc_replylist_mutex);
}


/*
 * schpc_replylist_link
 *
 * Allocate and initialize a schpc_replylist_t element.
 */
schpc_replylist_t *
schpc_replylist_link(uint32_t cmd, uint64_t transid, uint32_t length)
{
	schpc_replylist_t *entry;
#if DEBUG
	schpc_replylist_t *dbg_entry;
#endif	/* DEBUG */

	SCHPC_DEBUG1(D_GETSLOTSTATUS|D_SETSLOTSTATUS,
	    "schpc_replylist_link() - 0x%lx transid inserting into replylist",
	    transid);

	entry = kmem_zalloc(sizeof (schpc_replylist_t), KM_SLEEP);
	mutex_init(&entry->reply_lock, NULL, MUTEX_DRIVER, NULL);
	cv_init(&entry->reply_cv, NULL, CV_DRIVER, NULL);
	entry->type = MBOXSC_MSG_REPLY;
	entry->cmd  = cmd;
	entry->transid  = transid;
	entry->length  = length;
	entry->reply_recvd = B_FALSE;
	entry->reply_cexit = B_FALSE;

	mutex_enter(&schpc_replylist_mutex);
	if (schpc_replylist_last) {
		entry->prev = schpc_replylist_last;
		schpc_replylist_last->next = entry;
		schpc_replylist_last = entry;
	} else {
		schpc_replylist_last = schpc_replylist_first = entry;
	}

	schpc_replylist_count++;

#if DEBUG
	if (schpc_debug_flags & (D_GETSLOTSTATUS|D_SETSLOTSTATUS)) {
		dbg_entry = schpc_replylist_first;
		cmn_err(CE_CONT, "schpc: schpc_replylist_link() - replylist "
		    "count = %d\n", schpc_replylist_count);
		while (dbg_entry != NULL) {
			cmn_err(CE_CONT, "schpc: schpc_replylist_link() - "
			    "0x%lx transid\n", dbg_entry->transid);
			dbg_entry = dbg_entry->next;
		}
	}
#endif	/* DEBUG  */

	mutex_exit(&schpc_replylist_mutex);

	return (entry);
}


/*
 * schpc_getslotstatus
 *
 * Issues a Get Slot Status command to the System Controller
 * for a specific slot.
 */
static int
schpc_getslotstatus(uint32_t expander, uint32_t board, uint32_t slot,
    pci_getslot_t *slotstatus)
{
	pcimsg_t	request;
	pcimsg_t	reply;
	int		rval;
	uint32_t	type, cmd, length;
	uint64_t	transid;
	schpc_replylist_t *entry;

	SCHPC_DEBUG4(D_GETSLOTSTATUS,
	    "schpc_getslotstatus(expander=%d board=%d "
	    "slot=%d slotstatus=0x%p", expander, board,
	    SCHPC_SLOT_NUM(slot), (void *)slotstatus);

	if (schpc_p == NULL) {
		return (1);
	}

	bzero(&request, sizeof (pcimsg_t));

	request.pcimsg_node = expander;
	request.pcimsg_board = board;
	request.pcimsg_slot = SCHPC_SLOT_NUM(slot);
	request.pcimsg_revision = PCIMSG_REVISION;
	request.pcimsg_command = PCIMSG_GETSLOTSTATUS;

	type = MBOXSC_MSG_REQUEST;
	cmd = PCIMSG_GETSLOTSTATUS;
	transid =  schpc_gettransid(schpc_p, slot);
	length = sizeof (pcimsg_t);

	SCHPC_DEBUG1(D_GETSLOTSTATUS, "schpc_getslotstatus() - "
	    "0x%lx transid schpc_putrequest called", transid);

	rval = schpc_putrequest(KEY_PCSC, type, cmd, &transid, length,
	    (void *)&request, schpc_timeout_putmsg, &entry);

	SCHPC_DEBUG2(D_GETSLOTSTATUS, "schpc_getslotstatus() - "
	    "0x%lx transid schpc_putrequest returned 0x%x", transid, rval);

	if (rval) {
		return (rval);
	}

	bzero(&reply, sizeof (pcimsg_t));
	type = MBOXSC_MSG_REPLY;

	SCHPC_DEBUG1(D_GETSLOTSTATUS, "schpc_getslotstatus() - "
	    "0x%lx transid schpc_getreply called", transid);

	rval = schpc_getreply(KEY_SCPC, &type, &cmd, &transid, &length,
	    (void *)&reply, schpc_timeout_getmsg, entry);

	SCHPC_DEBUG2(D_GETSLOTSTATUS, "schpc_getslotstatus() - "
	    "0x%lx transid schpc_getreply returned 0x%x", transid, rval);

	if (rval == 0) {
		*slotstatus = reply.pcimsg_type.pcimsg_getslot;

		SCHPC_DEBUG0(D_GETSLOTSTATUS, "schpc_getslotstatus()");
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_power_on %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_power_on);
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_powergood %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_powergood);
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_powerfault %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_powerfault);
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_empty %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_empty);
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_freq_cap %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_freq_cap);
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_freq_setting %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_freq_setting);
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_condition %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_condition);
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_HEALTHY %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_HEALTHY);
		SCHPC_DEBUG1(D_GETSLOTSTATUS, "    slot_ENUM %x",
		    reply.pcimsg_type.pcimsg_getslot.slot_ENUM);
	}

	return (rval);
}


/*
 * schpc_setslotstatus
 *
 * Issues a Set Slot Status command to the System Controller
 * for a specific slot.
 */
static int
schpc_setslotstatus(uint32_t expander, uint32_t board, uint32_t slot,
    pci_setslot_t *slotstatus)
{
	pcimsg_t	request;
	pcimsg_t	reply;
	int		rval;
	uint32_t	type, cmd, length;
	uint64_t	transid;
	schpc_replylist_t *entry;

	SCHPC_DEBUG4(D_SETSLOTSTATUS,
	    "schpc_setslotstatus(expander=%d board=%d "
	    "slot=%d slotstatus=0x%p", expander, board,
	    SCHPC_SLOT_NUM(slot), (void *)slotstatus);

	bzero(&request, sizeof (pcimsg_t));

	if (schpc_p == NULL) {
		return (1);
	}

	request.pcimsg_node = expander;
	request.pcimsg_board = board;
	request.pcimsg_slot = SCHPC_SLOT_NUM(slot);
	request.pcimsg_revision = PCIMSG_REVISION;
	request.pcimsg_command = PCIMSG_SETSLOTSTATUS;

	request.pcimsg_type.pcimsg_setslot = *slotstatus;

	SCHPC_DEBUG0(D_IOC_LED, "schpc_setslotstatus() - LED state change");
	SCHPC_DEBUG3(D_IOC_LED, "LED Power %d Service %d Fault %d",
	    slotstatus->slot_led_power,
	    slotstatus->slot_led_service,
	    slotstatus->slot_led_fault);

	type = MBOXSC_MSG_REQUEST;
	cmd = PCIMSG_SETSLOTSTATUS;
	transid =  schpc_gettransid(schpc_p, slot);
	length = sizeof (pcimsg_t);

	SCHPC_DEBUG1(D_SETSLOTSTATUS, "schpc_setslotstatus() - "
	    "0x%lx transid schpc_putrequest called", transid);

	rval = schpc_putrequest(KEY_PCSC, type, cmd, &transid, length,
	    (void *)&request, schpc_timeout_putmsg, &entry);

	SCHPC_DEBUG2(D_SETSLOTSTATUS, "schpc_setslotstatus() - "
	    "0x%lx transid schpc_putrequest returned 0x%x", transid, rval);

	if (rval) {
		return (rval);
	}

	bzero(&reply, sizeof (pcimsg_t));
	type = MBOXSC_MSG_REPLY;

	SCHPC_DEBUG1(D_SETSLOTSTATUS, "schpc_setslotstatus() - "
	    "0x%lx transid schpc_getreply called", transid);

	rval = schpc_getreply(KEY_SCPC, &type, &cmd, &transid, &length,
	    (void *)&reply, schpc_timeout_getmsg, entry);

	SCHPC_DEBUG2(D_SETSLOTSTATUS, "schpc_setslotstatus() - "
	    "0x%lx transid schpc_getreply returned 0x%x", transid, rval);

	if (rval == 0) {
		slotstatus->slot_replystatus =
		    reply.pcimsg_type.pcimsg_setslot.slot_replystatus;
	}

	return (rval);
}

/*
 * schpc_setslotled
 *
 * Changes the attention indicators for a given slot.
 */
static void
schpc_setslotled(int expander, int board, int slot, uint32_t led_state)
{

	pci_setslot_t	setslot;

	if (schpc_p == NULL) {
		return;
	}

	schpc_init_setslot_message(&setslot);

	if (led_state & POWER_LED_ON) {
		schpc_p->schpc_slot[slot].led.led_power = PCIMSG_LED_ON;
	}
	if (led_state & POWER_LED_OFF) {
		schpc_p->schpc_slot[slot].led.led_power = PCIMSG_LED_OFF;
	}
	if (led_state & POWER_LED_FLASH) {
		schpc_p->schpc_slot[slot].led.led_power = PCIMSG_LED_FLASH;
	}
	if (led_state & SERVICE_LED_ON) {
		schpc_p->schpc_slot[slot].led.led_service = PCIMSG_LED_ON;
	}
	if (led_state & SERVICE_LED_OFF) {
		schpc_p->schpc_slot[slot].led.led_service = PCIMSG_LED_OFF;
	}
	if (led_state & SERVICE_LED_FLASH) {
		schpc_p->schpc_slot[slot].led.led_service = PCIMSG_LED_FLASH;
	}
	if (led_state & FAULT_LED_ON) {
		schpc_p->schpc_slot[slot].led.led_fault = PCIMSG_LED_ON;
	}
	if (led_state & FAULT_LED_OFF) {
		schpc_p->schpc_slot[slot].led.led_fault = PCIMSG_LED_OFF;
	}
	if (led_state & FAULT_LED_FLASH) {
		schpc_p->schpc_slot[slot].led.led_fault = PCIMSG_LED_FLASH;
	}

	switch (schpc_p->schpc_slot[slot].led.led_power) {
	case PCIMSG_LED_ON:
		setslot.slot_led_power = PCIMSG_LED_ON;
		break;
	case PCIMSG_LED_OFF:
		setslot.slot_led_power = PCIMSG_LED_OFF;
		break;
	case PCIMSG_LED_FLASH:
		setslot.slot_led_power = PCIMSG_LED_FLASH;
		break;
	}
	switch (schpc_p->schpc_slot[slot].led.led_service) {
	case PCIMSG_LED_ON:
		setslot.slot_led_service = PCIMSG_LED_ON;
		break;
	case PCIMSG_LED_OFF:
		setslot.slot_led_service = PCIMSG_LED_OFF;
		break;
	case PCIMSG_LED_FLASH:
		setslot.slot_led_service = PCIMSG_LED_FLASH;
		break;
	}
	switch (schpc_p->schpc_slot[slot].led.led_fault) {
	case PCIMSG_LED_ON:
		setslot.slot_led_fault = PCIMSG_LED_ON;
		break;
	case PCIMSG_LED_OFF:
		setslot.slot_led_fault = PCIMSG_LED_OFF;
		break;
	case PCIMSG_LED_FLASH:
		setslot.slot_led_fault = PCIMSG_LED_FLASH;
		break;
	}

	(void) schpc_setslotstatus(expander, board, slot, &setslot);
}

/*
 * schpc_init_setslot_message
 *
 * Initialize Set Slot Message before using it.
 */
static void
schpc_init_setslot_message(pci_setslot_t *setslot)
{
	/*
	 * Initialize Set Slot Command.
	 */
	setslot->slot_power_on = PCIMSG_OFF;
	setslot->slot_power_off = PCIMSG_OFF;
	setslot->slot_led_power = PCIMSG_LED_OFF;
	setslot->slot_led_service = PCIMSG_LED_OFF;
	setslot->slot_led_fault = PCIMSG_LED_OFF;
	setslot->slot_disable_ENUM = PCIMSG_OFF;
	setslot->slot_enable_ENUM = PCIMSG_OFF;
	setslot->slot_disable_HEALTHY = PCIMSG_OFF;
	setslot->slot_enable_HEALTHY = PCIMSG_OFF;
}

/*
 * schpc_gettransid
 *
 * Builds a unique transaction ID.
 */
static uint64_t
schpc_gettransid(schpc_t *schpc_p, int slot)
{
	uint64_t	trans_id;

	mutex_enter(&schpc_p->schpc_mutex);

	if (++schpc_p->schpc_transid == 0)
		schpc_p->schpc_transid = 1;

	trans_id = (schpc_p->schpc_slot[slot].expander<<24) |
	    (schpc_p->schpc_slot[slot].board << 16) | schpc_p->schpc_transid;

	mutex_exit(&schpc_p->schpc_mutex);

	SCHPC_DEBUG1(D_TRANSID, "schpc_gettransid() - 0x%lx transid returning",
	    trans_id);

	return (trans_id);
}

/*
 * schpc_slot_get_index
 *
 * get slot table index from the slot handle
 */
static int
schpc_slot_get_index(schpc_t *schpc_p, hpc_slot_t slot)
{
	int	i;
	int	rval = -1;

	ASSERT(MUTEX_HELD(&schpc_p->schpc_mutex));

	for (i = 0; i < schpc_p->schpc_number_of_slots; i++) {
		if (schpc_p->schpc_slot[i].slot_handle == slot)
			return (i);
	}

	return (rval);
}

/*
 * schpc_register_all_slots
 *
 * Search device tree for pci nodes and register attachment points
 * for all hot pluggable slots.
 */
/*ARGSUSED*/
static void
schpc_register_all_slots(schpc_t *schpc_p)
{
	int		slot = 0;
	char		caddr[64];
	dev_info_t	*pci_dip = NULL;
	find_dev_t	find_dev;
	int		leaf, schizo, expander, portid, offset;

	SCHPC_DEBUG1(D_ATTACH,
	    "schpc_register_all_slots(schpc_p=%p)", (void *)schpc_p);

	/*
	 * Allow the event_handler to start processing unsolicited
	 * events now that slots are about to be registered.
	 */
	slots_registered = B_TRUE;

	for (slot = 0; slot < STARCAT_MAX_SLOTS; slot++) {

		leaf = SCHPC_SLOT_LEAF(slot);
		schizo = SCHPC_SLOT_SCHIZO(slot);
		expander = SCHPC_SLOT_EXPANDER(slot);

		if (schizo == 0)
			portid = 0x1c;
		else
			portid = 0x1d;

		if (leaf == 0)
			offset = 0x600000;
		else
			offset = 0x700000;

		portid = (expander << 5) | portid;

		(void) sprintf(caddr, "%x,%x", portid, offset);

		SCHPC_DEBUG3(D_ATTACH,
		    "schpc_register_all_slots: searching for pci@%s"
		    " schizo=%d, leaf=%d", caddr, schizo, leaf);

		find_dev.cname = "pci";
		find_dev.caddr = caddr;
		find_dev.schizo = schizo;
		find_dev.leaf = leaf;
		find_dev.dip = NULL;

		/* root node doesn't have to be held */
		ddi_walk_devs(ddi_root_node(), schpc_match_dip,
		    &find_dev);

		pci_dip = find_dev.dip;

		if (pci_dip == NULL) {

			SCHPC_DEBUG1(D_ATTACH,
			    "schpc_register_all_slots: pci@%s NOT FOUND",
			    caddr);

			continue;
		}

		SCHPC_DEBUG2(D_ATTACH,
		    "schpc_register_all_slots: pci@%s FOUND dip=0x%p",
		    caddr, (void *)pci_dip);

		(void) schpc_add_pci(pci_dip);

		/*
		 * Release hold acquired in schpc_match_dip()
		 */
		ndi_rele_devi(pci_dip);
	}

	SCHPC_DEBUG0(D_ATTACH, "schpc_register_all_slots: Thread Exit");

	thread_exit();
}

/*
 * schpc_add_pci
 *
 * Routine to add attachments points associated with a pci node.
 * Can be call externally by DR when configuring a PCI I/O Board.
 */
int
schpc_add_pci(dev_info_t *bdip)
{
	int		portid;
	int		expander, board, schizo, leaf, slot, status;
	char		ap_id[MAXNAMELEN];
	char		caddr[64];
	char		*naddr;
	hpc_slot_info_t	slot_info;
	hpc_slot_ops_t	*slot_ops;
	dev_info_t 	*sdip = bdip;

	SCHPC_DEBUG1(D_ATTACH, "schpc_add_pci(dip=0x%p)", (void *)sdip);

	if (schpc_p == NULL) {
		/*
		 * The schpc driver has not been attached yet.
		 */
		return (DDI_SUCCESS);
	}

	if ((portid = ddi_getprop(DDI_DEV_T_ANY, sdip, 0, "portid", -1)) < 0) {
		cmn_err(CE_WARN, "schpc_add_pci(dip=0x%p) - no portid\n",
		    (void *)sdip);
		return (DDI_FAILURE);
	}

	expander = schpc_getexpander(sdip);
	board = schpc_getboard(sdip);

	switch (portid & 0x1f) {

	case 0x1c:
		schizo = 0;
		break;
	case 0x1d:
		schizo = 1;
		break;
	default:
		cmn_err(CE_WARN, "schpc_add_pci(dip=0x%p) - "
		    "Invalid pci portid 0x%x\n", (void *)sdip, portid);
		return (DDI_FAILURE);
	}

	naddr = ddi_get_name_addr(sdip);
	if (naddr == NULL) {
		SCHPC_DEBUG1(D_ATTACH, "schpc_add_pci: ddi_get_name_addr"
		    "(0x%p) returns null", (void *)sdip);
		return (DDI_FAILURE);
	}

	(void) sprintf(caddr, "%x,600000", portid);

	if (strcmp(caddr, naddr) == 0) {
		leaf = 0;
	} else {
		(void) sprintf(caddr, "%x,700000", portid);
		if (strcmp(caddr, naddr) == 0) {
			char *name;

			leaf = 1;
			name = ddi_binding_name(sdip);
			if ((strcmp(name, "pci108e,8002") == 0) &&
			    (schizo == 0)) {
				int circ;
				dev_info_t *cdip;
				/*
				 * XMITS 0 Leaf B will have its hot
				 * pluggable slot off a PCI-PCI bridge,
				 * which is the only child.
				 */
				ndi_devi_enter(sdip, &circ);
				cdip = ddi_get_child(sdip);
				if (cdip == NULL) {
					cmn_err(CE_WARN,
					    "schpc_add_pci(dip=0x%p) - "
					    "Invalid pci name addr %s\n",
					    (void *)sdip, naddr);
					ndi_devi_exit(sdip, circ);
					return (DDI_FAILURE);
				}
				ndi_devi_exit(sdip, circ);
				sdip = cdip;
			}
		} else {
			cmn_err(CE_WARN, "schpc_add_pci(dip=0x%p) - "
			    "Invalid pci name addr %s\n", (void *)sdip, naddr);
			return (DDI_FAILURE);
		}
	}

	/* create a slot table index */
	slot = SCHPC_MAKE_SLOT_INDEX3(expander, schizo, leaf);

	if (schpc_p->schpc_slot[slot].devi) {
		cmn_err(CE_WARN, "schpc_add_pci(dip=0x%p) - "
		    "pci node already registered\n", (void *)sdip);
		return (DDI_FAILURE);
	}

	/*
	 * There is no need to hold the dip while saving it in
	 * the devi field below. The dip is never dereferenced.
	 * (If that changes, this code should be modified).
	 * We want to avoid holding the dip here because it
	 * prevents DR.
	 *
	 * NOTE: Even though the slot on XMITS0 Leaf-B
	 * is connected to a pci_pci bridge, we will be saving
	 * the busdip in this datastructure. This will make
	 * it easier to identify the dip being removed in
	 * schpc_remove_pci().
	 */
	schpc_p->schpc_slot[slot].devi = bdip;

	schpc_p->schpc_slot[slot].expander = expander;
	schpc_p->schpc_slot[slot].board = board;
	schpc_p->schpc_slot[slot].schizo = schizo;
	schpc_p->schpc_slot[slot].leaf = leaf;

	/*
	 * Starcat PCI slots are always PCI device 1.
	 */
	schpc_p->schpc_slot[slot].pci_id = 1;

	schpc_buildapid(sdip, slot, (char *)&ap_id);

	(void) strcpy(schpc_p->schpc_slot[slot].ap_id, (char *)&ap_id);

	/* safe to call ddi_pathname(): bdip is held */
	(void) ddi_pathname(sdip, schpc_p->schpc_slot[slot].nexus_path);

	status = schpc_get_slot_status(expander, board, SCHPC_SLOT_NUM(slot));
	switch (status) {
		case RSV_UNKNOWN:
		case RSV_PRESENT:
		case RSV_MISS:
		case RSV_PASS:
		case RSV_EMPTY_CASSETTE:

			/*
			 * Test the condition of the slot.
			 */
			schpc_test((caddr_t)schpc_p, slot, 0, 0);
			break;
		case RSV_BLACK:
			schpc_p->schpc_slot[slot].state = 0;
			cmn_err(CE_WARN, "schpc: PCI card blacklisted: "
			    "expander=%d board=%d slot=%d\n", expander,
			    board, SCHPC_SLOT_NUM(slot));
			break;
		default:
			schpc_p->schpc_slot[slot].state = 0;
			cmn_err(CE_WARN, "schpc: PCI card failed by POST: "
			    "expander=%d board=%d slot=%d failure=0x%x\n",
			    expander, board, SCHPC_SLOT_NUM(slot), status);
			break;
	}

	if (schpc_p->schpc_slot[slot].state & SCHPC_SLOTSTATE_REC_GOOD) {

		/* allocate slot ops */

		slot_ops = hpc_alloc_slot_ops(KM_SLEEP);
		schpc_p->schpc_slot[slot].slot_ops = slot_ops;

		/*
		 * Default to Autoconfiguration disabled.
		 */
		schpc_p->schpc_slot[slot].state &=
		    ~SCHPC_SLOTSTATE_AUTOCFG_ENABLE;

		/*
		 * Fill in the slot information structure that
		 * describes the slot.
		 */
		slot_info.version = HPC_SLOT_OPS_VERSION;

		if (schpc_p->schpc_hotplugmodel ==
		    SCHPC_HOTPLUGTYPE_CPCIHOTPLUG)
			slot_info.slot_type = HPC_SLOT_TYPE_PCI;
		else
			slot_info.slot_type = HPC_SLOT_TYPE_CPCI;

		slot_info.slot.pci.device_number =
		    schpc_p->schpc_slot[slot].pci_id;

		slot_info.slot.pci.slot_capabilities = HPC_SLOT_64BITS;

		if (schpc_use_legacy_apid)
			slot_info.slot_flags = HPC_SLOT_NO_AUTO_ENABLE;
		else
			slot_info.slot_flags = HPC_SLOT_NO_AUTO_ENABLE |
			    HPC_SLOT_CREATE_DEVLINK;

		(void) strcpy(slot_info.slot.pci.slot_logical_name,
		    schpc_p->schpc_slot[slot].ap_id);

		/*
		 * Fill in the slot ops structure that tells
		 * the Hot Plug Services what function we
		 * support.
		 */
		slot_ops->hpc_version = HPC_SLOT_OPS_VERSION;
		if (schpc_p->schpc_hotplugmodel ==
		    SCHPC_HOTPLUGTYPE_CPCIHOTPLUG) {
			slot_ops->hpc_op_connect = schpc_connect;
			slot_ops->hpc_op_disconnect = schpc_disconnect;
			slot_ops->hpc_op_insert = NULL;
			slot_ops->hpc_op_remove = NULL;
			slot_ops->hpc_op_control = schpc_pci_control;
		} else {
			slot_ops->hpc_op_connect = NULL;
			slot_ops->hpc_op_disconnect = NULL;
			slot_ops->hpc_op_insert = NULL;
			slot_ops->hpc_op_remove = NULL;
			slot_ops->hpc_op_control = schpc_cpci_control;
		}

		SCHPC_DEBUG5(D_ATTACH, "schpc_add_pci: Registering HPC "
		    "- nexus =%s schpc_p=%p slot=%d pci number=%d ap_id=%s",
		    schpc_p->schpc_slot[slot].nexus_path,
		    (void *)schpc_p, SCHPC_SLOT_NUM(slot),
		    slot_info.slot.pci.device_number,
		    slot_info.slot.pci.slot_logical_name);

		if (hpc_slot_register(schpc_p->schpc_devi,
		    schpc_p->schpc_slot[slot].nexus_path, &slot_info,
		    &schpc_p->schpc_slot[slot].slot_handle,
		    slot_ops, (caddr_t)schpc_p, 0) != 0) {

			/*
			 * If the slot can not be registered,
			 * then the slot_ops need to be freed.
			 */
			cmn_err(CE_WARN, "schpc%d Unable to Register "
			    "Slot %s", schpc_p->schpc_instance,
			    slot_info.slot.pci.slot_logical_name);

			hpc_free_slot_ops(schpc_p->schpc_slot[slot].slot_ops);

			schpc_p->schpc_slot[slot].slot_ops = NULL;

			return (DDI_FAILURE);
		}

		/*
		 * We are ready to take commands from the HPC Services.
		 */
		schpc_p->schpc_slot[slot].state |= SCHPC_SLOTSTATE_HPCINITED;
	}

	return (DDI_SUCCESS);
}

/*
 * schpc_remove_pci
 *
 * Routine to remove attachments points associated with a pci node.
 * Can be call externally by DR when unconfiguring a PCI I/O Board.
 */
int
schpc_remove_pci(dev_info_t *dip)
{
	int slot;

	SCHPC_DEBUG1(D_DETACH, "schpc_remove_pci(dip=0x%p)", (void *)dip);

	if (schpc_p == NULL) {
		/*
		 * The schpc driver has not been attached yet.
		 */
		return (DDI_SUCCESS);
	}

	for (slot = 0; slot < schpc_p->schpc_number_of_slots; slot++) {
		if (schpc_p->schpc_slot[slot].devi == dip) {

			if (schpc_p->schpc_slot[slot].slot_ops) {
				if (hpc_slot_unregister(
				    &schpc_p->schpc_slot[slot].slot_handle)) {
					cmn_err(CE_WARN,
					    "schpc_remove_pci(dip=0x%p) - "
					    "unable to unregister pci slots\n",
					    (void *)dip);
					return (DDI_FAILURE);
				} else {
					hpc_free_slot_ops(
					    schpc_p->schpc_slot[slot].slot_ops);

					schpc_p->schpc_slot[slot].slot_ops =
					    NULL;

					schpc_p->schpc_slot[slot].devi = NULL;

					return (DDI_SUCCESS);
				}
			} else {
				schpc_p->schpc_slot[slot].devi = NULL;

				return (DDI_SUCCESS);
			}
		}
	}

	cmn_err(CE_WARN, "schpc_remove_pci(dip=0x%p) "
	    "dip not found\n", (void *)dip);

	return (DDI_SUCCESS);
}

/*
 * schpc_match_dip
 *
 * Used by ddi_walk_devs to find PCI Nexus nodes associated with
 * Hot Plug Controllers.
 */
static int
schpc_match_dip(dev_info_t *dip, void *arg)
{
	char		*naddr;
	find_dev_t	*find_dev = (find_dev_t *)arg;

	if (strcmp(find_dev->cname, ddi_node_name(dip)) == 0 &&
	    ((((naddr = ddi_get_name_addr(dip)) != NULL) &&
	    (strcmp(find_dev->caddr, naddr) == 0)) ||
	    ((naddr == NULL) && (strlen(find_dev->caddr) == 0)))) {
		/*
		 * While ddi_walk_devs() holds dips when invoking this
		 * callback, this dip is being saved and will be accessible
		 * to the caller outside ddi_walk_devs(). Therefore it must be
		 * held.
		 */
		ndi_hold_devi(dip);
		find_dev->dip = dip;

		SCHPC_DEBUG2(D_ATTACH,
		    "schpc_match_dip: pci@%s FOUND dip=0x%p",
		    find_dev->caddr, (void *)find_dev->dip);

		return (DDI_WALK_TERMINATE);
	}

	ASSERT(find_dev->dip == NULL);
	return (DDI_WALK_CONTINUE);
}

/*
 * schpc_buildapid
 *
 * Takes a component address and translates it into a ap_id prefix.
 */
static void
schpc_buildapid(dev_info_t *dip, int slot, char *ap_id)
{
	int r, pci_id_cnt, pci_id_bit;
	int slots_before, found;
	unsigned char *slot_names_data, *s;
	int slot_names_size;
	int slot_num;
	unsigned int bit_mask;

	slot_num = SCHPC_SLOT_NUM(slot);

	if (schpc_use_legacy_apid) {
		SCHPC_DEBUG1(D_APID, "Slot %d - Using Legacy ap-id", slot);

		(void) sprintf(ap_id, "e%02db%dslot%d", schpc_getexpander(dip),
		    schpc_getboard(dip), slot_num);

		SCHPC_DEBUG2(D_APID, "Slot %d - ap-id=%s", slot, ap_id);

		return;
	}

	r = ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "slot-names", (caddr_t)&slot_names_data,
	    &slot_names_size);

	if (r == DDI_PROP_SUCCESS) {

		/*
		 * We can try to use the slot-names property to
		 * build our ap-id.
		 */
		bit_mask = slot_names_data[3] | (slot_names_data[2] << 8) |
		    (slot_names_data[1] << 16) | (slot_names_data[0] << 24);

		pci_id_bit = 1;
		pci_id_cnt = slots_before = found = 0;

		SCHPC_DEBUG2(D_APID, "Slot %d - slot-names bitmask=%x",
		    slot, bit_mask);

		/*
		 * Walk the bit mask until we find the bit that corresponds
		 * to our slots device number.  We count how many bits
		 * we find before we find our slot's bit.
		 */
		while (!found && (pci_id_cnt < 32)) {

			while (schpc_p->schpc_slot[slot].pci_id
			    != pci_id_cnt) {

				/*
				 * Find the next bit set.
				 */
				while (!(bit_mask & pci_id_bit) &&
				    (pci_id_cnt < 32)) {
					pci_id_bit = pci_id_bit << 1;
					pci_id_cnt++;
				}

				if (schpc_p->schpc_slot[slot].pci_id !=
				    pci_id_cnt)
					slots_before++;
				else
					found = 1;
			}
		}

		if (pci_id_cnt < 32) {

			/*
			 * Set ptr to first string.
			 */
			s = slot_names_data + 4;

			/*
			 * Increment past all the strings for the slots
			 * before ours.
			 */
			while (slots_before) {
				while (*s != NULL)
					s++;
				s++;
				slots_before--;
			}

			/*
			 * We should be at our string.
			 */

			(void) sprintf(ap_id, "IO%d_%s",
			    schpc_getexpander(dip), s);

			SCHPC_DEBUG2(D_APID, "Slot %d - ap-id=%s",
			    slot, ap_id);

			kmem_free(slot_names_data, slot_names_size);
			return;
		}

		SCHPC_DEBUG1(D_APID, "Slot %d - slot-names entry not found",
		    slot);

		kmem_free(slot_names_data, slot_names_size);
	} else
		SCHPC_DEBUG1(D_APID, "Slot %d - No slot-names prop found",
		    slot);

	/*
	 * Build the ap-id using the legacy naming scheme.
	 */
	(void) sprintf(ap_id, "e%02db%dslot%d", schpc_getexpander(dip),
	    schpc_getboard(dip), slot_num);

	SCHPC_DEBUG2(D_APID, "Slot %d - ap-id=%s", slot, ap_id);
}

/*
 * schpc_getexpander
 *
 * Returns the Expander Number (0-17) for the dip passed in. The Expander
 * Number is extracted from the portid property of the pci node. Portid
 * consists of <Expbrd#><1110x>, where x is the schizo number.
 */
static int
schpc_getexpander(dev_info_t *dip)
{
	int	id;

	id = ddi_getprop(DDI_DEV_T_ANY, dip, 0, "portid", -1);

	if (id != -1)
		return (id >> 5);
	else {
		id = ddi_getprop(DDI_DEV_T_ANY, dip, 0, "expander", -1);
		return (id);
	}
}

/*
 * schpc_getboard
 *
 * Returns the board number (0 or 1) for the dip passed in.
 */
static int
schpc_getboard(dev_info_t *dip)
{
	_NOTE(ARGUNUSED(dip))

	/*
	 * Hot Pluggable PCI/cPCI slots are only available on
	 * Board 1 (half-bandwidth slot).
	 */
	return (1);
}

/*ARGSUSED*/
static int
schpc_get_slot_status(uint_t expander, uint_t board, uint_t slot)
{
	gdcd_t *gdcd;
	int prd_slot, status, bus;

	SCHPC_DEBUG3(D_ATTACH, "schpc_get_slot_status() "
	    "exp=%d board=%d slot=%d", expander, board, slot);

	if ((gdcd = (gdcd_t *)kmem_zalloc(sizeof (gdcd_t),
	    KM_SLEEP)) == NULL) {
		return (RSV_UNDEFINED);
	}

	/*
	 * Get the Starcat Specific Global DCD Structure from the golden
	 * IOSRAM.
	 */
	if (iosram_rd(GDCD_MAGIC, 0, sizeof (gdcd_t), (caddr_t)gdcd)) {
		cmn_err(CE_WARN, "sc_gptwocfg: Unable To Read GDCD "
		    "From IOSRAM\n");
		kmem_free(gdcd, sizeof (gdcd_t));
		return (RSV_UNDEFINED);
	}

	if (gdcd->h.dcd_magic != GDCD_MAGIC) {

		cmn_err(CE_WARN, "schpc: GDCD Bad Magic 0x%x\n",
		    gdcd->h.dcd_magic);

		kmem_free(gdcd, sizeof (gdcd_t));
		return (RSV_UNDEFINED);
	}

	if (gdcd->h.dcd_version != DCD_VERSION) {
		cmn_err(CE_WARN, "schpc: GDCD Bad Version: "
		    "GDCD Version 0x%x Expecting 0x%x\n",
		    gdcd->h.dcd_version, DCD_VERSION);

		kmem_free(gdcd, sizeof (gdcd_t));
		return (RSV_UNDEFINED);
	}

	if (slot < 2)
		prd_slot = 4;
	else
		prd_slot = 5;

	bus = slot & 0x1;

	status = gdcd->dcd_prd[expander][prd_slot].prd_iocard_rsv[bus][0];

	kmem_free(gdcd, sizeof (gdcd_t));

	SCHPC_DEBUG3(D_ATTACH, "schpc_get_slot_status() "
	    "prd_slot=%d bus=%d status=%d", prd_slot, bus, status);

	return (status);
}

#define	LEAF_SAVE_END			0xff

typedef struct {
	int	reg;
	int	offset;
	int	access_size;
	int	number;
} save_reg_list_t;

/*
 * Save List Array.  Describes the leaf registers that need to
 * be restored after a leaf reset.
 *
 * Entry 1 - Reg Entry: 0=PCI Leaf CSRs, 2=PCI Config Space
 * Entry 2 - Offset Start
 * Entry 3 - Access Size: 8=64 bit, 4=32 bit, 2=16 bit, 1=8 bit
 * Entry 4 - # of registers to be saved starting at offset,
 */
save_reg_list_t	save_reg_list[] = {	0, 0x110, 8, 1,
					0, 0x200, 8, 2,
					0, 0x1000, 8, 0x18,
					0, 0x1a00, 8, 1,
					0, 0x2000, 8, 1,
					0, 0x2020, 8, 1,
					0, 0x2040, 8, 1,
					0, 0x2308, 8, 2,
					0, 0x2800, 8, 1,
					2, 0x04, 2, 1,		/* Command */
					2, 0x0d, 1, 1,		/* Latency */
					2, 0x40, 1, 1,		/* Bus # */
					2, 0x41, 1, 1,		/* Sub. Bus # */
					LEAF_SAVE_END, 0, 0, 0};

static int
schpc_save_leaf(int slot)
{
	int		save_entry, list_entry, reg;
	caddr_t		leaf_regs;
	ddi_device_acc_attr_t attr;

	SCHPC_DEBUG1(D_FREQCHG, "Slot %d - Leaf Registers Saved", slot);

	attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
	attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;

	/*
	 * Map in the 3 addresses spaces defined for XMITS.
	 */
	for (reg = 0; reg < 3; reg++) {
		if (ddi_regs_map_setup(schpc_p->schpc_slot[slot].devi, reg,
		    &leaf_regs, 0, 0, &attr, &schpc_p->schpc_slot[slot].
		    saved_handle[reg]) != DDI_SUCCESS) {
			cmn_err(CE_WARN, "Mapin failed\n");
			schpc_p->schpc_slot[slot].saved_regs_va[reg] = NULL;
			return (1);
		}

		schpc_p->schpc_slot[slot].saved_regs_va[reg] = leaf_regs;
	}


	/*
	 * Determine how many entries are in the list so we can
	 * allocate the save space.
	 */
	list_entry = 0;
	save_entry = 0;
	while (save_reg_list[list_entry].reg != LEAF_SAVE_END) {
		save_entry += save_reg_list[list_entry].number;
		list_entry++;
	}

	schpc_p->schpc_slot[slot].saved_size = (save_entry * sizeof (uint64_t));

	if (schpc_p->schpc_slot[slot].saved_size == 0)
		return (0);

	schpc_p->schpc_slot[slot].saved_regs =
	    (uint64_t *)kmem_zalloc(schpc_p->schpc_slot[slot].saved_size,
	    KM_SLEEP);

	/*
	 * Walk through the register list and save contents.
	 */
	list_entry = 0;
	save_entry = 0;
	while (save_reg_list[list_entry].reg != LEAF_SAVE_END) {
		schpc_save_entry(slot, list_entry, save_entry);
		save_entry += save_reg_list[list_entry].number;
		list_entry ++;
	}

	SCHPC_DEBUG1(D_FREQCHG, "Slot %d - Leaf Registers Saved", slot);

	return (0);
}

static void
schpc_restore_leaf(int slot)
{
	int	save_entry, list_entry, reg;

	if (schpc_p->schpc_slot[slot].saved_regs == NULL)
		return;

	/*
	 * Walk through the register list and restore contents.
	 */
	list_entry = 0;
	save_entry = 0;
	while (save_reg_list[list_entry].reg != LEAF_SAVE_END) {

		schpc_restore_entry(slot, list_entry, save_entry);

		save_entry += save_reg_list[list_entry].number;
		list_entry ++;
	}

	/*
	 * Free the mapped in registers.
	 */
	for (reg = 0; reg < 3; reg++) {
		if (schpc_p->schpc_slot[slot].saved_regs_va[reg]) {

			ddi_regs_map_free(
			    &schpc_p->schpc_slot[slot].saved_handle[reg]);

			schpc_p->schpc_slot[slot].saved_regs_va[reg] = NULL;
		}
	}

	kmem_free(schpc_p->schpc_slot[slot].saved_regs,
	    schpc_p->schpc_slot[slot].saved_size);

	schpc_p->schpc_slot[slot].saved_size = 0;
	schpc_p->schpc_slot[slot].saved_regs = NULL;

	SCHPC_DEBUG1(D_FREQCHG, "Slot %d - Leaf Registers Restored", slot);
}

static void
schpc_save_entry(int slot, int list_entry, int save_entry)
{
	int reg, reads = 0;

	reg = save_reg_list[list_entry].reg;

	while (reads < save_reg_list[list_entry].number) {
		switch (save_reg_list[list_entry].access_size) {
		case 8:
			schpc_p->schpc_slot[slot].saved_regs[save_entry] =
			    ddi_get64(
			    schpc_p->schpc_slot[slot].saved_handle[reg],
			    (uint64_t *)(schpc_p->schpc_slot[slot].
			    saved_regs_va[reg]
			    + save_reg_list[list_entry].offset +
			    (reads * sizeof (uint64_t))));
#ifdef DEBUG
			if (schpc_dump_save_regs)
				cmn_err(CE_WARN, "Save 64 %x %lx %lx\n", reg,
				    save_reg_list[list_entry].offset +
				    (reads * sizeof (uint64_t)),
				    schpc_p->schpc_slot[slot].
				    saved_regs[save_entry]);
#endif

			break;
		case 4:
			schpc_p->schpc_slot[slot].saved_regs[save_entry] =
			    ddi_get32(
			    schpc_p->schpc_slot[slot].saved_handle[reg],
			    (uint32_t *)(schpc_p->schpc_slot[slot].
			    saved_regs_va[reg]
			    + save_reg_list[list_entry].offset +
			    (reads * sizeof (uint32_t))));

#ifdef DEBUG
			if (schpc_dump_save_regs)
				cmn_err(CE_WARN, "Save 32 %x %lx %lx\n", reg,
				    save_reg_list[list_entry].offset +
				    (reads * sizeof (uint32_t)),
				    schpc_p->schpc_slot[slot].
				    saved_regs[save_entry]);
#endif

			break;
		case 2:
			schpc_p->schpc_slot[slot].saved_regs[save_entry] =
			    ddi_get16(
			    schpc_p->schpc_slot[slot].saved_handle[reg],
			    (uint16_t *)(schpc_p->schpc_slot[slot].
			    saved_regs_va[reg]
			    + save_reg_list[list_entry].offset +
			    (reads * sizeof (uint16_t))));

#ifdef DEBUG
			if (schpc_dump_save_regs)
				cmn_err(CE_WARN, "Save 16 %x %lx %lx\n", reg,
				    save_reg_list[list_entry].offset +
				    (reads * sizeof (uint16_t)),
				    schpc_p->schpc_slot[slot].
				    saved_regs[save_entry]);
#endif

			break;
		case 1:
			schpc_p->schpc_slot[slot].saved_regs[save_entry] =
			    ddi_get8(
			    schpc_p->schpc_slot[slot].saved_handle[reg],
			    (uint8_t *)(schpc_p->schpc_slot[slot].
			    saved_regs_va[reg]
			    + save_reg_list[list_entry].offset +
			    (reads * sizeof (uint8_t))));

#ifdef DEBUG
			if (schpc_dump_save_regs)
				cmn_err(CE_WARN, "Save 8 %x %lx %lx\n", reg,
				    save_reg_list[list_entry].offset +
				    (reads * sizeof (uint8_t)),
				    schpc_p->schpc_slot[slot].
				    saved_regs[save_entry]);
#endif

			break;
		default:
			cmn_err(CE_WARN,
			    "schpc: Illegal List Entry\n");
		}
		reads++;
		save_entry++;
	}
}

static void
schpc_restore_entry(int slot, int list_entry, int save_entry)
{
	int reg, writes = 0;

	reg = save_reg_list[list_entry].reg;

	while (writes < save_reg_list[list_entry].number) {
		switch (save_reg_list[list_entry].access_size) {
		case 8:
#ifdef DEBUG
			if (schpc_dump_save_regs)
				cmn_err(CE_WARN, "Restore 64 %x %lx %lx\n", reg,
				    save_reg_list[list_entry].offset +
				    (writes * sizeof (uint64_t)),
				    schpc_p->schpc_slot[slot].
				    saved_regs[save_entry]);
#endif

			ddi_put64(schpc_p->schpc_slot[slot].saved_handle[reg],
			    (uint64_t *)(schpc_p->schpc_slot[slot].
			    saved_regs_va[reg]
			    + save_reg_list[list_entry].offset +
			    (writes * sizeof (uint64_t))),
			    schpc_p->schpc_slot[slot].saved_regs[save_entry]);

			break;
		case 4:
#ifdef DEBUG
			if (schpc_dump_save_regs)
				cmn_err(CE_WARN, "Restore 32 %x %lx %lx\n", reg,
				    save_reg_list[list_entry].offset +
				    (writes * sizeof (uint32_t)),
				    schpc_p->schpc_slot[slot].
				    saved_regs[save_entry]);
#endif

			ddi_put32(schpc_p->schpc_slot[slot].saved_handle[reg],
			    (uint32_t *)(schpc_p->schpc_slot[slot].
			    saved_regs_va[reg]
			    + save_reg_list[list_entry].offset +
			    (writes * sizeof (uint32_t))),
			    schpc_p->schpc_slot[slot].saved_regs[save_entry]);

			break;
		case 2:
#ifdef DEBUG
			if (schpc_dump_save_regs)
				cmn_err(CE_WARN, "Restore 16 %x %lx %lx\n", reg,
				    save_reg_list[list_entry].offset +
				    (writes * sizeof (uint16_t)),
				    schpc_p->schpc_slot[slot].
				    saved_regs[save_entry]);
#endif

			ddi_put16(schpc_p->schpc_slot[slot].saved_handle[reg],
			    (uint16_t *)(schpc_p->schpc_slot[slot].
			    saved_regs_va[reg]
			    + save_reg_list[list_entry].offset +
			    (writes * sizeof (uint16_t))),
			    schpc_p->schpc_slot[slot].saved_regs[save_entry]);

			break;
		case 1:
#ifdef DEBUG
			if (schpc_dump_save_regs)
				cmn_err(CE_WARN, "Restore 8 %x %lx %lx\n", reg,
				    save_reg_list[list_entry].offset +
				    (writes * sizeof (uint8_t)),
				    schpc_p->schpc_slot[slot].
				    saved_regs[save_entry]);
#endif

			ddi_put8(schpc_p->schpc_slot[slot].saved_handle[reg],
			    (uint8_t *)(schpc_p->schpc_slot[slot].
			    saved_regs_va[reg]
			    + save_reg_list[list_entry].offset +
			    (writes * sizeof (uint8_t))),
			    schpc_p->schpc_slot[slot].saved_regs[save_entry]);

			break;
		default:
			cmn_err(CE_WARN,
			    "schpc: Illegal List Entry\n");
		}
		writes++;
		save_entry++;
	}
}

/*
 * Returns TRUE if a leaf reset is required to change frequencies/mode.
 */
static int
schpc_is_leaf_reset_required(int slot)
{
	char *name;
	int32_t mod_rev;

	/*
	 * Only XMITS 3.0 and greater connected slots will require a
	 * reset to switch frequency and/or mode.
	 */
	name = ddi_binding_name(schpc_p->schpc_slot[slot].devi);

	if (strcmp(name, "pci108e,8002") == 0) {
		mod_rev = ddi_prop_get_int(DDI_DEV_T_ANY,
		    schpc_p->schpc_slot[slot].devi,
		    DDI_PROP_DONTPASS, "module-revision#", 0);

		SCHPC_DEBUG2(D_FREQCHG, "Slot %d - mod_rev=%x", slot, mod_rev);

		/*
		 * Check for XMITS 3.0 or greater.
		 */
		if (mod_rev >= XMITS_30) {

			/*
			 * The leaf attached to C5V0 (slot 1) should
			 * not be reset.
			 */
			if ((slot & 3) == 1) {

				SCHPC_DEBUG1(D_FREQCHG, "Slot %d - Leaf Reset "
				    "Not Required - C5V0", slot);

				return (0);
			}

			SCHPC_DEBUG1(D_FREQCHG, "Slot %d - Leaf Reset "
			    "Required", slot);

			return (1);
		}
	}
	SCHPC_DEBUG1(D_FREQCHG, "Slot %d - Leaf Reset NOT Required", slot);

	return (0);
}

/*
 * Returns TRUE if the bus can change frequencies.
 */
static int
schpc_is_freq_switchable(int slot)
{
	char *name;
	int32_t mod_rev;

	name = ddi_binding_name(schpc_p->schpc_slot[slot].devi);

	if (strcmp(name, "pci108e,8002") == 0) {
		mod_rev = ddi_prop_get_int(DDI_DEV_T_ANY,
		    schpc_p->schpc_slot[slot].devi,
		    DDI_PROP_DONTPASS, "module-revision#", 0);

		SCHPC_DEBUG2(D_FREQCHG, "Slot %d - mod_rev=%x", slot, mod_rev);

		/*
		 * We will only report back that XMITS 2.0 (mod_rev = 2)
		 * or greater will have the ability to switch frequencies.
		 */
		if (mod_rev >= XMITS_20) {
			SCHPC_DEBUG1(D_FREQCHG, "Slot %d - "
			    "Frequency is switchable", slot);
			return (1);
		}
	}

	SCHPC_DEBUG1(D_FREQCHG, "Slot %d - Frequency is NOT switchable", slot);
	return (0);
}

/*
 * schpc_slot_freq
 *
 * Convert the slot frequency setting to integer value.
 */
static int
schpc_slot_freq(pci_getslot_t *getslotp)
{
	switch (getslotp->slot_freq_setting) {
	case PCIMSG_FREQ_33MHZ:
		return (SCHPC_33MHZ);
	case PCIMSG_FREQ_66MHZ:
		return (SCHPC_66MHZ);
	case PCIMSG_FREQ_90MHZ:
		return (SCHPC_90MHZ);
	case PCIMSG_FREQ_133MHZ:
		return (SCHPC_133MHZ);
	default:
		return (0);
	}
}

/*
 * schpc_find_dip
 *
 * Used by ddi_walk_devs to find the dip which belongs
 * to a certain slot.
 *
 * When this function returns, the dip is held.  It is the
 * responsibility of the caller to release the dip.
 */
static int
schpc_find_dip(dev_info_t *dip, void *arg)
{
	find_dev_t	*find_dev = (find_dev_t *)arg;
	char		*pathname = find_dev->caddr;

	(void) ddi_pathname(dip, pathname);
	if (strcmp(find_dev->cname, pathname) == 0) {
		ndi_hold_devi(dip);
		find_dev->dip = dip;
		return (DDI_WALK_TERMINATE);
	}
	return (DDI_WALK_CONTINUE);
}