ufdt_node.c - platform/system/libufdt - Git at Google

 /*
  * 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.
  */

 #include "libufdt.h"

 #include "ufdt_node_pool.h"

 struct ufdt_node *ufdt_node_construct(void *fdtp, fdt32_t *fdt_tag_ptr,
                                       struct ufdt_node_pool *pool) {
   void *buf = ufdt_node_pool_alloc(pool);
   uint32_t tag = fdt32_to_cpu(*fdt_tag_ptr);
   if (tag == FDT_PROP) {
     const struct fdt_property *prop = (const struct fdt_property *)fdt_tag_ptr;
     struct ufdt_node_fdt_prop *res = (struct ufdt_node_fdt_prop *)buf;
     if (res == NULL) return NULL;
     res->parent.fdt_tag_ptr = fdt_tag_ptr;
     res->parent.sibling = NULL;
     res->name = fdt_string(fdtp, fdt32_to_cpu(prop->nameoff));
     return (struct ufdt_node *)res;
   } else {
     struct ufdt_node_fdt_node *res = (struct ufdt_node_fdt_node *)buf;
     if (res == NULL) return NULL;
     res->parent.fdt_tag_ptr = fdt_tag_ptr;
     res->parent.sibling = NULL;
     res->child = NULL;
     res->last_child_p = &res->child;
     return (struct ufdt_node *)res;
   }
 }

 void ufdt_node_destruct(struct ufdt_node *node, struct ufdt_node_pool *pool) {
   if (node == NULL) return;

   if (ufdt_node_tag(node) == FDT_BEGIN_NODE) {
     struct ufdt_node *it = ((struct ufdt_node_fdt_node *)node)->child;
     while (it != NULL) {
       struct ufdt_node *next = it->sibling;
       ufdt_node_destruct(it, pool);
       it = next;
     }
   }

   ufdt_node_pool_free(pool, node);
 }

 int ufdt_node_add_child(struct ufdt_node *parent, struct ufdt_node *child) {
   if (!parent || !child) return -1;
   if (ufdt_node_tag(parent) != FDT_BEGIN_NODE) return -1;

   int err = 0;
   uint32_t child_tag = ufdt_node_tag(child);
   switch (child_tag) {
     case FDT_PROP:
     case FDT_BEGIN_NODE:
       // Append the child node to the last child of parant node
       *((struct ufdt_node_fdt_node *)parent)->last_child_p = child;
       ((struct ufdt_node_fdt_node *)parent)->last_child_p = &child->sibling;
       break;

     default:
       err = -1;
       dto_error("invalid children tag type\n");
   }

   return err;
 }

 /*
  * BEGIN of FDT_PROP related methods.
  */

 struct ufdt_node *ufdt_node_get_subnode_by_name_len(const struct ufdt_node *node,
                                                   const char *name, int len) {
   struct ufdt_node **it = NULL;
   for_each_node(it, node) {
     if (ufdt_node_name_eq(*it, name, len)) return *it;
   }
   return NULL;
 }

 struct ufdt_node *ufdt_node_get_subnode_by_name(const struct ufdt_node *node,
                                               const char *name) {
   return ufdt_node_get_subnode_by_name_len(node, name, strlen(name));
 }

 struct ufdt_node *ufdt_node_get_property_by_name_len(
     const struct ufdt_node *node, const char *name, int len) {
   if (!node) return NULL;

   struct ufdt_node **it = NULL;
   for_each_prop(it, node) {
     if (ufdt_node_name_eq(*it, name, len)) return *it;
   }
   return NULL;
 }

 struct ufdt_node *ufdt_node_get_property_by_name(const struct ufdt_node *node,
                                                  const char *name) {
   return ufdt_node_get_property_by_name_len(node, name, dto_strlen(name));
 }

 char *ufdt_node_get_fdt_prop_data(const struct ufdt_node *node, int *out_len) {
   if (!node || ufdt_node_tag(node) != FDT_PROP) {
     return NULL;
   }
   const struct fdt_property *prop = (struct fdt_property *)node->fdt_tag_ptr;
   if (out_len != NULL) {
     *out_len = fdt32_to_cpu(prop->len);
   }
   return (char *)prop->data;
 }

 char *ufdt_node_get_fdt_prop_data_by_name_len(const struct ufdt_node *node,
                                               const char *name, int len,
                                               int *out_len) {
   return ufdt_node_get_fdt_prop_data(
       ufdt_node_get_property_by_name_len(node, name, len), out_len);
 }

 char *ufdt_node_get_fdt_prop_data_by_name(const struct ufdt_node *node,
                                           const char *name, int *out_len) {
   return ufdt_node_get_fdt_prop_data(ufdt_node_get_property_by_name(node, name),
                                      out_len);
 }

 /*
  * END of FDT_PROP related methods.
  */

 /*
  * BEGIN of searching-in-ufdt_node methods.
  */

 uint32_t ufdt_node_get_phandle(const struct ufdt_node *node) {
   if (!node || ufdt_node_tag(node) != FDT_BEGIN_NODE) {
     return 0;
   }
   int len = 0;
   void *ptr = ufdt_node_get_fdt_prop_data_by_name(node, "phandle", &len);
   if (!ptr || len != sizeof(fdt32_t)) {
     ptr = ufdt_node_get_fdt_prop_data_by_name(node, "linux,phandle", &len);
     if (!ptr || len != sizeof(fdt32_t)) {
       return 0;
     }
   }
   return fdt32_to_cpu(*((fdt32_t *)ptr));
 }

 struct ufdt_node *ufdt_node_get_node_by_path_len(const struct ufdt_node *node,
                                                  const char *path, int len) {
   const char *end = path + len;

   struct ufdt_node *cur = (struct ufdt_node *)node;

   while (path < end) {
     while (path[0] == '/') path++;
     if (path == end) return cur;

     const char *next_slash;
     next_slash = dto_memchr(path, '/', end - path);
     if (!next_slash) next_slash = end;

     struct ufdt_node *next = NULL;

     next = ufdt_node_get_subnode_by_name_len(cur, path, next_slash - path);

     cur = next;
     path = next_slash;
     if (!cur) return cur;
   }

   return cur;
 }

 struct ufdt_node *ufdt_node_get_node_by_path(const struct ufdt_node *node,
                                              const char *path) {
   return ufdt_node_get_node_by_path_len(node, path, dto_strlen(path));
 }

 bool ufdt_node_name_eq(const struct ufdt_node *node, const char *name, int len) {
   if (!node) return false;
   if (!name) return false;
   if (dto_strncmp(ufdt_node_name(node), name, len) != 0) return false;
   if (ufdt_node_name(node)[len] != '\0') return false;
   return true;
 }

 /*
  * END of searching-in-ufdt_node methods.
  */

 static int merge_children(struct ufdt_node *node_a, struct ufdt_node *node_b,
                           struct ufdt_node_pool *pool) {
   int err = 0;
   struct ufdt_node *it;
   for (it = ((struct ufdt_node_fdt_node *)node_b)->child; it;) {
     struct ufdt_node *cur_node = it;
     it = it->sibling;
     cur_node->sibling = NULL;
     struct ufdt_node *target_node = NULL;
     if (ufdt_node_tag(cur_node) == FDT_BEGIN_NODE) {
       target_node =
           ufdt_node_get_subnode_by_name(node_a, ufdt_node_name(cur_node));
     } else {
       target_node =
           ufdt_node_get_property_by_name(node_a, ufdt_node_name(cur_node));
     }
     if (target_node == NULL) {
       err = ufdt_node_add_child(node_a, cur_node);
     } else {
       err = ufdt_node_merge_into(target_node, cur_node, pool);
       ufdt_node_pool_free(pool, cur_node);
     }
     if (err < 0) return -1;
   }
   /*
    * The ufdt_node* in node_b will be copied to node_a.
    * To prevent the ufdt_node from being freed twice
    * (main_tree and overlay_tree) at the end of function
    * ufdt_apply_overlay(), set this node in node_b
    * (overlay_tree) to NULL.
    */
   ((struct ufdt_node_fdt_node *)node_b)->child = NULL;

   return 0;
 }

 int ufdt_node_merge_into(struct ufdt_node *node_a, struct ufdt_node *node_b,
                          struct ufdt_node_pool *pool) {
   if (ufdt_node_tag(node_a) == FDT_PROP) {
     node_a->fdt_tag_ptr = node_b->fdt_tag_ptr;
     return 0;
   }

   int err = 0;
   err = merge_children(node_a, node_b, pool);
   if (err < 0) return -1;

   return 0;
 }

 #define TAB_SIZE 2

 void ufdt_node_print(const struct ufdt_node *node, int depth) {
   if (!node) return;

   int i;
   for (i = 0; i < depth * TAB_SIZE; i++) dto_print(" ");

   uint32_t tag;
   tag = ufdt_node_tag(node);

   switch (tag) {
     case FDT_BEGIN_NODE:
       dto_print("NODE ");
       break;
     case FDT_PROP:
       dto_print("PROP ");
       break;
     default:
       dto_print("UNKNOWN ");
       break;
   }

   if (ufdt_node_name(node)) {
     dto_print(":%s:\n", ufdt_node_name(node));
   } else {
     dto_print("node name is NULL.\n");
   }

   if (ufdt_node_tag(node) == FDT_BEGIN_NODE) {
     struct ufdt_node **it;

     for_each_prop(it, node) ufdt_node_print(*it, depth + 1);

     for_each_node(it, node) ufdt_node_print(*it, depth + 1);
   }
 }
	/*
	* 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.
	*/

	#include "libufdt.h"

	#include "ufdt_node_pool.h"

	struct ufdt_node ufdt_node_construct(void fdtp, fdt32_t *fdt_tag_ptr,
	struct ufdt_node_pool *pool) {
	void *buf = ufdt_node_pool_alloc(pool);
	uint32_t tag = fdt32_to_cpu(*fdt_tag_ptr);
	if (tag == FDT_PROP) {
	const struct fdt_property prop = (const struct fdt_property )fdt_tag_ptr;
	struct ufdt_node_fdt_prop res = (struct ufdt_node_fdt_prop )buf;
	if (res == NULL) return NULL;
	res->parent.fdt_tag_ptr = fdt_tag_ptr;
	res->parent.sibling = NULL;
	res->name = fdt_string(fdtp, fdt32_to_cpu(prop->nameoff));
	return (struct ufdt_node *)res;
	} else {
	struct ufdt_node_fdt_node res = (struct ufdt_node_fdt_node )buf;
	if (res == NULL) return NULL;
	res->parent.fdt_tag_ptr = fdt_tag_ptr;
	res->parent.sibling = NULL;
	res->child = NULL;
	res->last_child_p = &res->child;
	return (struct ufdt_node *)res;
	}
	}

	void ufdt_node_destruct(struct ufdt_node node, struct ufdt_node_pool pool) {
	if (node == NULL) return;

	if (ufdt_node_tag(node) == FDT_BEGIN_NODE) {
	struct ufdt_node it = ((struct ufdt_node_fdt_node )node)->child;
	while (it != NULL) {
	struct ufdt_node *next = it->sibling;
	ufdt_node_destruct(it, pool);
	it = next;
	}
	}

	ufdt_node_pool_free(pool, node);
	}

	int ufdt_node_add_child(struct ufdt_node parent, struct ufdt_node child) {
	if (!parent \|\| !child) return -1;
	if (ufdt_node_tag(parent) != FDT_BEGIN_NODE) return -1;

	int err = 0;
	uint32_t child_tag = ufdt_node_tag(child);
	switch (child_tag) {
	case FDT_PROP:
	case FDT_BEGIN_NODE:
	// Append the child node to the last child of parant node
	((struct ufdt_node_fdt_node )parent)->last_child_p = child;
	((struct ufdt_node_fdt_node *)parent)->last_child_p = &child->sibling;
	break;

	default:
	err = -1;
	dto_error("invalid children tag type\n");
	}

	return err;
	}

	/*
	* BEGIN of FDT_PROP related methods.
	*/

	struct ufdt_node ufdt_node_get_subnode_by_name_len(const struct ufdt_node node,
	const char *name, int len) {
	struct ufdt_node **it = NULL;
	for_each_node(it, node) {
	if (ufdt_node_name_eq(it, name, len)) return it;
	}
	return NULL;
	}

	struct ufdt_node ufdt_node_get_subnode_by_name(const struct ufdt_node node,
	const char *name) {
	return ufdt_node_get_subnode_by_name_len(node, name, strlen(name));
	}

	struct ufdt_node *ufdt_node_get_property_by_name_len(
	const struct ufdt_node node, const char name, int len) {
	if (!node) return NULL;

	struct ufdt_node **it = NULL;
	for_each_prop(it, node) {
	if (ufdt_node_name_eq(it, name, len)) return it;
	}
	return NULL;
	}

	struct ufdt_node ufdt_node_get_property_by_name(const struct ufdt_node node,
	const char *name) {
	return ufdt_node_get_property_by_name_len(node, name, dto_strlen(name));
	}

	char ufdt_node_get_fdt_prop_data(const struct ufdt_node node, int *out_len) {
	if (!node \|\| ufdt_node_tag(node) != FDT_PROP) {
	return NULL;
	}
	const struct fdt_property prop = (struct fdt_property )node->fdt_tag_ptr;
	if (out_len != NULL) {
	*out_len = fdt32_to_cpu(prop->len);
	}
	return (char *)prop->data;
	}

	char ufdt_node_get_fdt_prop_data_by_name_len(const struct ufdt_node node,
	const char *name, int len,
	int *out_len) {
	return ufdt_node_get_fdt_prop_data(
	ufdt_node_get_property_by_name_len(node, name, len), out_len);
	}

	char ufdt_node_get_fdt_prop_data_by_name(const struct ufdt_node node,
	const char name, int out_len) {
	return ufdt_node_get_fdt_prop_data(ufdt_node_get_property_by_name(node, name),
	out_len);
	}

	/*
	* END of FDT_PROP related methods.
	*/

	/*
	* BEGIN of searching-in-ufdt_node methods.
	*/

	uint32_t ufdt_node_get_phandle(const struct ufdt_node *node) {
	if (!node \|\| ufdt_node_tag(node) != FDT_BEGIN_NODE) {
	return 0;
	}
	int len = 0;
	void *ptr = ufdt_node_get_fdt_prop_data_by_name(node, "phandle", &len);
	if (!ptr \|\| len != sizeof(fdt32_t)) {
	ptr = ufdt_node_get_fdt_prop_data_by_name(node, "linux,phandle", &len);
	if (!ptr \|\| len != sizeof(fdt32_t)) {
	return 0;
	}
	}
	return fdt32_to_cpu(((fdt32_t )ptr));
	}

	struct ufdt_node ufdt_node_get_node_by_path_len(const struct ufdt_node node,
	const char *path, int len) {
	const char *end = path + len;

	struct ufdt_node cur = (struct ufdt_node )node;

	while (path < end) {
	while (path[0] == '/') path++;
	if (path == end) return cur;

	const char *next_slash;
	next_slash = dto_memchr(path, '/', end - path);
	if (!next_slash) next_slash = end;

	struct ufdt_node *next = NULL;

	next = ufdt_node_get_subnode_by_name_len(cur, path, next_slash - path);

	cur = next;
	path = next_slash;
	if (!cur) return cur;
	}

	return cur;
	}

	struct ufdt_node ufdt_node_get_node_by_path(const struct ufdt_node node,
	const char *path) {
	return ufdt_node_get_node_by_path_len(node, path, dto_strlen(path));
	}

	bool ufdt_node_name_eq(const struct ufdt_node node, const char name, int len) {
	if (!node) return false;
	if (!name) return false;
	if (dto_strncmp(ufdt_node_name(node), name, len) != 0) return false;
	if (ufdt_node_name(node)[len] != '\0') return false;
	return true;
	}

	/*
	* END of searching-in-ufdt_node methods.
	*/

	static int merge_children(struct ufdt_node node_a, struct ufdt_node node_b,
	struct ufdt_node_pool *pool) {
	int err = 0;
	struct ufdt_node *it;
	for (it = ((struct ufdt_node_fdt_node *)node_b)->child; it;) {
	struct ufdt_node *cur_node = it;
	it = it->sibling;
	cur_node->sibling = NULL;
	struct ufdt_node *target_node = NULL;
	if (ufdt_node_tag(cur_node) == FDT_BEGIN_NODE) {
	target_node =
	ufdt_node_get_subnode_by_name(node_a, ufdt_node_name(cur_node));
	} else {
	target_node =
	ufdt_node_get_property_by_name(node_a, ufdt_node_name(cur_node));
	}
	if (target_node == NULL) {
	err = ufdt_node_add_child(node_a, cur_node);
	} else {
	err = ufdt_node_merge_into(target_node, cur_node, pool);
	ufdt_node_pool_free(pool, cur_node);
	}
	if (err < 0) return -1;
	}
	/*
	* The ufdt_node* in node_b will be copied to node_a.
	* To prevent the ufdt_node from being freed twice
	* (main_tree and overlay_tree) at the end of function
	* ufdt_apply_overlay(), set this node in node_b
	* (overlay_tree) to NULL.
	*/
	((struct ufdt_node_fdt_node *)node_b)->child = NULL;

	return 0;
	}

	int ufdt_node_merge_into(struct ufdt_node node_a, struct ufdt_node node_b,
	struct ufdt_node_pool *pool) {
	if (ufdt_node_tag(node_a) == FDT_PROP) {
	node_a->fdt_tag_ptr = node_b->fdt_tag_ptr;
	return 0;
	}

	int err = 0;
	err = merge_children(node_a, node_b, pool);
	if (err < 0) return -1;

	return 0;
	}

	#define TAB_SIZE 2

	void ufdt_node_print(const struct ufdt_node *node, int depth) {
	if (!node) return;

	int i;
	for (i = 0; i < depth * TAB_SIZE; i++) dto_print(" ");

	uint32_t tag;
	tag = ufdt_node_tag(node);

	switch (tag) {
	case FDT_BEGIN_NODE:
	dto_print("NODE ");
	break;
	case FDT_PROP:
	dto_print("PROP ");
	break;
	default:
	dto_print("UNKNOWN ");
	break;
	}

	if (ufdt_node_name(node)) {
	dto_print(":%s:\n", ufdt_node_name(node));
	} else {
	dto_print("node name is NULL.\n");
	}

	if (ufdt_node_tag(node) == FDT_BEGIN_NODE) {
	struct ufdt_node **it;

	for_each_prop(it, node) ufdt_node_print(*it, depth + 1);

	for_each_node(it, node) ufdt_node_print(*it, depth + 1);
	}
	}