/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2020 Peter Tribble.
 *
 * Serengeti Platform specific functions.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <kstat.h>
#include <string.h>
#include <assert.h>
#include <alloca.h>
#include <libintl.h>
#include <fcntl.h>
#include <varargs.h>

#include <sys/openpromio.h>
#include <sys/sysmacros.h>

#include <sys/serengeti.h>
#include <sys/sgfrutypes.h>

#include <pdevinfo.h>
#include <display.h>
#include <pdevinfo_sun4u.h>
#include <display_sun4u.h>
#include <libprtdiag.h>

#include <config_admin.h>

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN     "SYS_TEST"
#endif

#define SCHIZO_COMPATIBLE       "pci108e,8001"
#define XMITS_COMPATIBLE        "pci108e,8002"

#define ACTIVE          0
#define INACTIVE        1
#define DISPLAY_INFO    40

#define EVNT2STR(e)     ((e) == CFGA_STAT_NONE ? "none" : \
                            (e) == CFGA_STAT_EMPTY ? "empty" : \
                            (e) == CFGA_STAT_DISCONNECTED ? "disconnected" : \
                            (e) == CFGA_STAT_CONNECTED ? "connected" : \
                            (e) == CFGA_STAT_UNCONFIGURED ? "unconfigured" : \
                            (e) == CFGA_STAT_CONFIGURED ? "configured" : \
                            "unknown")

#define COND2STR(c)     ((c) == CFGA_COND_UNKNOWN ? "unknown" : \
                            (c) == CFGA_COND_OK ? "ok" : \
                            (c) == CFGA_COND_FAILING ? "failing" : \
                            (c) == CFGA_COND_FAILED ? "failed" : \
                            (c) == CFGA_COND_UNUSABLE ? "unusable" : \
                            "???")

#define SG_CLK_FREQ_TO_MHZ(x)   (((x) + 500000) / 1000000)

#define MAX_STATUS_LEN          8
#define SG_FAIL                 "fail"
#define SG_DISABLED             "disabled"
#define SG_DEGRADED             "degraded"
#define SG_OK                   "ok"

#define SG_SCHIZO_FAILED        1
#define SG_SCHIZO_GOOD          0

#define DEFAULT_MAX_FREQ        66      /* 66 MHz */
#define PCIX_MAX_FREQ           100     /* 100 MHz */

#define CFG_CPU "::cpu"

#define CFG_SET_FRU_NAME_NODE(str, num) \
{ \
        char tmp_str[MAX_FRU_NAME_LEN]; \
        sprintf(tmp_str, "/N%d", num); \
        strncat(str, tmp_str, sizeof (tmp_str)); \
}

#define CFG_SET_FRU_NAME_CPU_BOARD(str, num) \
{ \
        char tmp_str[MAX_FRU_NAME_LEN]; \
        sprintf(tmp_str, ".%s%d", SG_HPU_TYPE_CPU_BOARD_ID, num); \
        strncat(str, tmp_str, sizeof (tmp_str)); \
}

#define CFG_SET_FRU_NAME_MODULE(str, num) \
{ \
        char tmp_str[MAX_FRU_NAME_LEN]; \
        sprintf(tmp_str, "%s%d", CFG_CPU, num); \
        strncat(str, tmp_str, sizeof (tmp_str)); \
}

extern  int     print_flag;

/*
 * these functions will overlay the symbol table of libprtdiag
 * at runtime (Serengeti systems only)
 */
int     do_prominfo(int syserrlog, char *pgname, int log_flag, int prt_flag);
void    *get_prop_val(Prop *prop);
Prop    *find_prop(Prom_node *pnode, char *name);
char    *get_node_name(Prom_node *pnode);
char    *get_node_type(Prom_node *pnode);
void    add_node(Sys_tree *, Prom_node *);
void    display_pci(Board_node *);
void    display_ffb(Board_node *, int);
void    display_io_cards(struct io_card *list);
void    display_cpu_devices(Sys_tree *tree);
void    display_cpus(Board_node *board);
void    display_diaginfo(int flag, Prom_node *root, Sys_tree *tree,
                struct system_kstat_data *kstats);
void    display_hp_fail_fault(Sys_tree *tree, struct system_kstat_data *kstats);
void    get_failed_parts(void);
int     display_failed_parts(Sys_tree *tree);
void    display_memoryconf(Sys_tree *tree);
void    print_us3_memory_line(int portid, int bank_id, uint64_t bank_size,
            char *bank_status, uint64_t dimm_size, uint32_t intlv, int seg_id);

/* Local Functions */
static void     serengeti_display_hw_revisions(Prom_node *root,
                                                        Board_node *bnode);
static Board_node *serengeti_find_board(Sys_tree *root, int board, int nodeid);
static Board_node *serengeti_insert_board(Sys_tree *root, int board, int nid);
static int      display_schizo_revisions(Board_node *bdlist, int mode);
static void     display_sgsbbc_revisions(Board_node *bdlist);
static void     serengeti_display_board_info(int state);
static void     serengeti_display_board_info_header(int state);
static boolean_t cpu_node_configured(char *const node);
static void display_io_max_bus_speed(struct io_card *p);
static void display_io_slot_info(struct io_card *p);
static void get_slot_name(struct io_card *card, char *slot_name);

/* The bus max freq is determined based on board level in use */
int     board_bus_max_freq = DEFAULT_MAX_FREQ;  /* 66MHz default */

/*
 * Serengeti now uses both the devinfo tree and the OBP tree for it's
 * prtdiag. The devinfo tree is used for getting the HW config of the
 * system and the OBP device tree is used for listing the failed HW
 * in the system. This is because devinfo currently does not include
 * any PROM nodes with a status of 'fail' so we need to go to OBP to
 * get a list of failed HW. We use the tree flag to allow the same code
 * to walk both trees.
 *
 * We really need to look at having a single tree for all platforms!
 */
#define DEVINFO_TREE    1
#define OBP_TREE        2

static int      tree = DEVINFO_TREE;

#ifdef DEBUG
#define D_PRINTFINDENT  printfindent
void
printfindent(int indent, char *fmt, ...)
{
        va_list ap;
        int i = 0;
        for (i = 0; i < indent; i ++)
                printf("\t");

        va_start(ap);
        (void) vprintf(fmt, ap);
        va_end(ap);
}
#else
#define D_PRINTFINDENT
#endif

/*
 * display_pci
 * Display all the PCI IO cards on this board.
 */
