sunfire/common/sunfire.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Sunfire Platform specific functions.
 *
 *  called when :
 *  machine_type == MTYPE_SUNFIRE
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <kvm.h>
#include <varargs.h>
#include <time.h>
#include <dirent.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <sys/openpromio.h>
#include <libintl.h>
#include <syslog.h>
#include <sys/dkio.h>
#include "pdevinfo.h"
#include "display.h"
#include "pdevinfo_sun4u.h"
#include "display_sun4u.h"
#include "libprtdiag.h"

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

/* Macros for manipulating UPA IDs and board numbers on Sunfire. */
#define bd_to_upa(bd) ((bd) << 1)
#define upa_to_bd(upa)  ((upa) >> 1)

#define MAX_MSGS    64

extern  int print_flag;

/*
 * these functions will overlay the symbol table of libprtdiag
 * at runtime (sunfire systems only)
 */
int error_check(Sys_tree *tree, struct system_kstat_data *kstats);
void    display_memoryconf(Sys_tree *tree, struct grp_info *grps);
int disp_fail_parts(Sys_tree *tree);
void    display_memorysize(Sys_tree *tree, struct system_kstat_data *kstats,
        struct grp_info *grps, struct mem_total *memory_total);
void    display_hp_fail_fault(Sys_tree *tree, struct system_kstat_data *kstats);
void    display_diaginfo(int flag, Prom_node *root, Sys_tree *tree,
        struct system_kstat_data *kstats);
void    display_mid(int mid);
void    display_pci(Board_node *);
void    display_ffb(Board_node *, int);
void    add_node(Sys_tree *, Prom_node *);
void    resolve_board_types(Sys_tree *);

/* local functions */
static  void build_mem_tables(Sys_tree *, struct system_kstat_data *,
        struct grp_info *);
static  void get_mem_total(struct mem_total *, struct grp_info *);
static  int disp_fault_list(Sys_tree *, struct system_kstat_data *);
static  int disp_err_log(struct system_kstat_data *);
static  int disp_env_status(struct system_kstat_data *);
static  int disp_keysw_and_leds(struct system_kstat_data *);
static  void sunfire_disp_prom_versions(Sys_tree *);
static  void erase_msgs(char **);
static  void display_msgs(char **msgs, int board);
static  void sunfire_disp_asic_revs(Sys_tree *, struct system_kstat_data *);
static  void display_hp_boards(struct system_kstat_data *);
static  int disp_parts(char **, u_longlong_t, int);
/*
 * Error analysis routines. These routines decode data from specified
 * error registers. They are meant to be used for decoding the fatal
 * hardware reset data passed to the kernel by sun4u POST.
 */
static int analyze_cpu(char **, int, u_longlong_t);
static int analyze_ac(char **, u_longlong_t);
static int analyze_dc(int, char **, u_longlong_t);

#define RESERVED_STR    "Reserved"

#define MAX_PARTS   5
#define MAX_FRUS    5

#define MAXSTRLEN   256

/* Define special bits */
#define UPA_PORT_A  0x1
#define UPA_PORT_B  0x2


/*
 * These defines comne from async.h, but it does not get exported from
 * uts/sun4u/sys, so they must be redefined.
 */
#define P_AFSR_ISAP 0x0000000040000000ULL /* incoming addr. parity err */
#define P_AFSR_ETP  0x0000000020000000ULL /* ecache tag parity */
#define P_AFSR_ETS  0x00000000000F0000ULL /* cache tag parity syndrome */
#define ETS_SHIFT   16

/* List of parts possible */
#define RSVD_PART   1
#define UPA_PART    2
#define UPA_A_PART  3
#define UPA_B_PART  4
#define SOFTWARE_PART   5
#define AC_PART     6
#define AC_ANY_PART 7
#define DTAG_PART   8
#define DTAG_A_PART 9
#define DTAG_B_PART 10
#define FHC_PART    11
#define BOARD_PART  12
#define BOARD_ANY_PART  13
#define BOARD_CONN_PART 14
#define BACK_PIN_PART   15
#define BACK_TERM_PART  16
#define CPU_PART    17

/* List of possible parts */
static char *part_str[] = {
    "",         /* 0, a placeholder for indexing */
    "",         /* 1, reserved strings shouldn't be printed */
    "UPA devices",                  /* 2 */
    "UPA Port A device",                /* 3 */
    "UPA Port B device",                /* 4 */
    "Software error",               /* 5 */
    "Address Controller",               /* 6 */
    "Undetermined Address Controller in system",    /* 7 */
    "Data Tags",                    /* 8 */
    "Data Tags for UPA Port A",         /* 9 */
    "Data Tags for UPA Port B",         /* 10 */
    "Firehose Controller",              /* 11 */
    "This Board",                   /* 12 */
    "Undetermined Board in system",         /* 13 */
    "Board Connector",              /* 14 */
    "Centerplane pins ",                /* 15 */
    "Centerplane terminators",          /* 16 */
    "CPU",                      /* 17 */
};

/* Ecache parity error messages. Tells which bits are bad. */
static char *ecache_parity[] = {
    "Bits 7:0 ",
    "Bits 15:8 ",
    "Bits 21:16 ",
    "Bits 24:22 "
};


struct ac_error {
    char *error;
    int part[MAX_PARTS];
};

typedef struct ac_error ac_err;

/*
 * Hardware error register meanings, failed parts and FRUs. The
 * following strings are indexed for the bit positions of the
 * corresponding bits in the hardware. The code checks bit x of
 * the hardware error register and prints out string[x] if the bit
 * is turned on.
 *
 * This database of parts which are probably failed and which FRU's
 * to replace was based on knowledge of the Sunfire Programmers Spec.
 * and discussions with the hardware designers. The order of the part
 * lists and consequently the FRU lists are in the order of most
 * likely cause first.
 */
