opl/common/opl_picl.c

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

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <kstat.h>
#include <fcntl.h>
#include <string.h>
#include <assert.h>
#include <libintl.h>
#include <note.h>
#include <dlfcn.h>
#include <errno.h>
#include <sys/systeminfo.h>
#include <sys/openpromio.h>
#include <sys/sysmacros.h>
#include <picl.h>
#include "picldefs.h"
#include <pdevinfo.h>
#include <display.h>
#include <libprtdiag.h>
#include <alloca.h>
#include "opl_picl.h"
#include <sys/pci.h>
#include <sys/pci_tools.h>
#include <sys/types.h>

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

static picl_errno_t do_walk(picl_nodehdl_t rooth, const char *classname,
    void *c_args, picl_errno_t (*callback_fn)(picl_nodehdl_t hdl, void *args));
static int opl_get_node_by_name(picl_nodehdl_t rooth, char *name,
    picl_nodehdl_t *nodeh);
static picl_errno_t get_lane_width(char *device_path, int bus_no, int func_no,
    int dev_no, int *actual, int *maximum, uint32_t *speed_max,
    uint32_t *speed_at, int *type);
static int  opl_display_pci(int syserrlog, picl_nodehdl_t plafh);
static picl_errno_t opl_pci_callback(picl_nodehdl_t pcih, void *args);
static int opl_get_first_compatible_value(picl_nodehdl_t nodeh,
    char **outbuf);
static int picldiag_get_clock_freq(picl_nodehdl_t modh,
    uint32_t *freq, uint32_t *freq_max);
static uint64_t picldiag_get_uint_propval(picl_nodehdl_t modh,
    char *prop_name, int *ret);
static uint32_t read_long(int fd, int bus, int dev, int func,
    int offset, int *ret);
static uint8_t read_byte(int fd, int bus, int dev, int func, int offset,
    int *ret);
static uint16_t read_word(int fd, int bus, int dev, int func, int offset,
    int *ret);

/*
 * Collect I/O nodes information.
 */
