rt-thread/components/drivers/ofw/base.c

/*
 * Copyright (c) 2006-2024, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2022-08-25     GuEe-GUI     first version
 */

#include <rthw.h>
#include <rtthread.h>

#include <drivers/ofw.h>
#include <drivers/ofw_io.h>
#include <drivers/ofw_fdt.h>
#include <drivers/ofw_raw.h>

#define DBG_TAG "rtdm.ofw"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>

#include "ofw_internal.h"

struct rt_ofw_node *ofw_node_root = RT_NULL;
struct rt_ofw_node *ofw_node_cpus = RT_NULL;
struct rt_ofw_node *ofw_node_chosen = RT_NULL;
struct rt_ofw_node *ofw_node_aliases = RT_NULL;
struct rt_ofw_node *ofw_node_reserved_memory = RT_NULL;

static rt_phandle _phandle_range[2] = { 1, 1 }, _phandle_next = 1;
static struct rt_ofw_node **_phandle_hash = RT_NULL;

static rt_list_t _aliases_nodes = RT_LIST_OBJECT_INIT(_aliases_nodes);

rt_err_t ofw_phandle_hash_reset(rt_phandle min, rt_phandle max)
{
    rt_err_t err = RT_EOK;
    rt_phandle next = max;
    struct rt_ofw_node **hash_ptr = RT_NULL;

    max = RT_ALIGN(max, OFW_NODE_MIN_HASH);

    if (max > _phandle_range[1])
    {
        rt_size_t size = sizeof(*_phandle_hash) * (max - min);

        if (!_phandle_hash)
        {
            hash_ptr = rt_calloc(1, size);
        }
        else
        {
            hash_ptr = rt_realloc(_phandle_hash, size);

            if (hash_ptr)
            {
                rt_size_t old_max = _phandle_range[1];

                rt_memset(&hash_ptr[old_max], 0, sizeof(_phandle_hash) * (max - old_max));
            }
        }
    }

    if (hash_ptr)
    {
        /* We always reset min value only once */
        if (min)
        {
            _phandle_range[0] = min;
        }
        _phandle_range[1] = max;
        _phandle_next = next + 1;
        _phandle_hash = hash_ptr;
    }
    else
    {
        err = -RT_ENOMEM;
    }

    return err;
}

static rt_phandle ofw_phandle_next(void)
{
    rt_phandle next;
    static struct rt_spinlock op_lock = {};

    rt_hw_spin_lock(&op_lock.lock);

    RT_ASSERT(_phandle_next != OFW_PHANDLE_MAX);

    if (_phandle_next <= _phandle_range[1])
    {
        next = _phandle_next++;
    }
    else
    {
        rt_err_t err = ofw_phandle_hash_reset(_phandle_range[0], _phandle_next);

        if (!err)
        {
            next = _phandle_next++;
        }
        else
        {
            next = 0;
            LOG_E("Expanded phandle hash[%u, %u] fail error = %s",
                    _phandle_range[0], _phandle_next + 1, rt_strerror(err));
        }
    }

    rt_hw_spin_unlock(&op_lock.lock);

    return next;
}
static void ofw_prop_destroy(struct rt_ofw_prop *prop)
{
    struct rt_ofw_prop *next;

    while (prop)
    {
        next = prop->next;

        rt_free(prop);

        prop = next;
    }
}

static struct rt_ofw_node *ofw_get_next_node(struct rt_ofw_node *prev)
{
    struct rt_ofw_node *np;

    /*
     * Walk:
     *
     *    / { ------------------------ [0] (START) has child, goto child.
     *
     *        node0 { ---------------- [1] has child, goto child.
     *
     *            node0_0 { ---------- [2] no child, has sibling, goto sibling.
     *            };
     *
     *            node0_1 { ---------- [3] no sibling now.
     *                                     upward while the parent has sibling.
     *            };
     *        };
     *
     *        node1 { ---------------- [4] come from node0 who find the sibling:
     *                                     node1, node1 has child, goto child.
     *
     *            node1_0 { ---------- [5] has child, goto child.
     *
     *                node1_0_0 { ---- [6] no sibling now.
     *                                     upward while the parent has sibling.
     *                                     (END) in the root.
     *                };
     *            };
     *        };
     *    };
     */

    if (!prev)
    {
        np = ofw_node_root;
    }
    else if (prev->child)
    {
        np = prev->child;
    }
    else
    {
        np = prev;

        while (np->parent && !np->sibling)
        {
            np = np->parent;
        }

        np = np->sibling;
    }

    return np;
}

static void ofw_node_destroy(struct rt_ofw_node *np)
{
    struct rt_ofw_node *prev;

    if (np->parent)
    {
        /* Ask parent and prev sibling we are destroy. */
        prev = np->parent->child;

        if (prev == np)
        {
            np->parent->child = RT_NULL;
        }
        else
        {
            while (prev->sibling != np)
            {
                prev = prev->sibling;
            }

            prev->sibling = np->sibling;
        }
    }

    while (np)
    {
        if (rt_ofw_node_test_flag(np, RT_OFW_F_SYSTEM) == RT_FALSE)
        {
            LOG_E("%s is system node", np->full_name);
            RT_ASSERT(0);
        }

        prev = np;

        np = ofw_get_next_node(np);

        ofw_prop_destroy(prev->props);
        rt_free(prev);
    }
}

