xref: /titanic_50/usr/src/uts/sun4u/serengeti/io/sbdp_mbox.c (revision 03831d35f7499c87d51205817c93e9a8d42c4bae)

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

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

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

#include <sys/cpuvar.h>
#include <sys/cpu_module.h>
#include <sys/kmem.h>
#include <sys/sunddi.h>
#include <sys/param.h>
#include <sys/obpdefs.h>
#include <sys/prom_plat.h>
#include <sys/sgsbbc_mailbox.h>
#include <sys/sbd_ioctl.h>
#include <sys/sbdp_priv.h>
#include <sys/sbdp_mbox.h>
#include <sys/promif.h>
#include <sys/plat_ecc_dimm.h>

#define	UNKNOWN "unknown"
#define	INITL_STATUS	0xdead

int sbdp_mbox_wait = 86400;	/* in seconds */
int sbdp_shw_bd_wait = 5;	/* in seconds */

int sbdp_sc_err_translation(int);
int sbdp_poweroff_wkaround = 1;

/*
 * By default, DR of non-Panther procs is not allowed into a Panther
 * domain with large page sizes enabled.  Setting this to 0 will remove
 * the restriction.
 */
static int sbdp_large_page_restriction = 1;

/*
 * Initialize the data structs for the common part of the pkts
 */
void
sbdp_init_msg_pkt(sbbc_msg_t *msg, uint16_t sub_type, int len, caddr_t buf)
{
	msg->msg_type.type = DR_MBOX;
	msg->msg_type.sub_type = sub_type;
	msg->msg_status = INITL_STATUS;
	msg->msg_len = len;
	msg->msg_buf = buf;
	msg->msg_data[0] = 0;
	msg->msg_data[1] = 0;

}

/*
 * Convert a showboard data structure to the board structure shared
 * between sbd and sbdp
 */
void
sbdp_showbd_2_sbd_stat(show_board_t *shbp, sbd_stat_t *stp, int board)
{
	static fn_t	f = "sbdp_showbd_2_sbd_stat";

	SBDP_DBG_FUNC("%s\n", f);

	stp->s_board = board;
	(void) strcpy(stp->s_info, shbp->s_info);
	stp->s_power = shbp->s_power;

	(void) strcpy(stp->s_type, shbp->s_type);

	if (shbp->s_present == 0) {
		/*
		 * This should go away since the SC should put the unknown
		 * We leave this here so Symon and other scripts don't have
		 * a problem
		 */
		(void) strcpy(stp->s_type, UNKNOWN);
		stp->s_rstate = SBD_STAT_EMPTY;
	} else if (shbp->s_claimed == 0)
		stp->s_rstate = SBD_STAT_DISCONNECTED;
	else
		stp->s_rstate = SBD_STAT_CONNECTED;


	stp->s_assigned = shbp->s_assigned;
	stp->s_cond = shbp->s_cond;
}

/*
 * Entry point from sbd.  Get the status from the SC and then convert
 * the info returned into something that sbd understands
 * If the request times out or fails other than an illegal transaction
 * copy the info from our inventory
 */