void
display_pci(Board_node *board)
{
        struct io_card *card_list = NULL;
        struct io_card card;
        void *value;
        Prom_node *pci;
        Prom_node *card_node;
        Prom_node *pci_bridge_node;
        Prom_node *child_pci_bridge_node;
        char    *slot_name = NULL;      /* info in "slot-names" prop */
        char    *child_name;
        char    *name, *type;
        char    *pname, *ptype;
        char    buf[MAXSTRLEN];
        int     *int_val;
        int     pci_bus;
        int     pci_bridge = 0;
        int     pci_bridge_dev_no;
        char    *slot_name_arr[SG_MAX_SLOTS_PER_IO_BD] = {NULL};
        int     i;
        int     portid;
        int     level = 0;
        int     version, *pversion;
#ifdef DEBUG
        int     slot_name_bits;
#endif

        if (board == NULL)
                return;

        /* Initialize all the common information */
        card.display = TRUE;
        card.board = board->board_num;
        card.node_id = board->node_id;

        /*
         * Search for each schizo and xmits, then find/display all nodes under
         * each schizo and xmits node found.
         */
        for (pci = dev_find_node_by_compatible(board->nodes, SCHIZO_COMPATIBLE);
            pci != NULL;
            pci = dev_next_node_by_compatible(pci, SCHIZO_COMPATIBLE)) {

                /* set max freq for this board */
                board_bus_max_freq = DEFAULT_MAX_FREQ;
                /*
                 * Find out if this is a PCI or cPCI IO Board.
                 * If "enum-impl" property exists in pci node => cPCI.
                 */
                value = get_prop_val(find_prop(pci, "enum-impl"));
                if (value == NULL) {
                        (void) sprintf(card.bus_type, "PCI");
                } else {
                        (void) sprintf(card.bus_type, "cPCI");
                }

                if (strstr((char *)get_prop_val(
                    find_prop(pci, "compatible")), XMITS_COMPATIBLE)) {
                        sprintf(card.notes, "%s", XMITS_COMPATIBLE);
                        /*
                         * With XMITS 3.X and PCI-X mode, the bus speed
                         * can be higher than 66MHZ.
                         */
                        value = (int *)get_prop_val
                            (find_prop(pci, "module-revision#"));
                        if (value) {
                                pversion = (int *)value;
                                version = *pversion;
                                if (version >= 4)
                                        board_bus_max_freq = PCIX_MAX_FREQ;
                        }
                } else if (strstr((char *)get_prop_val(
                    find_prop(pci, "compatible")), SCHIZO_COMPATIBLE))
                        sprintf(card.notes, "%s", SCHIZO_COMPATIBLE);
                else
                        sprintf(card.notes, " ");

                /*
                 * Get slot-name properties from parent node and
                 * store them in an array.
                 */
                value = (char *)get_prop_val(find_prop(pci, "slot-names"));
                if (value != NULL) {
#ifdef DEBUG
                        /* save the 4 byte bitmask */
                        slot_name_bits = *(int *)value;
#endif
                        /* array starts after first int */
                        slot_name_arr[0] = (char *)value + sizeof (int);

                        D_PRINTFINDENT(0, "slot_name_arr[0] is [%s]\n",
                            slot_name_arr[0]);

                        for (i = 1; i < SG_MAX_SLOTS_PER_IO_BD; i++) {
                                slot_name_arr[i] = (char *)slot_name_arr[i - 1]
                                    + strlen(slot_name_arr[i - 1]) +1;

                        D_PRINTFINDENT(0, "slot_name_arr[%d] is [%s]\n", i,
                            slot_name_arr[i]);

                        }
                }

                /*
                 * Search for Children of this node ie. Cards.
                 * Note: any of these cards can be a pci-bridge
                 *      that itself has children. If we find a
                 *      pci-bridge we need to handle it specially.
                 *
                 *      There can now be the condition of a pci-bridge
                 *      being the child of a pci-bridge which create a
                 *      two levels of pci-bridges.  This special condition
                 *      needs to be handled as well.  The variable level
                 *      is used to track the depth of the tree.  This
                 *      variable is then used to find instances of this case.
                 */
                level = 0;
                card_node = pci->child;
                while (card_node != NULL) {
                        pci_bridge = 0;

                        /* If it doesn't have a name, skip it */
                        name = (char *)get_prop_val(
                            find_prop(card_node, "name"));
                        if (name == NULL) {
                                card_node = card_node->sibling;
                                continue;
                        }
                        D_PRINTFINDENT(level, "NAME is %s\n", name);

                        type = (char *)get_prop_val(
                            find_prop(card_node, "device_type"));

                        /*
                         * get dev# and func# for this card from the
                         * 'reg' property.
                         */
                        int_val = (int *)get_prop_val(
                            find_prop(card_node, "reg"));
                        if (int_val != NULL) {
                                card.dev_no = (((*int_val) & 0xF800) >> 11);
                                card.func_no = (((*int_val) & 0x700) >> 8);
                        } else {
                                card.dev_no = -1;
                                card.func_no = -1;
                        }

                        /*
                         * If this is a pci-bridge, then store it's dev#
                         * as it's children nodes need this to get their slot#.
                         * We set the pci_bridge flag so that we know we are
                         * looking at a pci-bridge node. This flag gets reset
                         * every time we enter this while loop.
                         */

                        /*
                         * Check for a PCI-PCI Bridge for PCI and cPCI
                         * IO Boards using the name and type properties.
                         *
                         * If level is greater then 0, then check the parent
                         * node to see if it was also a pci-bridge.  We do not
                         * this when level is 0 as this will see the schizo or
                         * xmits device as a pci-bridge node.  This will mess
                         * up the slot number of child nodes.
                         */
                        if ((type != NULL) &&
                            (strncmp(name, "pci", 3) == 0) &&
                            (strcmp(type, "pci") == 0)) {
                                if (level > 0) {
                                        pname = (char *)get_prop_val(
                                            find_prop(card_node->parent,
                                            "name"));
                                        ptype = (char *)get_prop_val(
                                            find_prop(card_node->parent,
                                            "device_type"));

                                        if ((ptype != NULL) &&
                                            (pname != NULL) &&
                                            (strncmp(pname, "pci", 3) == 0) &&
                                            (strcmp(ptype, "pci") == 0)) {
                                                child_pci_bridge_node =
                                                    card_node;
                                        } else {
                                                pci_bridge_dev_no = card.dev_no;
                                                pci_bridge_node = card_node;
                                        }
                                } else {
                                        pci_bridge_dev_no = card.dev_no;
                                        pci_bridge_node = card_node;
                                }
                                pci_bridge = TRUE;

                                D_PRINTFINDENT(level,
                                    "pci_bridge_dev_no is [%d]\n",
                                    pci_bridge_dev_no);
                        }

                        /*
                         * Get slot-names property from slot_names_arr.
                         * If we are the child of a pci_bridge we use the
                         * dev# of the pci_bridge as an index to get
                         * the slot number. We know that we are a child of
                         * a pci-bridge if our parent is the same as the last
                         * pci_bridge node found above.
                         */
                        if (type)
                                D_PRINTFINDENT(level,
                                    "*** name is [%s] - type is [%s]\n",
                                    name, type);
                        else
                                D_PRINTFINDENT(level,
                                    "*** name is [%s]\n", name);

                        if (card.dev_no != -1) {
                                /*
                                 * We compare this cards parent node with the
                                 * pci_bridge_node to see if it's a child.
                                 */
                                if (((level > 0) &&
                                    (card_node->parent->parent ==
                                    pci_bridge_node)) ||
                                    (card_node->parent == pci_bridge_node)) {
                                        /* use dev_no of pci_bridge */
                                        D_PRINTFINDENT(level,
                                            "   pci_bridge_dev_no is [%d]\n",
                                            pci_bridge_dev_no);

                                        slot_name =
                                            slot_name_arr[pci_bridge_dev_no -1];
                                } else {
                                        /* use cards own dev_no */
                                        D_PRINTFINDENT(level,
                                            "    card.dev_no is [%d]\n",
                                            card.dev_no);

                                        slot_name =
                                            slot_name_arr[card.dev_no - 1];
                                }

                                get_slot_name(&card, slot_name);

                        } else {
                                (void) sprintf(card.slot_str, "%c", '-');
                        }

                        /*
                         * Get the portid of the schizo and xmits that this card
                         * lives under.
                         */
                        portid = -1;
                        value = get_prop_val(find_prop(pci, "portid"));
                        if (value != NULL) {
                                portid = *(int *)value;
                        }
                        card.schizo_portid = portid;

#ifdef DEBUG
                        (void) sprintf(card.notes, "%s portid [%d] dev_no[%d]"
                            " slot_name[%s] name_bits[%d]",
                            card.notes,
                            portid,
                            card.dev_no, slot_name,
                            slot_name_bits);
#endif

                        /*
                         * Find out whether this is PCI bus A or B
                         * using the 'reg' property.
                         */
                        int_val = (int *)get_prop_val
                            (find_prop(pci, "reg"));

                        if (int_val != NULL) {
                                int_val ++; /* skip over first integer */
                                pci_bus = ((*int_val) & 0x7f0000);
                                if (pci_bus == 0x600000)
                                        card.pci_bus = 'A';
                                else if (pci_bus == 0x700000)
                                        card.pci_bus = 'B';
                                else
                                        card.pci_bus = '-';
                        } else {
                                card.pci_bus = '-';
                        }


                        /*
                         * Check for failed status.
                         */
                        if (node_status(card_node, SG_FAIL))
                                strncpy(card.status, SG_FAIL,
                                    sizeof (SG_FAIL));
                        else if (node_status(card_node, SG_DISABLED))
                                strncpy(card.status, SG_DISABLED,
                                    sizeof (SG_DISABLED));
                        else
                                strncpy(card.status, SG_OK,
                                    sizeof (SG_OK));

                        /* Get the model of this card */
                        value = get_prop_val(find_prop(card_node, "model"));
                        if (value == NULL)
                                card.model[0] = '\0';
                        else {
                                (void) sprintf(card.model, "%s",
                                    (char *)value);
                                /* Skip sgsbbc nodes, they are not cards */
                                if (strcmp(card.model, "SUNW,sgsbbc") == 0) {
                                        card_node = card_node->sibling;
                                        continue;
                                }
                        }

                        /*
                         * Check if further processing is necessary to display
                         * this card uniquely.
                         */
                        distinguish_identical_io_cards(name, card_node, &card);

                        /*
                         * The card may have a "clock-frequency" but we
                         * are not interested in that. Instead we get the
                         * "clock-frequency" of the PCI Bus that the card
                         * resides on. PCI-A can operate at 33Mhz or 66Mhz
                         * depending on what card is plugged into the Bus.
                         * PCI-B always operates at 33Mhz.
                         *
                         */
                        int_val = get_prop_val(find_prop(pci,
                            "clock-frequency"));
                        if (int_val != NULL) {
                                card.freq = SG_CLK_FREQ_TO_MHZ(*int_val);
                        } else {
                                card.freq = -1;
                        }

                        /*
                         * Figure out how we want to display the name
                         */
                        value = get_prop_val(find_prop(card_node,
                            "compatible"));
                        if (value != NULL) {
                                /* use 'name'-'compatible' */
                                (void) sprintf(buf, "%s-%s", name,
                                    (char *)value);
                        } else {
                                /* just use 'name' */
                                (void) sprintf(buf, "%s", name);
                        }
                        name = buf;

                        /*
                         * If this node has children, add the device_type
                         * of the child to the name value of this card.
                         */
                        child_name = (char *)get_node_name(card_node->child);
                        if ((card_node->child != NULL) &&
                            (child_name != NULL)) {
                                value = get_prop_val(find_prop(card_node->child,
                                    "device_type"));
                                if (value != NULL) {
                                        /* add device_type of child to name */
                                        (void) sprintf(card.name, "%s/%s (%s)",
                                            name, child_name,
                                            (char *)value);
                                } else {
                                        /* just add childs name */
                                        (void) sprintf(card.name, "%s/%s", name,
                                            child_name);
                                }
                        } else {
                                (void) sprintf(card.name, "%s", (char *)name);
                        }

                        /*
                         * If this is a pci-bridge, then add the word
                         * 'pci-bridge' to it's model.
                         */
                        if (pci_bridge) {
                                if (strlen(card.model) == 0)
                                        (void) sprintf(card.model,
                                            "%s", "pci-bridge");
                                else
                                        (void) sprintf(card.model,
                                            "%s/pci-bridge", card.model);
                        }

                        /* insert this card in the list to be displayed later */
                        card_list = insert_io_card(card_list, &card);

                        /*
                         * If we are dealing with a pci-bridge, we need to move
                         * down to the children of this bridge if there are any.
                         *
                         * If we are not, we are either dealing with a regular
                         * card (in which case we move onto the sibling of this
                         * card) or we are dealing with a child of a pci-bridge
                         * (in which case we move onto the child's siblings or
                         * if there are no more siblings for this child, we
                         * move onto the parents siblings).
                         *
                         * Once we reach the last child node of a pci-bridge,
                         * we need to back up the tree to the parents sibling
                         * node.  If our parent has no more siblings, we need
                         * to check our grand parent for siblings.
                         *
                         * If we have no more siblings, we simply point to
                         * to the child's sibling which moves us onto the next
                         * bus leaf.
                         *
                         * The variable level gets adjusted on some of the
                         * conditions as this is used to track level within
                         * the tree we have reached.
                         */
                        if (pci_bridge) {
                                if (card_node->child != NULL) {
                                        level++;
                                        card_node = card_node->child;
                                } else
                                        card_node = card_node->sibling;
                        } else {
                                if ((card_node->parent == pci_bridge_node) &&
                                    (card_node->sibling == NULL)) {
                                        card_node = pci_bridge_node->sibling;
                                        if (level > 0)
                                                level--;
                                } else if ((card_node->parent ==
                                    child_pci_bridge_node) &&
                                    (card_node->parent->parent ==
                                    pci_bridge_node)) {
                                        if ((child_pci_bridge_node->sibling) &&
                                            (card_node->sibling == NULL)) {
                                                card_node =
                                                    child_pci_bridge_node-> \
                                                    sibling;
                                        if (level > 0)
                                                level--;
                                        } else if ((pci_bridge_node->sibling) &&
                                            (card_node->sibling == NULL)) {
                                                card_node =
                                                    pci_bridge_node->sibling;
                                                if (level > 1)
                                                        level = level - 2;
                                                else if (level > 0)
                                                        level--;
                                        } else
                                                card_node = card_node->sibling;
                                } else
                                        card_node = card_node->sibling;
                        }
                } /* end-while */
        } /* end-for */

        display_io_cards(card_list);
        free_io_cards(card_list);
}

