]>
git.ipfire.org Git - people/ms/u-boot.git/blob - libfdt/fdt_ro.c
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 _fdt_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 (const char *)fdt
+ fdt_off_dt_strings(fdt
) + stroffset
;
87 static int _fdt_string_eq(const void *fdt
, int stroffset
,
88 const char *s
, int len
)
90 const char *p
= fdt_string(fdt
, stroffset
);
92 return (strlen(p
) == len
) && (memcmp(p
, s
, len
) == 0);
95 int fdt_get_mem_rsv(const void *fdt
, int n
, uint64_t *address
, uint64_t *size
)
97 FDT_CHECK_HEADER(fdt
);
98 *address
= fdt64_to_cpu(_fdt_mem_rsv(fdt
, n
)->address
);
99 *size
= fdt64_to_cpu(_fdt_mem_rsv(fdt
, n
)->size
);
103 int fdt_num_mem_rsv(const void *fdt
)
107 while (fdt64_to_cpu(_fdt_mem_rsv(fdt
, i
)->size
) != 0)
112 int fdt_subnode_offset_namelen(const void *fdt
, int offset
,
113 const char *name
, int namelen
)
117 FDT_CHECK_HEADER(fdt
);
120 (offset
>= 0) && (depth
>= 0);
121 offset
= fdt_next_node(fdt
, offset
, &depth
))
123 && _fdt_nodename_eq(fdt
, offset
, name
, namelen
))
127 return -FDT_ERR_NOTFOUND
;
128 return offset
; /* error */
131 int fdt_subnode_offset(const void *fdt
, int parentoffset
,
134 return fdt_subnode_offset_namelen(fdt
, parentoffset
, name
, strlen(name
));
137 int fdt_path_offset(const void *fdt
, const char *path
)
139 const char *end
= path
+ strlen(path
);
140 const char *p
= path
;
143 FDT_CHECK_HEADER(fdt
);
145 /* see if we have an alias */
147 const char *q
= strchr(path
, '/');
152 p
= fdt_get_alias_namelen(fdt
, p
, q
- p
);
154 return -FDT_ERR_BADPATH
;
155 offset
= fdt_path_offset(fdt
, p
);
171 offset
= fdt_subnode_offset_namelen(fdt
, offset
, p
, q
-p
);
181 const char *fdt_get_name(const void *fdt
, int nodeoffset
, int *len
)
183 const struct fdt_node_header
*nh
= _fdt_offset_ptr(fdt
, nodeoffset
);
186 if (((err
= fdt_check_header(fdt
)) != 0)
187 || ((err
= _fdt_check_node_offset(fdt
, nodeoffset
)) < 0))
191 *len
= strlen(nh
->name
);
201 const struct fdt_property
*fdt_get_property_namelen(const void *fdt
,
204 int namelen
, int *lenp
)
207 const struct fdt_property
*prop
;
208 int offset
, nextoffset
;
211 if (((err
= fdt_check_header(fdt
)) != 0)
212 || ((err
= _fdt_check_node_offset(fdt
, nodeoffset
)) < 0))
219 tag
= fdt_next_tag(fdt
, offset
, &nextoffset
);
225 /* FDT_END tag with unclosed nodes */
226 err
= -FDT_ERR_BADSTRUCTURE
;
230 prop
= _fdt_offset_ptr(fdt
, offset
);
231 if (_fdt_string_eq(fdt
, fdt32_to_cpu(prop
->nameoff
),
235 *lenp
= fdt32_to_cpu(prop
->len
);
241 } while ((tag
!= FDT_BEGIN_NODE
) && (tag
!= FDT_END_NODE
));
243 err
= -FDT_ERR_NOTFOUND
;
250 const struct fdt_property
*fdt_get_property(const void *fdt
,
252 const char *name
, int *lenp
)
254 return fdt_get_property_namelen(fdt
, nodeoffset
, name
,
258 const void *fdt_getprop_namelen(const void *fdt
, int nodeoffset
,
259 const char *name
, int namelen
, int *lenp
)
261 const struct fdt_property
*prop
;
263 prop
= fdt_get_property_namelen(fdt
, nodeoffset
, name
, namelen
, lenp
);
270 const void *fdt_getprop(const void *fdt
, int nodeoffset
,
271 const char *name
, int *lenp
)
273 return fdt_getprop_namelen(fdt
, nodeoffset
, name
, strlen(name
), lenp
);
276 uint32_t fdt_get_phandle(const void *fdt
, int nodeoffset
)
281 php
= fdt_getprop(fdt
, nodeoffset
, "linux,phandle", &len
);
282 if (!php
|| (len
!= sizeof(*php
)))
285 return fdt32_to_cpu(*php
);
288 const char *fdt_get_alias_namelen(const void *fdt
,
289 const char *name
, int namelen
)
293 aliasoffset
= fdt_path_offset(fdt
, "/aliases");
297 return fdt_getprop_namelen(fdt
, aliasoffset
, name
, namelen
, NULL
);
300 const char *fdt_get_alias(const void *fdt
, const char *name
)
302 return fdt_get_alias_namelen(fdt
, name
, strlen(name
));
305 int fdt_get_path(const void *fdt
, int nodeoffset
, char *buf
, int buflen
)
307 int pdepth
= 0, p
= 0;
308 int offset
, depth
, namelen
;
311 FDT_CHECK_HEADER(fdt
);
314 return -FDT_ERR_NOSPACE
;
316 for (offset
= 0, depth
= 0;
317 (offset
>= 0) && (offset
<= nodeoffset
);
318 offset
= fdt_next_node(fdt
, offset
, &depth
)) {
319 while (pdepth
> depth
) {
322 } while (buf
[p
-1] != '/');
326 if (pdepth
>= depth
) {
327 name
= fdt_get_name(fdt
, offset
, &namelen
);
330 if ((p
+ namelen
+ 1) <= buflen
) {
331 memcpy(buf
+ p
, name
, namelen
);
338 if (offset
== nodeoffset
) {
339 if (pdepth
< (depth
+ 1))
340 return -FDT_ERR_NOSPACE
;
342 if (p
> 1) /* special case so that root path is "/", not "" */
349 if ((offset
== -FDT_ERR_NOTFOUND
) || (offset
>= 0))
350 return -FDT_ERR_BADOFFSET
;
351 else if (offset
== -FDT_ERR_BADOFFSET
)
352 return -FDT_ERR_BADSTRUCTURE
;
354 return offset
; /* error from fdt_next_node() */
357 int fdt_supernode_atdepth_offset(const void *fdt
, int nodeoffset
,
358 int supernodedepth
, int *nodedepth
)
361 int supernodeoffset
= -FDT_ERR_INTERNAL
;
363 FDT_CHECK_HEADER(fdt
);
365 if (supernodedepth
< 0)
366 return -FDT_ERR_NOTFOUND
;
368 for (offset
= 0, depth
= 0;
369 (offset
>= 0) && (offset
<= nodeoffset
);
370 offset
= fdt_next_node(fdt
, offset
, &depth
)) {
371 if (depth
== supernodedepth
)
372 supernodeoffset
= offset
;
374 if (offset
== nodeoffset
) {
378 if (supernodedepth
> depth
)
379 return -FDT_ERR_NOTFOUND
;
381 return supernodeoffset
;
385 if ((offset
== -FDT_ERR_NOTFOUND
) || (offset
>= 0))
386 return -FDT_ERR_BADOFFSET
;
387 else if (offset
== -FDT_ERR_BADOFFSET
)
388 return -FDT_ERR_BADSTRUCTURE
;
390 return offset
; /* error from fdt_next_node() */
393 int fdt_node_depth(const void *fdt
, int nodeoffset
)
398 err
= fdt_supernode_atdepth_offset(fdt
, nodeoffset
, 0, &nodedepth
);
400 return (err
< 0) ? err
: -FDT_ERR_INTERNAL
;
404 int fdt_parent_offset(const void *fdt
, int nodeoffset
)
406 int nodedepth
= fdt_node_depth(fdt
, nodeoffset
);
410 return fdt_supernode_atdepth_offset(fdt
, nodeoffset
,
411 nodedepth
- 1, NULL
);
414 int fdt_node_offset_by_prop_value(const void *fdt
, int startoffset
,
415 const char *propname
,
416 const void *propval
, int proplen
)
422 FDT_CHECK_HEADER(fdt
);
424 /* FIXME: The algorithm here is pretty horrible: we scan each
425 * property of a node in fdt_getprop(), then if that didn't
426 * find what we want, we scan over them again making our way
427 * to the next node. Still it's the easiest to implement
428 * approach; performance can come later. */
429 for (offset
= fdt_next_node(fdt
, startoffset
, NULL
);
431 offset
= fdt_next_node(fdt
, offset
, NULL
)) {
432 val
= fdt_getprop(fdt
, offset
, propname
, &len
);
433 if (val
&& (len
== proplen
)
434 && (memcmp(val
, propval
, len
) == 0))
438 return offset
; /* error from fdt_next_node() */
441 int fdt_node_offset_by_phandle(const void *fdt
, uint32_t phandle
)
443 if ((phandle
== 0) || (phandle
== -1))
444 return -FDT_ERR_BADPHANDLE
;
445 phandle
= cpu_to_fdt32(phandle
);
446 return fdt_node_offset_by_prop_value(fdt
, -1, "linux,phandle",
447 &phandle
, sizeof(phandle
));
450 static int _fdt_stringlist_contains(const char *strlist
, int listlen
,
453 int len
= strlen(str
);
456 while (listlen
>= len
) {
457 if (memcmp(str
, strlist
, len
+1) == 0)
459 p
= memchr(strlist
, '\0', listlen
);
461 return 0; /* malformed strlist.. */
462 listlen
-= (p
-strlist
) + 1;
468 int fdt_node_check_compatible(const void *fdt
, int nodeoffset
,
469 const char *compatible
)
474 prop
= fdt_getprop(fdt
, nodeoffset
, "compatible", &len
);
477 if (_fdt_stringlist_contains(prop
, len
, compatible
))
483 int fdt_node_offset_by_compatible(const void *fdt
, int startoffset
,
484 const char *compatible
)
488 FDT_CHECK_HEADER(fdt
);
490 /* FIXME: The algorithm here is pretty horrible: we scan each
491 * property of a node in fdt_node_check_compatible(), then if
492 * that didn't find what we want, we scan over them again
493 * making our way to the next node. Still it's the easiest to
494 * implement approach; performance can come later. */
495 for (offset
= fdt_next_node(fdt
, startoffset
, NULL
);
497 offset
= fdt_next_node(fdt
, offset
, NULL
)) {
498 err
= fdt_node_check_compatible(fdt
, offset
, compatible
);
499 if ((err
< 0) && (err
!= -FDT_ERR_NOTFOUND
))
505 return offset
; /* error from fdt_next_node() */