intel/os/fmsmb.c

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

#include <sys/types.h>
#include <sys/time.h>
#include <sys/nvpair.h>
#include <sys/cmn_err.h>
#include <sys/fm/util.h>
#include <sys/fm/protocol.h>
#include <sys/smbios.h>
#include <sys/smbios_impl.h>

/*
 * Variable used to determine if the x86 generic topology enumerator will
 * revert to legacy enumeration. I.E. Big Kill Switch... tunable via
 * /etc/system
 */
int x86gentopo_legacy = 0;

#define MC      0
#define PROC        1
#define MAX_PAIRS   20
#define MAX_CONT    40

typedef struct bbindex  {
    int count;
    uint16_t index[MAX_PAIRS];
} bbindex_t;

/*
 * the enum values come from DMTF
 */
typedef enum baseb {
    BB_BAD = 0,     /* There is no bb value 0 */
    BB_UNKNOWN,     /* Unknown */
    BB_OTHER,       /* Other */
    BB_BLADE,       /* Server Blade */
    BB_CONNSW,      /* Connectivity Switch */
    BB_SMM,         /* System Management Module */
    BB_PROCMOD,     /* Processor Module */
    BB_IOMOD,       /* I/O Module */
    BB_MEMMOD,      /* Memory Module */
    BB_DBOARD,      /* Daughter Board */
    BB_MBOARD,      /* Motherboard */
    BB_PROCMMOD,        /* Processor/Memory Module */
    BB_PROCIOMOD,       /* Processor/IO Module */
    BB_ICONNBD      /* Interconnect Board */
} bbd_t;

static struct bboard_type {
    bbd_t       baseb;
    const char  *name;
} bbd_type[] = {
    {BB_BAD,        NULL},
    {BB_UNKNOWN,        "unknown"},
    {BB_OTHER,      "other"},
    {BB_BLADE,      "systemboard"},
    {BB_CONNSW,     "connswitch"},
    {BB_SMM,        "smmodule"},
    {BB_PROCMOD,        "cpuboard"},
    {BB_IOMOD,      "ioboard"},
    {BB_MEMMOD,     "memboard"},
    {BB_DBOARD,     "systemboard"},
    {BB_MBOARD,     "motherboard"},
    {BB_PROCMMOD,       "systemboard"},
    {BB_PROCIOMOD,      "systemboard"},
    {BB_ICONNBD,        "systemboard"}
};

typedef struct smbs_con_ids {
    int id;
    int inst;
    int cont_count;
    uint16_t **cont_ids;
    int cont_by_id;
    int visited;
} smbs_con_ids_t;

typedef struct smbs_cnt {
    int type;           /* SMBIOS stucture type */
    int count;          /* number of table entries */
    smbs_con_ids_t **ids;       /* SMBIOS table entry id(s) */
} smbs_cnt_t;

/*
 * dynamically allocate the storage for the smbs_cnt_t
 */
static smbs_cnt_t *
smb_create_strcnt(int count)
{
    smbs_cnt_t *types = NULL;
    int i, j;

    types = kmem_zalloc(sizeof (smbs_cnt_t), KM_SLEEP);

    types->ids = (smbs_con_ids_t **)kmem_zalloc(
        count * sizeof (smbs_con_ids_t *), KM_SLEEP);

    for (i = 0; i < count; i++) {
        types->ids[i] = (smbs_con_ids_t *)kmem_zalloc(
            sizeof (smbs_con_ids_t), KM_SLEEP);
    }

    for (i = 0; i < count; i++) {
        types->ids[i]->cont_ids = (uint16_t **)kmem_zalloc(
            MAX_CONT * sizeof (uint16_t *), KM_SLEEP);
    }

    for (i = 0; i < count; i++) {
        for (j = 0; j < MAX_CONT; j++) {
            types->ids[i]->cont_ids[j] = (uint16_t *)kmem_zalloc(
                sizeof (uint16_t), KM_SLEEP);
        }
    }
    return (types);
}

/*
 * free the smbs_cnt_t memory
 */