static ac_err ac_errors[] = {
    {                           /* 0 */
        "UPA Port A Error",
        { UPA_A_PART, 0, 0, 0, 0 },
    },
    {                           /* 1 */
        "UPA Port B Error",
        { UPA_B_PART, 0, 0, 0, 0 },
    },
    {                           /* 2 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 3 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 4 */
        "UPA Interrupt to unmapped destination",
        { BOARD_PART, 0, 0, 0, 0 },
    },
    {                           /* 5 */
        "UPA Non-cacheable write to unmapped destination",
        { BOARD_PART, 0, 0, 0, 0 },
    },
    {                           /* 6 */
        "UPA Cacheable write to unmapped destination",
        { BOARD_PART, 0, 0, 0, 0 },
    },
    {                           /* 7 */
        "Illegal Write Received",
        { BOARD_PART, 0, 0, 0, 0 },
    },
    {                           /* 8 */
        "Local Writeback match with line in state S",
        { AC_PART, DTAG_PART, 0, 0, 0 },
    },
    {                           /* 9 */
        "Local Read match with valid line in Tags",
        { AC_PART, DTAG_PART, 0, 0, 0 },
    },
    {                           /* 10 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 11 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 12 */
        "Tag and Victim were valid during lookup",
        { AC_PART, DTAG_PART, 0, 0, 0 },
    },
    {                           /* 13 */
        "Local Writeback matches a victim in state S",
        { AC_PART, CPU_PART, 0, 0, 0 },
    },
    {                           /* 14 */
        "Local Read matches valid line in victim buffer",
        { AC_PART, CPU_PART, 0, 0, 0 },
    },
    {                           /* 15 */
        "Local Read victim bit set and victim is S state",
        { AC_PART, CPU_PART, 0, 0, 0 },
    },
    {                           /* 16 */
        "Local Read Victim bit set and Valid Victim Buffer",
        { AC_PART, CPU_PART, 0, 0, 0 },
    },
    {                           /* 17 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 18 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 19 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 20 */
        "UPA Transaction received in Sleep mode",
        { AC_PART, 0, 0, 0, 0 },
    },
    {                           /* 21 */
        "P_FERR error P_REPLY received from UPA Port",
        { CPU_PART, AC_PART, 0, 0, 0 },
    },
    {                           /* 22 */
        "Illegal P_REPLY received from UPA Port",
        { CPU_PART, AC_PART, 0, 0, 0 },
    },
    {                           /* 23 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 24 */
        "Timeout on a UPA Master Port",
        { AC_ANY_PART, BOARD_ANY_PART, 0, 0, 0 },
    },
    {                           /* 25 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 26 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 27 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 28 */
        "Coherent Transactions Queue Overflow Error",
        { BACK_PIN_PART, BOARD_CONN_PART, AC_PART, AC_ANY_PART, 0 },
    },
    {                           /* 29 */
        "Non-cacheable Request Queue Overflow Error",
        { AC_PART, AC_ANY_PART, 0, 0, 0 },
    },
    {                           /* 30 */
        "Non-cacheable Reply Queue Overflow Error",
        { AC_PART, 0, 0, 0, 0 },
    },
    {                           /* 31 */
        "PREQ Queue Overflow Error",
        { CPU_PART, AC_PART, 0, 0, 0 },
    },
    {                           /* 32 */
        "Foreign DID CAM Overflow Error",
        { AC_PART, AC_ANY_PART, 0, 0, 0 },
    },
    {                           /* 33 */
        "FT->UPA Queue Overflow Error",
        { BACK_PIN_PART, BOARD_CONN_PART, AC_PART, AC_ANY_PART, 0 },
    },
    {                           /* 34 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 35 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 36 */
        "UPA Port B Dtag Parity Error",
        { DTAG_B_PART, AC_PART, 0, 0, 0 },
    },
    {                           /* 37 */
        "UPA Port A Dtag Parity Error",
        { DTAG_A_PART, AC_PART, 0, 0, 0 },
    },
    {                           /* 38 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 39 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 40 */
        "UPA Bus Parity Error",
        { UPA_PART, AC_PART, 0, 0, 0 },
    },
    {                           /* 41 */
        "Data ID Line Mismatch",
        { BACK_PIN_PART, BOARD_CONN_PART, AC_PART, 0, 0 },
    },
    {                           /* 42 */
        "Arbitration Line Mismatch",
        { BACK_PIN_PART, BOARD_CONN_PART, AC_PART, 0, 0 },
    },
    {                           /* 43 */
        "Shared Line Parity Mismatch",
        { BACK_PIN_PART, BOARD_CONN_PART, AC_PART, 0, 0 },
    },
    {                           /* 44 */
        "FireTruck Control Line Parity Error",
        { AC_PART, BACK_PIN_PART, 0, 0, 0 },
    },
    {                           /* 45 */
        "FireTruck Address Bus Parity Error",
        { AC_PART, BACK_PIN_PART, 0, 0, 0 },
    },
    {                           /* 46 */
        "Internal RAM Parity Error",
        { AC_PART, 0, 0, 0, 0 },
    },
    {                           /* 47 */
        NULL,
        { RSVD_PART, 0, 0, 0, 0 },
    },
    {                           /* 48 */
        "Internal Hardware Error",
        { AC_PART, 0, 0, 0, 0 },
    },
    {                           /* 49 */
        "FHC Communications Error",
        { FHC_PART, AC_PART, 0, 0, 0 },
    },
    /* Bits 50-63 are reserved in this implementation. */
};


#define MAX_BITS (sizeof (ac_errors)/ sizeof (ac_err))

/*
 * There are only two error bits in the DC shadow chain that are
 * important. They indicate an overflow error and a parity error,
 * respectively. The other bits are not error bits and should not
 * be checked for.
 */
#define DC_OVERFLOW 0x2
#define DC_PARITY   0x4

static char dc_overflow_txt[] = "Board %d DC %d Overflow Error";
static char dc_parity_txt[] = "Board %d DC %d Parity Error";

/* defines for the sysio */
#define UPA_APERR   0x4

int
error_check(Sys_tree *tree, struct system_kstat_data *kstats)
{
    int exit_code = 0;  /* init to all OK */

    /*
     * silently check for any types of machine errors
     */
    print_flag = 0;
    if (disp_fail_parts(tree) || disp_fault_list(tree, kstats) ||
        disp_err_log(kstats) || disp_env_status(kstats)) {
        /* set exit_code to show failures */
        exit_code = 1;
    }
    print_flag = 1;

    return (exit_code);
}

/*
 * disp_fail_parts
 *
 * Display the failed parts in the system. This function looks for
 * the status property in all PROM nodes. On systems where
 * the PROM does not supports passing diagnostic information
 * thruogh the device tree, this routine will be silent.
 */
int
disp_fail_parts(Sys_tree *tree)
{
    int exit_code;
    int system_failed = 0;
    Board_node *bnode = tree->bd_list;
    Prom_node *pnode;

    exit_code = 0;

    /* go through all of the boards looking for failed units. */
    while (bnode != NULL) {
        /* find failed chips */
        pnode = find_failed_node(bnode->nodes);
        if ((pnode != NULL) && !system_failed) {
            system_failed = 1;
            exit_code = 1;
            if (print_flag == 0) {
                return (exit_code);
            }
            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 *value;
            char *name;     /* node name string */
            char *type;     /* node type string */
            char *board_type = NULL;

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

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

            /* Find the board type of this board */
            if (bnode->board_type == CPU_BOARD) {
                board_type = "CPU";
            } else {
                board_type = "IO";
            }

            log_printf(dgettext(TEXT_DOMAIN,
                "%s unavailable on %s Board #%d\n"),
                name, board_type, bnode->board_num, 0);

            log_printf(dgettext(TEXT_DOMAIN,
                "\tPROM fault string: %s\n"), value, 0);

            log_printf(dgettext(TEXT_DOMAIN,
                "\tFailed Field Replaceable Unit is "), 0);

            /*
             * Determine whether FRU is CPU module, system
             * board, or SBus card.
             */
            if ((name != NULL) && (strstr(name, "sbus"))) {

                log_printf(dgettext(TEXT_DOMAIN,
                    "SBus Card %d\n"),
                    get_sbus_slot(pnode), 0);

            } else if (((name = get_node_name(pnode->parent)) !=
                NULL) && (strstr(name, "pci"))) {

                log_printf(dgettext(TEXT_DOMAIN,
                    "PCI Card %d"),
                    get_pci_device(pnode), 0);

            } else if (((type = get_node_type(pnode)) != NULL) &&
                (strstr(type, "cpu"))) {

                log_printf(dgettext(TEXT_DOMAIN,
                    "UltraSPARC module "
                    "Board %d Module %d\n"),
                        get_id(pnode) >> 1,
                        get_id(pnode) & 0x1);

            } else {
                log_printf(dgettext(TEXT_DOMAIN,
                    "%s board %d\n"), board_type,
                    bnode->board_num, 0);
            }
            pnode = next_failed_node(pnode);
        }
        bnode = bnode->next;
    }

    if (!system_failed) {
        log_printf("\n", 0);
        log_printf(dgettext(TEXT_DOMAIN,
            "No failures found in System\n"), 0);
        log_printf("===========================\n", 0);
    }

    if (system_failed)
        return (1);
    else
        return (0);
}

void
display_memorysize(Sys_tree *tree, struct system_kstat_data *kstats,
    struct grp_info *grps, struct mem_total *memory_total) {

    /* Build the memory group tables and interleave data */
    build_mem_tables(tree, kstats, grps);

    /* display total usable installed memory */
    get_mem_total(memory_total, grps);
    (void) log_printf(dgettext(TEXT_DOMAIN,
        "Memory size: %4dMb\n"), memory_total->dram, 0);

    /* We display the NVSIMM size totals separately. */
    if (memory_total->nvsimm != 0) {
        (void) log_printf(dgettext(TEXT_DOMAIN,
            "NVSIMM size: %4dMb\n"), memory_total->nvsimm);
    }
}

/*
 * This routine displays the memory configuration for all boards in the
 * system.
 */
