serengeti/io/sgsbbc_mailbox.c

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

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

/*
 * Interface for Serengeti IOSRAM mailbox
 * OS <-> SC communication protocol
 */

#include <sys/types.h>
#include <sys/systm.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/kmem.h>
#include <sys/uadmin.h>
#include <sys/machsystm.h>
#include <sys/disp.h>
#include <sys/taskq.h>

#include <sys/sgevents.h>
#include <sys/sgsbbc_priv.h>
#include <sys/sgsbbc_iosram_priv.h>
#include <sys/sgsbbc_mailbox_priv.h>
#include <sys/plat_ecc_unum.h>
#include <sys/plat_ecc_dimm.h>
#include <sys/serengeti.h>
#include <sys/fm/util.h>
#include <sys/promif.h>
#include <sys/plat_datapath.h>

sbbc_mailbox_t	*master_mbox = NULL;

/*
 * Panic Shutdown event support
 */
static	kmutex_t	panic_hdlr_lock;

/*
 * The ID of the soft interrupt which triggers the bringing down of a Domain
 * when a PANIC_SHUTDOWN event is received.
 */
static ddi_softintr_t	panic_softintr_id = 0;

static sg_panic_shutdown_t	panic_payload;
static sbbc_msg_t		panic_payload_msg;

/*
 * A queue for making sure outgoing messages are in order as ScApp
 * does not support interleaving messages.
 */
static kcondvar_t	outbox_queue;
static kmutex_t		outbox_queue_lock;

/*
 * Handle unsolicited capability message.
 */
static plat_capability_data_t	cap_payload;
static sbbc_msg_t		cap_payload_msg;
static kmutex_t			cap_msg_hdlr_lock;

/*
 * Datapath error and fault messages arrive unsolicited.  The message data
 * is contained in a plat_datapath_info_t structure.
 */
typedef struct {
	uint8_t		type;		/* CDS, DX, CP */
	uint8_t		pad;		/* for alignment */
	uint16_t	cpuid;		/* Safari ID of base CPU */
	uint32_t	t_value;	/* SERD timeout threshold (seconds) */
} plat_datapath_info_t;

/*
 * Unsolicited datapath error messages are processed via a soft interrupt,
 * triggered in unsolicited interrupt processing.
 */
static	ddi_softintr_t		dp_softintr_id = 0;
static	kmutex_t		dp_hdlr_lock;

static	plat_datapath_info_t	dp_payload;
static	sbbc_msg_t		dp_payload_msg;

static char *dperrtype[] = {
	DP_ERROR_CDS,
	DP_ERROR_DX,
	DP_ERROR_RP
};

/*
 * Variable indicating if we are already processing requests.
 * Setting this value must be protected by outbox_queue_lock.
 */
static int		outbox_busy = 0;

/*
 * local stuff
 */
static int sbbc_mbox_send_msg(sbbc_msg_t *, int, uint_t, time_t, clock_t);
static int sbbc_mbox_recv_msg();
static int mbox_write(struct sbbc_mbox_header *,
	struct sbbc_fragment *, sbbc_msg_t *);
static int mbox_read(struct sbbc_mbox_header *, struct sbbc_fragment *,
	sbbc_msg_t *);
static int mbox_has_free_space(struct sbbc_mbox_header *);
static void mbox_skip_next_msg(struct sbbc_mbox_header *);
static int mbox_read_header(uint32_t, struct sbbc_mbox_header *);
static void mbox_update_header(uint32_t, struct sbbc_mbox_header *);
static int mbox_read_frag(struct sbbc_mbox_header *, struct sbbc_fragment *);
static struct sbbc_msg_waiter *mbox_find_waiter(uint16_t, uint32_t);
static void wakeup_next(void);
static uint_t sbbc_panic_shutdown_handler(char *arg);
static uint_t sbbc_do_fast_shutdown(char *arg);
static void sbbc_mbox_post_reg(sbbc_softstate_t *softsp);
static uint_t cap_ecc_msg_handler(char *);
static uint_t sbbc_datapath_error_msg_handler(char *arg);
static uint_t sbbc_datapath_fault_msg_handler(char *arg);
static uint_t sbbc_dp_trans_event(char *arg);


/*
 * Interrupt handlers
 */
static int sbbc_mbox_msgin(void);
static int sbbc_mbox_msgout(void);
static int sbbc_mbox_spacein(void);
static int sbbc_mbox_spaceout(void);

/*
 * ECC event mailbox message taskq and parameters
 */
static taskq_t	*sbbc_ecc_mbox_taskq = NULL;
static int	sbbc_ecc_mbox_taskq_errs = 0;
static int	sbbc_ecc_mbox_send_errs = 0;
static int	sbbc_ecc_mbox_inval_errs = 0;
static int	sbbc_ecc_mbox_other_errs = 0;
int	sbbc_ecc_mbox_err_throttle = ECC_MBOX_TASKQ_ERR_THROTTLE;

/*
 * Called when SBBC driver is loaded
 * Initialise global mailbox stuff, etc
 */
void
sbbc_mbox_init()
{
	int	i;

	master_mbox = kmem_zalloc(sizeof (sbbc_mailbox_t), KM_NOSLEEP);
	if (master_mbox == NULL) {
		cmn_err(CE_PANIC, "Can't allocate memory for mailbox\n");
	}

	/*
	 * mutex'es for the wait-lists
	 */
	for (i = 0; i < SBBC_MBOX_MSG_TYPES; i++) {
		mutex_init(&master_mbox->mbox_wait_lock[i],
			NULL, MUTEX_DEFAULT, NULL);
		master_mbox->mbox_wait_list[i] = NULL;
	}

	for (i = 0; i < SBBC_MBOX_MSG_TYPES; i++)
		master_mbox->intrs[i] = NULL;

	/*
	 * Two mailbox channels SC -> OS , read-only
	 *			OS -> SC, read/write
	 */
	master_mbox->mbox_in = kmem_zalloc(sizeof (sbbc_mbox_t), KM_NOSLEEP);
	if (master_mbox->mbox_in == NULL) {
		cmn_err(CE_PANIC,
			"Can't allocate memory for inbound mailbox\n");
	}

	master_mbox->mbox_out = kmem_zalloc(sizeof (sbbc_mbox_t), KM_NOSLEEP);
	if (master_mbox->mbox_out == NULL) {
		cmn_err(CE_PANIC,
			"Can't allocate memory for outbound mailbox\n");
	}

	mutex_init(&master_mbox->mbox_in->mb_lock, NULL,
		MUTEX_DEFAULT, NULL);
	mutex_init(&master_mbox->mbox_out->mb_lock, NULL,
		MUTEX_DEFAULT, NULL);

	/*
	 * Add PANIC_SHUTDOWN Event mutex
	 */
	mutex_init(&panic_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);

	/* Initialize datapath error message handler mutex */
	mutex_init(&dp_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);

	/* Initialize capability message handler event mutex */
	mutex_init(&cap_msg_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);

	/*
	 * NOT USED YET
	 */
	master_mbox->mbox_in->mb_type =
		master_mbox->mbox_out->mb_type = 0;

	cv_init(&outbox_queue, NULL, CV_DEFAULT, NULL);
	mutex_init(&outbox_queue_lock, NULL, MUTEX_DEFAULT, NULL);

}

/*
 * called when the SBBC driver is unloaded
 */
void
sbbc_mbox_fini()
{
	int	i;
	int	err;

	/*
	 * destroy ECC event mailbox taskq
	 */
	if (sbbc_ecc_mbox_taskq != NULL) {
		taskq_destroy(sbbc_ecc_mbox_taskq);
		sbbc_ecc_mbox_taskq = NULL;
		sbbc_ecc_mbox_taskq_errs = 0;
	}

	/*
	 * unregister interrupts
	 */
	(void) iosram_unreg_intr(SBBC_MAILBOX_IN);
	(void) iosram_unreg_intr(SBBC_MAILBOX_IN);
	(void) iosram_unreg_intr(SBBC_MAILBOX_SPACE_IN);
	(void) iosram_unreg_intr(SBBC_MAILBOX_SPACE_OUT);

	/*
	 * Remove Panic Shutdown and Datapath Error event support.
	 *
	 * NOTE: If we have not added the soft interrupt handlers for these
	 * then we know that we have not registered the event handlers either.
	 */
	if (panic_softintr_id != 0) {
		ddi_remove_softintr(panic_softintr_id);

		err = sbbc_mbox_unreg_intr(MBOX_EVENT_PANIC_SHUTDOWN,
			sbbc_panic_shutdown_handler);
		if (err != 0) {
			cmn_err(CE_WARN, "Failed to unreg Panic Shutdown "
				"handler. Err=%d", err);
		}
	}
	if (dp_softintr_id != 0) {
		ddi_remove_softintr(dp_softintr_id);

		err = sbbc_mbox_unreg_intr(MBOX_EVENT_DP_ERROR,
			sbbc_datapath_error_msg_handler);
		err |= sbbc_mbox_unreg_intr(MBOX_EVENT_DP_FAULT,
			sbbc_datapath_fault_msg_handler);
		if (err != 0) {
			cmn_err(CE_WARN, "Failed to unreg Datapath Error "
				"handler. Err=%d", err);
		}
	}

	/*
	 * destroy all its mutex'es, lists etc
	 */

	/*
	 * mutex'es for the wait-lists
	 */
	for (i = 0; i < SBBC_MBOX_MSG_TYPES; i++) {
		mutex_destroy(&master_mbox->mbox_wait_lock[i]);
	}

	mutex_destroy(&master_mbox->mbox_in->mb_lock);
	mutex_destroy(&master_mbox->mbox_out->mb_lock);

	mutex_destroy(&panic_hdlr_lock);
	mutex_destroy(&dp_hdlr_lock);

	kmem_free(master_mbox->mbox_in, sizeof (sbbc_mbox_t));
	kmem_free(master_mbox->mbox_out, sizeof (sbbc_mbox_t));
	kmem_free(master_mbox, sizeof (sbbc_mailbox_t));

	cv_destroy(&outbox_queue);
	mutex_destroy(&outbox_queue_lock);

	err = sbbc_mbox_unreg_intr(INFO_MBOX, cap_ecc_msg_handler);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to unregister capability message "
		    "handler. Err=%d", err);
	}

	mutex_destroy(&cap_msg_hdlr_lock);
}

/*
 * Update iosram_sbbc to the new softstate after a tunnel switch.
 * Move software interrupts from the old dip to the new dip.
 */
int
sbbc_mbox_switch(sbbc_softstate_t *softsp)
{
	sbbc_intrs_t	*intr;
	int		msg_type;
	int		rc = 0;
	int		err;

	if (master_mbox == NULL)
		return (ENXIO);

	ASSERT(MUTEX_HELD(&master_iosram->iosram_lock));

	for (msg_type = 0; msg_type < SBBC_MBOX_MSG_TYPES; msg_type++) {

		for (intr = master_mbox->intrs[msg_type]; intr != NULL;
			intr = intr->sbbc_intr_next) {

			if (intr->sbbc_intr_id) {
				ddi_remove_softintr(intr->sbbc_intr_id);

				if (ddi_add_softintr(softsp->dip,
					DDI_SOFTINT_HIGH,
					&intr->sbbc_intr_id, NULL, NULL,
					intr->sbbc_handler, intr->sbbc_arg)
					!= DDI_SUCCESS) {

					cmn_err(CE_WARN,
						"Can't add SBBC mailbox "
						"softint for msg_type %x\n",
							msg_type);
					rc = ENXIO;
				}
			}
		}
	}

	/*
	 * Add PANIC_SHUTDOWN Event handler
	 */
	if (panic_softintr_id) {
		ddi_remove_softintr(panic_softintr_id);

		err = ddi_add_softintr(softsp->dip, DDI_SOFTINT_LOW,
			&panic_softintr_id, NULL, NULL,
			sbbc_do_fast_shutdown, NULL);

		if (err != DDI_SUCCESS) {
			cmn_err(CE_WARN, "Failed to register Panic "
				"Shutdown handler. Err=%d", err);
			(void) sbbc_mbox_unreg_intr(MBOX_EVENT_PANIC_SHUTDOWN,
				sbbc_panic_shutdown_handler);
			rc = ENXIO;
		}

	}
	/*
	 * Add Datapath Error Event handler
	 */
	if (dp_softintr_id) {
		ddi_remove_softintr(dp_softintr_id);

		err = ddi_add_softintr(softsp->dip, DDI_SOFTINT_LOW,
			&dp_softintr_id, NULL, NULL,
			sbbc_dp_trans_event, NULL);

		if (err != DDI_SUCCESS) {
			cmn_err(CE_WARN, "Failed to register Datapath "
				"Error Event handler. Err=%d", err);
			(void) sbbc_mbox_unreg_intr(MBOX_EVENT_DP_ERROR,
				sbbc_datapath_error_msg_handler);
			(void) sbbc_mbox_unreg_intr(MBOX_EVENT_DP_FAULT,
				sbbc_datapath_fault_msg_handler);
			rc = ENXIO;
		}

	}

	return (rc);
}

