xref: /illumos-gate/usr/src/uts/sun4u/os/plat_ecc_unum.c (revision e98a9323)

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

#include <sys/plat_ecc_unum.h>
#include <sys/utsname.h>
#include <sys/cmn_err.h>
#include <sys/async.h>
#include <sys/errno.h>
#include <sys/fm/protocol.h>
#include <sys/fm/cpu/UltraSPARC-III.h>
#include <sys/bl.h>
#include <sys/taskq.h>
#include <sys/condvar.h>
#include <sys/plat_ecc_dimm.h>

/*
 * Pointer to platform specific function to initialize a cache of DIMM
 * serial ids
 */
int (*p2init_sid_cache)(void);

/*
 * This file contains the common code that is used for parsing
 * ecc unum data and logging it appropriately as the platform
 * that calls this code implements.
 */

int plat_ecc_dispatch_task(plat_ecc_message_t *);
static void plat_ecc_send_msg(void *);

#define	CHECK_UNUM \
	if (unum_ptr == NULL) { \
		break; \
	}

/*
 * See plat_ecc_unum.h for the meaning of these variables.
 */
int ecc_log_fruid_enable = ECC_FRUID_ENABLE_DEFAULT;

uint32_t plat_ecc_capability_map_domain = PLAT_ECC_CAPABILITY_DOMAIN_DEFAULT;
uint32_t plat_ecc_capability_map_sc = PLAT_ECC_CAPABILITY_SC_DEFAULT;
uint16_t ecc_error2_mailbox_flags = PLAT_ECC_ERROR2_SEND_DEFAULT;
uint16_t ecc_indictment2_mailbox_flags = PLAT_ECC_SEND_INDICT2_DEFAULT;

/*
 * We log all ECC errors using the function that is defined as
 * plat_send_ecc_mailbox_msg(); We first parse the unum string and
 * then pass the data to be logged to the plat_send_ecc_mailbox_msg
 * function for logging. Each platform that uses this code needs to
 * implement a suitable function for this purpose.
 */