static void
smb_free_strcnt(smbs_cnt_t *types, int count)
{
    int i, j;

    if (types == NULL)
        return;

    for (i = 0; i < count; i++) {
        for (j = 0; j < MAX_CONT; j++) {
            if (types->ids[i]->cont_ids[j] != NULL)
                kmem_free(types->ids[i]->cont_ids[j],
                    sizeof (uint16_t));
        }
    }

    for (i = 0; i < count; i++) {
        if (types->ids[i]->cont_ids != NULL)
            kmem_free(types->ids[i]->cont_ids,
                MAX_CONT * sizeof (uint16_t *));
    }

    for (i = 0; i < count; i++) {
        if (types->ids[i] != NULL)
            kmem_free(types->ids[i], sizeof (smbs_con_ids_t));
    }

    if (types->ids != NULL)
        kmem_free(types->ids, count * sizeof (smbs_con_ids_t *));

    if (types != NULL)
        kmem_free(types, sizeof (smbs_cnt_t));

}

/*
 * count number of the structure type in the ksmbios
 */
static int
smb_cnttypes(smbios_hdl_t *shp, int type)
{
    const smb_struct_t *sp = shp->sh_structs;
    int nstructs = shp->sh_nstructs;
    int i;
    int cnt = 0;

    for (i = 0, cnt = 0; i < nstructs; i++, sp++) {
        if (sp->smbst_hdr->smbh_type == type)
            cnt++;
    }
    return (cnt);
}

static void
smb_strcnt(smbios_hdl_t *shp, smbs_cnt_t *stype)
{
    const smb_struct_t *sp = shp->sh_structs;
    int nstructs = shp->sh_nstructs;
    smbios_bboard_t bb;
    int i, cnt;
    int mb_cnt = 0;
    int cpub_cnt = 0;
    int sysb_cnt = 0;
    int memb_cnt = 0;
    int iob_cnt = 0;
    int inst = 0;
    int rc = 0;

    for (i = 0, cnt = 0; i < nstructs; i++, sp++) {
        if (sp->smbst_hdr->smbh_type == stype->type) {
            stype->ids[cnt]->id = sp->smbst_hdr->smbh_hdl;
            stype->ids[cnt]->inst = cnt;
            stype->ids[cnt]->visited = 0;
            stype->ids[cnt]->cont_by_id = -1;
            if (stype->type == SMB_TYPE_BASEBOARD) {
                rc = smbios_info_bboard(shp,
                    stype->ids[cnt]->id, &bb);
                if (rc == 0) {
                    switch (bb.smbb_type) {
                        case SMB_BBT_PROC :
                            inst = cpub_cnt++;
                            break;
                        case SMB_BBT_IO :
                            inst = iob_cnt++;
                            break;
                        case SMB_BBT_MEM :
                            inst = memb_cnt++;
                            break;
                        case SMB_BBT_MOTHER :
                            inst = mb_cnt++;
                            break;
                        default:
                            /*
                             * SMB_BBT_UNKNOWN
                             * SMB_BBT_OTHER
                             * SMB_BBT_SBLADE
                             * SMB_BBT_CSWITCH
                             * SMB_BBT_SMM
                             * SMB_BBT_DAUGHTER
                             * SMB_BBT_PROCMEM
                             * SMB_BBT_PROCIO
                             * SMB_BBT_INTER
                             */
                            inst = sysb_cnt++;
                            break;
                    }
                    stype->ids[cnt]->inst = inst;
                }
            }
            cnt++;
        }
    }
    stype->count = cnt;
}

/*
 * Go through the smbios structures looking for type 2. Fill in
 * the cont_id and cont_by_id for each type 2
 *
 */
static void
smb_bb_contains(smbios_hdl_t *shp, smbs_cnt_t *stype)
{
    int i, j, cnt, c;
    uint_t cont_count;
    const smb_struct_t *spt;
    smbios_bboard_t smb_bb;
    uint16_t bb_id, cont_id;
    uint_t cont_len;
    id_t *cont_hdl = NULL;
    int rc;

    for (cnt = 0; cnt < stype->count; cnt++) {
        bb_id = stype->ids[cnt]->id;
        (void) smbios_info_bboard(shp, stype->ids[cnt]->id, &smb_bb);
        cont_count = (uint_t)smb_bb.smbb_contn;
        if (cont_count == 0) {
            continue;
        }

        cont_len = sizeof (id_t);
        cont_hdl = kmem_zalloc(cont_count * cont_len, KM_SLEEP);
        if (cont_hdl == NULL)
            continue;

        rc = smbios_info_contains(shp, stype->ids[cnt]->id,
            cont_count, cont_hdl);
        if (rc > SMB_CONT_MAX) {
            kmem_free(cont_hdl, cont_count * cont_len);
            continue;
        }
        cont_count = MIN(rc, cont_count);

        /*
         * fill in the type 2 and type 4 ids which are
         * contained in this type 2
         */
        c = 0;
        for (j = 0; j < cont_count; j++) {
            cont_id = (uint16_t)cont_hdl[j];
            spt = smb_lookup_id(shp, cont_id);
            if (spt->smbst_hdr->smbh_type == SMB_TYPE_BASEBOARD ||
                spt->smbst_hdr->smbh_type == SMB_TYPE_PROCESSOR) {
                *stype->ids[cnt]->cont_ids[c] = cont_id;
                c++;
            }

            if (spt->smbst_hdr->smbh_type == SMB_TYPE_BASEBOARD) {
                for (i = 0; i < stype->count; i++) {
                    if (stype->ids[i]->id == cont_id) {
                        stype->ids[i]->cont_by_id =
                            bb_id;
                    }
                }
            }

        }
        stype->ids[cnt]->cont_count = c;
        if (cont_hdl != NULL)
            kmem_free(cont_hdl, cont_count * cont_len);
    }
}