/*
 * Called when the IOSRAM tunnel is created for the 'chosen' node.
 *
 * Read the mailbox header from the IOSRAM
 * tunnel[SBBC_MAILBOX_KEY]
 * Register the mailbox interrupt handlers
 * for messages in/space etc
 */
int
sbbc_mbox_create(sbbc_softstate_t *softsp)
{
	struct sbbc_mbox_header	header;

	int	i;
	int	err;
	int	rc = 0;

	/*
	 * This function should only be called once when
	 * the chosen node is initialized.
	 */
	ASSERT(MUTEX_HELD(&chosen_lock));

	if (master_mbox == NULL)
		return (ENXIO);

	/*
	 * read the header at offset 0
	 * check magic/version etc
	 */
	if (rc = iosram_read(SBBC_MAILBOX_KEY, 0, (caddr_t)&header,
	    sizeof (struct sbbc_mbox_header))) {

		return (rc);
	}

	/*
	 * add the interrupt handlers for the mailbox
	 * interrupts
	 */
	for (i = 0; i < MBOX_INTRS; i++) {
		sbbc_intrfunc_t		intr_handler;
		uint_t 			*state;
		kmutex_t 		*lock;
		uint32_t		intr_num;

		switch (i) {
		case MBOX_MSGIN_INTR:
			intr_handler = (sbbc_intrfunc_t)sbbc_mbox_msgin;
			intr_num = SBBC_MAILBOX_IN;
			break;
		case MBOX_MSGOUT_INTR:
			intr_handler = (sbbc_intrfunc_t)sbbc_mbox_msgout;
			intr_num = SBBC_MAILBOX_OUT;
			break;
		case MBOX_SPACEIN_INTR:
			intr_handler = (sbbc_intrfunc_t)sbbc_mbox_spacein;
			intr_num = SBBC_MAILBOX_SPACE_IN;
			break;
		case MBOX_SPACEOUT_INTR:
			intr_handler = (sbbc_intrfunc_t)sbbc_mbox_spaceout;
			intr_num = SBBC_MAILBOX_SPACE_OUT;
			break;
		}
		state = (uint_t *)&master_mbox->intr_state[i].mbox_intr_state;
		lock = &master_mbox->intr_state[i].mbox_intr_lock;
		if (iosram_reg_intr(intr_num, intr_handler, (caddr_t)NULL,
			state, lock)) {

			cmn_err(CE_WARN,
				"Can't register Mailbox interrupts \n");
		}
	}

	/*
	 * Add PANIC_SHUTDOWN Event handler
	 */
	panic_payload_msg.msg_buf = (caddr_t)&panic_payload;
	panic_payload_msg.msg_len = sizeof (panic_payload);

	err = ddi_add_softintr(softsp->dip, DDI_SOFTINT_LOW, &panic_softintr_id,
		NULL, NULL, sbbc_do_fast_shutdown, NULL);

	if (err == DDI_SUCCESS) {
		err = sbbc_mbox_reg_intr(MBOX_EVENT_PANIC_SHUTDOWN,
			sbbc_panic_shutdown_handler, &panic_payload_msg,
			NULL, &panic_hdlr_lock);
		if (err != 0) {
			cmn_err(CE_WARN, "Failed to register Panic "
				"Shutdown handler. Err=%d", err);
		}

	} else {
		cmn_err(CE_WARN, "Failed to add Panic Shutdown "
			"softintr handler");
	}

	/*
	 * Add Unsolicited Datapath Error Events handler
	 */
	dp_payload_msg.msg_buf = (caddr_t)&dp_payload;
	dp_payload_msg.msg_len = sizeof (dp_payload);

	err = ddi_add_softintr(softsp->dip, DDI_SOFTINT_LOW, &dp_softintr_id,
		NULL, NULL, sbbc_dp_trans_event, NULL);

	if (err == DDI_SUCCESS) {
		err = sbbc_mbox_reg_intr(MBOX_EVENT_DP_ERROR,
			sbbc_datapath_error_msg_handler, &dp_payload_msg,
			NULL, &dp_hdlr_lock);
		err |= sbbc_mbox_reg_intr(MBOX_EVENT_DP_FAULT,
			sbbc_datapath_fault_msg_handler, &dp_payload_msg,
			NULL, &dp_hdlr_lock);
		if (err != 0) {
			cmn_err(CE_WARN, "Failed to register Datapath "
				"error handler. Err=%d", err);
		}

	} else {
		cmn_err(CE_WARN, "Failed to add Datapath error "
			"softintr handler");
	}

	/*
	 * Register an interrupt handler with the sgbbc driver for the
	 * unsolicited INFO_MBOX response for the capability bitmap.
	 * This message is expected whenever the SC is (re)booted or
	 * failed over.
	 */
	cap_payload_msg.msg_buf = (caddr_t)&cap_payload;
	cap_payload_msg.msg_len = sizeof (cap_payload);

	err = sbbc_mbox_reg_intr(INFO_MBOX, cap_ecc_msg_handler,
	    &cap_payload_msg, NULL, &cap_msg_hdlr_lock);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to register capability message"
		    " handler with Err=%d", err);
	}

	/*
	 * Now is the opportunity to register
	 * the deferred mbox intrs.
	 */
	sbbc_mbox_post_reg(softsp);

	return (rc);
}

/*
 * Called when chosen IOSRAM is initialized
 * to register the deferred mbox intrs.
 */
static void
sbbc_mbox_post_reg(sbbc_softstate_t *softsp)
{
	uint32_t msg_type;
	sbbc_intrs_t	*intr;

	ASSERT(master_mbox);
	for (msg_type = 0;  msg_type < SBBC_MBOX_MSG_TYPES; msg_type++) {
		intr = master_mbox->intrs[msg_type];
		while (intr != NULL) {
			if (!intr->registered) {
				SGSBBC_DBG_INTR(CE_CONT, "sbbc_mbox_post_reg: "
					"postreg for msgtype=%x\n", msg_type);
				if (ddi_add_softintr(softsp->dip,
					DDI_SOFTINT_HIGH, &intr->sbbc_intr_id,
					NULL, NULL, intr->sbbc_handler,
					(caddr_t)intr->sbbc_arg)
						!= DDI_SUCCESS) {
					cmn_err(CE_WARN, "Can't add SBBC "
						"deferred mailbox softint \n");
				} else
					intr->registered = 1;
			}
			intr = intr->sbbc_intr_next;
		}
	}
}

/*
 * Register a handler for a message type
 * NB NB NB
 * arg must be either NULL or the address of a sbbc_fragment
 * pointer
 */
int
sbbc_mbox_reg_intr(uint32_t msg_type, sbbc_intrfunc_t intr_handler,
		sbbc_msg_t *arg, uint_t *state, kmutex_t *lock)
{
	sbbc_intrs_t	*intr, *previntr;
	int		rc = 0;

	/*
	 * Validate arguments
	 */
	if (msg_type >= SBBC_MBOX_MSG_TYPES)
		return (EINVAL);

	/*
	 * Verify that we have already set up the master sbbc
	 */
	if (master_iosram == NULL || master_mbox == NULL)
		return (ENXIO);

	mutex_enter(&master_iosram->iosram_lock);
	msg_type &= SBBC_MSG_TYPE_MASK;
	previntr = intr = master_mbox->intrs[msg_type];

	/* Find the end of the link list */
	while (intr != NULL && intr->sbbc_handler != intr_handler) {

		previntr = intr;
		intr = intr->sbbc_intr_next;
	}

	/* Return if the handler has been registered */
	if (intr != NULL) {
		mutex_exit(&master_iosram->iosram_lock);
		return (EBUSY);
	}

	/*
	 * The requested handler has not been installed.
	 * Allocate some memory.
	 */
	intr = kmem_zalloc(sizeof (sbbc_intrs_t), KM_SLEEP);

	intr->sbbc_handler  = intr_handler;
	intr->sbbc_arg = (caddr_t)arg;
	intr->sbbc_intr_state = state;
	intr->sbbc_intr_lock = lock;
	intr->sbbc_intr_next = NULL;
	/* not registered yet */
	intr->registered = 0;

	if (previntr != NULL)
		previntr->sbbc_intr_next = intr;
	else
		master_mbox->intrs[msg_type] = intr;

	/*
	 * register only if the chosen IOSRAM is
	 * initialized, otherwise defer the registration
	 * until IOSRAM initialization.
	 */
	if (master_iosram->iosram_sbbc) {
		if (ddi_add_softintr(master_iosram->iosram_sbbc->dip,
			DDI_SOFTINT_HIGH,
			&intr->sbbc_intr_id, NULL, NULL,
			intr_handler, (caddr_t)arg) != DDI_SUCCESS) {
			cmn_err(CE_WARN, "Can't add SBBC mailbox softint \n");
			rc = ENXIO;
		} else
			intr->registered = 1;
	} else {
		SGSBBC_DBG_INTR(CE_CONT, "sbbc_mbox_reg_intr: "
				"deferring msg=%x registration\n", msg_type);
	}

	mutex_exit(&master_iosram->iosram_lock);

	return (rc);
}

/*
 * Unregister a handler for a message type
 */
int
sbbc_mbox_unreg_intr(uint32_t msg_type, sbbc_intrfunc_t intr_handler)
{
	sbbc_intrs_t		*intr, *previntr, *nextintr;

	/*
	 * Verify that we have already set up the master sbbc
	 */
	if (master_iosram == NULL || master_mbox == NULL)
		return (ENXIO);

	msg_type &= SBBC_MSG_TYPE_MASK;

	if (msg_type >= SBBC_MBOX_MSG_TYPES ||
		intr_handler == (sbbc_intrfunc_t)NULL) {

		return (EINVAL);
	}

	mutex_enter(&master_iosram->iosram_lock);

	previntr = intr = master_mbox->intrs[msg_type];

	/*
	 * No handlers installed
	 */
	if (intr == NULL) {
		mutex_exit(&master_iosram->iosram_lock);
		return (EINVAL);
	}

	while (intr != NULL) {

		/* Save the next pointer */
		nextintr = intr->sbbc_intr_next;

		/* Found a match.  Remove it from the link list */
		if (intr->sbbc_handler == intr_handler) {

			if (intr->sbbc_intr_id)
				ddi_remove_softintr(intr->sbbc_intr_id);

			kmem_free(intr, sizeof (sbbc_intrs_t));

			if (previntr != master_mbox->intrs[msg_type])
				previntr->sbbc_intr_next = nextintr;
			else
				master_mbox->intrs[msg_type] = nextintr;

			break;
		}

		/* update pointers */
		previntr = intr;
		intr = nextintr;
	}

	mutex_exit(&master_iosram->iosram_lock);

	return (0);
}
/*
 * Interrupt handlers - one for each mailbox
 * interrupt type
 */