/* ARGSUSED */
static picl_errno_t
opl_pci_callback(picl_nodehdl_t pcih, void *args)
{
    picl_errno_t    err = PICL_SUCCESS;
    picl_nodehdl_t  nodeh;
    picl_prophdl_t  proph;
    picl_propinfo_t pinfo;
    char        path[MAXSTRLEN];
    char        parent_path[MAXSTRLEN];
    static char root_path[MAXSTRLEN];
    char        piclclass[PICL_CLASSNAMELEN_MAX];
    char        name[MAXSTRLEN];
    char        model[MAXSTRLEN];
    char        *compatible;
    char        binding_name[MAXSTRLEN];
    struct io_card  pci_card;
    char        status[6] = "N/A";
    int     portid = PROP_INVALID;
    int     *reg_val;
    int     board = PROP_INVALID;
    static int  saved_board = PROP_INVALID;
    static int  saved_portid = PROP_INVALID;
    int         actual = PROP_INVALID, maximum = PROP_INVALID;
    int         bus_type;
    int         rev_id = PROP_INVALID, dev_id = PROP_INVALID;
    int     ven_id = PROP_INVALID;
    size_t      prop_size;

    (void) memset(&pci_card, 0, sizeof (pci_card));

    err = picl_get_propval_by_name(pcih, PICL_PROP_CLASSNAME,
        piclclass, sizeof (piclclass));

    if (err !=  PICL_SUCCESS)
        /* Do not proceed to parse this branch */
        return (err);

    if (!IS_PCI(piclclass))
        /* Do not parse non-pci nodes */
        return (PICL_INVALIDARG);

    err = picl_get_propval_by_name(pcih, PICL_PROP_DEVFS_PATH, parent_path,
        sizeof (parent_path));
    if (err != PICL_SUCCESS)
        /* Do not proceed to parse this branch */
        return (err);
    err = picl_get_propval_by_name(pcih, OBP_PROP_BOARD_NUM, &board,
        sizeof (board));

    if (err == PICL_NORESPONSE)
        /* Do not proceed to parse this branch */
        return (err);
    else if (err != PICL_PROPNOTFOUND) {
        saved_board = board;
        /* Save board node's pathname */
        prop_size = sizeof (parent_path) + 1;
        if (prop_size > MAXSTRLEN)
            prop_size = MAXSTRLEN;
        (void) strlcpy(root_path, parent_path, prop_size);
    }

    err = picl_get_propval_by_name
        (pcih, OBP_PROP_PORTID, &portid, sizeof (portid));

    if (err != PICL_PROPNOTFOUND)
        saved_portid = portid;

    /* Walk through the children */

    err = picl_get_propval_by_name(pcih, PICL_PROP_CHILD, &nodeh,
        sizeof (picl_nodehdl_t));

    while (err == PICL_SUCCESS) {
        uint32_t    freq_max = 0, freq_at = 0;

        err = picl_get_propval_by_name(nodeh, PICL_PROP_CLASSNAME,
            piclclass, sizeof (piclclass));
        if (err !=  PICL_SUCCESS)
            /* Do not proceed to parse this node */
            return (err);

        if (IS_EBUS(piclclass)) {
            err = picl_get_propval_by_name(nodeh, PICL_PROP_PEER,
                &nodeh, sizeof (picl_nodehdl_t));
            continue;
        }

        err = picl_get_propval_by_name(nodeh, PICL_PROP_DEVFS_PATH,
            path, sizeof (path));
        if (err != PICL_SUCCESS) {
            /* Do not proceed to parse this node */
            return (err);
        }

        prop_size = sizeof (path) + 1;
        if (prop_size > MAXSTRLEN)
            prop_size = MAXSTRLEN;
        (void) strlcpy(pci_card.notes, path, prop_size);

        pci_card.board = saved_board;
        pci_card.schizo_portid = saved_portid;

        /*
         * Get bus#, dev# and func# for this card from 'reg' property.
         */

        err = picl_get_propinfo_by_name
            (nodeh, OBP_PROP_REG, &pinfo, &proph);
        if (err == PICL_SUCCESS) {
            /* All of the array of bytes of "reg" have to be read */
            reg_val = malloc(pinfo.size);
            if (reg_val == NULL)
                return (PICL_FAILURE);


            err = picl_get_propval_by_name
                (nodeh, OBP_PROP_REG, reg_val, pinfo.size);

            if (err != PICL_SUCCESS) {
                free(reg_val);
                /* Do not proceed to parse this node */
                return (err);
            }

            if (reg_val[0] != 0) {
                pci_card.dev_no =
                    (((reg_val[0]) & PCI_DEV_MASK) >> 11);
                pci_card.func_no =
                    (((reg_val[0]) & PCI_FUNC_MASK) >> 8);
                pci_card.slot =
                    (((reg_val[0]) & PCI_BUS_MASK) >> 16);
            } else
                free(reg_val);
        }

        err = get_lane_width(root_path, pci_card.slot, pci_card.dev_no,
            pci_card.func_no, &actual, &maximum, &freq_max, &freq_at,
            &bus_type);

        if (err != PICL_SUCCESS) {
            /*
             * get_lane_width will fail when run as non-root.
             * Set bus_type to PCI_UNKN so that bus frequency,
             * bus type and lane width will print as "--" or UNKN.
             */
            bus_type = PCI_UNKN;
        }


        err = picl_get_propval_by_name
            (nodeh, PICL_PROP_NAME, name, sizeof (name));
        if (err != PICL_SUCCESS)
            (void) strcpy(name, "");

        /*
         * Get the name of this card. If binding_name is found,
         * name will be <nodename>-<binding_name>
         */

        err = picl_get_propval_by_name(nodeh, PICL_PROP_BINDING_NAME,
            binding_name, sizeof (binding_name));
        if (err == PICL_PROPNOTFOUND) {
            /*
             * if compatible prop is found, name will be
             * <nodename>-<compatible>
             */
            err = opl_get_first_compatible_value(nodeh,
                &compatible);
            if (err == PICL_SUCCESS) {
                (void) strlcat(name, "-", MAXSTRLEN);
                (void) strlcat(name, compatible, MAXSTRLEN);
                free(compatible);
            }
        } else if (err != PICL_SUCCESS) {
            /* No binding-name or compatible */
            (void) strcpy(binding_name, "N/A");
        } else if (strcmp(name, binding_name) != 0) {
            (void) strlcat(name, "-", MAXSTRLEN);
            (void) strlcat(name, binding_name, MAXSTRLEN);
        }


        prop_size = sizeof (name) + 1;
        if (prop_size > MAXSTRLEN)
            prop_size =  MAXSTRLEN;
        (void) strlcpy(pci_card.name, name, prop_size);

        /* Get the status of the card */
        err = picl_get_propval_by_name
            (nodeh, PICL_PROP_STATUS, status, sizeof (status));


        /* Get the model of this card */

        err = picl_get_propval_by_name
            (nodeh, OBP_PROP_MODEL, model, sizeof (model));
        prop_size = sizeof (model) + 1;
        if (prop_size > MAXSTRLEN)
            prop_size =  MAXSTRLEN;
        if (err != PICL_SUCCESS)
            (void) strcpy(model, "N/A");
        (void) strlcpy(pci_card.model, model, prop_size);

        if (bus_type == PCI)
            (void) strlcpy(pci_card.bus_type,
                "PCI", sizeof (pci_card.bus_type));
        else if (bus_type == PCIX)
            (void) strlcpy(pci_card.bus_type,
                "PCIx", sizeof (pci_card.bus_type));
        else if (bus_type == PCIE)
            (void) strlcpy(pci_card.bus_type,
                "PCIe", sizeof (pci_card.bus_type));
        else
            (void) strlcpy(pci_card.bus_type,
                "UNKN", sizeof (pci_card.bus_type));

        /* Get revision id */
        err = picl_get_propval_by_name
            (nodeh, OBP_PROP_REVISION_ID, &rev_id, sizeof (rev_id));

        /* Get device id */
        err = picl_get_propval_by_name
            (nodeh, OBP_PROP_DEVICE_ID, &dev_id, sizeof (dev_id));

        /* Get vendor id */
        err = picl_get_propval_by_name
            (nodeh, OBP_PROP_VENDOR_ID, &ven_id, sizeof (ven_id));

        /*
         * prtdiag -v prints all devices
         */

        /* Print board number */
        log_printf("%02d  ", pci_card.board);
        /* Print IO Type */
        log_printf("%-5.5s ", pci_card.bus_type);

        log_printf("%-3d  ", pci_card.schizo_portid);
        log_printf("%4x, %4x, %4x     ", rev_id, dev_id, ven_id);

        log_printf("%3d, %2d, %2d",
            pci_card.slot, pci_card.dev_no, pci_card.func_no);

        /* Print status */
        log_printf("  %-5.5s ", status);

        /* Print Lane widths, Max/Sup Freq, Speed */
        if (bus_type == PCIE) {
            PRINT_FMT(actual, maximum);
        } else if (bus_type == PCIX) {
            PRINT_FREQ_FMT(freq_at, freq_max);
        } else if (bus_type == PCI) {
            err = picldiag_get_clock_freq(nodeh, &freq_at,
                &freq_max);
            PRINT_FREQ_FMT(freq_at, freq_max);
        } else
            log_printf(" -- , --   ");

        /* Print Card Name */
        log_printf("%-30.30s", pci_card.name);

        /* Print Card Model */
        log_printf(" %-20.20s", pci_card.model);

        log_printf("\n");

        log_printf("%4s%-100.100s", " ", pci_card.notes);
        log_printf("\n");
        log_printf("\n");


        err = picl_get_propval_by_name
            (nodeh, PICL_PROP_PEER, &nodeh, sizeof (picl_nodehdl_t));

    }

    return (PICL_WALK_CONTINUE);
}

