2 * libfdt - Flat Device Tree manipulation
3 * Copyright (C) 2006 David Gibson, IBM Corporation.
5 * libfdt is dual licensed: you can use it either under the terms of
6 * the GPL, or the BSD license, at your option.
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.
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.
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,
25 * b) Redistribution and use in source and binary forms, with or
26 * without modification, are permitted provided that the following
29 * 1. Redistributions of source code must retain the above
30 * copyright notice, this list of conditions and the following
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.
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.
51 #include "libfdt_env.h"
60 #include "libfdt_internal.h"
62 static int nodename_eq(const void *fdt
, int offset
,
63 const char *s
, int len
)
65 const char *p
= fdt_offset_ptr(fdt
, offset
+ FDT_TAGSIZE
, len
+1);
71 if (memcmp(p
, s
, len
) != 0)
76 else if (!memchr(s
, '@', len
) && (p
[len
] == '@'))
82 const char *fdt_string(const void *fdt
, int stroffset
)
84 return (char *)fdt
+ fdt_off_dt_strings(fdt
) + stroffset
;
87 int fdt_get_mem_rsv(const void *fdt
, int n
, uint64_t *address
, uint64_t *size
)
90 *address
= fdt64_to_cpu(_fdt_mem_rsv(fdt
, n
)->address
);
91 *size
= fdt64_to_cpu(_fdt_mem_rsv(fdt
, n
)->size
);
95 int fdt_num_mem_rsv(const void *fdt
)
99 while (fdt64_to_cpu(_fdt_mem_rsv(fdt
, i
)->size
) != 0)
104 int fdt_subnode_offset_namelen(const void *fdt
, int offset
,
105 const char *name
, int namelen
)
113 offset
= fdt_next_node(fdt
, offset
, &depth
)) {
115 return -FDT_ERR_NOTFOUND
;
116 else if ((depth
== 1)
117 && nodename_eq(fdt
, offset
, name
, namelen
))
121 return offset
; /* error */
124 int fdt_subnode_offset(const void *fdt
, int parentoffset
,
127 return fdt_subnode_offset_namelen(fdt
, parentoffset
, name
, strlen(name
));
130 int fdt_path_offset(const void *fdt
, const char *path
)
132 const char *end
= path
+ strlen(path
);
133 const char *p
= path
;
139 return -FDT_ERR_BADPATH
;
152 offset
= fdt_subnode_offset_namelen(fdt
, offset
, p
, q
-p
);
162 const char *fdt_get_name(const void *fdt
, int nodeoffset
, int *len
)
164 const struct fdt_node_header
*nh
;
167 if ((err
= fdt_check_header(fdt
)) != 0)
170 err
= -FDT_ERR_BADOFFSET
;
171 nh
= fdt_offset_ptr(fdt
, nodeoffset
, sizeof(*nh
));
172 if (!nh
|| (fdt32_to_cpu(nh
->tag
) != FDT_BEGIN_NODE
))
176 *len
= strlen(nh
->name
);
186 const struct fdt_property
*fdt_get_property(const void *fdt
,
188 const char *name
, int *lenp
)
191 const struct fdt_property
*prop
;
193 int offset
, nextoffset
;
196 if ((err
= fdt_check_header(fdt
)) != 0)
199 err
= -FDT_ERR_BADOFFSET
;
200 if (nodeoffset
% FDT_TAGSIZE
)
203 tag
= fdt_next_tag(fdt
, nodeoffset
, &nextoffset
);
204 if (tag
!= FDT_BEGIN_NODE
)
210 tag
= fdt_next_tag(fdt
, offset
, &nextoffset
);
213 err
= -FDT_ERR_TRUNCATED
;
222 err
= -FDT_ERR_BADSTRUCTURE
;
223 prop
= fdt_offset_ptr(fdt
, offset
, sizeof(*prop
));
226 namestroff
= fdt32_to_cpu(prop
->nameoff
);
227 if (streq(fdt_string(fdt
, namestroff
), name
)) {
229 int len
= fdt32_to_cpu(prop
->len
);
230 prop
= fdt_offset_ptr(fdt
, offset
,
243 err
= -FDT_ERR_BADSTRUCTURE
;
246 } while ((tag
!= FDT_BEGIN_NODE
) && (tag
!= FDT_END_NODE
));
248 err
= -FDT_ERR_NOTFOUND
;
255 const void *fdt_getprop(const void *fdt
, int nodeoffset
,
256 const char *name
, int *lenp
)
258 const struct fdt_property
*prop
;
260 prop
= fdt_get_property(fdt
, nodeoffset
, name
, lenp
);
267 uint32_t fdt_get_phandle(const void *fdt
, int nodeoffset
)
272 php
= fdt_getprop(fdt
, nodeoffset
, "linux,phandle", &len
);
273 if (!php
|| (len
!= sizeof(*php
)))
276 return fdt32_to_cpu(*php
);
279 int fdt_get_path(const void *fdt
, int nodeoffset
, char *buf
, int buflen
)
281 int pdepth
= 0, p
= 0;
282 int offset
, depth
, namelen
;
288 return -FDT_ERR_NOSPACE
;
290 for (offset
= 0, depth
= 0;
291 (offset
>= 0) && (offset
<= nodeoffset
);
292 offset
= fdt_next_node(fdt
, offset
, &depth
)) {
294 continue; /* overflowed buffer */
296 while (pdepth
> depth
) {
299 } while (buf
[p
-1] != '/');
303 name
= fdt_get_name(fdt
, offset
, &namelen
);
306 if ((p
+ namelen
+ 1) <= buflen
) {
307 memcpy(buf
+ p
, name
, namelen
);
313 if (offset
== nodeoffset
) {
314 if (pdepth
< (depth
+ 1))
315 return -FDT_ERR_NOSPACE
;
317 if (p
> 1) /* special case so that root path is "/", not "" */
324 if ((offset
== -FDT_ERR_NOTFOUND
) || (offset
>= 0))
325 return -FDT_ERR_BADOFFSET
;
326 else if (offset
== -FDT_ERR_BADOFFSET
)
327 return -FDT_ERR_BADSTRUCTURE
;
329 return offset
; /* error from fdt_next_node() */
332 int fdt_supernode_atdepth_offset(const void *fdt
, int nodeoffset
,
333 int supernodedepth
, int *nodedepth
)
336 int supernodeoffset
= -FDT_ERR_INTERNAL
;
340 if (supernodedepth
< 0)
341 return -FDT_ERR_NOTFOUND
;
343 for (offset
= 0, depth
= 0;
344 (offset
>= 0) && (offset
<= nodeoffset
);
345 offset
= fdt_next_node(fdt
, offset
, &depth
)) {
346 if (depth
== supernodedepth
)
347 supernodeoffset
= offset
;
349 if (offset
== nodeoffset
) {
353 if (supernodedepth
> depth
)
354 return -FDT_ERR_NOTFOUND
;
356 return supernodeoffset
;
360 if ((offset
== -FDT_ERR_NOTFOUND
) || (offset
>= 0))
361 return -FDT_ERR_BADOFFSET
;
362 else if (offset
== -FDT_ERR_BADOFFSET
)
363 return -FDT_ERR_BADSTRUCTURE
;
365 return offset
; /* error from fdt_next_node() */
368 int fdt_node_depth(const void *fdt
, int nodeoffset
)
373 err
= fdt_supernode_atdepth_offset(fdt
, nodeoffset
, 0, &nodedepth
);
375 return (err
< 0) ? err
: -FDT_ERR_INTERNAL
;
379 int fdt_parent_offset(const void *fdt
, int nodeoffset
)
381 int nodedepth
= fdt_node_depth(fdt
, nodeoffset
);
385 return fdt_supernode_atdepth_offset(fdt
, nodeoffset
,
386 nodedepth
- 1, NULL
);
389 int fdt_node_offset_by_prop_value(const void *fdt
, int startoffset
,
390 const char *propname
,
391 const void *propval
, int proplen
)
399 /* FIXME: The algorithm here is pretty horrible: we scan each
400 * property of a node in fdt_getprop(), then if that didn't
401 * find what we want, we scan over them again making our way
402 * to the next node. Still it's the easiest to implement
403 * approach; performance can come later. */
404 for (offset
= fdt_next_node(fdt
, startoffset
, NULL
);
406 offset
= fdt_next_node(fdt
, offset
, NULL
)) {
407 val
= fdt_getprop(fdt
, offset
, propname
, &len
);
408 if (val
&& (len
== proplen
)
409 && (memcmp(val
, propval
, len
) == 0))
413 return offset
; /* error from fdt_next_node() */
416 int fdt_node_offset_by_phandle(const void *fdt
, uint32_t phandle
)
418 if ((phandle
== 0) || (phandle
== -1))
419 return -FDT_ERR_BADPHANDLE
;
420 phandle
= cpu_to_fdt32(phandle
);
421 return fdt_node_offset_by_prop_value(fdt
, -1, "linux,phandle",
422 &phandle
, sizeof(phandle
));
425 int _stringlist_contains(const void *strlist
, int listlen
, const char *str
)
427 int len
= strlen(str
);
430 while (listlen
>= len
) {
431 if (memcmp(str
, strlist
, len
+1) == 0)
433 p
= memchr(strlist
, '\0', listlen
);
435 return 0; /* malformed strlist.. */
436 listlen
-= (p
-strlist
) + 1;
442 int fdt_node_check_compatible(const void *fdt
, int nodeoffset
,
443 const char *compatible
)
448 prop
= fdt_getprop(fdt
, nodeoffset
, "compatible", &len
);
451 if (_stringlist_contains(prop
, len
, compatible
))
457 int fdt_node_offset_by_compatible(const void *fdt
, int startoffset
,
458 const char *compatible
)
464 /* FIXME: The algorithm here is pretty horrible: we scan each
465 * property of a node in fdt_node_check_compatible(), then if
466 * that didn't find what we want, we scan over them again
467 * making our way to the next node. Still it's the easiest to
468 * implement approach; performance can come later. */
469 for (offset
= fdt_next_node(fdt
, startoffset
, NULL
);
471 offset
= fdt_next_node(fdt
, offset
, NULL
)) {
472 err
= fdt_node_check_compatible(fdt
, offset
, compatible
);
473 if ((err
< 0) && (err
!= -FDT_ERR_NOTFOUND
))
479 return offset
; /* error from fdt_next_node() */