/*
 * Verify SMBIOS structures for x86 generic topology.
 *
 * Return (0) on success.
 */
static int
fm_smb_check(smbios_hdl_t *shp)
{
    int i;
    int bb_cnt = 0;
    int pr_cnt = 0;
    int expr_cnt = 0;
    int ma_cnt = 0;
    int exma_cnt = 0;
    int mdev_cnt = 0;
    int exmdev_cnt = 0;
    uint16_t bb_id;
    uint16_t pr_id, expr_id;
    uint16_t ma_id, exma_id;
    uint16_t mdev_id, exmdev_id;
    smbios_bboard_t bb;
    smbios_processor_ext_t exproc;
    smbios_memarray_ext_t exma;
    smbios_memdevice_ext_t exmdev;
    smbs_cnt_t *bb_stype;
    smbs_cnt_t *pr_stype, *expr_stype;
    smbs_cnt_t *ma_stype, *exma_stype;
    smbs_cnt_t *mdev_stype, *exmdev_stype;

    /*
     * Verify the existance of the requuired extended OEM-Specific
     * structures and they coincide with the structures they extend
     * (e.g. the number of extended processor structures equal the
     * number of processor structures).
     */
    pr_cnt = smb_cnttypes(shp, SMB_TYPE_PROCESSOR);
    expr_cnt = smb_cnttypes(shp, SUN_OEM_EXT_PROCESSOR);
    ma_cnt = smb_cnttypes(shp, SMB_TYPE_MEMARRAY);
    exma_cnt = smb_cnttypes(shp, SUN_OEM_EXT_MEMARRAY);
    mdev_cnt = smb_cnttypes(shp, SMB_TYPE_MEMDEVICE);
    exmdev_cnt = smb_cnttypes(shp, SUN_OEM_EXT_MEMDEVICE);
    if (expr_cnt == 0 || exma_cnt == 0 || exmdev_cnt == 0 ||
        expr_cnt != pr_cnt || exma_cnt != ma_cnt ||
        exmdev_cnt != mdev_cnt) {
#ifdef  DEBUG
        cmn_err(CE_NOTE, "!Structure mismatch: ext_proc (%d) "
            "proc (%d) ext_ma (%d) ma (%d) ext_mdev (%d) mdev (%d)\n",
            expr_cnt, pr_cnt, exma_cnt, ma_cnt, exmdev_cnt,
            mdev_cnt);
#endif  /* DEBUG */
        return (-1);
    }

    /*
     * Verify the OEM-Specific structrures are correctly
     * linked to the SMBIOS structure types they extend.
     */

    /* allocate processor stypes */
    pr_stype = smb_create_strcnt(pr_cnt);
    expr_stype = smb_create_strcnt(expr_cnt);

    /* fill in stypes */
    pr_stype->type = SMB_TYPE_PROCESSOR;
    smb_strcnt(shp, pr_stype);
    expr_stype->type = SUN_OEM_EXT_PROCESSOR;
    smb_strcnt(shp, expr_stype);

    /* verify the ext proc struct belong to the proc struct */
    for (i = 0; i < pr_cnt; i++) {
        pr_id = pr_stype->ids[i]->id;
        expr_id = expr_stype->ids[i]->id;
        (void) smbios_info_extprocessor(shp, expr_id, &exproc);
        if (exproc.smbpe_processor != pr_id) {
#ifdef  DEBUG
            cmn_err(CE_NOTE, "!Processor struct linkage (%d)", i);
#endif  /* DEBUG */
            smb_free_strcnt(pr_stype, pr_cnt);
            smb_free_strcnt(expr_stype, expr_cnt);
            return (-1);
        }
    }

    /* free stypes */
    smb_free_strcnt(pr_stype, pr_cnt);
    smb_free_strcnt(expr_stype, expr_cnt);

    /* allocate memory array stypes */
    ma_stype = smb_create_strcnt(ma_cnt);
    exma_stype = smb_create_strcnt(exma_cnt);

    /* fill in stypes */
    ma_stype->type = SMB_TYPE_MEMARRAY;
    smb_strcnt(shp, ma_stype);
    exma_stype->type = SUN_OEM_EXT_MEMARRAY;
    smb_strcnt(shp, exma_stype);

    /* verify linkage from ext memarray struct to memarray struct */
    for (i = 0; i < ma_cnt; i++) {
        ma_id = ma_stype->ids[i]->id;
        exma_id = exma_stype->ids[i]->id;
        (void) smbios_info_extmemarray(shp, exma_id, &exma);
        if (exma.smbmae_ma != ma_id) {
#ifdef  DEBUG
            cmn_err(CE_NOTE,
                "!Memory Array struct linkage (%d)", i);
#endif  /* DEBUG */
            smb_free_strcnt(ma_stype, ma_cnt);
            smb_free_strcnt(exma_stype, exma_cnt);
            return (-1);
        }
    }

    /* free stypes */
    smb_free_strcnt(ma_stype, ma_cnt);
    smb_free_strcnt(exma_stype, exma_cnt);

    /* allocate memory device stypes */
    mdev_stype = smb_create_strcnt(mdev_cnt);
    exmdev_stype = smb_create_strcnt(exmdev_cnt);

    /* fill in stypes */
    mdev_stype->type = SMB_TYPE_MEMDEVICE;
    smb_strcnt(shp, mdev_stype);
    exmdev_stype->type = SUN_OEM_EXT_MEMDEVICE;
    smb_strcnt(shp, exmdev_stype);

    /* verify linkage */
    for (i = 0; i < mdev_cnt; i++) {
        mdev_id = mdev_stype->ids[i]->id;
        exmdev_id = exmdev_stype->ids[i]->id;
        (void) smbios_info_extmemdevice(shp, exmdev_id, &exmdev);
        if (exmdev.smbmdeve_md != mdev_id) {
#ifdef  DEBUG
            cmn_err(CE_NOTE, "!Memory Device struct linkage (%d)",
                i);
#endif  /* DEBUG */
            smb_free_strcnt(mdev_stype, mdev_cnt);
            smb_free_strcnt(exmdev_stype, exmdev_cnt);
            return (-1);
        }
    }

    /* free stypes */
    smb_free_strcnt(mdev_stype, mdev_cnt);
    smb_free_strcnt(exmdev_stype, exmdev_cnt);

    /*
     * Verify the presece of contained handles if there are more
     * than one Type-2 (Base Board) structures.
     */
    bb_cnt = smb_cnttypes(shp, SMB_TYPE_BASEBOARD);
    if (bb_cnt > 1) {
        /* allocate base board stypes */
        bb_stype = smb_create_strcnt(bb_cnt);

        /* fill in stypes */
        bb_stype->type = SMB_TYPE_BASEBOARD;
        smb_strcnt(shp, bb_stype);

        /* verify contained handles */
        for (i = 0; i < bb_cnt; i++) {
            bb_id = bb_stype->ids[i]->id;
            (void) smbios_info_bboard(shp, bb_id, &bb);
            if (bb.smbb_contn == 0) {
#ifdef  DEBUG
                cmn_err(CE_NOTE, "!No contained hanldes (%d)",
                    i);
#endif  /* DEBUG */
                smb_free_strcnt(bb_stype, bb_cnt);
                return (-1);
            }
        }

        /* free stypes */
        smb_free_strcnt(bb_stype, bb_cnt);
    }

    return (0);
}