/*
 * opl_display_pci
 * Display all the PCI IO cards on this board.
 */
static int
opl_display_pci(int syserrlog, picl_nodehdl_t plafh)
{
    picl_errno_t err;
    char    *fmt = "%-3s %-5s %-4s %-20s %-11s %-5s %-11s %-30s %-20s";
    char    *fmt2 = "%-16s";
    static int banner = FALSE; /* Have we printed the column headings? */

    if (banner == FALSE) {
        log_printf("\n", 0);
        log_printf("=========================", 0);
        log_printf(dgettext(TEXT_DOMAIN, " IO Devices "), 0);
        log_printf("=========================", 0);
        log_printf("\n", 0);
        log_printf("\n", 0);
        log_printf(fmt, "", "IO", "", "", "", "", "Lane/Frq",
            "", "", 0);
        log_printf("\n", 0);

        log_printf(fmt, "LSB", "Type", "LPID", "  RvID,DvID,VnID",
            "  BDF", "State", "Act,  Max", "Name", "Model", 0);

        log_printf("\n");

        log_printf(fmt,
            "---", "-----", "----", "  ------------------",
            "  ---------", "-----", "-----------",
            "------------------------------",
            "--------------------", 0);
        log_printf("\n");
        log_printf(fmt2, "    Logical Path");
        log_printf("\n");
        log_printf(fmt2, "    ------------");
        log_printf("\n");
        banner = TRUE;
    }

    err = do_walk(plafh, PICL_CLASS_PCI, PICL_CLASS_PCI, opl_pci_callback);
    return (err);
}