rt_err_t rt_ofw_node_destroy(struct rt_ofw_node *np)
{
    rt_err_t err = RT_EOK;

    if (np)
    {
        if (rt_ref_read(&np->ref) <= 1)
        {
            ofw_node_destroy(np);
        }
        else
        {
            err = -RT_EBUSY;
        }
    }
    else
    {
        err = -RT_EINVAL;
    }

    return err;
}

struct rt_ofw_node *rt_ofw_node_get(struct rt_ofw_node *np)
{
    if (np)
    {
        LOG_D("%s get ref = %d", np->full_name, rt_ref_read(&np->ref));
        rt_ref_get(&np->ref);
    }

    return np;
}

static void ofw_node_release(struct rt_ref *r)
{
    struct rt_ofw_node *np = rt_container_of(r, struct rt_ofw_node, ref);

    LOG_E("%s is release", np->full_name);
    (void)np;

    RT_ASSERT(0);
}

void rt_ofw_node_put(struct rt_ofw_node *np)
{
    if (np)
    {
        LOG_D("%s put ref = %d", np->full_name, rt_ref_read(&np->ref));
        rt_ref_put(&np->ref, &ofw_node_release);
    }
}

rt_bool_t rt_ofw_node_tag_equ(const struct rt_ofw_node *np, const char *tag)
{
    rt_bool_t ret = RT_FALSE;

    if (np && tag)
    {
        const char *node_name = rt_fdt_node_name(np->full_name);
        rt_size_t tag_len = strchrnul(node_name, '@') - node_name;

        ret = (rt_strlen(tag) == tag_len && !rt_strncmp(node_name, tag, tag_len));
    }

    return ret;
}

rt_bool_t rt_ofw_node_tag_prefix(const struct rt_ofw_node *np, const char *prefix)
{
    rt_bool_t ret = RT_FALSE;

    if (np && prefix)
    {
        ret = !rt_strncmp(rt_fdt_node_name(np->full_name), prefix, rt_strlen(prefix));
    }

    return ret;
}

static int ofw_prop_index_of_string(struct rt_ofw_prop *prop, const char *string,
        rt_int32_t (*cmp)(const char *cs, const char *ct))
{
    int index = -1;
    rt_size_t len = prop->length, slen = 0;
    const char *value = prop->value;

    for (int idx = 0; len > 0; ++idx)
    {
        /* Add '\0' */
        slen = rt_strlen(value) + 1;

        if (!cmp(value, string))
        {
            index = idx;

            break;
        }

        len -= slen;
        value += slen;
    }

    return index;
}

static rt_int32_t ofw_strcasecmp(const char *cs, const char *ct)
{
    extern rt_int32_t strcasecmp(const char *cs, const char *ct);

    return rt_strcasecmp(cs, ct);
}

static int ofw_prop_index_of_compatible(struct rt_ofw_prop *prop, const char *compatible)
{
    return ofw_prop_index_of_string(prop, compatible, ofw_strcasecmp);
}

static int ofw_node_index_of_compatible(const struct rt_ofw_node *np, const char *compatible)
{
    int idx = -1;
    struct rt_ofw_prop *prop = rt_ofw_get_prop(np, "compatible", RT_NULL);

    if (prop)
    {
        idx = ofw_prop_index_of_compatible(prop, compatible);
    }

    return idx;
}

rt_bool_t rt_ofw_machine_is_compatible(const char *compatible)
{
    return ofw_node_index_of_compatible(ofw_node_root, compatible) >= 0;
}

/*
 * Property status:
 *
 *  "okay" or "ok":
 *      Indicates the device is operational.
 *
 *  "disabled":
 *      Indicates that the device is not presently operational, but it might
 *      become operational in the future (for example, something is not
 *      plugged in, or switched off).
 *      Refer to the device binding for details on what disabled means for a
 *      given device.
 *
 *  "reserved":
 *      Indicates that the device is operational, but should not be used.
 *      Typically this is used for devices that are controlled by another
 *      software component, such as platform firmware.
 *
 *  "fail":
 *      Indicates that the device is not operational. A serious error was
 *      detected in the device, and it is unlikely to become operational
 *      without repair.
 *
 *  "fail-sss":
 *      Indicates that the device is not operational. A serious error was
 *      detected in the device and it is unlikely to become operational
 *      without repair. The sss portion of the value is specific to the
 *      device and indicates the error condition detected.
 */

static rt_bool_t ofw_node_is_fail(const struct rt_ofw_node *np)
{
    rt_bool_t res = RT_FALSE;
    const char *status = rt_ofw_prop_read_raw(np, "status", RT_NULL);

    if (status)
    {
        res = !rt_strcmp(status, "fail") || !rt_strncmp(status, "fail-", 5);
    }

    return res;
}

static rt_bool_t ofw_node_is_available(const struct rt_ofw_node *np)
{
    rt_bool_t res = RT_TRUE;
    const char *status = rt_ofw_prop_read_raw(np, "status", RT_NULL);

    if (status)
    {
        res = !rt_strcmp(status, "okay") || !rt_strcmp(status, "ok");
    }

    return res;
}

rt_bool_t rt_ofw_node_is_available(const struct rt_ofw_node *np)
{
    return np ? ofw_node_is_available(np) : RT_FALSE;
}

rt_bool_t rt_ofw_node_is_compatible(const struct rt_ofw_node *np, const char *compatible)
{
    rt_bool_t res = RT_FALSE;

    if (np)
    {
        res = ofw_node_index_of_compatible(np, compatible) >= 0;
    }

    return res;
}

