Commit | Line | Data |
---|---|---|
a4da2e3e DG |
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; | |
ed95d745 | 118 | child->parent = parent; |
a4da2e3e DG |
119 | |
120 | p = &parent->children; | |
121 | while (*p) | |
122 | p = &((*p)->next_sibling); | |
123 | ||
124 | *p = child; | |
125 | } | |
126 | ||
ed95d745 DG |
127 | struct reserve_info *build_reserve_entry(uint64_t address, uint64_t size, |
128 | char *label) | |
a4da2e3e DG |
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, | |
ed95d745 | 170 | struct node *tree, uint32_t boot_cpuid_phys) |
a4da2e3e DG |
171 | { |
172 | struct boot_info *bi; | |
173 | ||
174 | bi = xmalloc(sizeof(*bi)); | |
175 | bi->reservelist = reservelist; | |
176 | bi->dt = tree; | |
ed95d745 | 177 | bi->boot_cpuid_phys = boot_cpuid_phys; |
a4da2e3e DG |
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)); | |
ed95d745 | 208 | return fdt32_to_cpu(*((cell_t *)prop->val.val)); |
a4da2e3e DG |
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 | } |