void
display_memoryconf(Sys_tree *tree, struct grp_info *grps)
{
    int group;
    char *status_str[] = {  "Unknown", " Empty ", " Failed", " Active",
                " Spare " };
    char *cond_str[] = {    " Unknown  ", "    OK    ", " Failing  ",
                "  Failed  ", " Uninit.  " };

#ifdef lint
    tree = tree;
#endif
    /* Print the header for the memory section. */
    log_printf("\n", 0);
    log_printf("=========================", 0);
    log_printf(dgettext(TEXT_DOMAIN, " Memory "), 0);
    log_printf("=========================", 0);
    log_printf("\n", 0);
    log_printf("\n", 0);
    log_printf("                                              Intrlv.  "
        "Intrlv.\n", 0);
    log_printf("Brd   Bank   MB    Status   Condition  Speed   Factor  "
        " With\n", 0);
    log_printf("---  -----  ----  -------  ----------  -----  -------  "
        "-------\n", 0);

    /* Print the Memory groups information. */
    for (group = 0; group < MAX_GROUPS; group++) {
        struct grp *grp;

        grp = &grps->grp[group];

        /* If this board is not a CPU or MEM board, skip it. */
        if ((grp->type != MEM_BOARD) && (grp->type != CPU_BOARD)) {
            continue;
        }

        if (grp->valid) {
            log_printf("%2d   ", grp->board, 0);
            log_printf("  %1d    ", grp->group, 0);
            log_printf("%4d  ", grp->size, 0);
            log_printf("%7s  ", status_str[grp->status], 0);
            log_printf("%10s  ", cond_str[grp->condition], 0);
            log_printf("%3dns  ", grp->speed, 0);
            log_printf("%3d-way  ", grp->factor, 0);
            if (grp->factor > 1) {
                log_printf("%4c", grp->groupid, 0);
            }
            log_printf("\n", 0);
        }
    }

}


void
display_hp_fail_fault(Sys_tree *tree, struct system_kstat_data *kstats)
{
    /* Display Hot plugged, disabled and failed boards */
    (void) display_hp_boards(kstats);

    /* Display failed units */
    (void) disp_fail_parts(tree);

    /* Display fault info */
    (void) disp_fault_list(tree, kstats);
}

void
display_diaginfo(int flag, Prom_node *root, Sys_tree *tree,
    struct system_kstat_data *kstats)
{
    /*
     * Now display the last powerfail time and the fatal hardware
     * reset information. We do this under a couple of conditions.
     * First if the user asks for it. The second is iof the user
     * told us to do logging, and we found a system failure.
     */
    if (flag) {
        /*
         * 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);

        /* Display system environmental conditions. */
        (void) disp_env_status(kstats);

        /* Display ASIC Chip revs for all boards. */
        sunfire_disp_asic_revs(tree, kstats);

        /* Print the PROM revisions here */
        sunfire_disp_prom_versions(tree);

        /*
         * Display the latest system fatal hardware
         * error data, if any. The system holds this
         * data in SRAM, so it does not persist
         * across power-on resets.
         */
        (void) disp_err_log(kstats);
    }
}

void
display_mid(int mid)
{
    log_printf("  %2d     ", mid % 2, 0);
}

/*
 * display_pci
 * Call the generic psycho version of this function.
 */
void
display_pci(Board_node *board)
{
    display_psycho_pci(board);
}

/*
 * display_ffb
 * Display all FFBs on this board.  It can either be in tabular format,
 * or a more verbose format.
 */
void
display_ffb(Board_node *board, int table)
{
    Prom_node *ffb;
    void *value;
    struct io_card *card_list = NULL;
    struct io_card card;

    if (board == NULL)
        return;

    /* Fill in common information */
    card.display = 1;
    card.board = board->board_num;
    (void) sprintf(card.bus_type, "UPA");
    card.freq = sys_clk;

    for (ffb = dev_find_node(board->nodes, FFB_NAME); ffb != NULL;
        ffb = dev_next_node(ffb, FFB_NAME)) {
        if (table == 1) {
            /* Print out in table format */

            /* XXX - Get the slot number (hack) */
            card.slot = get_id(ffb);

            /* Find out if it's single or double buffered */
            (void) sprintf(card.name, "FFB");
            value = get_prop_val(find_prop(ffb, "board_type"));
            if (value != NULL)
                if ((*(int *)value) & FFB_B_BUFF)
                    (void) sprintf(card.name, "FFB, "
                        "Double Buffered");
                else
                    (void) sprintf(card.name, "FFB, "
                        "Single Buffered");

            /* Print model number */
            card.model[0] = '\0';
            value = get_prop_val(find_prop(ffb, "model"));
            if (value != NULL)
                (void) sprintf(card.model, "%s",
                    (char *)value);

            card_list = insert_io_card(card_list, &card);
        } else {
            /* print in long format */
            char device[MAXSTRLEN];
            int fd = -1;
            struct dirent *direntp;
            DIR *dirp;
            union strap_un strap;
            struct ffb_sys_info fsi;

            /* Find the device node using upa address */
            value = get_prop_val(find_prop(ffb, "upa-portid"));
            if (value == NULL)
                continue;

            (void) sprintf(device, "%s@%x", FFB_NAME,
                *(int *)value);
            if ((dirp = opendir("/devices")) == NULL)
                continue;

            while ((direntp = readdir(dirp)) != NULL) {
                if (strstr(direntp->d_name, device) != NULL) {
                    (void) sprintf(device, "/devices/%s",
                        direntp->d_name);
                    fd = open(device, O_RDWR, 0666);
                    break;
                }
            }
            (void) closedir(dirp);

            if (fd == -1)
                continue;

            if (ioctl(fd, FFB_SYS_INFO, &fsi) < 0)
                continue;

            log_printf("Board %d FFB Hardware Configuration:\n",
                board->board_num, 0);
            log_printf("-----------------------------------\n", 0);

            strap.ffb_strap_bits = fsi.ffb_strap_bits;
            log_printf("\tBoard rev: %d\n",
                (int)strap.fld.board_rev, 0);
            log_printf("\tFBC version: 0x%x\n", fsi.fbc_version, 0);
            log_printf("\tDAC: %s\n",
                fmt_manf_id(fsi.dac_version, device), 0);
            log_printf("\t3DRAM: %s\n",
                fmt_manf_id(fsi.fbram_version, device), 0);
            log_printf("\n", 0);
        }
    }

    display_io_cards(card_list);
    free_io_cards(card_list);
}

/*
 * 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;
    Board_node *bnode;
    char *name = get_node_name(pnode);
    Prom_node *p;

    /* add this node to the Board list of the appropriate board */
    if ((board = get_board_num(pnode)) == -1) {
        void *value;

        /*
         * if it is a server, pci nodes and ffb nodes never have
         * board number properties and software can find the board
         * number from the reg property. It is derived from the
         * high word of the 'reg' property, which contains the
         * mid.
         */
        if ((name != NULL) &&
            ((strcmp(name, FFB_NAME) == 0) ||
            (strcmp(name, "pci") == 0) ||
            (strcmp(name, "counter-timer") == 0))) {
            /* extract the board number from the 'reg' prop. */
            if ((value = get_prop_val(find_prop(pnode,
                "reg"))) == NULL) {
                (void) printf("add_node() no reg property\n");
                exit(2);
            }
            board = (*(int *)value - 0x1c0) / 4;
        }
    }

    /* find the node with the same board number */
    if ((bnode = find_board(root, board)) == NULL) {
        bnode = insert_board(root, board);
        bnode->board_type = UNKNOWN_BOARD;
    }

    /* 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;
    }

}

/*
 * Function resolve_board_types
 *
 * After the tree is walked and all the information is gathered, this
 * function is called to resolve the type of each board.
 */
