xref: /system/libufdt/include/libufdt.h

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef LIBUFDT_H
#define LIBUFDT_H

#include "libufdt_sysdeps.h"
#include "ufdt_types.h"

/*
 * BEGIN of ufdt_node methods
 */

/*
 * Allocates spaces for new ufdt_node who represents a fdt node at fdt_tag_ptr.
 * In order to get name pointer, it's neccassary to give the pointer to the
 * entire fdt it belongs to.
 *
 *
 * @return: a pointer to the newly created ufdt_node or
 *          NULL if dto_malloc failed
 */
struct ufdt_node *ufdt_node_construct(void *fdtp, fdt32_t *fdt_tag_ptr);

/*
 * Frees all nodes in the subtree rooted at *node.
 */
void ufdt_node_destruct(struct ufdt_node *node);

/*
 * Adds the child as a subnode of the parent.
 * It's been done by add entries in parent->prop_list or node_list depending on
 * the tag type of child.
 *
 * @return: 0 if success
 *          < 0 otherwise
 *
 * @Time: O(1) w.h.p.
 */
int ufdt_node_add_child(struct ufdt_node *parent, struct ufdt_node *child);

/* BEGIN of FDT_PROP related functions .*/

/*
 * Gets pointer to FDT_PROP subnode of node with name equals to name[0..len-1]
 *
 * @return: a pointer to the subnode or
 *          NULL if no such subnode.
 *
 * @Time: O(len = length of name) w.h.p.
 */
struct ufdt_node *ufdt_node_get_property_by_name_len(
    const struct ufdt_node *node, const char *name, int len);
struct ufdt_node *ufdt_node_get_property_by_name(const struct ufdt_node *node,
                                                 const char *name);

/*
 * Gets the pointer to the FDT_PROP node's data in the corresponding fdt.
 * Also writes the length of such data to *out_len if out_len is not NULL.
 *
 * @return: a pointer to some data located in fdt or
 *          NULL if *node is not a FDT_PROP
 */
char *ufdt_node_get_fdt_prop_data(const struct ufdt_node *node, int *out_len);

/*
 * Gets pointer to FDT_PROP node's data in fdt with name equals to
 * name[0..len-1], which is a subnode of *node.
 * It's actually a composition of ufdt_node_get_property_by_name and
 * ufdt_node_get_fdt_prop_data
 *
 * @return: a pointer to some data located in fdt or
 *          NULL if no such subnode.
 *
 * @Time: O(len = length of name) w.h.p.
 */
char *ufdt_node_get_fdt_prop_data_by_name_len(const struct ufdt_node *node,
                                              const char *name, int len,
                                              int *out_len);
char *ufdt_node_get_fdt_prop_data_by_name(const struct ufdt_node *node,
                                          const char *name, int *out_len);

/* END of FDT_PROP related functions .*/

/*
 * Gets pointer to FDT_BEGIN_NODE subnode of node with name equals to
 * name[0..len-1].
 *
 * @return: a pointer to the subnode or
 *          NULL if no such subnode.
 *
 * @Time: O(len = length of name) w.h.p.
 */

struct ufdt_node *ufdt_node_get_subnode_by_name_len(const struct ufdt_node *node,
                                                    const char *name, int len);
struct ufdt_node *ufdt_node_get_subnode_by_name(const struct ufdt_node *node,
                                                const char *name);

/*
 * Gets the pointer to FDT_NODE node whose relative path to *node is
 * path[0..len-1].
 * Note that the relative path doesn't support parent node like:
 * "../path/to/node".
 *
 * @return: a pointer to the node or
 *          NULL if no such node.
 *
 * @Time: O(len = length of path) w.h.p.
 */
struct ufdt_node *ufdt_node_get_node_by_path_len(const struct ufdt_node *node,
                                                 const char *path, int len);
struct ufdt_node *ufdt_node_get_node_by_path(const struct ufdt_node *node,
                                             const char *path);

/*
 * Gets the phandle value of the node if it has.
 *
 * @return: phandle value of that node or
 *          0 if *node is not FDT_NODE or there's no "phandle"/"linux,phandle"
 *          property.
 *
 * @Time: O(1) w.h.p.
 */
uint32_t ufdt_node_get_phandle(const struct ufdt_node *node);

/*
 * END of ufdt_node methods
 */

/*
 * BEGIN of ufdt methods.
 */

/*
 * Constructs a ufdt whose base fdt is fdtp.
 * Note that this function doesn't construct the entire tree.
 * To get the whole tree please call `fdt_to_ufdt(fdtp, fdt_size)`
 *
 * @return: an empty ufdt with base fdtp = fdtp
 */
struct ufdt *ufdt_construct(void *fdtp);

/*
 * Frees the space occupied by the ufdt, including all ufdt_nodes
 * with static_phandle_table.
 */
void ufdt_destruct(struct ufdt *tree);

/*
 * Add a fdt into this ufdt.
 * Note that this function just add the given fdtp into this ufdt,
 * and doesn't create any node.
 *
 * @return: 0 if success.
 */
int ufdt_add_fdt(struct ufdt *tree, void *fdtp);

/*
 * Calculate the offset in the string tables of the given string.
 * All string tables will be concatenated in reversed order.
 *
 * @return: The offset is a negative number, base on the end position of
 *          all concatenated string tables
 *          Return 0 if not in any string table.
 */