void
plat_log_fruid_error(int synd_code, struct async_flt *ecc, char *unum,
    uint64_t afsr_bit)
{
	plat_ecc_error_data_t ecc_error_data;
	enum plat_ecc_type ecc_type = PLAT_ECC_UNKNOWN;
	int board_num;
	int proc_position;
	int invalid_unum = 1;

	bzero(&ecc_error_data, sizeof (plat_ecc_error_data_t));
	ecc_error_data.version = PLAT_ECC_VERSION;

	switch (afsr_bit) {
	case C_AFSR_CE:
		ecc_error_data.error_code = PLAT_ERROR_CODE_CE;
		break;
	case C_AFSR_UE:
		ecc_error_data.error_code = PLAT_ERROR_CODE_UE;
		break;
	case C_AFSR_EDC:
		ecc_error_data.error_code = PLAT_ERROR_CODE_EDC;
		break;
	case C_AFSR_EDU:
		ecc_error_data.error_code = PLAT_ERROR_CODE_EDU;
		break;
	case C_AFSR_WDC:
		ecc_error_data.error_code = PLAT_ERROR_CODE_WDC;
		break;
	case C_AFSR_WDU:
		ecc_error_data.error_code = PLAT_ERROR_CODE_WDU;
		break;
	case C_AFSR_CPC:
		ecc_error_data.error_code = PLAT_ERROR_CODE_CPC;
		break;
	case C_AFSR_CPU:
		ecc_error_data.error_code = PLAT_ERROR_CODE_CPU;
		break;
	case C_AFSR_UCC:
		ecc_error_data.error_code = PLAT_ERROR_CODE_UCC;
		break;
	case C_AFSR_UCU:
		ecc_error_data.error_code = PLAT_ERROR_CODE_UCU;
		break;
	case C_AFSR_EMC:
		ecc_error_data.error_code = PLAT_ERROR_CODE_EMC;
		break;
	case C_AFSR_EMU:
		ecc_error_data.error_code = PLAT_ERROR_CODE_EMU;
		break;
	default:
		/*
		 * Do not send messages with unknown error codes, since
		 * the SC will not be able to tell what type of error
		 * occurred.
		 */
		return;
	}

	ecc_error_data.detecting_proc = ecc->flt_bus_id;

	if (ecc->flt_in_memory)
		ecc_type = PLAT_ECC_MEMORY;
	else if (ecc->flt_status & ECC_ECACHE)
		ecc_type = PLAT_ECC_ECACHE;

	switch (ecc_type) {
	case PLAT_ECC_MEMORY: {
		/*
		 * The unum string is expected to be in this form:
		 * "/N0/SB12/P0/B0/D2 J13500, ..."
		 * for serengeti.  As this code is shared with Starcat
		 * if N is missing then it is set to 0.
		 * From that we will extract the bank number, dimm
		 * number, and Jnumber.
		 */
		char *unum_ptr = unum;
		char *jno_ptr = ecc_error_data.Jnumber;
		int i;

		/*
		 * On Serengeti we expect to find 'N' in the unum string
		 * however, on Starcat 'N' does not appear in the unum string.
		 * We do not want this code to break at this point, so the
		 * unum_ptr is reset to the start of unum string if we fail
		 * to find an 'N'.
		 */
		unum_ptr = strchr(unum_ptr, 'N');
		if (unum_ptr == NULL) {
			ecc_error_data.node_no = 0;
			unum_ptr = unum;
		} else {
			unum_ptr++;
			ecc_error_data.node_no = stoi(&unum_ptr);
		}

		/*
		 * Now pull out the SB number
		 */
		unum_ptr = strstr(unum_ptr, "SB");
		CHECK_UNUM;
		unum_ptr += 2;
		board_num = stoi(&unum_ptr);

		/*
		 * Now pull out the Proc position (relative to the board)
		 */
		unum_ptr = strchr(unum_ptr, 'P');
		CHECK_UNUM;
		unum_ptr++;
		proc_position = stoi(&unum_ptr);

		/*
		 * Using the SB number and Proc position we create a FRU
		 * cpu id.
		 */
		ecc_error_data.proc_num =
		    plat_make_fru_cpuid(board_num, 0, proc_position);

		/*
		 * Now pull out the Memory Bank number
		 */
		unum_ptr = strchr(unum_ptr, 'B');
		CHECK_UNUM;
		unum_ptr++;
		ecc_error_data.bank_no = (stoi(&unum_ptr) & 0x01);

		/*
		 * Now pull out the Dimm number within the Memory Bank.
		 */
		unum_ptr = strchr(unum_ptr, 'D');
		CHECK_UNUM;
		unum_ptr++;
		ecc_error_data.ecache_dimm_no = (stoi(&unum_ptr) & 0x03);

		/*
		 * Now pull out the J-number.
		 */
		unum_ptr = strchr(unum_ptr, 'J');
		CHECK_UNUM;
		unum_ptr++;
		for (i = PLAT_ECC_JNUMBER_LENGTH;
		    i > 0 && *unum_ptr >= '0' && *unum_ptr <= '9'; i--)
			*jno_ptr++ = *unum_ptr++;
		*jno_ptr = '\0';

		/*
		 * If we get here, we can assume the unum is valid
		 */
		invalid_unum = 0;
		break;
	}
	case PLAT_ECC_ECACHE: {
		/*
		 * The unum string is expected to be in this form:
		 * "[/N0/][SB|IO]12/P0/E0 J13500, ..."
		 * for serengeti.  As this code is shared with Starcat
		 * if N is missing then it is set to 0.  IO may only appear
		 * on Starcats.  From that we will extract the bank number,
		 * dimm number, and Jnumber.
		 */
		char *unum_ptr = unum;
		char *jno_ptr = ecc_error_data.Jnumber;
		int is_maxcat = 0;
		int i;

		/*
		 * On Serengeti we expect to find 'N' in the unum string
		 * however, on Starcat 'N' does not appear in the unum string.
		 * We do not want this code to break at this point, so the
		 * unum_ptr is reset to the start of unum string if we fail
		 * to find an 'N'.
		 */
		unum_ptr = strchr(unum_ptr, 'N');
		if (unum_ptr == NULL) {
			ecc_error_data.node_no = 0;
			unum_ptr = unum;
		} else {
			unum_ptr++;
			ecc_error_data.node_no = stoi(&unum_ptr);
		}

		/*
		 * Now pull out the SB/IO number
		 */
		unum_ptr = strstr(unum_ptr, "SB");
		if (unum_ptr == NULL) {

			/*
			 * Since this is an E$ error, it must have occurred on
			 * either a System Board (represented by "SB" in the
			 * unum string) or a Maxcat board ("IO" in the unum
			 * string).  Since we failed the "SB" check, we'll
			 * assume this is a maxcat board.
			 */
			is_maxcat = 1;
			unum_ptr = strstr(unum, "IO");
		}
		CHECK_UNUM;
		unum_ptr += 2;
		board_num = stoi(&unum_ptr);

		/*
		 * Now pull out the Proc position (relative to the board)
		 */
		unum_ptr = strchr(unum_ptr, 'P');
		CHECK_UNUM;
		unum_ptr++;
		proc_position = stoi(&unum_ptr);

		/*
		 * Using the SB/IO number, slot 0/1 value (is_maxcat), and
		 * proc position, we create the cpu id.
		 */
		ecc_error_data.proc_num = plat_make_fru_cpuid(board_num,
		    is_maxcat, proc_position);

		ecc_error_data.bank_no = 0;	/* not used */

		unum_ptr = strchr(unum_ptr, 'E');
		CHECK_UNUM;
		unum_ptr++;
		ecc_error_data.ecache_dimm_no = (stoi(&unum_ptr) & 0x01);

		unum_ptr = strchr(unum_ptr, 'J');
		CHECK_UNUM;
		unum_ptr++;
		for (i = PLAT_ECC_JNUMBER_LENGTH;
		    i > 0 && *unum_ptr >= '0' && *unum_ptr <= '9'; i--)
			*jno_ptr++ = *unum_ptr++;
		*jno_ptr = '\0';

		/*
		 * If we get here, we can assume the unum is valid
		 */
		invalid_unum = 0;
		break;
	}
	default:
		/*
		 * Unknown error
		 */
		break;
	}

	/*
	 * This is where CHECK_UNUM goes when it finds an error
	 */

	if (ECC_SYND_DATA_BEGIN <= synd_code &&
	    synd_code < ECC_SYND_ECC_BEGIN) {
		ecc_error_data.error_type = PLAT_ERROR_TYPE_SINGLE;
		ecc_error_data.databit_type = PLAT_BIT_TYPE_DATA;
		ecc_error_data.databit_no = synd_code;
	} else if (ECC_SYND_ECC_BEGIN <= synd_code &&
	    synd_code < ECC_SYND_MTAG_BEGIN) {
		ecc_error_data.error_type = PLAT_ERROR_TYPE_SINGLE;
		ecc_error_data.databit_type = PLAT_BIT_TYPE_ECC;
		ecc_error_data.databit_no = synd_code - ECC_SYND_ECC_BEGIN;
	} else if (ECC_SYND_MTAG_BEGIN <= synd_code &&
	    synd_code < ECC_SYND_MECC_BEGIN) {
		ecc_error_data.error_type = PLAT_ERROR_TYPE_SINGLE;
		ecc_error_data.databit_type = PLAT_BIT_TYPE_MTAG_D;
		ecc_error_data.databit_no = synd_code - ECC_SYND_MTAG_BEGIN;
	} else if (ECC_SYND_MECC_BEGIN <= synd_code &&
	    synd_code < ECC_SYND_M2) {
		ecc_error_data.error_type = PLAT_ERROR_TYPE_SINGLE;
		ecc_error_data.databit_type = PLAT_BIT_TYPE_MTAG_E;
		ecc_error_data.databit_no = synd_code - ECC_SYND_MECC_BEGIN;
	} else {
		switch (synd_code) {
		case ECC_SYND_M2:
			ecc_error_data.error_type = PLAT_ERROR_TYPE_M2;
			break;
		case ECC_SYND_M3:
			ecc_error_data.error_type = PLAT_ERROR_TYPE_M3;
			break;
		case ECC_SYND_M4:
			ecc_error_data.error_type = PLAT_ERROR_TYPE_M4;
			break;
		case ECC_SYND_M:
			ecc_error_data.error_type = PLAT_ERROR_TYPE_M;
			break;
		default:
			ecc_error_data.error_type = PLAT_ERROR_TYPE_UNK;
			break;
		}
		ecc_error_data.databit_type = PLAT_BIT_TYPE_MULTI;
		ecc_error_data.databit_no = 0; /* not used */
	}

#ifdef DEBUG
	if (invalid_unum &&
	    (ecc_error_data.error_code != PLAT_ERROR_CODE_UE) &&
	    unum && *unum)
		cmn_err(CE_WARN, "Unexpected unum string format: %s\n", unum);
#endif

	/*
	 * Send this data off as a mailbox message to the SC.
	 */
	(void) plat_send_ecc_mailbox_msg(PLAT_ECC_ERROR_MESSAGE,
	    &ecc_error_data);
}