int
sbdp_get_board_status(sbdp_handle_t *hp, sbd_stat_t *stp)
{
	int		board = hp->h_board;
	int		node = hp->h_wnode;
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	info_t		inform, *informp = &inform;
	show_board_t	show_bd, *shbp = &show_bd;
	int		rv = 0;
	sbd_error_t	*sep = hp->h_err;
	int		len;
	sbdp_bd_t	*bdp;
	static fn_t	f = "sbdp_get_board_status";

	SBDP_DBG_FUNC("%s\n", f);

	/*
	 * Check for options.  If there are any, fail the operation
	 */
	if (hp->h_opts != NULL && hp->h_opts->copts != NULL) {
		sbdp_set_err(sep, ESBD_INVAL_OPT, hp->h_opts->copts);
		return (-1);
	}

	bdp = sbdp_get_bd_info(node, board);

	informp->board = board;
	informp->node = node;
	informp->revision = 0xdead;
	len = sizeof (info_t);

	sbdp_init_msg_pkt(reqp, DR_MBOX_SHOW_BOARD, len, (caddr_t)informp);

	bzero(shbp, sizeof (show_board_t));
	shbp->s_cond = -1;
	shbp->s_power = -1;
	shbp->s_assigned = -1;
	shbp->s_claimed = -1;
	shbp->s_present = -1;
	len = sizeof (show_board_t);

	sbdp_init_msg_pkt(resp, DR_MBOX_SHOW_BOARD, len, (caddr_t)shbp);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_shw_bd_wait);

	SBDP_DBG_MISC("show board completed: rv = %d\n", rv);

	/*
	 * This domain has no access to this board. Return failure
	 */
	if ((resp->msg_status == SG_MBOX_STATUS_BOARD_ACCESS_DENIED) ||
		(resp->msg_status == SG_MBOX_STATUS_ILLEGAL_SLOT) ||
		(resp->msg_status == SG_MBOX_STATUS_ILLEGAL_NODE)) {

		/*
		 * invalidate cached copy.
		 */
		bdp->valid_cp = -1;

		sbdp_set_err(sep, ESGT_GET_BOARD_STAT, NULL);
		return (EIO);
	}

	/*
	 * If we get any error see if we can return a cached copy of the
	 * board info.  If one exists turn the busy flag on
	 */
	if (rv != 0) {
		mutex_enter(&bdp->bd_mutex);
		if (bdp->valid_cp == -1) {
			sbdp_set_err(sep, ESGT_GET_BOARD_STAT,
			    NULL);
			mutex_exit(&bdp->bd_mutex);
			return (EIO);
		}

		/*
		 * we have a valid copy.  Return it and set the
		 * busy flag on so the user know this is not the most
		 * recent copy
		 */
		bcopy(bdp->bd_sc, shbp, sizeof (show_board_t));
		mutex_exit(&bdp->bd_mutex);
		stp->s_busy = 1;
		/*
		 * The sbbc returns the error in both parts (i.e rv and status)
		 * so since we just took care of it reset rv
		 */
		rv = 0;
	} else {
		/*
		 * revalidate our copy of the returned data
		 */
		if (bdp == NULL) {
			SBDP_DBG_MBOX("HUGE ERROR\n");
		} else {
			mutex_enter(&bdp->bd_mutex);
			bcopy(shbp, bdp->bd_sc, sizeof (show_board_t));
			bdp->valid_cp = 1;
			mutex_exit(&bdp->bd_mutex);
		}
	}


	SBDP_DBG_MBOX("Showboard: board\t%d\n\trevision\t%d\n\ts_cond\t%d\n\t"
		"s_power\t%d\n\ts_assigned\t%d\n\ts_claimed\t%d\n\t"
		"s_present\t%d\n\ts_ledstatus\t%d\n\ts_type\t%s\n\t"
		"s_info\t%s\n",
			board, shbp->revision, shbp->s_cond, shbp->s_power,
			shbp->s_assigned, shbp->s_claimed, shbp->s_present,
			shbp->s_ledstatus, shbp->s_type, shbp->s_info);

	/*
	 * Now that we got the info run through the sbd-sbdp translator
	 */
	sbdp_showbd_2_sbd_stat(shbp, stp, board);

	/*
	 * Last add the platform options
	 */
	SBDP_PLATFORM_OPTS(stp->s_platopts);

	return (rv);
}

/*
 * Entry point from sbd.  Call down to the SC to assign the board
 * We simply return the status the SC told us
 */
int
sbdp_assign_board(sbdp_handle_t *hp)
{
	int		board = hp->h_board;
	int		node = hp->h_wnode;
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		cmd_rev = -1;
	info2_t		inform, *informp = &inform;
	int		rv = 0;
	sbd_error_t	*sep;
	int		len;
	static fn_t	f = "sbdp_assign_board";

	SBDP_DBG_FUNC("%s\n", f);

	sep = hp->h_err;
	/*
	 * Check for options.  If there are any, fail the operation
	 */
	if (hp->h_opts != NULL && hp->h_opts->copts != NULL) {
		sbdp_set_err(sep, ESBD_INVAL_OPT, hp->h_opts->copts);
		return (-1);
	}

	informp->board = board;
	informp->node = node;
	informp->extra = SBDP_ASSIGN;
	len =	sizeof (info2_t);

	sbdp_init_msg_pkt(reqp, DR_MBOX_ASSIGN, len, (caddr_t)informp);

	len =  sizeof (cmd_rev);

	sbdp_init_msg_pkt(resp, DR_MBOX_ASSIGN, len, (caddr_t)&cmd_rev);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to assign board: rv = %d\n", rv);
		sbdp_set_err(sep, sbdp_sc_err_translation(resp->msg_status),
		    NULL);
	}

	return (rv);
}