int ufdt_get_string_off(const struct ufdt *tree, const char *s);

/*
 * Gets the pointer to the ufdt_node in tree with phandle = phandle.
 * The function do a binary search in tree->phandle_table.
 *
 * @return: a pointer to the target ufdt_node
 *          NULL if no ufdt_node has phandle = phandle
 *
 * @Time: O(log(# of nodes in tree)) = O(log(size of underlying fdt))
 */
struct ufdt_node *ufdt_get_node_by_phandle(struct ufdt *tree, uint32_t phandle);

/*
 * Gets the pointer to the ufdt_node in tree with absoulte path =
 * path[0..len-1].
 * Absolute path has form "/path/to/node" or "some_alias/to/node".
 * In later example, some_alias is a property in "/aliases" with data is a path
 * to some node X. Then the funcion will return node with relative
 * path = "to/node" w.r.t. X.
 *
 * @return: a pointer to the target ufdt_node or
 *          NULL if such dnt doesn't exist.
 *
 * @Time: O(len = length of path) w.h.p.
 */
struct ufdt_node *ufdt_get_node_by_path_len(struct ufdt *tree, const char *path,
                                            int len);
struct ufdt_node *ufdt_get_node_by_path(struct ufdt *tree, const char *path);

/*
 * END of ufdt methods.
 */

/*
 * Compares function between 2 nodes, compare by name of each node.
 *
 * @return: x < 0  if a's name is lexicographically smaller
 *          x == 0 if a, b has same name
 *          x > 0  if a's name is lexicographically bigger
 */
int node_cmp(const void *a, const void *b);

/*
 * Determines whether node->name equals to name[0..len-1]
 *
 * @return: true if they're equal.
 *          false otherwise
 */
bool node_name_eq(const struct ufdt_node *node, const char *name, int len);

/*
 * Merges tree_b into tree_a with tree_b has all nodes except root disappeared.
 * Overwrite property in tree_a if there's one with same name in tree_b.
 * Otherwise add the property to tree_a.
 * For subnodes with the same name, recursively run this function.
 *
 * Ex:
 * tree_a : ta {
 *  b = "b";
 *  c = "c";
 *  d {
 *    e = "g";
 *  };
 * };
 *
 * tree_b : tb {
 *  c = "C";
 *  g = "G";
 *  d {
 *    da = "dad";
 *  };
 *  h {
 *    hh = "HH";
 *  };
 * };
 *
 * The resulting trees will be:
 *
 * tree_a : ta {
 *  b = "b";
 *  c = "C";
 *  g = "G";
 *  d {
 *    da = "dad";
 *    e = "g";
 *  };
 *  h {
 *    hh = "HH";
 *  };
 * };
 *
 * tree_b : tb {
 * };
 *
 *
 * @return: 0 if merge success
 *          < 0 otherwise
 *
 * @Time: O(# of nodes in tree_b + total length of all names in tree_b) w.h.p.
 */
int merge_ufdt_into(struct ufdt_node *tree_a, struct ufdt_node *tree_b);

/*
 * BEGIN of ufdt output functions
 */

/*
 * Builds the ufdt for FDT pointed by fdtp.
 *
 * @return: the ufdt T representing fdtp or
 *          T with T.fdtp == NULL if fdtp is unvalid.
 *
 * @Time: O(fdt_size + nlogn) where n = # of nodes in fdt.
 */
struct ufdt *fdt_to_ufdt(void *fdtp, size_t fdt_size);

/*
 * Sequentially dumps the whole ufdt to FDT buffer fdtp with buffer size
 * buf_size.
 *
 * Basically using functions provided by libfdt/fdt_sw.c.
 *
 * @return: 0 if successfully dump or
 *          < 0 otherwise
 *
 * @Time: O(total length of all names + # of nodes in tree)
 */
int ufdt_to_fdt(const struct ufdt *tree, void *buf, int buf_size);

/*
 * prints the entire subtree rooted at *node in form:
 * NODE :[node name]:
 *   PROP :[prop name]:
 *   ...
 *   NODE :[subnode1 name]:
 *     ...
 *   NODE :[subnode1 name]:
 *     ...
 *   ...
 * There're (depth * TAB_SIZE) spaces in front of each line.
 */
void ufdt_node_print(const struct ufdt_node *node, int depth);

/*
 * It's just ufdt_node_print(tree->root, 0).
 */
void ufdt_print(struct ufdt *tree);

/*
 * END of ufdt output functions
 */

/*
 * Runs closure.func(node, closure.env) for all nodes in subtree rooted at
 * *node.
 * The order of each node being applied by the function is depth first.
 * Basically it's the same order as the order printed in ufdt_node_print().
 *
 * Example:
 *
 * void print_name(struct ufdt_node *node, void *env) {
 *   printf("%s\n", node->name);
 * }
 *
 * struct ufdt_node_closure clos;
 * clos.func = print_name;
 * clos.env = NULL;
 * ufdt_map(tree, clos);
 *
 * Then you can print all names of nodes in tree.
 *
 * @Time: O((# of nodes in subtree rooted at *node) * avg. running time of the
 * function closure.func)
 */
void ufdt_node_map(struct ufdt_node *node, struct ufdt_node_closure closure);

/*
 * It's just ufdt_node_map(tree->root, closure);
 */
void ufdt_map(struct ufdt *tree, struct ufdt_node_closure closure);

#endif /* LIBUFDT_H */