/*
 * display_ffb
 *
 * There are no FFB's on a Serengeti, however in the generic library,
 * the display_ffb() function is implemented so we have to define an
 * empty function here.
 */
/*ARGSUSED0*/
void
display_ffb(Board_node *board, int table)
{}

static void
serengeti_display_board_info_header(int state)
{
        char *fmt = "%-9s  %-11s  %-12s  %-12s  %-9s %-40s\n";

        log_printf("\n", 0);
        log_printf("=========================", 0);
        if (state == ACTIVE)
                log_printf(dgettext(TEXT_DOMAIN,
                    " Active Boards for Domain "), 0);
        else
                log_printf(dgettext(TEXT_DOMAIN,
                    " Available Boards/Slots for Domain "), 0);
        log_printf("===========================", 0);
        log_printf("\n", 0);
        log_printf("\n", 0);

        log_printf(fmt, "", "Board", "Receptacle", "Occupant", "", "", 0);

        log_printf(fmt, "FRU Name", "Type", "Status", "Status",
            "Condition", "Info", 0);

        log_printf(fmt, "---------", "-----------", "-----------",
            "------------", "---------",
            "----------------------------------------", 0);
}

static void
serengeti_display_board_info(int state)
{
        int i, z, ret;
        int nlist = 0;
        int available_board_count = 0;
        struct cfga_list_data *board_cfg = NULL;
        char *err_string = NULL;
        char tmp_id[CFGA_LOG_EXT_LEN + 1];
        char tmp_info[DISPLAY_INFO + 1];
        const char listops[] = "class=sbd";
        struct cfga_list_data dat;
        cfga_flags_t flags = 0;

        ret = config_list_ext(0, NULL, &board_cfg, &nlist,
            NULL, listops,
            &err_string, flags);

        if (ret == CFGA_OK) {
                serengeti_display_board_info_header(state);
                for (i = 0; i < nlist; i++) {
                        dat = board_cfg[i];

                        if ((state != ACTIVE) &&
                            (dat.ap_o_state == CFGA_STAT_CONFIGURED))
                                continue;
                        else if ((state == ACTIVE) &&
                            (dat.ap_o_state != CFGA_STAT_CONFIGURED))
                                continue;
                        if (state == INACTIVE)
                                available_board_count++;

                        memcpy(tmp_id, dat.ap_log_id, CFGA_LOG_EXT_LEN);
                        tmp_id[CFGA_LOG_EXT_LEN] = '\0';
                        for (z = 0; z < strlen(tmp_id); z++) {
                                if (tmp_id[z] == '.')
                                        tmp_id[z] = '/';
                        }
                        log_printf("/%-8s  ", tmp_id, 0);
                        log_printf("%-11s  ", dat.ap_type, 0);

                        log_printf("%-12s  ", EVNT2STR(dat.ap_r_state), 0);
                        log_printf("%-12s  ", EVNT2STR(dat.ap_o_state), 0);
                        log_printf("%-8s  ", COND2STR(dat.ap_cond), 0);

                        memcpy(tmp_info, dat.ap_info, DISPLAY_INFO);
                        tmp_info[DISPLAY_INFO - 1] = '\0';
                        if (strlen(tmp_info) >= (DISPLAY_INFO - 1))
                                tmp_info[DISPLAY_INFO - 2] = '+';
                        log_printf("%-*s\n", (DISPLAY_INFO - 1), tmp_info, 0);
                }
                if ((state == INACTIVE) &&
                    (available_board_count == 0)) {
                        log_printf(dgettext(TEXT_DOMAIN,
                            "There are currently no "
                            "Boards/Slots available "
                            "to this Domain\n"), 0);
                }
        }
        if (board_cfg)
                free(board_cfg);
        if (err_string)
                free(err_string);
}