/*
 * The unum string for memory is expected to be in this form:
 * "[/N0/]SB12/P0/B0/D2 [J13500]"
 * Or if the unum was generated as the result of a UE:
 * "[/N0/]SB12/P0/B0 [J13500, ...]"
 * From that we will extract the board number, processor position,
 * bank number and jnumber.
 *
 * Return (1) for an invalid unum string.  If the unum is for an
 * individual DIMM and there is no jnumber, jnumber will be set
 * to -1 and the caller can decide if the unum is valid.  This
 * is because Serengeti does not have jnumbers for bank unums
 * which may be used to create DIMM unums (e.g. for acquiring
 * DIMM serial ids).
 */

int
parse_unum_memory(char *unum, int *board, int *pos, int *bank, int *dimm,
    int *jnumber)
{
	char *c;

	if ((c = strstr(unum, "SB")) == NULL)
		return (1);
	c += 2;
	*board = (uint8_t)stoi(&c);

	if (*c++ != '/' || *c++ != 'P')
		return (1);
	*pos = stoi(&c);

	if (*c++ != '/' || *c++ != 'B')
		return (1);
	*bank = stoi(&c);

	if ((c = strchr(c, 'D')) == NULL) {
		*dimm = -1;
		*jnumber = 0;
		return (0);
	}
	c++;
	*dimm = stoi(&c);

	if ((c = strchr(c, 'J')) == NULL) {
		*jnumber = -1;
		return (0);
	}

	c++;
	*jnumber = (uint16_t)stoi(&c);

	return (0);
}

/*
 * The unum string for ecache is expected to be in this form:
 * "[/N0/][SB|IO]12/P0/E0 J13500, ..."
 * From that we will extract the board number, processor position and
 * junmber.
 *
 * return (1) for any invalid unum string.
 */
static int
parse_unum_ecache(char *unum, int *board, int *pos, int *jnumber, int *maxcat)
{
	char *c;

	if ((c = strstr(unum, "SB")) == NULL) {
		/*
		 * Since this is an E$ error, it must have occurred on
		 * either a System Board (represented by "SB" in the
		 * unum string) or a Maxcat board ("IO" in the unum
		 * string).
		 */
		if ((c = strstr(unum, "IO")) == NULL)
			return (1);
		*maxcat = 1;
	}

	c += 2;
	*board = (uint8_t)stoi(&c);

	if (*c++ != '/' || *c++ != 'P')
		return (1);
	*pos = stoi(&c);

	if ((c = strchr(c, 'J')) == NULL)
		return (1);

	c++;
	*jnumber = (uint16_t)stoi(&c);

	return (0);
}

