]>
Commit | Line | Data |
---|---|---|
35748177 GVB |
1 | /* |
2 | * libfdt - Flat Device Tree manipulation | |
3 | * Copyright (C) 2006 David Gibson, IBM Corporation. | |
4 | * | |
8d04f02f KG |
5 | * libfdt is dual licensed: you can use it either under the terms of |
6 | * the GPL, or the BSD license, at your option. | |
35748177 | 7 | * |
8d04f02f KG |
8 | * a) This library is free software; you can redistribute it and/or |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation; either version 2 of the | |
11 | * License, or (at your option) any later version. | |
35748177 | 12 | * |
8d04f02f KG |
13 | * This library is distributed in the hope that it will be useful, |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public | |
19 | * License along with this library; if not, write to the Free | |
20 | * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, | |
21 | * MA 02110-1301 USA | |
22 | * | |
23 | * Alternatively, | |
24 | * | |
25 | * b) Redistribution and use in source and binary forms, with or | |
26 | * without modification, are permitted provided that the following | |
27 | * conditions are met: | |
28 | * | |
29 | * 1. Redistributions of source code must retain the above | |
30 | * copyright notice, this list of conditions and the following | |
31 | * disclaimer. | |
32 | * 2. Redistributions in binary form must reproduce the above | |
33 | * copyright notice, this list of conditions and the following | |
34 | * disclaimer in the documentation and/or other materials | |
35 | * provided with the distribution. | |
36 | * | |
37 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND | |
38 | * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, | |
39 | * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
40 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
41 | * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | |
42 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
43 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
44 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
45 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
46 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
47 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
48 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, | |
49 | * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
35748177 GVB |
50 | */ |
51 | #include "libfdt_env.h" | |
52 | ||
8cf30809 | 53 | #ifndef USE_HOSTCC |
35748177 GVB |
54 | #include <fdt.h> |
55 | #include <libfdt.h> | |
8cf30809 BS |
56 | #else |
57 | #include "fdt_host.h" | |
58 | #endif | |
35748177 GVB |
59 | |
60 | #include "libfdt_internal.h" | |
61 | ||
fc7758ee DG |
62 | static int _fdt_nodename_eq(const void *fdt, int offset, |
63 | const char *s, int len) | |
35748177 | 64 | { |
ae0b5908 | 65 | const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1); |
35748177 GVB |
66 | |
67 | if (! p) | |
68 | /* short match */ | |
69 | return 0; | |
70 | ||
71 | if (memcmp(p, s, len) != 0) | |
72 | return 0; | |
73 | ||
8d04f02f KG |
74 | if (p[len] == '\0') |
75 | return 1; | |
76 | else if (!memchr(s, '@', len) && (p[len] == '@')) | |
77 | return 1; | |
78 | else | |
35748177 | 79 | return 0; |
35748177 GVB |
80 | } |
81 | ||
8d04f02f | 82 | const char *fdt_string(const void *fdt, int stroffset) |
9675ee72 | 83 | { |
c6683026 | 84 | return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset; |
8d04f02f | 85 | } |
9675ee72 | 86 | |
0219399a DG |
87 | static int _fdt_string_eq(const void *fdt, int stroffset, |
88 | const char *s, int len) | |
89 | { | |
90 | const char *p = fdt_string(fdt, stroffset); | |
91 | ||
92 | return (strlen(p) == len) && (memcmp(p, s, len) == 0); | |
93 | } | |
94 | ||
8d04f02f KG |
95 | int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size) |
96 | { | |
fc7758ee | 97 | FDT_CHECK_HEADER(fdt); |
8d04f02f KG |
98 | *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address); |
99 | *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size); | |
9675ee72 GVB |
100 | return 0; |
101 | } | |
102 | ||
8d04f02f | 103 | int fdt_num_mem_rsv(const void *fdt) |
35748177 | 104 | { |
8d04f02f KG |
105 | int i = 0; |
106 | ||
107 | while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0) | |
108 | i++; | |
109 | return i; | |
35748177 GVB |
110 | } |
111 | ||
ae0b5908 | 112 | int fdt_subnode_offset_namelen(const void *fdt, int offset, |
35748177 GVB |
113 | const char *name, int namelen) |
114 | { | |
ae0b5908 | 115 | int depth; |
35748177 | 116 | |
fc7758ee | 117 | FDT_CHECK_HEADER(fdt); |
35748177 | 118 | |
ae0b5908 DG |
119 | for (depth = 0; |
120 | offset >= 0; | |
121 | offset = fdt_next_node(fdt, offset, &depth)) { | |
122 | if (depth < 0) | |
123 | return -FDT_ERR_NOTFOUND; | |
124 | else if ((depth == 1) | |
fc7758ee | 125 | && _fdt_nodename_eq(fdt, offset, name, namelen)) |
ae0b5908 DG |
126 | return offset; |
127 | } | |
35748177 | 128 | |
ae0b5908 | 129 | return offset; /* error */ |
35748177 GVB |
130 | } |
131 | ||
132 | int fdt_subnode_offset(const void *fdt, int parentoffset, | |
133 | const char *name) | |
134 | { | |
135 | return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name)); | |
136 | } | |
137 | ||
8d04f02f | 138 | int fdt_path_offset(const void *fdt, const char *path) |
35748177 GVB |
139 | { |
140 | const char *end = path + strlen(path); | |
141 | const char *p = path; | |
142 | int offset = 0; | |
143 | ||
fc7758ee | 144 | FDT_CHECK_HEADER(fdt); |
35748177 | 145 | |
feeca3f5 KG |
146 | /* see if we have an alias */ |
147 | if (*path != '/') { | |
148 | const char *q; | |
149 | int aliasoffset = fdt_path_offset(fdt, "/aliases"); | |
150 | ||
151 | if (aliasoffset < 0) | |
152 | return -FDT_ERR_BADPATH; | |
153 | ||
154 | q = strchr(path, '/'); | |
155 | if (!q) | |
156 | q = end; | |
157 | ||
158 | p = fdt_getprop_namelen(fdt, aliasoffset, path, q - p, NULL); | |
159 | if (!p) | |
160 | return -FDT_ERR_BADPATH; | |
161 | offset = fdt_path_offset(fdt, p); | |
162 | ||
163 | p = q; | |
164 | } | |
35748177 GVB |
165 | |
166 | while (*p) { | |
167 | const char *q; | |
168 | ||
169 | while (*p == '/') | |
170 | p++; | |
171 | if (! *p) | |
8d04f02f | 172 | return offset; |
35748177 GVB |
173 | q = strchr(p, '/'); |
174 | if (! q) | |
175 | q = end; | |
176 | ||
177 | offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p); | |
178 | if (offset < 0) | |
179 | return offset; | |
180 | ||
181 | p = q; | |
182 | } | |
183 | ||
aea03c4e | 184 | return offset; |
35748177 GVB |
185 | } |
186 | ||
8d04f02f KG |
187 | const char *fdt_get_name(const void *fdt, int nodeoffset, int *len) |
188 | { | |
2f08bfa9 | 189 | const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset); |
8d04f02f KG |
190 | int err; |
191 | ||
2f08bfa9 DG |
192 | if (((err = fdt_check_header(fdt)) != 0) |
193 | || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0)) | |
194 | goto fail; | |
8d04f02f KG |
195 | |
196 | if (len) | |
197 | *len = strlen(nh->name); | |
198 | ||
199 | return nh->name; | |
200 | ||
201 | fail: | |
202 | if (len) | |
203 | *len = err; | |
204 | return NULL; | |
205 | } | |
206 | ||
0219399a DG |
207 | const struct fdt_property *fdt_get_property_namelen(const void *fdt, |
208 | int nodeoffset, | |
209 | const char *name, | |
210 | int namelen, int *lenp) | |
35748177 | 211 | { |
35748177 | 212 | uint32_t tag; |
8d04f02f KG |
213 | const struct fdt_property *prop; |
214 | int namestroff; | |
35748177 GVB |
215 | int offset, nextoffset; |
216 | int err; | |
217 | ||
2f08bfa9 DG |
218 | if (((err = fdt_check_header(fdt)) != 0) |
219 | || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0)) | |
220 | goto fail; | |
35748177 | 221 | |
2f08bfa9 | 222 | nextoffset = err; |
35748177 GVB |
223 | do { |
224 | offset = nextoffset; | |
225 | ||
8d04f02f | 226 | tag = fdt_next_tag(fdt, offset, &nextoffset); |
35748177 GVB |
227 | switch (tag) { |
228 | case FDT_END: | |
229 | err = -FDT_ERR_TRUNCATED; | |
230 | goto fail; | |
231 | ||
232 | case FDT_BEGIN_NODE: | |
35748177 | 233 | case FDT_END_NODE: |
8d04f02f | 234 | case FDT_NOP: |
35748177 GVB |
235 | break; |
236 | ||
237 | case FDT_PROP: | |
8d04f02f KG |
238 | err = -FDT_ERR_BADSTRUCTURE; |
239 | prop = fdt_offset_ptr(fdt, offset, sizeof(*prop)); | |
240 | if (! prop) | |
9675ee72 | 241 | goto fail; |
8d04f02f | 242 | namestroff = fdt32_to_cpu(prop->nameoff); |
0219399a | 243 | if (_fdt_string_eq(fdt, namestroff, name, namelen)) { |
8d04f02f KG |
244 | /* Found it! */ |
245 | int len = fdt32_to_cpu(prop->len); | |
246 | prop = fdt_offset_ptr(fdt, offset, | |
247 | sizeof(*prop)+len); | |
248 | if (! prop) | |
249 | goto fail; | |
250 | ||
251 | if (lenp) | |
252 | *lenp = len; | |
35748177 | 253 | |
8d04f02f KG |
254 | return prop; |
255 | } | |
35748177 GVB |
256 | break; |
257 | ||
258 | default: | |
259 | err = -FDT_ERR_BADSTRUCTURE; | |
260 | goto fail; | |
261 | } | |
8d04f02f | 262 | } while ((tag != FDT_BEGIN_NODE) && (tag != FDT_END_NODE)); |
35748177 GVB |
263 | |
264 | err = -FDT_ERR_NOTFOUND; | |
8d04f02f | 265 | fail: |
35748177 GVB |
266 | if (lenp) |
267 | *lenp = err; | |
268 | return NULL; | |
269 | } | |
270 | ||
0219399a DG |
271 | const struct fdt_property *fdt_get_property(const void *fdt, |
272 | int nodeoffset, | |
273 | const char *name, int *lenp) | |
274 | { | |
275 | return fdt_get_property_namelen(fdt, nodeoffset, name, | |
276 | strlen(name), lenp); | |
277 | } | |
278 | ||
279 | const void *fdt_getprop_namelen(const void *fdt, int nodeoffset, | |
280 | const char *name, int namelen, int *lenp) | |
35748177 GVB |
281 | { |
282 | const struct fdt_property *prop; | |
283 | ||
0219399a | 284 | prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp); |
35748177 GVB |
285 | if (! prop) |
286 | return NULL; | |
287 | ||
8d04f02f | 288 | return prop->data; |
3af0d587 GVB |
289 | } |
290 | ||
0219399a DG |
291 | const void *fdt_getprop(const void *fdt, int nodeoffset, |
292 | const char *name, int *lenp) | |
293 | { | |
294 | return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp); | |
295 | } | |
296 | ||
8d04f02f KG |
297 | uint32_t fdt_get_phandle(const void *fdt, int nodeoffset) |
298 | { | |
299 | const uint32_t *php; | |
300 | int len; | |
3af0d587 | 301 | |
8d04f02f KG |
302 | php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len); |
303 | if (!php || (len != sizeof(*php))) | |
304 | return 0; | |
305 | ||
306 | return fdt32_to_cpu(*php); | |
307 | } | |
308 | ||
309 | int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen) | |
3af0d587 | 310 | { |
ae0b5908 DG |
311 | int pdepth = 0, p = 0; |
312 | int offset, depth, namelen; | |
8d04f02f KG |
313 | const char *name; |
314 | ||
fc7758ee | 315 | FDT_CHECK_HEADER(fdt); |
8d04f02f | 316 | |
8d04f02f KG |
317 | if (buflen < 2) |
318 | return -FDT_ERR_NOSPACE; | |
8d04f02f | 319 | |
ae0b5908 DG |
320 | for (offset = 0, depth = 0; |
321 | (offset >= 0) && (offset <= nodeoffset); | |
322 | offset = fdt_next_node(fdt, offset, &depth)) { | |
323 | if (pdepth < depth) | |
324 | continue; /* overflowed buffer */ | |
8d04f02f | 325 | |
ae0b5908 DG |
326 | while (pdepth > depth) { |
327 | do { | |
328 | p--; | |
329 | } while (buf[p-1] != '/'); | |
330 | pdepth--; | |
331 | } | |
332 | ||
333 | name = fdt_get_name(fdt, offset, &namelen); | |
334 | if (!name) | |
335 | return namelen; | |
336 | if ((p + namelen + 1) <= buflen) { | |
8d04f02f KG |
337 | memcpy(buf + p, name, namelen); |
338 | p += namelen; | |
339 | buf[p++] = '/'; | |
ae0b5908 DG |
340 | pdepth++; |
341 | } | |
8d04f02f | 342 | |
ae0b5908 DG |
343 | if (offset == nodeoffset) { |
344 | if (pdepth < (depth + 1)) | |
345 | return -FDT_ERR_NOSPACE; | |
8d04f02f | 346 | |
ae0b5908 DG |
347 | if (p > 1) /* special case so that root path is "/", not "" */ |
348 | p--; | |
349 | buf[p] = '\0'; | |
350 | return p; | |
3af0d587 | 351 | } |
3af0d587 GVB |
352 | } |
353 | ||
ae0b5908 DG |
354 | if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0)) |
355 | return -FDT_ERR_BADOFFSET; | |
356 | else if (offset == -FDT_ERR_BADOFFSET) | |
357 | return -FDT_ERR_BADSTRUCTURE; | |
3af0d587 | 358 | |
ae0b5908 | 359 | return offset; /* error from fdt_next_node() */ |
35748177 | 360 | } |
3f9f08cf | 361 | |
8d04f02f KG |
362 | int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset, |
363 | int supernodedepth, int *nodedepth) | |
364 | { | |
ae0b5908 | 365 | int offset, depth; |
8d04f02f KG |
366 | int supernodeoffset = -FDT_ERR_INTERNAL; |
367 | ||
fc7758ee | 368 | FDT_CHECK_HEADER(fdt); |
8d04f02f KG |
369 | |
370 | if (supernodedepth < 0) | |
371 | return -FDT_ERR_NOTFOUND; | |
372 | ||
ae0b5908 DG |
373 | for (offset = 0, depth = 0; |
374 | (offset >= 0) && (offset <= nodeoffset); | |
375 | offset = fdt_next_node(fdt, offset, &depth)) { | |
376 | if (depth == supernodedepth) | |
377 | supernodeoffset = offset; | |
8d04f02f | 378 | |
ae0b5908 DG |
379 | if (offset == nodeoffset) { |
380 | if (nodedepth) | |
381 | *nodedepth = depth; | |
8d04f02f | 382 | |
ae0b5908 DG |
383 | if (supernodedepth > depth) |
384 | return -FDT_ERR_NOTFOUND; | |
385 | else | |
386 | return supernodeoffset; | |
8d04f02f | 387 | } |
ae0b5908 | 388 | } |
8d04f02f | 389 | |
ae0b5908 DG |
390 | if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0)) |
391 | return -FDT_ERR_BADOFFSET; | |
392 | else if (offset == -FDT_ERR_BADOFFSET) | |
393 | return -FDT_ERR_BADSTRUCTURE; | |
8d04f02f | 394 | |
ae0b5908 | 395 | return offset; /* error from fdt_next_node() */ |
8d04f02f KG |
396 | } |
397 | ||
398 | int fdt_node_depth(const void *fdt, int nodeoffset) | |
3f9f08cf | 399 | { |
8d04f02f KG |
400 | int nodedepth; |
401 | int err; | |
402 | ||
403 | err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth); | |
404 | if (err) | |
405 | return (err < 0) ? err : -FDT_ERR_INTERNAL; | |
406 | return nodedepth; | |
407 | } | |
408 | ||
409 | int fdt_parent_offset(const void *fdt, int nodeoffset) | |
410 | { | |
411 | int nodedepth = fdt_node_depth(fdt, nodeoffset); | |
412 | ||
413 | if (nodedepth < 0) | |
414 | return nodedepth; | |
415 | return fdt_supernode_atdepth_offset(fdt, nodeoffset, | |
416 | nodedepth - 1, NULL); | |
417 | } | |
418 | ||
419 | int fdt_node_offset_by_prop_value(const void *fdt, int startoffset, | |
420 | const char *propname, | |
421 | const void *propval, int proplen) | |
422 | { | |
ae0b5908 | 423 | int offset; |
8d04f02f KG |
424 | const void *val; |
425 | int len; | |
426 | ||
fc7758ee | 427 | FDT_CHECK_HEADER(fdt); |
8d04f02f | 428 | |
8d04f02f KG |
429 | /* FIXME: The algorithm here is pretty horrible: we scan each |
430 | * property of a node in fdt_getprop(), then if that didn't | |
431 | * find what we want, we scan over them again making our way | |
432 | * to the next node. Still it's the easiest to implement | |
433 | * approach; performance can come later. */ | |
ae0b5908 DG |
434 | for (offset = fdt_next_node(fdt, startoffset, NULL); |
435 | offset >= 0; | |
436 | offset = fdt_next_node(fdt, offset, NULL)) { | |
437 | val = fdt_getprop(fdt, offset, propname, &len); | |
438 | if (val && (len == proplen) | |
439 | && (memcmp(val, propval, len) == 0)) | |
440 | return offset; | |
441 | } | |
8d04f02f | 442 | |
ae0b5908 | 443 | return offset; /* error from fdt_next_node() */ |
8d04f02f KG |
444 | } |
445 | ||
446 | int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle) | |
447 | { | |
448 | if ((phandle == 0) || (phandle == -1)) | |
449 | return -FDT_ERR_BADPHANDLE; | |
450 | phandle = cpu_to_fdt32(phandle); | |
451 | return fdt_node_offset_by_prop_value(fdt, -1, "linux,phandle", | |
452 | &phandle, sizeof(phandle)); | |
453 | } | |
454 | ||
f171746f DG |
455 | static int _fdt_stringlist_contains(const char *strlist, int listlen, |
456 | const char *str) | |
8d04f02f KG |
457 | { |
458 | int len = strlen(str); | |
ef4e8ce1 | 459 | const char *p; |
8d04f02f KG |
460 | |
461 | while (listlen >= len) { | |
462 | if (memcmp(str, strlist, len+1) == 0) | |
463 | return 1; | |
464 | p = memchr(strlist, '\0', listlen); | |
465 | if (!p) | |
466 | return 0; /* malformed strlist.. */ | |
467 | listlen -= (p-strlist) + 1; | |
468 | strlist = p + 1; | |
3f9f08cf GVB |
469 | } |
470 | return 0; | |
471 | } | |
472 | ||
8d04f02f KG |
473 | int fdt_node_check_compatible(const void *fdt, int nodeoffset, |
474 | const char *compatible) | |
3f9f08cf | 475 | { |
8d04f02f KG |
476 | const void *prop; |
477 | int len; | |
3f9f08cf | 478 | |
8d04f02f KG |
479 | prop = fdt_getprop(fdt, nodeoffset, "compatible", &len); |
480 | if (!prop) | |
481 | return len; | |
f171746f | 482 | if (_fdt_stringlist_contains(prop, len, compatible)) |
8d04f02f KG |
483 | return 0; |
484 | else | |
485 | return 1; | |
486 | } | |
3f9f08cf | 487 | |
8d04f02f KG |
488 | int fdt_node_offset_by_compatible(const void *fdt, int startoffset, |
489 | const char *compatible) | |
490 | { | |
11abe45c | 491 | int offset, err; |
8d04f02f | 492 | |
fc7758ee | 493 | FDT_CHECK_HEADER(fdt); |
8d04f02f | 494 | |
8d04f02f KG |
495 | /* FIXME: The algorithm here is pretty horrible: we scan each |
496 | * property of a node in fdt_node_check_compatible(), then if | |
497 | * that didn't find what we want, we scan over them again | |
498 | * making our way to the next node. Still it's the easiest to | |
499 | * implement approach; performance can come later. */ | |
ae0b5908 DG |
500 | for (offset = fdt_next_node(fdt, startoffset, NULL); |
501 | offset >= 0; | |
502 | offset = fdt_next_node(fdt, offset, NULL)) { | |
503 | err = fdt_node_check_compatible(fdt, offset, compatible); | |
504 | if ((err < 0) && (err != -FDT_ERR_NOTFOUND)) | |
505 | return err; | |
506 | else if (err == 0) | |
507 | return offset; | |
508 | } | |
8d04f02f | 509 | |
ae0b5908 | 510 | return offset; /* error from fdt_next_node() */ |
3f9f08cf | 511 | } |