i86pc/x86pi/x86pi.c

	x86pi.c revision 5677a1bfa64862936660af8d84d5b3e4d3835af3
/*
 * 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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * x86 Generic FMA Topology Enumerator
 */


#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <strings.h>
#include <sys/fcntl.h>
#include <fm/topo_mod.h>
#include <fm/topo_hc.h>
#include <sys/systeminfo.h>
#include <sys/smbios.h>
#include <sys/smbios_impl.h>
#include <sys/fm/protocol.h>
#include <x86pi_impl.h>


static int x86pi_enum_start(topo_mod_t *, x86pi_enum_t *);
static int x86pi_enum_gentopo(topo_mod_t *, tnode_t *, smbios_hdl_t *);

/*
 * Entry point called by libtopo when enumeration is required
 */
static topo_enum_f x86pi_enum;  /* libtopo enumeration entry point */

/*
 * Declare the operations vector and information structure used during
 * module registration
 */
static topo_modops_t x86pi_ops =
    { x86pi_enum, NULL };

static topo_modinfo_t   x86pi_modinfo =
    { X86PI_DESC, X86PI_SCHEME, X86PI_VERSION, &x86pi_ops };

/*
 * Used to pass SMBIOS' FM compatibility to the
 * chip enumerator
 */
int x86pi_smbios = 0;

/*
 * Called by libtopo when the topo module is loaded.
 */
int
_topo_init(topo_mod_t *mod, topo_version_t version)
{
    int result;
    char    isa[MAXNAMELEN];

    if (getenv("TOPOX86PIDBG") != NULL) {
        /* Debugging is requested for this module */
        topo_mod_setdebug(mod);
    }
    topo_mod_dprintf(mod, "module initializing.\n");

    if (version != TOPO_VERSION) {
        (void) topo_mod_seterrno(mod, EMOD_VER_NEW);
        topo_mod_dprintf(mod, "incompatible topo version %d\n",
            version);
        return (-1);
    }

    /* Verify that this is a i86pc architecture machine */
    (void) sysinfo(SI_MACHINE, isa, MAXNAMELEN);
    if (strncmp(isa, "i86pc", MAXNAMELEN) != 0) {
        topo_mod_dprintf(mod, "not i86pc architecture: %s\n", isa);
        return (-1);
    }

    result = topo_mod_register(mod, &x86pi_modinfo, TOPO_VERSION);
    if (result < 0) {
        topo_mod_dprintf(mod, "registration failed: %s\n",
            topo_mod_errmsg(mod));
        /* module errno already set */
        return (-1);
    }
    topo_mod_dprintf(mod, "module ready.\n");
    return (0);
}


/*
 * Clean up any data used by the module before it is unloaded.
 */
void
_topo_fini(topo_mod_t *mod)
{
    topo_mod_dprintf(mod, "module finishing.\n");

    /* Unregister from libtopo */
    topo_mod_unregister(mod);
}


/*
 * Enumeration entry point for the x86 Generic topology enumerator
 */
/* ARGSUSED */
static int
x86pi_enum(topo_mod_t *mod, tnode_t *t_parent, const char *name,
    topo_instance_t min, topo_instance_t max, void *pi_private, void *data)
{
    int     result;
    hrtime_t    starttime;
    x86pi_enum_t    x86pi;

    /* Begin enumeration */
    starttime = gethrtime();
    topo_mod_dprintf(mod, "enumeration starting.\n");

    /*
     * Let's do some enumeration.
     */
    bzero(&x86pi, sizeof (x86pi_enum_t));
    x86pi.t_parent = t_parent;
    result = x86pi_enum_start(mod, &x86pi);
    if (result != 0) {
        topo_mod_dprintf(mod, "Enumeration failed.\n");
        return (-1);
    }

    /* Complete enumeration */
    topo_mod_dprintf(mod, "enumeration complete in %lld ms.\n",
        ((gethrtime() - starttime)/MICROSEC));

    /* All done */
    return (result);
}