void
fm_smb_fmacompat()
{
    int i, j;
    int id;
    int cnt;
    const char **oem_strings = NULL;
    smbs_cnt_t *oemstypes;
    smbios_hdl_t *shp;
    int strcnt;
    int compat = 0;

    /* check for BKS */
    if (x86gentopo_legacy == 1) {
        return;
    }

    shp = ksmbios;
    if (shp == NULL) {
        goto bad;
    }

    /* OEM strings (Type 11) */
    strcnt = smb_cnttypes(shp, SMB_TYPE_OEMSTR);
    if (strcnt == 0)
        goto bad;

    oemstypes = smb_create_strcnt(strcnt);
    if (oemstypes == NULL)
        goto bad;

    oemstypes->type = SMB_TYPE_OEMSTR;
    smb_strcnt(shp, oemstypes);

    for (i = 0; i < oemstypes->count; i++) {
        id = oemstypes->ids[i]->id;
        cnt = smbios_info_strtab(shp, id, 0, NULL);
        if (cnt > 0) {
            oem_strings = kmem_zalloc(sizeof (char *) * cnt,
                KM_SLEEP);
            (void) smbios_info_strtab(shp, id, cnt, oem_strings);

            for (j = 0; j < cnt; j++) {
                if (strncmp(oem_strings[j], SMB_PRMS1,
                    strlen(SMB_PRMS1) + 1) == 0) {
                    kmem_free(oem_strings,
                        sizeof (char *) * cnt);
                    smb_free_strcnt(oemstypes, strcnt);
                    compat = 1;
                    break;
                }
            }
        }
    }

    if (compat == 0) {
        /* didn't find x86pi magic cookie */
        if (oem_strings != NULL)
            kmem_free(oem_strings, sizeof (char *) * cnt);
        smb_free_strcnt(oemstypes, strcnt);
        goto bad;
    }

    /* sanity check SMBIOS structures */
    if (fm_smb_check(shp) == 0)
        return;

bad:
    /* not compatible with x86gentopo; revert to legacy enumeration */
#ifdef  DEBUG
    cmn_err(CE_NOTE,
        "!SMBIOS is not compatible with x86 generic topology.");
    cmn_err(CE_NOTE, "!Invoking legacy x86 topology enumeration.");
#endif  /* DEBUG */
    x86gentopo_legacy = 1;
}