/*
 * mailbox message received
 */
static int
sbbc_mbox_msgin()
{
	mutex_enter(&master_mbox->intr_state[MBOX_MSGIN_INTR].mbox_intr_lock);
	master_mbox->intr_state[MBOX_MSGIN_INTR].mbox_intr_state =
		SBBC_INTR_RUNNING;
	mutex_exit(&master_mbox->intr_state[MBOX_MSGIN_INTR].mbox_intr_lock);

	/*
	 * We are only locking the InBox here, not the whole
	 * mailbox. This is based on the assumption of
	 * complete separation of mailboxes - outbox is
	 * read/write, inbox is read-only.
	 * We only ever update the producer for the
	 * outbox and the consumer for the inbox.
	 */
	mutex_enter(&master_mbox->mbox_in->mb_lock);

	for (;;) {
		/*
		 * Get as many incoming messages as possible
		 */
		while (sbbc_mbox_recv_msg() == 0)
			/* empty */;

		/*
		 * send interrupt to SC to let it know that
		 * space is available over here
		 */
		(void) iosram_send_intr(SBBC_MAILBOX_SPACE_IN);

		mutex_enter(&master_mbox->intr_state[MBOX_MSGIN_INTR].
			mbox_intr_lock);
		/*
		 * Read the inbox one more time to see if new messages
		 * has come in after we exit the loop.
		 */
		if (sbbc_mbox_recv_msg() == 0) {
			mutex_exit(&master_mbox->intr_state[MBOX_MSGIN_INTR].
				mbox_intr_lock);
		} else {
			master_mbox->intr_state[MBOX_MSGIN_INTR].
				mbox_intr_state = SBBC_INTR_IDLE;
			mutex_exit(&master_mbox->intr_state[MBOX_MSGIN_INTR].
				mbox_intr_lock);
			break;
		}
	}

	mutex_exit(&master_mbox->mbox_in->mb_lock);

	return (DDI_INTR_CLAIMED);
}

/*
 * mailbox message sent
 */
static int
sbbc_mbox_msgout()
{
	/*
	 * Should never get this
	 */

	return (DDI_INTR_CLAIMED);
}

/*
 * space in the inbox
 */
static int
sbbc_mbox_spacein()
{
	/*
	 * Should never get this
	 */

	return (DDI_INTR_CLAIMED);
}

/*
 * space in the outbox
 */
static int
sbbc_mbox_spaceout()
{
	/*
	 * cv_broadcast() the threads waiting on the
	 * outbox's mb_full
	 */

	mutex_enter(&master_mbox->mbox_out->mb_lock);

	cv_broadcast(&master_mbox->mbox_out->mb_full);

	mutex_exit(&master_mbox->mbox_out->mb_lock);

	return (DDI_INTR_CLAIMED);
}

/*
 * Client Interface
 *
 * The main interface will be
 *
 * sbbc_mbox_request_response(sbbc_msg_t *request,
 * 			sbbc_msg_t *response, time_t wait_time)
 *
 * 1) the client calls request_response
 * 2) a new unique msg ID is assigned for that msg
 * 3) if there is space available in the outbox
 *    - the request msg is written to the mbox_out mailbox
 *	and the mailbox info updated.
 *    - allocate a sbbc_msg_waiter struct for this
 *	message, initialise the w_cv condvar.
 *    - get the mailbox mbox_wait_lock mutex for this
 *      message type
 *    - the response msg is put on the mbox_wait_list for
 *	that message type to await the SC's response
 *    - wait on the w_cv condvar protected by the
 *	mbox_wait_lock
 *    - SBBC_MAILBOX_OUT interrupt is sent to the SC
 *
 * 4) if no space in the outbox,
 *    - the request message blocks waiting
 *	for a SBBC_MAILBOX_SPACE_OUT interrupt
 *      It will block on the mailbox mb_full condvar.
 *    - go to (3) above
 * 5) When we get a SBBC_MAILBOX_IN interrupt.
 *    - read the message ID of the next message (FIFO)
 *    - find that ID on the wait list
 *    - no wait list entry => unsolicited message. If theres
 *      a handler, trigger it
 *    - if someone is waiting, read the message in from
 *	SRAM, handling fragmentation, wraparound, etc
 *    - if the whole message has been read, signal
 *	the waiter
 *    - read next message until mailbox empty
 *    - send SBBC_MAILBOX_SPACE_IN interrupt to the SC
 *
 * 6) If a response is required and none is received, the client
 *	will timeout after <wait_time> seconds and the message
 *	status will be set to ETIMEDOUT.
 */
int
sbbc_mbox_request_response(sbbc_msg_t *request,
		sbbc_msg_t *response, time_t wait_time)
{

	struct sbbc_msg_waiter	*waiter;
	uint_t			msg_id;
	int			rc = 0;
	int			flags;
	uint16_t		msg_type;
	clock_t			stop_time;
	clock_t			clockleft;
	kmutex_t		*mbox_wait_lock;
	kmutex_t		*mb_lock;
	static fn_t		f = "sbbc_mbox_request_response";

	if ((request == NULL) ||
		(request->msg_type.type >= SBBC_MBOX_MSG_TYPES) ||
		((response != NULL) &&
		(response->msg_type.type >= SBBC_MBOX_MSG_TYPES)))
		return (EINVAL);

	msg_type = request->msg_type.type;

	/*
	 * Verify that we have already set up the master sbbc
	 */
	if (master_mbox == NULL)
		return (ENXIO);
	mbox_wait_lock = &master_mbox->mbox_wait_lock[msg_type];

	flags = WAIT_FOR_REPLY|WAIT_FOR_SPACE;

	/*
	 * We want to place a lower limit on the shortest amount of time we
	 * will wait before timing out while communicating with the SC via
	 * the mailbox.
	 */
	if (wait_time < sbbc_mbox_min_timeout)
		wait_time = sbbc_mbox_default_timeout;

	stop_time = ddi_get_lbolt() + wait_time * drv_usectohz(MICROSEC);

	/*
	 * If there is a message being processed, sleep until it is our turn.
	 */
	mutex_enter(&outbox_queue_lock);

	/*
	 * allocate an ID for this message, let it wrap
	 * around transparently.
	 * msg_id == 0 is unsolicited message
	 */
	msg_id = ++(master_mbox->mbox_msg_id);
	if (msg_id == 0)
		msg_id = ++(master_mbox->mbox_msg_id);

	SGSBBC_DBG_MBOX("%s: msg_id = 0x%x, msg_len = 0x%x\n",
		f, msg_id, request->msg_len);

	/*
	 * A new message can actually grab the lock before the thread
	 * that has just been signaled.  Therefore, we need to double
	 * check to make sure that outbox_busy is not already set
	 * after we wake up.
	 *
	 * Potentially this could mean starvation for certain unfortunate
	 * threads that keep getting woken up and putting back to sleep.
	 * But the window of such contention is very small to begin with.
	 */
	while (outbox_busy) {

		clockleft = cv_timedwait(&outbox_queue, &outbox_queue_lock,
			stop_time);

		SGSBBC_DBG_MBOX("%s: msg_id = 0x%x is woken up\n", f, msg_id);

		/*
		 * If we have timed out, set status to ETIMEOUT and return.
		 */
		if (clockleft < 0) {
			SGSBBC_DBG_MBOX("%s: msg_id = 0x%x has timed out\n",
				f, msg_id);
			cmn_err(CE_NOTE,
				"Timed out obtaining SBBC outbox lock");
			request->msg_status = ETIMEDOUT;
			if (response != NULL)
				response->msg_status = ETIMEDOUT;
			mutex_exit(&outbox_queue_lock);
			return (ETIMEDOUT);
		}
	}

	outbox_busy = 1;
	mutex_exit(&outbox_queue_lock);

	/*
	 * We are only locking the OutBox from here, not the whole
	 * mailbox. This is based on the assumption of
	 * complete separation of mailboxes - outbox is
	 * read/write, inbox is read-only.
	 * We only ever update the producer for the
	 * outbox and the consumer for the inbox.
	 */
	mb_lock = &master_mbox->mbox_out->mb_lock;
	mutex_enter(mb_lock);

	/*
	 * No response expected ? Just send the message and return
	 */
	if (response == NULL) {
		rc = sbbc_mbox_send_msg(request, flags, msg_id, wait_time,
			stop_time);
		SGSBBC_DBG_MBOX("%s: msg_id = 0x%x send rc = %d\n",
		    f, msg_id, rc);

		wakeup_next();

		mutex_exit(mb_lock);
		request->msg_status = rc;
		return (rc);
	}

	/*
	 * allocate/initialise a waiter
	 */
	waiter = kmem_zalloc(sizeof (struct sbbc_msg_waiter), KM_NOSLEEP);

	if (waiter == (struct sbbc_msg_waiter *)NULL) {
		cmn_err(CE_WARN, "SBBC Mailbox can't allocate waiter\n");

		wakeup_next();

		mutex_exit(mb_lock);
		return (ENOMEM);
	}

	waiter->w_id = 0;	/* Until we get an ID from the send */
	waiter->w_msg = response;
	waiter->w_msg->msg_status = EINPROGRESS;

	cv_init(&waiter->w_cv, NULL, CV_DEFAULT, NULL);

	rc = sbbc_mbox_send_msg(request, flags, msg_id, wait_time, stop_time);

	wakeup_next();

	if (rc != 0) {

		request->msg_status = response->msg_status = rc;
		mutex_exit(mb_lock);

		/* Free the waiter */
		cv_destroy(&waiter->w_cv);
		kmem_free(waiter, sizeof (struct sbbc_msg_waiter));

		SGSBBC_DBG_MBOX("%s: msg_id = 0x%x send rc = %d\n",
		    f, msg_id, rc);

		return (rc);
	}

	waiter->w_id = msg_id;

	/*
	 * Lock this waiter list and add the waiter
	 */
	mutex_enter(mbox_wait_lock);

	if (master_mbox->mbox_wait_list[msg_type] == NULL) {
		master_mbox->mbox_wait_list[msg_type] = waiter;
		waiter->w_next = NULL;
	} else {
		struct sbbc_msg_waiter	*tmp;
		tmp = master_mbox->mbox_wait_list[msg_type];
		master_mbox->mbox_wait_list[msg_type] = waiter;
		waiter->w_next = tmp;
	}

	mutex_exit(mb_lock);

	/*
	 * wait here for a response to our message
	 * holding the mbox_wait_lock for the list ensures
	 * that the interrupt handler can't get in before
	 * we block.
	 * NOTE: We use the request msg_type for the
	 *	 the wait_list. This ensures that  the
	 *	 msg_type won't change.
	 */
	clockleft = cv_timedwait(&waiter->w_cv, mbox_wait_lock, stop_time);

	SGSBBC_DBG_MBOX("%s: msg_id = 0x%x is woken up for response\n",
		f, msg_id);

	/*
	 * If we have timed out, set msg_status to ETIMEDOUT,
	 * and remove the waiter from the waiter list.
	 */
	if (clockleft < 0) {
		/*
		 * Remove the waiter from the waiter list.
		 * If we can't find the waiter in the list,
		 * 1. msg_status == EINPROGRESS
		 *    It is being processed.  We will give it
		 *    a chance to finish.
		 * 2. msg_status != EINPROGRESS
		 *    It is done processing.  We can safely
		 *    remove it.
		 * If we can find the waiter, it has timed out.
		 */
		SGSBBC_DBG_MBOX("%s: msg_id = 0x%x has timed out\n",
			f, msg_id);
		if (mbox_find_waiter(msg_type, msg_id) == NULL) {
			if (waiter->w_msg->msg_status == EINPROGRESS) {
				SGSBBC_DBG_MBOX("%s: Waiting for msg_id = 0x%x "
					"complete.\n", f, msg_id);
				cv_wait(&waiter->w_cv, mbox_wait_lock);
			}
		} else {
			SGSBBC_DBG_MBOX("%s: setting msg_id = 0x%x "
				"to ETIMEDOUT\n", f, msg_id);
			cmn_err(CE_NOTE, "Timed out waiting for SC response");
			rc = waiter->w_msg->msg_status = ETIMEDOUT;
		}
	}

	/*
	 * lose the waiter
	 */
	cv_destroy(&waiter->w_cv);
	kmem_free(waiter, sizeof (struct sbbc_msg_waiter));

	mutex_exit(mbox_wait_lock);

	return (rc);

}