/*
 * return the first compatible value
 */
static int
opl_get_first_compatible_value(picl_nodehdl_t nodeh, char **outbuf)
{
    picl_errno_t    err;
    picl_prophdl_t  proph;
    picl_propinfo_t pinfo;
    picl_prophdl_t  tblh;
    picl_prophdl_t  rowproph;
    char        *pval;

    err = picl_get_propinfo_by_name(nodeh, OBP_PROP_COMPATIBLE,
        &pinfo, &proph);
    if (err != PICL_SUCCESS)
        return (err);

    if (pinfo.type == PICL_PTYPE_CHARSTRING) {
        pval = malloc(pinfo.size);
        if (pval == NULL)
            return (PICL_FAILURE);
        err = picl_get_propval(proph, pval, pinfo.size);
        if (err != PICL_SUCCESS) {
            free(pval);
            return (err);
        }
        *outbuf = pval;
        return (PICL_SUCCESS);
    }

    if (pinfo.type != PICL_PTYPE_TABLE)
        return (PICL_FAILURE);

    /* get first string from table */
    err = picl_get_propval(proph, &tblh, pinfo.size);
    if (err != PICL_SUCCESS)
        return (err);

    err = picl_get_next_by_row(tblh, &rowproph);
    if (err != PICL_SUCCESS)
        return (err);

    err = picl_get_propinfo(rowproph, &pinfo);
    if (err != PICL_SUCCESS)
        return (err);

    pval = malloc(pinfo.size);
    if (pval == NULL)
        return (PICL_FAILURE);

    err = picl_get_propval(rowproph, pval, pinfo.size);
    if (err != PICL_SUCCESS) {
        free(pval);
        return (err);
    }

    *outbuf = pval;
    return (PICL_SUCCESS);
}

int
do_piclinfo(int syserrlog)
{
    picl_nodehdl_t rooth;       /* root PICL node for IO display */
    picl_nodehdl_t plafh;       /* Platform PICL node for IO display */

    picl_errno_t err;

    err = picl_initialize();
    if (err != PICL_SUCCESS) {
        (void) log_printf("picl_initialize failed: %s\n",
            picl_strerror(err));
        return (err);
    }


    err = picl_get_root(&rooth);
    if (err != PICL_SUCCESS) {
        (void) log_printf("Getting root node failed: %s\n",
            picl_strerror(err));
        return (err);
    }

    err = opl_get_node_by_name(rooth, PICL_NODE_PLATFORM, &plafh);

    if (err != PICL_SUCCESS) {
        (void) log_printf("Getting nodes by name failed: %s\n",
            picl_strerror(err));
        return (err);
    }

    err = opl_display_pci(syserrlog, plafh);

    (void) picl_shutdown();

    return (err);
}

/*
 * search children to get the node by the nodename
 */
static int
opl_get_node_by_name(picl_nodehdl_t rooth, char *name,
    picl_nodehdl_t *nodeh)
{
    picl_nodehdl_t  childh;
    int     err;
    char        *nodename;

    nodename = alloca(strlen(name) + 1);
    if (nodename == NULL)
        return (PICL_FAILURE);

    err = picl_get_propval_by_name(rooth, PICL_PROP_CHILD, &childh,
        sizeof (picl_nodehdl_t));

    while (err == PICL_SUCCESS) {
        err = picl_get_propval_by_name(childh, PICL_PROP_NAME,
            nodename, (strlen(name) + 1));
        if (err != PICL_SUCCESS) {
            err = picl_get_propval_by_name(childh, PICL_PROP_PEER,
                &childh, sizeof (picl_nodehdl_t));
            continue;
        }

        if (strcmp(nodename, name) == 0) {
            *nodeh = childh;
            return (PICL_SUCCESS);
        }

        err = picl_get_propval_by_name(childh, PICL_PROP_PEER,
            &childh, sizeof (picl_nodehdl_t));
    }

    return (err);
}

