|
1 /* |
|
2 * libfdt - Flat Device Tree manipulation |
|
3 * Copyright (C) 2006 David Gibson, IBM Corporation. |
|
4 * |
|
5 * libfdt is dual licensed: you can use it either under the terms of |
|
6 * the GPL, or the BSD license, at your option. |
|
7 * |
|
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. |
|
12 * |
|
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. |
|
50 */ |
|
51 #include "libfdt_env.h" |
|
52 |
|
53 #include <fdt.h> |
|
54 #include <libfdt.h> |
|
55 |
|
56 #include "libfdt_internal.h" |
|
57 |
|
58 #define CHECK_HEADER(fdt) \ |
|
59 { \ |
|
60 int err; \ |
|
61 if ((err = fdt_check_header(fdt)) != 0) \ |
|
62 return err; \ |
|
63 } |
|
64 |
|
65 static int nodename_eq(const void *fdt, int offset, |
|
66 const char *s, int len) |
|
67 { |
|
68 const char *p = fdt_offset_ptr(fdt, offset, len+1); |
|
69 |
|
70 if (! p) |
|
71 /* short match */ |
|
72 return 0; |
|
73 |
|
74 if (memcmp(p, s, len) != 0) |
|
75 return 0; |
|
76 |
|
77 if (p[len] == '\0') |
|
78 return 1; |
|
79 else if (!memchr(s, '@', len) && (p[len] == '@')) |
|
80 return 1; |
|
81 else |
|
82 return 0; |
|
83 } |
|
84 |
|
85 const char *fdt_string(const void *fdt, int stroffset) |
|
86 { |
|
87 return (char *)fdt + fdt_off_dt_strings(fdt) + stroffset; |
|
88 } |
|
89 |
|
90 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size) |
|
91 { |
|
92 CHECK_HEADER(fdt); |
|
93 *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address); |
|
94 *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size); |
|
95 return 0; |
|
96 } |
|
97 |
|
98 int fdt_num_mem_rsv(const void *fdt) |
|
99 { |
|
100 int i = 0; |
|
101 |
|
102 while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0) |
|
103 i++; |
|
104 return i; |
|
105 } |
|
106 |
|
107 int fdt_subnode_offset_namelen(const void *fdt, int parentoffset, |
|
108 const char *name, int namelen) |
|
109 { |
|
110 int level = 0; |
|
111 uint32_t tag; |
|
112 int offset, nextoffset; |
|
113 |
|
114 CHECK_HEADER(fdt); |
|
115 |
|
116 tag = fdt_next_tag(fdt, parentoffset, &nextoffset); |
|
117 if (tag != FDT_BEGIN_NODE) |
|
118 return -FDT_ERR_BADOFFSET; |
|
119 |
|
120 do { |
|
121 offset = nextoffset; |
|
122 tag = fdt_next_tag(fdt, offset, &nextoffset); |
|
123 |
|
124 switch (tag) { |
|
125 case FDT_END: |
|
126 return -FDT_ERR_TRUNCATED; |
|
127 |
|
128 case FDT_BEGIN_NODE: |
|
129 level++; |
|
130 if (level != 1) |
|
131 continue; |
|
132 if (nodename_eq(fdt, offset+FDT_TAGSIZE, name, namelen)) |
|
133 /* Found it! */ |
|
134 return offset; |
|
135 break; |
|
136 |
|
137 case FDT_END_NODE: |
|
138 level--; |
|
139 break; |
|
140 |
|
141 case FDT_PROP: |
|
142 case FDT_NOP: |
|
143 break; |
|
144 |
|
145 default: |
|
146 return -FDT_ERR_BADSTRUCTURE; |
|
147 } |
|
148 } while (level >= 0); |
|
149 |
|
150 return -FDT_ERR_NOTFOUND; |
|
151 } |
|
152 |
|
153 int fdt_subnode_offset(const void *fdt, int parentoffset, |
|
154 const char *name) |
|
155 { |
|
156 return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name)); |
|
157 } |
|
158 |
|
159 int fdt_path_offset(const void *fdt, const char *path) |
|
160 { |
|
161 const char *end = path + strlen(path); |
|
162 const char *p = path; |
|
163 int offset = 0; |
|
164 |
|
165 CHECK_HEADER(fdt); |
|
166 |
|
167 if (*path != '/') |
|
168 return -FDT_ERR_BADPATH; |
|
169 |
|
170 while (*p) { |
|
171 const char *q; |
|
172 |
|
173 while (*p == '/') |
|
174 p++; |
|
175 if (! *p) |
|
176 return offset; |
|
177 q = strchr(p, '/'); |
|
178 if (! q) |
|
179 q = end; |
|
180 |
|
181 offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p); |
|
182 if (offset < 0) |
|
183 return offset; |
|
184 |
|
185 p = q; |
|
186 } |
|
187 |
|
188 return offset; |
|
189 } |
|
190 |
|
191 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len) |
|
192 { |
|
193 const struct fdt_node_header *nh; |
|
194 int err; |
|
195 |
|
196 if ((err = fdt_check_header(fdt)) != 0) |
|
197 goto fail; |
|
198 |
|
199 err = -FDT_ERR_BADOFFSET; |
|
200 nh = fdt_offset_ptr(fdt, nodeoffset, sizeof(*nh)); |
|
201 if (!nh || (fdt32_to_cpu(nh->tag) != FDT_BEGIN_NODE)) |
|
202 goto fail; |
|
203 |
|
204 if (len) |
|
205 *len = strlen(nh->name); |
|
206 |
|
207 return nh->name; |
|
208 |
|
209 fail: |
|
210 if (len) |
|
211 *len = err; |
|
212 return NULL; |
|
213 } |
|
214 |
|
215 const struct fdt_property *fdt_get_property(const void *fdt, |
|
216 int nodeoffset, |
|
217 const char *name, int *lenp) |
|
218 { |
|
219 uint32_t tag; |
|
220 const struct fdt_property *prop; |
|
221 int namestroff; |
|
222 int offset, nextoffset; |
|
223 int err; |
|
224 |
|
225 if ((err = fdt_check_header(fdt)) != 0) |
|
226 goto fail; |
|
227 |
|
228 err = -FDT_ERR_BADOFFSET; |
|
229 if (nodeoffset % FDT_TAGSIZE) |
|
230 goto fail; |
|
231 |
|
232 tag = fdt_next_tag(fdt, nodeoffset, &nextoffset); |
|
233 if (tag != FDT_BEGIN_NODE) |
|
234 goto fail; |
|
235 |
|
236 do { |
|
237 offset = nextoffset; |
|
238 |
|
239 tag = fdt_next_tag(fdt, offset, &nextoffset); |
|
240 switch (tag) { |
|
241 case FDT_END: |
|
242 err = -FDT_ERR_TRUNCATED; |
|
243 goto fail; |
|
244 |
|
245 case FDT_BEGIN_NODE: |
|
246 case FDT_END_NODE: |
|
247 case FDT_NOP: |
|
248 break; |
|
249 |
|
250 case FDT_PROP: |
|
251 err = -FDT_ERR_BADSTRUCTURE; |
|
252 prop = fdt_offset_ptr(fdt, offset, sizeof(*prop)); |
|
253 if (! prop) |
|
254 goto fail; |
|
255 namestroff = fdt32_to_cpu(prop->nameoff); |
|
256 if (streq(fdt_string(fdt, namestroff), name)) { |
|
257 /* Found it! */ |
|
258 int len = fdt32_to_cpu(prop->len); |
|
259 prop = fdt_offset_ptr(fdt, offset, |
|
260 sizeof(*prop)+len); |
|
261 if (! prop) |
|
262 goto fail; |
|
263 |
|
264 if (lenp) |
|
265 *lenp = len; |
|
266 |
|
267 return prop; |
|
268 } |
|
269 break; |
|
270 |
|
271 default: |
|
272 err = -FDT_ERR_BADSTRUCTURE; |
|
273 goto fail; |
|
274 } |
|
275 } while ((tag != FDT_BEGIN_NODE) && (tag != FDT_END_NODE)); |
|
276 |
|
277 err = -FDT_ERR_NOTFOUND; |
|
278 fail: |
|
279 if (lenp) |
|
280 *lenp = err; |
|
281 return NULL; |
|
282 } |
|
283 |
|
284 const void *fdt_getprop(const void *fdt, int nodeoffset, |
|
285 const char *name, int *lenp) |
|
286 { |
|
287 const struct fdt_property *prop; |
|
288 |
|
289 prop = fdt_get_property(fdt, nodeoffset, name, lenp); |
|
290 if (! prop) |
|
291 return NULL; |
|
292 |
|
293 return prop->data; |
|
294 } |
|
295 |
|
296 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset) |
|
297 { |
|
298 const uint32_t *php; |
|
299 int len; |
|
300 |
|
301 php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len); |
|
302 if (!php || (len != sizeof(*php))) |
|
303 return 0; |
|
304 |
|
305 return fdt32_to_cpu(*php); |
|
306 } |
|
307 |
|
308 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen) |
|
309 { |
|
310 uint32_t tag; |
|
311 int p = 0, overflow = 0; |
|
312 int offset, nextoffset, namelen; |
|
313 const char *name; |
|
314 |
|
315 CHECK_HEADER(fdt); |
|
316 |
|
317 tag = fdt_next_tag(fdt, 0, &nextoffset); |
|
318 if (tag != FDT_BEGIN_NODE) |
|
319 return -FDT_ERR_BADSTRUCTURE; |
|
320 |
|
321 if (buflen < 2) |
|
322 return -FDT_ERR_NOSPACE; |
|
323 buf[0] = '/'; |
|
324 p = 1; |
|
325 |
|
326 while (nextoffset <= nodeoffset) { |
|
327 offset = nextoffset; |
|
328 tag = fdt_next_tag(fdt, offset, &nextoffset); |
|
329 switch (tag) { |
|
330 case FDT_END: |
|
331 return -FDT_ERR_BADOFFSET; |
|
332 |
|
333 case FDT_BEGIN_NODE: |
|
334 name = fdt_get_name(fdt, offset, &namelen); |
|
335 if (!name) |
|
336 return namelen; |
|
337 if (overflow || ((p + namelen + 1) > buflen)) { |
|
338 overflow++; |
|
339 break; |
|
340 } |
|
341 memcpy(buf + p, name, namelen); |
|
342 p += namelen; |
|
343 buf[p++] = '/'; |
|
344 break; |
|
345 |
|
346 case FDT_END_NODE: |
|
347 if (overflow) { |
|
348 overflow--; |
|
349 break; |
|
350 } |
|
351 do { |
|
352 p--; |
|
353 } while (buf[p-1] != '/'); |
|
354 break; |
|
355 |
|
356 case FDT_PROP: |
|
357 case FDT_NOP: |
|
358 break; |
|
359 |
|
360 default: |
|
361 return -FDT_ERR_BADSTRUCTURE; |
|
362 } |
|
363 } |
|
364 |
|
365 if (overflow) |
|
366 return -FDT_ERR_NOSPACE; |
|
367 |
|
368 if (p > 1) /* special case so that root path is "/", not "" */ |
|
369 p--; |
|
370 buf[p] = '\0'; |
|
371 return p; |
|
372 } |
|
373 |
|
374 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset, |
|
375 int supernodedepth, int *nodedepth) |
|
376 { |
|
377 int level = -1; |
|
378 uint32_t tag; |
|
379 int offset, nextoffset = 0; |
|
380 int supernodeoffset = -FDT_ERR_INTERNAL; |
|
381 |
|
382 CHECK_HEADER(fdt); |
|
383 |
|
384 if (supernodedepth < 0) |
|
385 return -FDT_ERR_NOTFOUND; |
|
386 |
|
387 do { |
|
388 offset = nextoffset; |
|
389 tag = fdt_next_tag(fdt, offset, &nextoffset); |
|
390 switch (tag) { |
|
391 case FDT_END: |
|
392 return -FDT_ERR_BADOFFSET; |
|
393 |
|
394 case FDT_BEGIN_NODE: |
|
395 level++; |
|
396 if (level == supernodedepth) |
|
397 supernodeoffset = offset; |
|
398 break; |
|
399 |
|
400 case FDT_END_NODE: |
|
401 level--; |
|
402 break; |
|
403 |
|
404 case FDT_PROP: |
|
405 case FDT_NOP: |
|
406 break; |
|
407 |
|
408 default: |
|
409 return -FDT_ERR_BADSTRUCTURE; |
|
410 } |
|
411 } while (offset < nodeoffset); |
|
412 |
|
413 if (nodedepth) |
|
414 *nodedepth = level; |
|
415 |
|
416 if (supernodedepth > level) |
|
417 return -FDT_ERR_NOTFOUND; |
|
418 return supernodeoffset; |
|
419 } |
|
420 |
|
421 int fdt_node_depth(const void *fdt, int nodeoffset) |
|
422 { |
|
423 int nodedepth; |
|
424 int err; |
|
425 |
|
426 err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth); |
|
427 if (err) |
|
428 return (err < 0) ? err : -FDT_ERR_INTERNAL; |
|
429 return nodedepth; |
|
430 } |
|
431 |
|
432 int fdt_parent_offset(const void *fdt, int nodeoffset) |
|
433 { |
|
434 int nodedepth = fdt_node_depth(fdt, nodeoffset); |
|
435 |
|
436 if (nodedepth < 0) |
|
437 return nodedepth; |
|
438 return fdt_supernode_atdepth_offset(fdt, nodeoffset, |
|
439 nodedepth - 1, NULL); |
|
440 } |
|
441 |
|
442 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset, |
|
443 const char *propname, |
|
444 const void *propval, int proplen) |
|
445 { |
|
446 uint32_t tag; |
|
447 int offset, nextoffset; |
|
448 const void *val; |
|
449 int len; |
|
450 |
|
451 CHECK_HEADER(fdt); |
|
452 |
|
453 if (startoffset >= 0) { |
|
454 tag = fdt_next_tag(fdt, startoffset, &nextoffset); |
|
455 if (tag != FDT_BEGIN_NODE) |
|
456 return -FDT_ERR_BADOFFSET; |
|
457 } else { |
|
458 nextoffset = 0; |
|
459 } |
|
460 |
|
461 /* FIXME: The algorithm here is pretty horrible: we scan each |
|
462 * property of a node in fdt_getprop(), then if that didn't |
|
463 * find what we want, we scan over them again making our way |
|
464 * to the next node. Still it's the easiest to implement |
|
465 * approach; performance can come later. */ |
|
466 do { |
|
467 offset = nextoffset; |
|
468 tag = fdt_next_tag(fdt, offset, &nextoffset); |
|
469 |
|
470 switch (tag) { |
|
471 case FDT_BEGIN_NODE: |
|
472 val = fdt_getprop(fdt, offset, propname, &len); |
|
473 if (val |
|
474 && (len == proplen) |
|
475 && (memcmp(val, propval, len) == 0)) |
|
476 return offset; |
|
477 break; |
|
478 |
|
479 case FDT_PROP: |
|
480 case FDT_END: |
|
481 case FDT_END_NODE: |
|
482 case FDT_NOP: |
|
483 break; |
|
484 |
|
485 default: |
|
486 return -FDT_ERR_BADSTRUCTURE; |
|
487 } |
|
488 } while (tag != FDT_END); |
|
489 |
|
490 return -FDT_ERR_NOTFOUND; |
|
491 } |
|
492 |
|
493 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle) |
|
494 { |
|
495 if ((phandle == 0) || (phandle == -1)) |
|
496 return -FDT_ERR_BADPHANDLE; |
|
497 phandle = cpu_to_fdt32(phandle); |
|
498 return fdt_node_offset_by_prop_value(fdt, -1, "linux,phandle", |
|
499 &phandle, sizeof(phandle)); |
|
500 } |
|
501 |
|
502 int _stringlist_contains(const void *strlist, int listlen, const char *str) |
|
503 { |
|
504 int len = strlen(str); |
|
505 const void *p; |
|
506 |
|
507 while (listlen >= len) { |
|
508 if (memcmp(str, strlist, len+1) == 0) |
|
509 return 1; |
|
510 p = memchr(strlist, '\0', listlen); |
|
511 if (!p) |
|
512 return 0; /* malformed strlist.. */ |
|
513 listlen -= (p-strlist) + 1; |
|
514 strlist = p + 1; |
|
515 } |
|
516 return 0; |
|
517 } |
|
518 |
|
519 int fdt_node_check_compatible(const void *fdt, int nodeoffset, |
|
520 const char *compatible) |
|
521 { |
|
522 const void *prop; |
|
523 int len; |
|
524 |
|
525 prop = fdt_getprop(fdt, nodeoffset, "compatible", &len); |
|
526 if (!prop) |
|
527 return len; |
|
528 if (_stringlist_contains(prop, len, compatible)) |
|
529 return 0; |
|
530 else |
|
531 return 1; |
|
532 } |
|
533 |
|
534 int fdt_node_offset_by_compatible(const void *fdt, int startoffset, |
|
535 const char *compatible) |
|
536 { |
|
537 uint32_t tag; |
|
538 int offset, nextoffset; |
|
539 int err; |
|
540 |
|
541 CHECK_HEADER(fdt); |
|
542 |
|
543 if (startoffset >= 0) { |
|
544 tag = fdt_next_tag(fdt, startoffset, &nextoffset); |
|
545 if (tag != FDT_BEGIN_NODE) |
|
546 return -FDT_ERR_BADOFFSET; |
|
547 } else { |
|
548 nextoffset = 0; |
|
549 } |
|
550 |
|
551 /* FIXME: The algorithm here is pretty horrible: we scan each |
|
552 * property of a node in fdt_node_check_compatible(), then if |
|
553 * that didn't find what we want, we scan over them again |
|
554 * making our way to the next node. Still it's the easiest to |
|
555 * implement approach; performance can come later. */ |
|
556 do { |
|
557 offset = nextoffset; |
|
558 tag = fdt_next_tag(fdt, offset, &nextoffset); |
|
559 |
|
560 switch (tag) { |
|
561 case FDT_BEGIN_NODE: |
|
562 err = fdt_node_check_compatible(fdt, offset, |
|
563 compatible); |
|
564 if ((err < 0) |
|
565 && (err != -FDT_ERR_NOTFOUND)) |
|
566 return err; |
|
567 else if (err == 0) |
|
568 return offset; |
|
569 break; |
|
570 |
|
571 case FDT_PROP: |
|
572 case FDT_END: |
|
573 case FDT_END_NODE: |
|
574 case FDT_NOP: |
|
575 break; |
|
576 |
|
577 default: |
|
578 return -FDT_ERR_BADSTRUCTURE; |
|
579 } |
|
580 } while (tag != FDT_END); |
|
581 |
|
582 return -FDT_ERR_NOTFOUND; |
|
583 } |