static struct rt_ofw_node_id *ofw_prop_match(struct rt_ofw_prop *prop, const struct rt_ofw_node_id *ids)
{
    int best_index = RT_UINT32_MAX >> 1, index;
    struct rt_ofw_node_id *found_id = RT_NULL, *id;

    for (id = (struct rt_ofw_node_id *)ids; id->compatible[0]; ++id)
    {
        index = ofw_prop_index_of_compatible(prop, id->compatible);

        if (index >= 0 && index < best_index)
        {
            found_id = id;
            best_index = index;
        }
    }

    return found_id;
}

struct rt_ofw_node_id *rt_ofw_prop_match(struct rt_ofw_prop *prop, const struct rt_ofw_node_id *ids)
{
    struct rt_ofw_node_id *id = RT_NULL;

    if (prop && ids && !rt_strcmp(prop->name, "compatible"))
    {
        id = ofw_prop_match(prop, ids);
    }

    return id;
}

struct rt_ofw_node_id *rt_ofw_node_match(struct rt_ofw_node *np, const struct rt_ofw_node_id *ids)
{
    struct rt_ofw_prop *prop;
    struct rt_ofw_node_id *id = RT_NULL;

    if (np && ids && (prop = rt_ofw_get_prop(np, "compatible", RT_NULL)))
    {
        id = ofw_prop_match(prop, ids);
    }

    return id;
}

struct rt_ofw_node *rt_ofw_find_node_by_tag(struct rt_ofw_node *from, const char *tag)
{
    struct rt_ofw_node *np = RT_NULL;

    if (tag)
    {
        rt_ofw_foreach_nodes(from, np)
        {
            if (rt_ofw_node_tag_equ(np, tag))
            {
                break;
            }
        }
    }

    return np;
}

struct rt_ofw_node *rt_ofw_find_node_by_prop_r(struct rt_ofw_node *from, const char *propname,
        const struct rt_ofw_prop **out_prop)
{
    struct rt_ofw_node *np = RT_NULL;

    if (propname)
    {
        rt_ofw_foreach_nodes(from, np)
        {
            struct rt_ofw_prop *prop = rt_ofw_get_prop(np, propname, RT_NULL);

            if (prop)
            {
                if (out_prop)
                {
                    *out_prop = prop;
                }

                break;
            }
        }
    }

    return np;
}

struct rt_ofw_node *rt_ofw_find_node_by_name(struct rt_ofw_node *from, const char *name)
{
    struct rt_ofw_node *np = RT_NULL;

    if (name)
    {
        rt_ofw_foreach_nodes(from, np)
        {
            if (np->name && !rt_strcmp(np->name, name))
            {
                np = rt_ofw_node_get(np);
                break;
            }
        }
    }

    return np;
}

struct rt_ofw_node *rt_ofw_find_node_by_type(struct rt_ofw_node *from, const char *type)
{
    struct rt_ofw_node *np = RT_NULL;

    if (type)
    {
        rt_ofw_foreach_nodes(from, np)
        {
            if (rt_ofw_node_is_type(np, type))
            {
                break;
            }
        }
    }

    return np;
}

struct rt_ofw_node *rt_ofw_find_node_by_compatible(struct rt_ofw_node *from, const char *compatible)
{
    struct rt_ofw_node *np = RT_NULL;

    if (compatible)
    {
        rt_ofw_foreach_nodes(from, np)
        {
            if (ofw_node_index_of_compatible(np, compatible) >= 0)
            {
                break;
            }
        }
    }

    return np;
}

struct rt_ofw_node *rt_ofw_find_node_by_ids_r(struct rt_ofw_node *from, const struct rt_ofw_node_id *ids,
        const struct rt_ofw_node_id **out_id)
{
    struct rt_ofw_node *np = RT_NULL;

    if (ids)
    {
        rt_ofw_foreach_nodes(from, np)
        {
            struct rt_ofw_node_id *id = rt_ofw_node_match(np, ids);

            if (id)
            {
                if (out_id)
                {
                    *out_id = id;
                }

                break;
            }
        }
    }

    return np;
}

struct rt_ofw_node *rt_ofw_find_node_by_path(const char *path)
{
    struct rt_ofw_node *np = RT_NULL, *parent, *tmp = RT_NULL;

    if (path)
    {
        if (!rt_strcmp(path, "/"))
        {
            np = ofw_node_root;
        }
        else
        {
            ++path;
            parent = rt_ofw_node_get(ofw_node_root);

            while (*path)
            {
                const char *next = strchrnul(path, '/');
                rt_size_t len = next - path;

                tmp = RT_NULL;

                rt_ofw_foreach_child_node(parent, np)
                {
                    if (!rt_strncmp(np->full_name, path, len))
                    {
                        rt_ofw_node_put(parent);

                        parent = np;
                        tmp = np;

                        break;
                    }
                }

                if (!tmp)
                {
                    rt_ofw_node_put(parent);

                    break;
                }

                path += len + !!*next;
            }

            np = tmp;
        }

        rt_ofw_node_get(np);
    }

    return np;
}

struct rt_ofw_node *rt_ofw_find_node_by_phandle(rt_phandle phandle)
{
    struct rt_ofw_node *np = RT_NULL;