static int
open_root_complex(char *root_complex)
{
    char *path;
    static char device_str[] = {"/devices"};
    static char devctl_str[] = {":reg"};
    int fd;

    path = malloc(
        strlen(root_complex) + sizeof (device_str) + sizeof (devctl_str));
    if (path == NULL)
        return (PICL_FAILURE);
    (void) strcpy(path, device_str);
    (void) strcat(path, root_complex);
    (void) strcat(path, devctl_str);

    if ((fd = open(path, O_RDWR)) == -1) {
        return (-1);
    }
    return (fd);
}

static uint32_t
read_long(int fd, int bus, int dev, int func, int offset, int *ret)
{
    int rval;
    pcitool_reg_t prg;

    prg.user_version = PCITOOL_VERSION;
    prg.barnum = 0;
    prg.acc_attr = PCITOOL_ACC_ATTR_SIZE_4 +
        PCITOOL_ACC_ATTR_ENDN_LTL;
    prg.bus_no = bus;
    prg.dev_no = dev;
    prg.func_no = func;
    prg.offset = offset;
    rval = ioctl(fd, PCITOOL_DEVICE_GET_REG, &prg);
    if (rval != 0) {
        log_printf("DEV_GET failed %d %s\n", rval, strerror(errno));
        log_printf("%d.%d.%d offset 0x%x\n", bus, dev, func, offset);
    }
    *ret = rval;
    return ((uint32_t)prg.data);
}

static uint16_t
read_word(int fd, int bus, int dev, int func, int offset, int *ret)
{
    int rval;
    pcitool_reg_t prg;

    prg.user_version = PCITOOL_VERSION;
    prg.barnum = 0;
    prg.acc_attr = PCITOOL_ACC_ATTR_SIZE_2 +
        PCITOOL_ACC_ATTR_ENDN_LTL;
    prg.bus_no = bus;
    prg.dev_no = dev;
    prg.func_no = func;
    prg.offset = offset;
    rval = ioctl(fd, PCITOOL_DEVICE_GET_REG, &prg);
    if (rval != 0) {
        log_printf("DEV_GET failed %d %s\n", rval, strerror(errno));
        log_printf("%d.%d.%d offset 0x%x\n", bus, dev, func, offset);
    }
    *ret = rval;
    return ((uint16_t)prg.data);
}

static uint8_t
read_byte(int fd, int bus, int dev, int func, int offset, int *ret)
{
    int rval;
    pcitool_reg_t prg;

    prg.user_version = PCITOOL_VERSION;
    prg.barnum = 0;
    prg.acc_attr = PCITOOL_ACC_ATTR_SIZE_1 +
        PCITOOL_ACC_ATTR_ENDN_LTL;
    prg.bus_no = bus;
    prg.dev_no = dev;
    prg.func_no = func;
    prg.offset = offset;
    rval = ioctl(fd, PCITOOL_DEVICE_GET_REG, &prg);
    if (rval != 0) {
        log_printf("DEV_GET failed %d %s\n", rval, strerror(errno));
        log_printf("%d.%d.%d offset 0x%x\n", bus, dev, func, offset);
    }
    *ret = rval;
    return ((uint8_t)prg.data);
}