void
resolve_board_types(Sys_tree *tree)
{
    Board_node *bnode;
    Prom_node *pnode;
    char *type;

    bnode = tree->bd_list;
    while (bnode != NULL) {
        bnode->board_type = UNKNOWN_BOARD;

        pnode = dev_find_node(bnode->nodes, "fhc");
        type = get_prop_val(find_prop(pnode, "board-type"));
        if (type == NULL) {
            bnode = bnode->next;
            continue;
        }

        if (strcmp(type, CPU_BD_NAME) == 0) {
            bnode->board_type = CPU_BOARD;
        } else if (strcmp(type, MEM_BD_NAME) == 0) {
            bnode->board_type = MEM_BOARD;
        } else if (strcmp(type, DISK_BD_NAME) == 0) {
            bnode->board_type = DISK_BOARD;
        } else if (strcmp(type, IO_SBUS_FFB_BD_NAME) == 0) {
            bnode->board_type = IO_SBUS_FFB_BOARD;
        } else if (strcmp(type, IO_2SBUS_BD_NAME) == 0) {
            bnode->board_type = IO_2SBUS_BOARD;
        } else if (strcmp(type, IO_PCI_BD_NAME) == 0) {
            bnode->board_type = IO_PCI_BOARD;
        } else if (strcmp(type, IO_2SBUS_SOCPLUS_BD_NAME) == 0) {
            bnode->board_type = IO_2SBUS_SOCPLUS_BOARD;
        } else if (strcmp(type, IO_SBUS_FFB_SOCPLUS_BD_NAME) == 0) {
            bnode->board_type = IO_SBUS_FFB_SOCPLUS_BOARD;
        }

        bnode = bnode->next;
    }

}

/*
 * local functions
 */

static void
sunfire_disp_prom_versions(Sys_tree *tree)
{
    Board_node *bnode;

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

    /* For each board, print the POST and OBP versions */
    for (bnode = tree->bd_list; bnode != NULL; bnode = bnode->next) {
        Prom_node *flashprom;   /* flashprom device node */

        /* find a flashprom node for this board */
        flashprom = dev_find_node(bnode->nodes, "flashprom");

        /* If no flashprom node found, continue */
        if (flashprom == NULL)
            continue;

        /* flashprom node found, display board# */
        log_printf("Board %2d: ", bnode->board_num, 0);

        disp_prom_version(flashprom);
    }
}


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

/*
 * build_mem_tables
 *
 * This routine builds the memory table which tells how much memory
 * is present in each SIMM group of each board, what the interleave
 * factors are, and the group ID of the interleave group.
 *
 * The algorithms used are:
 *  First fill in the sizes of groups.
 *  Next build lists of all groups with same physical base.
 *  From #of members in each list, interleave factor is
 *  determined.
 *  All members of a certain list get the same interleave
 *  group ID.
 */
static void
build_mem_tables(Sys_tree *tree,
        struct system_kstat_data *kstats,
        struct grp_info *grps)
{
    struct mem_inter inter_grps;    /* temp structure for interleaves */
    struct inter_grp *intrp;
    int group;
    int i;

    /* initialize the interleave lists */
    for (i = 0, intrp = &inter_grps.i_grp[0]; i < MAX_GROUPS; i++,
        intrp++) {
        intrp->valid = 0;
        intrp->count = 0;
        intrp->groupid = '\0';
        intrp->base = 0;
    }

    for (group = 0; group < MAX_GROUPS; group++) {
        int found;
        int board;
        struct grp *grp;
        struct bd_kstat_data *bksp;
        uchar_t simm_reg;
        Board_node *bnode;

        board = group/2;
        bksp = &kstats->bd_ksp_list[board];
        grp = &grps->grp[group];
        grp->group = group % 2;

        /*
         * Copy the board type field into the group record.
         */
        if ((bnode = find_board(tree, board)) != NULL) {
            grp->type = bnode->board_type;
        } else {
            grp->type = UNKNOWN_BOARD;
            continue;
        }

        /* Make sure we have kstats for this board */
        if (bksp->ac_kstats_ok == 0) {
            /* Mark this group as invalid and move to next one */
            grp->valid = 0;
            continue;
        }

        /* Find the bank status property */
        if (bksp->ac_memstat_ok) {
            grp->status = bksp->mem_stat[grp->group].status;
            grp->condition = bksp->mem_stat[grp->group].condition;
        } else {
            grp->status = StUnknown;
            grp->condition = ConUnknown;
        }

        switch (grp->status) {
        case StBad:
        case StActive:
        case StSpare:
            break;
        default:
            grp->status = StUnknown;
            break;
        }

        switch (grp->condition) {
        case ConOK:
        case ConFailing:
        case ConFailed:
        case ConTest:
        case ConBad:
            break;
        default:
            grp->condition = ConUnknown;
            break;
        }

        /* base the group size off of the simmstat kstat. */
        if (bksp->simmstat_kstats_ok == 0) {
            grp->valid = 0;
            continue;
        }

        /* Is it bank 0 or bank 1 */
        if (grp->group == 0) {
            simm_reg = bksp->simm_status[0];
        } else {
            simm_reg = bksp->simm_status[1];
        }

        /* Now decode the size field. */
        switch (simm_reg & 0x1f) {
        case MEM_SIZE_64M:
            grp->size = 64;
            break;
        case MEM_SIZE_256M:
            grp->size = 256;
            break;
        case MEM_SIZE_1G:
            grp->size = 1024;
            break;
        case MEM_SIZE_2G:
            grp->size = 2048;
            break;
        default:
            grp->valid = 0;
            continue;
        }

        /* Decode the speed field */
        switch ((simm_reg & 0x60) >> 5) {
        case MEM_SPEED_50ns:
            grp->speed = 50;
            break;
        case MEM_SPEED_60ns:
            grp->speed = 60;
            break;
        case MEM_SPEED_70ns:
            grp->speed = 70;
            break;
        case MEM_SPEED_80ns:
            grp->speed = 80;
            break;
        }

        grp->valid = 1;
        grp->base = GRP_BASE(bksp->ac_memdecode[grp->group]);
        grp->board = board;
        if (grp->group == 0) {
            grp->factor = INTLV0(bksp->ac_memctl);
        } else {    /* assume it is group 1 */
            grp->factor = INTLV1(bksp->ac_memctl);
        }
        grp->groupid = '\0';    /* Not in a group yet */

        /*
         * find the interleave list this group belongs on. If the
         * interleave list corresponding to this base address is
         * not found, then create a new one.
         */

        i = 0;
        intrp = &inter_grps.i_grp[0];
        found = 0;
        while ((i < MAX_GROUPS) && !found && (intrp->valid != 0)) {
            if ((intrp->valid != 0) &&
                (intrp->base == grp->base)) {
                grp->groupid = intrp->groupid;
                intrp->count++;
                found = 1;
            }
            i++;
            intrp++;
        }
        /*
         * We did not find a matching base. So now i and intrp
         * now point to the next interleave group in the list.
         */
        if (!found) {
            intrp->count++;
            intrp->valid = 1;
            intrp->groupid = 'A' + (char)i;
            intrp->base = grp->base;
            grp->groupid = intrp->groupid;
        }
    }
}


static void
get_mem_total(struct mem_total *mem_total, struct grp_info *grps)
{
    struct grp *grp;
    int i;

    /* Start with total of zero */
    mem_total->dram = 0;
    mem_total->nvsimm = 0;

    /* For now we ignore NVSIMMs. We might want to fix this later. */
    for (i = 0, grp = &grps->grp[0]; i < MAX_GROUPS; i++, grp++) {
        if (grp->valid == 1 && grp->status == StActive) {
            mem_total->dram += grp->size;
        }
    }
}