/*
 * Entry point from sbd.  Call down to the SC to unassign the board
 * We simply return the status the SC told us
 */
int
sbdp_unassign_board(sbdp_handle_t *hp)
{
	int		board = hp->h_board;
	int		node = hp->h_wnode;
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		cmd_rev = -1;
	info2_t		inform, *informp = &inform;
	int		rv = 0;
	sbd_error_t	*sep;
	int		len;
	static fn_t	f = "sbdp_unassign_board";

	SBDP_DBG_FUNC("%s\n", f);

	sep = hp->h_err;
	/*
	 * Check for options.  If there are any, fail the operation
	 */
	if (hp->h_opts != NULL && hp->h_opts->copts != NULL) {
		sbdp_set_err(sep, ESBD_INVAL_OPT, hp->h_opts->copts);
		return (-1);
	}

	informp->board = board;
	informp->node = node;
	informp->extra = SBDP_UNASSIGN;
	len =	sizeof (info2_t);

	sbdp_init_msg_pkt(reqp, DR_MBOX_ASSIGN, len, (caddr_t)informp);

	len =  sizeof (cmd_rev);

	sbdp_init_msg_pkt(resp, DR_MBOX_ASSIGN, len, (caddr_t)&cmd_rev);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to unassign board: rv = %d\n", rv);
		sbdp_set_err(sep, sbdp_sc_err_translation(resp->msg_status),
		    NULL);
	}

	return (rv);
}

static int
sg_attach_board(void *arg)
{
	sbdp_handle_t	*hp;
	cpuset_t	cset;
	int		rv;
	static fn_t	f = "sg_attach_board";

	SBDP_DBG_FUNC("%s\n", f);

	hp = (sbdp_handle_t *)arg;

	cset = cpu_ready_set;
	promsafe_xc_attention(cset);
	rv = prom_serengeti_attach_board(hp->h_wnode, hp->h_board);
	xc_dismissed(cset);

	return (rv);
}

static int
sg_detach_board(void *arg)
{
	sbdp_handle_t	*hp;
	cpuset_t	cset;
	int		rv;
	static fn_t	f = "sg_detach_board";

	SBDP_DBG_FUNC("%s\n", f);

	hp = (sbdp_handle_t *)arg;

	cset = cpu_ready_set;
	promsafe_xc_attention(cset);
	rv = prom_serengeti_detach_board(hp->h_wnode, hp->h_board);
	xc_dismissed(cset);

	return (rv);
}

/*
 * Entry point from sbd.  First we call down to the SC to "attach/claim" this
 * board.  As a side effect the SC updates the pda info so obp can create the
 * device tree.  If we are successful, we ask OBP to probe the board.  OBP
 * creates new nodes on its own obp tree
 * As an added bonus, since we don't use the inkernel prober, we need to create
 * the dev_info nodes but just to a point where they are created but
 * Solaris can't use them (i.e BIND)
 */
