/*
 * 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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/errno.h>
#include <sys/log.h>
#include <sys/systm.h>
#include <sys/modctl.h>
#include <sys/errorq.h>
#include <sys/controlregs.h>
#include <sys/fm/util.h>
#include <sys/fm/protocol.h>
#include <sys/sysevent.h>
#include <sys/pghw.h>
#include <sys/cyclic.h>
#include <sys/pci_cfgspace.h>
#include <sys/mc_intel.h>
#include <sys/smbios.h>
#include "nb5000.h"
#include "nb_log.h"
#include "dimm_phys.h"

int nb_check_validlog = 1;

static uint32_t uerrcnt[2];
static uint32_t cerrcnta[2][2];
static uint32_t cerrcntb[2][2];
static uint32_t cerrcntc[2][2];
static uint32_t cerrcntd[2][2];
static nb_logout_t nb_log;

struct mch_error_code {
        int intel_error_list;   /* error number in Chipset Error List */
        uint32_t emask;         /* mask for machine check */
        uint32_t error_bit;     /* error bit in fault register */
};

static struct mch_error_code fat_fbd_error_code[] = {
        { 23, EMASK_FBD_M23, ERR_FAT_FBD_M23 },
        { 3, EMASK_FBD_M3, ERR_FAT_FBD_M3 },
        { 2, EMASK_FBD_M2, ERR_FAT_FBD_M2 },
        { 1, EMASK_FBD_M1, ERR_FAT_FBD_M1 }
};

static int
intel_fat_fbd_err(uint32_t fat_fbd)
{
        int rt = -1;
        int nerr = 0;
        uint32_t emask_fbd = 0;
        int i;
        int sz;

        sz = sizeof (fat_fbd_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (fat_fbd & fat_fbd_error_code[i].error_bit) {
                        rt = fat_fbd_error_code[i].intel_error_list;
                        emask_fbd |= fat_fbd_error_code[i].emask;
                        nerr++;
                }
        }

        if (emask_fbd)
                nb_fbd_mask_mc(emask_fbd);
        if (nerr > 1)
                rt = -1;
        return (rt);
}

static char *
fat_memory_error(const nb_regs_t *rp, void *data)
{
        int channel;
        uint32_t ferr_fat_fbd, nrecmemb;
        uint32_t nrecmema;
        char *intr = "nb.unknown";
        nb_mem_scatchpad_t *sp = &((nb_scatchpad_t *)data)->ms;

        ferr_fat_fbd = rp->nb.fat_fbd_regs.ferr_fat_fbd;
        if ((ferr_fat_fbd & ERR_FAT_FBD_MASK) == 0) {
                sp->intel_error_list =
                    intel_fat_fbd_err(rp->nb.fat_fbd_regs.nerr_fat_fbd);
                sp->branch = -1;
                sp->channel = -1;
                sp->rank = -1;
                sp->dimm = -1;
                sp->bank = -1;
                sp->cas = -1;
                sp->ras = -1;
                sp->pa = -1LL;
                sp->offset = -1;
                return (intr);
        }
        sp->intel_error_list = intel_fat_fbd_err(ferr_fat_fbd);
        channel = (ferr_fat_fbd >> 28) & 3;
        sp->branch = channel >> 1;
        sp->channel = channel;
        if ((ferr_fat_fbd & (ERR_FAT_FBD_M2|ERR_FAT_FBD_M1)) != 0) {
                if ((ferr_fat_fbd & ERR_FAT_FBD_M1) != 0)
                        intr = "nb.fbd.alert";  /* Alert on FB-DIMM M1 */
                else
                        intr = "nb.fbd.crc";    /* CRC error FB_DIMM M2 */
                nrecmema = rp->nb.fat_fbd_regs.nrecmema;
                nrecmemb = rp->nb.fat_fbd_regs.nrecmemb;
                sp->rank = (nrecmema >> 8) & RANK_MASK;
                sp->dimm = sp->rank >> 1;
                sp->bank = (nrecmema >> 12) & BANK_MASK;
                sp->cas = (nrecmemb >> 16) & CAS_MASK;
                sp->ras = nrecmemb & RAS_MASK;
                /*
                 * If driver was built with closed tree present then we will
                 * have Intel proprietary code for finding physaddr
                 */
                if (&dimm_getphys) {
                        sp->pa = dimm_getphys((uint16_t)sp->branch,
                            (uint16_t)sp->rank, (uint64_t)sp->bank,
                            (uint64_t)sp->ras, (uint64_t)sp->cas);
                        if (sp->pa >= MAXPHYS_ADDR)
                                sp->pa = -1ULL;
                } else {
                        sp->pa = -1ULL;
                }
                /*
                 * If there is an offset decoder use it otherwise encode
                 * rank/bank/ras/cas
                 */
                if (&dimm_getoffset) {
                        sp->offset = dimm_getoffset(sp->branch, sp->rank,
                            sp->bank, sp->ras, sp->cas);
                } else {
                        sp->offset = TCODE_OFFSET(sp->rank, sp->bank, sp->ras,
                            sp->cas);
                }
        } else {
                if ((ferr_fat_fbd & ERR_FAT_FBD_M3) != 0)
                        intr = "nb.fbd.otf";    /* thermal temp > Tmid M3 */
                else if ((ferr_fat_fbd & ERR_FAT_FBD_M23) != 0) {
                        intr = "nb.fbd.reset_timeout";
                        sp->channel = -1;
                }
                sp->rank = -1;
                sp->dimm = -1;
                sp->bank = -1;
                sp->cas = -1;
                sp->ras = -1;
                sp->pa = -1LL;
                sp->offset = -1;
        }
        return (intr);
}


static struct mch_error_code nf_fbd_error_code[] = {
        { 29, EMASK_FBD_M29, ERR_NF_FBD_M29 },
        { 28, EMASK_FBD_M28, ERR_NF_FBD_M28 },
        { 27, EMASK_FBD_M27, ERR_NF_FBD_M27 },
        { 26, EMASK_FBD_M26, ERR_NF_FBD_M26 },
        { 25, EMASK_FBD_M25, ERR_NF_FBD_M25 },
        { 24, EMASK_FBD_M24, ERR_NF_FBD_M24 },
        { 22, EMASK_FBD_M22, ERR_NF_FBD_M22 },
        { 21, EMASK_FBD_M21, ERR_NF_FBD_M21 },
        { 20, EMASK_FBD_M20, ERR_NF_FBD_M20 },
        { 19, EMASK_FBD_M19, ERR_NF_FBD_M19 },
        { 18, EMASK_FBD_M18, ERR_NF_FBD_M18 },
        { 17, EMASK_FBD_M17, ERR_NF_FBD_M17 },
        { 16, EMASK_FBD_M16, ERR_NF_FBD_M16 },
        { 15, EMASK_FBD_M15, ERR_NF_FBD_M15 },
        { 14, EMASK_FBD_M14, ERR_NF_FBD_M14 },
        { 13, EMASK_FBD_M13, ERR_NF_FBD_M13 },
        { 12, EMASK_FBD_M12, ERR_NF_FBD_M12 },
        { 11, EMASK_FBD_M11, ERR_NF_FBD_M11 },
        { 10, EMASK_FBD_M10, ERR_NF_FBD_M10 },
        { 9, EMASK_FBD_M9, ERR_NF_FBD_M9 },
        { 8, EMASK_FBD_M8, ERR_NF_FBD_M8 },
        { 7, EMASK_FBD_M7, ERR_NF_FBD_M7 },
        { 6, EMASK_FBD_M6, ERR_NF_FBD_M6 },
        { 5, EMASK_FBD_M5, ERR_NF_FBD_M5 },
        { 4, EMASK_FBD_M4, ERR_NF_FBD_M4 }
};

static int
intel_nf_fbd_err(uint32_t nf_fbd)
{
        int rt = -1;
        int nerr = 0;
        uint32_t emask_fbd = 0;
        int i;
        int sz;

        sz = sizeof (nf_fbd_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (nf_fbd & nf_fbd_error_code[i].error_bit) {
                        rt = nf_fbd_error_code[i].intel_error_list;
                        emask_fbd |= nf_fbd_error_code[i].emask;
                        nerr++;
                }
        }
        if (emask_fbd)
                nb_fbd_mask_mc(emask_fbd);
        if (nerr > 1)
                rt = -1;
        return (rt);
}

static char *
nf_memory_error(const nb_regs_t *rp, void *data)
{
        uint32_t ferr_nf_fbd, recmemb, redmemb;
        uint32_t recmema;
        int branch, channel, ecc_locator;
        char *intr = "nb.unknown";
        nb_mem_scatchpad_t *sp = &((nb_scatchpad_t *)data)->ms;

        sp->rank = -1;
        sp->dimm = -1;
        sp->bank = -1;
        sp->cas = -1;
        sp->ras = -1LL;
        sp->pa = -1LL;
        sp->offset = -1;
        ferr_nf_fbd = rp->nb.nf_fbd_regs.ferr_nf_fbd;
        if ((ferr_nf_fbd & ERR_NF_FBD_MASK) == 0) {
                /* unknown ereport if a recognizable error was not found */
                sp->branch = -1;
                sp->channel = -1;
                sp->intel_error_list = -1;
                return (intr);
        }
        sp->intel_error_list = intel_nf_fbd_err(ferr_nf_fbd);
        channel = (ferr_nf_fbd >> ERR_FBD_CH_SHIFT) & 3;
        branch = channel >> 1;
        sp->branch = branch;
        sp->channel = channel;
        if (ferr_nf_fbd & ERR_NF_FBD_MASK) {
                if (ferr_nf_fbd & ERR_NF_FBD_ECC_UE) {
                        /*
                         * uncorrectable ECC M4 - M12
                         * we can only isolate to pair of dimms
                         * for single dimm configuration let eversholt
                         * sort it out with out needing a special rule
                         */
                        sp->channel = -1;
                        recmema = rp->nb.nf_fbd_regs.recmema;
                        recmemb = rp->nb.nf_fbd_regs.recmemb;
                        sp->rank = (recmema >> 8) & RANK_MASK;
                        sp->bank = (recmema >> 12) & BANK_MASK;
                        sp->cas = (recmemb >> 16) & CAS_MASK;
                        sp->ras = recmemb & RAS_MASK;
                        intr = "nb.mem_ue";
                } else if (ferr_nf_fbd & ERR_NF_FBD_M13) {
                        /*
                         * write error M13
                         * we can only isolate to pair of dimms
                         */
                        sp->channel = -1;
                        if (nb_mode != NB_MEMORY_MIRROR) {
                                recmema = rp->nb.nf_fbd_regs.recmema;
                                recmemb = rp->nb.nf_fbd_regs.recmemb;
                                sp->rank = (recmema >> 8) & RANK_MASK;
                                sp->bank = (recmema >> 12) & BANK_MASK;
                                sp->cas = (recmemb >> 16) & CAS_MASK;
                                sp->ras = recmemb & RAS_MASK;
                        }
                        intr = "nb.fbd.ma"; /* memory alert */
                } else if (ferr_nf_fbd & ERR_NF_FBD_MA) { /* M14, M15 and M21 */
                        intr = "nb.fbd.ch"; /* FBD on channel */
                } else if ((ferr_nf_fbd & ERR_NF_FBD_ECC_CE) != 0) {
                        /* correctable ECC M17-M20 */
                        recmema = rp->nb.nf_fbd_regs.recmema;
                        recmemb = rp->nb.nf_fbd_regs.recmemb;
                        sp->rank = (recmema >> 8) & RANK_MASK;
                        redmemb = rp->nb.nf_fbd_regs.redmemb;
                        ecc_locator = redmemb & 0x3ffff;
                        if (ecc_locator & 0x1ff)
                                sp->channel = branch << 1;
                        else if (ecc_locator & 0x3fe00)
                                sp->channel = (branch << 1) + 1;
                        sp->dimm = sp->rank >> 1;
                        sp->bank = (recmema >> 12) & BANK_MASK;
                        sp->cas = (recmemb >> 16) & CAS_MASK;
                        sp->ras = recmemb & RAS_MASK;
                        intr = "nb.mem_ce";
                } else if ((ferr_nf_fbd & ERR_NF_FBD_SPARE) != 0) {
                        /* spare dimm M27, M28 */
                        intr = "nb.mem_ds";
                        sp->channel = -1;
                        if (rp->nb.nf_fbd_regs.spcps & SPCPS_SPARE_DEPLOYED) {
                                sp->rank =
                                    SPCPS_FAILED_RANK(rp->nb.nf_fbd_regs.spcps);
                                nb_used_spare_rank(sp->branch, sp->rank);
                                nb_config_gen++;
                        }
                } else if ((ferr_nf_fbd & ERR_NF_FBD_M22) != 0) {
                        intr = "nb.spd";        /* SPD protocol */
                }
        }
        if (sp->ras != -1) {
                /*
                 * If driver was built with closed tree present then we will
                 * have Intel proprietary code for finding physaddr
                 */
                if (&dimm_getphys) {
                        sp->pa = dimm_getphys((uint16_t)sp->branch,
                            (uint16_t)sp->rank, (uint64_t)sp->bank,
                            (uint64_t)sp->ras, (uint64_t)sp->cas);
                        if (sp->pa >= MAXPHYS_ADDR)
                                sp->pa = -1ULL;
                } else {
                        sp->pa = -1ULL;
                }
                if (&dimm_getoffset) {
                        sp->offset = dimm_getoffset(sp->branch, sp->rank,
                            sp->bank, sp->ras, sp->cas);
                } else {
                        sp->offset = TCODE_OFFSET(sp->rank, sp->bank, sp->ras,
                            sp->cas);
                }
        }
        return (intr);
}