static int
find_matching_apic(smbios_hdl_t *shp, uint16_t proc_id, uint_t strand_apicid)
{
    uint16_t ext_id;
    int i, j;
    smbios_processor_ext_t ep;
    smbs_cnt_t *pstypes;
    int strcnt;

    strcnt = smb_cnttypes(shp, SUN_OEM_EXT_PROCESSOR);
    if (strcnt == 0)
        return (0);

    pstypes = smb_create_strcnt(strcnt);
    if (pstypes == NULL)
        return (0);

    pstypes->type = SUN_OEM_EXT_PROCESSOR;
    smb_strcnt(shp, pstypes);
    for (i = 0; i < pstypes->count; i++) {
        ext_id = pstypes->ids[i]->id;
        (void) smbios_info_extprocessor(shp, ext_id, &ep);
        if (ep.smbpe_processor == proc_id) {
            for (j = 0; j < ep.smbpe_n; j++) {
                if (ep.smbpe_apicid[j] == strand_apicid) {
                    smb_free_strcnt(pstypes, strcnt);
                    return (1);
                }
            }
        }
    }
    smb_free_strcnt(pstypes, strcnt);
    return (0);
}

/*
 * go throught the type 2 structure contained_ids looking for
 * the type 4 which  has strand_apicid == this strand_apicid
 */
static int
find_matching_proc(smbios_hdl_t *shp, uint_t strand_apicid,
    uint16_t bb_id, uint16_t proc_hdl, int is_proc)
{
    int n;
    const smb_struct_t *sp;
    smbios_bboard_t bb;
    uint_t cont_count, cont_len;
    uint16_t cont_id;
    id_t *cont_hdl = NULL;
    int rc;


    (void) smbios_info_bboard(shp, bb_id, &bb);
    cont_count = (uint_t)bb.smbb_contn;
    if (cont_count == 0)
        return (0);

    cont_len = sizeof (id_t);
    cont_hdl = kmem_zalloc(cont_count * cont_len, KM_SLEEP);
    if (cont_hdl == NULL)
        return (0);

    rc = smbios_info_contains(shp, bb_id, cont_count, cont_hdl);
    if (rc > SMB_CONT_MAX) {
        kmem_free(cont_hdl, cont_count * cont_len);
        return (0);
    }
    cont_count = MIN(rc, cont_count);

    for (n = 0; n < cont_count; n++) {
        cont_id = (uint16_t)cont_hdl[n];
        sp = smb_lookup_id(shp, cont_id);
        if (sp->smbst_hdr->smbh_type == SMB_TYPE_PROCESSOR) {
            if (is_proc) {
                if (find_matching_apic(shp, cont_id,
                    strand_apicid)) {
                    kmem_free(cont_hdl,
                        cont_count * cont_len);
                    return (1);
                }
            } else {
                if (cont_id == proc_hdl) {
                    kmem_free(cont_hdl,
                        cont_count * cont_len);
                    return (1);
                }
            }
        }
    }
    if (cont_hdl != NULL)
        kmem_free(cont_hdl, cont_count * cont_len);

    return (0);
}