int
sbdp_connect_board(sbdp_handle_t *hp)
{
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		rv = 0;
	int		board, node;
	sbd_error_t	*sep;
	static fn_t	f = "sbdp_connect_board";
	int		panther_pages_enabled;

	SBDP_DBG_FUNC("%s\n", f);

	board = hp->h_board;
	node = hp->h_wnode;
	sep = hp->h_err;

	/*
	 * Check for options.  If there are any, fail the operation
	 */
	if (hp->h_opts != NULL && hp->h_opts->copts != NULL) {
		sbdp_set_err(sep, ESBD_INVAL_OPT, hp->h_opts->copts);
		return (-1);
	}

	/*
	 * Currently, we pass the info in the extra data fields.
	 * This may change in the SC.  We need to change it then
	 */
	sbdp_init_msg_pkt(reqp, DR_MBOX_CLAIM, 0, (caddr_t)NULL);
	reqp->msg_data[0] = node;
	reqp->msg_data[1] = board;

	sbdp_init_msg_pkt(resp, DR_MBOX_CLAIM, 0, (caddr_t)NULL);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to claim board: rv = %d\n", rv);
		sbdp_set_err(sep, sbdp_sc_err_translation(resp->msg_status),
		    NULL);
		return (rv);
	}

	rv = prom_tree_update(sg_attach_board, hp);
	if (rv != 0) {
		SBDP_DBG_MISC("failed to prom attach board: rv = %d\n", rv);
		sbdp_set_err(sep, ESGT_PROM_ATTACH, NULL);
		/*
		 * Clean up
		 */
		sbdp_init_msg_pkt(reqp, DR_MBOX_UNCLAIM, 0, (caddr_t)NULL);
		reqp->msg_data[0] = node;
		reqp->msg_data[1] = board;

		sbdp_init_msg_pkt(resp, DR_MBOX_UNCLAIM, 0, (caddr_t)NULL);

		(void) sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

		return (rv);
	}

	SBDP_DBG_MISC("prom attach worked\n");
	sbdp_attach_bd(node, board);

	/*
	 * XXX Until the Solaris large pages support heterogeneous cpu
	 * domains, DR needs to prevent the addition of non-Panther cpus
	 * to an all-Panther domain with large pages enabled.
	 */
	panther_pages_enabled = (page_num_pagesizes() > DEFAULT_MMU_PAGE_SIZES);
	if (sbdp_board_non_panther_cpus(node, board) > 0 &&
	    panther_pages_enabled && sbdp_large_page_restriction) {
		cmn_err(CE_WARN, "Domain shutdown is required to add a non-"
		    "UltraSPARC-IV+ board into an all UltraSPARC-IV+ domain");
		(void) sbdp_disconnect_board(hp);
		sbdp_set_err(sep, ESGT_NOT_SUPP, NULL);
		return (-1);
	}

	/*
	 * Now that the board has been successfully attached, obtain
	 * platform-specific DIMM serial id information for the board.
	 */
	if (SG_BOARD_IS_CPU_TYPE(board) &&
	    plat_ecc_capability_sc_get(PLAT_ECC_DIMM_SID_MESSAGE)) {
		(void) plat_request_mem_sids(board);
	}

	return (rv);
}

/*
 * Entry point from sbd.  Undo the connect call. We first need to remove
 * the "dummy (i.e unusable)" nodes from solaris.  We then call down to OBP
 * to prune its tree.  After all has been cleaned up from OBP and Solaris
 * We call the SC to "detach/unclain" the board. A side effect is that the
 * SC will clear the pda entries for this board
 */
int
sbdp_disconnect_board(sbdp_handle_t *hp)
{
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		rv = 0;
	int		board, node;
	sbd_error_t	*sep;
	static fn_t	f = "sbdp_disconnect_board";

	SBDP_DBG_FUNC("%s\n", f);

	board = hp->h_board;
	node = hp->h_wnode;
	sep = hp->h_err;

	SBDP_DBG_MISC("sbdp_disconnect_board: board = %d node = %d\n",
	    board, node);

	/*
	 * Check for options.  If there are any, fail the operation
	 */
	if (hp->h_opts != NULL && hp->h_opts->copts != NULL) {
		sbdp_set_err(sep, ESBD_INVAL_OPT, hp->h_opts->copts);
		return (-1);
	}

	if (sbdp_detach_bd(node, board, sep)) {
		sbdp_attach_bd(node, board);
		SBDP_DBG_ALL("failed to detach board %d\n", board);
		return (-1);
	}

	rv = prom_tree_update(sg_detach_board, hp);
	if (rv == -1) {
		/*
		 * Clean up
		 */
		sbdp_attach_bd(node, board);
		SBDP_DBG_MISC("failed to prom detach board: rv = %d\n", rv);
		sbdp_set_err(sep, ESGT_PROM_DETACH, NULL);
		return (rv);
	}

	SBDP_DBG_MISC("prom detach worked\n");
	/*
	 * Currently, we pass the info in the extra data fields.
	 * This may change in the SC.  We need to change it then
	 */
	sbdp_init_msg_pkt(reqp, DR_MBOX_UNCLAIM, 0, (caddr_t)NULL);
	reqp->msg_data[0] = node;
	reqp->msg_data[1] = board;

	sbdp_init_msg_pkt(resp, DR_MBOX_UNCLAIM, 0, (caddr_t)NULL);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to unclaim board: rv = %d\n", rv);
		sbdp_set_err(sep, sbdp_sc_err_translation(resp->msg_status),
		    NULL);
		/* bring back the obp tree to what it was */
		(void) prom_tree_update(sg_attach_board, hp);
	}

	/*
	 * Now that the board has been successfully detached, discard
	 * platform-specific DIMM serial id information for the board.
	 */
	if (!rv && SG_BOARD_IS_CPU_TYPE(board) &&
	    plat_ecc_capability_sc_get(PLAT_ECC_DIMM_SID_MESSAGE)) {
		(void) plat_discard_mem_sids(board);
	}

	return (rv);
}