static void
wakeup_next()
{
	/*
	 * Done sending the current message or encounter an error.
	 * Wake up the one request in the outbox_queue.
	 */
	mutex_enter(&outbox_queue_lock);
	outbox_busy = 0;
	cv_signal(&outbox_queue);
	mutex_exit(&outbox_queue_lock);
}


/* ARGSUSED */
int
sbbc_mbox_send_msg(sbbc_msg_t *msg, int flags, uint_t msg_id,
	time_t wait_time, clock_t stop_time)
{
	struct sbbc_mbox_header	header;
	struct sbbc_fragment	frag;
	int			rc = 0;
	int			bytes_written;
	uint32_t		intr_enabled;
	clock_t			clockleft;
	static fn_t		f = "sbbc_mbox_send_msg";

	/*
	 * First check that the SC has enabled its mailbox
	 */
	rc = iosram_read(SBBC_INTR_SC_ENABLED_KEY, 0,
		(caddr_t)&intr_enabled, sizeof (intr_enabled));

	if (rc)
		return (rc);

	if (!(intr_enabled & SBBC_MAILBOX_OUT))
		return (ENOTSUP);

	/*
	 * read the mailbox header
	 */
	if (rc = mbox_read_header(SBBC_OUTBOX, &header))
		return (rc);

	/*
	 * Allocate/initialise a fragment for this message
	 */
	frag.f_id = msg_id;
	frag.f_type = msg->msg_type;
	frag.f_status = 0;
	frag.f_total_len = msg->msg_len;
	frag.f_frag_offset = 0;
	/*
	 * Throw in the message data
	 */
	bcopy(&msg->msg_data, &frag.f_data, sizeof (msg->msg_data));

	/*
	 * If not enough space is available
	 * write what we can and wait for
	 * an interrupt to tell us that more
	 * space is available
	 */

	bytes_written = 0;
	do {
		rc = mbox_write(&header, &frag, msg);

		if (rc != 0 && rc != ENOSPC) {
			return (rc);
		}

		if (rc == 0) {
			/*
			 * Always tell the SC when there is a message.
			 * Ignore returned value as not being able to
			 * signal the SC about space available does
			 * not stop the SC from processing input.
			 */
			(void) iosram_send_intr(SBBC_MAILBOX_OUT);
		}

		bytes_written += frag.f_frag_len;
		frag.f_frag_offset += frag.f_frag_len;
		if ((bytes_written < msg->msg_len) || (rc == ENOSPC)) {

			if (mbox_has_free_space(&header) <=
				sizeof (struct sbbc_fragment)) {

				int tmprc;

				clockleft = cv_timedwait(
					&master_mbox->mbox_out->mb_full,
					&master_mbox->mbox_out->mb_lock,
					stop_time);

				/* Return ETIMEDOUT if we timed out */
				if (clockleft < 0) {
					SGSBBC_DBG_MBOX("%s: msg_id = 0x%x "
						"has timed out\n", f, msg_id);
					cmn_err(CE_NOTE,
						"Timed out sending message "
						"to SC");
					return (ETIMEDOUT);
				}

				/* Read updated header from IOSRAM */
				if (tmprc = mbox_read_header(SBBC_OUTBOX,
				    &header)) {

					return (tmprc);
				}
			}
		}

		SGSBBC_DBG_MBOX("%s: msg_id = 0x%x, bytes_written = 0x%x, "
			"msg_len = 0x%x\n", f,
				msg_id, bytes_written, msg->msg_len);
	} while ((bytes_written < msg->msg_len) || (rc == ENOSPC));

	/*
	 * this could be a spurious interrupt
	 * as the SC may be merrily readings its
	 * mail even as send, but what can you do ? No
	 * synchronization method between SC <-> OS
	 * SRAM data eaters means that this is inevitable.
	 * It would take a bigger brain to fix this.
	 *
	 */
	(void) iosram_send_intr(SBBC_MAILBOX_OUT);

	return (rc);
}


/*
 * get next message
 * Read the next message from SRAM
 * Check if theres an entry on the wait queue
 * for this message
 * If yes, read the message in and signal
 * the waiter (if all the message has been received)
 * No, its unsolicited, if theres a handler installed for
 * this message type trigger it, otherwise toss
 * the message
 */
int
sbbc_mbox_recv_msg()
{
	struct sbbc_mbox_header	header;
	struct sbbc_fragment	frag;
	sbbc_msg_t		tmpmsg;	/* Temporary msg storage */
	int			rc = 0, i, first_hdlr, last_hdlr;
	uint32_t		intr_enabled;
	sbbc_intrs_t		*intr;
	struct sbbc_msg_waiter	*waiter;
	uint16_t		type;	/* frag.f_type.type */
	uint32_t		f_id;	/* frag.f_id */
	uint32_t		f_frag_offset, f_frag_len;
	kmutex_t		*mbox_wait_lock;
	static fn_t		f = "sbbc_mbox_recv_msg";

	/*
	 * First check that the OS has enabled its mailbox
	 */
	rc = iosram_read(SBBC_SC_INTR_ENABLED_KEY, 0,
		(caddr_t)&intr_enabled, sizeof (intr_enabled));

	if (rc) {
		return (rc);
	}

	if (!(intr_enabled & SBBC_MAILBOX_IN))
		return (ENOTSUP);

	/*
	 * read the mailbox header
	 */
	if (rc = mbox_read_header(SBBC_INBOX, &header))
		return (rc);

	/*
	 * check if any messages available. If
	 * consumer == producer then no more
	 * messages
	 */
	if ((header.mailboxes[SBBC_INBOX].mbox_consumer ==
		header.mailboxes[SBBC_INBOX].mbox_producer)) {

		return (-1);
	}

	/*
	 * read the fragment header for this message
	 */
	if (rc = mbox_read_frag(&header, &frag)) {

		return (rc);
	}

	/* Save to local variable for easy reading */
	type = frag.f_type.type;
	f_id = frag.f_id;

	SGSBBC_DBG_MBOX("%s: f_id = 0x%x\n", f, f_id);

	/*
	 * check the message type. If its invalid, we will
	 * just toss the message
	 */
	if (type >= SBBC_MBOX_MSG_TYPES) {
		goto done;
	}

	/*
	 * if theres no waiters for this message type, and theres
	 * no message handler installed, toss it.
	 *
	 * Unsolicited messages (f_id == 0) are tricky because we won't know
	 * when the handler has finished so that we can
	 * remove the message, so, given the small brains in operation
	 * here, what we do is restrict junk mail to zero-length
	 * messages, then we allocate a fragment using kmem,
	 * make a copy of the fragment in this memory,
	 * pass this pointer to the fragment, then skip the message.
	 * So even if there is data associated with the junkmail,
	 * the message handler doesn't get to see it
	 * We expect the mesaage handler to free the memory.
	 */
	if (type == SBBC_BROADCAST_MSG) {
		/*
		 * Broadcast message, trigger all handlers
		 */
		first_hdlr = 0;
		last_hdlr = SBBC_MBOX_MSG_TYPES - 1;
	} else if ((master_mbox->mbox_wait_list[type] == NULL) || (f_id == 0)) {
		/*
		 * Theres no waiters, or its unsolicited anyway
		 */
		first_hdlr = last_hdlr = type;
	} else {
		/*
		 * check the fragment message type, look at the wait list for
		 * that type to find its associated message
		 *
		 * First find the message. If we get it, take it off
		 * the waiter list and read the data. We will
		 * put it back on the list if necessary.
		 * This avoids the problem of a second message-in
		 * interrupt playing with this waiter.
		 * This will cut down on mutex spinning on the wait
		 * list locks, also, expect the next fragment to be
		 * for this messageso we might as well have it at the
		 * start of the list.
		 *
		 * its possible that a return message has a different type,
		 * (possible but not recommended!). So, if we don't find
		 * it on the list pointed to by the request type,
		 * go look at all the other lists
		 */

		mbox_wait_lock = &master_mbox->mbox_wait_lock[type];

		mutex_enter(mbox_wait_lock);
		if ((waiter = mbox_find_waiter(type, f_id)) == NULL) {
			for (i = 0; i < SBBC_MBOX_MSG_TYPES; i++) {
				if (i == type)
					continue;
				if ((waiter = mbox_find_waiter(i, f_id))
					!= NULL)
					break;
			}
		}
		mutex_exit(mbox_wait_lock);

		if (waiter == NULL) {
			rc = -1;
			/*
			 * there's no waiter for this message, but that
			 * could mean that this message is the start of
			 * a send/receive to us, and every 'first' request
			 * must by definition be unsolicited,
			 * so trigger the handler
			 */
			first_hdlr = last_hdlr = type;
		} else {
			SGSBBC_DBG_MBOX("%s: f_id = 0x%x, msg_id = 0x%x, "
				"msg_len = 0x%x\n",
					f, f_id, waiter->w_id,
					waiter->w_msg->msg_len);

			rc = mbox_read(&header, &frag, waiter->w_msg);

			SGSBBC_DBG_MBOX("%s: f_id = 0x%x, offset = 0x%x, "
				"len = 0x%x, total_len = 0x%x\n",
					f, frag.f_id, frag.f_frag_offset,
					frag.f_frag_len, frag.f_total_len);

			if (rc || ((frag.f_frag_offset + frag.f_frag_len) ==
				frag.f_total_len)) {
				/*
				 * failed or all the message has been read in
				 */
				mutex_enter(mbox_wait_lock);
				waiter->w_msg->msg_status = (rc == ENOMEM)?
					rc : frag.f_status;
				SGSBBC_DBG_MBOX("%s: msg_status = %d\n",
					f, waiter->w_msg->msg_status);
				cv_signal(&waiter->w_cv);
				mutex_exit(mbox_wait_lock);

			} else {
				/*
				 * back on the wait list
				 */
				mutex_enter(mbox_wait_lock);
				if (waiter->w_msg->msg_status == ETIMEDOUT) {
					cv_signal(&waiter->w_cv);
					mutex_exit(mbox_wait_lock);
					goto done;
				}

				if (master_mbox->mbox_wait_list[type] == NULL) {
					master_mbox->mbox_wait_list[type] =
						waiter;
					waiter->w_next = NULL;
				} else {
					struct sbbc_msg_waiter	*tmp;
					tmp = master_mbox->mbox_wait_list[type];
					master_mbox->mbox_wait_list[type] =
						waiter;
					waiter->w_next = tmp;
				}
				mutex_exit(mbox_wait_lock);
			}
			goto done;
		}
	}

	/*
	 * Set msg_len to f_frag_len so msg_buf will be large enough
	 * to contain what is in the fragment.
	 */
	f_frag_len = tmpmsg.msg_len = frag.f_frag_len;
	/*
	 * Save the f_frag_offset for copying into client's space.
	 * Set frag.f_frag_offset to 0 so we don't have to allocate
	 * too much space for reading in the message.
	 */
	f_frag_offset = frag.f_frag_offset;
	frag.f_frag_offset = 0;

	/* Allocate space for msg_buf */
	if (f_frag_len != 0 && (tmpmsg.msg_buf =
		kmem_alloc(f_frag_len, KM_NOSLEEP)) == NULL) {

		rc = ENOMEM;
		cmn_err(CE_WARN, "Can't allocate memory"
			" for unsolicited messages\n");
	} else {
		/* Save the incoming message in tmpmsg */
		rc = mbox_read(&header, &frag, &tmpmsg);

		for (i = first_hdlr; rc == 0 && i <= last_hdlr; i++) {

			intr = master_mbox->intrs[i];
			if ((intr == NULL) || (intr->sbbc_intr_id == 0)) {
				continue;
			}

			while (intr != NULL) {
				/*
				 * If the client has allocated enough space
				 * for incoming message, copy into the
				 * client buffer.
				 */
				sbbc_msg_t *arg = (sbbc_msg_t *)intr->sbbc_arg;
				if (arg != (void *)NULL) {
					if (arg->msg_len >= frag.f_total_len) {
						if (f_frag_len > 0)
							bcopy(tmpmsg.msg_buf,
								arg->msg_buf +
								f_frag_offset,
								f_frag_len);
					} else {
						arg->msg_status = ENOMEM;
					}
				}

				/*
				 * Only trigger the interrupt when we
				 * have received the whole message.
				 */
				if (f_frag_offset + f_frag_len ==
					frag.f_total_len) {

					ddi_trigger_softintr(
						intr->sbbc_intr_id);
				}
				intr = intr->sbbc_intr_next;
			}
		}

		if (f_frag_len != 0) {
			/* Don't forget to free the buffer */
			kmem_free(tmpmsg.msg_buf, f_frag_len);
		}
	}
done:
	mbox_skip_next_msg(&header);
	return (rc);
}