static struct mch_error_code nf_mem_error_code[] = {
        { 21, EMASK_MEM_M21, ERR_NF_MEM_M21 },
        { 20, EMASK_MEM_M20, ERR_NF_MEM_M20 },
        { 18, EMASK_MEM_M18, ERR_NF_MEM_M18 },
        { 16, EMASK_MEM_M16, ERR_NF_MEM_M16 },
        { 15, EMASK_MEM_M15, ERR_NF_MEM_M15 },
        { 14, EMASK_MEM_M14, ERR_NF_MEM_M14 },
        { 12, EMASK_MEM_M12, ERR_NF_MEM_M12 },
        { 11, EMASK_MEM_M11, ERR_NF_MEM_M11 },
        { 10, EMASK_MEM_M10, ERR_NF_MEM_M10 },
        { 6, EMASK_MEM_M6, ERR_NF_MEM_M6 },
        { 5, EMASK_MEM_M5, ERR_NF_MEM_M5 },
        { 4, EMASK_MEM_M4, ERR_NF_MEM_M4 },
        { 1, EMASK_MEM_M1, ERR_NF_MEM_M1 }
};

static int
intel_nf_mem_err(uint32_t nf_mem)
{
        int rt = -1;
        int nerr = 0;
        uint32_t emask_mem = 0;
        int i;
        int sz;

        sz = sizeof (nf_mem_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (nf_mem & nf_mem_error_code[i].error_bit) {
                        rt = nf_mem_error_code[i].intel_error_list;
                        emask_mem |= nf_mem_error_code[i].emask;
                        nerr++;
                }
        }
        if (emask_mem)
                nb_mem_mask_mc(emask_mem);
        if (nerr > 1)
                rt = -1;
        return (rt);
}

static char *
nf_mem_error(const nb_regs_t *rp, void *data)
{
        uint32_t ferr_nf_mem, recmema, recmemb;
        uint32_t nrecmema, nrecmemb, validlog;
        int channel;
        char *intr = "nb.unknown";
        nb_mem_scatchpad_t *sp = &((nb_scatchpad_t *)data)->ms;

        sp->rank = -1;
        sp->dimm = -1;
        sp->bank = -1;
        sp->cas = -1;
        sp->ras = -1LL;
        sp->pa = -1LL;
        sp->offset = -1;
        ferr_nf_mem = rp->nb.nf_mem_regs.ferr_nf_mem;
        if ((ferr_nf_mem & ERR_NF_MEM_MASK) == 0) {
                /* no first error found */
                sp->branch = -1;
                sp->channel = -1;
                sp->intel_error_list =
                    intel_nf_mem_err(rp->nb.nf_mem_regs.nerr_nf_mem);
                return (intr);
        }
        sp->intel_error_list = intel_nf_mem_err(ferr_nf_mem);

        channel = (ferr_nf_mem >> ERR_MEM_CH_SHIFT) & 0x1;
        sp->branch = channel;
        sp->channel = -1;
        if (ferr_nf_mem & ERR_NF_MEM_MASK) {
                if (ferr_nf_mem & ERR_NF_MEM_ECC_UE) {
                        /*
                         * uncorrectable ECC M1,M4-M6,M10-M12
                         * There is only channel per branch
                         * Invalidate the channel number so the mem ereport
                         * has the same detector with existing 5000 ereports.
                         * so we can leverage the existing Everhsolt rule.
                         */
                        validlog = rp->nb.nf_mem_regs.validlog;
                        if (ferr_nf_mem & ERR_NF_MEM_M1) {
                                nrecmema = rp->nb.nf_mem_regs.nrecmema;
                                nrecmemb = rp->nb.nf_mem_regs.nrecmemb;
                                /* check if the nrecmem log is valid */
                                if (validlog & 0x1 || nb_check_validlog == 0) {
                                        sp->rank = (nrecmema >> 8) & RANK_MASK;
                                        sp->bank = (nrecmema >> 12) & BANK_MASK;
                                        sp->cas = (nrecmemb >> 16) & CAS_MASK;
                                        sp->ras = nrecmemb & RAS_MASK;
                                }
                        } else {
                                recmema = rp->nb.nf_mem_regs.recmema;
                                recmemb = rp->nb.nf_mem_regs.recmemb;
                                /* check if the recmem log is valid */
                                if (validlog & 0x2 || nb_check_validlog == 0) {
                                        sp->rank = (recmema >> 8) & RANK_MASK;
                                        sp->bank = (recmema >> 12) & BANK_MASK;
                                        sp->cas = (recmemb >> 16) & CAS_MASK;
                                        sp->ras = recmemb & RAS_MASK;
                                }
                        }
                        intr = "nb.ddr2_mem_ue";
                } else if ((ferr_nf_mem & ERR_NF_MEM_ECC_CE) != 0) {
                        /* correctable ECC M14-M16 */
                        recmema = rp->nb.nf_mem_regs.recmema;
                        recmemb = rp->nb.nf_mem_regs.recmemb;
                        validlog = rp->nb.nf_mem_regs.validlog;
                        /* check if the recmem log is valid */
                        if (validlog & 0x2 || nb_check_validlog == 0) {
                                sp->channel = channel;
                                sp->rank = (recmema >> 8) & RANK_MASK;
                                sp->dimm = nb_rank2dimm(sp->channel, sp->rank);
                                sp->bank = (recmema >> 12) & BANK_MASK;
                                sp->cas = (recmemb >> 16) & CAS_MASK;
                                sp->ras = recmemb & RAS_MASK;
                        }
                        intr = "nb.ddr2_mem_ce";
                } else if ((ferr_nf_mem & ERR_NF_MEM_SPARE) != 0) {
                        /* spare dimm M20, M21 */
                        intr = "nb.ddr2_mem_ds";

                        /*
                         * The channel can be valid here.
                         * However, there is only one channel per branch and
                         * to leverage the eversolt rules of other chipsets,
                         * the channel is ignored and let the rule find it out
                         * from the topology.
                         */
                        if (rp->nb.nf_mem_regs.spcps & SPCPS_SPARE_DEPLOYED) {
                                sp->rank =
                                    SPCPS_FAILED_RANK(rp->nb.nf_mem_regs.spcps);
                                nb_used_spare_rank(sp->branch, sp->rank);
                                nb_config_gen++;
                        }
                } else if ((ferr_nf_mem & ERR_NF_MEM_M18) != 0) {
                        sp->channel = channel;
                        intr = "nb.ddr2_spd";   /* SPD protocol */

                }
        }
        if (sp->ras != -1) {
                /*
                 * If driver was built with closed tree present then we will
                 * have Intel proprietary code for finding physaddr
                 */
                if (&dimm_getphys) {
                        sp->pa = dimm_getphys((uint16_t)sp->branch,
                            (uint16_t)sp->rank, (uint64_t)sp->bank,
                            (uint64_t)sp->ras, (uint64_t)sp->cas);
                        if (sp->pa >= MAXPHYS_ADDR)
                                sp->pa = -1ULL;
                } else {
                        sp->pa = -1ULL;
                }
                if (&dimm_getoffset) {
                        sp->offset = dimm_getoffset(sp->branch, sp->rank,
                            sp->bank, sp->ras, sp->cas);
                } else {
                        sp->offset = TCODE_OFFSET(sp->rank, sp->bank, sp->ras,
                            sp->cas);
                }
        }
        return (intr);
}

static struct mch_error_code fat_int_error_code[] = {
        { 14, EMASK_INT_B14, ERR_FAT_INT_B14 },
        { 12, EMASK_INT_B12, ERR_FAT_INT_B12 },
        { 25, EMASK_INT_B25, ERR_FAT_INT_B25 },
        { 23, EMASK_INT_B23, ERR_FAT_INT_B23 },
        { 21, EMASK_INT_B21, ERR_FAT_INT_B21 },
        { 7, EMASK_INT_B7, ERR_FAT_INT_B7 },
        { 4, EMASK_INT_B4, ERR_FAT_INT_B4 },
        { 3, EMASK_INT_B3, ERR_FAT_INT_B3 },
        { 2, EMASK_INT_B2, ERR_FAT_INT_B2 },
        { 1, EMASK_INT_B1, ERR_FAT_INT_B1 }
};

static struct mch_error_code nf_int_error_code[] = {
        { 27, 0, ERR_NF_INT_B27 },
        { 24, 0, ERR_NF_INT_B24 },
        { 22, EMASK_INT_B22, ERR_NF_INT_B22 },
        { 20, EMASK_INT_B20, ERR_NF_INT_B20 },
        { 19, EMASK_INT_B19, ERR_NF_INT_B19 },
        { 18, 0, ERR_NF_INT_B18 },
        { 17, 0, ERR_NF_INT_B17 },
        { 16, 0, ERR_NF_INT_B16 },
        { 11, EMASK_INT_B11, ERR_NF_INT_B11 },
        { 10, EMASK_INT_B10, ERR_NF_INT_B10 },
        { 9, EMASK_INT_B9, ERR_NF_INT_B9 },
        { 8, EMASK_INT_B8, ERR_NF_INT_B8 },
        { 6, EMASK_INT_B6, ERR_NF_INT_B6 },
        { 5, EMASK_INT_B5, ERR_NF_INT_B5 }
};