static int
disp_fault_list(Sys_tree *tree, struct system_kstat_data *kstats)
{
    struct ft_list *ftp;
    int i;
    int result = 0;
    time_t t;

    if (!kstats->ft_kstat_ok) {
        return (result);
    }

    for (i = 0, ftp = kstats->ft_array; i < kstats->nfaults; i++, ftp++) {
        if (!result) {
            log_printf("\n", 0);
            log_printf("Detected System Faults\n", 0);
            log_printf("======================\n", 0);
        }
        result = 1;
        if (ftp->fclass == FT_BOARD) {
            log_printf("Board %d fault: %s\n", ftp->unit,
                ftp->msg, 0);

            /*
             * If the fault on this board is PROM inherited, see
             * if we can find some failed component information
             * in the PROM device tree. The general solution
             * would be to fix the fhc driver and have it put in
             * more descriptive messages, but that's for another
             * day.
             */

            if (ftp->type == FT_PROM) {
                Board_node *bn;
                Prom_node *pn;
                char *str;

                bn = find_board(tree, ftp->unit);
                /*
                 * If any nodes under this board have a
                 * status containing "fail", print it out.
                 */
                pn = find_failed_node(bn->nodes);
                while (pn) {
                    str = get_prop_val(find_prop(pn,
                        "status"));
                    if (str != NULL) {
                        log_printf("Fault: %s\n", str,
                            0);
                    }

                    pn = next_failed_node(pn);
                }
            }
        } else if ((ftp->type == FT_CORE_PS) || (ftp->type == FT_PPS)) {
            log_printf("Unit %d %s failure\n", ftp->unit,
                ftp->msg, 0);
        } else if ((ftp->type == FT_OVERTEMP) &&
            (ftp->fclass == FT_SYSTEM)) {
            log_printf("Clock board %s\n", ftp->msg, 0);
        } else {
            log_printf("%s failure\n", ftp->msg, 0);
        }

        t = (time_t)ftp->create_time;
        log_printf("\tDetected %s",
            asctime(localtime(&t)), 0);
    }

    if (!result) {
        log_printf("\n", 0);
        log_printf("No System Faults found\n", 0);
        log_printf("======================\n", 0);
    }

    log_printf("\n", 0);

    return (result);
}


/*
 * disp_err_log
 *
 * Display the fatal hardware reset system error logs. These logs are
 * collected by POST and passed up through the kernel to userland.
 * They will not necessarily be present in all systems. Their form
 * might also be different in different systems.
 *
 * NOTE - We are comparing POST defined board types here. Do not confuse
 * them with kernel board types. The structure being analyzed in this
 * function is created by POST. All the defines for it are in reset_info.h,
 * which was ported from POST header files.
 */
static int
disp_err_log(struct system_kstat_data *kstats)
{
    int exit_code = 0;
    int i;
    struct reset_info *rst_info;
    struct board_info *bdp;
    char *err_msgs[MAX_MSGS]; /* holds all messages for a system board */
    int msg_idx;        /* current msg number */
    int count;      /* number added by last analyze call */
    char **msgs;

    /* start by initializing the err_msgs array to all NULLs */
    for (i = 0; i < MAX_MSGS; i++) {
        err_msgs[i] = NULL;
    }

    /* First check to see that the reset-info kstats are present. */
    if (kstats->reset_kstats_ok == 0) {
        return (exit_code);
    }

    rst_info = &kstats->reset_info;

    /* Everything is OK, so print out time/date stamp first */
    log_printf("\n", 0);
    log_printf(
        dgettext(TEXT_DOMAIN,
            "Analysis of most recent Fatal Hardware Watchdog:\n"),
            0);
    log_printf("======================================================\n",
        0);
    log_printf("Log Date: %s\n",
        get_time(&kstats->reset_info.tod_timestamp[0]), 0);

    /* initialize the vector and the message index. */
    msgs = err_msgs;
    msg_idx = 0;

    /* Loop Through all of the boards. */
    bdp = &rst_info->bd_reset_info[0];
    for (i = 0; i < MAX_BOARDS; i++, bdp++) {

        /* Is there data for this board? */
        if ((bdp->board_desc & BD_STATE_MASK) == BD_NOT_PRESENT) {
            continue;
        }

        /* If it is a CPU Board, look for CPU data. */
        if (BOARD_TYPE(bdp->board_desc) == CPU_TYPE) {
            /* analyze CPU 0 if present */
            if (bdp->board_desc & CPU0_OK) {
                count = analyze_cpu(msgs, 0,
                    bdp->cpu[0].afsr);
                msgs += count;
                msg_idx += count;
            }

            /* analyze CPU1 if present. */
            if (bdp->board_desc & CPU1_OK) {
                count = analyze_cpu(msgs, 1,
                    bdp->cpu[1].afsr);
                msgs += count;
                msg_idx += count;
            }
        }

        /* Always Analyze the AC and the DCs on a board. */
        count = analyze_ac(msgs, bdp->ac_error_status);
        msgs += count;
        msg_idx += count;

        count = analyze_dc(i, msgs, bdp->dc_shadow_chain);
        msgs += count;
        msg_idx += count;

        if (msg_idx != 0)
            display_msgs(err_msgs, i);

        erase_msgs(err_msgs);

        /* If any messages are logged, we have errors */
        if (msg_idx != 0) {
            exit_code = 1;
        }

        /* reset the vector and the message index */
        msg_idx = 0;
        msgs = &err_msgs[0];
    }

    return (exit_code);
}

static void
erase_msgs(char **msgs)
{
    int i;

    for (i = 0; (*msgs != NULL) && (i < MAX_MSGS); i++, msgs++) {
        free(*msgs);
        *msgs = NULL;
    }
}


static void
display_msgs(char **msgs, int board)
{
    int i;

    /* display the header for this board */
    print_header(board);

    for (i = 0; (*msgs != NULL) && (i < MAX_MSGS); i++, msgs++) {
        log_printf(*msgs, 0);
    }
}


/*
 * disp_keysw_and_leds
 *
 * This routine displays the position of the keyswitch and the front panel
 * system LEDs. The keyswitch can be in either normal, diagnostic, or
 * secure position. The three front panel LEDs are of importance because
 * the center LED indicates component failure on the system.
 */