/*
 * available free space in the outbox
 */
static int
mbox_has_free_space(struct sbbc_mbox_header *header)
{
	uint32_t	space = 0;

	ASSERT(MUTEX_HELD(&master_mbox->mbox_out->mb_lock));

	if (header->mailboxes[SBBC_OUTBOX].mbox_producer ==
		header->mailboxes[SBBC_OUTBOX].mbox_consumer) {
		/*
		 * mailbox is empty
		 */
		space += header->mailboxes[SBBC_OUTBOX].mbox_len -
			header->mailboxes[SBBC_OUTBOX].mbox_producer;
		space +=
			header->mailboxes[SBBC_OUTBOX].mbox_producer;
	} else if (header->mailboxes[SBBC_OUTBOX].mbox_producer >
		header->mailboxes[SBBC_OUTBOX].mbox_consumer) {
		space += header->mailboxes[SBBC_OUTBOX].mbox_len -
			header->mailboxes[SBBC_OUTBOX].mbox_producer;
		space += header->mailboxes[SBBC_OUTBOX].mbox_consumer;
	} else {
		/*
		 * mailbox wrapped around
		 */
		space += header->mailboxes[SBBC_OUTBOX].mbox_consumer -
			header->mailboxes[SBBC_OUTBOX].mbox_producer;
	}

	/*
	 * Need to make sure that the mailbox never
	 * gets completely full, as consumer == producer is
	 * our test for empty, so we drop MBOX_ALIGN_BYTES.
	 */

	if (space >= MBOX_ALIGN_BYTES)
		space -= MBOX_ALIGN_BYTES;
	else
		space = 0;

	return (space);

}
/*
 * Write the data to IOSRAM
 * Update the SRAM mailbox header
 * Update the local mailbox pointers
 * Only write a single fragment. If possible,
 * put the whole message into a fragment.
 *
 * Note: We assume that there is no 'max' message
 *	 size. We will just keep fragmenting.
 * Note: We always write to SBBC_OUTBOX and
 *	 read from SBBC_INBOX
 *
 * If we get an error at any time, return immediately
 * without updating the mailbox header in SRAM
 */
static int
mbox_write(struct sbbc_mbox_header *header,
	struct sbbc_fragment *frag, sbbc_msg_t *msg)
{
	int		bytes_written, bytes_remaining, free_space;
	int		rc = 0;
	caddr_t		src;
	uint32_t	sram_dst;
	int		space_at_end, space_at_start;
	uint32_t	mbox_offset, mbox_len;
	uint32_t	mbox_producer, mbox_consumer;
	uint32_t	f_total_len, f_frag_offset;
	uint32_t	frag_header_size;
	static fn_t	f = "mbox_write";

	ASSERT(MUTEX_HELD(&master_mbox->mbox_out->mb_lock));

	/*
	 * Save to local variables to make code more readable
	 */
	mbox_offset = header->mailboxes[SBBC_OUTBOX].mbox_offset;
	mbox_len = header->mailboxes[SBBC_OUTBOX].mbox_len;
	mbox_producer = header->mailboxes[SBBC_OUTBOX].mbox_producer;
	mbox_consumer = header->mailboxes[SBBC_OUTBOX].mbox_consumer;
	f_total_len = frag->f_total_len;
	f_frag_offset = frag->f_frag_offset;
	frag_header_size = sizeof (struct sbbc_fragment);

	SGSBBC_DBG_MBOX("%s: mbox_consumer = 0x%x, "
		"mbox_producer = 0x%x\n", f, mbox_consumer, mbox_producer);

	/*
	 * Write pointer in SRAM
	 */
	sram_dst = mbox_offset + mbox_producer;

	/*
	 * NB We assume that the consumer stays constant
	 *    during the write. It may not necessarily
	 *    be the case but it won't cause us any problems, just means
	 *    we fragment more than is absolutely necessary
	 *
	 * possible cases
	 * 1) consumer == producer, mailbox empty
	 *	space_at_end == mailbox end - producer
	 *	space_at_start == producer - MBOX_ALIGN_BYTES
	 * 2) producer < consumer
	 *	space_at_end = (consumer - producer - MBOX_ALIGN_BYTES)
	 *	space_at_start == 0
	 * 3) producer > consumer
	 *	space_at_end = mailbox end - producer
	 *	space_at_start = consumer - MBOX_ALIGN_BYTES
	 *
	 * (space - MBOX_ALIGN_BYTES) because we need to avoid the
	 * scenario where the producer wraps around completely and
	 * producer == consumer, as this is our test for 'empty'.
	 * Also we want it to be 8-byte aligned.
	 * Note: start is assumed = 0
	 */
	if (mbox_producer < mbox_consumer) {
		space_at_end = mbox_consumer - mbox_producer - MBOX_ALIGN_BYTES;
		if (space_at_end < 0)
			space_at_end = 0;
		space_at_start = 0;
	} else {
		space_at_end = mbox_len - mbox_producer;
		if (mbox_consumer == 0)
			space_at_end -= MBOX_ALIGN_BYTES;
		space_at_start = mbox_consumer - MBOX_ALIGN_BYTES;
		if (space_at_start < 0)
			space_at_start = 0;
	}

	SGSBBC_DBG_MBOX("%s: space_at_end = 0x%x, space_at_start = 0x%x\n",
		f, space_at_end, space_at_start);

	free_space = space_at_end + space_at_start;

	if (free_space < frag_header_size) {
		/*
		 * can't even write a fragment header, so just return
		 * the caller will block waiting for space
		 */
		frag->f_frag_len = 0;
		return (ENOSPC);
	}

	/*
	 * How many bytes will be in the fragment ?
	 */
	bytes_remaining = f_total_len - f_frag_offset;
	frag->f_frag_len = min(bytes_remaining, free_space - frag_header_size);

	SGSBBC_DBG_MBOX("%s: writing header:sram_dst = 0x%x\n",
		f, sram_dst);

	/*
	 * we can write the fragment header and some data
	 * First, the fragment header
	 */
	if (space_at_end >=  frag_header_size) {
		rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst, (caddr_t)frag,
			frag_header_size);
		if (rc)
			return (rc);

		sram_dst = (uint32_t)(sram_dst + frag_header_size);
		/*
		 * Wrap around if we reach the end
		 */
		if (sram_dst >= (mbox_len + mbox_offset)) {
			sram_dst = mbox_offset;
		}
		space_at_end -= frag_header_size;
	} else {
		/* wraparound */
		if (space_at_end) {
			rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst,
				(caddr_t)frag, space_at_end);
			if (rc)
				return (rc);
			sram_dst = (uint32_t)mbox_offset;
		}
		rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst,
			(caddr_t)((caddr_t)frag + space_at_end),
			(frag_header_size - space_at_end));
		if (rc)
			return (rc);
		sram_dst += frag_header_size - space_at_end;
		space_at_start -= (frag_header_size - space_at_end);
		space_at_end = 0;
	}

	SGSBBC_DBG_MBOX("%s: space_at_end = 0x%x, space_at_start = 0x%x\n",
		f, space_at_end, space_at_start);

	/*
	 * Now the fragment data
	 */
	free_space -= frag_header_size;
	src = (caddr_t)(msg->msg_buf + f_frag_offset);
	bytes_written = 0;
	if (space_at_end) {
		SGSBBC_DBG_MBOX("%s: writing data:sram_dst = 0x%x, "
			"bytes_remaining = 0x%x\n",
				f, sram_dst, bytes_remaining);

		if (space_at_end < bytes_remaining)
			bytes_written = space_at_end;
		else
			bytes_written = bytes_remaining;
		rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst, src,
			bytes_written);
		if (rc)
			return (rc);

		sram_dst = (uint32_t)(sram_dst + bytes_written);
		/*
		 * Wrap around if we reach the end
		 */
		if (sram_dst >= (mbox_len + mbox_offset)) {
			sram_dst = mbox_offset;
		}
		src = (caddr_t)(src + bytes_written);
		bytes_remaining -= bytes_written;
	}

	if ((bytes_remaining > 0) && space_at_start) {
		SGSBBC_DBG_MBOX("%s: writing the rest:sram_dst = 0x%x, "
			"bytes_remaining = 0x%x\n",
				f, sram_dst, bytes_remaining);
		if (space_at_start < bytes_remaining) {
			rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst, src,
				space_at_start);
			bytes_written += space_at_start;
		} else {
			rc = iosram_write(SBBC_MAILBOX_KEY, sram_dst, src,
				bytes_remaining);
			bytes_written += bytes_remaining;
		}
		if (rc)
			return (rc);
	}

	frag->f_frag_len = bytes_written;

	/*
	 * update header->mbox_producer (bytes_written + frag_size)
	 */
	sram_dst = mbox_producer + bytes_written + frag_header_size;
	if (sram_dst >= mbox_len) {
		sram_dst = sram_dst % mbox_len;
	}

	SGSBBC_DBG_MBOX("%s: after writing data:sram_dst = 0x%x, "
		"bytes_written = 0x%x\n", f, sram_dst, bytes_written);

	header->mailboxes[SBBC_OUTBOX].mbox_producer = sram_dst;

	mbox_update_header(SBBC_OUTBOX, header);


	return (rc);
}


/*
 * Get the next frag from IOSRAM.
 * Write it to the corresponding msg buf.
 * The caller must update the SRAM pointers etc.
 */
static int
mbox_read(struct sbbc_mbox_header *header,
	struct sbbc_fragment *frag, sbbc_msg_t *msg)
{
	int			rc = 0;
	uint32_t		sram_src, sram_end;
	caddr_t			msg_buf;
	int			bytes_at_start, bytes_at_end;
	int			bytes_to_read;
	uint32_t		frag_header_size, frag_total_size;
	uint32_t		f_frag_offset, f_frag_len;
	uint32_t		mbox_producer, mbox_consumer;
	uint32_t		mbox_len, mbox_offset;
	static fn_t		f = "mbox_read";

	ASSERT(MUTEX_HELD(&master_mbox->mbox_in->mb_lock));

	/*
	 * Save to local variables to make code more readable
	 */
	mbox_producer = header->mailboxes[SBBC_INBOX].mbox_producer;
	mbox_consumer = header->mailboxes[SBBC_INBOX].mbox_consumer;
	mbox_len = header->mailboxes[SBBC_INBOX].mbox_len;
	mbox_offset = header->mailboxes[SBBC_INBOX].mbox_offset;
	frag_header_size = sizeof (struct sbbc_fragment);
	f_frag_offset = frag->f_frag_offset;
	f_frag_len = frag->f_frag_len;
	frag_total_size = frag_header_size + f_frag_len;