static picl_errno_t
get_lane_width
    (char *device_path, int bus, int dev, int func, int *actual,
    int *maximum, uint32_t *speed_max, uint32_t *speed_at, int *type)
{
    uint_t cap_ptr, cap_reg, link_status, link_cap, capid;
    int fd, ret;

    if (device_path == NULL)
        return (PICL_FAILURE);

    fd = open_root_complex(device_path);
    if (fd == -1)
        return (PICL_FAILURE);

    /*
     * Link Capabilities and Link Status registers are in the
     * PCI-E capabilities register.  They are at offset
     * 0xc and 0x12 respectively. They are documented in section
     * 7.8 of the PCI Express Base Specification. The address of
     * that structure is not fixed, it's kind of a linked list.
     * The Capabilities Pointer reg (8 bits) is always at 0x34.
     * It contains a pointer to the first capabilities structure.
     * For each capability structure, the first 8 bits is the capability
     * ID. The next 8 bits is the pointer to the next structure.
     * If the Next Cap register is zero, it's the end of the list.
     * The capability ID for the PCI-E strucutre is 0x10.  The idea
     * is to follow the links until you find a Cap ID of 0x10, then
     * read the registers at 0xc and 0x12 from there.
     * If there's no Cap ID 0x10, then it's not a PCI-E device.
     */

    cap_ptr = read_byte(fd, bus, dev, func, PCI_CONF_CAP_PTR, &ret);
    if (ret != 0) {
        /* ioctl failure */
        close(fd);
        return (PICL_FAILURE);
    }
    cap_reg = read_word(fd, bus, dev, func, cap_ptr, &ret);
    if (ret != 0) {
        /* ioctl failure */
        close(fd);
        return (PICL_FAILURE);
    }
    *type = PCI;
    capid = cap_reg & PCI_CAP_MASK;
    while (cap_ptr != 0) {

        if (capid == PCI_CAP_ID_PCI_E) {
            link_cap = read_long(fd, bus, dev, func, cap_ptr +
                PCIE_LINKCAP, &ret);
            if (ret != 0) {
                close(fd);
                return (PICL_FAILURE);
            }
            link_status = read_word(fd, bus, dev, func,
                cap_ptr + PCIE_LINKSTS, &ret);
            if (ret != 0) {
                close(fd);
                return (PICL_FAILURE);
            }
            *actual = ((link_status >> PCI_LINK_SHIFT) &
                PCI_LINK_MASK);
            *maximum = ((link_cap >> PCI_LINK_SHIFT) &
                PCI_LINK_MASK);
            *type = PCIE;
        } else if (capid == PCI_CAP_ID_PCIX) {
            uint32_t pcix_status;
            uint8_t hdr_type;
            int max_speed = PCI_FREQ_66;

            hdr_type = read_byte
                (fd, bus, dev, func, PCI_CONF_HEADER, &ret);
            if (ret != 0) {
                /* ioctl failure */
                close(fd);
                return (PICL_FAILURE);
            }
            *type = PCIX;
            if ((hdr_type & PCI_HEADER_TYPE_M) == PCI_HEADER_PPB) {
                /* This is a PCI-X bridge */
                uint16_t sec_status, mode;
                sec_status = read_word(fd, bus, dev, func,
                    cap_ptr + PCI_PCIX_SEC_STATUS, &ret);
                if (ret != 0) {
                    /* ioctl failure */
                    close(fd);
                    return (PICL_FAILURE);
                }
                if (sec_status & PCI_SEC_133)
                    max_speed = PCI_FREQ_133;
                if (sec_status & PCI_SEC_266)
                    max_speed = PCI_FREQ_266;
                if (sec_status & PCI_SEC_533)
                    max_speed = PCI_FREQ_533;
                *speed_max = max_speed;
                mode = (sec_status >> PCI_CLASS_BRIDGE) &
                    PCI_BRIDGE_MC;
                if (mode) {
                    int speed;
                    if (mode == PCI_MODE_66)
                        speed = PCI_FREQ_66;
                    else if (mode == PCI_MODE_100)
                        speed = PCI_FREQ_100;
                    else if (mode == PCI_MODE_133)
                        speed = PCI_FREQ_133;
                    *speed_at = speed;
                }

            } else {  /* Leaf device */
                pcix_status = read_long(fd, bus, dev, func,
                    cap_ptr + PCI_PCIX_STATUS, &ret);
                if (ret != 0) {
                    /* ioctl failure */
                    close(fd);
                    return (PICL_FAILURE);
                }
                if (pcix_status &
                    (PCI_LEAF_ULONG << PCI_SHIFT_133))
                    max_speed = PCI_FREQ_133;
                if (pcix_status &
                    (PCI_LEAF_ULONG << PCI_SHIFT_266))
                    max_speed = PCI_FREQ_266;
                if (pcix_status &
                    (PCI_LEAF_ULONG << PCI_SHIFT_533))
                    max_speed = PCI_FREQ_533;
                *speed_max = max_speed;
            }
        }
        cap_ptr = (cap_reg >> PCI_REG_FUNC_SHIFT);
        cap_reg = read_word(fd, bus, dev, func, cap_ptr, &ret);
        if (ret != 0) {
            /* ioctl failure */
            close(fd);
            return (PICL_FAILURE);
        }
        capid = cap_reg & PCI_CAP_MASK;
    }

    if (close(fd) == -1) {
        return (PICL_FAILURE);
    }

    return (PICL_SUCCESS);
}