/* The following array maps the error to its corresponding set */
static int plat_ecc_e2d_map[PLAT_ECC_ERROR2_NUMVALS] = {
	PLAT_ECC_ERROR2_NONE,			/* 0x00 */
	PLAT_ECC_ERROR2_SEND_L2_XXC,		/* 0x01 */
	PLAT_ECC_ERROR2_SEND_L2_XXU,		/* 0x02 */
	PLAT_ECC_ERROR2_SEND_L3_XXC,		/* 0x03 */
	PLAT_ECC_ERROR2_SEND_L3_XXU,		/* 0x04 */
	PLAT_ECC_ERROR2_SEND_MEM_ERRS,		/* 0x05 */
	PLAT_ECC_ERROR2_SEND_MEM_ERRS,		/* 0x06 */
	PLAT_ECC_ERROR2_SEND_MEM_ERRS,		/* 0x07 */
	PLAT_ECC_ERROR2_SEND_BUS_ERRS,		/* 0x08 */
	PLAT_ECC_ERROR2_SEND_BUS_ERRS,		/* 0x09 */
	PLAT_ECC_ERROR2_SEND_BUS_ERRS,		/* 0x0a */
	PLAT_ECC_ERROR2_SEND_BUS_ERRS,		/* 0x0b */
	PLAT_ECC_ERROR2_SEND_L2_TAG_ERRS,	/* 0x0c */
	PLAT_ECC_ERROR2_SEND_L2_TAG_ERRS,	/* 0x0d */
	PLAT_ECC_ERROR2_SEND_L3_TAG_ERRS,	/* 0x0e */
	PLAT_ECC_ERROR2_SEND_L3_TAG_ERRS,	/* 0x0f */
	PLAT_ECC_ERROR2_SEND_L1_PARITY,		/* 0x10 */
	PLAT_ECC_ERROR2_SEND_L1_PARITY,		/* 0x11 */
	PLAT_ECC_ERROR2_SEND_TLB_PARITY,	/* 0x12 */
	PLAT_ECC_ERROR2_SEND_TLB_PARITY,	/* 0x13 */
	PLAT_ECC_ERROR2_SEND_IV_ERRS,		/* 0x14 */
	PLAT_ECC_ERROR2_SEND_IV_ERRS,		/* 0x15 */
	PLAT_ECC_ERROR2_SEND_MTAG_XXC,		/* 0x16 */
	PLAT_ECC_ERROR2_SEND_IV_MTAG_XXC,	/* 0x17 */
	PLAT_ECC_ERROR2_SEND_L3_XXC,		/* 0x18 */
	PLAT_ECC_ERROR2_SEND_PCACHE		/* 0x19 */
};

/*
 * log enhanced error information to SC.
 */
void
plat_log_fruid_error2(int msg_type, char *unum, struct async_flt *aflt,
    plat_ecc_ch_async_flt_t *ecc_ch_flt)
{
	plat_ecc_error2_data_t e2d = {0};
	int board, pos, bank, dimm, jnumber;
	int maxcat = 0;
	uint16_t flags;

	/* Check the flags */
	flags = plat_ecc_e2d_map[msg_type];
	if ((ecc_error2_mailbox_flags & flags) == 0)
		return;

	/* Fill the header */
	e2d.ee2d_major_version = PLAT_ECC_ERROR2_VERSION_MAJOR;
	e2d.ee2d_minor_version = PLAT_ECC_ERROR2_VERSION_MINOR;
	e2d.ee2d_msg_type = PLAT_ECC_ERROR2_MESSAGE;
	e2d.ee2d_msg_length = sizeof (plat_ecc_error2_data_t);

	/* Fill the data */
	if (aflt->flt_in_memory) {
		if (parse_unum_memory(unum, &board, &pos, &bank, &dimm,
		    &jnumber) || (dimm != -1 && jnumber == -1))
			return;
		/*
		 * Using the SB number and Proc position we create a FRU
		 * cpu id.
		 */
		e2d.ee2d_owning_proc = plat_make_fru_cpuid(board, 0, pos);
		e2d.ee2d_jnumber = jnumber;
		e2d.ee2d_bank_number = bank;
	} else if (aflt->flt_status & ECC_ECACHE) {
		if (parse_unum_ecache(unum, &board, &pos, &jnumber, &maxcat))
			return;
		/*
		 * Using the SB number and Proc position we create a FRU
		 * cpu id.
		 */
		e2d.ee2d_owning_proc = plat_make_fru_cpuid(board, maxcat, pos);
		e2d.ee2d_jnumber = jnumber;
		e2d.ee2d_bank_number = (uint8_t)-1;
	} else {
		/*
		 * L1 Cache
		 */
		e2d.ee2d_owning_proc = aflt->flt_bus_id;
		e2d.ee2d_jnumber = (uint16_t)-1;
		e2d.ee2d_bank_number = (uint8_t)-1;
	}

	e2d.ee2d_type = (uint8_t)msg_type;
	e2d.ee2d_afar_status = (uint8_t)ecc_ch_flt->ecaf_afar_status;
	e2d.ee2d_synd_status = (uint8_t)ecc_ch_flt->ecaf_synd_status;
	e2d.ee2d_detecting_proc = aflt->flt_bus_id;
	e2d.ee2d_cpu_impl = cpunodes[e2d.ee2d_owning_proc].implementation;
	e2d.ee2d_timestamp = aflt->flt_id;
	e2d.ee2d_afsr = aflt->flt_stat;
	e2d.ee2d_afar = aflt->flt_addr;

	e2d.ee2d_sdw_afsr = ecc_ch_flt->ecaf_sdw_afsr;
	e2d.ee2d_sdw_afar = ecc_ch_flt->ecaf_sdw_afar;
	e2d.ee2d_afsr_ext = ecc_ch_flt->ecaf_afsr_ext;
	e2d.ee2d_sdw_afsr_ext = ecc_ch_flt->ecaf_sdw_afsr_ext;

	/* Send the message to SC */
	(void) plat_send_ecc_mailbox_msg(PLAT_ECC_ERROR2_MESSAGE, &e2d);
}

uint8_t ecc_indictment_mailbox_disable = PLAT_ECC_INDICTMENT_OK;
uint8_t ecc_indictment_mailbox_flags = PLAT_ECC_SEND_DEFAULT_INDICT;

/*
 * We log all Solaris indictments of failing hardware.  We pull the system
 * board number and jnumber out of the unum string, and calculate the cpuid
 * from some members of the unum string.  The rest of the structure is filled
 * in through the other arguments.  The data structure is then passed to
 * plat_ecc_dispatch_task().  This function should only be loaded into memory
 * or called on platforms that define a plat_send_ecc_mailbox_msg() function.
 */