	/*
	 * If the message buffer size is smaller than the fragment
	 * size, return an error.
	 */
	if (msg->msg_len < f_frag_len)  {
		rc = ENOMEM;
		goto done;
	}

	msg_buf = (caddr_t)(msg->msg_buf + f_frag_offset);

	/*
	 * Throw in the message data
	 */
	bcopy(&frag->f_data, &msg->msg_data, sizeof (msg->msg_data));

	/*
	 * We have it all, waiter, message, so lets
	 * go get that puppy!
	 * Message could be in one or two chunks -
	 * consumer < producer: 1 chunk, (producer - consumer)
	 * consumer > producer: 2 chunks, (end - consumer)
	 *				 (producer - start)
	 */
	sram_end =  (uint32_t)(mbox_offset + mbox_len);
	sram_src = (uint32_t)(mbox_offset + mbox_consumer + frag_header_size);

	/*
	 * wraparound
	 */
	if (sram_src >= sram_end)
		sram_src -= mbox_len;

	/*
	 * find where the data is
	 * possible cases
	 * 1) consumer == producer, mailbox empty
	 *	error
	 * 2) producer < consumer
	 *	bytes_at_end =  mailbox end - consumer
	 *	bytes_at_start = producer
	 * 3) producer > consumer
	 *	bytes_at_end =  producer - consumer
	 *	bytes_at_start = 0
	 */

	SGSBBC_DBG_MBOX("%s: mbox_consumer = 0x%x, mbox_producer = 0x%x, "
		"frag_len = 0x%x\n",
			f, mbox_consumer, mbox_producer, f_frag_len);

	if (mbox_producer == mbox_consumer) {
		bytes_at_end = bytes_at_start = 0;
	} else if (mbox_producer < mbox_consumer) {
		bytes_at_end = mbox_len - mbox_consumer;
		bytes_at_start = mbox_producer;
	} else {
		bytes_at_end = mbox_producer - mbox_consumer;
		bytes_at_start = 0;
	}

	SGSBBC_DBG_MBOX("%s: bytes_at_end = 0x%x, "
		"bytes_at_start = 0x%x\n", f, bytes_at_end, bytes_at_start);

	if ((bytes_at_end + bytes_at_start) < frag_total_size) {

		/*
		 * mailbox is corrupt
		 * but what to do ?
		 */
		cmn_err(CE_PANIC, "Corrupt INBOX!\n"
		    "producer = %x, consumer = %x, bytes_at_start = %x, "
		    "bytes_at_end = %x\n", mbox_producer, mbox_consumer,
		    bytes_at_start, bytes_at_end);
	}

	/*
	 * If bytes_at_end is greater than header size, read the
	 * part at the end of the mailbox, and then update the
	 * pointers and bytes_to_read.
	 */
	if (bytes_at_end > frag_header_size) {
		/*
		 * We are only interested in the data segment.
		 */
		bytes_at_end -= frag_header_size;
		bytes_to_read = (bytes_at_end >= f_frag_len)?
			f_frag_len : bytes_at_end;
		SGSBBC_DBG_MBOX("%s: reading data: sram_src = 0x%x, "
			"bytes_to_read = 0x%x\n", f, sram_src, bytes_to_read);
		rc = iosram_read(SBBC_MAILBOX_KEY, sram_src, msg_buf,
			bytes_to_read);
		if (rc) {
			goto done;
		}

		/*
		 * Update pointers in SRAM and message buffer.
		 */
		sram_src = (uint32_t)mbox_offset;
		msg_buf = (caddr_t)(msg_buf + bytes_to_read);
		bytes_to_read = f_frag_len - bytes_to_read;
	} else {
		bytes_to_read = f_frag_len;
	}

	/*
	 * wraparound to start of mailbox
	 */
	if (bytes_to_read > 0) {
		SGSBBC_DBG_MBOX("%s: reading the rest: sram_src = 0x%x, "
			"bytes_to_read = 0x%x\n", f, sram_src, bytes_to_read);
		rc = iosram_read(SBBC_MAILBOX_KEY, sram_src, msg_buf,
			bytes_to_read);
	}

done:
	msg->msg_bytes += f_frag_len;

	return (rc);
}

/*
 * move past the next message in the inbox
 */
static void
mbox_skip_next_msg(struct sbbc_mbox_header *header)
{
	struct sbbc_fragment	frag;
	uint32_t		next_msg;

	ASSERT(MUTEX_HELD(&master_mbox->mbox_in->mb_lock));

	if (mbox_read_frag(header, &frag)) {
		cmn_err(CE_PANIC, "INBOX is Corrupt !\n");
	}

	/*
	 * Move on to the next message
	 */
	next_msg = header->mailboxes[SBBC_INBOX].mbox_consumer;
	next_msg += sizeof (struct sbbc_fragment);
	next_msg += frag.f_frag_len;
	if (next_msg >= header->mailboxes[SBBC_INBOX].mbox_len) {
		next_msg = (next_msg +
			header->mailboxes[SBBC_INBOX].mbox_len) %
			header->mailboxes[SBBC_INBOX].mbox_len;
	}
	header->mailboxes[SBBC_INBOX].mbox_consumer =
		next_msg;

	mbox_update_header(SBBC_INBOX, header);

	return;

}

static struct sbbc_msg_waiter *
mbox_find_waiter(uint16_t msg_type, uint32_t msg_id)
{
	struct	sbbc_msg_waiter	*waiter, *prev;

	prev = NULL;
	for (waiter = master_mbox->mbox_wait_list[msg_type];
		waiter != NULL; waiter = waiter->w_next) {

		if (waiter->w_id == msg_id) {
			if (prev != NULL) {
				prev->w_next = waiter->w_next;
			} else {
				master_mbox->mbox_wait_list[msg_type] =
					waiter->w_next;
			}
			break;
		}
		prev = waiter;
	}

	return (waiter);
}

static int
mbox_read_header(uint32_t mailbox, struct sbbc_mbox_header *header)
{
	struct sbbc_mbox_header *hd;
	uint32_t	offset;
	int		rc;

	/*
	 * Initialize a sbbc_mbox_header pointer to 0 so that we
	 * can use it to calculate the offsets of fields inside
	 * the structure.
	 */
	hd = (struct sbbc_mbox_header *)0;

	if (rc = iosram_read(SBBC_MAILBOX_KEY, 0, (caddr_t)header,
	    sizeof (struct sbbc_mbox_header)))
		return (rc);

	/*
	 * Since the header is read in a byte-by-byte fashion
	 * using ddi_rep_get8, we need to re-read the producer
	 * or consumer pointer as integer in case it has changed
	 * after part of the previous value has been read.
	 */
	switch (mailbox) {

	case SBBC_INBOX:
		offset = (uint32_t)(uintptr_t)
		    (&hd->mailboxes[SBBC_INBOX].mbox_producer);
		rc = iosram_read(SBBC_MAILBOX_KEY, offset,
		    (caddr_t)&header->mailboxes[SBBC_INBOX].mbox_producer,
		    sizeof (uint32_t));
		break;
	case SBBC_OUTBOX:
		offset = (uint32_t)(uintptr_t)
		    (&hd->mailboxes[SBBC_OUTBOX].mbox_consumer);
		rc = iosram_read(SBBC_MAILBOX_KEY, offset,
		    (caddr_t)&header->mailboxes[SBBC_OUTBOX].mbox_consumer,
		    sizeof (uint32_t));
		break;
	default:
		cmn_err(CE_PANIC, "Invalid Mbox header type\n");
		break;

	}

	return (rc);
}

/*
 * There are only two fields updated by the  domain,
 * the inbox consumer field and the outbox producer
 * field. These fields are protected by the respective
 * mbox_{in|out}->mb_lock so that accesses will
 * be serialised. The only coherency issue is writing
 * back the header, so we do it here after grabbing
 * the global mailbox lock.
 */
static void
mbox_update_header(uint32_t mailbox, struct sbbc_mbox_header *header)
{
	struct sbbc_mbox_header	*hd;
	uint32_t		value, offset, mbox_len;

	/*
	 * Initialize a sbbc_mbox_header pointer to 0 so that we
	 * can use it to calculate the offsets of fields inside
	 * the structure.
	 */
	hd = (struct sbbc_mbox_header *)0;

	switch (mailbox) {

	case SBBC_INBOX:
		value = header->mailboxes[SBBC_INBOX].mbox_consumer;
		offset = (uint32_t)(uintptr_t)
			(&hd->mailboxes[SBBC_INBOX].mbox_consumer);

		mbox_len = header->mailboxes[SBBC_INBOX].mbox_len;
		break;
	case SBBC_OUTBOX:
		value = header->mailboxes[SBBC_OUTBOX].mbox_producer;
		offset = (uint32_t)(uintptr_t)
			(&hd->mailboxes[SBBC_OUTBOX].mbox_producer);
		mbox_len = header->mailboxes[SBBC_OUTBOX].mbox_len;
		break;
	default:
		cmn_err(CE_PANIC, "Invalid Mbox header type\n");
		break;

	}

	/*
	 * If the last read/write would cause the next read/write
	 * to be unaligned, we skip on modulo MBOX_ALIGN_BYTES.
	 * This is OK because all the mailbox handlers will
	 * conform to this.
	 */
	if (value % MBOX_ALIGN_BYTES) {
		value += (MBOX_ALIGN_BYTES - (value % MBOX_ALIGN_BYTES));
		value %= mbox_len;
	}

	if (iosram_write(SBBC_MAILBOX_KEY, offset, (caddr_t)&value,
		sizeof (uint32_t))) {
		cmn_err(CE_PANIC, "Mailbox Corrupt ! \n");
	}

	/*
	 * Update internal pointers so they won't be out of sync with
	 * the values in IOSRAM.
	 */
	switch (mailbox) {

	case SBBC_INBOX:
		header->mailboxes[SBBC_INBOX].mbox_consumer = value;
		break;
	case SBBC_OUTBOX:
		header->mailboxes[SBBC_OUTBOX].mbox_producer = value;
		break;
	}
}

static int
mbox_read_frag(struct sbbc_mbox_header *header,
	struct sbbc_fragment *frag)
{
	int			rc = 0;
	uint32_t		sram_src, bytes;
	caddr_t			dst;

	ASSERT(MUTEX_HELD(&master_mbox->mbox_in->mb_lock));
	/*
	 * read the fragment header for this message
	 */
	sram_src = (uint32_t)(header->mailboxes[SBBC_INBOX].mbox_offset +
		header->mailboxes[SBBC_INBOX].mbox_consumer);

	/*
	 * wraparound ?
	 */
	if ((header->mailboxes[SBBC_INBOX].mbox_consumer +
		sizeof (struct sbbc_fragment)) >=
		header->mailboxes[SBBC_INBOX].mbox_len) {

		dst = (caddr_t)frag;
		bytes = header->mailboxes[SBBC_INBOX].mbox_len -
			header->mailboxes[SBBC_INBOX].mbox_consumer;

		if (rc = iosram_read(SBBC_MAILBOX_KEY, sram_src, dst, bytes)) {
			return (rc);
		}

		dst += bytes;
		sram_src = header->mailboxes[SBBC_INBOX].mbox_offset;
		bytes = (header->mailboxes[SBBC_INBOX].mbox_consumer +
			sizeof (struct sbbc_fragment)) %
			header->mailboxes[SBBC_INBOX].mbox_len;

		if (rc = iosram_read(SBBC_MAILBOX_KEY, sram_src,
			dst, bytes)) {
			return (rc);
		}
	} else {
		if (rc = iosram_read(SBBC_MAILBOX_KEY, sram_src, (caddr_t)frag,
			sizeof (struct sbbc_fragment))) {
			return (rc);
		}
	}

	return (0);
}


/*
 * This function is triggered by a soft interrupt and it's purpose is to call
 * to kadmin() to shutdown the Domain.
 */