static int
intel_int_err(uint16_t err_fat_int, uint16_t err_nf_int)
{
        int rt = -1;
        int nerr = 0;
        uint32_t emask_int = 0;
        int i;
        int sz;

        sz = sizeof (fat_int_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (err_fat_int & fat_int_error_code[i].error_bit) {
                        rt = fat_int_error_code[i].intel_error_list;
                        emask_int |= fat_int_error_code[i].emask;
                        nerr++;
                }
        }

        if (nb_chipset == INTEL_NB_5400 &&
            (err_nf_int & NERR_NF_5400_INT_B26) != 0) {
                err_nf_int &= ~NERR_NF_5400_INT_B26;
                rt = 26;
                nerr++;
        }

        if (rt)
                err_nf_int &= ~ERR_NF_INT_B18;

        sz = sizeof (nf_int_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (err_nf_int & nf_int_error_code[i].error_bit) {
                        rt = nf_int_error_code[i].intel_error_list;
                        emask_int |= nf_int_error_code[i].emask;
                        nerr++;
                }
        }

        if (emask_int)
                nb_int_mask_mc(emask_int);
        if (nerr > 1)
                rt = -1;
        return (rt);
}

static int
log_int_err(nb_regs_t *rp, int willpanic, int *interpose)
{
        int t = 0;
        int rt = 0;

        rp->flag = NB_REG_LOG_INT;
        rp->nb.int_regs.ferr_fat_int = FERR_FAT_INT_RD(interpose);
        rp->nb.int_regs.ferr_nf_int = FERR_NF_INT_RD(&t);
        *interpose |= t;
        rp->nb.int_regs.nerr_fat_int = NERR_FAT_INT_RD(&t);
        *interpose |= t;
        rp->nb.int_regs.nerr_nf_int = NERR_NF_INT_RD(&t);
        *interpose |= t;
        rp->nb.int_regs.nrecint = NRECINT_RD();
        rp->nb.int_regs.recint = RECINT_RD();
        rp->nb.int_regs.nrecsf = NRECSF_RD();
        rp->nb.int_regs.recsf = RECSF_RD();

        if (!willpanic) {
                if (rp->nb.int_regs.ferr_fat_int || *interpose)
                        FERR_FAT_INT_WR(rp->nb.int_regs.ferr_fat_int);
                if (rp->nb.int_regs.ferr_nf_int || *interpose)
                        FERR_NF_INT_WR(rp->nb.int_regs.ferr_nf_int);
                if (rp->nb.int_regs.nerr_fat_int)
                        NERR_FAT_INT_WR(rp->nb.int_regs.nerr_fat_int);
                if (rp->nb.int_regs.nerr_nf_int)
                        NERR_NF_INT_WR(rp->nb.int_regs.nerr_nf_int);
                /*
                 * if interpose write read-only registers to clear from pcii
                 * cache
                 */
                if (*interpose) {
                        NRECINT_WR();
                        RECINT_WR();
                        NRECSF_WR();
                        RECSF_WR();
                }
        }
        if (rp->nb.int_regs.ferr_fat_int == 0 &&
            rp->nb.int_regs.nerr_fat_int == 0 &&
            (rp->nb.int_regs.ferr_nf_int == ERR_NF_INT_B18 ||
            (rp->nb.int_regs.ferr_nf_int == 0 &&
            rp->nb.int_regs.nerr_nf_int == ERR_NF_INT_B18))) {
                rt = 1;
        }
        return (rt);
}

static void
log_thermal_err(nb_regs_t *rp, int willpanic, int *interpose)
{
        int t = 0;

        rp->flag = NB_REG_LOG_THR;
        rp->nb.thr_regs.ferr_fat_thr = FERR_FAT_THR_RD(interpose);
        rp->nb.thr_regs.nerr_fat_thr = NERR_FAT_THR_RD(&t);
        *interpose |= t;
        rp->nb.thr_regs.ferr_nf_thr = FERR_NF_THR_RD(&t);
        *interpose |= t;
        rp->nb.thr_regs.nerr_nf_thr = NERR_NF_THR_RD(&t);
        *interpose |= t;
        rp->nb.thr_regs.ctsts = CTSTS_RD();
        rp->nb.thr_regs.thrtsts = THRTSTS_RD();

        if (!willpanic) {
                if (rp->nb.thr_regs.ferr_fat_thr || *interpose)
                        FERR_FAT_THR_WR(rp->nb.thr_regs.ferr_fat_thr);
                if (rp->nb.thr_regs.nerr_fat_thr || *interpose)
                        NERR_FAT_THR_WR(rp->nb.thr_regs.nerr_fat_thr);
                if (rp->nb.thr_regs.ferr_nf_thr || *interpose)
                        FERR_NF_THR_WR(rp->nb.thr_regs.ferr_nf_thr);
                if (rp->nb.thr_regs.nerr_nf_thr || *interpose)
                        NERR_NF_THR_WR(rp->nb.thr_regs.nerr_nf_thr);

                if (*interpose) {
                        CTSTS_WR(rp->nb.thr_regs.ctsts);
                        THRTSTS_WR(rp->nb.thr_regs.thrtsts);
                }
        }
}

static void
log_dma_err(nb_regs_t *rp, int *interpose)
{
        rp->flag = NB_REG_LOG_DMA;

        rp->nb.dma_regs.pcists = PCISTS_RD(interpose);
        rp->nb.dma_regs.pexdevsts = PCIDEVSTS_RD();
}

static struct mch_error_code fat_fsb_error_code[] = {
        { 9, EMASK_FSB_F9, ERR_FAT_FSB_F9 },
        { 2, EMASK_FSB_F2, ERR_FAT_FSB_F2 },
        { 1, EMASK_FSB_F1, ERR_FAT_FSB_F1 }
};

static struct mch_error_code nf_fsb_error_code[] = {
        { 8, EMASK_FSB_F8, ERR_NF_FSB_F8 },
        { 7, EMASK_FSB_F7, ERR_NF_FSB_F7 },
        { 6, EMASK_FSB_F6, ERR_NF_FSB_F6 }
};

static int
intel_fsb_err(int fsb, uint8_t err_fat_fsb, uint8_t err_nf_fsb)
{
        int rt = -1;
        int nerr = 0;
        uint16_t emask_fsb = 0;
        int i;
        int sz;

        sz = sizeof (fat_fsb_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (err_fat_fsb & fat_fsb_error_code[i].error_bit) {
                        rt = fat_fsb_error_code[i].intel_error_list;
                        emask_fsb |= fat_fsb_error_code[i].emask;
                        nerr++;
                }
        }

        sz = sizeof (nf_fsb_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (err_nf_fsb & nf_fsb_error_code[i].error_bit) {
                        rt = nf_fsb_error_code[i].intel_error_list;
                        emask_fsb |= nf_fsb_error_code[i].emask;
                        nerr++;
                }
        }

        if (emask_fsb)
                nb_fsb_mask_mc(fsb, emask_fsb);
        if (nerr > 1)
                rt = -1;
        return (rt);
}

static void
log_fsb_err(uint64_t ferr, nb_regs_t *rp, int willpanic, int *interpose)
{
        uint8_t fsb;
        int t = 0;

        fsb = GE_FERR_FSB(ferr);
        rp->flag = NB_REG_LOG_FSB;

        rp->nb.fsb_regs.fsb = fsb;
        rp->nb.fsb_regs.ferr_fat_fsb = FERR_FAT_FSB_RD(fsb, interpose);
        rp->nb.fsb_regs.ferr_nf_fsb = FERR_NF_FSB_RD(fsb, &t);
        *interpose |= t;
        rp->nb.fsb_regs.nerr_fat_fsb = NERR_FAT_FSB_RD(fsb, &t);
        *interpose |= t;
        rp->nb.fsb_regs.nerr_nf_fsb = NERR_NF_FSB_RD(fsb, &t);
        *interpose |= t;
        rp->nb.fsb_regs.nrecfsb = NRECFSB_RD(fsb);
        rp->nb.fsb_regs.nrecfsb_addr = NRECADDR_RD(fsb);
        rp->nb.fsb_regs.recfsb = RECFSB_RD(fsb);
        if (!willpanic) {
                /* Clear the fatal/non-fatal first/next FSB errors */
                if (rp->nb.fsb_regs.ferr_fat_fsb || *interpose)
                        FERR_FAT_FSB_WR(fsb, rp->nb.fsb_regs.ferr_fat_fsb);
                if (rp->nb.fsb_regs.ferr_nf_fsb || *interpose)
                        FERR_NF_FSB_WR(fsb, rp->nb.fsb_regs.ferr_nf_fsb);
                if (rp->nb.fsb_regs.nerr_fat_fsb || *interpose)
                        NERR_FAT_FSB_WR(fsb, rp->nb.fsb_regs.nerr_fat_fsb);
                if (rp->nb.fsb_regs.nerr_nf_fsb || *interpose)
                        NERR_NF_FSB_WR(fsb, rp->nb.fsb_regs.nerr_nf_fsb);

                /*
                 * if interpose write read-only registers to clear from pcii
                 * cache
                 */
                if (*interpose) {
                        NRECFSB_WR(fsb);
                        NRECADDR_WR(fsb);
                        RECFSB_WR(fsb);
                }
        }
}

static struct mch_error_code fat_pex_error_code[] = {
        { 19, EMASK_UNCOR_PEX_IO19, PEX_FAT_IO19 },
        { 18, EMASK_UNCOR_PEX_IO18, PEX_FAT_IO18 },
        { 10, EMASK_UNCOR_PEX_IO10, PEX_FAT_IO10 },
        { 9, EMASK_UNCOR_PEX_IO9, PEX_FAT_IO9 },
        { 8, EMASK_UNCOR_PEX_IO8, PEX_FAT_IO8 },
        { 7, EMASK_UNCOR_PEX_IO7, PEX_FAT_IO7 },
        { 6, EMASK_UNCOR_PEX_IO6, PEX_FAT_IO6 },
        { 5, EMASK_UNCOR_PEX_IO5, PEX_FAT_IO5 },
        { 4, EMASK_UNCOR_PEX_IO4, PEX_FAT_IO4 },
        { 3, EMASK_UNCOR_PEX_IO3, PEX_FAT_IO3 },
        { 2, EMASK_UNCOR_PEX_IO2, PEX_FAT_IO2 },
        { 0, EMASK_UNCOR_PEX_IO0, PEX_FAT_IO0 }
};

static struct mch_error_code fat_unit_pex_5400_error_code[] = {
        { 32, EMASK_UNIT_PEX_IO32, PEX_5400_FAT_IO32 },
        { 31, EMASK_UNIT_PEX_IO31, PEX_5400_FAT_IO31 },
        { 30, EMASK_UNIT_PEX_IO30, PEX_5400_FAT_IO30 },
        { 29, EMASK_UNIT_PEX_IO29, PEX_5400_FAT_IO29 },
        { 27, EMASK_UNIT_PEX_IO27, PEX_5400_FAT_IO27 },
        { 26, EMASK_UNIT_PEX_IO26, PEX_5400_FAT_IO26 },
        { 25, EMASK_UNIT_PEX_IO25, PEX_5400_FAT_IO25 },
        { 24, EMASK_UNIT_PEX_IO24, PEX_5400_FAT_IO24 },
        { 23, EMASK_UNIT_PEX_IO23, PEX_5400_FAT_IO23 },
        { 22, EMASK_UNIT_PEX_IO22, PEX_5400_FAT_IO22 },
};

static struct mch_error_code fat_pex_5400_error_code[] = {
        { 19, EMASK_UNCOR_PEX_IO19, PEX_5400_FAT_IO19 },
        { 18, EMASK_UNCOR_PEX_IO18, PEX_5400_FAT_IO18 },
        { 10, EMASK_UNCOR_PEX_IO10, PEX_5400_FAT_IO10 },
        { 9, EMASK_UNCOR_PEX_IO9, PEX_5400_FAT_IO9 },
        { 8, EMASK_UNCOR_PEX_IO8, PEX_5400_FAT_IO8 },
        { 7, EMASK_UNCOR_PEX_IO7, PEX_5400_FAT_IO7 },
        { 6, EMASK_UNCOR_PEX_IO6, PEX_5400_FAT_IO6 },
        { 5, EMASK_UNCOR_PEX_IO5, PEX_5400_FAT_IO5 },
        { 4, EMASK_UNCOR_PEX_IO4, PEX_5400_FAT_IO4 },
        { 2, EMASK_UNCOR_PEX_IO2, PEX_5400_FAT_IO2 },
        { 0, EMASK_UNCOR_PEX_IO0, PEX_5400_FAT_IO0 }
};