    if (phandle >= OFW_PHANDLE_MIN && phandle <= OFW_PHANDLE_MAX)
    {
        /* rebase from zero */
        rt_phandle poff = phandle - _phandle_range[0];

        np = _phandle_hash[poff];

        if (!np)
        {
            rt_ofw_foreach_allnodes(np)
            {
                if (np->phandle == phandle)
                {
                    _phandle_hash[poff] = np;

                    break;
                }
            }
        }
        else
        {
            rt_ofw_node_get(np);
        }
    }

    return np;
}

struct rt_ofw_node *rt_ofw_get_parent(const struct rt_ofw_node *np)
{
    if (np)
    {
        np = rt_ofw_node_get(np->parent);
    }

    return (struct rt_ofw_node *)np;
}

struct rt_ofw_node *rt_ofw_get_child_by_tag(const struct rt_ofw_node *parent, const char *tag)
{
    struct rt_ofw_node *child = RT_NULL;

    if (parent && tag)
    {
        rt_ofw_foreach_child_node(parent, child)
        {
            if (rt_ofw_node_tag_equ(child, tag))
            {
                break;
            }
        }
    }

    return child;
}

struct rt_ofw_node *rt_ofw_get_child_by_compatible(const struct rt_ofw_node *parent, const char *compatible)
{
    struct rt_ofw_node *child = RT_NULL;

    if (parent && compatible)
    {
        rt_ofw_foreach_child_node(parent, child)
        {
            if (ofw_node_index_of_compatible(child, compatible) >= 0)
            {
                break;
            }
        }
    }

    return child;
}

int rt_ofw_get_child_count(const struct rt_ofw_node *np)
{
    int nr;

    if (np)
    {
        struct rt_ofw_node *child;

        nr = 0;

        rt_ofw_foreach_child_node(np, child)
        {
            ++nr;
        }
    }
    else
    {
        nr = -RT_EINVAL;
    }

    return nr;
}

int rt_ofw_get_available_child_count(const struct rt_ofw_node *np)
{
    int nr;

    if (np)
    {
        struct rt_ofw_node *child;

        nr = 0;

        rt_ofw_foreach_available_child_node(np, child)
        {
            ++nr;
        }
    }
    else
    {
        nr = -RT_EINVAL;
    }

    return nr;
}

struct rt_ofw_node *rt_ofw_get_next_node(struct rt_ofw_node *prev)
{
    struct rt_ofw_node *np;

    np = rt_ofw_node_get(ofw_get_next_node(prev));
    rt_ofw_node_put(prev);

    return np;
}

struct rt_ofw_node *rt_ofw_get_next_parent(struct rt_ofw_node *prev)
{
    struct rt_ofw_node *next = RT_NULL;

    if (prev)
    {
        next = rt_ofw_node_get(prev->parent);
        rt_ofw_node_put(prev);
    }

    return next;
}

struct rt_ofw_node *rt_ofw_get_next_child(const struct rt_ofw_node *parent, struct rt_ofw_node *prev)
{
    struct rt_ofw_node *next = RT_NULL;

    if (parent)
    {
        next = prev ? prev->sibling : parent->child;
        rt_ofw_node_put(prev);
        rt_ofw_node_get(next);
    }

    return next;
}

struct rt_ofw_node *rt_ofw_get_next_available_child(const struct rt_ofw_node *parent, struct rt_ofw_node *prev)
{
    struct rt_ofw_node *next = RT_NULL;

    if (parent)
    {
        next = prev;

        do {
            next = rt_ofw_get_next_child(parent, next);

        } while (next && !ofw_node_is_available(next));
    }

    return next;
}

struct rt_ofw_node *rt_ofw_get_cpu_node(int cpu, int *thread, rt_bool_t (*match_cpu_hwid)(int cpu, rt_uint64_t hwid))
{
    const char *propname = "reg";
    struct rt_ofw_node *cpu_np = RT_NULL;

    /*
     * "reg" (some of the obsolete arch may be other names):
     *  The value of reg is a <prop-encoded-array> that defines a unique
     *  CPU/thread id for the CPU/threads represented by the CPU node.
     *
     *  If a CPU supports more than one thread (i.e. multiple streams of
     *  execution) the reg property is an array with 1 element per thread. The
     *  #address-cells on the /cpus node specifies how many cells each element
     *  of the array takes. Software can determine the number of threads by
     *  dividing the size of reg by the parent node’s #address-cells:
     *
     *      thread-number = reg-cells / address-cells
     *
     *  If a CPU/thread can be the target of an external interrupt the reg
     *  property value must be a unique CPU/thread id that is addressable by the
     *  interrupt controller.
     *
     *  If a CPU/thread cannot be the target of an external interrupt, then reg
     *  must be unique and out of bounds of the range addressed by the interrupt
     *  controller
     *
     *  If a CPU/thread’s PIR (pending interrupt register) is modifiable, a
     *  client program should modify PIR to match the reg property value. If PIR
     *  cannot be modified and the PIR value is distinct from the interrupt
     *  controller number space, the CPUs binding may define a binding-specific
     *  representation of PIR values if desired.
     */