/*
 * add_node
 *
 * This function adds a board node to the board structure where that
 * that node's physical component lives.
 */
void
add_node(Sys_tree *root, Prom_node *pnode)
{
        int     board   = -1;
        int     portid  = -1;
        int     nodeid  = -1;

        void            *value  = NULL;
        Board_node      *bnode  = NULL;
        Prom_node       *p      = NULL;
        char            *type;

        /* Get the board number of this board from the portid prop */
        if ((value = get_prop_val(find_prop(pnode, "portid"))) == NULL) {
                if ((type = get_node_type(pnode)) && (strcmp(type, "cpu") == 0))
                        value =
                            get_prop_val(find_prop(pnode->parent, "portid"));
        }
        if (value != NULL) {
                portid = *(int *)value;
        }

        nodeid  = SG_PORTID_TO_NODEID(portid);
        board   = SG_PORTID_TO_BOARD_NUM(portid);

        /* find the board node with the same board number */
        if ((bnode = serengeti_find_board(root, board, nodeid)) == NULL) {
                bnode = serengeti_insert_board(root, board, nodeid);
        }

        /* now attach this prom node to the board list */
        /* Insert this node at the end of the list */
        pnode->sibling = NULL;
        if (bnode->nodes == NULL)
                bnode->nodes = pnode;
        else {
                p = bnode->nodes;
                while (p->sibling != NULL)
                        p = p->sibling;
                p->sibling = pnode;
        }
}



/*
 * Print out all the io cards in the list.  Also print the column
 * headers if told to do so.
 */
void
display_io_cards(struct io_card *list)
{
        char    *fmt = "%-10s  %-4s %-4s %-4s %-4s %-4s %-4s %-4s %-4s %-34s";

        static int banner = FALSE; /* Have we printed the column headings? */
        struct io_card *p;

        if (list == NULL)
                return;

        if (banner == FALSE) {
                log_printf(fmt, "", "", "", "", "", "Bus", "Max",
                    "", "", "", 0);
                log_printf("\n", 0);
                log_printf(fmt, "", "IO", "Port", "Bus", "", "Freq", "Bus",
                    "Dev,", "", "", 0);
                log_printf("\n", 0);
                log_printf(fmt, "FRU Name", "Type", " ID", "Side", "Slot",
                    "MHz", "Freq", "Func", "State", "Name", 0);
#ifdef DEBUG
                log_printf("Model                   Notes\n", 0);
#else
                log_printf("Model\n", 0);
#endif

                log_printf(fmt, "----------", "----", "----", "----", "----",
                    "----", "----", "----", "-----",
                    "--------------------------------", 0);
#ifdef DEBUG
                log_printf("----------------------  ", 0);
#endif
                log_printf("----------------------\n", 0);
                banner = TRUE;
        }

        for (p = list; p != NULL; p = p -> next) {

                display_io_slot_info(p);

                display_io_max_bus_speed(p);

                log_printf("\n", 0);
        }
}

static void
display_io_slot_info(struct io_card *p)
{
        char    fru_name[MAX_FRU_NAME_LEN] = "";

        SG_SET_FRU_NAME_NODE(fru_name, p->node_id);
        SG_SET_FRU_NAME_IO_BOARD(fru_name, p->board);
        SG_SET_FRU_NAME_MODULE(fru_name, p->schizo_portid % 2);

        log_printf("%-8s  ", fru_name, 0);
        log_printf("%-4s  ", p->bus_type, 0);
        log_printf("%-3d  ", p->schizo_portid, 0);
        log_printf("%c    ", p->pci_bus, 0);
        log_printf("%-1s    ", p->slot_str, 0);
        log_printf("%-3d ", p->freq, 0);
}

#define BUS_SPEED_PRINT(speed)  log_printf(" %d  ", speed, 0)

static void
display_io_max_bus_speed(struct io_card *p)
{
        int speed = board_bus_max_freq;

        switch (p->pci_bus) {
        case 'A':
                BUS_SPEED_PRINT(speed);
                break;
        case 'B':
                if (strcmp(p->notes, XMITS_COMPATIBLE) == 0) {
                        if ((strncmp(p->slot_str, "1", 1) == 0) ||
                            (strncmp(p->slot_str, "0", 1) == 0))
                                BUS_SPEED_PRINT(33);
                        else
                                BUS_SPEED_PRINT(speed);
                } else
                        BUS_SPEED_PRINT(33);
                break;
        default:
                log_printf("  -  ", 0);
                break;
        }

        log_printf("%-1d,%-1d  ", p->dev_no, p->func_no, 0);
        log_printf("%-5s ", p->status, 0);

        log_printf("%-32.32s%c ", p->name,
            ((strlen(p->name) > 32) ? '+' : ' '), 0);
        log_printf("%-22.22s%c", p->model,
            ((strlen(p->model) > 22) ? '+' : ' '), 0);
#ifdef  DEBUG
        log_printf(" %s", p->notes, 0);
#endif  /* DEBUG */
}

void
display_cpu_devices(Sys_tree *tree)
{
        Board_node *bnode;

        /* printf formats */
        char    *fmt1 = "%-10s  %-7s  %-4s  %-4s  %-7s  %-4s\n";

        /*
         * Display the table header for CPUs . Then display the CPU
         * frequency, cache size, and processor revision of all cpus.
         */
        log_printf("\n", 0);
        log_printf("=========================", 0);
        log_printf(" CPUs ", 0);
        log_printf("=========================", 0);
        log_printf("======================", 0);
        log_printf("\n", 0);
        log_printf("\n", 0);

        log_printf(fmt1, "", "CPU ", "Run", " E$", "CPU", "CPU", 0);

        log_printf(fmt1, "FRU Name", "ID ", "MHz", " MB",
            "Impl.", "Mask", 0);

        log_printf(fmt1, "----------", "-------", "----", "----",
            "-------",  "----", 0);

        /* Now display all of the cpus on each board */
        bnode = tree->bd_list;
        while (bnode != NULL) {
                display_cpus(bnode);
                bnode = bnode->next;
        }

        log_printf("\n", 0);
}

static boolean_t
cpu_node_configured(char *const node)
{
        int ret, i;
        int nlist = 0;
        boolean_t rv;
        char *err_string = NULL;
        struct cfga_list_data *statlist = NULL;
        struct cfga_list_data dat;
        cfga_flags_t flags = CFGA_FLAG_LIST_ALL;

        if (node == NULL)
                return (FALSE);

        ret = config_list_ext(1, &node, &statlist, &nlist,
            NULL, NULL, &err_string, flags);

        if (ret == CFGA_OK) {
                dat = statlist[0];

                if (dat.ap_o_state == CFGA_STAT_CONFIGURED)
                        rv = TRUE;
                else
                        rv = FALSE;
        } else {
                rv = FALSE;
        }
        if (statlist)
                free(statlist);
        if (err_string)
                free(err_string);
        return (rv);
}

/*
 * Display the CPUs present on this board.
 */