static int
x86pi_enum_start(topo_mod_t *mod, x86pi_enum_t *x86pi)
{
    int     rv;
    int     complvl = 0;
    smbios_hdl_t    *shp;
    char        *f = "x86pi_enum_start";

    /*
     * Verify BIOS compliance.
     */
    shp = x86pi_smb_open(mod);
    if (shp == NULL) {
        topo_mod_dprintf(mod, "%s: failed to open SMBIOS\n", f);
        complvl = X86PI_NONE;
    } else {
        complvl = x86pi_check_comp(mod, shp);
    }

    topo_mod_dprintf(mod, "%s: SMBIOS x86pi compliance: %s\n", f,
        complvl == X86PI_FULL ? "FULL" : "NONE");

    if (complvl == X86PI_NONE) {
        /* fall back to legacy enumeration */
        topo_mod_dprintf(mod,
            "%s: Calling legacy enumeration\n", f);

        return (topo_mod_enummap(mod, x86pi->t_parent,
            "i86pc-legacy", FM_FMRI_SCHEME_HC));
    }

    x86pi->priv = (void *)shp;
    x86pi_smbios = complvl;

    if (x86pi_hbr_enum_init(mod) < 0) {
        topo_mod_dprintf(mod, "%s: x86pi_hbr_enum_init() failed.\n", f);
        return (-1);
    }

    /*
     * Create the topology.
     */
    fac_done = 0;
    rv = x86pi_enum_gentopo(mod, x86pi->t_parent, shp);

    x86pi_hbr_enum_fini(mod);

    if (rv != 0) {
        return (-1);
    }
    x86pi->mod = mod;

    if (fac_done == 0) {
        (void) topo_mod_enummap(mod, x86pi->t_parent, "chassis",
            FM_FMRI_SCHEME_HC);
        (void) topo_mod_enummap(mod, x86pi->t_parent, "fan",
            FM_FMRI_SCHEME_HC);
        (void) topo_mod_enummap(mod, x86pi->t_parent, "psu",
            FM_FMRI_SCHEME_HC);
    }

    /* All done */
    topo_mod_dprintf(mod, "%s: done.\n", f);
    return (rv);
}

/*
 * Create the i86pc topology
 *
 * If either Type 2 or Type 3 structures have contained elements/handles,
 * walk them creating the topo.
 *
 * If there are no contained elements/handles, build this topo:
 *
 *    Main Chassis
 *      Motherboard
 *        CMP Chip/Core/Strands
 *          Memory Controllers/Memory Devices (DIMMs)
 *        PCIE HostBrige
 *          PCIE Root Complex
 *
 */