static int
plat_log_fruid_indictment(int msg_type, struct async_flt *aflt, char *unum)
{
	plat_ecc_message_t *wrapperp;
	plat_ecc_indict_msg_contents_t *contentsp;
	char *unum_ptr;
	int is_maxcat = 0;

	switch (ecc_indictment_mailbox_disable) {
	case (PLAT_ECC_INDICTMENT_OK):
	case (PLAT_ECC_INDICTMENT_SUSPECT):
		break;
	case (PLAT_ECC_INDICTMENT_NO_SEND):
	default:
		return (ECONNREFUSED);
	}

	switch (msg_type) {
	case (PLAT_ECC_INDICT_DIMM):
		if ((ecc_indictment_mailbox_flags &
		    PLAT_ECC_SEND_DIMM_INDICT) == 0)
			return (ECONNREFUSED);
		break;
	case (PLAT_ECC_INDICT_ECACHE_CORRECTABLES):
		if ((ecc_indictment_mailbox_flags &
		    PLAT_ECC_SEND_ECACHE_XXC_INDICT) == 0)
			return (ECONNREFUSED);
		break;
	case (PLAT_ECC_INDICT_ECACHE_UNCORRECTABLE):
		if ((ecc_indictment_mailbox_flags &
		    PLAT_ECC_SEND_ECACHE_XXU_INDICT) == 0)
			return (ECONNREFUSED);
		break;
	default:
		return (ECONNREFUSED);
	}

	/* LINTED: E_TRUE_LOGICAL_EXPR */
	ASSERT(sizeof (plat_ecc_indictment_data_t) == PLAT_ECC_INDICT_SIZE);

	wrapperp = (plat_ecc_message_t *)
	    kmem_zalloc(sizeof (plat_ecc_message_t), KM_SLEEP);

	wrapperp->ecc_msg_status = PLAT_ECC_NO_MSG_ACTIVE;
	wrapperp->ecc_msg_type = PLAT_ECC_INDICTMENT_MESSAGE;
	wrapperp->ecc_msg_len = sizeof (plat_ecc_indictment_data_t);
	wrapperp->ecc_msg_data = kmem_zalloc(wrapperp->ecc_msg_len, KM_SLEEP);

	contentsp = &(((plat_ecc_indictment_data_t *)
	    wrapperp->ecc_msg_data)->msg_contents);

	/*
	 * Find board_num, jnumber, and proc position from the unum string.
	 * Use the board number, is_maxcat, and proc position to calculate
	 * cpuid.
	 */
	unum_ptr = strstr(unum, "SB");
	if (unum_ptr == NULL) {
		is_maxcat = 1;
		unum_ptr = strstr(unum, "IO");
		if (unum_ptr == NULL) {
			kmem_free(wrapperp->ecc_msg_data,
			    wrapperp->ecc_msg_len);
			kmem_free(wrapperp, sizeof (plat_ecc_message_t));
			return (EINVAL);
		}
	}
	unum_ptr += 2;
	contentsp->board_num = (uint8_t)stoi(&unum_ptr);

	unum_ptr = strchr(unum_ptr, 'P');
	if (unum_ptr == NULL) {
		kmem_free(wrapperp->ecc_msg_data, wrapperp->ecc_msg_len);
		kmem_free(wrapperp, sizeof (plat_ecc_message_t));
		return (EINVAL);
	}
	unum_ptr++;
	contentsp->detecting_proc =
	    (uint16_t)plat_make_fru_cpuid(contentsp->board_num, is_maxcat,
	    stoi(&unum_ptr));

	unum_ptr = strchr(unum_ptr, 'J');
	if (unum_ptr == NULL) {
		kmem_free(wrapperp->ecc_msg_data, wrapperp->ecc_msg_len);
		kmem_free(wrapperp, sizeof (plat_ecc_message_t));
		return (EINVAL);
	}
	unum_ptr++;
	contentsp->jnumber = (uint16_t)stoi(&unum_ptr);

	/*
	 * Fill in the rest of the data
	 */
	contentsp->version = PLAT_ECC_INDICTMENT_VERSION;
	contentsp->indictment_type = msg_type;
	contentsp->indictment_uncertain = ecc_indictment_mailbox_disable;
	contentsp->syndrome = aflt->flt_synd;
	contentsp->afsr = aflt->flt_stat;
	contentsp->afar = aflt->flt_addr;

	/*
	 * Build the solaris_version string:
	 */
	(void) snprintf(contentsp->solaris_version,
	    PLAT_ECC_VERSION_LENGTH, "%s %s", utsname.release, utsname.version);

	/*
	 * Send the data on to the queuing function
	 */
	return (plat_ecc_dispatch_task(wrapperp));
}

/* The following array maps the indictment to its corresponding set */
static int plat_ecc_i2d_map[PLAT_ECC_INDICT2_NUMVALS] = {
	PLAT_ECC_INDICT2_NONE,			/* 0x00 */
	PLAT_ECC_SEND_INDICT2_L2_XXU,		/* 0x01 */
	PLAT_ECC_SEND_INDICT2_L2_XXC_SERD,	/* 0x02 */
	PLAT_ECC_SEND_INDICT2_L2_TAG_SERD,	/* 0x03 */
	PLAT_ECC_SEND_INDICT2_L3_XXU,		/* 0x04 */
	PLAT_ECC_SEND_INDICT2_L3_XXC_SERD,	/* 0x05 */
	PLAT_ECC_SEND_INDICT2_L3_TAG_SERD,	/* 0x06 */
	PLAT_ECC_SEND_INDICT2_L1_SERD,		/* 0x07 */
	PLAT_ECC_SEND_INDICT2_L1_SERD,		/* 0x08 */
	PLAT_ECC_SEND_INDICT2_TLB_SERD,		/* 0x09 */
	PLAT_ECC_SEND_INDICT2_TLB_SERD,		/* 0x0a */
	PLAT_ECC_SEND_INDICT2_FPU,		/* 0x0b */
	PLAT_ECC_SEND_INDICT2_PCACHE_SERD	/* 0x0c */
};

