1 /*

     2  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.

     3  *

     4  *

     5  * This program is free software; you can redistribute it and/or

     6  * modify it under the terms of the GNU General Public License as

     7  * published by the Free Software Foundation; either version 2 of the

     8  * License, or (at your option) any later version.

     9  *

    10  *  This program is distributed in the hope that it will be useful,

    11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13  *  General Public License for more details.

    14  *

    15  *  You should have received a copy of the GNU General Public License

    16  *  along with this program; if not, write to the Free Software

    17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307

    18  *                                                                   USA

    19  */

    20 

    21 #include "dtc.h"

    22 

    23 /*

    24  * Tree building functions

    25  */

    26 

    27 struct property *build_property(char *name, struct data val, char *label)

    28 {

    29 	struct property *new = xmalloc(sizeof(*new));

    30 

    31 	new->name = name;

    32 	new->val = val;

    33 

    34 	new->next = NULL;

    35 

    36 	new->label = label;

    37 

    38 	return new;

    39 }

    40 

    41 struct property *chain_property(struct property *first, struct property *list)

    42 {

    43 	assert(first->next == NULL);

    44 

    45 	first->next = list;

    46 	return first;

    47 }

    48 

    49 struct property *reverse_properties(struct property *first)

    50 {

    51 	struct property *p = first;

    52 	struct property *head = NULL;

    53 	struct property *next;

    54 

    55 	while (p) {

    56 		next = p->next;

    57 		p->next = head;

    58 		head = p;

    59 		p = next;

    60 	}

    61 	return head;

    62 }

    63 

    64 struct node *build_node(struct property *proplist, struct node *children)

    65 {

    66 	struct node *new = xmalloc(sizeof(*new));

    67 	struct node *child;

    68 

    69 	memset(new, 0, sizeof(*new));

    70 

    71 	new->proplist = reverse_properties(proplist);

    72 	new->children = children;

    73 

    74 	for_each_child(new, child) {

    75 		child->parent = new;

    76 	}

    77 

    78 	return new;

    79 }

    80 

    81 struct node *name_node(struct node *node, char *name, char * label)

    82 {

    83 	assert(node->name == NULL);

    84 

    85 	node->name = name;

    86 

    87 	node->label = label;

    88 

    89 	return node;

    90 }

    91 

    92 struct node *chain_node(struct node *first, struct node *list)

    93 {

    94 	assert(first->next_sibling == NULL);

    95 

    96 	first->next_sibling = list;

    97 	return first;

    98 }

    99 

   100 void add_property(struct node *node, struct property *prop)

   101 {

   102 	struct property **p;

   103 

   104 	prop->next = NULL;

   105 

   106 	p = &node->proplist;

   107 	while (*p)

   108 		p = &((*p)->next);

   109 

   110 	*p = prop;

   111 }

   112 

   113 void add_child(struct node *parent, struct node *child)

   114 {

   115 	struct node **p;

   116 

   117 	child->next_sibling = NULL;

   118 	child->parent = parent;

   119 

   120 	p = &parent->children;

   121 	while (*p)

   122 		p = &((*p)->next_sibling);

   123 

   124 	*p = child;

   125 }

   126 

   127 struct reserve_info *build_reserve_entry(uint64_t address, uint64_t size,

   128 					 char *label)

   129 {

   130 	struct reserve_info *new = xmalloc(sizeof(*new));

   131 

   132 	new->re.address = address;

   133 	new->re.size = size;

   134 

   135 	new->next = NULL;

   136 

   137 	new->label = label;

   138 

   139 	return new;

   140 }

   141 

   142 struct reserve_info *chain_reserve_entry(struct reserve_info *first,

   143 					struct reserve_info *list)

   144 {

   145 	assert(first->next == NULL);

   146 

   147 	first->next = list;

   148 	return first;

   149 }

   150 

   151 struct reserve_info *add_reserve_entry(struct reserve_info *list,

   152 				      struct reserve_info *new)

   153 {

   154 	struct reserve_info *last;

   155 

   156 	new->next = NULL;

   157 

   158 	if (! list)

   159 		return new;

   160 

   161 	for (last = list; last->next; last = last->next)

   162 		;

   163 

   164 	last->next = new;

   165 

   166 	return list;

   167 }

   168 

   169 struct boot_info *build_boot_info(struct reserve_info *reservelist,

   170 				  struct node *tree, uint32_t boot_cpuid_phys)

   171 {

   172 	struct boot_info *bi;

   173 

   174 	bi = xmalloc(sizeof(*bi));

   175 	bi->reservelist = reservelist;

   176 	bi->dt = tree;

   177 	bi->boot_cpuid_phys = boot_cpuid_phys;

   178 

   179 	return bi;

   180 }

   181 

   182 /*

   183  * Tree accessor functions

   184  */

   185 

   186 const char *get_unitname(struct node *node)

   187 {

   188 	if (node->name[node->basenamelen] == '\0')

   189 		return "";

   190 	else

   191 		return node->name + node->basenamelen + 1;

   192 }

   193 

   194 struct property *get_property(struct node *node, const char *propname)

   195 {

   196 	struct property *prop;

   197 

   198 	for_each_property(node, prop)

   199 		if (streq(prop->name, propname))

   200 			return prop;

   201 

   202 	return NULL;

   203 }

   204 

   205 cell_t propval_cell(struct property *prop)

   206 {

   207 	assert(prop->val.len == sizeof(cell_t));

   208 	return fdt32_to_cpu(*((cell_t *)prop->val.val));

   209 }

   210 

   211 struct node *get_subnode(struct node *node, const char *nodename)

   212 {

   213 	struct node *child;

   214 

   215 	for_each_child(node, child)

   216 		if (streq(child->name, nodename))

   217 			return child;

   218 

   219 	return NULL;

   220 }

   221 

   222 struct node *get_node_by_path(struct node *tree, const char *path)

   223 {

   224 	const char *p;

   225 	struct node *child;

   226 

   227 	if (!path || ! (*path))

   228 		return tree;

   229 

   230 	while (path[0] == '/')

   231 		path++;

   232 

   233 	p = strchr(path, '/');

   234 

   235 	for_each_child(tree, child) {

   236 		if (p && strneq(path, child->name, p-path))

   237 			return get_node_by_path(child, p+1);

   238 		else if (!p && streq(path, child->name))

   239 			return child;

   240 	}

   241 

   242 	return NULL;

   243 }

   244 

   245 struct node *get_node_by_label(struct node *tree, const char *label)

   246 {

   247 	struct node *child, *node;

   248 

   249 	assert(label && (strlen(label) > 0));

   250 

   251 	if (tree->label && streq(tree->label, label))

   252 		return tree;

   253 

   254 	for_each_child(tree, child) {

   255 		node = get_node_by_label(child, label);

   256 		if (node)

   257 			return node;

   258 	}

   259 

   260 	return NULL;

   261 }

   262 

   263 struct node *get_node_by_phandle(struct node *tree, cell_t phandle)

   264 {

   265 	struct node *child, *node;

   266 

   267 	assert((phandle != 0) && (phandle != -1));

   268 

   269 	if (tree->phandle == phandle)

   270 		return tree;

   271 

   272 	for_each_child(tree, child) {

   273 		node = get_node_by_phandle(child, phandle);

   274 		if (node)

   275 			return node;

   276 	}

   277 

   278 	return NULL;

   279 }

   280 

   281 struct node *get_node_by_ref(struct node *tree, const char *ref)

   282 {

   283 	if (ref[0] == '/')

   284 		return get_node_by_path(tree, ref);

   285 	else

   286 		return get_node_by_label(tree, ref);

   287 }

   288 

   289 cell_t get_node_phandle(struct node *root, struct node *node)

   290 {

   291 	static cell_t phandle = 1; /* FIXME: ick, static local */

   292 

   293 	if ((node->phandle != 0) && (node->phandle != -1))

   294 		return node->phandle;

   295 

   296 	assert(! get_property(node, "linux,phandle"));

   297 

   298 	while (get_node_by_phandle(root, phandle))

   299 		phandle++;

   300 

   301 	node->phandle = phandle;

   302 	add_property(node,

   303 		     build_property("linux,phandle",

   304 				    data_append_cell(empty_data, phandle),

   305 				    NULL));

   306 

   307 	return node->phandle;

   308 }