static int
is_66mhz_capable(picl_nodehdl_t nodeh)
{
    picl_errno_t    err;
    picl_prophdl_t  proph;
    picl_propinfo_t pinfo;

    err = picl_get_propinfo_by_name(nodeh, OBP_PROP_66MHZ_CAPABLE,
        &pinfo, &proph);
    if (err == PICL_SUCCESS)
        return (1);
    return (0);
}

/*
 * get the clock frequency
 */
static int
picldiag_get_clock_freq(picl_nodehdl_t modh, uint32_t *freq, uint32_t *freq_max)
{
    int     err;
    uint64_t    clk_freq;

    *freq_max = PCI_FREQ_33;
    if (is_66mhz_capable(modh))
        *freq_max = PCI_FREQ_66;
    clk_freq = picldiag_get_uint_propval(modh, OBP_PROP_CLOCK_FREQ, &err);
    if (err != PICL_SUCCESS)
        return (err);

    *freq = ROUND_TO_MHZ(clk_freq);

    return (PICL_SUCCESS);
}

static uint64_t
picldiag_get_uint_propval(picl_nodehdl_t modh, char *prop_name, int *ret)
{
    int     err;
    picl_prophdl_t  proph;
    picl_propinfo_t pinfo;
    uint8_t     uint8v;
    uint16_t    uint16v;
    uint32_t    uint32v;
    uint64_t    uint64v;

    err = picl_get_propinfo_by_name(modh, prop_name, &pinfo, &proph);
    if (err != PICL_SUCCESS) {
        *ret = err;
        return (0);
    }

    /*
     * If it is not an int or uint prop, return failure
     */
    if ((pinfo.type != PICL_PTYPE_INT) &&
        (pinfo.type != PICL_PTYPE_UNSIGNED_INT)) {
        *ret = PICL_FAILURE;
        return (0);
    }


    /* uint prop */

    switch (pinfo.size) {
    case sizeof (uint8_t):
        err = picl_get_propval(proph, &uint8v, sizeof (uint8v));
        *ret = err;
        return (uint8v);
    case sizeof (uint16_t):
        err = picl_get_propval(proph, &uint16v, sizeof (uint16v));
        *ret = err;
        return (uint16v);
    case sizeof (uint32_t):
        err = picl_get_propval(proph, &uint32v, sizeof (uint32v));
        *ret = err;
        return (uint32v);
    case sizeof (uint64_t):
        err = picl_get_propval(proph, &uint64v, sizeof (uint64v));
        *ret = err;
        return (uint64v);
    default:    /* not supported size */
        *ret = PICL_FAILURE;
        return (0);
    }
}

/*
 * recursively visit all nodes
 */
static picl_errno_t
do_walk(picl_nodehdl_t rooth, const char *classname,
    void *c_args, picl_errno_t (*callback_fn)(picl_nodehdl_t hdl, void *args))
{
    picl_errno_t    err;
    picl_nodehdl_t  chdh;
    char        classval[PICL_CLASSNAMELEN_MAX];

    err = picl_get_propval_by_name(rooth, PICL_PROP_CHILD, &chdh,
        sizeof (chdh));
    while (err == PICL_SUCCESS) {
        err = picl_get_propval_by_name(chdh, PICL_PROP_NAME,
            classval, sizeof (classval));
        if (err != PICL_SUCCESS)
            return (err);

        err = callback_fn(chdh, c_args);

        if ((err = do_walk(chdh, classname, c_args, callback_fn)) !=
            PICL_WALK_CONTINUE)
            return (err);

        err = picl_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
            sizeof (chdh));
    }
    if (err == PICL_PROPNOTFOUND)   /* end of a branch */
        return (PICL_WALK_CONTINUE);
    return (err);
}

int
get_proc_mode(void)
{
    picl_nodehdl_t nodeh;
    picl_prophdl_t  proph;
    picl_errno_t err;

    err = picl_initialize();
    if (err != PICL_SUCCESS) {
        (void) log_printf("picl_initialize failed: %s\n",
            picl_strerror(err));
        return (err);
    }

    err = picl_get_node_by_path("/platform",  &nodeh);
    if (err != PICL_SUCCESS) {
        (void) log_printf("Getting plat node failed: %s\n",
            picl_strerror(err));
        return (err);
    }

    err = picl_get_prop_by_name(nodeh, "SPARC64-VII-mode",  &proph);
    if (err != PICL_SUCCESS) {
        /* Do not display error message */
        return (err);
    }

    (void) picl_shutdown();

    return (err);
}