/*ARGSUSED0*/
static uint_t
sbbc_do_fast_shutdown(char *arg)
{
	(void) kadmin(A_SHUTDOWN, AD_POWEROFF, NULL, kcred);

	/*
	 * If kadmin fails for some reason then we bring the system down
	 * via power_down(), or failing that using halt().
	 */
	power_down("kadmin() failed, trying power_down()");

	halt("power_down() failed, trying halt()");

	/*
	 * We should never make it this far, so something must have gone
	 * horribly, horribly wrong.
	 */
	/*NOTREACHED*/
	return (DDI_INTR_UNCLAIMED);
}


/*
 * This function handles unsolicited PANIC_SHUTDOWN events
 */
static uint_t
sbbc_panic_shutdown_handler(char *arg)
{
	static fn_t	f = "sbbc_panic_shutdown_handler()";

	sg_panic_shutdown_t	*payload = NULL;
	sbbc_msg_t		*msg = NULL;

	if (arg == NULL) {
		SGSBBC_DBG_EVENT(CE_NOTE, "%s: arg == NULL", f);
		return (DDI_INTR_UNCLAIMED);
	}

	msg = (sbbc_msg_t *)arg;

	if (msg->msg_buf == NULL) {
		SGSBBC_DBG_EVENT(CE_NOTE, "%s: msg_buf == NULL", f);
		return (DDI_INTR_UNCLAIMED);
	}

	payload = (sg_panic_shutdown_t *)msg->msg_buf;

	switch (*payload) {
	case SC_EVENT_PANIC_ENV:

		/*
		 * Let the user know why the domain is going down.
		 */
		cmn_err(CE_WARN, "%s", PANIC_ENV_EVENT_MSG);

		/*
		 * trigger sbbc_do_fast_shutdown().
		 */
		ddi_trigger_softintr(panic_softintr_id);

		/*NOTREACHED*/
		break;

	case SC_EVENT_PANIC_KEYSWITCH:
		/*
		 * The SC warns a user if they try a destructive keyswitch
		 * command on a Domain which is currently running Solaris.
		 * If the user chooses to continue despite our best advise
		 * then we bring down the Domain immediately without trying
		 * to shut the system down gracefully.
		 */
		break;

	default:
		SGSBBC_DBG_EVENT(CE_NOTE, "%s: Unknown payload:%d", f,
			*payload);
		return (DDI_INTR_UNCLAIMED);
	}

	return (DDI_INTR_CLAIMED);
}

/*
 * dp_get_cores()
 *
 * Checks cpu implementation for the input cpuid and returns
 * the number of cores.
 * If implementation cannot be determined, returns 1
 */
static int
dp_get_cores(uint16_t cpuid)
{
	int	bd, ii, impl, nc;

	bd = cpuid / 4;
	nc = SG_MAX_CPUS_PER_BD;

	/* find first with valid implementation */
	for (ii = 0; ii < nc; ii++)
		if (cpu[MAKE_CPUID(bd, ii)]) {
			impl = cpunodes[MAKE_CPUID(bd, ii)].implementation;
			break;
		}

	if (IS_JAGUAR(impl) || IS_PANTHER(impl))
		return (2);
	else
		return (1);
}

/*
 * dp_payload_add_cpus()
 *
 * From datapath mailbox message, determines the number of and safari IDs
 * for affected cpus, then adds this info to the datapath ereport.
 *
 */
static int
dp_payload_add_cpus(plat_datapath_info_t *dpmsg, nvlist_t *erp)
{
	int		jj = 0, numcpus = 0;
	int		bd, procpos, ii, num, ncores, ret;
	uint16_t	*dparray, cpuid;
	uint64_t	*snarray;

	/* check for multiple core architectures */
	ncores = dp_get_cores(dpmsg->cpuid);

	switch (dpmsg->type) {
		case DP_CDS_TYPE:
			numcpus = ncores;
			break;

		case DP_DX_TYPE:
			numcpus = 2 * ncores;
			break;

		case DP_RP_TYPE:
			numcpus = SG_MAX_CPUS_PER_BD;
			break;

		default:
			ASSERT(0);
			return (-1);
	}

	num = numcpus;

	/*
	 * populate dparray with impacted cores (only those present)
	 */
	dparray = kmem_zalloc(num * sizeof (uint16_t *), KM_SLEEP);
	bd = SG_PORTID_TO_BOARD_NUM(SG_CPUID_TO_PORTID(dpmsg->cpuid));
	procpos = SG_CPUID_TO_PORTID(dpmsg->cpuid) & 0x3;

	mutex_enter(&cpu_lock);

	switch (dpmsg->type) {

		case DP_CDS_TYPE:
			/*
			 * For a CDS error, it's the reporting cpuid
			 * and it's other core (if present)
			 */
			cpuid = dpmsg->cpuid & 0x1FF;	/* core 0 */
			if (cpu[cpuid])
				dparray[jj++] = cpuid;

			cpuid = dpmsg->cpuid | SG_CORE_ID_MASK;	/* core 1 */
			if (cpu[cpuid])
				dparray[jj++] = cpuid;
			break;

		case DP_DX_TYPE:
			/*
			 * For a DX error, it's the reporting cpuid (all
			 * cores) and the other CPU sharing the same
			 * DX<-->DCDS interface (all cores)
			 */

			/* reporting cpuid */
			cpuid = dpmsg->cpuid & 0x1FF;	/* core 0 */
			if (cpu[cpuid])
				dparray[jj++] = cpuid;

			cpuid = dpmsg->cpuid | SG_CORE_ID_MASK;	/* core 1 */
			if (cpu[cpuid])
				dparray[jj++] = cpuid;

			/* find partner cpuid */
			if (procpos == 0 || procpos == 2)
				cpuid = dpmsg->cpuid + 1;
			else
				cpuid = dpmsg->cpuid - 1;

			/* add partner cpuid */
			cpuid &= 0x1FF;			/* core 0 */
			if (cpu[cpuid])
				dparray[jj++] = cpuid;

			cpuid |= SG_CORE_ID_MASK;	/* core 1 */
			if (cpu[cpuid])
				dparray[jj++] = cpuid;
			break;

		case DP_RP_TYPE:
			/*
			 * For a RP error, it's all cpuids (all cores) on
			 * the reporting board
			 */
			for (ii = 0; ii < SG_MAX_CMPS_PER_BD; ii++) {
				cpuid = MAKE_CPUID(bd, ii);
				if (cpu[cpuid])		/* core 0 */
					dparray[jj++] = cpuid;
				cpuid |= SG_CORE_ID_MASK;
				if (cpu[cpuid])		/* core 1 */
					dparray[jj++] = cpuid;
			}
			break;
	}

	mutex_exit(&cpu_lock);

	/*
	 * The datapath message could not be associated with any
	 * configured CPU.
	 */
	if (!jj) {
		kmem_free(dparray, num * sizeof (uint16_t *));
		ret = nvlist_add_uint32(erp, DP_LIST_SIZE, jj);
		ASSERT(ret == 0);
		return (-1);
	}

	snarray = kmem_zalloc(jj * sizeof (uint64_t), KM_SLEEP);
	for (ii = 0; ii < jj; ii++)
		snarray[ii] = cpunodes[dparray[ii]].device_id;

	ret = nvlist_add_uint32(erp, DP_LIST_SIZE, jj);
	ret |= nvlist_add_uint16_array(erp, DP_LIST, dparray, jj);
	ret |= nvlist_add_uint64_array(erp, SN_LIST, snarray, jj);
	ASSERT(ret == 0);

	kmem_free(dparray, num * sizeof (uint16_t *));
	kmem_free(snarray, jj * sizeof (uint64_t *));

	return (0);
}

/*
 * sbbc_dp_trans_event() - datapath message handler.
 *
 * Process datapath error and fault messages received from the SC.  Checks
 * for, and disregards, messages associated with I/O boards.  Otherwise,
 * extracts message info to produce a datapath ereport.
 */
/*ARGSUSED*/
static uint_t
sbbc_dp_trans_event(char *arg)
{
	const char	*f = "sbbc_dp_trans_event()";
	nvlist_t	*erp, *detector, *hcelem;
	char		buf[FM_MAX_CLASS];
	int		board;
	plat_datapath_info_t	*dpmsg;
	sbbc_msg_t	*msg;
	int		msgtype;

	/* set i/f message and payload pointers */
	msg = &dp_payload_msg;
	dpmsg = &dp_payload;
	msgtype = msg->msg_type.type;

	cmn_err(CE_NOTE, "%s: msgtype=0x%x\n", f, msgtype);
	cmn_err(CE_NOTE, "type=0x%x cpuid=0x%x t_value=0x%x\n", dpmsg->type,
		dpmsg->cpuid, dpmsg->t_value);

	/* check for valid type */
	if (dpmsg->type > DP_RP_TYPE) {
		cmn_err(CE_WARN, "%s: dpmsg type 0x%x invalid\n",
			f, dpmsg->type);
		return (DDI_INTR_CLAIMED);
	}

	/* check for I/O board message -  Schizo AIDs are 25 - 30 */
	if (dpmsg->cpuid > 23) {
		cmn_err(CE_NOTE, "%s: ignore I/O board msg\n", f);
		return (DDI_INTR_CLAIMED);
	}

	/* allocate space for ereport */
	erp = fm_nvlist_create(NULL);

/*
 * Member Name	Data Type	   Comments
 * -----------	---------	   -----------
 * version	uint8		   0
 * class	string		   "asic"
 * ENA		uint64		   ENA Format 1
 * detector	fmri		   aggregated ID data for SC-DE
 *
 * Datapath ereport subclasses and data payloads:
 * There will be two types of ereports (error and fault) which will be
 * identified by the "type" member.
 *
 * ereport.asic.serengeti.cds.cds-dp
 * ereport.asic.serengeti.dx.dx-dp	(board)
 * ereport.asic.serengeti.rp.rp-dp	(centerplane)
 *
 * Member Name	Data Type	  Comments
 * -----------	---------	  -----------
 * erptype	uint16		  derived from message type: error or
 *				  fault
 * t-value	uint32		  SC's datapath SERD timeout threshold
 * dp-list-sz	uint8		  number of dp-list array elements
 * dp-list	array of uint16	  Safari IDs of affected cpus
 * sn-list	array of uint64	  Serial numbers of affected cpus
 */

	/* compose common ereport elements */
	detector = fm_nvlist_create(NULL);

	/*
	 *  Create legacy FMRI for the detector
	 */
	board = SG_PORTID_TO_BOARD_NUM(SG_CPUID_TO_PORTID(dpmsg->cpuid));
	switch (dpmsg->type) {
		case DP_CDS_TYPE:
		case DP_DX_TYPE:
			(void) snprintf(buf, FM_MAX_CLASS, "SB%d", board);
			break;
		case DP_RP_TYPE:
			(void) snprintf(buf, FM_MAX_CLASS, "RP");
			break;
		default:
			(void) snprintf(buf, FM_MAX_CLASS, "UNKNOWN");
			break;
	}

	hcelem = fm_nvlist_create(NULL);

	(void) nvlist_add_string(hcelem, FM_FMRI_HC_NAME, FM_FMRI_LEGACY_HC);
	(void) nvlist_add_string(hcelem, FM_FMRI_HC_ID, buf);

	(void) nvlist_add_uint8(detector, FM_VERSION, FM_HC_SCHEME_VERSION);
	(void) nvlist_add_string(detector, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC);
	(void) nvlist_add_string(detector, FM_FMRI_HC_ROOT, "");
	(void) nvlist_add_uint32(detector, FM_FMRI_HC_LIST_SZ, 1);
	(void) nvlist_add_nvlist_array(detector, FM_FMRI_HC_LIST, &hcelem, 1);

	/* build ereport class name */
	(void) snprintf(buf, FM_MAX_CLASS, "asic.serengeti.%s.%s-%s",
		dperrtype[dpmsg->type], dperrtype[dpmsg->type],
		FM_ERROR_DATAPATH);

	fm_ereport_set(erp, FM_EREPORT_VERSION, buf,
		fm_ena_generate(0, FM_ENA_FMT1), detector, NULL);

	/* add payload elements */
	if (msgtype == MBOX_EVENT_DP_ERROR)
		fm_payload_set(erp,
			DP_EREPORT_TYPE, DATA_TYPE_UINT16, DP_ERROR, NULL);
	else
		fm_payload_set(erp,
			DP_EREPORT_TYPE, DATA_TYPE_UINT16, DP_FAULT, NULL);

	fm_payload_set(erp, DP_TVALUE, DATA_TYPE_UINT32, dpmsg->t_value, NULL);

	(void) dp_payload_add_cpus(dpmsg, erp);

	/* post ereport */
	fm_ereport_post(erp, EVCH_SLEEP);

	/* free ereport memory */
	fm_nvlist_destroy(erp, FM_NVA_FREE);
	fm_nvlist_destroy(detector, FM_NVA_FREE);

	return (DDI_INTR_CLAIMED);
}