void
display_cpus(Board_node *board)
{
        Prom_node *cpu;
        uint_t freq;     /* CPU clock frequency */
        int ecache_size; /* External cache size */
        int board_num = board->board_num;
        int *mid;
        int *impl;
        int *mask;
        int decoded_mask;
        int *coreid;
        int mid_prev = -1;
        int ecache_size_prev = 0;
        char fru_prev[MAX_FRU_NAME_LEN] = "";

        /*
         * display the CPUs' operating frequency, cache size, impl. field
         * and mask revision.
         */
        for (cpu = dev_find_type(board->nodes, "cpu"); cpu != NULL;
            cpu = dev_next_type(cpu, "cpu")) {
                char    fru_name[MAX_FRU_NAME_LEN] = "";
                char    cfg_fru_name[MAX_FRU_NAME_LEN] = "";

                mid = (int *)get_prop_val(find_prop(cpu, "portid"));
                if (mid == NULL)
                        mid = (int *)get_prop_val(find_prop(cpu, "cpuid"));
                freq = SG_CLK_FREQ_TO_MHZ(get_cpu_freq(cpu));
                ecache_size = get_ecache_size(cpu);
                impl = (int *)get_prop_val(find_prop(cpu, "implementation#"));
                mask = (int *)get_prop_val(find_prop(cpu, "mask#"));

                /* Do not display a failed CPU node */
                if ((impl == NULL) || (freq == 0) || (node_failed(cpu)))
                        continue;

                /* FRU Name */
                SG_SET_FRU_NAME_NODE(fru_name, board->node_id);

                SG_SET_FRU_NAME_CPU_BOARD(fru_name, board_num);
                SG_SET_FRU_NAME_MODULE(fru_name, *mid % 4);

                if (CPU_IMPL_IS_CMP(*impl)) {
                        coreid = (int *)get_prop_val(find_prop(cpu,
                            "reg"));
                        if (coreid == NULL) {
                                continue;
                        }

                        /*
                         * The assumption is made that 2 cores will always be
                         * listed together in the device tree. If either core
                         * is "bad" then the FRU will not be listed.
                         *
                         * As display_cpus on Serengeti does actually process
                         * all cpu's per board a copy of the fru_name needs to
                         * be made as the following core may not be its
                         * sibling. If this is the case it is assumed that a
                         * sibling core has failed, so the fru should not be
                         * displayed.
                         *
                         * For the first instance of a core, fru_prev is
                         * expected to be empty.  The current values are then
                         * stored and the next board->nodes is processed. If
                         * this is a sibling core, the ecache size it tallied
                         * and the  previous value reset and processing
                         * continues.
                         *
                         * If the following core is not a sibling, the new
                         * values are stored and the next board->nodes is
                         * processed.
                         */
                        if (strncmp(fru_prev, "", sizeof (fru_prev)) == 0) {
                                strncpy(fru_prev, fru_name, sizeof (fru_name));
                                mid_prev = *mid;
                                ecache_size_prev = ecache_size;
                                continue;
                        } else {
                                if (strncmp(fru_name, fru_prev,
                                    sizeof (fru_prev)) == 0) {
                                        /*
                                         * Jaguar has a split E$, so the size
                                         * for both cores must be added together
                                         * to get the total size for the entire
                                         * chip.
                                         *
                                         * Panther E$ (L3) is logically shared,
                                         * so the total size is equal to the
                                         * core size.
                                         */
                                        if (IS_JAGUAR(*impl)) {
                                                ecache_size += ecache_size_prev;
                                        }

                                        ecache_size_prev = 0;
                                        strncpy(fru_prev, "",
                                            sizeof (fru_prev));
                                } else {
                                        mid_prev = *mid;
                                        ecache_size_prev = ecache_size;
                                        strncpy(fru_prev, fru_name,
                                            sizeof (fru_name));
                                        continue;
                                }
                        }
                }

                /*
                 * If cpu is not configured, do not display it
                 */
                CFG_SET_FRU_NAME_NODE(cfg_fru_name, board->node_id);
                CFG_SET_FRU_NAME_CPU_BOARD(cfg_fru_name, board_num);
                CFG_SET_FRU_NAME_MODULE(cfg_fru_name, *mid % 4);

                if (!(cpu_node_configured(cfg_fru_name))) {
                        continue;
                }


                log_printf("%-10s  ", fru_name, 0);

                /* CPU MID */
                if (CPU_IMPL_IS_CMP(*impl)) {
                        log_printf("%3d,%3d ", mid_prev, *mid, 0);
                        mid_prev = -1;
                } else
                        log_printf("%3d     ", *mid, 0);

                /* Running frequency */
                log_printf(" %4u  ", freq, 0);

                /* Ecache size */
                if (ecache_size == 0)
                        log_printf("%3s  ", "N/A", 0);
                else
                        log_printf("%4.1f  ",
                            (float)ecache_size / (float)(1<<20),
                            0);

                /* Implementation */
                if (impl == NULL) {
                        log_printf("%6s  ", " N/A", 0);
                } else {
                        switch (*impl) {
                        case CHEETAH_IMPL:
                                log_printf("%-7s ", "US-III", 0);
                                break;
                        case CHEETAH_PLUS_IMPL:
                                log_printf("%-7s ", "US-III+", 0);
                                break;
                        case JAGUAR_IMPL:
                                log_printf("%-7s ", "US-IV", 0);
                                break;
                        case PANTHER_IMPL:
                                log_printf("%-7s ", "US-IV+", 0);
                                break;
                        default:
                                log_printf("%-7x ", *impl, 0);
                                break;
                        }
                }

                /* CPU Mask */
                if (mask == NULL) {
                        log_printf(" %3s   ", "N/A", 0);
                } else {
                        if (IS_CHEETAH(*impl))
                                decoded_mask = REMAP_CHEETAH_MASK(*mask);
                        else
                                decoded_mask = *mask;

                        log_printf(" %d.%d   ",
                            (decoded_mask >> 4) & 0xf,
                            decoded_mask & 0xf, 0);
                }

                log_printf("\n", 0);
        }
}


/*ARGSUSED3*/
void
display_diaginfo(int flag, Prom_node *root, Sys_tree *tree,
    struct system_kstat_data *kstats)
{
        log_printf("\n", 0);
        log_printf("=========================", 0);
        log_printf(dgettext(TEXT_DOMAIN, " Hardware Failures "), 0);
        log_printf("==================================", 0);
        log_printf("\n", 0);

        /*
         * Get a list of failed parts (ie. devices with a status of
         * 'fail') from the OBP device tree and display them.
         */
        get_failed_parts();

        /* return unless -v option specified */
        if (!flag) {
                log_printf("\n", 0);
                return;
        }

        /*
         * display time of latest powerfail. Not all systems
         * have this capability. For those that do not, this
         * is just a no-op.
         */
        disp_powerfail(root);

        /* Print the PROM revisions here */
        serengeti_display_hw_revisions(root, tree->bd_list);
}

/*
 * local functions -  functions that are only needed inside this library
 */

static void
serengeti_display_hw_revisions(Prom_node *root, Board_node *bdlist)
{
        Prom_node       *pnode;
        char            *value;

        /* Print the header */
        log_printf("\n", 0);
        log_printf("=========================", 0);
        log_printf(dgettext(TEXT_DOMAIN, " HW Revisions "), 0);
        log_printf("=======================================", 0);
        log_printf("\n", 0);
        log_printf("\n", 0);

        /* Display Prom revision header */
        log_printf("System PROM revisions:\n", 0);
        log_printf("----------------------\n", 0);

        /*
         * Display OBP version info
         */
        pnode = dev_find_node(root, "openprom");
        if (pnode != NULL) {
                value = (char *)get_prop_val(find_prop(pnode, "version"));
                log_printf("%s\n\n", value, 0);
        } else {
                log_printf("OBP ???\n\n", value, 0);
        }

        /*
         * Display ASIC revisions
         */
        log_printf("IO ASIC revisions:\n", 0);
        log_printf("------------------\n", 0);

        log_printf("                            Port\n", 0);
        log_printf("FRU Name    Model            ID    Status", 0);
#ifdef DEBUG
        log_printf("   Version  Notes\n", 0);
#else
        log_printf("   Version\n", 0);
#endif
        /* ---------FRU Name--Model-----------Port-Status */
        log_printf("----------- --------------- ---- ---------- "
#ifdef DEBUG
            "-------  "
#endif
            "-------\n", 0);
        /*
         * Display SCHIZO version info
         */
        display_schizo_revisions(bdlist, SG_SCHIZO_GOOD);

        /*
         * Display sgsbbc version info
         */
        display_sgsbbc_revisions(bdlist);
}

/*
 * This function displays Schizo and Xmits revision of boards
 */