static struct mch_error_code fat_rp_5400_error_code[] = {
        { 1, EMASK_RP_PEX_IO1, PEX_5400_FAT_IO1 }
};

static struct mch_error_code fat_rp_error_code[] = {
        { 1, EMASK_RP_PEX_IO1, PEX_FAT_IO1 }
};

static struct mch_error_code uncor_pex_error_code[] = {
        { 19, EMASK_UNCOR_PEX_IO19, PEX_NF_IO19 },
        { 9, EMASK_UNCOR_PEX_IO9, PEX_NF_IO9 },
        { 8, EMASK_UNCOR_PEX_IO8, PEX_NF_IO8 },
        { 7, EMASK_UNCOR_PEX_IO7, PEX_NF_IO7 },
        { 6, EMASK_UNCOR_PEX_IO6, PEX_NF_IO6 },
        { 5, EMASK_UNCOR_PEX_IO5, PEX_NF_IO5 },
        { 4, EMASK_UNCOR_PEX_IO4, PEX_NF_IO4 },
        { 3, EMASK_UNCOR_PEX_IO3, PEX_NF_IO3 },
        { 0, EMASK_UNCOR_PEX_IO0, PEX_NF_IO0 }
};

static struct mch_error_code uncor_pex_5400_error_code[] = {
        { 33, EMASK_UNIT_PEX_IO33, PEX_5400_NF_IO33 },
        { 32, EMASK_UNIT_PEX_IO32, PEX_5400_NF_IO32 },
        { 31, EMASK_UNIT_PEX_IO31, PEX_5400_NF_IO31 },
        { 30, EMASK_UNIT_PEX_IO30, PEX_5400_NF_IO30 },
        { 29, EMASK_UNIT_PEX_IO29, PEX_5400_NF_IO29 },
        { 28, EMASK_UNIT_PEX_IO28, PEX_5400_NF_IO28 },
        { 27, EMASK_UNIT_PEX_IO27, PEX_5400_NF_IO27 },
        { 26, EMASK_UNIT_PEX_IO26, PEX_5400_NF_IO26 },
        { 25, EMASK_UNIT_PEX_IO25, PEX_5400_NF_IO25 },
        { 24, EMASK_UNIT_PEX_IO24, PEX_5400_NF_IO24 },
        { 23, EMASK_UNIT_PEX_IO23, PEX_5400_NF_IO23 },
};

static struct mch_error_code cor_pex_error_code[] = {
        { 20, EMASK_COR_PEX_IO20, PEX_5400_NF_IO20 },
        { 16, EMASK_COR_PEX_IO16, PEX_NF_IO16 },
        { 15, EMASK_COR_PEX_IO15, PEX_NF_IO15 },
        { 14, EMASK_COR_PEX_IO14, PEX_NF_IO14 },
        { 13, EMASK_COR_PEX_IO13, PEX_NF_IO13 },
        { 12, EMASK_COR_PEX_IO12, PEX_NF_IO12 },
        { 10, 0, PEX_NF_IO10 },
        { 2, 0, PEX_NF_IO2 }
};

static struct mch_error_code rp_pex_5400_error_code[] = {
        { 17, EMASK_RP_PEX_IO17, PEX_5400_NF_IO17 },
        { 11, EMASK_RP_PEX_IO11, PEX_5400_NF_IO11 }
};

static struct mch_error_code cor_pex_5400_error_code1[] = {
        { 19, EMASK_UNCOR_PEX_IO19, PEX_5400_NF_IO19 },
        { 10, EMASK_UNCOR_PEX_IO10, PEX_5400_NF_IO10 },
        { 9, EMASK_UNCOR_PEX_IO9, PEX_5400_NF_IO9 },
        { 8, EMASK_UNCOR_PEX_IO8, PEX_5400_NF_IO8 },
        { 7, EMASK_UNCOR_PEX_IO7, PEX_5400_NF_IO7 },
        { 6, EMASK_UNCOR_PEX_IO6, PEX_5400_NF_IO6 },
        { 5, EMASK_UNCOR_PEX_IO5, PEX_5400_NF_IO5 },
        { 4, EMASK_UNCOR_PEX_IO4, PEX_5400_NF_IO4 },
        { 2, EMASK_UNCOR_PEX_IO2, PEX_5400_NF_IO2 },
        { 0, EMASK_UNCOR_PEX_IO0, PEX_5400_NF_IO0 }
};

static struct mch_error_code cor_pex_5400_error_code2[] = {
        { 20, EMASK_COR_PEX_IO20, PEX_5400_NF_IO20 },
        { 16, EMASK_COR_PEX_IO16, PEX_5400_NF_IO16 },
        { 15, EMASK_COR_PEX_IO15, PEX_5400_NF_IO15 },
        { 14, EMASK_COR_PEX_IO14, PEX_5400_NF_IO14 },
        { 13, EMASK_COR_PEX_IO13, PEX_5400_NF_IO13 },
        { 12, EMASK_COR_PEX_IO12, PEX_5400_NF_IO12 }
};

static struct mch_error_code cor_pex_5400_error_code3[] = {
        { 33, EMASK_UNIT_PEX_IO33, PEX_5400_NF_IO33 },
        { 32, EMASK_UNIT_PEX_IO32, PEX_5400_NF_IO32 },
        { 31, EMASK_UNIT_PEX_IO31, PEX_5400_NF_IO31 },
        { 30, EMASK_UNIT_PEX_IO30, PEX_5400_NF_IO30 },
        { 29, EMASK_UNIT_PEX_IO29, PEX_5400_NF_IO29 },
        { 28, EMASK_UNIT_PEX_IO28, PEX_5400_NF_IO28 },
        { 27, EMASK_UNIT_PEX_IO27, PEX_5400_NF_IO27 },
        { 26, EMASK_UNIT_PEX_IO26, PEX_5400_NF_IO26 },
        { 25, EMASK_UNIT_PEX_IO25, PEX_5400_NF_IO25 },
        { 24, EMASK_UNIT_PEX_IO24, PEX_5400_NF_IO24 },
        { 23, EMASK_UNIT_PEX_IO23, PEX_5400_NF_IO23 }
};

static struct mch_error_code rp_pex_error_code[] = {
        { 17, EMASK_RP_PEX_IO17, PEX_NF_IO17 },
        { 11, EMASK_RP_PEX_IO11, PEX_NF_IO11 },
};

static int
intel_pex_err(uint32_t pex_fat, uint32_t pex_nf_cor)
{
        int rt = -1;
        int nerr = 0;
        int i;
        int sz;

        sz = sizeof (fat_pex_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_fat & fat_pex_error_code[i].error_bit) {
                        rt = fat_pex_error_code[i].intel_error_list;
                        nerr++;
                }
        }
        sz = sizeof (fat_rp_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_fat & fat_rp_error_code[i].error_bit) {
                        rt = fat_rp_error_code[i].intel_error_list;
                        nerr++;
                }
        }
        sz = sizeof (uncor_pex_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_nf_cor & uncor_pex_error_code[i].error_bit) {
                        rt = uncor_pex_error_code[i].intel_error_list;
                        nerr++;
                }
        }

        sz = sizeof (cor_pex_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_nf_cor & cor_pex_error_code[i].error_bit) {
                        rt = cor_pex_error_code[i].intel_error_list;
                        nerr++;
                }
        }
        sz = sizeof (rp_pex_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_nf_cor & rp_pex_error_code[i].error_bit) {
                        rt = rp_pex_error_code[i].intel_error_list;
                        nerr++;
                }
        }

        if (nerr > 1)
                rt = -1;
        return (rt);
}

static struct mch_error_code fat_thr_error_code[] = {
        { 2, EMASK_THR_F2, ERR_FAT_THR_F2 },
        { 1, EMASK_THR_F1, ERR_FAT_THR_F1 }
};

static struct mch_error_code nf_thr_error_code[] = {
        { 5, EMASK_THR_F5, ERR_NF_THR_F5 },
        { 4, EMASK_THR_F4, ERR_NF_THR_F4 },
        { 3, EMASK_THR_F3, ERR_NF_THR_F3 }
};

static int
intel_thr_err(uint8_t err_fat_thr, uint8_t err_nf_thr)
{
        int rt = -1;
        int nerr = 0;
        uint16_t emask_thr = 0;
        int i;
        int sz;

        sz = sizeof (fat_thr_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (err_fat_thr & fat_thr_error_code[i].error_bit) {
                        rt = fat_thr_error_code[i].intel_error_list;
                        emask_thr |= fat_thr_error_code[i].emask;
                        nerr++;
                }
        }

        sz = sizeof (nf_thr_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (err_nf_thr & nf_thr_error_code[i].error_bit) {
                        rt = nf_thr_error_code[i].intel_error_list;
                        emask_thr |= nf_thr_error_code[i].emask;
                        nerr++;
                }
        }

        if (emask_thr)
                nb_thr_mask_mc(emask_thr);
        if (nerr > 1)
                rt = -1;
        return (rt);
}

static int
intel_pex_5400_err(uint32_t pex_fat, uint32_t pex_nf_cor)
{
        int rt = -1;
        int nerr = 0;
        int i;
        int sz;

        sz = sizeof (fat_pex_5400_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_fat & fat_pex_5400_error_code[i].error_bit) {
                        rt = fat_pex_5400_error_code[i].intel_error_list;
                        nerr++;
                }
        }
        sz = sizeof (fat_rp_5400_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_fat & fat_rp_5400_error_code[i].error_bit) {
                        rt = fat_rp_5400_error_code[i].intel_error_list;
                        nerr++;
                }
        }
        sz = sizeof (fat_unit_pex_5400_error_code) /
            sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_fat &
                    fat_unit_pex_5400_error_code[i].error_bit) {
                        rt = fat_unit_pex_5400_error_code[i].intel_error_list;
                        nerr++;
                }
        }
        sz = sizeof (uncor_pex_5400_error_code) /
            sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_fat & uncor_pex_5400_error_code[i].error_bit) {
                        rt = uncor_pex_5400_error_code[i].intel_error_list;
                        nerr++;
                }
        }

        sz = sizeof (rp_pex_5400_error_code) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_nf_cor & rp_pex_5400_error_code[i].error_bit) {
                        rt = rp_pex_5400_error_code[i].intel_error_list;
                        nerr++;
                }
        }

        sz = sizeof (cor_pex_5400_error_code1) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_nf_cor & cor_pex_5400_error_code1[i].error_bit) {
                        rt = cor_pex_5400_error_code1[i].intel_error_list;
                        nerr++;
                }
        }

        sz = sizeof (cor_pex_5400_error_code2) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_nf_cor & cor_pex_5400_error_code2[i].error_bit) {
                        rt = cor_pex_5400_error_code2[i].intel_error_list;
                        nerr++;
                }
        }

        sz = sizeof (cor_pex_5400_error_code3) / sizeof (struct mch_error_code);

        for (i = 0; i < sz; i++) {
                if (pex_nf_cor & cor_pex_5400_error_code3[i].error_bit) {
                        rt = cor_pex_5400_error_code3[i].intel_error_list;
                        nerr++;
                }
        }

        if (nerr > 1)
                rt = -1;
        return (rt);
}