void
get_bboard_index(smbs_cnt_t *bbstypes, uint_t bb_id, bbindex_t *bb_idx)
{
    int curr_id, tmp_id;
    int i, j, nb;
    bbindex_t tmp_idx;

    for (i = 0; i < MAX_PAIRS; i++)
        tmp_idx.index[i] = 0;

    tmp_idx.count = 0;

    curr_id = bb_id;
    for (nb = bbstypes->count-1, i = 0; nb >= 0; nb--) {
        tmp_id = bbstypes->ids[nb]->id;
        if (tmp_id == curr_id) {
            tmp_idx.index[i] = nb;
            tmp_idx.count++;
            curr_id = bbstypes->ids[nb]->cont_by_id;
            if (curr_id == -1)
                break;
            i++;
        }
    }

    for (i = tmp_idx.count - 1, j = 0; i >= 0; i--) {
        bb_idx->index[j] = tmp_idx.index[i];
        j++;
    }

    bb_idx->count = tmp_idx.count;
}

int
get_chassis_inst(smbios_hdl_t *shp, uint16_t *chassis_inst,
    uint16_t bb_id, int *chcnt)
{
    int ch_strcnt;
    smbs_cnt_t *chstypes;
    uint16_t chassis_id, tmp_id;
    smbios_bboard_t bb;
    int rc = 0;
    int i;

    rc = smbios_info_bboard(shp, bb_id, &bb);
    if (rc != 0) {
        return (-1);
    }

    chassis_id = bb.smbb_chassis;

    ch_strcnt = smb_cnttypes(shp, SMB_TYPE_CHASSIS);

    if (ch_strcnt == 0)
        return (-1);

    chstypes = smb_create_strcnt(ch_strcnt);
    if (chstypes == NULL)
        return (-1);

    chstypes->type = SMB_TYPE_CHASSIS;
    smb_strcnt(shp, chstypes);

    for (i = 0; i < chstypes->count; i++) {
        tmp_id = chstypes->ids[i]->id;
        if (tmp_id == chassis_id) {
            *chassis_inst = chstypes->ids[i]->inst;
            if (chstypes->ids[i]->inst != 0)
                *chcnt = 2;
            else
                *chcnt = 1;
            smb_free_strcnt(chstypes, ch_strcnt);
            return (0);
        }
    }

    smb_free_strcnt(chstypes, ch_strcnt);
    return (-1);
}

int
smb_get_bb_fmri(smbios_hdl_t *shp, nvlist_t *fmri,  uint_t parent,
    smbs_cnt_t *bbstypes)
{
    int rc = 0;
    int i, j, n, cnt;
    int id, index;
    nvlist_t *pairs[MAX_PAIRS];
    smbios_bboard_t bb;
    uint16_t chassis_inst, mch_inst;
    char name[40];
    char idstr[11];
    bbindex_t bb_idx;
    uint16_t bbid;
    int chcnt = 0;

    for (n = 0; n < MAX_PAIRS; n++) {
        bb_idx.index[n] = 0;
        pairs[n] = NULL;
    }
    bb_idx.count = 0;

    get_bboard_index(bbstypes, parent, &bb_idx);

    index = bb_idx.index[0];
    bbid = bbstypes->ids[index]->id;

    rc = get_chassis_inst(shp, &chassis_inst, bbid, &chcnt);

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

    if ((bb_idx.count + chcnt) > MAX_PAIRS) {
        return (-1);
    }

    i = 0;
    if (chcnt > 1) {
        /*
         * create main chassis pair
         */
        pairs[i] = fm_nvlist_create(NULL);
        if (pairs[i] == NULL) {
            return (-1);
        }
        mch_inst = 0;
        (void) snprintf(idstr, sizeof (idstr), "%u", mch_inst);
        if ((nvlist_add_string(pairs[i], FM_FMRI_HC_NAME,
            "chassis") != 0) ||
            (nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr)) != 0) {
            fm_nvlist_destroy(pairs[i], FM_NVA_FREE);
            return (-1);
        }
        i++;
    }

    /*
     * create chassis pair
     */
    pairs[i] = fm_nvlist_create(NULL);
    if (pairs[i] == NULL) {
        for (n = 0; n < MAX_PAIRS; n++) {
            if (pairs[n] != NULL)
                fm_nvlist_destroy(pairs[n], FM_NVA_FREE);
        }
        return (-1);
    }
    (void) snprintf(idstr, sizeof (idstr), "%u", chassis_inst);
    if ((nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, "chassis") != 0) ||
        (nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr) != 0)) {
        for (n = 0; n < MAX_PAIRS; n++) {
            if (pairs[n] != NULL)
                fm_nvlist_destroy(pairs[n], FM_NVA_FREE);
        }
        return (-1);
    }

    for (j = 0, i = chcnt, cnt = chcnt; j < bb_idx.count; j++) {
        index = bb_idx.index[j];
        bbid = bbstypes->ids[index]->id;
        rc =  smbios_info_bboard(shp, bbid, &bb);
        if (rc != 0) {
            rc = -1;
            break;
        }

        pairs[i] = fm_nvlist_create(NULL);
        if (pairs[i] == NULL) {
            rc = -1;
            break;
        }

        id = bbstypes->ids[index]->inst;
        (void) snprintf(idstr, sizeof (idstr), "%u", id);
        (void) strncpy(name, bbd_type[bb.smbb_type].name,
            sizeof (name));
        cnt++;

        if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, name) != 0 ||
            nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr)
            != 0) {
            rc = -1;
            break;
        }
        i++;
    }

    if (rc != -1) {
        if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST,
            pairs, cnt) != 0) {
            rc = -1;
        }
    }

    for (n = 0; n < cnt; n++) {
        if (pairs[n] != NULL)
            fm_nvlist_destroy(pairs[n], FM_NVA_FREE);
    }

    return (rc);
}