    rt_ofw_foreach_cpu_node(cpu_np)
    {
        rt_ssize_t prop_len;
        rt_bool_t is_end = RT_FALSE;
        int tid, addr_cells = rt_ofw_io_addr_cells(cpu_np);
        const fdt32_t *cell = rt_ofw_prop_read_raw(cpu_np, propname, &prop_len);

        if (!cell && !addr_cells)
        {
            if (match_cpu_hwid && match_cpu_hwid(cpu, 0))
            {
                break;
            }

            continue;
        }

        if (!match_cpu_hwid)
        {
            continue;
        }

        prop_len /= sizeof(*cell) * addr_cells;

        for (tid = 0; tid < prop_len; ++tid)
        {
            rt_uint64_t hwid = rt_fdt_read_number(cell, addr_cells);

            if (match_cpu_hwid(cpu, hwid))
            {
                if (thread)
                {
                    *thread = tid;
                }

                is_end = RT_TRUE;

                break;
            }

            cell += addr_cells;
        }

        if (is_end)
        {
            break;
        }
    }

    return cpu_np;
}

struct rt_ofw_node *rt_ofw_get_next_cpu_node(struct rt_ofw_node *prev)
{
    struct rt_ofw_node *cpu_np;

    if (prev)
    {
        cpu_np = prev->sibling;
        rt_ofw_node_put(prev);
    }
    else
    {
        cpu_np = ofw_node_cpus->child;
    }

    for (; cpu_np; cpu_np = cpu_np->sibling)
    {
        if (ofw_node_is_fail(cpu_np))
        {
            continue;
        }

        if (!(rt_ofw_node_tag_equ(cpu_np, "cpu") || rt_ofw_node_is_type(cpu_np, "cpu")))
        {
            continue;
        }

        if (rt_ofw_node_get(cpu_np))
        {
            break;
        }
    }

    return cpu_np;
}

struct rt_ofw_node *rt_ofw_get_cpu_state_node(struct rt_ofw_node *cpu_np, int index)
{
    struct rt_ofw_cell_args args;
    struct rt_ofw_node *np = RT_NULL, *state_np;
    rt_err_t err = rt_ofw_parse_phandle_cells(cpu_np, "power-domains", "#power-domain-cells", 0, &args);

    if (!err)
    {
        state_np = rt_ofw_parse_phandle(args.data, "domain-idle-states", index);

        rt_ofw_node_put(args.data);

        if (state_np)
        {
            np = state_np;
        }
    }

    if (!np)
    {
        int count = 0;
        rt_uint32_t phandle;
        const fdt32_t *cell;
        struct rt_ofw_prop *prop;

        rt_ofw_foreach_prop_u32(cpu_np, "cpu-idle-states", prop, cell, phandle)
        {
            if (count == index)
            {
                np = rt_ofw_find_node_by_phandle((rt_phandle)phandle);

                break;
            }

            ++count;
        }
    }

    return np;
}

rt_uint64_t rt_ofw_get_cpu_id(struct rt_ofw_node *cpu_np)
{
    rt_uint64_t cpuid = ~0ULL;

    if (cpu_np)
    {
        rt_uint64_t idx = 0;
        struct rt_ofw_node *np = ofw_node_cpus->child;

        for (; np; np = np->sibling)
        {
            if (!(rt_ofw_node_tag_equ(cpu_np, "cpu") || rt_ofw_node_is_type(cpu_np, "cpu")))
            {
                continue;
            }

            if (cpu_np == np)
            {
                cpuid = idx;

                break;
            }

            ++idx;
        }

        if ((rt_int64_t)cpuid < 0 && !rt_ofw_prop_read_u64(cpu_np, "rt-thread,cpuid", &idx))
        {
            cpuid = idx;
        }
    }

    return cpuid;
}

rt_uint64_t rt_ofw_get_cpu_hwid(struct rt_ofw_node *cpu_np, unsigned int thread)
{
    rt_uint64_t thread_id, hwid = ~0ULL;

    if (cpu_np && thread >= 0 && !rt_ofw_get_address(cpu_np, thread, &thread_id, RT_NULL))
    {
        hwid = thread_id;
    }

    return hwid;
}

rt_err_t ofw_alias_scan(void)
{
    rt_err_t err = RT_EOK;
    struct rt_ofw_prop *prop;
    struct rt_ofw_node *np = ofw_node_aliases, *tmp;

    rt_ofw_foreach_prop(np, prop)
    {
        int id = 0, rate = 1;
        struct alias_info *info;
        const char *name = prop->name, *end;

        /* Maybe the bootloader will set the name, or other nodes reference the aliases */
        if (!rt_strcmp(name, "name") || !rt_strcmp(name, "phandle"))
        {
            continue;
        }

        if (!(tmp = rt_ofw_find_node_by_path(prop->value)))
        {
            continue;
        }

        end = name + rt_strlen(name) - 1;

        while (*end && !(*end >= '0' && *end <= '9') && end > name)
        {
            --end;
        }

        while (*end && (*end >= '0' && *end <= '9'))
        {
            id += (*end - '0') * rate;
            rate *= 10;

            ++end;
        }

        info = rt_malloc(sizeof(*info));

        if (!info)
        {
            err = -RT_ENOMEM;
            break;
        }

        rt_list_init(&info->list);

        info->id = id;
        info->tag = name;
        info->tag_len = end - name - 1;
        info->np = tmp;

        rt_list_insert_after(&_aliases_nodes, &info->list);
    }

    return err;
}

struct rt_ofw_node *rt_ofw_get_alias_node(const char *tag, int id)
{
    struct alias_info *info;
    struct rt_ofw_node *np = RT_NULL;

    if (tag && id >= 0)
    {
        rt_list_for_each_entry(info, &_aliases_nodes, list)
        {
            if (rt_strncmp(info->tag, tag, info->tag_len))
            {
                continue;
            }

            if (info->id == id)
            {
                np = info->np;
                break;
            }
        }
    }