static uint_t
sbbc_datapath_error_msg_handler(char *arg)
{
	static fn_t	f = "sbbc_datapath_error_msg_handler()";
	sbbc_msg_t	*msg = NULL;

	if (arg == NULL) {
		SGSBBC_DBG_EVENT(CE_NOTE, "%s: arg == NULL", f);
		return (DDI_INTR_UNCLAIMED);
	}

	msg = (sbbc_msg_t *)arg;

	if (msg->msg_buf == NULL) {
		SGSBBC_DBG_EVENT(CE_NOTE, "%s: msg_buf == NULL", f);
		return (DDI_INTR_UNCLAIMED);
	}

	msg->msg_type.type = MBOX_EVENT_DP_ERROR;

	/* trigger sbbc_dp_trans_event() */
	ddi_trigger_softintr(dp_softintr_id);

	return (DDI_INTR_CLAIMED);
}

static uint_t
sbbc_datapath_fault_msg_handler(char *arg)
{

	static fn_t	f = "sbbc_datapath_fault_msg_handler()";

	sbbc_msg_t		*msg = NULL;

	if (arg == NULL) {
		SGSBBC_DBG_EVENT(CE_NOTE, "%s: arg == NULL", f);
		return (DDI_INTR_UNCLAIMED);
	}

	msg = (sbbc_msg_t *)arg;

	if (msg->msg_buf == NULL) {
		SGSBBC_DBG_EVENT(CE_NOTE, "%s: msg_buf == NULL", f);
		return (DDI_INTR_UNCLAIMED);
	}

	msg->msg_type.type = MBOX_EVENT_DP_FAULT;

	/* trigger sbbc_dp_trans_event() */
	ddi_trigger_softintr(dp_softintr_id);

	return (DDI_INTR_CLAIMED);
}

/*
 * Log an ECC event message to the SC.  This is called from the
 * sbbc_ecc_mbox_taskq or directly from plat_send_ecc_mailbox_msg
 * for indictment messages.
 */
int
sbbc_mbox_ecc_output(sbbc_ecc_mbox_t *msgp)
{
	int				rv;
	plat_capability_data_t		*cap;
	plat_dimm_sid_board_data_t	*ddata;
	plat_ecc_msg_hdr_t		*hdr;

	rv = sbbc_mbox_request_response(&msgp->ecc_req, &msgp->ecc_resp,
		sbbc_mbox_default_timeout);

	if (rv != 0) {
		/*
		 * Indictment messages use the return value to indicate a
		 * problem in the mailbox.  For Error mailbox messages, we'll
		 * have to use a syslog message.
		 */
		if (msgp->ecc_log_error) {
			if (sbbc_ecc_mbox_send_errs == 0) {
				cmn_err(CE_NOTE, "!Solaris failed to send a "
				    "message (0x%x/0x%x) to the System "
				    "Controller. Error: %d, Message Status: %d",
				    msgp->ecc_resp.msg_type.type,
				    msgp->ecc_resp.msg_type.sub_type,
				    rv, msgp->ecc_resp.msg_status);
			}

			if (++sbbc_ecc_mbox_send_errs >=
			    sbbc_ecc_mbox_err_throttle) {
				sbbc_ecc_mbox_send_errs = 0;
			}
		}

	} else if (msgp->ecc_resp.msg_status != 0) {
		if (msgp->ecc_resp.msg_type.type == INFO_MBOX) {
			switch (msgp->ecc_resp.msg_type.sub_type) {
			case INFO_MBOX_ECC:
				hdr = (plat_ecc_msg_hdr_t *)
				    msgp->ecc_req.msg_buf;
				if (hdr->emh_msg_type ==
				    PLAT_ECC_DIMM_SID_MESSAGE) {
					rv = msgp->ecc_resp.msg_status;
					break;
				}
			/*FALLTHROUGH*/
			case INFO_MBOX_ECC_CAP:
				/*
				 * The positive response comes only
				 * from the AVL FS1 updated SC.
				 * If the firmware is either downgraded
				 * or failover to an older version, then
				 * lets reset the SC capability to
				 * default.
				 */
				plat_ecc_capability_sc_set
				    (PLAT_ECC_CAPABILITY_SC_DEFAULT);
				break;
			default:
				break;
			}
		}
		if (msgp->ecc_log_error) {
			if (sbbc_ecc_mbox_inval_errs == 0) {
				cmn_err(CE_NOTE, "!An internal error (%d) "
				    "occurred in the System Controller while "
				    "processing this message (0x%x/0x%x)",
				    msgp->ecc_resp.msg_status,
				    msgp->ecc_resp.msg_type.type,
				    msgp->ecc_resp.msg_type.sub_type);
			}
			if (msgp->ecc_resp.msg_status == EINVAL) {
				if (++sbbc_ecc_mbox_inval_errs >=
				    sbbc_ecc_mbox_err_throttle) {
					sbbc_ecc_mbox_inval_errs = 0;
				}
				rv = ENOMSG;
			} else {
				if (++sbbc_ecc_mbox_other_errs >=
				    sbbc_ecc_mbox_err_throttle) {
					sbbc_ecc_mbox_other_errs = 0;
				}
				rv = msgp->ecc_resp.msg_status;
			}
		}

	} else {
		if (msgp->ecc_resp.msg_type.type == INFO_MBOX) {
			switch (msgp->ecc_resp.msg_type.sub_type) {
			case INFO_MBOX_ECC_CAP:
				/*
				 * Successfully received the response
				 * for the capability message, so updating
				 * the SC ECC messaging capability.
				 */
				cap = (plat_capability_data_t *)
				    msgp->ecc_resp.msg_buf;
				plat_ecc_capability_sc_set
				    (cap->capd_capability);
				break;

			case INFO_MBOX_ECC:
				hdr = (plat_ecc_msg_hdr_t *)
				    msgp->ecc_resp.msg_buf;
				if (hdr && (hdr->emh_msg_type ==
				    PLAT_ECC_DIMM_SID_MESSAGE)) {
					/*
					 * Successfully received a response
					 * to a request for DIMM serial ids.
					 */
					ddata = (plat_dimm_sid_board_data_t *)
					    msgp->ecc_resp.msg_buf;
					(void) plat_store_mem_sids(ddata);
				}
				break;

			default:
				break;
			}
		}
	}

	if (msgp->ecc_resp.msg_buf)
		kmem_free((void *)msgp->ecc_resp.msg_buf,
		    (size_t)msgp->ecc_resp.msg_len);

	kmem_free((void *)msgp->ecc_req.msg_buf, (size_t)msgp->ecc_req.msg_len);
	kmem_free(msgp, sizeof (sbbc_ecc_mbox_t));
	return (rv);
}

/*
 * Enqueue ECC event message on taskq to SC.  This is invoked from
 * plat_send_ecc_mailbox_msg() for each ECC event generating a message.
 */
void
sbbc_mbox_queue_ecc_event(sbbc_ecc_mbox_t *sbbc_ecc_msgp)
{
	/*
	 * Create the ECC event mailbox taskq, if it does not yet exist.
	 * This must be done here rather than in sbbc_mbox_init().  The
	 * sgsbbc driver is loaded very early in the boot flow.  Calling
	 * taskq_create() from sbbc_mbox_init could lead to a boot deadlock.
	 *
	 * There might be a tiny probability that two ECC handlers on
	 * different processors could arrive here simultaneously.  If
	 * the taskq has not been created previously, then these two
	 * simultaneous events could cause the creation of an extra taskq.
	 * Given the extremely small likelihood (if not outright impossibility)
	 * of this occurrence, sbbc_ecc_mbox_taskq is not protected by a lock.
	 */

	if (sbbc_ecc_mbox_taskq == NULL) {
		sbbc_ecc_mbox_taskq = taskq_create("ECC_event_mailbox", 1,
		    minclsyspri, ECC_MBOX_TASKQ_MIN, ECC_MBOX_TASKQ_MAX,
		    TASKQ_PREPOPULATE);
		if (sbbc_ecc_mbox_taskq == NULL) {
			if (sbbc_ecc_mbox_taskq_errs == 0) {
				cmn_err(CE_NOTE, "Unable to create mailbox "
				    "task queue for ECC event logging to "
				    "System Controller");
			}
			if (++sbbc_ecc_mbox_taskq_errs >=
			    sbbc_ecc_mbox_err_throttle) {
				sbbc_ecc_mbox_taskq_errs = 0;
			}

			kmem_free((void *)sbbc_ecc_msgp->ecc_req.msg_buf,
				(size_t)sbbc_ecc_msgp->ecc_req.msg_len);
			kmem_free((void *)sbbc_ecc_msgp,
				sizeof (sbbc_ecc_mbox_t));
			return;
		}

		/*
		 * Reset error counter so that first taskq_dispatch
		 * error will be output
		 */
		sbbc_ecc_mbox_taskq_errs = 0;
	}

	/*
	 * Enqueue the message
	 */

	if (taskq_dispatch(sbbc_ecc_mbox_taskq,
	    (task_func_t *)sbbc_mbox_ecc_output, sbbc_ecc_msgp,
	    TQ_NOSLEEP) == TASKQID_INVALID) {

		if (sbbc_ecc_mbox_taskq_errs == 0) {
			cmn_err(CE_NOTE, "Unable to send ECC event "
				"message to System Controller");
		}
		if (++sbbc_ecc_mbox_taskq_errs >= sbbc_ecc_mbox_err_throttle) {
			sbbc_ecc_mbox_taskq_errs = 0;
		}

		kmem_free((void *)sbbc_ecc_msgp->ecc_req.msg_buf,
				(size_t)sbbc_ecc_msgp->ecc_req.msg_len);
		kmem_free((void *)sbbc_ecc_msgp, sizeof (sbbc_ecc_mbox_t));
	}
}

static uint_t
cap_ecc_msg_handler(char *addr)
{
	sbbc_msg_t *msg = NULL;
	plat_capability_data_t *cap = NULL;
	static fn_t f = "cap_ecc_msg_handler";

	msg = (sbbc_msg_t *)addr;

	if (msg == NULL) {
		SGSBBC_DBG_EVENT(CE_WARN, "cap_ecc_msg_handler() called with "
		    "null addr");
		return (DDI_INTR_CLAIMED);
	}

	if (msg->msg_buf == NULL) {
		SGSBBC_DBG_EVENT(CE_WARN, "cap_ecc_msg_handler() called with "
		    "null data buffer");
		return (DDI_INTR_CLAIMED);
	}

	cap = (plat_capability_data_t *)msg->msg_buf;
	switch (cap->capd_msg_type) {
	case PLAT_ECC_CAPABILITY_MESSAGE:
		SGSBBC_DBG_MBOX("%s: capability  0x%x\n", f,
		    cap->capd_capability);
		plat_ecc_capability_sc_set(cap->capd_capability);
		break;
	default:
		SGSBBC_DBG_MBOX("%s: Unknown message type = 0x%x\n", f,
		    cap->capd_msg_type);
		break;
	}

	return (DDI_INTR_CLAIMED);
}