static int
display_schizo_revisions(Board_node *bdlist, int mode)
{
        Prom_node       *pnode;
        int             *int_val;
        int             portid;
        int             prev_portid = -1;
        char            *model;
        char            *status_a, *status_b;
        char            status[MAX_STATUS_LEN];
        int             version;
        int             node_id;
#ifdef DEBUG
        uint32_t        a_notes, b_notes;
#endif
        int             pci_bus;
        /*
         * rv is used when mode is set to SG_SCHIZO_FAILED.
         * We need to signal if a failure is found so that
         * the correct headers/footers can be printed.
         *
         * rv = 1 implies a failed/disavled schizo device
         * rv = 0 implies all other cases
         */
        int             rv = 0;
        Board_node      *bnode;
        void            *value;

        bnode = bdlist;
        while (bnode != NULL) {
                /*
                 * search this board node for all Schizos
                 */
                for (pnode = dev_find_node_by_compatible(bnode->nodes,
                    SCHIZO_COMPATIBLE); pnode != NULL;
                    pnode = dev_next_node_by_compatible(pnode,
                    SCHIZO_COMPATIBLE)) {

                        char    fru_name[MAX_FRU_NAME_LEN] = "";

                        /*
                         * get the reg property to determine
                         * whether we are looking at side A or B
                         */
                        int_val = (int *)get_prop_val
                            (find_prop(pnode, "reg"));
                        if (int_val != NULL) {
                                int_val ++; /* second integer in array */
                                pci_bus = ((*int_val) & 0x7f0000);
                        }

                        /* get portid */
                        int_val = (int *)get_prop_val
                            (find_prop(pnode, "portid"));
                        if (int_val == NULL)
                                continue;

                        portid = *int_val;

                        /*
                         * If this is a new portid and it is PCI bus B,
                         * we skip onto the PCI bus A. (PCI-A and PCI-B share
                         * the same portid)
                         */
                        if ((portid != prev_portid) && (pci_bus == 0x700000)) {
                                prev_portid = portid;
                                /* status */
                                status_b = (char *)get_prop_val
                                    (find_prop(pnode, "status"));
#ifdef DEBUG
                                b_notes = pci_bus;
#endif
                                continue; /* skip to the next schizo */
                        }

                        /*
                         * This must be side A of the same Schizo.
                         * Gather all its props and display them.
                         */
#ifdef DEBUG
                        a_notes = pci_bus;
#endif

                        prev_portid = portid;

                        /* get the node-id */
                        node_id =  SG_PORTID_TO_NODEID(portid);

                        /* model */
                        model = (char *)get_prop_val
                            (find_prop(pnode, "model"));

                        /* version */
                        value = (int *)get_prop_val
                            (find_prop(pnode, "module-revision#"));

                        if (value)
                                int_val = (int *)value;
                        else
                                int_val = (int *)get_prop_val
                                    (find_prop(pnode, "version#"));
                        if (int_val != NULL)
                                version = *int_val;
                        else
                                version = -1;

                        /* status */
                        status_a = (char *)get_prop_val(find_prop
                            (pnode, "status"));

                        /*
                         * Display the data
                         */
                        /* FRU Name */
                        SG_SET_FRU_NAME_NODE(fru_name, node_id);
                        SG_SET_FRU_NAME_IO_BOARD(fru_name,
                            SG_IO_BD_PORTID_TO_BD_NUM(portid));
                        SG_SET_FRU_NAME_MODULE(fru_name, portid % 2);

                        if (mode == SG_SCHIZO_FAILED) {
                                if ((status_a != (char *)NULL) &&
                                    ((status_b != (char *)NULL))) {
                                        if ((strcmp
                                            (status_a, SG_DISABLED) == 0) &&
                                            (strcmp(status_b,
                                            SG_DISABLED) == 0)) {
                                                log_printf("\tFRU Type : %s\n ",
                                                    model, 0);
                                                log_printf("\tLocation : %s\n",
                                                    fru_name, 0);
                                                log_printf
                                                    ("\tPROM status: %s\n\n",
                                                    SG_DISABLED, 0);
                                                rv = 1;
                                        }
                                }
                                continue;
                        }
                        /*
                         * This section of code is executed when displaying
                         * non-failed schizo devices.  If the mode is set to
                         * SG_SCHIZO_FAILED, then this section of code will
                         * not be executed
                         */
                        if ((status_a == (char *)NULL) &&
                            ((status_b == (char *)NULL)))
                                sprintf(status, " %s      ", SG_OK);
                        else if ((status_a == (char *)NULL) &&
                            ((strcmp(status_b, SG_DISABLED) == 0)))
                                sprintf(status, " %s", SG_DEGRADED);
                        else if ((status_b == (char *)NULL) &&
                            ((strcmp(status_a, SG_DISABLED) == 0)))
                                sprintf(status, " %s", SG_DEGRADED);
                        else
                                continue;

                        log_printf("%-12s", fru_name, 0);

                        /* model */

                        if (model != NULL)
                                log_printf("%-15s  ", model, 0);
                        else
                                log_printf("%-15s  ", "unknown", 0);
                        /* portid */
                        log_printf("%-3d ", portid, 0);

                        /* status */
                        log_printf("%s", status, 0);

                        /* version */
                        log_printf("     %-4d   ", version, 0);
#ifdef DEBUG
                        log_printf("0x%x 0x%x", a_notes, b_notes, 0);
                        log_printf(" %d", portid, 0);
#endif
                        log_printf("\n", 0);
                }
                bnode = bnode->next;
        }
        return (rv);
}

static void
display_sgsbbc_revisions(Board_node *bdlist)
{

        Prom_node       *pnode;
        int             *int_val;
        int             portid;
        char            *model;
        char            *status;
        int             revision;
        int             node_id;
        Board_node      *bnode;

#ifdef DEBUG
        char    *slot_name;
        char    notes[30];
        char    *value;
#endif

        bnode = bdlist;
        while (bnode != NULL) {
                /*
                 * search this board node for all sgsbbc's
                 */
                for (pnode = dev_find_node_by_type(bnode->nodes, "model",
                    "SUNW,sgsbbc"); pnode != NULL;
                    pnode = dev_next_node_by_type(pnode, "model",
                    "SUNW,sgsbbc")) {

                        char    fru_name[MAX_FRU_NAME_LEN] = "";

                        /*
                         * We need to go to this node's parent to
                         * get a portid to tell us what board it is on
                         */
                        int_val = (int *)get_prop_val
                            (find_prop(pnode->parent, "portid"));
                        if (int_val == NULL)
                                continue;

                        portid = *int_val;
                        /* get the node-id */
                        node_id =  SG_PORTID_TO_NODEID(portid);

                        /* model */
                        model = (char *)get_prop_val
                            (find_prop(pnode, "model"));

                        /* status */
                        status = (char *)get_prop_val(find_prop
                            (pnode, "status"));

                        /* revision */
                        int_val = (int *)get_prop_val
                            (find_prop(pnode, "revision-id"));
                        if (int_val != NULL)
                                revision = *int_val;
                        else
                                revision = -1;

#ifdef DEBUG
                        value = (char *)get_prop_val(
                            find_prop(pnode->parent, "slot-names"));
                        if (value != NULL) {
                                /* Skip the 4 byte bitmask */
                                slot_name = (char *)value + sizeof (int);
                        } else {
                                strcpy(slot_name, "not_found");
                        }
                        (void) sprintf(notes, "[%s] portid [%d]", slot_name,
                            portid);
#endif
                        /*
                         * Display the data
                         */
                        /* FRU Name */
                        SG_SET_FRU_NAME_NODE(fru_name, node_id);
                        SG_SET_FRU_NAME_IO_BOARD(fru_name,
                            SG_IO_BD_PORTID_TO_BD_NUM(portid));
                        SG_SET_FRU_NAME_MODULE(fru_name, portid % 2);
                        log_printf("%-12s", fru_name, 0);

                        /* model */
                        if (model != NULL)
                                log_printf("%-15s  ", model, 0);
                        else
                                log_printf("%-15s  ", "unknown", 0);
                        /* portid */
                        log_printf("%-3d ", portid, 0);
                        /* status */
                        if (status == (char *)NULL)
                                log_printf(" ok      ", 0);
                        else
                                log_printf(" fail    ", 0);
                        /* revision */
                        log_printf("     %-4d   ", revision, 0);
#ifdef DEBUG
                        log_printf("%s", notes, 0);
#endif
                        log_printf("\n", 0);
                }
                bnode = bnode->next;
        }
}

/*ARGSUSED0*/
void
display_hp_fail_fault(Sys_tree *tree, struct system_kstat_data *kstats)
{
        serengeti_display_board_info(ACTIVE);
        serengeti_display_board_info(INACTIVE);
}

/*
 * display_failed_parts
 *
 * Display the failed parts in the system. This function looks for
 * the status property in all PROM nodes contained in the Sys_tree
 * passed in.
 */