static int
log_pex_err(uint64_t ferr, nb_regs_t *rp, int willpanic, int *interpose)
{
        uint8_t pex = (uint8_t)-1;
        int t = 0;

        rp->flag = NB_REG_LOG_PEX;
        pex = GE_ERR_PEX(ferr);

        rp->nb.pex_regs.pex = pex;
        rp->nb.pex_regs.pex_fat_ferr =  PEX_FAT_FERR_RD(pex, interpose);
        rp->nb.pex_regs.pex_fat_nerr = PEX_FAT_NERR_RD(pex, &t);
        *interpose |= t;
        rp->nb.pex_regs.pex_nf_corr_ferr = PEX_NF_FERR_RD(pex, &t);
        *interpose |= t;
        rp->nb.pex_regs.pex_nf_corr_nerr = PEX_NF_NERR_RD(pex, &t);
        *interpose |= t;
        if (rp->nb.pex_regs.pex_fat_ferr == 0 &&
            rp->nb.pex_regs.pex_fat_nerr == 0 &&
            rp->nb.pex_regs.pex_nf_corr_ferr == 0 &&
            rp->nb.pex_regs.pex_nf_corr_nerr == 0)
                return (0);
        rp->nb.pex_regs.uncerrsev = UNCERRSEV_RD(pex);
        rp->nb.pex_regs.rperrsts = RPERRSTS_RD(pex);
        rp->nb.pex_regs.rperrsid = RPERRSID_RD(pex);
        if (pex != (uint8_t)-1)
                rp->nb.pex_regs.uncerrsts = UNCERRSTS_RD(pex);
        else
                rp->nb.pex_regs.uncerrsts = 0;
        rp->nb.pex_regs.aerrcapctrl = AERRCAPCTRL_RD(pex);
        rp->nb.pex_regs.corerrsts = CORERRSTS_RD(pex);
        rp->nb.pex_regs.pexdevsts = PEXDEVSTS_RD(pex);

        if (!willpanic) {
                if (rp->nb.pex_regs.pex_fat_ferr || *interpose)
                        PEX_FAT_FERR_WR(pex, rp->nb.pex_regs.pex_fat_ferr);
                if (rp->nb.pex_regs.pex_fat_nerr)
                        PEX_FAT_NERR_WR(pex, rp->nb.pex_regs.pex_fat_nerr);
                if (rp->nb.pex_regs.pex_nf_corr_ferr || *interpose)
                        PEX_NF_FERR_WR(pex, rp->nb.pex_regs.pex_nf_corr_ferr);
                if (rp->nb.pex_regs.pex_nf_corr_nerr)
                        PEX_NF_NERR_WR(pex, rp->nb.pex_regs.pex_nf_corr_nerr);
                if (*interpose)
                        UNCERRSTS_WR(pex, rp->nb.pex_regs.uncerrsts);
                if (*interpose)
                        RPERRSTS_WR(pex, rp->nb.pex_regs.rperrsts);
                if (*interpose)
                        PEXDEVSTS_WR(pex, 0);
        }
        return (1);
}

static void
log_fat_fbd_err(nb_regs_t *rp, int willpanic, int *interpose)
{
        int channel, branch;
        int t = 0;

        rp->flag = NB_REG_LOG_FAT_FBD;
        rp->nb.fat_fbd_regs.ferr_fat_fbd = FERR_FAT_FBD_RD(interpose);
        channel = (rp->nb.fat_fbd_regs.ferr_fat_fbd >> 28) & 3;
        branch = channel >> 1;
        rp->nb.fat_fbd_regs.nerr_fat_fbd = NERR_FAT_FBD_RD(&t);
        *interpose |= t;
        rp->nb.fat_fbd_regs.nrecmema = NRECMEMA_RD(branch);
        rp->nb.fat_fbd_regs.nrecmemb = NRECMEMB_RD(branch);
        rp->nb.fat_fbd_regs.nrecfglog = NRECFGLOG_RD(branch);
        rp->nb.fat_fbd_regs.nrecfbda = NRECFBDA_RD(branch);
        rp->nb.fat_fbd_regs.nrecfbdb = NRECFBDB_RD(branch);
        rp->nb.fat_fbd_regs.nrecfbdc = NRECFBDC_RD(branch);
        rp->nb.fat_fbd_regs.nrecfbdd = NRECFBDD_RD(branch);
        rp->nb.fat_fbd_regs.nrecfbde = NRECFBDE_RD(branch);
        rp->nb.fat_fbd_regs.nrecfbdf = NRECFBDF_RD(branch);
        rp->nb.fat_fbd_regs.spcps = SPCPS_RD(branch);
        rp->nb.fat_fbd_regs.spcpc = SPCPC_RD(branch);
        rp->nb.fat_fbd_regs.uerrcnt = UERRCNT_RD(branch);
        rp->nb.fat_fbd_regs.uerrcnt_last = uerrcnt[branch];
        uerrcnt[branch] = rp->nb.fat_fbd_regs.uerrcnt;
        rp->nb.fat_fbd_regs.badrama = BADRAMA_RD(branch);
        rp->nb.fat_fbd_regs.badramb = BADRAMB_RD(branch);
        rp->nb.fat_fbd_regs.badcnt = BADCNT_RD(branch);
        if (!willpanic) {
                if (rp->nb.fat_fbd_regs.ferr_fat_fbd || *interpose)
                        FERR_FAT_FBD_WR(rp->nb.fat_fbd_regs.ferr_fat_fbd);
                if (rp->nb.fat_fbd_regs.nerr_fat_fbd)
                        NERR_FAT_FBD_WR(rp->nb.fat_fbd_regs.nerr_fat_fbd);
                /*
                 * if interpose write read-only registers to clear from pcii
                 * cache
                 */
                if (*interpose) {
                        NRECMEMA_WR(branch);
                        NRECMEMB_WR(branch);
                        NRECFGLOG_WR(branch);
                        NRECFBDA_WR(branch);
                        NRECFBDB_WR(branch);
                        NRECFBDC_WR(branch);
                        NRECFBDD_WR(branch);
                        NRECFBDE_WR(branch);
                        NRECFBDF_WR(branch);
                }
        }
}

static void
log_nf_fbd_err(nb_regs_t *rp, int willpanic, int *interpose)
{
        int channel, branch;
        int t = 0;

        rp->flag = NB_REG_LOG_NF_FBD;
        rp->nb.nf_fbd_regs.ferr_nf_fbd = FERR_NF_FBD_RD(interpose);
        channel = (rp->nb.nf_fbd_regs.ferr_nf_fbd >> 28) & 3;
        branch = channel >> 1;
        rp->nb.nf_fbd_regs.nerr_nf_fbd = NERR_NF_FBD_RD(&t);
        *interpose |= t;
        rp->nb.nf_fbd_regs.redmemb = REDMEMB_RD();
        rp->nb.nf_fbd_regs.recmema = RECMEMA_RD(branch);
        rp->nb.nf_fbd_regs.recmemb = RECMEMB_RD(branch);
        rp->nb.nf_fbd_regs.recfglog = RECFGLOG_RD(branch);
        rp->nb.nf_fbd_regs.recfbda = RECFBDA_RD(branch);
        rp->nb.nf_fbd_regs.recfbdb = RECFBDB_RD(branch);
        rp->nb.nf_fbd_regs.recfbdc = RECFBDC_RD(branch);
        rp->nb.nf_fbd_regs.recfbdd = RECFBDD_RD(branch);
        rp->nb.nf_fbd_regs.recfbde = RECFBDE_RD(branch);
        rp->nb.nf_fbd_regs.recfbdf = RECFBDF_RD(branch);
        rp->nb.nf_fbd_regs.spcps = SPCPS_RD(branch);
        rp->nb.nf_fbd_regs.spcpc = SPCPC_RD(branch);
        if (nb_chipset == INTEL_NB_7300 || nb_chipset == INTEL_NB_5400) {
                rp->nb.nf_fbd_regs.cerrcnta = CERRCNTA_RD(branch, channel);
                rp->nb.nf_fbd_regs.cerrcntb = CERRCNTB_RD(branch, channel);
                rp->nb.nf_fbd_regs.cerrcntc = CERRCNTC_RD(branch, channel);
                rp->nb.nf_fbd_regs.cerrcntd = CERRCNTD_RD(branch, channel);
        } else {
                rp->nb.nf_fbd_regs.cerrcnta = CERRCNT_RD(branch);
                rp->nb.nf_fbd_regs.cerrcntb = 0;
                rp->nb.nf_fbd_regs.cerrcntc = 0;
                rp->nb.nf_fbd_regs.cerrcntd = 0;
        }
        rp->nb.nf_fbd_regs.cerrcnta_last = cerrcnta[branch][channel & 1];
        rp->nb.nf_fbd_regs.cerrcntb_last = cerrcntb[branch][channel & 1];
        rp->nb.nf_fbd_regs.cerrcntc_last = cerrcntc[branch][channel & 1];
        rp->nb.nf_fbd_regs.cerrcntd_last = cerrcntd[branch][channel & 1];
        cerrcnta[branch][channel & 1] = rp->nb.nf_fbd_regs.cerrcnta;
        cerrcntb[branch][channel & 1] = rp->nb.nf_fbd_regs.cerrcntb;
        cerrcntc[branch][channel & 1] = rp->nb.nf_fbd_regs.cerrcntc;
        cerrcntd[branch][channel & 1] = rp->nb.nf_fbd_regs.cerrcntd;
        rp->nb.nf_fbd_regs.badrama = BADRAMA_RD(branch);
        rp->nb.nf_fbd_regs.badramb = BADRAMB_RD(branch);
        rp->nb.nf_fbd_regs.badcnt = BADCNT_RD(branch);
        if (!willpanic) {
                if (rp->nb.nf_fbd_regs.ferr_nf_fbd || *interpose)
                        FERR_NF_FBD_WR(rp->nb.nf_fbd_regs.ferr_nf_fbd);
                if (rp->nb.nf_fbd_regs.nerr_nf_fbd)
                        NERR_NF_FBD_WR(rp->nb.nf_fbd_regs.nerr_nf_fbd);
                /*
                 * if interpose write read-only registers to clear from pcii
                 * cache
                 */
                if (*interpose) {
                        RECMEMA_WR(branch);
                        RECMEMB_WR(branch);
                        RECFGLOG_WR(branch);
                        RECFBDA_WR(branch);
                        RECFBDB_WR(branch);
                        RECFBDC_WR(branch);
                        RECFBDD_WR(branch);
                        RECFBDE_WR(branch);
                        RECFBDF_WR(branch);
                        SPCPS_WR(branch);
                }
        }
}