static int
x86pi_enum_gentopo(topo_mod_t *mod, tnode_t *t_parent, smbios_hdl_t *shp)
{
    int     rv;
    int     nch, nbb, ncmp, i;
    int     ch_smbid, bb_smbid;
    tnode_t     *chassis_node = NULL;
    tnode_t     *basebd_node = NULL;
    smbs_cnt_t  *smbc;
    tnode_t     *motherchassis_node = NULL;
    tnode_t     *pnode = NULL;
    id_t        psmbid;
    int     notvisited;
    int     bb_count, ch_count;
    int     min, max;
    int     ch_inst = 0;
    int     disk_inst = 0;
    topo_instance_t  hbri = 0, rci = 0;
    smbios_pciexrc_t hbr;
    smbios_port_ext_t export;
    char        *f = "x86pi_enum_gentopo";

    if (t_parent == NULL) {
        topo_mod_dprintf(mod, "%s: NULL parent\n", f);
        return (-1);
    }

    /*
     * "Chassis'"
     */
    /* Type 3 structs */
    stypes[SMB_TYPE_CHASSIS].type = SMB_TYPE_CHASSIS;
    x86pi_smb_strcnt(shp, &stypes[SMB_TYPE_CHASSIS]);

    ch_count = stypes[SMB_TYPE_CHASSIS].count;

    for (nch = 0; nch < ch_count; nch++) {
        topo_mod_dprintf(mod, "%s: found %d chassis\n", f,
            stypes[SMB_TYPE_CHASSIS].count);

        ch_smbid = stypes[SMB_TYPE_CHASSIS].ids[nch].id;

        /*
         * Expect SMBIOS to set the first Chassis Structure to be the
         * parent/mother of all chassis
         */
        if (nch == 0)
            motherchassis_node = chassis_node =
                x86pi_gen_chassis(mod, t_parent, shp,
                ch_smbid, ch_inst++);
        else {
            if (motherchassis_node != NULL)
                chassis_node = x86pi_gen_chassis(mod,
                    motherchassis_node, shp,
                    ch_smbid, ch_inst++);
            else
                chassis_node = x86pi_gen_chassis(mod,
                    t_parent, shp, ch_smbid, ch_inst++);
        }

        if (chassis_node == NULL) {
            topo_mod_dprintf(mod,
                "%s: Failed to create chassis %d\n", f, nch);
            continue;
        }
        stypes[SMB_TYPE_CHASSIS].ids[nch].node = chassis_node;

        /* count SMBIOS extended port connector structures */
        smbc = &stypes[SUN_OEM_EXT_PORT];
        smbc->type = SUN_OEM_EXT_PORT;
        x86pi_smb_strcnt(shp, smbc);

        /* enumerate direct attached SATA disks */
        rv = topo_node_range_create(mod, chassis_node, BAY, 0,
            smbc->count + 1);
        if (rv != 0) {
            topo_mod_dprintf(mod,
                "%s: Failed to create %s range: %s\n",
                f, BAY, topo_mod_errmsg(mod));
            continue;
        }

        for (i = 0; i < smbc->count; i++) {
            if (smbios_info_extport(shp, smbc->ids[i].id,
                &export) != 0) {
                topo_mod_dprintf(mod,
                    "smbios_info_export failed: id = %d\n",
                    (int)smbc->ids[i].id);
                continue;
            }
            if (export.smbporte_chassis != ch_smbid)
                continue;

            /*
             * x86pi_gen_bay:
             *   create "bay" node
             *   call "disk" enum passing in "bay" node
             */
            rv = x86pi_gen_bay(mod, chassis_node, shp,
                &export, disk_inst);
            if (rv != 0)
                topo_mod_dprintf(mod,
                    "Failed to create disk %d\n", i);
            disk_inst++;
        }
    }

    /*
     * "Base Board"
     */
    /* Type 2 structs */
    stypes[SMB_TYPE_BASEBOARD].type = SMB_TYPE_BASEBOARD;
    x86pi_smb_strcnt(shp, &stypes[SMB_TYPE_BASEBOARD]);
    bb_count = notvisited = stypes[SMB_TYPE_BASEBOARD].count;

    for (nbb = 0; nbb < bb_count; nbb++) {
        stypes[SMB_TYPE_BASEBOARD].ids[nbb].visited = 0;
        stypes[SMB_TYPE_BASEBOARD].ids[nbb].con_by_id = 0;
        stypes[SMB_TYPE_BASEBOARD].ids[nbb].node = NULL;
    }
    (void) x86pi_bb_contains(mod, shp);

    min = 0;
    nbb = 0;
    do {
        /*
         * We have reached end of the array due to the
         * parent-child relationship, without visiting all
         * baseboards! so re-iterate..
         * (or)
         * All baseboards are visited and their contained
         * processors are enumerated
         * (and/or)
         * More baseboards pending a visit
         */
        if (nbb > bb_count && notvisited)
            nbb = 0;
        else if (nbb > bb_count && !notvisited)
            break;
        if (stypes[SMB_TYPE_BASEBOARD].ids[nbb].visited ==
            X86PI_VISITED) {
            nbb++;
            continue;
        }

        /*
         * Get the Top-most Parent Baseboard, irrespective
         * of its index in the array of Type-2s
         * If this Baseboard has no Baseboard parents
         * place it under the chassis that contains it
         */
        bb_smbid = x86pi_bb_topparent(shp, nbb, &pnode, &psmbid);
        if (bb_smbid == -1 || pnode == NULL) {
            topo_mod_dprintf(mod,
                "Failed to get BaseBoard node (%d): parent\n",
                nbb);
            return (-1);
        }

        if (stypes[SMB_TYPE_BASEBOARD].ids[nbb].id != bb_smbid) {
            for (int i = 0; i < bb_count; i++) {
                if (bb_smbid ==
                    stypes[SMB_TYPE_BASEBOARD].ids[i].id) {
                    stypes[SMB_TYPE_BASEBOARD].ids[i].\
                        visited = 1;
                    notvisited--;
                    break;
                }
            }
        } else {
            stypes[SMB_TYPE_BASEBOARD].ids[nbb].visited = 1;
            notvisited--;
        }

        basebd_node = x86pi_gen_bboard(mod, pnode, shp,
            bb_smbid, nbb, psmbid);
        if (basebd_node == NULL) {
            topo_mod_dprintf(mod,
                "Failed to create BaseBoard node (%d)\n", nbb);
            nbb++;
            continue;
        }

        stypes[SMB_TYPE_BASEBOARD].ids[nbb].node = basebd_node;
        /*
         * Look for contained handles here and if there are
         * make sure the chip handle below is part of it.
         */
        ncmp = x86pi_bb_getchips(mod, shp, nbb, bb_count);
        if (ncmp > 0) {
            max = min + ncmp - 1;
            /* make sure the chip enum is loaded */
            topo_mod_dprintf(mod, "%s: loading chip enum\n", f);

            if (topo_mod_load(mod, CHIP, TOPO_VERSION) == NULL) {
                topo_mod_dprintf(mod,
                    "%s: Failed to load %s module: %s\n", f,
                    CHIP, topo_strerror(topo_mod_errno(mod)));
            } else {
                /* create node range */
                topo_mod_dprintf(mod,
                    "%s: chip range %d to %d\n",
                    f, min, max);
                rv = topo_node_range_create(mod, basebd_node,
                    CHIP, min, max);
                if (rv != 0) {
                    topo_mod_dprintf(mod,
                        "%s: Failed to create node range: "
                        "%s\n", f,
                        topo_strerror(topo_mod_errno(mod)));
                } else {
                    /* call the chip enumerator */
                    topo_mod_dprintf(mod, "%s: calling"
                        " chip enum\n", f);
                    rv =
                        topo_mod_enumerate(mod, basebd_node,
                        CHIP, CHIP, min, max,
                        &x86pi_smbios);
                    min = max + 1;
                    if (rv != 0)
                        topo_mod_dprintf(mod, "%s:%s"
                            "enumeration failed: \n",
                            f, CHIP);
                }
            }
        }

        /* enumerate the hostbridge node */
        rv = topo_node_range_create(mod, basebd_node, HOSTBRIDGE,
            0, 255);
        if (rv != 0) {
            topo_mod_dprintf(mod,
                "%s: Failed to create %s range: %s\n",
                f, HOSTBRIDGE, topo_mod_errmsg(mod));
            continue;
        }

        smbc = &stypes[SUN_OEM_PCIEXRC];
        smbc->type = SUN_OEM_PCIEXRC;
        x86pi_smb_strcnt(shp, smbc);
        for (i = 0; i < smbc->count; i++) {
            if (smbios_info_pciexrc(shp, smbc->ids[i].id,
                &hbr) != 0) {
                topo_mod_dprintf(mod,
                    "smbios_info_pciexrc failed: "
                    "id = %d\n", (int)smbc->ids[i].id);
                continue;
            }

            if (hbr.smbpcie_bb != bb_smbid)
                continue;
            rv = x86pi_gen_hbr(mod, basebd_node, shp,
                smbc->ids[i].id, hbri, &rci);
            if (rv != 0)
                topo_mod_dprintf(mod,
                    "couldn't create hostbridge=%d\n", hbri);
            hbri++;
        }
        nbb++;

    } while (notvisited);

    return (0);
}