/*
 * Entry point from sbd.  Very simple.  Just ask the SC to poweoff the board
 * Return the status from the SC
 */
int
sbdp_poweroff_board(sbdp_handle_t *hp)
{
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		cmd_rev = -1;
	info2_t		inform, *informp;
	int		rv = 0;
	sbd_error_t	*sep;
	int		len;
	static fn_t	f = "sbdp_poweroff_board";

	SBDP_DBG_FUNC("%s\n", f);

	sep = hp->h_err;
	/*
	 * Check for options.  If there are any, fail the operation
	 */
	if (hp->h_opts != NULL && hp->h_opts->copts != NULL) {
		sbdp_set_err(sep, ESBD_INVAL_OPT, hp->h_opts->copts);
		return (-1);
	}

	/*
	 * Can't check for bad options here since we use this for workaround
	 * on poweron.
	 */

	informp = &inform;
	informp->board = hp->h_board;
	informp->node = hp->h_wnode;
	informp->extra = SBDP_POWER_OFF;

	len = sizeof (info2_t);
	sbdp_init_msg_pkt(reqp, DR_MBOX_POWER, len, (caddr_t)informp);

	len = sizeof (cmd_rev);
	sbdp_init_msg_pkt(resp, DR_MBOX_POWER, len, (caddr_t)&cmd_rev);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to poweroff board: rv = %d\n", rv);
		sbdp_set_err(sep, sbdp_sc_err_translation(resp->msg_status),
		    NULL);
	}

	return (rv);
}

/*
 * Entry point from sbd.  Ask the SC to poweron the board
 * Return the status from the SC
 */
int
sbdp_poweron_board(sbdp_handle_t *hp)
{
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		cmd_rev = -1;
	info2_t		inform, *informp;
	int		rv = 0;
	sbd_error_t	*sep;
	int		len;
	int		board = hp->h_board;
	static fn_t	f = "sbdp_poweron_board";

	SBDP_DBG_FUNC("%s\n", f);

	sep = hp->h_err;
	/*
	 * Check for options.  If there are any, fail the operation
	 */
	if (hp->h_opts != NULL && hp->h_opts->copts != NULL) {
		sbdp_set_err(sep, ESBD_INVAL_OPT, hp->h_opts->copts);
		return (-1);
	}

	if (sbdp_poweroff_wkaround)
		if (SG_BOARD_IS_CPU_TYPE(board)) {

			if ((rv = sbdp_poweroff_board(hp)) != 0)
				return (rv);
		}

	informp = &inform;
	informp->board = hp->h_board;
	informp->node = hp->h_wnode;
	informp->extra = SBDP_POWER_ON;

	len = sizeof (info2_t);
	sbdp_init_msg_pkt(reqp, DR_MBOX_POWER, len, (caddr_t)informp);

	len = sizeof (cmd_rev);
	sbdp_init_msg_pkt(resp, DR_MBOX_POWER, len, (caddr_t)&cmd_rev);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to poweron board: rv = %d\n", rv);
		sbdp_set_err(sep, sbdp_sc_err_translation(resp->msg_status),
		    NULL);
	}

	return (rv);
}