static int
log_nf_mem_err(nb_regs_t *rp, int willpanic, int *interpose)
{
        int channel, branch;
        int t = 0;
        int rt = 0;

        rp->flag = NB_REG_LOG_NF_MEM;

        /* Memmory err registers */
        rp->nb.nf_mem_regs.ferr_nf_mem = FERR_NF_MEM_RD(interpose);
        channel = (rp->nb.nf_mem_regs.ferr_nf_mem >> 28) & 0x1;
        branch = channel;
        rp->nb.nf_mem_regs.nerr_nf_mem = NERR_NF_MEM_RD(&t);
        *interpose |= t;
        rp->nb.nf_mem_regs.redmema = MEM_REDMEMA_RD(branch);
        rp->nb.nf_mem_regs.redmemb = MEM_REDMEMB_RD(branch);
        rp->nb.nf_mem_regs.recmema = MEM_RECMEMA_RD(branch);
        rp->nb.nf_mem_regs.recmemb = MEM_RECMEMB_RD(branch);
        rp->nb.nf_mem_regs.nrecmema = MEM_NRECMEMA_RD(branch);
        rp->nb.nf_mem_regs.nrecmemb = MEM_NRECMEMB_RD(branch);

        /* spare rank */
        rp->nb.nf_mem_regs.spcps = SPCPS_RD(branch);
        rp->nb.nf_mem_regs.spcpc = SPCPC_RD(branch);

        /* RAS registers */
        rp->nb.nf_mem_regs.cerrcnt = MEM_CERRCNT_RD(branch);
        rp->nb.nf_mem_regs.cerrcnt_ext = (uint32_t)MEM_CERRCNT_EXT_RD(branch);
        rp->nb.nf_mem_regs.cerrcnt_last = cerrcnta[branch][channel & 1];
        rp->nb.nf_mem_regs.cerrcnt_ext_last = cerrcntb[branch][channel & 1];
        cerrcnta[branch][channel & 1] = rp->nb.nf_mem_regs.cerrcnt;
        cerrcntb[branch][channel & 1] = rp->nb.nf_mem_regs.cerrcnt_ext;
        rp->nb.nf_mem_regs.badram = BADRAMA_RD(branch);
        rp->nb.nf_mem_regs.badcnt = BADCNT_RD(branch);
        rp->nb.nf_mem_regs.validlog = VALIDLOG_RD(branch);

        if (!willpanic) {
                if (rp->nb.nf_mem_regs.ferr_nf_mem || *interpose)
                        FERR_NF_MEM_WR(rp->nb.nf_mem_regs.ferr_nf_mem);
                if (rp->nb.nf_mem_regs.nerr_nf_mem)
                        NERR_NF_MEM_WR(rp->nb.nf_mem_regs.nerr_nf_mem);
                /*
                 * if interpose, write read-only registers to clear from pci
                 * cache
                 */
                if (*interpose) {
                        MEM_NRECMEMA_WR(branch);
                        MEM_NRECMEMB_WR(branch);
                        MEM_REDMEMA_WR(branch);
                        MEM_REDMEMB_WR(branch);
                        MEM_RECMEMA_WR(branch);
                        MEM_RECMEMB_WR(branch);
                        SPCPS_WR(branch);
                }
        }
        if (nb_mode == NB_MEMORY_SINGLE_CHANNEL && channel != 0) {
                /*
                 * In the single channel mode, all dimms are on the channel 0.
                 * Invalidate this error if the channel number is invalid.
                 */
                rt = 1;
        }
        return (rt);
}

static void
log_ferr(uint64_t ferr, uint32_t *nerrp, nb_logout_t *log, int willpanic)
{
        nb_regs_t *rp = &log->nb_regs;
        uint32_t nerr = *nerrp;
        int interpose = 0;
        int spurious = 0;

        log->acl_timestamp = gethrtime_waitfree();
        if ((ferr & (GE_PCIEX_FATAL | GE_PCIEX_NF)) != 0) {
                *nerrp = nerr & ~(GE_PCIEX_FATAL | GE_PCIEX_NF);
                if (log_pex_err(ferr, rp, willpanic, &interpose) == 0)
                        return;
        } else if ((ferr & GE_FBD_FATAL) != 0) {
                log_fat_fbd_err(rp, willpanic, &interpose);
                *nerrp = nerr & ~GE_NERR_FBD_FATAL;
        } else if ((ferr & GE_FBD_NF) != 0) {
                log_nf_fbd_err(rp, willpanic, &interpose);
                *nerrp = nerr & ~GE_NERR_FBD_NF;
        } else if ((ferr & GE_MEM_NF) != 0) {
                spurious = log_nf_mem_err(rp, willpanic, &interpose);
                *nerrp = nerr & ~GE_NERR_MEM_NF;
        } else if ((ferr & (GE_FERR_FSB_FATAL | GE_FERR_FSB_NF)) != 0) {
                log_fsb_err(ferr, rp, willpanic, &interpose);
                *nerrp = nerr & ~(GE_NERR_FSB_FATAL | GE_NERR_FSB_NF);
        } else if ((ferr & (GE_DMA_FATAL | GE_DMA_NF)) != 0) {
                log_dma_err(rp, &interpose);
                *nerrp = nerr & ~(GE_DMA_FATAL | GE_DMA_NF);
        } else if ((ferr & (GE_INT_FATAL | GE_INT_NF)) != 0) {
                spurious = log_int_err(rp, willpanic, &interpose);
                *nerrp = nerr & ~(GE_INT_FATAL | GE_INT_NF);
        } else if (nb_chipset == INTEL_NB_5400 &&
            (ferr & (GE_FERR_THERMAL_FATAL | GE_FERR_THERMAL_NF)) != 0) {
                log_thermal_err(rp, willpanic, &interpose);
                *nerrp = nerr & ~(GE_FERR_THERMAL_FATAL | GE_FERR_THERMAL_NF);
        }
        if (interpose)
                log->type = "inject";
        else
                log->type = "error";
        if (!spurious) {
                errorq_dispatch(nb_queue, log, sizeof (nb_logout_t),
                    willpanic ? ERRORQ_SYNC : ERRORQ_ASYNC);
        }
}

static void
log_nerr(uint32_t *errp, nb_logout_t *log, int willpanic)
{
        uint32_t err;
        nb_regs_t *rp = &log->nb_regs;
        int interpose = 0;
        int spurious = 0;

        err = *errp;
        log->acl_timestamp = gethrtime_waitfree();
        if ((err & (GE_PCIEX_FATAL | GE_PCIEX_NF)) != 0) {
                *errp = err & ~(GE_PCIEX_FATAL | GE_PCIEX_NF);
                if (log_pex_err(err, rp, willpanic, &interpose) == 0)
                        return;
        } else if ((err & GE_NERR_FBD_FATAL) != 0) {
                log_fat_fbd_err(rp, willpanic, &interpose);
                *errp = err & ~GE_NERR_FBD_FATAL;
        } else if ((err & GE_NERR_FBD_NF) != 0) {
                log_nf_fbd_err(rp, willpanic, &interpose);
                *errp = err & ~GE_NERR_FBD_NF;
        } else if ((err & GE_NERR_MEM_NF) != 0) {
                spurious = log_nf_mem_err(rp, willpanic, &interpose);
                *errp = err & ~GE_NERR_MEM_NF;
        } else if ((err & (GE_NERR_FSB_FATAL | GE_NERR_FSB_NF)) != 0) {
                log_fsb_err(GE_NERR_TO_FERR_FSB(err), rp, willpanic,
                    &interpose);
                *errp = err & ~(GE_NERR_FSB_FATAL | GE_NERR_FSB_NF);
        } else if ((err & (GE_DMA_FATAL | GE_DMA_NF)) != 0) {
                log_dma_err(rp, &interpose);
                *errp = err & ~(GE_DMA_FATAL | GE_DMA_NF);
        } else if ((err & (GE_INT_FATAL | GE_INT_NF)) != 0) {
                spurious = log_int_err(rp, willpanic, &interpose);
                *errp = err & ~(GE_INT_FATAL | GE_INT_NF);
        }
        if (interpose)
                log->type = "inject";
        else
                log->type = "error";
        if (!spurious) {
                errorq_dispatch(nb_queue, log, sizeof (nb_logout_t),
                    willpanic ? ERRORQ_SYNC : ERRORQ_ASYNC);
        }
}

/*ARGSUSED*/
void
nb_error_trap(cmi_hdl_t hdl, boolean_t ismc, boolean_t willpanic)
{
        uint64_t ferr;
        uint32_t nerr, err;
        int nmc = 0;
        int i;

        if (mutex_tryenter(&nb_mutex) == 0)
                return;

        nerr = NERR_GLOBAL_RD();
        err = nerr;
        for (i = 0; i < NB_MAX_ERRORS; i++) {
                ferr = FERR_GLOBAL_RD();
                nb_log.nb_regs.chipset = nb_chipset;
                nb_log.nb_regs.ferr = ferr;
                nb_log.nb_regs.nerr = nerr;
                if (ferr) {
                        log_ferr(ferr, &err, &nb_log, willpanic);
                        FERR_GLOBAL_WR(ferr);
                        nmc++;
                } else if (err) {
                        log_nerr(&err, &nb_log, willpanic);
                        nmc++;
                }
        }
        if (nerr) {
                NERR_GLOBAL_WR(nerr);
        }
        if (nmc == 0 && nb_mask_mc_set)
                nb_mask_mc_reset();
        mutex_exit(&nb_mutex);
}

static void
nb_fsb_err_payload(const nb_regs_t *nb_regs, nvlist_t *payload,
    nb_scatchpad_t *data)
{
        int intel_error_list;
        char buf[32];

        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FSB,
            DATA_TYPE_UINT8, nb_regs->nb.fsb_regs.fsb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_FAT_FSB,
            DATA_TYPE_UINT8, nb_regs->nb.fsb_regs.ferr_fat_fsb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_FAT_FSB,
            DATA_TYPE_UINT8, nb_regs->nb.fsb_regs.nerr_fat_fsb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_NF_FSB,
            DATA_TYPE_UINT8, nb_regs->nb.fsb_regs.ferr_nf_fsb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_NF_FSB,
            DATA_TYPE_UINT8, nb_regs->nb.fsb_regs.nerr_nf_fsb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFSB,
            DATA_TYPE_UINT32, nb_regs->nb.fsb_regs.nrecfsb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFSB_ADDR,
            DATA_TYPE_UINT64, nb_regs->nb.fsb_regs.nrecfsb_addr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECFSB,
            DATA_TYPE_UINT32, nb_regs->nb.fsb_regs.recfsb, NULL);
        intel_error_list = data->intel_error_list;
        if (intel_error_list >= 0)
                (void) snprintf(buf, sizeof (buf), "F%d", intel_error_list);
        else
                (void) snprintf(buf, sizeof (buf), "Multiple or unknown error");
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_ERROR_NO,
            DATA_TYPE_STRING, buf, NULL);
}

static void
nb_pex_err_payload(const nb_regs_t *nb_regs, nvlist_t *payload,
    nb_scatchpad_t *data)
{
        int intel_error_list;
        char buf[32];

        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_PEX,
            DATA_TYPE_UINT8, nb_regs->nb.pex_regs.pex, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_PEX_FAT_FERR,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.pex_fat_ferr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_PEX_FAT_NERR,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.pex_fat_nerr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_PEX_NF_CORR_FERR,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.pex_nf_corr_ferr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_PEX_NF_CORR_NERR,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.pex_nf_corr_nerr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_UNCERRSEV,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.uncerrsev, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RPERRSTS,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.rperrsts, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RPERRSID,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.rperrsid, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_UNCERRSTS,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.uncerrsts, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_AERRCAPCTRL,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.aerrcapctrl, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CORERRSTS,
            DATA_TYPE_UINT32, nb_regs->nb.pex_regs.corerrsts, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_PEXDEVSTS,
            DATA_TYPE_UINT16, nb_regs->nb.pex_regs.pexdevsts, NULL);
        intel_error_list = data->intel_error_list;
        if (intel_error_list >= 0)
                (void) snprintf(buf, sizeof (buf), "IO%d", intel_error_list);
        else
                (void) snprintf(buf, sizeof (buf), "Multiple or unknown error");
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_ERROR_NO,
            DATA_TYPE_STRING, buf, NULL);
}