    return np;
}

int ofw_alias_node_id(struct rt_ofw_node *np)
{
    int id;
    struct alias_info *info;

    if (np)
    {
        id = -1;

        rt_list_for_each_entry(info, &_aliases_nodes, list)
        {
            if (info->np == np)
            {
                id = info->id;
                break;
            }
        }
    }
    else
    {
        id = -RT_EINVAL;
    }

    return id;
}

int rt_ofw_get_alias_id(struct rt_ofw_node *np, const char *tag)
{
    int id;
    struct alias_info *info;

    if (np && tag)
    {
        id = -1;

        rt_list_for_each_entry(info, &_aliases_nodes, list)
        {
            if (rt_strncmp(info->tag, tag, info->tag_len))
            {
                continue;
            }

            if (info->np == np)
            {
                id = info->id;
                break;
            }
        }
    }
    else
    {
        id = -RT_EINVAL;
    }

    return id;
}

int rt_ofw_get_alias_last_id(const char *tag)
{
    int id;
    struct alias_info *info;

    if (tag)
    {
        id = -1;

        rt_list_for_each_entry(info, &_aliases_nodes, list)
        {
            if (rt_strncmp(info->tag, tag, info->tag_len))
            {
                continue;
            }

            if (info->id > id)
            {
                id = info->id;
            }
        }
    }
    else
    {
        id = -RT_EINVAL;
    }

    return id;
}

struct rt_ofw_node *rt_ofw_append_child(struct rt_ofw_node *parent, const char *full_name)
{
    rt_phandle phandle;
    rt_err_t err = RT_EOK;
    fdt32_t *phandle_value;
    struct rt_ofw_node *np = RT_NULL, *child;

    if (full_name)
    {
        if ((phandle = ofw_phandle_next()))
        {
            np = rt_calloc(1, sizeof(*np) + sizeof(*phandle_value));
        }
    }

    if (np)
    {
        parent = parent ? : ofw_node_root;

        np->full_name = full_name;
        np->phandle = phandle;
        np->parent = parent;

        rt_ref_init(&np->ref);

        phandle_value = (void *)np + sizeof(*np);
        *phandle_value = cpu_to_fdt32(phandle);

        err = rt_ofw_append_prop(np, "phandle", sizeof(*phandle_value), phandle_value);

        if (!err)
        {
            if (parent->child)
            {
                rt_ofw_foreach_child_node(parent, child)
                {
                    if (!child->sibling)
                    {
                        child->sibling = np;
                        rt_ofw_node_put(child);
                        break;
                    }
                }
            }
            else
            {
                parent->child = np;
            }
        }
        else
        {
            rt_free(np);
            np = RT_NULL;
        }
    }

    return np;
}

rt_err_t rt_ofw_append_prop(struct rt_ofw_node *np, const char *name, int length, void *value)
{
    rt_err_t err = RT_EOK;

    if (np && name && ((length && value) || (!length && !value)))
    {
        struct rt_ofw_prop *prop = rt_malloc(sizeof(*prop)), *last_prop;

        if (prop)
        {
            prop->name = name;
            prop->length = length;
            prop->value = value;
            prop->next = RT_NULL;

            if (np->props)
            {
                rt_ofw_foreach_prop(np, last_prop)
                {
                    if (!last_prop->next)
                    {
                        last_prop->next = prop;
                        break;
                    }
                }
            }
            else
            {
                np->props = prop;
            }
        }
        else
        {
            err = -RT_ENOMEM;
        }
    }
    else
    {
        err = -RT_EINVAL;
    }

    return err;
}

struct rt_ofw_node *rt_ofw_parse_phandle(const struct rt_ofw_node *np, const char *phandle_name, int index)
{
    struct rt_ofw_cell_args args;
    struct rt_ofw_node *ref_np = RT_NULL;

    if (!rt_ofw_parse_phandle_cells(np, phandle_name, RT_NULL, index, &args))
    {
        ref_np = args.data;
    }

    return ref_np;
}

static rt_err_t ofw_parse_phandle_cells(const struct rt_ofw_node *np, const char *list_name, const char *cells_name,
        int index, struct rt_ofw_cell_args *out_args)
{
    rt_err_t err = -RT_EEMPTY;
    rt_uint32_t value;
    rt_size_t count = 0;
    const fdt32_t *cell;
    struct rt_ofw_prop *prop;

    /*
     * List:
     *
     *      phandle1: node1 {
     *          #list-cells = <2>;
     *      };
     *
     *      phandle2: node2 {
     *          #list-cells = <1>;
     *      };
     *
     *      node3 {
     *          list = <&phandle1 0xaa 0xbb>, <&phandle2 0xcc>;
     *      };
     *
     * if call:
     *  rt_ofw_parse_phandle_cells(node3, "list", "#list-cells", 0, &args):
     *
     *      args.data = node1;
     *      args.args_count = 2;
     *      args.args[0] = 0xaa;
     *      args.args[1] = 0xbb;
     *
     *  rt_ofw_parse_phandle_cells(node3, "list", "#list-cells", 1, &args):
     *
     *      args.data = node2;
     *      args.args_count = 1;
     *      args.args[0] = 0xcc;
     */

    rt_ofw_foreach_prop_u32(np, list_name, prop, cell, value)
    {
        rt_uint32_t cells_count = 0;
        struct rt_ofw_node *phandle_np = rt_ofw_find_node_by_phandle((rt_phandle)value);

        /* if phandle node is undefined, we assume that the cels_count is 0 */
        if (cells_name && phandle_np)
        {
            rt_ofw_prop_read_u32(phandle_np, cells_name, &cells_count);
        }

        if (count++ == index)
        {
            for (int idx = 0; idx < cells_count; ++idx)
            {
                cell = rt_ofw_prop_next_u32(prop, cell, &value);

                out_args->args[idx] = value;
            }

            out_args->args_count = cells_count;
            out_args->data = phandle_np;

            if (out_args->data)
            {
                err = RT_EOK;
            }

            break;
        }

        cell += cells_count;
    }

    return err;
}