static int
plat_log_fruid_indictment2(int msg_type, struct async_flt *aflt, char *unum)
{
	plat_ecc_message_t *wrapperp;
	plat_ecc_indictment2_data_t *i2d;
	int board, pos, jnumber;
	int maxcat = 0;
	uint16_t flags;

	/*
	 * If the unum is null or empty, skip parsing it
	 */
	if (unum && unum[0] != '\0') {
		if (parse_unum_ecache(unum, &board, &pos, &jnumber, &maxcat))
			return (EINVAL);
	}

	if ((ecc_indictment_mailbox_disable != PLAT_ECC_INDICTMENT_OK) &&
	    (ecc_indictment_mailbox_disable != PLAT_ECC_INDICTMENT_SUSPECT))
		return (ECONNREFUSED);

	/* Check the flags */
	flags = plat_ecc_i2d_map[msg_type];
	if ((ecc_indictment2_mailbox_flags & flags) == 0)
		return (ECONNREFUSED);

	wrapperp = (plat_ecc_message_t *)
	    kmem_zalloc(sizeof (plat_ecc_message_t), KM_SLEEP);

	/* Initialize the wrapper */
	wrapperp->ecc_msg_status = PLAT_ECC_NO_MSG_ACTIVE;
	wrapperp->ecc_msg_type = PLAT_ECC_INDICTMENT2_MESSAGE;
	wrapperp->ecc_msg_len = sizeof (plat_ecc_indictment2_data_t);
	wrapperp->ecc_msg_data = kmem_zalloc(wrapperp->ecc_msg_len, KM_SLEEP);

	i2d = (plat_ecc_indictment2_data_t *)wrapperp->ecc_msg_data;

	/* Fill the header */
	i2d->ei2d_major_version = PLAT_ECC_INDICT2_MAJOR_VERSION;
	i2d->ei2d_minor_version = PLAT_ECC_INDICT2_MINOR_VERSION;
	i2d->ei2d_msg_type = PLAT_ECC_INDICTMENT2_MESSAGE;
	i2d->ei2d_msg_length = sizeof (plat_ecc_indictment2_data_t);

	/* Fill the data */
	if (unum && unum[0] != '\0') {
		i2d->ei2d_arraigned_proc = plat_make_fru_cpuid(board, maxcat,
		    pos);
		i2d->ei2d_board_num = board;
		i2d->ei2d_jnumber = jnumber;
	} else {
		i2d->ei2d_arraigned_proc = aflt->flt_inst;
		i2d->ei2d_board_num = (uint8_t)
		    plat_make_fru_boardnum(i2d->ei2d_arraigned_proc);
		i2d->ei2d_jnumber = (uint16_t)-1;
	}

	i2d->ei2d_type = msg_type;
	i2d->ei2d_uncertain = ecc_indictment_mailbox_disable;
	i2d->ei2d_cpu_impl = cpunodes[i2d->ei2d_arraigned_proc].implementation;
	i2d->ei2d_timestamp = aflt->flt_id;

	/*
	 * Send the data on to the queuing function
	 */
	return (plat_ecc_dispatch_task(wrapperp));
}

int
plat_ecc_capability_send(void)
{
	plat_ecc_message_t *wrapperp;
	plat_capability_data_t	*cap;
	int ver_len;

	wrapperp = kmem_zalloc(sizeof (plat_ecc_message_t), KM_SLEEP);

	ver_len = strlen(utsname.release) + strlen(utsname.version) + 2;

	/* Initialize the wrapper */
	wrapperp->ecc_msg_status = PLAT_ECC_NO_MSG_ACTIVE;
	wrapperp->ecc_msg_type = PLAT_ECC_CAPABILITY_MESSAGE;
	wrapperp->ecc_msg_len = sizeof (plat_capability_data_t) + ver_len;
	wrapperp->ecc_msg_data = kmem_zalloc(wrapperp->ecc_msg_len, KM_SLEEP);

	cap = (plat_capability_data_t *)wrapperp->ecc_msg_data;

	/* Fill the header */
	cap->capd_major_version = PLAT_ECC_CAP_VERSION_MAJOR;
	cap->capd_minor_version = PLAT_ECC_CAP_VERSION_MINOR;
	cap->capd_msg_type = PLAT_ECC_CAPABILITY_MESSAGE;
	cap->capd_msg_length = wrapperp->ecc_msg_len;

	/* Set the default domain capability */
	cap->capd_capability = PLAT_ECC_CAPABILITY_DOMAIN_DEFAULT;

	/*
	 * Build the solaris_version string:
	 * utsname.release + " " + utsname.version
	 */
	(void) snprintf(cap->capd_solaris_version, ver_len, "%s %s",
	    utsname.release, utsname.version);

	/*
	 * Send the data on to the queuing function
	 */
	return (plat_ecc_dispatch_task(wrapperp));
}