static void
nb_int_err_payload(const nb_regs_t *nb_regs, nvlist_t *payload,
    nb_scatchpad_t *data)
{
        int intel_error_list;
        char buf[32];

        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_FAT_INT,
            DATA_TYPE_UINT16, nb_regs->nb.int_regs.ferr_fat_int, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_NF_INT,
            DATA_TYPE_UINT16, nb_regs->nb.int_regs.ferr_nf_int, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_FAT_INT,
            DATA_TYPE_UINT16, nb_regs->nb.int_regs.nerr_fat_int, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_NF_INT,
            DATA_TYPE_UINT16, nb_regs->nb.int_regs.nerr_nf_int, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECINT,
            DATA_TYPE_UINT32, nb_regs->nb.int_regs.nrecint, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECINT,
            DATA_TYPE_UINT32, nb_regs->nb.int_regs.recint, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECSF,
            DATA_TYPE_UINT64, nb_regs->nb.int_regs.nrecsf, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECSF,
            DATA_TYPE_UINT64, nb_regs->nb.int_regs.recsf, NULL);
        intel_error_list = data->intel_error_list;
        if (intel_error_list >= 0)
                (void) snprintf(buf, sizeof (buf), "B%d", intel_error_list);
        else
                (void) snprintf(buf, sizeof (buf), "Multiple or unknown error");
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_ERROR_NO,
            DATA_TYPE_STRING, buf, NULL);
}

static void
nb_fat_fbd_err_payload(const nb_regs_t *nb_regs, nvlist_t *payload,
    nb_scatchpad_t *data)
{
        nb_mem_scatchpad_t *sp;
        char buf[32];

        sp = &((nb_scatchpad_t *)data)->ms;

        if (sp->ras != -1) {
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BANK,
                    DATA_TYPE_INT32, sp->bank, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CAS,
                    DATA_TYPE_INT32, sp->cas, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RAS,
                    DATA_TYPE_INT32, sp->ras, NULL);
                if (sp->offset != -1LL) {
                        fm_payload_set(payload, FM_FMRI_MEM_OFFSET,
                            DATA_TYPE_UINT64, sp->offset, NULL);
                }
                if (sp->pa != -1LL) {
                        fm_payload_set(payload, FM_FMRI_MEM_PHYSADDR,
                            DATA_TYPE_UINT64, sp->pa, NULL);
                }
        }
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_FAT_FBD,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.ferr_fat_fbd, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_FAT_FBD,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nerr_fat_fbd, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECMEMA,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecmema, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECMEMB,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecmemb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFGLOG,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecfglog, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFBDA,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecfbda, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFBDB,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecfbdb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFBDC,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecfbdc, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFBDD,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecfbdd, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFBDE,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecfbde, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECFBDF,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.nrecfbdf, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_SPCPS,
            DATA_TYPE_UINT8, nb_regs->nb.fat_fbd_regs.spcps, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_SPCPC,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.spcpc, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_UERRCNT,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.uerrcnt, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_UERRCNT_LAST,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.uerrcnt_last, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BADRAMA,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.badrama, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BADRAMB,
            DATA_TYPE_UINT16, nb_regs->nb.fat_fbd_regs.badramb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BADCNT,
            DATA_TYPE_UINT32, nb_regs->nb.fat_fbd_regs.badcnt, NULL);

        if (sp->intel_error_list >= 0)
                (void) snprintf(buf, sizeof (buf), "M%d", sp->intel_error_list);
        else
                (void) snprintf(buf, sizeof (buf), "Multiple or unknown error");
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_ERROR_NO,
            DATA_TYPE_STRING, buf, NULL);
}

static void
nb_nf_fbd_err_payload(const nb_regs_t *nb_regs, nvlist_t *payload,
    nb_scatchpad_t *data)
{
        nb_mem_scatchpad_t *sp;
        char buf[32];

        sp = &((nb_scatchpad_t *)data)->ms;

        if (sp->dimm == -1 && sp->rank != -1) {
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RANK,
                    DATA_TYPE_INT32, sp->rank, NULL);
        }
        if (sp->ras != -1) {
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BANK,
                    DATA_TYPE_INT32, sp->bank, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CAS,
                    DATA_TYPE_INT32, sp->cas, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RAS,
                    DATA_TYPE_INT32, sp->ras, NULL);
                if (sp->offset != -1LL) {
                        fm_payload_set(payload, FM_FMRI_MEM_OFFSET,
                            DATA_TYPE_UINT64, sp->offset, NULL);
                }
                if (sp->pa != -1LL) {
                        fm_payload_set(payload, FM_FMRI_MEM_PHYSADDR,
                            DATA_TYPE_UINT64, sp->pa, NULL);
                }
        }
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_NF_FBD,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.ferr_nf_fbd, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_NF_FBD,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.nerr_nf_fbd, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECMEMA,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recmema, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECMEMB,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recmemb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECFGLOG,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recfglog, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECFBDA,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recfbda, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECFBDB,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recfbdb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECFBDC,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recfbdc, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECFBDD,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recfbdd, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECFBDE,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recfbde, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECFBDF,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.recfbdf, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_SPCPS,
            DATA_TYPE_UINT8, nb_regs->nb.nf_fbd_regs.spcps, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_SPCPC,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.spcpc, NULL);
        if (nb_chipset == INTEL_NB_7300 || nb_chipset == INTEL_NB_5400) {
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNTA,
                    DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.cerrcnta, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNTB,
                    DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.cerrcntb, NULL);
                if (nb_chipset == INTEL_NB_7300) {
                        fm_payload_set(payload,
                            FM_EREPORT_PAYLOAD_NAME_CERRCNTC,
                            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.cerrcntc,
                            NULL);
                        fm_payload_set(payload,
                            FM_EREPORT_PAYLOAD_NAME_CERRCNTD,
                            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.cerrcntd,
                            NULL);
                }
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNTA_LAST,
                    DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.cerrcnta_last,
                    NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNTB_LAST,
                    DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.cerrcntb_last,
                    NULL);
                if (nb_chipset == INTEL_NB_7300) {
                        fm_payload_set(payload,
                            FM_EREPORT_PAYLOAD_NAME_CERRCNTC_LAST,
                            DATA_TYPE_UINT32,
                            nb_regs->nb.nf_fbd_regs.cerrcntc_last, NULL);
                        fm_payload_set(payload,
                            FM_EREPORT_PAYLOAD_NAME_CERRCNTD_LAST,
                            DATA_TYPE_UINT32,
                            nb_regs->nb.nf_fbd_regs.cerrcntd_last, NULL);
                }
        } else {
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNT,
                    DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.cerrcnta, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNT_LAST,
                    DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.cerrcnta_last,
                    NULL);
        }
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BADRAMA,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.badrama, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BADRAMB,
            DATA_TYPE_UINT16, nb_regs->nb.nf_fbd_regs.badramb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BADCNT,
            DATA_TYPE_UINT32, nb_regs->nb.nf_fbd_regs.badcnt, NULL);

        if (sp->intel_error_list >= 0)
                (void) snprintf(buf, sizeof (buf), "M%d", sp->intel_error_list);
        else
                (void) snprintf(buf, sizeof (buf), "Multiple or unknown error");
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_ERROR_NO,
            DATA_TYPE_STRING, buf, NULL);
}

static void
nb_nf_mem_err_payload(const nb_regs_t *nb_regs, nvlist_t *payload,
    nb_scatchpad_t *data)
{
        nb_mem_scatchpad_t *sp;
        char buf[32];

        sp = &((nb_scatchpad_t *)data)->ms;

        if (sp->dimm == -1 && sp->rank != -1) {
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RANK,
                    DATA_TYPE_INT32, sp->rank, NULL);
        }
        if (sp->ras != -1) {
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BANK,
                    DATA_TYPE_INT32, sp->bank, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CAS,
                    DATA_TYPE_INT32, sp->cas, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RAS,
                    DATA_TYPE_INT32, sp->ras, NULL);
                if (sp->offset != -1LL) {
                        fm_payload_set(payload, FM_FMRI_MEM_OFFSET,
                            DATA_TYPE_UINT64, sp->offset, NULL);
                }
                if (sp->pa != -1LL) {
                        fm_payload_set(payload, FM_FMRI_MEM_PHYSADDR,
                            DATA_TYPE_UINT64, sp->pa, NULL);
                }
        }
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_NF_MEM,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.ferr_nf_mem, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_NF_MEM,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.nerr_nf_mem, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECMEMA,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.recmema, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_RECMEMB,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.recmemb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_REDMEMA,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.redmema, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_REDMEMB,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.redmemb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECMEMA,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.nrecmema, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NRECMEMB,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.nrecmemb, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_SPCPS,
            DATA_TYPE_UINT8, nb_regs->nb.nf_mem_regs.spcps, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_SPCPC,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.spcpc, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNT,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.cerrcnt, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNT_LAST,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.cerrcnt_last, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNT_EXT,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.cerrcnt_ext, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CERRCNT_EXT_LAST,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.cerrcnt_ext_last, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BADRAM,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.badram, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_BADCNT,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.badcnt, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_VALIDLOG,
            DATA_TYPE_UINT32, nb_regs->nb.nf_mem_regs.validlog, NULL);

        if (sp->intel_error_list >= 0)
                (void) snprintf(buf, sizeof (buf), "M%d", sp->intel_error_list);
        else
                (void) snprintf(buf, sizeof (buf), "Multiple or unknown error");
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_ERROR_NO,
            DATA_TYPE_STRING, buf, NULL);
}

static void
nb_dma_err_payload(const nb_regs_t *nb_regs, nvlist_t *payload)
{
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_PCISTS,
            DATA_TYPE_UINT16, nb_regs->nb.dma_regs.pcists, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_PEXDEVSTS,
            DATA_TYPE_UINT16, nb_regs->nb.dma_regs.pexdevsts, NULL);
}

static void
nb_thr_err_payload(const nb_regs_t *nb_regs, nvlist_t *payload,
    nb_scatchpad_t *data)
{
        char buf[32];

        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_FAT_THR,
            DATA_TYPE_UINT8, nb_regs->nb.thr_regs.ferr_fat_thr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_FAT_THR,
            DATA_TYPE_UINT8, nb_regs->nb.thr_regs.nerr_fat_thr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_NF_THR,
            DATA_TYPE_UINT8, nb_regs->nb.thr_regs.ferr_nf_thr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_NF_THR,
            DATA_TYPE_UINT8, nb_regs->nb.thr_regs.nerr_nf_thr, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_CTSTS,
            DATA_TYPE_UINT8, nb_regs->nb.thr_regs.ctsts, NULL);
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_THRTSTS,
            DATA_TYPE_UINT16, nb_regs->nb.thr_regs.thrtsts, NULL);
        if (data->intel_error_list >= 0) {
                (void) snprintf(buf, sizeof (buf), "TH%d",
                    data->intel_error_list);
        } else {
                (void) snprintf(buf, sizeof (buf), "Multiple or unknown error");
        }
        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_ERROR_NO,
            DATA_TYPE_STRING, buf, NULL);
}

static void
nb_ereport_add_logout(nvlist_t *payload, const nb_logout_t *acl,
    nb_scatchpad_t *data)
{
        const nb_regs_t *nb_regs = &acl->nb_regs;

        fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_MC_TYPE,
            DATA_TYPE_STRING, acl->type, NULL);
        switch (nb_regs->flag) {
        case NB_REG_LOG_FSB:
                nb_fsb_err_payload(nb_regs, payload, data);
                break;
        case NB_REG_LOG_PEX:
                nb_pex_err_payload(nb_regs, payload, data);
                break;
        case NB_REG_LOG_INT:
                nb_int_err_payload(nb_regs, payload, data);
                break;
        case NB_REG_LOG_FAT_FBD:
                nb_fat_fbd_err_payload(nb_regs, payload, data);
                break;
        case NB_REG_LOG_NF_FBD:
                nb_nf_fbd_err_payload(nb_regs, payload, data);
                break;
        case NB_REG_LOG_DMA:
                nb_dma_err_payload(nb_regs, payload);
                break;
        case NB_REG_LOG_THR:
                nb_thr_err_payload(nb_regs, payload, data);
                break;
        case NB_REG_LOG_NF_MEM:
                nb_nf_mem_err_payload(nb_regs, payload, data);
                break;
        default:
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_FERR_GLOBAL,
                    DATA_TYPE_UINT64, nb_regs->ferr, NULL);
                fm_payload_set(payload, FM_EREPORT_PAYLOAD_NAME_NERR_GLOBAL,
                    DATA_TYPE_UINT32, nb_regs->nerr, NULL);
                break;
        }
}