rt_err_t rt_ofw_parse_phandle_cells(const struct rt_ofw_node *np, const char *list_name, const char *cells_name,
        int index, struct rt_ofw_cell_args *out_args)
{
    rt_err_t err;

    if (np && list_name && index >= 0 && out_args)
    {
        err = ofw_parse_phandle_cells(np, list_name, cells_name, index, out_args);
    }
    else
    {
        err = -RT_EINVAL;
    }

    return err;
}

int rt_ofw_count_phandle_cells(const struct rt_ofw_node *np, const char *list_name, const char *cells_name)
{
    int count;

    if (np && list_name)
    {
        count = -1;

        if (!cells_name)
        {
            rt_ssize_t length;

            if (rt_ofw_get_prop(np, list_name, &length))
            {
                count = length / sizeof(fdt32_t);
            }
        }
        else
        {
            int index = count = 0;
            struct rt_ofw_cell_args args;

            while (!ofw_parse_phandle_cells(np, list_name, cells_name, index, &args))
            {
                ++index;
                ++count;
            }
        }
    }
    else
    {
        count = -RT_EINVAL;
    }

    return count;
}

static const char *ofw_get_prop_fuzzy_name(const struct rt_ofw_node *np, const char *name)
{
    char *sf, split_field[64];
    rt_size_t len = 0, max_ak = 0;
    const char *str, *result = RT_NULL;
    RT_DECLARE_BITMAP(ak, sizeof(split_field));
    struct rt_ofw_prop *prop;

    /*
     * List:
     *
     *      node {
     *          property;
     *          front-prop-rear;
     *          front-prop;
     *          prop-rear;
     *      };
     *
     * if call:
     *  ofw_get_prop_fuzzy_name(node, name):
     *      ["prop"] => property
     *      ["-prop"] => front-prop-rear
     *      ["prop-"] => front-prop-rear
     *      ["-prop$"] => front-prop
     *      ["^prop-"] => prop-rear
     *      ["-prop-"] => front-prop-rear
     *      ["front-*-rear"] => front-prop-rear
     */

    str = name;
    sf = split_field;

    if (str[0] != '^')
    {
        /* As '*' */
        *sf++ = '\0';
        rt_bitmap_set_bit(ak, len++);
    }
    else
    {
        ++str;
    }

    for (; *str && len < sizeof(split_field); ++str, ++sf, ++len)
    {
        if (*str != '*')
        {
            *sf = *str;
            rt_bitmap_clear_bit(ak, len);
        }
        else
        {
            max_ak = len;
            *sf = '\0';
            rt_bitmap_set_bit(ak, len);
        }
    }
    *sf = '\0';

    if (str[-1] != '$')
    {
        /* As '*' */
        max_ak = len;
        rt_bitmap_set_bit(ak, len++);
    }
    else
    {
        sf[-1] = '\0';
        --len;
    }

    sf = split_field;

    if (len >= sizeof(split_field))
    {
        LOG_W("%s fuzzy name = %s len is %d out of %d", np->full_name, name, rt_strlen(name), sizeof(split_field));
    }

    rt_ofw_foreach_prop(np, prop)
    {
        int prep_ak = 0, next_ak, field;
        rt_bool_t match = RT_TRUE;
        const char *propname = prop->name, *fuzzy_name = sf;

        if (!rt_bitmap_test_bit(ak, prep_ak))
        {
            next_ak = rt_bitmap_next_set_bit(ak, prep_ak + 1, max_ak) ? : len;
            field = next_ak - prep_ak;

            if (rt_strncmp(propname, fuzzy_name, field))
            {
                continue;
            }

            propname += field;
            fuzzy_name += field;
            prep_ak = next_ak;
        }

        rt_bitmap_for_each_set_bit_from(ak, prep_ak, next_ak, max_ak)
        {
            /* Skip the '*' */
            if (prep_ak == next_ak)
            {
                ++fuzzy_name;

                next_ak = rt_bitmap_next_set_bit(ak, prep_ak + 1, max_ak);
            }

            if (!(str = rt_strstr(propname, fuzzy_name)))
            {
                match = RT_FALSE;
                break;
            }

            field = next_ak - prep_ak;
            propname = str + field - 1;
            fuzzy_name += field;
            prep_ak = next_ak;
        }

        if (match)
        {
            if ((max_ak || !split_field[0]) && next_ak >= max_ak && len - max_ak > 1)
            {
                if (next_ak == max_ak)
                {
                    /* Skip the last '*' */
                    ++fuzzy_name;
                }

                if (!(propname = rt_strstr(propname, fuzzy_name)))
                {
                    continue;
                }

                /* Check end flag */
                if (propname[len - max_ak - 1] != '\0')
                {
                    continue;
                }
            }

            result = prop->name;
            break;
        }
    }

    return result;
}

