source: mainline/uspace/lib/ofw/src/ofw.c

/*
 * Copyright (c) 2023 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libofw
 * @{
 */
/**
 * @file OpenFirmware device tree access
 */

#include <assert.h>
#include <errno.h>
#include <ofw.h>
#include <stdio.h>
#include <stdlib.h>
#include <str.h>
#include <sysinfo.h>

/** Convert OpenFirmware path to sysinfo path.
 *
 * @param ofwpath OpenFirmware path
 * @param sipath place to store pointer to newly allocated sysinfo path
 * @return EOK on success, ENOMEM if out of memory
 */
static errno_t ofw_path_to_sipath(const char *ofwpath, char **sipath)
{
        int rv;
        size_t size;
        size_t i;

        if (str_cmp(ofwpath, "/") == 0)
                ofwpath = "";

        /* Append path to firmware.ofw */
        rv = asprintf(sipath, "firmware.ofw%s", ofwpath);
        if (rv < 0)
                return ENOMEM;

        /* Replace '/' with '.' */
        size = str_size(*sipath);
        for (i = 0; i < size; i++)
                if ((*sipath)[i] == '/')
                        (*sipath)[i] = '.';

        return EOK;
}

/** Initialize child iterator with first child entry.
 *
 * Initialize the child iterator and make it point to the first child
 * of the specified OpenFirmware device node.
 *
 * @param it Child iterator to initialize
 * @param ofwpath OpenFirmware path of the parent node
 */
errno_t ofw_child_it_first(ofw_child_it_t *it, const char *ofwpath)
{
        errno_t rc;
        char *sipath = NULL;

        it->ofwpath = NULL;
        it->keys = NULL;
        it->keys_sz = 0;
        it->pos = 0;

        rc = ofw_path_to_sipath(ofwpath, &sipath);
        if (rc != EOK)
                goto error;

        if (str_cmp(ofwpath, "/") == 0) {
                it->ofwpath = str_dup("");
        } else {
                it->ofwpath = str_dup(ofwpath);
        }

        if (it->ofwpath == NULL) {
                rc = ENOMEM;
                goto error;
        }

        it->keys = sysinfo_get_keys(sipath, &it->keys_sz);
        if (it->keys == NULL) {
                rc = ENOENT;
                goto error;
        }

        return EOK;
error:
        if (sipath != NULL)
                free(sipath);

        if (it->ofwpath != NULL) {
                free(it->ofwpath);
                it->ofwpath = NULL;
        }

        return rc;
}

/** Move child iterator to the next child.
 *
 * @param it Child iterator
 */
void ofw_child_it_next(ofw_child_it_t *it)
{
        size_t adj;

        assert(!ofw_child_it_end(it));

        adj = str_nsize(it->keys + it->pos, it->keys_sz - it->pos) + 1;
        assert(it->pos + adj <= it->keys_sz);
        it->pos += adj;
}

/** Determine if there are no more child nodes.
 *
 * @param it Child iterator
 * @return @c true iff iterator is beyond the last entry
 */
bool ofw_child_it_end(ofw_child_it_t *it)
{
        return it->pos >= it->keys_sz;
}

/** Get child name from iterator.
 *
 * @param it Child iterator
 * @return Child name (valid until next operation on @a it
 */
const char *ofw_child_it_get_name(ofw_child_it_t *it)
{
        assert(!ofw_child_it_end(it));
        return it->keys + it->pos;
}

/** Get child path from iterator.
 *
 * @param it Child iterator
 * @param rpath Place to store pointer to allocated OpenFirmware path
 * @return @c EOK on success or an error code
 */
errno_t ofw_child_it_get_path(ofw_child_it_t *it, char **rpath)
{
        const char *name;
        int rv;

        assert(!ofw_child_it_end(it));
        name = ofw_child_it_get_name(it);

        rv = asprintf(rpath, "%s/%s", it->ofwpath, name);
        if (rv < 0)
                return ENOMEM;

        return EOK;
}

/** Finalize child iterator.
 *
 * This must be called after using a child iterator.
 *
 * @param it Child iterator
 */
void ofw_child_it_fini(ofw_child_it_t *it)
{
        free(it->ofwpath);
        free(it->keys);
        it->keys = NULL;
        it->keys_sz = 0;
}

/** Initialize property iterator with property.
 *
 * Initialize the property iterator and make it point to the first property
 * of the specified OpenFirmware device node.
 *
 * @param it Property iterator to initialize
 * @param ofwpath OpenFirmware path of the node
 */
errno_t ofw_prop_it_first(ofw_prop_it_t *it, const char *ofwpath)
{
        errno_t rc;
        char *sipath;

        it->data = NULL;
        it->data_sz = 0;
        it->pos = 0;

        rc = ofw_path_to_sipath(ofwpath, &sipath);
        if (rc != EOK)
                goto error;

        it->data = sysinfo_get_data(sipath, &it->data_sz);
        if (it->data == NULL) {
                rc = ENOENT;
                goto error;
        }

        return EOK;
error:
        if (sipath != NULL)
                free(sipath);
        return rc;
}

/** Move property iterator to the next property.
 *
 * @param it Child iterator
 */
void ofw_prop_it_next(ofw_prop_it_t *it)
{
        size_t cur_size;
        size_t value_size;

        cur_size = str_nsize(it->data + it->pos, it->data_sz - it->pos);
        if (((char *) it->data)[it->pos + cur_size] != 0)
                return;

        it->pos += cur_size + 1;

        /* Process value size */
        memcpy(&value_size, it->data + it->pos, sizeof(value_size));

        it->pos += sizeof(value_size);
        if ((it->pos >= it->data_sz) || (it->pos + value_size > it->data_sz))
                return;

        it->pos += value_size;
}

/** Determine if there are no more properties.
 *
 * @param it Property iterator
 * @return @c true iff iterator is beyond the last entry
 */
bool ofw_prop_it_end(ofw_prop_it_t *it)
{
        return it->pos >= it->data_sz;
}

/** Get property name from iterator.
 *
 * @param it Child iterator
 * @return Property name (valid until next operation on @a it
 */
const char *ofw_prop_it_get_name(ofw_prop_it_t *it)
{
        assert(!ofw_prop_it_end(it));
        return it->data + it->pos;
}

/** Get property data from iterator.
 *
 * @param it Property iterator
 * @param rsize Place to store size of data
 * @return Pointer to data
 */
const void *ofw_prop_it_get_data(ofw_prop_it_t *it, size_t *rsize)
{
        size_t cur_size;
        size_t value_size;
        size_t pos;

        assert(!ofw_prop_it_end(it));
        pos = it->pos;

        cur_size = str_nsize(it->data + pos, it->data_sz - pos);
        if (((char *) it->data)[pos + cur_size] != 0)
                return NULL;

        pos += cur_size + 1;

        /* Process value size */
        memcpy(&value_size, it->data + pos, sizeof(value_size));
        pos += sizeof(value_size);

        *rsize = value_size;
        return it->data + pos;
}

/** Finalize property iterator.
 *
 * This must be called after using a child iterator.
 *
 * @param it Child iterator
 */
void ofw_prop_it_fini(ofw_prop_it_t *it)
{
        free(it->data);
        it->data = NULL;
        it->data_sz = 0;
        it->pos = 0;
}

/** @}
 */