int
sbdp_get_diag(sbdp_opts_t *opts)
{
	char		*cptr;
	static fn_t	f = "sbdp_get_diag";

	SBDP_DBG_FUNC("%s\n", f);

	if ((opts == NULL) || (opts->copts == NULL))
		return (SBDP_DIAG_NVCI);

	if ((cptr = strstr(opts->copts, "diag=")) != NULL) {
		/*
		 * We have args and need to process them
		 */
		cptr += strlen("diag=");

		if (strncmp(cptr, "off", sizeof ("off")) == 0) {
			return (SBDP_DIAG_OFF);
		} else if (strncmp(cptr, "init", sizeof ("init")) == 0) {
			return (SBDP_DIAG_INIT);
		} else if (strncmp(cptr, "quick", sizeof ("quick")) == 0) {
			return (SBDP_DIAG_QUICK);
		} else if (strncmp(cptr, "min", sizeof ("min")) == 0) {
			return (SBDP_DIAG_MIN);
		} else if (strncmp(cptr, "default", sizeof ("default")) == 0 ||
			strncmp(cptr, "max", sizeof ("max")) == 0) {
			return (SBDP_DIAG_DEFAULT);
		} else if (strncmp(cptr, "mem1", sizeof ("mem1")) == 0) {
			return (SBDP_DIAG_MEM1);
		} else if (strncmp(cptr, "mem2", sizeof ("mem2")) == 0) {
			return (SBDP_DIAG_MEM2);
		}
	}
	SBDP_DBG_MISC("error: unrecognized arg\n");
	return (-1);
}


/*
 * Entry point from sbd.  Ask the SC to test the board.  We still need to
 * worry about the diag level.  The user may have changed it
 *
 * NOTE: The flag field has 2 different meanings whether we are dealing
 * with a cpu/mem board or an io board.  In the case of a cpu/mem board it
 * means retest the board to the diag level specified. In the case of an IO
 * board, it means: Perform the necessary steps to prepare the board
 * for the claim without running POST at the diag level specified.
 */
int
sbdp_test_board(sbdp_handle_t *hp, sbdp_opts_t *opts)
{
	int		board = hp->h_board;
	int		node = hp->h_wnode;
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		cmd_rev = -1;
	testb_t		inform, *informp = &inform;
	int		rv = 0;
	sbd_error_t	*sep;
	int		diag;
	int		len;
	static fn_t	f = "sbdp_test_board";

	SBDP_DBG_FUNC("%s\n", f);

	sep = hp->h_err;

	diag = sbdp_get_diag(opts);

	if (diag == -1) {
		sbdp_set_err(sep, ESBD_INVAL_OPT, opts != NULL ?
		    opts->copts : NULL);
		return (-1);
	}

	SBDP_DBG_MISC("Diag level is 0x%x\n", diag);

	informp->info.board = board;
	informp->info.node = node;

	informp->info.extra = diag;

	/*
	 * Only force retest on CPU boards
	 */
	if (SG_BOARD_IS_CPU_TYPE(board))
		informp->flag = 1;
	else {
		/*
		 * For CPULESS IO pass the force to the SC
		 */
		if (hp->h_flags & SBDP_IOCTL_FLAG_FORCE)
			informp->flag = 1;
		else
			informp->flag = 0;

	}

	len = sizeof (testb_t);
	sbdp_init_msg_pkt(reqp, DR_MBOX_TEST_BD, len, (caddr_t)informp);


	len = sizeof (cmd_rev);
	sbdp_init_msg_pkt(resp, DR_MBOX_TEST_BD, len, (caddr_t)&cmd_rev);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to test board: rv = %d status = %d\n",
		    rv, resp->msg_status);
		rv = resp->msg_status;
		sbdp_set_err(sep, sbdp_sc_err_translation(resp->msg_status),
		    NULL);
	}

	return (rv);
}

/*
 * Request the SC to update POST's memory slice table by swapping
 * the entries for the two board numbers given
 * This is used when performing a copy-rename operation.
 */
