efcode/fcdriver/phandle.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 (c) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */

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

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <fcode/private.h>
#include <fcode/log.h>

#include <fcdriver/fcdriver.h>


static int use_os_handle = 1;

void
do_use_os_handles(fcode_env_t *env)
{
    use_os_handle = 1;
}

void
do_use_fake_handles(fcode_env_t *env)
{
    log_message(MSG_ERROR, "WARNING: using fake phandles, test only\n");
    use_os_handle = 0;
}

static int
match_nodeid(void *s, void *d)
{
    my_nodeid_t *src = s;
    my_nodeid_t *dest = d;
    return ((src->node) == (dest->node));
}

static int
match_handle(void *s, void *d)
{
    my_nodeid_t *src = s;
    my_nodeid_t *dest = d;
    return ((src->my_handle) == (dest->my_handle));
}

/*
 * Convert from an OS phandle to an interpreter phandle
 */
device_t *
convert_phandle(fcode_env_t *env, fstack_t d)
{
    fc_resource_t *t;
    common_data_t *cdp = env->private;
    device_t *r;

    if (use_os_handle) {
        my_nodeid_t nh;
        nh.my_handle = (fc_phandle_t) d;
        t = find_resource(&cdp->nodeids, &nh, match_handle);
        if (t == NULL) {
            r = 0;
        } else {
            my_nodeid_t *p = (my_nodeid_t *) t->data;
            r = (device_t *) p->node;
        }
    } else
        r = (device_t *)d;
    return (r);
}

/*
 * Interpreter phandle to OS phandle
 */
fstack_t
revert_phandle(fcode_env_t *env, device_t *d)
{
    fc_resource_t *t;
    common_data_t *cdp = env->private;
    fstack_t r;

    if (use_os_handle) {
        my_nodeid_t nh;
        nh.node = d;
        t = find_resource(&cdp->nodeids, &nh, match_nodeid);
        if (t == NULL) {
            r = 0;
        } else {
            my_nodeid_t *p = (my_nodeid_t *) t->data;
            r = (fstack_t) p->my_handle;
        }
    } else
        r = (fstack_t) d;
    return (r);
}

void
add_my_handle(fcode_env_t *env, fc_phandle_t mh, device_t *d)
{
    my_nodeid_t *nh;
    common_data_t *cdp = env->private;

    nh = MALLOC(sizeof (my_nodeid_t));
    nh->my_handle = mh;
    nh->node = d;
    if (add_resource(&cdp->nodeids, nh, match_handle) == NULL) {
        log_message(MSG_ERROR, "add_my_handle: add_resource failed\n");
    }
}

void
allocate_phandle(fcode_env_t *env)
{
    private_data_t *pd;
    common_data_t *cdp;
    int error;
    char *service;
    device_t *current;
    fc_cell_t hcell;

    if ((cdp = env->private) == NULL) {
        log_message(MSG_ERROR, "allocate_phandle: NULL common\n");
        return;
    }

    if (!cdp->init_done)
        return;

    current = MYSELF->device;
    ASSERT(current);

    if (cdp->first_node) {
        service = FC_CONFIG_CHILD;
        cdp->first_node = 0;
    } else {
        service = FC_ALLOC_PHANDLE;
    }

    pd = MALLOC(sizeof (private_data_t));
    pd->common = cdp;
    pd->parent = (fc_phandle_t) revert_phandle(env, current->parent);
    pd->upload = (cdp->init_done == 1);
    current->private = pd;

    error = fc_run_priv(cdp, service, 0, 1, &hcell);

    pd->node = fc_cell2phandle(hcell);

    add_my_handle(env, pd->node, current);
}

fc_phandle_t
fc_get_ap(common_data_t *cdp)
{
    fc_cell_t hcell;
    int error;

    error = fc_run_priv(cdp, FC_AP_PHANDLE, 0, 1, &hcell);

    if (error)
        exit(1);

    return (fc_cell2phandle(hcell));
}


#pragma init(_init)

static void
_init(void)
{
    fcode_env_t *env = initial_env;

    ASSERT(env);
    NOTICE;

    env->convert_phandle = convert_phandle;
    env->revert_phandle = revert_phandle;
    env->allocate_phandle = allocate_phandle;
    FORTH(0,    "use-os-handles",   do_use_os_handles);
    FORTH(0,    "use-fake-handles", do_use_fake_handles);
}