]>
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; | |
118 | ||
119 | p = &parent->children; | |
120 | while (*p) | |
121 | p = &((*p)->next_sibling); | |
122 | ||
123 | *p = child; | |
124 | } | |
125 | ||
126 | struct reserve_info *build_reserve_entry(u64 address, u64 size, char *label) | |
127 | { | |
128 | struct reserve_info *new = xmalloc(sizeof(*new)); | |
129 | ||
130 | new->re.address = address; | |
131 | new->re.size = size; | |
132 | ||
133 | new->next = NULL; | |
134 | ||
135 | new->label = label; | |
136 | ||
137 | return new; | |
138 | } | |
139 | ||
140 | struct reserve_info *chain_reserve_entry(struct reserve_info *first, | |
141 | struct reserve_info *list) | |
142 | { | |
143 | assert(first->next == NULL); | |
144 | ||
145 | first->next = list; | |
146 | return first; | |
147 | } | |
148 | ||
149 | struct reserve_info *add_reserve_entry(struct reserve_info *list, | |
150 | struct reserve_info *new) | |
151 | { | |
152 | struct reserve_info *last; | |
153 | ||
154 | new->next = NULL; | |
155 | ||
156 | if (! list) | |
157 | return new; | |
158 | ||
159 | for (last = list; last->next; last = last->next) | |
160 | ; | |
161 | ||
162 | last->next = new; | |
163 | ||
164 | return list; | |
165 | } | |
166 | ||
167 | struct boot_info *build_boot_info(struct reserve_info *reservelist, | |
168 | struct node *tree) | |
169 | { | |
170 | struct boot_info *bi; | |
171 | ||
172 | bi = xmalloc(sizeof(*bi)); | |
173 | bi->reservelist = reservelist; | |
174 | bi->dt = tree; | |
175 | ||
176 | return bi; | |
177 | } | |
178 | ||
179 | /* | |
180 | * Tree accessor functions | |
181 | */ | |
182 | ||
183 | const char *get_unitname(struct node *node) | |
184 | { | |
185 | if (node->name[node->basenamelen] == '\0') | |
186 | return ""; | |
187 | else | |
188 | return node->name + node->basenamelen + 1; | |
189 | } | |
190 | ||
191 | struct property *get_property(struct node *node, const char *propname) | |
192 | { | |
193 | struct property *prop; | |
194 | ||
195 | for_each_property(node, prop) | |
196 | if (streq(prop->name, propname)) | |
197 | return prop; | |
198 | ||
199 | return NULL; | |
200 | } | |
201 | ||
202 | cell_t propval_cell(struct property *prop) | |
203 | { | |
204 | assert(prop->val.len == sizeof(cell_t)); | |
205 | return be32_to_cpu(*((cell_t *)prop->val.val)); | |
206 | } | |
207 | ||
208 | struct node *get_subnode(struct node *node, const char *nodename) | |
209 | { | |
210 | struct node *child; | |
211 | ||
212 | for_each_child(node, child) | |
213 | if (streq(child->name, nodename)) | |
214 | return child; | |
215 | ||
216 | return NULL; | |
217 | } | |
218 | ||
219 | struct node *get_node_by_path(struct node *tree, const char *path) | |
220 | { | |
221 | const char *p; | |
222 | struct node *child; | |
223 | ||
224 | if (!path || ! (*path)) | |
225 | return tree; | |
226 | ||
227 | while (path[0] == '/') | |
228 | path++; | |
229 | ||
230 | p = strchr(path, '/'); | |
231 | ||
232 | for_each_child(tree, child) { | |
233 | if (p && strneq(path, child->name, p-path)) | |
234 | return get_node_by_path(child, p+1); | |
235 | else if (!p && streq(path, child->name)) | |
236 | return child; | |
237 | } | |
238 | ||
239 | return NULL; | |
240 | } | |
241 | ||
242 | struct node *get_node_by_label(struct node *tree, const char *label) | |
243 | { | |
244 | struct node *child, *node; | |
245 | ||
246 | assert(label && (strlen(label) > 0)); | |
247 | ||
248 | if (tree->label && streq(tree->label, label)) | |
249 | return tree; | |
250 | ||
251 | for_each_child(tree, child) { | |
252 | node = get_node_by_label(child, label); | |
253 | if (node) | |
254 | return node; | |
255 | } | |
256 | ||
257 | return NULL; | |
258 | } | |
259 | ||
260 | struct node *get_node_by_phandle(struct node *tree, cell_t phandle) | |
261 | { | |
262 | struct node *child, *node; | |
263 | ||
264 | assert((phandle != 0) && (phandle != -1)); | |
265 | ||
266 | if (tree->phandle == phandle) | |
267 | return tree; | |
268 | ||
269 | for_each_child(tree, child) { | |
270 | node = get_node_by_phandle(child, phandle); | |
271 | if (node) | |
272 | return node; | |
273 | } | |
274 | ||
275 | return NULL; | |
276 | } | |
277 | ||
278 | struct node *get_node_by_ref(struct node *tree, const char *ref) | |
279 | { | |
280 | if (ref[0] == '/') | |
281 | return get_node_by_path(tree, ref); | |
282 | else | |
283 | return get_node_by_label(tree, ref); | |
284 | } | |
285 | ||
286 | cell_t get_node_phandle(struct node *root, struct node *node) | |
287 | { | |
288 | static cell_t phandle = 1; /* FIXME: ick, static local */ | |
289 | ||
290 | if ((node->phandle != 0) && (node->phandle != -1)) | |
291 | return node->phandle; | |
292 | ||
293 | assert(! get_property(node, "linux,phandle")); | |
294 | ||
295 | while (get_node_by_phandle(root, phandle)) | |
296 | phandle++; | |
297 | ||
298 | node->phandle = phandle; | |
299 | add_property(node, | |
300 | build_property("linux,phandle", | |
301 | data_append_cell(empty_data, phandle), | |
302 | NULL)); | |
303 | ||
304 | return node->phandle; | |
305 | } |