int
plat_ecc_capability_sc_get(int type)
{
	switch (type) {
		case PLAT_ECC_ERROR_MESSAGE:
			if (ecc_log_fruid_enable &&
			    (!(plat_ecc_capability_map_sc &
			    PLAT_ECC_CAPABILITY_ERROR2)))
				return (1);
			break;
		case PLAT_ECC_ERROR2_MESSAGE:
			if (plat_ecc_capability_map_sc &
			    PLAT_ECC_CAPABILITY_ERROR2)
				return (1);
			break;
		case PLAT_ECC_INDICTMENT_MESSAGE:
			if (!(plat_ecc_capability_map_sc &
			    PLAT_ECC_CAPABILITY_INDICT2) ||
			    !(plat_ecc_capability_map_domain &
			    PLAT_ECC_CAPABILITY_FMA))
				return (1);
			break;
		case PLAT_ECC_INDICTMENT2_MESSAGE:
			if (plat_ecc_capability_map_sc &
			    PLAT_ECC_CAPABILITY_INDICT2)
				return (1);
			break;
		case PLAT_ECC_DIMM_SID_MESSAGE:
			if (plat_ecc_capability_map_sc &
			    PLAT_ECC_CAPABILITY_DIMM_SID)
				return (1);
			/* FALLTHROUGH */
		default:
			return (0);
	}
	return (0);
}

int plat_ecc_cap_sc_set_cnt = 0;

void
plat_ecc_capability_sc_set(uint32_t cap)
{
	plat_ecc_capability_map_sc = cap;

	if (!plat_ecc_cap_sc_set_cnt && (cap & PLAT_ECC_CAPABILITY_DIMM_SID))
		if (p2init_sid_cache)
			p2init_sid_cache();

	plat_ecc_cap_sc_set_cnt++;
}

/*
 * The following table represents mapping between the indictment1 reason
 * to its type.
 */

static plat_ecc_bl_map_t plat_ecc_bl_map_v1[] = {
	{ "l2cachedata",	PLAT_ECC_INDICT_ECACHE_CORRECTABLES	},
	{ "l3cachedata",	PLAT_ECC_INDICT_ECACHE_CORRECTABLES	},
	{ "l2cachedata",	PLAT_ECC_INDICT_ECACHE_UNCORRECTABLE	},
	{ "l3cachedata",	PLAT_ECC_INDICT_ECACHE_UNCORRECTABLE	}
};

/*
 * The following table represents mapping between the indictment2 reason
 * to its type.
 */

static plat_ecc_bl_map_t plat_ecc_bl_map_v2[] = {
	{ "l2cachedata",	PLAT_ECC_INDICT2_L2_SERD	},
	{ "l3cachedata",	PLAT_ECC_INDICT2_L3_SERD	},
	{ "l2cachedata",	PLAT_ECC_INDICT2_L2_UE		},
	{ "l3cachedata",	PLAT_ECC_INDICT2_L3_UE		},
	{ "l2cachetag",		PLAT_ECC_INDICT2_L2_TAG_SERD	},
	{ "l3cachetag",		PLAT_ECC_INDICT2_L3_TAG_SERD	},
	{ "icache",		PLAT_ECC_INDICT2_ICACHE_SERD	},
	{ "dcache",		PLAT_ECC_INDICT2_DCACHE_SERD	},
	{ "pcache",		PLAT_ECC_INDICT2_PCACHE_SERD	},
	{ "itlb",		PLAT_ECC_INDICT2_ITLB_SERD	},
	{ "dtlb",		PLAT_ECC_INDICT2_DTLB_SERD	},
	{ "fpu",		PLAT_ECC_INDICT2_FPU		}
};

/*
 * The following function returns the indictment type for a given version
 */
static int
flt_name_to_msg_type(const char *fault, int indict_version)
{
	plat_ecc_bl_map_t *mapp;
	char *fltnm = "fault.cpu.";
	int mapsz;
	char *p;
	int i;

	/* Check if it starts with proper fault name */
	if (strncmp(fault, fltnm, strlen(fltnm)) != 0)
		return (PLAT_ECC_INDICT_NONE);

	fault += strlen(fltnm); /* c = "ultraSPARC-IV.icache" */

	/* Skip the cpu type */
	if ((p = strchr(fault, '.')) == NULL)
		return (PLAT_ECC_INDICT_NONE);

	p++;	/* skip the "." */

	if (indict_version ==  0) {
		mapp = plat_ecc_bl_map_v1;
		mapsz = sizeof (plat_ecc_bl_map_v1) /
		    sizeof (plat_ecc_bl_map_t);
	} else {
		mapp = plat_ecc_bl_map_v2;
		mapsz = sizeof (plat_ecc_bl_map_v2) /
		    sizeof (plat_ecc_bl_map_t);
	}
	for (i = 0; i < mapsz; i++) {
		if (strcmp(p, mapp[i].ebm_reason) == 0) {
			return (mapp[i].ebm_type);
		}
	}
	return (PLAT_ECC_INDICT_NONE);
}

/*
 * Blacklisting
 */
int
plat_blacklist(int cmd, const char *scheme, nvlist_t *fmri, const char *class)
{
	struct async_flt aflt;
	char *unum;
	int msg_type, is_old_indict;

	if (fmri == NULL)
		return (EINVAL);
	if (cmd != BLIOC_INSERT)
		return (ENOTSUP);

	/*
	 * We support both the blacklisting of CPUs via mem-schemed
	 * FMRIs that name E$ J-numbers, and CPUs via cpu-schemed FMRIs
	 * that name the cpuid.
	 */
	if (strcmp(scheme, FM_FMRI_SCHEME_MEM) == 0) {
		if (nvlist_lookup_string(fmri, FM_FMRI_MEM_UNUM, &unum))
			return (EINVAL);
		aflt.flt_inst = (uint_t)-1;
	} else if (strcmp(scheme, FM_FMRI_SCHEME_CPU) == 0) {
		if (nvlist_lookup_uint32(fmri, FM_FMRI_CPU_ID, &aflt.flt_inst))
			return (EINVAL);
		unum = NULL;
	} else {
		return (ENOTSUP);
	}

	/*
	 * If the SC cannot handle indictment2, so fall back to old one.
	 * Also if the domain does not support FMA, then send only the old one.
	 */

	is_old_indict = plat_ecc_capability_sc_get(PLAT_ECC_INDICTMENT_MESSAGE);

	if (is_old_indict)
		msg_type = flt_name_to_msg_type(class, 0);
	else
		msg_type = flt_name_to_msg_type(class, 1);

	if (msg_type == PLAT_ECC_INDICT_NONE)
		return (ENOTSUP);

	/*
	 * The current blacklisting interfaces are designed for a world where
	 * the SC is much more involved in the diagnosis and error reporting
	 * process than it is in the FMA world.  As such, the existing
	 * interfaces want all kinds of information about the error that's
	 * triggering the blacklist.  In the FMA world, we don't have access
	 * to any of that information by the time we're doing the blacklist,
	 * so we fake values.
	 */
	aflt.flt_id = gethrtime();
	aflt.flt_addr = -1;
	aflt.flt_stat = -1;
	aflt.flt_synd = (ushort_t)-1;

	if (is_old_indict) {
		if (unum && unum[0] != '\0')
			return (plat_log_fruid_indictment(msg_type, &aflt,
			    unum));
		else
			return (ENOTSUP);
	} else {
		return (plat_log_fruid_indictment2(msg_type, &aflt, unum));
	}
}