/*
 * pass in strand_apic id
 * return chip's bboards list which has strand_apicid == passed
 * in strand_apic id
 */
static nvlist_t *
smb_bboard(uint_t strand_apicid, uint16_t proc_hdl, int is_proc)
{
    smbios_hdl_t *shp;
    smbs_cnt_t *bbstypes;
    int nb;
    int bb_smbid;
    nvlist_t *fmri = NULL;
    int rc = 0;
    int bb_strcnt;

    if (x86gentopo_legacy)
        return (NULL);

    shp = ksmbios;
    if (shp == NULL) {
        goto bad;
    }

    /*
     * Type 2 structs : "base board"
     */
    bb_strcnt = smb_cnttypes(shp, SMB_TYPE_BASEBOARD);
    if (bb_strcnt == 0) {
        goto bad;
    }

    bbstypes = smb_create_strcnt(bb_strcnt);
    if (bbstypes == NULL)  {
        goto bad;
    }

    bbstypes->type = SMB_TYPE_BASEBOARD;
    smb_strcnt(shp, bbstypes);
    smb_bb_contains(shp, bbstypes);

    for (nb = 0; nb < bbstypes->count; nb++) {
        if (bbstypes->ids[nb]->visited) {
            continue;
        }

        bbstypes->ids[nb]->visited = 1;
        bb_smbid = bbstypes->ids[nb]->id;

        /*
         * check if there is a matching  processor under
         * this board. If found, find base board(s) of this proc
         * If proc is not in contained handle of a base board and
         * there is only one base board in the system, treat that base
         * board as the parent of the proc
         */
        if (find_matching_proc(shp, strand_apicid,
            bb_smbid, proc_hdl, is_proc) || (bbstypes->count == 1)) {
            fmri = fm_nvlist_create(NULL);
            if (fmri == NULL) {
                smb_free_strcnt(bbstypes, bb_strcnt);
                goto bad;
            }
            /*
             * find parent by walking the cont_by_id
             */
            rc = smb_get_bb_fmri(shp, fmri, bb_smbid, bbstypes);
            smb_free_strcnt(bbstypes, bb_strcnt);
            if (rc == 0) {
                return (fmri);
            } else
                goto bad;
        }

    }

    smb_free_strcnt(bbstypes, bb_strcnt);
bad:
    /* revert to legacy enumeration */
    x86gentopo_legacy = 1;

    return (NULL);
}

nvlist_t *
fm_smb_bboard(uint_t strand_apicid)
{
    return (smb_bboard(strand_apicid, 0, PROC));
}

