sun4v/promif/promif_node.c

	promif_node.c revision 1ae0874509b6811fdde1dfd46f0d93fd09867a3f
/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <sys/types.h>
#include <sys/esunddi.h>
#include <sys/promif_impl.h>

#ifdef _KMDB
static pnode_t chosennode;
static pnode_t optionsnode;
#else
static char *gettoken(char *tp, char *token);
static pnode_t finddevice(char *path);
#endif

/*
 * Routines for walking the PROMs devinfo tree
 */

#ifdef _KMDB

void
promif_set_nodes(pnode_t chosen, pnode_t options)
{
    chosennode = chosen;
    optionsnode = options;
}

int
promif_finddevice(void *p)
{
    cell_t  *ci = (cell_t *)p;
    char *path;

    ASSERT(ci[1] == 1);

    path = p1275_cell2ptr(ci[3]);

    if (strcmp("/chosen", path) == 0) {
        ci[4] = p1275_dnode2cell(chosennode);
    } else if (strcmp("/options", path) == 0) {
        ci[4] = p1275_dnode2cell(optionsnode);
    } else {
        /* only supports known nodes */
        ASSERT(0);
    }

    return (0);
}

#else

int
promif_finddevice(void *p)
{
    cell_t  *ci = (cell_t *)p;
    pnode_t node;

    ASSERT(ci[1] == 1);

    node = finddevice(p1275_cell2ptr(ci[3]));

    ci[4] = p1275_dnode2cell(node);

    return (0);
}

#endif

int
promif_nextnode(void *p)
{
    cell_t  *ci = (cell_t *)p;
    pnode_t next;

    ASSERT(ci[1] == 1);

    next = promif_stree_nextnode(p1275_cell2dnode(ci[3]));

    ci[4] = p1275_dnode2cell(next);

    return (0);
}

int
promif_childnode(void *p)
{
    cell_t  *ci = (cell_t *)p;
    pnode_t child;

    ASSERT(ci[1] == 1);

    child = promif_stree_childnode(p1275_cell2dnode(ci[3]));

    ci[4] = p1275_dnode2cell(child);

    return (0);
}

int
promif_parentnode(void *p)
{
    cell_t  *ci = (cell_t *)p;
    pnode_t parent;

    ASSERT(ci[1] == 1);

    parent = promif_stree_parentnode(p1275_cell2dnode(ci[3]));

    ci[4] = p1275_dnode2cell(parent);

    return (0);
}

#ifndef _KMDB

/*
 * Get a token from a prom pathname, collecting everything
 * until a non-comma, non-colon separator is found. Any
 * options, including the ':' option separator, on the end
 * of the token are removed.
 */
static char *
gettoken(char *tp, char *token)
{
    char *result = token;

    for (;;) {
        tp = prom_path_gettoken(tp, token);
        token += prom_strlen(token);
        if ((*tp == ',') || (*tp == ':')) {
            *token++ = *tp++;
            *token = '\0';
            continue;
        }
        break;
    }

    /* strip off any options from the token */
    prom_strip_options(result, result);

    return (tp);
}

/*
 * Retrieve the unit address for a node by looking it up
 * in the corresponding dip. -1 is returned if no unit
 * address can be determined.
 */
static int
get_unit_addr(pnode_t np, char *paddr)
{
    dev_info_t  *dip;
    char        *addr;

    if ((dip = e_ddi_nodeid_to_dip(np)) == NULL) {
        return (-1);
    }

    if ((addr = ddi_get_name_addr(dip)) == NULL) {
        ddi_release_devi(dip);
        return (-1);
    }

    (void) prom_strcpy(paddr, addr);

    ddi_release_devi(dip);

    return (0);
}

/*
 * Get node id of node in prom tree that path identifies
 */
static pnode_t
finddevice(char *path)
{
    char    name[OBP_MAXPROPNAME];
    char    addr[OBP_MAXPROPNAME];
    char    pname[OBP_MAXPROPNAME];
    char    paddr[OBP_MAXPROPNAME];
    char    *tp;
    pnode_t np;
    pnode_t device;

    CIF_DBG_NODE("finddevice: %s\n", path);

    tp = path;
    np = prom_rootnode();
    device = OBP_BADNODE;

    /* must be a fully specified path */
    if (*tp++ != '/')
        goto done;

    for (;;) {
        /* get the name from the path */
        tp = gettoken(tp, name);
        if (*name == '\0')
            break;

        /* get the address from the path */
        if (*tp == '@') {
            tp++;
            tp = gettoken(tp, addr);
        } else {
            addr[0] = '\0';
        }

        CIF_DBG_NODE("looking for: %s%s%s\n", name,
            (*addr != '\0') ? "@" : "", addr);

        if ((np = prom_childnode(np)) == OBP_NONODE)
            break;

        while (np != OBP_NONODE) {

            /* get the name from the current node */
            if (prom_getprop(np, OBP_NAME, pname) < 0)
                goto done;

            /* get the address from the current node */
            if (get_unit_addr(np, paddr) < 0)
                paddr[0] = '\0';

            /* compare the names and addresses */
            if ((prom_strcmp(name, pname) == 0) &&
                (prom_strcmp(addr, paddr) == 0)) {
                CIF_DBG_NODE("found dev: %s%s%s (0x%x)\n",
                    pname, (*paddr != '\0') ? "@" : "",
                    paddr, np);
                break;
            } else {
                CIF_DBG_NODE("  no match: %s%s%s vs %s%s%s\n",
                    name, (*addr != '\0') ? "@" : "", addr,
                    pname, (*paddr != '\0') ? "@" : "", paddr);
            }
            np = prom_nextnode(np);
        }

        /* path does not map to a node */
        if (np == OBP_NONODE)
            break;

        if (*tp == '\0') {
            /* found a matching node */
            device = np;
            break;
        }

        /*
         * Continue the loop with the
         * next component of the path.
         */
        tp++;
    }
done:

    if (device == OBP_BADNODE) {
        CIF_DBG_NODE("device not found\n\n");
    } else {
        CIF_DBG_NODE("returning 0x%x\n\n", device);
    }

    return (device);
}

#endif