int
display_failed_parts(Sys_tree *tree)
{
        int system_failed = 0;
        int bank_failed = 0;
        int schizo_failed = FALSE;
        int portid, nodeid, board;
        Board_node *bnode = tree->bd_list;
        Prom_node *pnode;
        int *coreid, *impl;
        print_flag = TRUE;

        /*
         * go through all of the OBP nodes looking for
         * failed units.
         */
        while (bnode != NULL) {

                pnode = find_failed_node(bnode->nodes);
                if ((pnode != NULL) && !system_failed) {
                        system_failed = TRUE;
                        log_printf("\n", 0);
                        log_printf(dgettext(TEXT_DOMAIN,
                            "Failed Field Replaceable Units (FRU) in "
                            "System:\n"), 0);
                        log_printf("=========================="
                            "====================\n", 0);
                }

                while (pnode != NULL) {
                        void *status;
                        char *name, *type, *model;

                        char    fru_name[MAX_FRU_NAME_LEN] = "";

                        status = get_prop_val(find_prop(pnode, "status"));
                        name = get_node_name(pnode);

                        /* sanity check of data retreived from PROM */
                        if ((status == NULL) || (name == NULL)) {
                                pnode = next_failed_node(pnode);
                                continue;
                        }

                        type = get_node_type(pnode);
                        portid = get_id(pnode);
                        model = (char *)get_prop_val
                            (find_prop(pnode, "model"));

                        /*
                         * Determine whether FRU is CPU module, Mem Controller,
                         * PCI card, schizo,xmits or sgsbbc.
                         */
                        if ((model != NULL) && strstr(model, "sgsbbc")) {
                                /*
                                 * sgsbbc / bootbus-controller
                                 */
                                portid = get_id(pnode->parent);
                                nodeid = SG_PORTID_TO_NODEID(portid);
                                board = SG_PORTID_TO_BOARD_NUM(portid);

                                SG_SET_FRU_NAME_NODE(fru_name, nodeid);
                                SG_SET_FRU_NAME_IO_BOARD(fru_name, board);
                                SG_SET_FRU_NAME_MODULE(fru_name, portid % 2);

                                log_printf("\tFailed Device : %s (%s)\n", model,
                                    name, 0);
                                log_printf("\tLocation : %s\n", fru_name, 0);

                        } else if (strstr(name, "pci") && (portid == -1)) {
                                /*
                                 * PCI Bridge if name = pci and it doesn't
                                 * have a portid.
                                 */
                                portid = get_id(pnode->parent);
                                nodeid = SG_PORTID_TO_NODEID(portid);
                                board = SG_PORTID_TO_BOARD_NUM(portid);

                                SG_SET_FRU_NAME_NODE(fru_name, nodeid);
                                SG_SET_FRU_NAME_IO_BOARD(fru_name, board);
                                SG_SET_FRU_NAME_MODULE(fru_name, portid % 2);

                                log_printf("\tFRU type : ", 0);
                                log_printf("PCI Bridge Device\n", 0);
                                log_printf("\tLocation : %s\n", fru_name, 0);

                        } else if ((type != NULL) &&
                            (strstr(type, "cpu") ||
                            strstr(type, "memory-controller"))) {
                                /*
                                 * CPU or memory controller
                                 */
                                portid = get_id(pnode);
                                /*
                                 * For cpu nodes that belong to a CMP, the
                                 * portid is stored in the parent "cmp" node.
                                 */
                                if (portid == -1)
                                        portid = get_id(pnode->parent);
                                nodeid = SG_PORTID_TO_NODEID(portid);
                                board = SG_PORTID_TO_BOARD_NUM(portid);

                                SG_SET_FRU_NAME_NODE(fru_name, nodeid);
                                SG_SET_FRU_NAME_CPU_BOARD(fru_name, board);
                                SG_SET_FRU_NAME_MODULE(fru_name, portid % 4);

                                log_printf("\tFRU type : ", 0);

                                if (strstr(type, "memory-controller"))
                                        log_printf("Memory Controller on ", 0);

                                log_printf("UltraSPARC module\n", 0);

                                log_printf("\tLocation : %s\n", fru_name, 0);

                        } else {
                                /*
                                 * It should only be a PCI card if we get to
                                 * here but lets check to be sure.
                                 */
                                char *parents_model, *grandparents_model;
                                Prom_node *parent_pnode;
                                int pci_card_found = 0;

                                if (pnode->parent != NULL)
                                        parent_pnode = pnode->parent;

                                /*
                                 * Is our parent a schizo or xmits
                                 */
                                parents_model = (char *)get_prop_val
                                    (find_prop(pnode->parent, "model"));
                                if ((parents_model != NULL) &&
                                    (strstr(parents_model, "SUNW,schizo") ||
                                    strstr(parents_model, "SUNW,xmits"))) {
                                        portid = get_id(pnode->parent);
                                        pci_card_found = TRUE;
                                }

                                /*
                                 * Is our grandparent a schizo xmits
                                 */
                                grandparents_model = (char *)get_prop_val
                                    (find_prop(parent_pnode->parent, "model"));
                                if ((grandparents_model != NULL) &&
                                    (strstr(grandparents_model,
                                    "SUNW,schizo") ||
                                    strstr(grandparents_model,
                                    "SUNW,xmits"))) {
                                        portid = get_id(parent_pnode->parent);
                                        pci_card_found = TRUE;
                                }

                                if (pci_card_found) {
                                        nodeid = SG_PORTID_TO_NODEID(portid);
                                        board = SG_PORTID_TO_BOARD_NUM(portid);

                                        SG_SET_FRU_NAME_NODE(fru_name, nodeid);
                                        SG_SET_FRU_NAME_IO_BOARD(fru_name,
                                            board);
                                        SG_SET_FRU_NAME_MODULE(fru_name,
                                            portid % 2);

                                        log_printf("\tFRU type :", 0);
                                        log_printf(" PCI Card\n", 0);
                                        log_printf("\tLocation : %s\n",
                                            fru_name, 0);
                                }
                        }
                        log_printf("\tPROM status: %s\n\n", status, 0);

                        pnode = next_failed_node(pnode);
                }
                bnode = bnode->next;

        }

        bank_failed = display_us3_failed_banks(system_failed);
        schizo_failed = display_schizo_revisions(tree->bd_list,
            SG_SCHIZO_FAILED);
        if (system_failed || bank_failed || schizo_failed)
                return (1);
        else
                return (0);
}


/*
 * This routine displays the memory configuration for all boards in the
 * system.
 */
void
display_memoryconf(Sys_tree *tree)
{
        Board_node      *bnode = tree->bd_list;

        log_printf("========================= Memory Configuration"
            " ===============================\n", 0);
        log_printf("\n                     Logical  Logical  Logical ", 0);
        log_printf("\n               Port  Bank     Bank     Bank         "
            "DIMM    Interleave  Interleave", 0);
        log_printf("\nFRU Name        ID   Num      Size     Status       "
            "Size    Factor      Segment", 0);
        log_printf("\n-------------  ----  ----     ------   -----------  "
            "------  ----------  ----------", 0);

        while (bnode != NULL) {
                if (get_us3_mem_regs(bnode)) {
                        log_printf(dgettext(TEXT_DOMAIN,
                            "\nFailed to get memory information.\n"), 0);
                        return;
                }
                bnode = bnode->next;
        }

        /* Display what we have found */
        display_us3_banks();
}

/*
 * This function provides Serengeti's formatting of the memory config
 * information that get_us3_mem_regs() and display_us3_banks() code has
 * gathered. It overrides the generic print_us3_memory_line() code
 * which prints an error message.
 */
void
print_us3_memory_line(int portid, int bank_id, uint64_t bank_size,
    char *bank_status, uint64_t dimm_size, uint32_t intlv, int seg_id)
{
        int             nodeid, board, mcid;
        char            fru_name[MAX_FRU_NAME_LEN] = "";

        mcid            = SG_PORTID_TO_SAFARI_ID(portid);
        nodeid          = SG_PORTID_TO_NODEID(portid);
        board           = SG_PORTID_TO_BOARD_NUM(portid);

        SG_SET_FRU_NAME_NODE(fru_name, nodeid);
        SG_SET_FRU_NAME_CPU_BOARD(fru_name, board);
        SG_SET_FRU_NAME_MODULE(fru_name, mcid % 4);
        SG_SET_FRU_NAME_BANK(fru_name, (bank_id % 4) % 2);

        log_printf("\n%-13s   %2d   %2d      %4lldMB    %11-s  %4lldMB "
            "   %2d-way       %d",
            fru_name, mcid,
            (bank_id % 4), bank_size, bank_status, dimm_size,
            intlv, seg_id, 0);
}