int
fm_smb_chipinst(uint_t strand_apicid, uint_t *chip_inst, uint16_t *smbiosid)
{
    int n;
    smbios_hdl_t *shp;
    uint16_t proc_id;
    smbs_cnt_t *pstypes;
    int strcnt;

    if (x86gentopo_legacy)
        return (-1);

    shp = ksmbios;
    if (shp == NULL) {
        goto bad;
    }

    strcnt = smb_cnttypes(shp, SMB_TYPE_PROCESSOR);
    if (strcnt == 0)
        goto bad;

    pstypes = smb_create_strcnt(strcnt);
    if (pstypes == NULL)
        goto bad;

    pstypes->type = SMB_TYPE_PROCESSOR;
    smb_strcnt(shp, pstypes);
    for (n = 0; n < pstypes->count; n++) {
        proc_id = pstypes->ids[n]->id;
        if (find_matching_apic(shp, proc_id, strand_apicid)) {
            *chip_inst = pstypes->ids[n]->inst;
            *smbiosid = pstypes->ids[n]->id;
            smb_free_strcnt(pstypes, strcnt);
            return (0);
        }
    }
    smb_free_strcnt(pstypes, strcnt);
bad:
    /* revert to legacy enumerarion */
    x86gentopo_legacy = 1;

    return (-1);
}

nvlist_t *
fm_smb_mc_bboards(uint_t bdf)
{

    int i;
    smbios_hdl_t *shp;
    uint16_t ext_id;
    smbios_memarray_ext_t em;
    nvlist_t *fmri = NULL;
    smbs_cnt_t *mastypes;
    int strcnt;

    if (x86gentopo_legacy)
        return (NULL);

    shp = ksmbios;
    if (shp == NULL) {
        goto bad;
    }

    strcnt = smb_cnttypes(shp, SUN_OEM_EXT_MEMARRAY);
    if (strcnt == 0)
        goto bad;

    mastypes = smb_create_strcnt(strcnt);
    if (mastypes == NULL)
        goto bad;

    mastypes->type = SUN_OEM_EXT_MEMARRAY;
    smb_strcnt(shp, mastypes);
    for (i = 0; i < mastypes->count; i++) {
        ext_id = mastypes->ids[i]->id;
        (void) smbios_info_extmemarray(shp, ext_id, &em);
        if (em.smbmae_bdf == bdf) {
            fmri = smb_bboard(0, em.smbmae_comp, MC);
            smb_free_strcnt(mastypes, strcnt);
            return (fmri);
        }
    }
    smb_free_strcnt(mastypes, strcnt);
bad:
    /* revert to legacy enumerarion */
    x86gentopo_legacy = 1;

    return (NULL);
}

int
fm_smb_mc_chipinst(uint_t bdf, uint_t *chip_inst) {

    int i, j;
    smbios_hdl_t *shp;
    smbios_memarray_ext_t em;
    uint16_t ext_id, proc_id;
    smbs_cnt_t *mastypes;
    smbs_cnt_t *pstypes;
    int ma_strcnt, p_strcnt;

    if (x86gentopo_legacy)
        return (-1);

    shp = ksmbios;
    if (shp == NULL) {
        goto bad;
    }

    ma_strcnt = smb_cnttypes(shp, SUN_OEM_EXT_MEMARRAY);
    if (ma_strcnt == 0)
        goto bad;

    mastypes = smb_create_strcnt(ma_strcnt);
    if (mastypes == NULL)
        goto bad;

    mastypes->type = SUN_OEM_EXT_MEMARRAY;
    smb_strcnt(shp, mastypes);
    for (i = 0; i < mastypes->count; i++) {
        ext_id = mastypes->ids[i]->id;
        (void) smbios_info_extmemarray(shp, ext_id, &em);
            if (em.smbmae_bdf == bdf) {
            p_strcnt = smb_cnttypes(shp, SMB_TYPE_PROCESSOR);
            if (p_strcnt == 0) {
                smb_free_strcnt(mastypes, ma_strcnt);
                goto bad;
            }

            pstypes = smb_create_strcnt(p_strcnt);
            if (pstypes == NULL) {
                smb_free_strcnt(mastypes, ma_strcnt);
                goto bad;
            }

            pstypes->type = SMB_TYPE_PROCESSOR;
            smb_strcnt(shp, pstypes);
            for (j = 0; j < pstypes->count; j++) {
                proc_id = pstypes->ids[j]->id;
                if (proc_id == em.smbmae_comp) {
                    *chip_inst = pstypes->ids[j]->inst;
                    smb_free_strcnt(mastypes, ma_strcnt);
                    smb_free_strcnt(pstypes, p_strcnt);
                    return (0);
                }
            }
        }
    }
    smb_free_strcnt(mastypes, ma_strcnt);
    smb_free_strcnt(pstypes, p_strcnt);
bad:
    /* revert to legacy enumeration */
    x86gentopo_legacy = 1;

    return (-1);
}