static int
disp_keysw_and_leds(struct system_kstat_data *kstats)
{
    int board;
    int diag_mode = 0;
    int secure_mode = 0;
    int result = 0;

    /* Check the first valid board to determeine the diag bit */
    /* Find the first valid board */
    for (board = 0; board < MAX_BOARDS; board++) {
        if (kstats->bd_ksp_list[board].fhc_kstats_ok != 0) {
            /* If this was successful, break out of loop */
            if ((kstats->bd_ksp_list[board].fhc_bsr &
                FHC_DIAG_MODE) == 0)
                diag_mode = 1;
            break;
        }
    }

    /*
     * Check the register on the clock-board to determine the
     * secure bit.
     */
    if (kstats->sys_kstats_ok) {
        /* The secure bit is negative logic. */
        if (kstats->keysw_status == KEY_SECURE) {
            secure_mode = 1;
        }
    }

    /*
     * The system cannot be in diag and secure mode. This is
     * illegal.
     */
    if (secure_mode && diag_mode) {
        result = 2;
        return (result);
    }

    /* Now print the keyswitch position. */
    log_printf("Keyswitch position is in ", 0);

    if (diag_mode) {
        log_printf("Diagnostic Mode\n");
    } else if (secure_mode) {
        log_printf("Secure Mode\n", 0);
    } else {
        log_printf("Normal Mode\n");
    }

    /* display the redundant power status */
    if (kstats->sys_kstats_ok) {
        log_printf("System Power Status: ", 0);

        switch (kstats->power_state) {
        case REDUNDANT:
            log_printf("Redundant\n", 0);
            break;

        case MINIMUM:
            log_printf("Minimum Available\n", 0);
            break;

        case BELOW_MINIMUM:
            log_printf("Insufficient Power Available\n", 0);
            break;

        default:
            log_printf("Unknown\n", 0);
            break;
        }
    }

    if (kstats->sys_kstats_ok) {
        /*
         * If the center LED is on, then we return a non-zero
         * result.
         */
        log_printf("System LED Status:    GREEN     YELLOW     "
            "GREEN\n", 0);
        if ((kstats->sysctrl & SYS_LED_MID) != 0) {
            log_printf("WARNING                ", 0);
        } else {
            log_printf("Normal                 ", 0);
        }

        /*
         * Left LED is negative logic, center and right LEDs
         * are positive logic.
         */
        if ((kstats->sysctrl & SYS_LED_LEFT) == 0) {
            log_printf("ON ", 0);
        } else {
            log_printf("OFF", 0);
        }

        log_printf("       ", 0);
        if ((kstats->sysctrl & SYS_LED_MID) != 0) {
            log_printf("ON ", 0);
        } else {
            log_printf("OFF", 0);
        }

        log_printf("       BLINKING", 0);
    }

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

/*
 * disp_env_status
 *
 * This routine displays the environmental status passed up from
 * device drivers via kstats. The kstat names are defined in
 * kernel header files included by this module.
 */
static int
disp_env_status(struct system_kstat_data *kstats)
{
    struct bd_kstat_data *bksp;
    int exit_code = 0;
    int i;
    uchar_t curr_temp;
    int is4slot = 0;

    /*
     * Define some message arrays to make life simpler.  These
     * messages correspond to definitions in <sys/fhc.c> for
     * temperature trend (enum temp_trend) and temperature state
     * (enum temp_state).
     */
    static char *temp_trend_msg[] = {   "unknown",
                        "rapidly falling",
                        "falling",
                        "stable",
                        "rising",
                        "rapidly rising",
                        "unknown (noisy)"
                    };
    static char *temp_state_msg[] = {   "   OK    ",
                        "WARNING  ",
                        " DANGER  "
                    };

    log_printf("\n", 0);
    log_printf("=========================", 0);
    log_printf(dgettext(TEXT_DOMAIN, " Environmental Status "), 0);
    log_printf("=========================", 0);
    log_printf("\n", 0);

    exit_code = disp_keysw_and_leds(kstats);

    if (!kstats->sys_kstats_ok) {
        log_printf(dgettext(TEXT_DOMAIN,
            "*** Error: Unavailable ***\n\n"));
        return (1);
    }

    /*
     * for purposes within this routine,
     * 5 slot behaves the same as a 4 slot
     */
    if (SYS_TYPE(kstats->sysstat1) == SYS_4_SLOT)
        is4slot = 1;

    log_printf("\n", 0);
    log_printf("\nFans:\n", 0);
    log_printf("-----\n", 0);

    log_printf("Unit   Status\n", 0);
    log_printf("----   ------\n", 0);

    log_printf("%-4s    ", is4slot ? "Disk" : "Rack", 0);
    /* Check the status of the Rack Fans */
    if ((kstats->fan_status & SYS_RACK_FANFAIL) == 0) {
        log_printf("OK\n", 0);
    } else {
        log_printf("FAIL\n", 0);
        exit_code = 1;
    }

    if (!is4slot) {
        /*
         * keyswitch and ac box are on 8 & 16 slot only
         */
        /* Check the status of the Keyswitch Fan assembly. */
        log_printf("%-4s    ", "Key", 0);
        if ((kstats->fan_status & SYS_KEYSW_FAN_OK) != 0) {
            log_printf("OK\n", 0);
        } else {
            log_printf("FAIL\n", 0);
            exit_code = 1;
        }

        log_printf("%-4s    ", "AC", 0);
        if ((kstats->fan_status & SYS_AC_FAN_OK) != 0) {
            log_printf("OK\n", 0);
        } else {
            log_printf("FAIL\n", 0);
            exit_code = 1;
        }
    } else {
        /*
         * peripheral fan is on 4 slot only
         * XXX might want to indicate transient states too
         */
        if (kstats->psstat_kstat_ok) {
            if (kstats->ps_shadow[SYS_P_FAN_INDEX] == PS_OK) {
                log_printf("PPS     OK\n", 0);
            } else if (kstats->ps_shadow[SYS_P_FAN_INDEX] ==
                PS_FAIL) {
                log_printf("PPS     FAIL\n", 0);
                exit_code = 1;
            }
        }
    }

    log_printf("\n", 0);


    log_printf("System Temperatures (Celsius):\n", 0);
    log_printf("------------------------------\n", 0);
    log_printf("Brd   State   Current  Min  Max  Trend\n", 0);
    log_printf("---  -------  -------  ---  ---  -----\n", 0);

    for (i = 0, bksp = &kstats->bd_ksp_list[0]; i < MAX_BOARDS;
        i++, bksp++) {

        /* Make sure we have kstats for this board first */
        if (!bksp->temp_kstat_ok) {
            continue;
        }
        log_printf("%2d   ", i, 0);

        /* Print the current state of the temperature */
        log_printf("%s", temp_state_msg[bksp->tempstat.state], 0);
        /* Set exit code for WARNING and DANGER */
        if (bksp->tempstat.state != 0)
            exit_code = 1;

        /* Print the current temperature */
        curr_temp = bksp->tempstat.l1[bksp->tempstat.index % L1_SZ];
        log_printf("   %2d    ", curr_temp, 0);

        /* Print the minimum recorded temperature */
        log_printf(" %2d  ", bksp->tempstat.min, 0);

        /* Print the maximum recorded temperature */
        log_printf(" %2d  ", bksp->tempstat.max, 0);

        /* Print the current trend in temperature (if available) */
        if (bksp->tempstat.version < 2)
            log_printf("unknown\n", 0);
        else
            log_printf("%s\n", temp_trend_msg[bksp->tempstat.trend], 0);
    }
    if (kstats->temp_kstat_ok) {
        log_printf("CLK  ", 0);

        /* Print the current state of the temperature */
        log_printf("%s", temp_state_msg[kstats->tempstat.state], 0);
        /* Set exit code for WARNING or DANGER */
        if (kstats->tempstat.state != 0)
            exit_code = 1;

        /* Print the current temperature */
        curr_temp = kstats->tempstat.l1[kstats->tempstat.index % L1_SZ];
        log_printf("   %2d    ", curr_temp, 0);

        /* Print the minimum recorded temperature */
        log_printf(" %2d  ", kstats->tempstat.min, 0);

        /* Print the maximum recorded temperature */
        log_printf(" %2d  ", kstats->tempstat.max, 0);

        /* Print the current trend in temperature (if available) */
        if (kstats->tempstat.version < 2)
            log_printf("unknown\n\n", 0);
        else
            log_printf("%s\n\n",
                temp_trend_msg[kstats->tempstat.trend], 0);
    } else {
        log_printf("\n");
    }

    log_printf("\n", 0);
    log_printf("Power Supplies:\n", 0);
    log_printf("---------------\n", 0);
    log_printf("Supply                        Status\n", 0);
    log_printf("---------                     ------\n", 0);
    if (kstats->psstat_kstat_ok) {
        for (i = 0; i < SYS_PS_COUNT; i++) {
            char *ps, *state;

            /* skip core power supplies that are not present */
            if (i <= SYS_PPS0_INDEX && kstats->ps_shadow[i] ==
                PS_OUT)
                continue;

            /* Display the unit Number */
            switch (i) {
            case 0: ps = "0"; break;
            case 1: ps = "1"; break;
            case 2: ps = "2"; break;
            case 3: ps = "3"; break;
            case 4: ps = "4"; break;
            case 5: ps = "5"; break;
            case 6: ps = "6"; break;
            case 7: ps = is4slot ? "2nd PPS" : "7"; break;

            case SYS_PPS0_INDEX: ps = "PPS"; break;
            case SYS_CLK_33_INDEX: ps = "    System 3.3v"; break;
            case SYS_CLK_50_INDEX: ps = "    System 5.0v"; break;
            case SYS_V5_P_INDEX: ps = "    Peripheral 5.0v"; break;
            case SYS_V12_P_INDEX: ps = "    Peripheral 12v"; break;
            case SYS_V5_AUX_INDEX: ps = "    Auxiliary 5.0v"; break;
            case SYS_V5_P_PCH_INDEX: ps =
                "    Peripheral 5.0v precharge";
                break;
            case SYS_V12_P_PCH_INDEX: ps =
                "    Peripheral 12v precharge";
                break;
            case SYS_V3_PCH_INDEX: ps =
                "    System 3.3v precharge"; break;
            case SYS_V5_PCH_INDEX: ps =
                "    System 5.0v precharge"; break;

            /* skip the peripheral fan here */
            case SYS_P_FAN_INDEX:
                continue;
            }

            /* what is the state? */
            switch (kstats->ps_shadow[i]) {
            case PS_OK:
                state = "OK";
                break;

            case PS_FAIL:
                state = "FAIL";
                exit_code = 1;
                break;

            /* XXX is this an exit_code condition? */
            case PS_OUT:
                state = "PPS Out";
                exit_code = 1;
                break;

            case PS_UNKNOWN:
                state = "Unknown";
                break;

            default:
                state = "Illegal State";
                break;
            }

            log_printf("%-32s %s\n", ps, state, 0);
        }
    }

    /* Check status of the system AC Power Source */
    log_printf("%-32s ", "AC Power", 0);
    if ((kstats->sysstat2 & SYS_AC_FAIL) == 0) {
        log_printf("OK\n", 0);
    } else {
        log_printf("failed\n", 0);
        exit_code = 1;
    }
    log_printf("\n", 0);

    return (exit_code);
}


/*
 * Many of the ASICs present in fusion machines have implementation and
 * version numbers stored in the OBP device tree. These codes are displayed
 * in this routine in an effort to aid Engineering and Field service
 * in detecting old ASICs which may have bugs in them.
 */
static void
sunfire_disp_asic_revs(Sys_tree *tree, struct system_kstat_data *kstats)
{
    Board_node *bnode;
    Prom_node *pnode;
    int isplusbrd;
    char *board_str[] = {   "Uninitialized", "Unknown", "CPU",
                "Memory", "Dual-SBus", "UPA-SBus",
                "Dual-PCI", "Disk", "Clock",
                "Dual-SBus-SOC+", "UPA-SBus-SOC+"};

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

    /* Else this is a Sunfire or campfire */
    log_printf("ASIC Revisions:\n", 0);
    log_printf("---------------\n", 0);

    /* Display Firetruck ASIC Revisions first */
    log_printf("Brd  FHC  AC  SBus0  SBus1  PCI0  PCI1  FEPS", 0);
    log_printf("  Board Type      Attributes", 0);
    log_printf("\n", 0);
    log_printf("---  ---  --  -----  -----  ----  ----  ----", 0);
    log_printf("  ----------      ----------", 0);
    log_printf("\n", 0);

    /*
     * Display all of the FHC, AC, and chip revisions for the entire
     * machine. The AC anf FHC chip revs are available  from the device
     * tree that was read out of the PROM, but the DC chip revs will be
     * read via a kstat. The interfaces for this are not completely
     * available at this time.
     */
    bnode = tree->bd_list;
    while (bnode != NULL) {
        int *version;
        int upa = bd_to_upa(bnode->board_num);

        /* Display the header with the board number */
        log_printf("%2d   ", bnode->board_num, 0);

        /* display the FHC version */
        if ((pnode = dev_find_node(bnode->nodes, "fhc")) == NULL) {
            log_printf("     ", 0);
        } else {
            if ((version = (int *)get_prop_val(find_prop(pnode,
                "version#"))) == NULL) {
                log_printf("     ", 0);
            } else {
                log_printf(" %d   ", *version, 0);
            }
        }

        /* display the AC version */
        if ((pnode = dev_find_node(bnode->nodes, "ac")) == NULL) {
            log_printf("    ", 0);
        } else {
            if ((version = (int *)get_prop_val(find_prop(pnode,
                "version#"))) == NULL) {
                log_printf("    ", 0);
            } else {
                log_printf(" %d  ", *version, 0);
            }
        }

        /* Find sysio 0 on board and print rev */
        if ((pnode = find_device(bnode, upa, "sbus")) == NULL) {
            log_printf("       ", 0);
        } else {
            if ((version = (int *)get_prop_val(find_prop(pnode,
                "version#"))) == NULL) {
                log_printf("       ", 0);
            } else {
                log_printf("  %d    ", *version, 0);
            }
        }

        /* Find sysio 1 on board and print rev */
        if ((pnode = find_device(bnode, upa+1, "sbus")) == NULL) {
            log_printf("       ", 0);
        } else {
            if ((version = (int *)get_prop_val(find_prop(pnode,
                "version#"))) == NULL) {
                log_printf("       ", 0);
            } else {
                log_printf("  %d    ", *version, 0);
            }
        }

        /* Find Psycho 0 on board and print rev */
        if ((pnode = find_device(bnode, upa, "pci")) == NULL) {
            log_printf("      ", 0);
        } else {
            if ((version = (int *)get_prop_val(find_prop(pnode,
                "version#"))) == NULL) {
                log_printf("      ", 0);
            } else {
                log_printf(" %d    ", *version, 0);
            }
        }

        /* Find Psycho 1 on board and print rev */
        if ((pnode = find_device(bnode, upa+1, "pci")) == NULL) {
            log_printf("      ", 0);
        } else {
            if ((version = (int *)get_prop_val(find_prop(pnode,
                "version#"))) == NULL) {
                log_printf("      ", 0);
            } else {
                log_printf(" %d    ", *version, 0);
            }
        }

        /* Find the FEPS on board and print rev */
        if ((pnode = dev_find_node(bnode->nodes, "SUNW,hme")) != NULL) {
            if ((version = (int *)get_prop_val(find_prop(pnode,
                "hm-rev"))) != NULL) {
                if (*version == 0xa0) {
                    log_printf(" 2.0  ", 0);
                } else if (*version == 0x20) {
                    log_printf(" 2.1  ", 0);
                } else {
                    log_printf(" %2x   ", *version, 0);
                }
            }
        } else
            log_printf("      ", 0);

        /* print out the board type */
        isplusbrd = ISPLUSBRD(kstats->bd_ksp_list
                [bnode->board_num].fhc_bsr);

        log_printf("%-16s", board_str[bnode->board_type], 0);
        if (isplusbrd)
            log_printf("100MHz Capable", 0);
        else
            log_printf("84MHz Capable", 0);

        log_printf("\n", 0);
        bnode = bnode->next;
    }
    log_printf("\n", 0);

    /* Now display the FFB board component revisions */
    for (bnode = tree->bd_list; bnode != NULL; bnode = bnode->next) {
        display_ffb(bnode, 0);
    }
}

static void
display_hp_boards(struct system_kstat_data *kstats)
{
    int i;
    int j;
    int hp_found = 0;
    struct hp_info *hp;
    char *state;

    for (i = 0, hp = &kstats->hp_info[0]; i < MAX_BOARDS; i++, hp++) {
        if (!hp->kstat_ok) {
            continue;
        }

        hp_found = 1;
    }

    /* return if there are no hotplug boards in the system. */
    if (!hp_found) {
        return;
    }

    if (hp_found != 0) {
        log_printf("\n", 0);
        log_printf("Detached Boards\n", 0);
        log_printf("===============\n", 0);
        log_printf("  Slot  State       Type           Info\n", 0);
        log_printf("  ----  ---------   ------         ----"
            "-------------------------------------\n", 0);
    }

    /* Display all detached boards */
    for (i = 0, hp = &kstats->hp_info[0]; i < MAX_BOARDS; i++, hp++) {
        struct cpu_info *cpu;

        if (hp->kstat_ok == 0) {
            continue;
        }


        switch (hp->bd_info.state) {
        case UNKNOWN_STATE:
            state = "unknown";
            break;

        case ACTIVE_STATE:
            state = "active";
            break;

        case LOWPOWER_STATE:
            state = "low-power";
            break;

        case HOTPLUG_STATE:
            state = "hot-plug";
            break;

        case DISABLED_STATE:
            state = "disabled";
            break;

        case FAILED_STATE:
            state = "failed";
            break;

        default:
            state = "unknown";
            break;
        }

        log_printf("   %2d   %9s   ", i, state, 0);

        switch (hp->bd_info.type) {
        case MEM_BOARD:
            log_printf("%-14s ", MEM_BD_NAME, 0);
            break;

        case CPU_BOARD:
            log_printf("%-14s ", CPU_BD_NAME, 0);

            /* Cannot display CPU info for disabled boards */
            if ((hp->bd_info.state == DISABLED_STATE) ||
                (hp->bd_info.state == FAILED_STATE)) {
                break;
            }

            /* Display both CPUs if present */
            cpu = &hp->bd_info.bd.cpu[0];
            for (j = 0; j < 2; j++, cpu++) {
                log_printf("CPU %d: ", j, 0);
                /* Print the rated speed of the CPU. */
                if (cpu->cpu_speed > 1) {
                    log_printf("%3d MHz", cpu->cpu_speed,
                        0);
                } else {
                    log_printf("no CPU       ", 0);
                    continue;
                }

                /* Display the size of the cache */
                if (cpu->cache_size != 0) {
                    log_printf(" %0.1fM ",
                        (float)cpu->cache_size /
                        (float)(1024*1024), 0);
                } else {
                    log_printf("    ", 0);
                }
            }
            break;

        case IO_2SBUS_BOARD:
            log_printf("%-14s ", IO_2SBUS_BD_NAME, 0);
            break;

        case IO_2SBUS_SOCPLUS_BOARD:
            log_printf("%-14s ", IO_2SBUS_SOCPLUS_BD_NAME, 0);
            break;

        case IO_SBUS_FFB_BOARD:
            log_printf("%-14s ", IO_SBUS_FFB_BD_NAME, 0);
            switch (hp->bd_info.bd.io2.ffb_size) {
            case FFB_SINGLE:
                log_printf("Single buffered FFB", 0);
                break;

            case FFB_DOUBLE:
                log_printf("Double buffered FFB", 0);
                break;

            case FFB_NOT_FOUND:
                log_printf("No FFB installed", 0);
                break;

            default:
                log_printf("Illegal FFB size", 0);
                break;
            }
            break;

        case IO_SBUS_FFB_SOCPLUS_BOARD:
            log_printf("%-14s ", IO_SBUS_FFB_SOCPLUS_BD_NAME, 0);
            switch (hp->bd_info.bd.io2.ffb_size) {
            case FFB_SINGLE:
                log_printf("Single buffered FFB", 0);
                break;

            case FFB_DOUBLE:
                log_printf("Double buffered FFB", 0);
                break;

            case FFB_NOT_FOUND:
                log_printf("No FFB installed", 0);
                break;

            default:
                log_printf("Illegal FFB size", 0);
                break;
            }
            break;

        case IO_PCI_BOARD:
            log_printf("%-14s ", IO_PCI_BD_NAME, 0);
            break;

        case DISK_BOARD:
            log_printf("%-14s ", "disk", 0);
            for (j = 0; j < 2; j++) {
                log_printf("Disk %d:", j, 0);
                if (hp->bd_info.bd.dsk.disk_pres[j]) {
                    log_printf(" Target: %2d   ",
                        hp->bd_info.bd.dsk.disk_id[j],
                        0);
                } else {
                    log_printf(" no disk      ", 0);
                }
            }
            break;

        case UNKNOWN_BOARD:
        case UNINIT_BOARD:
        default:
            log_printf("UNKNOWN ", 0);
            break;
        }
        log_printf("\n");
    }
}

/*
 * Analysis functions:
 *
 * Most of the Fatal error data analyzed from error registers is not
 * very complicated. This is because the FRUs for errors detected by
 * most parts is either a CPU module, a FFB, or the system board
 * itself.
 * The analysis of the Address Controller errors is the most complicated.
 * These errors can be caused by other boards as well as the local board.
 */

/*
 * analyze_cpu
 *
 * Analyze the CPU MFSR passed in and determine what type of fatal
 * hardware errors occurred at the time of the crash. This function
 * returns a pointer to a string to the calling routine.
 */
static int
analyze_cpu(char **msgs, int cpu_id, u_longlong_t afsr)
{
    int count = 0;
    int i;
    int syndrome;
    char msgbuf[MAXSTRLEN];

    if (msgs == NULL) {
        return (count);
    }

    if (afsr & P_AFSR_ETP) {
        (void) sprintf(msgbuf, "CPU %d Ecache Tag Parity Error, ",
            cpu_id);

        /* extract syndrome for afsr */
        syndrome = (afsr & P_AFSR_ETS) >> ETS_SHIFT;

        /* now concat the parity syndrome msg */
        for (i = 0; i < 4; i++) {
            if ((0x1 << i)  & syndrome) {
                (void) strcat(msgbuf, ecache_parity[i]);
            }
        }
        (void) strcat(msgbuf, "\n");
        *msgs++ = strdup(msgbuf);
        count++;
    }

    if (afsr & P_AFSR_ISAP) {
        (void) sprintf(msgbuf,
            "CPU %d Incoming System Address Parity Error\n",
            cpu_id);
        *msgs++ = strdup(msgbuf);
        count++;
    }

    return (count);
}

/*
 * analyze_ac
 *
 * This function checks the AC error register passed in and checks
 * for any errors that occured during the fatal hardware reset.
 */
static int
analyze_ac(char **msgs, u_longlong_t ac_error)
{
    int i;
    int count = 0;
    char msgbuf[MAXSTRLEN];
    int tmp_cnt;

    if (msgs == NULL) {
        return (count);
    }

    for (i = 2; i < MAX_BITS; i++) {
        if ((((u_longlong_t)0x1 << i) & ac_error) != 0) {
            if (ac_errors[i].error != NULL) {
                (void) sprintf(msgbuf, "AC: %s\n",
                    ac_errors[i].error);
                *msgs++ = strdup(msgbuf);
                count++;

                /* display the part that might cause this */
                tmp_cnt = disp_parts(msgs, ac_error, i);
                count += tmp_cnt;
                msgs += tmp_cnt;
            }
        }
    }

    return (count);
}

/*
 * analyze_dc
 *
 * This routine checks the DC shdow chain and tries to determine
 * what type of error might have caused the fatal hardware reset
 * error.
 */
static int
analyze_dc(int board, char **msgs, u_longlong_t dc_error)
{
    int i;
    int count = 0;
    char msgbuf[MAXSTRLEN];

    if (msgs == NULL) {
        return (count);
    }

    /*
     * The DC scan data is contained in 8 bytes, one byte per
     * DC. There are 8 DCs on a system board.
     */

    for (i = 0; i < 8; i++) {
        if (dc_error & DC_OVERFLOW) {
            (void) sprintf(msgbuf, dc_overflow_txt, board, i);
            *msgs++ = strdup(msgbuf);
            count++;
        }

        if (dc_error & DC_PARITY) {
            (void) sprintf(msgbuf, dc_parity_txt, board, i);
            *msgs++ = strdup(msgbuf);
            count++;
        }
        dc_error = dc_error >> 8;   /* shift over to next byte */
    }

    return (count);
}

static int
disp_parts(char **msgs, u_longlong_t ac_error, int type)
{
    int count = 0;
    int part;
    char msgbuf[MAXSTRLEN];
    int i;

    if (msgs == NULL) {
        return (count);
    }

    (void) sprintf(msgbuf, "\tThe error could be caused by:\n");
    *msgs++ = strdup(msgbuf);
    count++;

    for (i = 0; (i < MAX_FRUS) && ac_errors[type].part[i]; i++) {
        part = ac_errors[type].part[i];

        if (part == UPA_PART) {
            if (ac_error & UPA_PORT_A) {
                part = UPA_A_PART;
            } else if (ac_error & UPA_PORT_B) {
                part = UPA_B_PART;
            }
        }

        if (part == DTAG_PART) {
            if (ac_error & UPA_PORT_A) {
                part = DTAG_A_PART;
            } else if (ac_error & UPA_PORT_B) {
                part = DTAG_B_PART;
            }
        }

        (void) sprintf(msgbuf, "\t\t%s\n", part_str[part]);

        *msgs++ = strdup(msgbuf);
        count++;
    }

    return (count);
}