static kcondvar_t plat_ecc_condvar;
static kmutex_t plat_ecc_mutex;
static taskq_t *plat_ecc_taskq;

/*
 * plat_ecc_dispatch_task: Dispatch the task on a taskq and wait for the
 * return value.  We use cv_wait_sig to wait for the return values.  If a
 * signal interrupts us, we return EINTR.  Otherwise, we return the value
 * returned by the mailbox functions.
 *
 * To avoid overloading the lower-level mailbox routines, we use a taskq
 * to serialize all messages.  Currently, it is expected that only one
 * process (fmd) will use this ioctl, so the delay caused by the taskq
 * should not have much of an effect.
 */
int
plat_ecc_dispatch_task(plat_ecc_message_t *msg)
{
	int ret;

	ASSERT(msg != NULL);
	ASSERT(plat_ecc_taskq != NULL);

	if (taskq_dispatch(plat_ecc_taskq, plat_ecc_send_msg,
	    (void *)msg, TQ_NOSLEEP) == TASKQID_INVALID) {
		kmem_free(msg->ecc_msg_data, msg->ecc_msg_len);
		kmem_free(msg, sizeof (plat_ecc_message_t));
		return (ENOMEM);
	}
	mutex_enter(&plat_ecc_mutex);

	/*
	 * It's possible that the taskq function completed before we
	 * acquired the mutex.  Check for this first.  If this did not
	 * happen, we wait for the taskq function to signal us, or an
	 * interrupt.  We also check ecc_msg_status to protect against
	 * spurious wakeups from cv_wait_sig.
	 */
	if (msg->ecc_msg_status == PLAT_ECC_MSG_SENT) {
		ret = msg->ecc_msg_ret;
		kmem_free(msg->ecc_msg_data, msg->ecc_msg_len);
		kmem_free(msg, sizeof (plat_ecc_message_t));
	} else {
		msg->ecc_msg_status = PLAT_ECC_TASK_DISPATCHED;

		while ((ret = cv_wait_sig(&plat_ecc_condvar,
		    &plat_ecc_mutex)) != 0 &&
		    msg->ecc_msg_status == PLAT_ECC_TASK_DISPATCHED)
			;

		if ((ret == 0) && (msg->ecc_msg_status != PLAT_ECC_MSG_SENT)) {
			/* An interrupt was received */
			msg->ecc_msg_status = PLAT_ECC_INTERRUPT_RECEIVED;
			ret = EINTR;
		} else {
			ret = msg->ecc_msg_ret;
			kmem_free(msg->ecc_msg_data, msg->ecc_msg_len);
			kmem_free(msg, sizeof (plat_ecc_message_t));
		}
	}
	mutex_exit(&plat_ecc_mutex);
	return (ret);
}

static void
plat_ecc_send_msg(void *arg)
{
	plat_ecc_message_t *msg = arg;
	int ret;

	/*
	 * Send this data off as a mailbox message to the SC.
	 */
	ret = plat_send_ecc_mailbox_msg(msg->ecc_msg_type, msg->ecc_msg_data);

	mutex_enter(&plat_ecc_mutex);

	/*
	 * If the dispatching function received an interrupt, don't bother
	 * signalling it, and throw away the results.  Otherwise, set the
	 * return value and signal the condvar.
	 */
	if (msg->ecc_msg_status == PLAT_ECC_INTERRUPT_RECEIVED) {
		kmem_free(msg->ecc_msg_data, msg->ecc_msg_len);
		kmem_free(msg, sizeof (plat_ecc_message_t));
	} else {
		msg->ecc_msg_ret = ret;
		msg->ecc_msg_status = PLAT_ECC_MSG_SENT;
		cv_broadcast(&plat_ecc_condvar);
	}

	mutex_exit(&plat_ecc_mutex);
}

void
plat_ecc_init(void)
{
	int	bd;

	mutex_init(&plat_ecc_mutex, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&plat_ecc_condvar, NULL, CV_DEFAULT, NULL);
	plat_ecc_taskq = taskq_create("plat_ecc_taskq", 1, minclsyspri,
	    PLAT_ECC_TASKQ_MIN, PLAT_ECC_TASKQ_MAX, TASKQ_PREPOPULATE);
	ASSERT(plat_ecc_taskq != NULL);

	for (bd = 0; bd < plat_max_cpumem_boards(); bd++) {
		mutex_init(&domain_dimm_sids[bd].pdsb_lock,
		    NULL, MUTEX_DEFAULT, NULL);
	}

}