const char *rt_ofw_get_prop_fuzzy_name(const struct rt_ofw_node *np, const char *name)
{
    const char *propname = RT_NULL;

    if (np && name)
    {
        propname = ofw_get_prop_fuzzy_name(np, name);
    }

    return propname;
}


struct rt_ofw_prop *rt_ofw_get_prop(const struct rt_ofw_node *np, const char *name, rt_ssize_t *out_length)
{
    struct rt_ofw_prop *prop = RT_NULL;

    if (np && name)
    {
        rt_ofw_foreach_prop(np, prop)
        {
            if (!rt_strcmp(prop->name, name))
            {
                if (out_length)
                {
                    *out_length = prop->length;
                }

                break;
            }
        }
    }

    return prop;
}

#define OFW_PROP_READ_UXX_ARRAY_INDEX(bit)                      \
int rt_ofw_prop_read_u##bit##_array_index(                      \
        const struct rt_ofw_node *np, const char *propname,     \
        int index, int nr, rt_uint##bit##_t *out_values)        \
{                                                               \
    int res, max_nr;                                            \
    if (np && propname && index >= 0 && nr >= 0 && out_values)  \
    {                                                           \
        rt_ssize_t len;                                         \
        const fdt##bit##_t *elm;                                \
        elm = rt_ofw_prop_read_raw(np, propname, &len);         \
        max_nr = len / sizeof(*elm);                            \
        if (elm && index < max_nr)                              \
        {                                                       \
            elm += index;                                       \
            max_nr -= index;                                    \
            res = nr > max_nr ? max_nr : nr;                    \
            for (nr = 0; nr < res; ++nr)                        \
            {                                                   \
                *out_values++ = fdt##bit##_to_cpu(*elm++);      \
            }                                                   \
        }                                                       \
        else                                                    \
        {                                                       \
            res = -RT_EEMPTY;                                   \
        }                                                       \
    }                                                           \
    else                                                        \
    {                                                           \
        res = -RT_EINVAL;                                       \
    }                                                           \
    return res;                                                 \
}

OFW_PROP_READ_UXX_ARRAY_INDEX(8)
OFW_PROP_READ_UXX_ARRAY_INDEX(16)
OFW_PROP_READ_UXX_ARRAY_INDEX(32)
OFW_PROP_READ_UXX_ARRAY_INDEX(64)

#undef OFW_PROP_READ_UXX_ARRAY_INDEX

int rt_ofw_prop_read_string_array_index(const struct rt_ofw_node *np, const char *propname,
        int index, int nr, const char **out_strings)
{
    int res = 0;

    if (np && propname && index >= 0 && nr >= 0 && out_strings)
    {
        rt_ssize_t len, slen = 0;
        const char *value = rt_ofw_prop_read_raw(np, propname, &len);

        if (value)
        {
            nr += index;

            for (int idx = 0; idx < nr && len > 0; ++idx)
            {
                /* Add '\0' */
                slen = rt_strlen(value) + 1;

                if (idx >= index)
                {
                    *out_strings++ = value;

                    ++res;
                }

                len -= slen;
                value += slen;
            }
        }
        else
        {
            res = -RT_EEMPTY;
        }
    }
    else
    {
        res = -RT_EINVAL;
    }

    return res;
}

int rt_ofw_prop_count_of_size(const struct rt_ofw_node *np, const char *propname, int size)
{
    int count;

    if (np && propname && size > 0)
    {
        rt_ssize_t len;

        count = -RT_EEMPTY;

        if (rt_ofw_get_prop(np, propname, &len))
        {
            count = len / size;
        }
    }
    else
    {
        count = -RT_EINVAL;
    }

    return count;
}

static rt_int32_t ofw_strcmp(const char *cs, const char *ct)
{
    return rt_strcmp(cs, ct);
}

int rt_ofw_prop_index_of_string(const struct rt_ofw_node *np, const char *propname, const char *string)
{
    int idx;

    if (np && propname && string)
    {
        struct rt_ofw_prop *prop = rt_ofw_get_prop(np, propname, RT_NULL);

        idx = -1;

        if (prop)
        {
            idx = ofw_prop_index_of_string(prop, string, ofw_strcmp);
        }
    }
    else
    {
        idx = -RT_EINVAL;
    }

    return idx;
}

const fdt32_t *rt_ofw_prop_next_u32(struct rt_ofw_prop *prop, const fdt32_t *cur, rt_uint32_t *out_value)
{
    if (prop && out_value)
    {
        if (cur)
        {
            ++cur;

            if ((void *)cur >= prop->value + prop->length)
            {
                cur = RT_NULL;
            }
        }
        else
        {
            cur = prop->value;
        }

        if (cur)
        {
            *out_value = fdt32_to_cpu(*cur);
        }
    }
    else
    {
        cur = RT_NULL;
    }

    return cur;
}

const char *rt_ofw_prop_next_string(struct rt_ofw_prop *prop, const char *cur)
{
    if (prop)
    {
        if (cur)
        {
            cur += rt_strlen(cur) + 1;

            if ((void *)cur >= prop->value + prop->length)
            {
                cur = RT_NULL;
            }
        }
        else
        {
            cur = prop->value;
        }
    }
    else
    {
        cur = RT_NULL;
    }

    return cur;
}