void
print_us3_failed_memory_line(int portid, int bank_id, char *bank_status)
{
        int             nodeid, board, mcid;
        char            fru_name[MAX_FRU_NAME_LEN] = "";

        mcid            = SG_PORTID_TO_SAFARI_ID(portid);
        nodeid          = SG_PORTID_TO_NODEID(portid);
        board           = SG_PORTID_TO_BOARD_NUM(portid);

        SG_SET_FRU_NAME_NODE(fru_name, nodeid);
        SG_SET_FRU_NAME_CPU_BOARD(fru_name, board);
        SG_SET_FRU_NAME_MODULE(fru_name, mcid % 4);
        SG_SET_FRU_NAME_BANK(fru_name, (bank_id % 4) % 2);

        log_printf("\tFRU type : ", 0);
        log_printf("Physical Memory Bank\n", 0);
        log_printf("\tLocation : %s (Logical Bank %2d)\n",
            fru_name, (bank_id %4), 0);
        log_printf("\tPROM status: %s\n\n", bank_status, 0);
}


/*
 * Find the requested board struct in the system device tree.
 *
 * This function overrides the functionality of the generic find_board()
 * function in libprtdiag, but since we need to pass another parameter,
 * we cannot simply overlay the symbol table.
 */
static Board_node *
serengeti_find_board(Sys_tree *root, int board, int nodeid)
{
        Board_node *bnode = root->bd_list;

        while ((bnode != NULL) &&
            ((board != bnode->board_num) || (nodeid != bnode->node_id))) {
                bnode = bnode->next;
        }
        return (bnode);
}


/*
 * Add a board to the system list in order (sorted by NodeID then board#).
 * Initialize all pointer fields to NULL.
 */
static Board_node *
serengeti_insert_board(Sys_tree *root, int board, int nodeid)
{
        Board_node *bnode;
        Board_node *temp = root->bd_list;

        if ((bnode = (Board_node *) malloc(sizeof (Board_node))) == NULL) {
                perror("malloc");
                exit(1);
        }

        bnode->nodes = NULL;
        bnode->next = NULL;
        bnode->board_num = board;
        bnode->node_id = nodeid;
        bnode->board_type = UNKNOWN_BOARD;

        if (temp == NULL)
                root->bd_list = bnode;

        else if ((temp->board_num > board) && (temp->node_id >= nodeid)) {
                bnode->next = temp;
                root->bd_list = bnode;

        } else {
                while ((temp->next != NULL) &&
                    ((board > temp->next->board_num) ||
                    (nodeid > temp->node_id)))
                        temp = temp->next;

                bnode->next = temp->next;
                temp->next = bnode;
        }
        root->board_cnt++;

        return (bnode);
}

/*
 * We call do_devinfo() in order to use the libdevinfo device tree
 * instead of OBP's device tree.
 */
int
do_prominfo(int syserrlog, char *pgname, int log_flag, int prt_flag)
{

        return (do_devinfo(syserrlog, pgname, log_flag, prt_flag));

}

/*
 * return the property value for the Prop passed in depending on
 * which tree (OBP/DEVINFO) is being used.
 */
void *
get_prop_val(Prop *prop)
{
        if (prop == NULL)
                return (NULL);

        /* Check which tree is being used. */
        if (tree == DEVINFO_TREE)
                return ((void *)(prop->value.val_ptr));
        else {
                if (prop->value.opp.holds_array)
                        return ((void *)(prop->value.opp.oprom_array));
                else
                        return ((void *)(&prop->value.opp.oprom_node[0]));
        }
}

/*
 * Search a Prom node and retrieve the property with the correct
 * name depending on which tree (OBP/DEVINFO) is being used.
 */
Prop *
find_prop(Prom_node *pnode, char *name)
{
        Prop *prop;

        if (pnode  == NULL)
                return (NULL);

        if (pnode->props == NULL)
                return (NULL);

        prop = pnode->props;

        /* Check which tree is being used. */
        if (tree == DEVINFO_TREE) {
                while ((prop != NULL) &&
                    (strcmp((char *)(prop->name.val_ptr), name)))
                        prop = prop->next;
        } else {
                while ((prop != NULL) && (strcmp((char *)
                    (prop->name.opp.oprom_array), name)))
                        prop = prop->next;
        }
        return (prop);
}

/*
 * This function searches through the properties of the node passed in
 * and returns a pointer to the value of the name property
 * depending on which tree (OBP/DEVINFO) is being used.
 */
char *
get_node_name(Prom_node *pnode)
{
        Prop *prop;

        if (pnode == NULL)
                return (NULL);

        prop = pnode->props;
        while (prop != NULL) {
                /* Check which tree is being used. */
                if (tree == DEVINFO_TREE) {
                        if (strcmp("name", (char *)prop->name.val_ptr) == 0)
                                return ((char *)prop->value.val_ptr);
                } else {
                        if (strcmp("name", prop->name.opp.oprom_array) == 0)
                                return (prop->value.opp.oprom_array);
                }
                prop = prop->next;
        }
        return (NULL);
}

/*
 * This function searches through the properties of the node passed in
 * and returns a pointer to the value of the device_type property
 * depending on which tree (OBP/DEVINFO) is being used.
 */
char *
get_node_type(Prom_node *pnode)
{
        Prop *prop;

        if (pnode == NULL)
                return (NULL);

        prop = pnode->props;
        while (prop != NULL) {
                /* Check which tree is being used. */
                if (tree == DEVINFO_TREE) {
                        if (strcmp("device_type", (char *)prop->name.val_ptr)
                            == 0)
                                return ((char *)prop->value.val_ptr);
                } else {
                        if (strcmp("device_type", prop->name.opp.oprom_array)
                            == 0)
                                return (prop->value.opp.oprom_array);
                }
                prop = prop->next;
        }
        return (NULL);
}

/*
 * Take a snapshot of the OBP device tree and walk this snapshot
 * to find all failed HW (ie. devices with a status property of
 * 'fail'). Call display_failed_parts() to display the failed HW.
 */
void
get_failed_parts(void)
{
        int system_failed = 0;
        Sys_tree obp_sys_tree;          /* system information */

        /* set the the system tree fields */
        obp_sys_tree.sys_mem = NULL;
        obp_sys_tree.boards = NULL;
        obp_sys_tree.bd_list = NULL;
        obp_sys_tree.board_cnt = 0;

        if (promopen(O_RDONLY)) {
                (void) fprintf(stderr, "%s",
                    dgettext(TEXT_DOMAIN, "openprom device "
                    "open failed"));
                return;
        }

        if ((is_openprom() == 0) || (next(0) == 0)) {
                (void) fprintf(stderr, "%s",
                    dgettext(TEXT_DOMAIN, "openprom device "
                    "error encountered."));
                return;
        }

        tree = OBP_TREE;        /* Switch to the OBP tree */

        (void) walk(&obp_sys_tree, NULL, next(0));

        system_failed = display_failed_parts(&obp_sys_tree);

        if (!system_failed) {
                log_printf(dgettext(TEXT_DOMAIN,
                    "No Hardware failures found in System\n"), 0);
        }
        promclose();
        tree = DEVINFO_TREE;    /* Switch back to the DEVINFO tree */
}

/*
 * get_slot_name figures out the slot no. for the card. In the case of
 * XMITS slots 2 & 3 and slots 6 & 7 are reversed in slot_name by OBP
 * so we need to cater for this to correctly identify the slot no.
 */
static void
get_slot_name(struct io_card *card, char *slot_name)
{
        char tmp_ptr[2];

        if (strlen(slot_name) != 0) {
                if (strcmp(card->notes, XMITS_COMPATIBLE) == 0) {
                        (void) sprintf(tmp_ptr, "%c",
                            slot_name[strlen(slot_name) -1]);
                        switch (tmp_ptr[0]) {
                        case '2':
                                (void) sprintf(card->slot_str, "%c", '3');
                                break;
                        case '3':
                                (void) sprintf(card->slot_str, "%c", '2');
                                break;
                        case '6':
                                (void) sprintf(card->slot_str, "%c", '7');
                                break;
                        case '7':
                                (void) sprintf(card->slot_str, "%c", '6');
                                break;
                        default:
                                (void) sprintf(card->slot_str, "%c",
                                    slot_name[strlen(slot_name) -1]);
                        }
                } else
                        (void) sprintf(card->slot_str, "%c",
                            slot_name[strlen(slot_name) -1]);
        } else
                (void) sprintf(card->slot_str, "-");
}