|
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 } |