/*
|
* 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 necessary 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,
|
struct ufdt_node_pool *pool);
|
|
/*
|
* Frees all nodes in the subtree rooted at *node.
|
*/
|
void ufdt_node_destruct(struct ufdt_node *node, struct ufdt_node_pool *pool);
|
|
/*
|
* 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 `ufdt_from_fdt(fdtp, fdt_size)`
|
*
|
* @return: an empty ufdt with base fdtp = fdtp
|
*/
|
struct ufdt *ufdt_construct(void *fdtp, struct ufdt_node_pool *pool);
|
|
/*
|
* Frees the space occupied by the ufdt, including all ufdt_nodes
|
* with ufdt_static_phandle_table.
|
*/
|
void ufdt_destruct(struct ufdt *tree, struct ufdt_node_pool *pool);
|
|
/*
|
* 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 absolute 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);
|
|
/*
|
* Determines whether node->name equals to name[0..len-1]
|
*
|
* @return: true if they're equal.
|
* false otherwise
|
*/
|
bool ufdt_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 ufdt_node_merge_into(struct ufdt_node *node_a, struct ufdt_node *node_b,
|
struct ufdt_node_pool *pool);
|
|
/*
|
* END of ufdt methods.
|
*/
|
|
/*
|
* 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 *ufdt_from_fdt(void *fdtp, size_t fdt_size,
|
struct ufdt_node_pool *pool);
|
|
/*
|
* 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
|
*/
|
|
#endif /* LIBUFDT_H */
|