int
sbdp_swap_slices(int bd1, int bd2)
{
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		cmd_rev = -1;
	swap_slices_t	inform, *informp = &inform;
	int		rv;
	int		len;
	static fn_t	f = "sbdp_swap_slices";

	SBDP_DBG_FUNC("%s\n", f);

	informp->board1 = bd1;
	informp->board2 = bd2;

	len = sizeof (swap_slices_t);
	sbdp_init_msg_pkt(reqp, DR_MBOX_SWAP_SLICES, len, (caddr_t)informp);

	len = sizeof (cmd_rev);
	sbdp_init_msg_pkt(resp, DR_MBOX_SWAP_SLICES, len, (caddr_t)&cmd_rev);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to swap slices %d<->%d: rv = %d "
		    "status = %d\n", bd1, bd2, rv, resp->msg_status);
		rv = sbdp_sc_err_translation(resp->msg_status);
	}

	return (rv);
}

int
sbdp_sc_err_translation(int error)
{
	int err;
	static fn_t	f = "sbdp_sc_err_translation";

	SBDP_DBG_FUNC("%s\n", f);

	switch (error) {
	case SG_MBOX_STATUS_HARDWARE_FAILURE:
		err = ESGT_HW_FAIL;
		break;
	case SG_MBOX_STATUS_ILLEGAL_PARAMETER:
	case SG_MBOX_STATUS_ILLEGAL_NODE:
	case SG_MBOX_STATUS_ILLEGAL_SLOT:
		err = ESGT_INVAL;
		break;
	case SG_MBOX_STATUS_BOARD_ACCESS_DENIED:
		err = ESGT_BD_ACCESS;
		break;
	case SG_MBOX_STATUS_STALE_CONTENTS:
		err = ESGT_STALE_CMP;
		break;
	case SG_MBOX_STATUS_STALE_OBJECT:
		err = ESGT_STALE_OBJ;
		break;
	case SG_MBOX_STATUS_NO_SEPROM_SPACE:
		err = ESGT_NO_SEPROM_SPACE;
		break;
	case SG_MBOX_STATUS_NO_MEMORY:
		err = ESGT_NO_MEM;
		break;
	case SG_MBOX_STATUS_NOT_SUPPORTED:
		err = ESGT_NOT_SUPP;
		break;
	case SG_MBOX_STATUS_COMMAND_FAILURE:
	default:
		err = ESGT_INTERNAL;
		break;
	}

	return (err);
}

int
sbdp_stop_cpu(processorid_t cpu)
{
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		rv = 0;
	int		len;
	static fn_t	f = "sbdp_stop_cpu";

	SBDP_DBG_FUNC("%s\n", f);

	len = sizeof (processorid_t);
	sbdp_init_msg_pkt(reqp, DR_MBOX_STOP_CPU, len, (caddr_t)&cpu);

	sbdp_init_msg_pkt(resp, DR_MBOX_STOP_CPU, 0, (caddr_t)NULL);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to stop cpu: rv = %d\n", rv);
	}

	return (rv);
}

int
sbdp_start_cpu(processorid_t cpu)
{
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		rv = 0;
	int		len;
	static fn_t	f = "sbdp_start_cpu";

	SBDP_DBG_FUNC("%s\n", f);

	len = sizeof (cpu);
	sbdp_init_msg_pkt(reqp, DR_MBOX_START_CPU, len, (caddr_t)&cpu);

	sbdp_init_msg_pkt(resp, DR_MBOX_START_CPU, 0, (caddr_t)NULL);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to start cpu: rv = %d\n", rv);
	}

	return (rv);
}

/*
 * With the SIR implementation for CPU unconfigure, this mailbox
 * call is obsolete.
 */
int
sbdp_start_cpu_pairs(processorid_t cpu)
{
	sbbc_msg_t	request, *reqp = &request;
	sbbc_msg_t	response, *resp = &response;
	int		rv = 0;
	int		len;
	static fn_t	f = "sbdp_start_cpu_pairs";

	SBDP_DBG_FUNC("%s\n", f);

	len = sizeof (cpu);
	sbdp_init_msg_pkt(reqp, DR_MBOX_START_CPU_PAIRS, len, (caddr_t)&cpu);

	sbdp_init_msg_pkt(resp, DR_MBOX_START_CPU_PAIRS, 0, (caddr_t)NULL);

	rv = sbbc_mbox_request_response(reqp, resp, sbdp_mbox_wait);

	if (rv != 0 || (rv = resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {
		SBDP_DBG_MISC("failed to start cpu pair: rv = %d\n", rv);
	}

	return (rv);
}