void
nb_fsb_report(const nb_regs_t *nb_regs, char *class, nvlist_t *detector,
    nb_scatchpad_t *data)
{
        int chip;

        if (nb_chipset == INTEL_NB_7300)
                chip = nb_regs->nb.fsb_regs.fsb * 2;
        else
                chip = nb_regs->nb.fsb_regs.fsb;
        fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 2,
            "motherboard", 0, "chip", chip);

        if (nb_regs->nb.fsb_regs.ferr_fat_fsb == 0 &&
            nb_regs->nb.fsb_regs.ferr_nf_fsb == 0) {
                data->intel_error_list = intel_fsb_err(nb_regs->nb.fsb_regs.fsb,
                    nb_regs->nb.fsb_regs.nerr_fat_fsb,
                    nb_regs->nb.fsb_regs.nerr_nf_fsb);
        } else {
                data->intel_error_list = intel_fsb_err(nb_regs->nb.fsb_regs.fsb,
                    nb_regs->nb.fsb_regs.ferr_fat_fsb,
                    nb_regs->nb.fsb_regs.ferr_nf_fsb);
        }
        (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s.%s",
            FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, "nb", "fsb");
}

void
nb_pex_report(const nb_regs_t *nb_regs, char *class, nvlist_t *detector,
    nb_scatchpad_t *data)
{
        int hostbridge;

        if (nb_regs->nb.pex_regs.pex == 0) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 1,
                    "motherboard", 0);
        } else {
                hostbridge = nb_regs->nb.pex_regs.pex - 1;
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 2,
                    "motherboard", 0,
                    "hostbridge", hostbridge);
        }

        if (nb_regs->nb.pex_regs.pex_fat_ferr == 0 &&
            nb_regs->nb.pex_regs.pex_nf_corr_ferr == 0) {
                if (nb_chipset == INTEL_NB_5400) {
                        data->intel_error_list =
                            intel_pex_5400_err(
                            nb_regs->nb.pex_regs.pex_fat_nerr,
                            nb_regs->nb.pex_regs.pex_nf_corr_nerr);
                } else {
                        data->intel_error_list =
                            intel_pex_err(nb_regs->nb.pex_regs.pex_fat_nerr,
                            nb_regs->nb.pex_regs.pex_nf_corr_nerr);
                }
        } else {
                if (nb_chipset == INTEL_NB_5400) {
                        data->intel_error_list =
                            intel_pex_5400_err(
                            nb_regs->nb.pex_regs.pex_fat_ferr,
                            nb_regs->nb.pex_regs.pex_nf_corr_ferr);
                } else {
                        data->intel_error_list =
                            intel_pex_err(nb_regs->nb.pex_regs.pex_fat_ferr,
                            nb_regs->nb.pex_regs.pex_nf_corr_ferr);
                }
        }

        if (nb_regs->nb.pex_regs.pex == 0) {
                (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s.%s",
                    FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, "nb", "esi");
        } else {
                (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s.%s",
                    FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, "nb", "pex");
        }
}

void
nb_int_report(const nb_regs_t *nb_regs, char *class, nvlist_t *detector,
    void *data)
{
        fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 1,
            "motherboard", 0);

        if (nb_regs->nb.int_regs.ferr_fat_int == 0 &&
            nb_regs->nb.int_regs.ferr_nf_int == 0) {
                ((nb_scatchpad_t *)data)->intel_error_list =
                    intel_int_err(nb_regs->nb.int_regs.nerr_fat_int,
                    nb_regs->nb.int_regs.nerr_nf_int);
        } else {
                ((nb_scatchpad_t *)data)->intel_error_list =
                    intel_int_err(nb_regs->nb.int_regs.ferr_fat_int,
                    nb_regs->nb.int_regs.ferr_nf_int);
        }
        (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s.%s",
            FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, "nb", "ie");
}

void
nb_fat_fbd_report(const nb_regs_t *nb_regs, char *class, nvlist_t *detector,
    void *data)
{
        char *intr;
        nb_mem_scatchpad_t *sp;

        intr = fat_memory_error(nb_regs, data);
        sp = &((nb_scatchpad_t *)data)->ms;

        if (sp->dimm != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 5,
                    "motherboard", 0,
                    "memory-controller", sp->branch,
                    "dram-channel", sp->channel,
                    "dimm", sp->dimm,
                    "rank", sp->rank);
        } else if (sp->channel != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 3,
                    "motherboard", 0,
                    "memory-controller", sp->branch,
                    "dram-channel", sp->channel);
        } else if (sp->branch != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 2,
                    "motherboard", 0,
                    "memory-controller", sp->branch);
        } else {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 1,
                    "motherboard", 0);
        }

        (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s",
            FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, intr);
}

void
nb_nf_fbd_report(const nb_regs_t *nb_regs, char *class, nvlist_t *detector,
    void *data)
{
        char *intr;
        nb_mem_scatchpad_t *sp;

        intr = nf_memory_error(nb_regs, data);
        sp = &((nb_scatchpad_t *)data)->ms;

        if (sp->dimm != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 5,
                    "motherboard", 0,
                    "memory-controller", sp->branch,
                    "dram-channel", sp->channel,
                    "dimm", sp->dimm,
                    "rank", sp->rank);
        } else if (sp->channel != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 3,
                    "motherboard", 0,
                    "memory-controller", sp->branch,
                    "dram-channel", sp->channel);
        } else if (sp->branch != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 2,
                    "motherboard", 0,
                    "memory-controller", sp->branch);
        } else {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 1,
                    "motherboard", 0);
        }

        (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s",
            FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, intr);
}

void
nb_dma_report(char *class, nvlist_t *detector)
{
        fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 1,
            "motherboard", 0);

        (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s.%s",
            FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, "nb", "dma");
}

void
nb_thr_report(const nb_regs_t *nb_regs, char *class, nvlist_t *detector,
    void *data)
{
        ((nb_scatchpad_t *)data)->intel_error_list =
            intel_thr_err(nb_regs->nb.thr_regs.ferr_fat_thr,
            nb_regs->nb.thr_regs.ferr_nf_thr);
        fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 1,
            "motherboard", 0);

        (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s.%s",
            FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, "nb", "otf");
}

void
nb_nf_mem_report(const nb_regs_t *nb_regs, char *class, nvlist_t *detector,
    void *data)
{
        char *intr;
        nb_mem_scatchpad_t *sp;

        intr = nf_mem_error(nb_regs, data);
        sp = &((nb_scatchpad_t *)data)->ms;

        if (sp->dimm != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 5,
                    "motherboard", 0,
                    "memory-controller", sp->branch,
                    "dram-channel", sp->channel,
                    "dimm", sp->dimm,
                    "rank", sp->rank);
        } else if (sp->channel != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 3,
                    "motherboard", 0,
                    "memory-controller", sp->branch,
                    "dram-channel", sp->channel);
        } else if (sp->branch != -1) {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 2,
                    "motherboard", 0,
                    "memory-controller", sp->branch);
        } else {
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 1,
                    "motherboard", 0);
        }

        (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s",
            FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, intr);
}


nvlist_t *
nb_report(const nb_regs_t *nb_regs, char *class, nv_alloc_t *nva, void *scratch)
{
        nvlist_t *detector = fm_nvlist_create(nva);

        switch (nb_regs->flag) {
        case NB_REG_LOG_FSB:
                nb_fsb_report(nb_regs, class, detector, scratch);
                break;
        case NB_REG_LOG_PEX:
                nb_pex_report(nb_regs, class, detector, scratch);
                break;
        case NB_REG_LOG_INT:
                nb_int_report(nb_regs, class, detector, scratch);
                break;
        case NB_REG_LOG_FAT_FBD:
                nb_fat_fbd_report(nb_regs, class, detector, scratch);
                break;
        case NB_REG_LOG_NF_FBD:
                nb_nf_fbd_report(nb_regs, class, detector, scratch);
                break;
        case NB_REG_LOG_DMA:
                nb_dma_report(class, detector);
                break;
        case NB_REG_LOG_THR:
                nb_thr_report(nb_regs, class, detector, scratch);
                break;
        case NB_REG_LOG_NF_MEM:
                nb_nf_mem_report(nb_regs, class, detector, scratch);
                break;
        default:
                fm_fmri_hc_set(detector, FM_HC_SCHEME_VERSION, NULL, NULL, 1,
                    "motherboard", 0);

                (void) snprintf(class, FM_MAX_CLASS, "%s.%s.%s.%s",
                    FM_ERROR_CPU, FM_EREPORT_CPU_INTEL, "nb", "unknown");
        }
        return (detector);
}

/*ARGSUSED*/
void
nb_drain(void *ignored, const void *data, const errorq_elem_t *eqe)
{
        nb_logout_t *acl = (nb_logout_t *)data;
        errorq_elem_t *eqep, *scr_eqep;
        nvlist_t *ereport, *detector;
        nv_alloc_t *nva = NULL;
        char buf[FM_MAX_CLASS];
        nb_scatchpad_t nb_scatchpad;

        eqep = NULL;
        scr_eqep = NULL;
        if (panicstr) {
                if ((eqep = errorq_reserve(ereport_errorq)) == NULL)
                        return;
                ereport = errorq_elem_nvl(ereport_errorq, eqep);
                /*
                 * Now try to allocate another element for scratch space and
                 * use that for further scratch space (eg for constructing
                 * nvlists to add the main ereport).  If we can't reserve
                 * a scratch element just fallback to working within the
                 * element we already have, and hope for the best.  All this
                 * is necessary because the fixed buffer nv allocator does
                 * not reclaim freed space and nvlist construction is
                 * expensive.
                 */
                if ((scr_eqep = errorq_reserve(ereport_errorq)) != NULL)
                        nva = errorq_elem_nva(ereport_errorq, scr_eqep);
                else
                        nva = errorq_elem_nva(ereport_errorq, eqep);
        } else {
                ereport = fm_nvlist_create(NULL);
        }
        detector = nb_report(&acl->nb_regs, buf, nva, &nb_scatchpad);
        if (detector == NULL)
                return;
        fm_ereport_set(ereport, FM_EREPORT_VERSION, buf,
            fm_ena_generate(acl->acl_timestamp, FM_ENA_FMT1), detector, NULL);
        /*
         * We're done with 'detector' so reclaim the scratch space.
         */
        if (panicstr) {
                fm_nvlist_destroy(detector, FM_NVA_RETAIN);
                nv_alloc_reset(nva);
        } else {
                fm_nvlist_destroy(detector, FM_NVA_FREE);
        }

        /*
         * Encode the error-specific data that was saved in the logout area.
         */
        nb_ereport_add_logout(ereport, acl, &nb_scatchpad);

        if (panicstr) {
                errorq_commit(ereport_errorq, eqep, ERRORQ_SYNC);
                if (scr_eqep)
                        errorq_cancel(ereport_errorq, scr_eqep);
        } else {
                (void) fm_ereport_post(ereport, EVCH_TRYHARD);
                fm_nvlist_destroy(ereport, FM_NVA_FREE);
        }
}