14549e789STom Rini // SPDX-License-Identifier: GPL-2.0+ OR BSD-2-Clause
20de71d50SPeter Tyser /*
30de71d50SPeter Tyser * libfdt - Flat Device Tree manipulation
40de71d50SPeter Tyser * Copyright (C) 2006 David Gibson, IBM Corporation.
50de71d50SPeter Tyser */
6b08c8c48SMasahiro Yamada #include <linux/libfdt_env.h>
70de71d50SPeter Tyser
80de71d50SPeter Tyser #ifndef USE_HOSTCC
90de71d50SPeter Tyser #include <fdt.h>
10b08c8c48SMasahiro Yamada #include <linux/libfdt.h>
110de71d50SPeter Tyser #else
120de71d50SPeter Tyser #include "fdt_host.h"
130de71d50SPeter Tyser #endif
140de71d50SPeter Tyser
150de71d50SPeter Tyser #include "libfdt_internal.h"
160de71d50SPeter Tyser
_fdt_nodename_eq(const void * fdt,int offset,const char * s,int len)170de71d50SPeter Tyser static int _fdt_nodename_eq(const void *fdt, int offset,
180de71d50SPeter Tyser const char *s, int len)
190de71d50SPeter Tyser {
200de71d50SPeter Tyser const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
210de71d50SPeter Tyser
220de71d50SPeter Tyser if (!p)
230de71d50SPeter Tyser /* short match */
240de71d50SPeter Tyser return 0;
250de71d50SPeter Tyser
260de71d50SPeter Tyser if (memcmp(p, s, len) != 0)
270de71d50SPeter Tyser return 0;
280de71d50SPeter Tyser
290de71d50SPeter Tyser if (p[len] == '\0')
300de71d50SPeter Tyser return 1;
310de71d50SPeter Tyser else if (!memchr(s, '@', len) && (p[len] == '@'))
320de71d50SPeter Tyser return 1;
330de71d50SPeter Tyser else
340de71d50SPeter Tyser return 0;
350de71d50SPeter Tyser }
360de71d50SPeter Tyser
fdt_string(const void * fdt,int stroffset)370de71d50SPeter Tyser const char *fdt_string(const void *fdt, int stroffset)
380de71d50SPeter Tyser {
390de71d50SPeter Tyser return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
400de71d50SPeter Tyser }
410de71d50SPeter Tyser
_fdt_string_eq(const void * fdt,int stroffset,const char * s,int len)420de71d50SPeter Tyser static int _fdt_string_eq(const void *fdt, int stroffset,
430de71d50SPeter Tyser const char *s, int len)
440de71d50SPeter Tyser {
450de71d50SPeter Tyser const char *p = fdt_string(fdt, stroffset);
460de71d50SPeter Tyser
47af67b252SJon Nalley return (strnlen(p, len + 1) == len) && (memcmp(p, s, len) == 0);
480de71d50SPeter Tyser }
490de71d50SPeter Tyser
fdt_get_max_phandle(const void * fdt)5057c7809aSMaxime Ripard uint32_t fdt_get_max_phandle(const void *fdt)
5157c7809aSMaxime Ripard {
5257c7809aSMaxime Ripard uint32_t max_phandle = 0;
5357c7809aSMaxime Ripard int offset;
5457c7809aSMaxime Ripard
5557c7809aSMaxime Ripard for (offset = fdt_next_node(fdt, -1, NULL);;
5657c7809aSMaxime Ripard offset = fdt_next_node(fdt, offset, NULL)) {
5757c7809aSMaxime Ripard uint32_t phandle;
5857c7809aSMaxime Ripard
5957c7809aSMaxime Ripard if (offset == -FDT_ERR_NOTFOUND)
6057c7809aSMaxime Ripard return max_phandle;
6157c7809aSMaxime Ripard
6257c7809aSMaxime Ripard if (offset < 0)
639c07b987SSimon Glass return (uint32_t)-1;
6457c7809aSMaxime Ripard
6557c7809aSMaxime Ripard phandle = fdt_get_phandle(fdt, offset);
6657c7809aSMaxime Ripard if (phandle == (uint32_t)-1)
679c07b987SSimon Glass continue;
6857c7809aSMaxime Ripard
6957c7809aSMaxime Ripard if (phandle > max_phandle)
7057c7809aSMaxime Ripard max_phandle = phandle;
7157c7809aSMaxime Ripard }
7257c7809aSMaxime Ripard
7357c7809aSMaxime Ripard return 0;
7457c7809aSMaxime Ripard }
7557c7809aSMaxime Ripard
fdt_get_mem_rsv(const void * fdt,int n,uint64_t * address,uint64_t * size)760de71d50SPeter Tyser int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
770de71d50SPeter Tyser {
780de71d50SPeter Tyser FDT_CHECK_HEADER(fdt);
79*db405d19SRob Herring *address = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->address);
80*db405d19SRob Herring *size = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->size);
810de71d50SPeter Tyser return 0;
820de71d50SPeter Tyser }
830de71d50SPeter Tyser
fdt_num_mem_rsv(const void * fdt)840de71d50SPeter Tyser int fdt_num_mem_rsv(const void *fdt)
850de71d50SPeter Tyser {
860de71d50SPeter Tyser int i = 0;
870de71d50SPeter Tyser
88*db405d19SRob Herring while (fdt64_to_cpu(fdt_mem_rsv_(fdt, i)->size) != 0)
890de71d50SPeter Tyser i++;
900de71d50SPeter Tyser return i;
910de71d50SPeter Tyser }
920de71d50SPeter Tyser
_nextprop(const void * fdt,int offset)93d1c63148SDavid Gibson static int _nextprop(const void *fdt, int offset)
94d1c63148SDavid Gibson {
95d1c63148SDavid Gibson uint32_t tag;
96d1c63148SDavid Gibson int nextoffset;
97d1c63148SDavid Gibson
98d1c63148SDavid Gibson do {
99d1c63148SDavid Gibson tag = fdt_next_tag(fdt, offset, &nextoffset);
100d1c63148SDavid Gibson
101d1c63148SDavid Gibson switch (tag) {
102d1c63148SDavid Gibson case FDT_END:
103d1c63148SDavid Gibson if (nextoffset >= 0)
104d1c63148SDavid Gibson return -FDT_ERR_BADSTRUCTURE;
105d1c63148SDavid Gibson else
106d1c63148SDavid Gibson return nextoffset;
107d1c63148SDavid Gibson
108d1c63148SDavid Gibson case FDT_PROP:
109d1c63148SDavid Gibson return offset;
110d1c63148SDavid Gibson }
111d1c63148SDavid Gibson offset = nextoffset;
112d1c63148SDavid Gibson } while (tag == FDT_NOP);
113d1c63148SDavid Gibson
114d1c63148SDavid Gibson return -FDT_ERR_NOTFOUND;
115d1c63148SDavid Gibson }
116d1c63148SDavid Gibson
fdt_subnode_offset_namelen(const void * fdt,int offset,const char * name,int namelen)1170de71d50SPeter Tyser int fdt_subnode_offset_namelen(const void *fdt, int offset,
1180de71d50SPeter Tyser const char *name, int namelen)
1190de71d50SPeter Tyser {
1200de71d50SPeter Tyser int depth;
1210de71d50SPeter Tyser
1220de71d50SPeter Tyser FDT_CHECK_HEADER(fdt);
1230de71d50SPeter Tyser
1240de71d50SPeter Tyser for (depth = 0;
1250de71d50SPeter Tyser (offset >= 0) && (depth >= 0);
1260de71d50SPeter Tyser offset = fdt_next_node(fdt, offset, &depth))
1270de71d50SPeter Tyser if ((depth == 1)
1280de71d50SPeter Tyser && _fdt_nodename_eq(fdt, offset, name, namelen))
1290de71d50SPeter Tyser return offset;
1300de71d50SPeter Tyser
1310de71d50SPeter Tyser if (depth < 0)
1320de71d50SPeter Tyser return -FDT_ERR_NOTFOUND;
1330de71d50SPeter Tyser return offset; /* error */
1340de71d50SPeter Tyser }
1350de71d50SPeter Tyser
fdt_subnode_offset(const void * fdt,int parentoffset,const char * name)1360de71d50SPeter Tyser int fdt_subnode_offset(const void *fdt, int parentoffset,
1370de71d50SPeter Tyser const char *name)
1380de71d50SPeter Tyser {
1390de71d50SPeter Tyser return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
1400de71d50SPeter Tyser }
1410de71d50SPeter Tyser
14277d7fff8SHans de Goede /*
1436f5f92c6SMaxime Ripard * Find the next of path separator, note we need to search for both '/' and ':'
1446feed2a5SRobert P. J. Day * and then take the first one so that we do the right thing for e.g.
14577d7fff8SHans de Goede * "foo/bar:option" and "bar:option/otheroption", both of which happen, so
14677d7fff8SHans de Goede * first searching for either ':' or '/' does not work.
14777d7fff8SHans de Goede */
fdt_path_next_separator(const char * path,int len)1488e968571SMaxime Ripard static const char *fdt_path_next_separator(const char *path, int len)
14977d7fff8SHans de Goede {
1508e968571SMaxime Ripard const void *sep1 = memchr(path, '/', len);
1518e968571SMaxime Ripard const void *sep2 = memchr(path, ':', len);
15277d7fff8SHans de Goede
15377d7fff8SHans de Goede if (sep1 && sep2)
15477d7fff8SHans de Goede return (sep1 < sep2) ? sep1 : sep2;
15577d7fff8SHans de Goede else if (sep1)
15677d7fff8SHans de Goede return sep1;
15777d7fff8SHans de Goede else
15877d7fff8SHans de Goede return sep2;
15977d7fff8SHans de Goede }
16077d7fff8SHans de Goede
fdt_path_offset_namelen(const void * fdt,const char * path,int namelen)1618e968571SMaxime Ripard int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen)
1620de71d50SPeter Tyser {
1638e968571SMaxime Ripard const char *end = path + namelen;
1640de71d50SPeter Tyser const char *p = path;
1650de71d50SPeter Tyser int offset = 0;
1660de71d50SPeter Tyser
1670de71d50SPeter Tyser FDT_CHECK_HEADER(fdt);
1680de71d50SPeter Tyser
1690de71d50SPeter Tyser /* see if we have an alias */
1700de71d50SPeter Tyser if (*path != '/') {
1718e968571SMaxime Ripard const char *q = fdt_path_next_separator(path, namelen);
1720de71d50SPeter Tyser
1730de71d50SPeter Tyser if (!q)
1740de71d50SPeter Tyser q = end;
1750de71d50SPeter Tyser
1760de71d50SPeter Tyser p = fdt_get_alias_namelen(fdt, p, q - p);
1770de71d50SPeter Tyser if (!p)
1780de71d50SPeter Tyser return -FDT_ERR_BADPATH;
1790de71d50SPeter Tyser offset = fdt_path_offset(fdt, p);
1800de71d50SPeter Tyser
1810de71d50SPeter Tyser p = q;
1820de71d50SPeter Tyser }
1830de71d50SPeter Tyser
1848e968571SMaxime Ripard while (*p && (p < end)) {
1850de71d50SPeter Tyser const char *q;
1860de71d50SPeter Tyser
1870de71d50SPeter Tyser while (*p == '/')
1880de71d50SPeter Tyser p++;
1898e968571SMaxime Ripard
19077d7fff8SHans de Goede if (*p == '\0' || *p == ':')
1910de71d50SPeter Tyser return offset;
1928e968571SMaxime Ripard
1938e968571SMaxime Ripard q = fdt_path_next_separator(p, end - p);
1940de71d50SPeter Tyser if (!q)
1950de71d50SPeter Tyser q = end;
1960de71d50SPeter Tyser
1970de71d50SPeter Tyser offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
1980de71d50SPeter Tyser if (offset < 0)
1990de71d50SPeter Tyser return offset;
2000de71d50SPeter Tyser
2010de71d50SPeter Tyser p = q;
2020de71d50SPeter Tyser }
2030de71d50SPeter Tyser
2040de71d50SPeter Tyser return offset;
2050de71d50SPeter Tyser }
2060de71d50SPeter Tyser
fdt_path_offset(const void * fdt,const char * path)20742b7600dSSimon Glass int fdt_path_offset(const void *fdt, const char *path)
20842b7600dSSimon Glass {
20942b7600dSSimon Glass return fdt_path_offset_namelen(fdt, path, strlen(path));
21042b7600dSSimon Glass }
21142b7600dSSimon Glass
fdt_get_name(const void * fdt,int nodeoffset,int * len)2120de71d50SPeter Tyser const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
2130de71d50SPeter Tyser {
214*db405d19SRob Herring const struct fdt_node_header *nh = fdt_offset_ptr_(fdt, nodeoffset);
2150de71d50SPeter Tyser int err;
2160de71d50SPeter Tyser
2170de71d50SPeter Tyser if (((err = fdt_check_header(fdt)) != 0)
218*db405d19SRob Herring || ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0))
2190de71d50SPeter Tyser goto fail;
2200de71d50SPeter Tyser
2210de71d50SPeter Tyser if (len)
2220de71d50SPeter Tyser *len = strlen(nh->name);
2230de71d50SPeter Tyser
2240de71d50SPeter Tyser return nh->name;
2250de71d50SPeter Tyser
2260de71d50SPeter Tyser fail:
2270de71d50SPeter Tyser if (len)
2280de71d50SPeter Tyser *len = err;
2290de71d50SPeter Tyser return NULL;
2300de71d50SPeter Tyser }
2310de71d50SPeter Tyser
fdt_first_property_offset(const void * fdt,int nodeoffset)232d1c63148SDavid Gibson int fdt_first_property_offset(const void *fdt, int nodeoffset)
2330de71d50SPeter Tyser {
234d1c63148SDavid Gibson int offset;
235d1c63148SDavid Gibson
236*db405d19SRob Herring if ((offset = fdt_check_node_offset_(fdt, nodeoffset)) < 0)
237d1c63148SDavid Gibson return offset;
238d1c63148SDavid Gibson
239d1c63148SDavid Gibson return _nextprop(fdt, offset);
240d1c63148SDavid Gibson }
241d1c63148SDavid Gibson
fdt_next_property_offset(const void * fdt,int offset)242d1c63148SDavid Gibson int fdt_next_property_offset(const void *fdt, int offset)
243d1c63148SDavid Gibson {
244*db405d19SRob Herring if ((offset = fdt_check_prop_offset_(fdt, offset)) < 0)
245d1c63148SDavid Gibson return offset;
246d1c63148SDavid Gibson
247d1c63148SDavid Gibson return _nextprop(fdt, offset);
248d1c63148SDavid Gibson }
249d1c63148SDavid Gibson
fdt_get_property_by_offset(const void * fdt,int offset,int * lenp)250d1c63148SDavid Gibson const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
251d1c63148SDavid Gibson int offset,
252d1c63148SDavid Gibson int *lenp)
253d1c63148SDavid Gibson {
2540de71d50SPeter Tyser int err;
255d1c63148SDavid Gibson const struct fdt_property *prop;
2560de71d50SPeter Tyser
257*db405d19SRob Herring if ((err = fdt_check_prop_offset_(fdt, offset)) < 0) {
258d1c63148SDavid Gibson if (lenp)
259d1c63148SDavid Gibson *lenp = err;
260d1c63148SDavid Gibson return NULL;
261d1c63148SDavid Gibson }
2620de71d50SPeter Tyser
263*db405d19SRob Herring prop = fdt_offset_ptr_(fdt, offset);
264d1c63148SDavid Gibson
2650de71d50SPeter Tyser if (lenp)
2660de71d50SPeter Tyser *lenp = fdt32_to_cpu(prop->len);
2670de71d50SPeter Tyser
2680de71d50SPeter Tyser return prop;
2690de71d50SPeter Tyser }
270d1c63148SDavid Gibson
fdt_get_property_namelen(const void * fdt,int offset,const char * name,int namelen,int * lenp)271d1c63148SDavid Gibson const struct fdt_property *fdt_get_property_namelen(const void *fdt,
272d1c63148SDavid Gibson int offset,
273d1c63148SDavid Gibson const char *name,
274d1c63148SDavid Gibson int namelen, int *lenp)
275d1c63148SDavid Gibson {
276d1c63148SDavid Gibson for (offset = fdt_first_property_offset(fdt, offset);
277d1c63148SDavid Gibson (offset >= 0);
278d1c63148SDavid Gibson (offset = fdt_next_property_offset(fdt, offset))) {
279d1c63148SDavid Gibson const struct fdt_property *prop;
280d1c63148SDavid Gibson
281d1c63148SDavid Gibson if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) {
282d1c63148SDavid Gibson offset = -FDT_ERR_INTERNAL;
2830de71d50SPeter Tyser break;
2840de71d50SPeter Tyser }
285d1c63148SDavid Gibson if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
286d1c63148SDavid Gibson name, namelen))
287d1c63148SDavid Gibson return prop;
288d1c63148SDavid Gibson }
2890de71d50SPeter Tyser
2900de71d50SPeter Tyser if (lenp)
291d1c63148SDavid Gibson *lenp = offset;
2920de71d50SPeter Tyser return NULL;
2930de71d50SPeter Tyser }
2940de71d50SPeter Tyser
fdt_get_property(const void * fdt,int nodeoffset,const char * name,int * lenp)2950de71d50SPeter Tyser const struct fdt_property *fdt_get_property(const void *fdt,
2960de71d50SPeter Tyser int nodeoffset,
2970de71d50SPeter Tyser const char *name, int *lenp)
2980de71d50SPeter Tyser {
2990de71d50SPeter Tyser return fdt_get_property_namelen(fdt, nodeoffset, name,
3000de71d50SPeter Tyser strlen(name), lenp);
3010de71d50SPeter Tyser }
3020de71d50SPeter Tyser
fdt_getprop_namelen(const void * fdt,int nodeoffset,const char * name,int namelen,int * lenp)3030de71d50SPeter Tyser const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
3040de71d50SPeter Tyser const char *name, int namelen, int *lenp)
3050de71d50SPeter Tyser {
3060de71d50SPeter Tyser const struct fdt_property *prop;
3070de71d50SPeter Tyser
3080de71d50SPeter Tyser prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
3090de71d50SPeter Tyser if (!prop)
3100de71d50SPeter Tyser return NULL;
3110de71d50SPeter Tyser
3120de71d50SPeter Tyser return prop->data;
3130de71d50SPeter Tyser }
3140de71d50SPeter Tyser
fdt_getprop_by_offset(const void * fdt,int offset,const char ** namep,int * lenp)315d1c63148SDavid Gibson const void *fdt_getprop_by_offset(const void *fdt, int offset,
316d1c63148SDavid Gibson const char **namep, int *lenp)
317d1c63148SDavid Gibson {
318d1c63148SDavid Gibson const struct fdt_property *prop;
319d1c63148SDavid Gibson
320d1c63148SDavid Gibson prop = fdt_get_property_by_offset(fdt, offset, lenp);
321d1c63148SDavid Gibson if (!prop)
322d1c63148SDavid Gibson return NULL;
323d1c63148SDavid Gibson if (namep)
324d1c63148SDavid Gibson *namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
325d1c63148SDavid Gibson return prop->data;
326d1c63148SDavid Gibson }
327d1c63148SDavid Gibson
fdt_getprop(const void * fdt,int nodeoffset,const char * name,int * lenp)3280de71d50SPeter Tyser const void *fdt_getprop(const void *fdt, int nodeoffset,
3290de71d50SPeter Tyser const char *name, int *lenp)
3300de71d50SPeter Tyser {
3310de71d50SPeter Tyser return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
3320de71d50SPeter Tyser }
3330de71d50SPeter Tyser
fdt_get_phandle(const void * fdt,int nodeoffset)3340de71d50SPeter Tyser uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
3350de71d50SPeter Tyser {
336b2ba62a1SKim Phillips const fdt32_t *php;
3370de71d50SPeter Tyser int len;
3380de71d50SPeter Tyser
33905a22ba0SDavid Gibson /* FIXME: This is a bit sub-optimal, since we potentially scan
34005a22ba0SDavid Gibson * over all the properties twice. */
34105a22ba0SDavid Gibson php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
34205a22ba0SDavid Gibson if (!php || (len != sizeof(*php))) {
3430de71d50SPeter Tyser php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
3440de71d50SPeter Tyser if (!php || (len != sizeof(*php)))
3450de71d50SPeter Tyser return 0;
34605a22ba0SDavid Gibson }
3470de71d50SPeter Tyser
3480de71d50SPeter Tyser return fdt32_to_cpu(*php);
3490de71d50SPeter Tyser }
3500de71d50SPeter Tyser
fdt_get_alias_namelen(const void * fdt,const char * name,int namelen)3510de71d50SPeter Tyser const char *fdt_get_alias_namelen(const void *fdt,
3520de71d50SPeter Tyser const char *name, int namelen)
3530de71d50SPeter Tyser {
3540de71d50SPeter Tyser int aliasoffset;
3550de71d50SPeter Tyser
3560de71d50SPeter Tyser aliasoffset = fdt_path_offset(fdt, "/aliases");
3570de71d50SPeter Tyser if (aliasoffset < 0)
3580de71d50SPeter Tyser return NULL;
3590de71d50SPeter Tyser
3600de71d50SPeter Tyser return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);
3610de71d50SPeter Tyser }
3620de71d50SPeter Tyser
fdt_get_alias(const void * fdt,const char * name)3630de71d50SPeter Tyser const char *fdt_get_alias(const void *fdt, const char *name)
3640de71d50SPeter Tyser {
3650de71d50SPeter Tyser return fdt_get_alias_namelen(fdt, name, strlen(name));
3660de71d50SPeter Tyser }
3670de71d50SPeter Tyser
fdt_get_path(const void * fdt,int nodeoffset,char * buf,int buflen)3680de71d50SPeter Tyser int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
3690de71d50SPeter Tyser {
3700de71d50SPeter Tyser int pdepth = 0, p = 0;
3710de71d50SPeter Tyser int offset, depth, namelen;
3720de71d50SPeter Tyser const char *name;
3730de71d50SPeter Tyser
3740de71d50SPeter Tyser FDT_CHECK_HEADER(fdt);
3750de71d50SPeter Tyser
3760de71d50SPeter Tyser if (buflen < 2)
3770de71d50SPeter Tyser return -FDT_ERR_NOSPACE;
3780de71d50SPeter Tyser
3790de71d50SPeter Tyser for (offset = 0, depth = 0;
3800de71d50SPeter Tyser (offset >= 0) && (offset <= nodeoffset);
3810de71d50SPeter Tyser offset = fdt_next_node(fdt, offset, &depth)) {
3820de71d50SPeter Tyser while (pdepth > depth) {
3830de71d50SPeter Tyser do {
3840de71d50SPeter Tyser p--;
3850de71d50SPeter Tyser } while (buf[p-1] != '/');
3860de71d50SPeter Tyser pdepth--;
3870de71d50SPeter Tyser }
3880de71d50SPeter Tyser
3890de71d50SPeter Tyser if (pdepth >= depth) {
3900de71d50SPeter Tyser name = fdt_get_name(fdt, offset, &namelen);
3910de71d50SPeter Tyser if (!name)
3920de71d50SPeter Tyser return namelen;
3930de71d50SPeter Tyser if ((p + namelen + 1) <= buflen) {
3940de71d50SPeter Tyser memcpy(buf + p, name, namelen);
3950de71d50SPeter Tyser p += namelen;
3960de71d50SPeter Tyser buf[p++] = '/';
3970de71d50SPeter Tyser pdepth++;
3980de71d50SPeter Tyser }
3990de71d50SPeter Tyser }
4000de71d50SPeter Tyser
4010de71d50SPeter Tyser if (offset == nodeoffset) {
4020de71d50SPeter Tyser if (pdepth < (depth + 1))
4030de71d50SPeter Tyser return -FDT_ERR_NOSPACE;
4040de71d50SPeter Tyser
4050de71d50SPeter Tyser if (p > 1) /* special case so that root path is "/", not "" */
4060de71d50SPeter Tyser p--;
4070de71d50SPeter Tyser buf[p] = '\0';
4080de71d50SPeter Tyser return 0;
4090de71d50SPeter Tyser }
4100de71d50SPeter Tyser }
4110de71d50SPeter Tyser
4120de71d50SPeter Tyser if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
4130de71d50SPeter Tyser return -FDT_ERR_BADOFFSET;
4140de71d50SPeter Tyser else if (offset == -FDT_ERR_BADOFFSET)
4150de71d50SPeter Tyser return -FDT_ERR_BADSTRUCTURE;
4160de71d50SPeter Tyser
4170de71d50SPeter Tyser return offset; /* error from fdt_next_node() */
4180de71d50SPeter Tyser }
4190de71d50SPeter Tyser
fdt_supernode_atdepth_offset(const void * fdt,int nodeoffset,int supernodedepth,int * nodedepth)4200de71d50SPeter Tyser int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
4210de71d50SPeter Tyser int supernodedepth, int *nodedepth)
4220de71d50SPeter Tyser {
4230de71d50SPeter Tyser int offset, depth;
4240de71d50SPeter Tyser int supernodeoffset = -FDT_ERR_INTERNAL;
4250de71d50SPeter Tyser
4260de71d50SPeter Tyser FDT_CHECK_HEADER(fdt);
4270de71d50SPeter Tyser
4280de71d50SPeter Tyser if (supernodedepth < 0)
4290de71d50SPeter Tyser return -FDT_ERR_NOTFOUND;
4300de71d50SPeter Tyser
4310de71d50SPeter Tyser for (offset = 0, depth = 0;
4320de71d50SPeter Tyser (offset >= 0) && (offset <= nodeoffset);
4330de71d50SPeter Tyser offset = fdt_next_node(fdt, offset, &depth)) {
4340de71d50SPeter Tyser if (depth == supernodedepth)
4350de71d50SPeter Tyser supernodeoffset = offset;
4360de71d50SPeter Tyser
4370de71d50SPeter Tyser if (offset == nodeoffset) {
4380de71d50SPeter Tyser if (nodedepth)
4390de71d50SPeter Tyser *nodedepth = depth;
4400de71d50SPeter Tyser
4410de71d50SPeter Tyser if (supernodedepth > depth)
4420de71d50SPeter Tyser return -FDT_ERR_NOTFOUND;
4430de71d50SPeter Tyser else
4440de71d50SPeter Tyser return supernodeoffset;
4450de71d50SPeter Tyser }
4460de71d50SPeter Tyser }
4470de71d50SPeter Tyser
4480de71d50SPeter Tyser if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
4490de71d50SPeter Tyser return -FDT_ERR_BADOFFSET;
4500de71d50SPeter Tyser else if (offset == -FDT_ERR_BADOFFSET)
4510de71d50SPeter Tyser return -FDT_ERR_BADSTRUCTURE;
4520de71d50SPeter Tyser
4530de71d50SPeter Tyser return offset; /* error from fdt_next_node() */
4540de71d50SPeter Tyser }
4550de71d50SPeter Tyser
fdt_node_depth(const void * fdt,int nodeoffset)4560de71d50SPeter Tyser int fdt_node_depth(const void *fdt, int nodeoffset)
4570de71d50SPeter Tyser {
4580de71d50SPeter Tyser int nodedepth;
4590de71d50SPeter Tyser int err;
4600de71d50SPeter Tyser
4610de71d50SPeter Tyser err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
4620de71d50SPeter Tyser if (err)
4630de71d50SPeter Tyser return (err < 0) ? err : -FDT_ERR_INTERNAL;
4640de71d50SPeter Tyser return nodedepth;
4650de71d50SPeter Tyser }
4660de71d50SPeter Tyser
fdt_parent_offset(const void * fdt,int nodeoffset)4670de71d50SPeter Tyser int fdt_parent_offset(const void *fdt, int nodeoffset)
4680de71d50SPeter Tyser {
4690de71d50SPeter Tyser int nodedepth = fdt_node_depth(fdt, nodeoffset);
4700de71d50SPeter Tyser
4710de71d50SPeter Tyser if (nodedepth < 0)
4720de71d50SPeter Tyser return nodedepth;
4730de71d50SPeter Tyser return fdt_supernode_atdepth_offset(fdt, nodeoffset,
4740de71d50SPeter Tyser nodedepth - 1, NULL);
4750de71d50SPeter Tyser }
4760de71d50SPeter Tyser
fdt_node_offset_by_prop_value(const void * fdt,int startoffset,const char * propname,const void * propval,int proplen)4770de71d50SPeter Tyser int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
4780de71d50SPeter Tyser const char *propname,
4790de71d50SPeter Tyser const void *propval, int proplen)
4800de71d50SPeter Tyser {
4810de71d50SPeter Tyser int offset;
4820de71d50SPeter Tyser const void *val;
4830de71d50SPeter Tyser int len;
4840de71d50SPeter Tyser
4850de71d50SPeter Tyser FDT_CHECK_HEADER(fdt);
4860de71d50SPeter Tyser
4870de71d50SPeter Tyser /* FIXME: The algorithm here is pretty horrible: we scan each
4880de71d50SPeter Tyser * property of a node in fdt_getprop(), then if that didn't
4890de71d50SPeter Tyser * find what we want, we scan over them again making our way
4900de71d50SPeter Tyser * to the next node. Still it's the easiest to implement
4910de71d50SPeter Tyser * approach; performance can come later. */
4920de71d50SPeter Tyser for (offset = fdt_next_node(fdt, startoffset, NULL);
4930de71d50SPeter Tyser offset >= 0;
4940de71d50SPeter Tyser offset = fdt_next_node(fdt, offset, NULL)) {
4950de71d50SPeter Tyser val = fdt_getprop(fdt, offset, propname, &len);
4960de71d50SPeter Tyser if (val && (len == proplen)
4970de71d50SPeter Tyser && (memcmp(val, propval, len) == 0))
4980de71d50SPeter Tyser return offset;
4990de71d50SPeter Tyser }
5000de71d50SPeter Tyser
5010de71d50SPeter Tyser return offset; /* error from fdt_next_node() */
5020de71d50SPeter Tyser }
5030de71d50SPeter Tyser
fdt_node_offset_by_phandle(const void * fdt,uint32_t phandle)5040de71d50SPeter Tyser int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
5050de71d50SPeter Tyser {
50605a22ba0SDavid Gibson int offset;
50705a22ba0SDavid Gibson
5080de71d50SPeter Tyser if ((phandle == 0) || (phandle == -1))
5090de71d50SPeter Tyser return -FDT_ERR_BADPHANDLE;
51005a22ba0SDavid Gibson
51105a22ba0SDavid Gibson FDT_CHECK_HEADER(fdt);
51205a22ba0SDavid Gibson
51305a22ba0SDavid Gibson /* FIXME: The algorithm here is pretty horrible: we
51405a22ba0SDavid Gibson * potentially scan each property of a node in
51505a22ba0SDavid Gibson * fdt_get_phandle(), then if that didn't find what
51605a22ba0SDavid Gibson * we want, we scan over them again making our way to the next
51705a22ba0SDavid Gibson * node. Still it's the easiest to implement approach;
51805a22ba0SDavid Gibson * performance can come later. */
51905a22ba0SDavid Gibson for (offset = fdt_next_node(fdt, -1, NULL);
52005a22ba0SDavid Gibson offset >= 0;
52105a22ba0SDavid Gibson offset = fdt_next_node(fdt, offset, NULL)) {
52205a22ba0SDavid Gibson if (fdt_get_phandle(fdt, offset) == phandle)
52305a22ba0SDavid Gibson return offset;
52405a22ba0SDavid Gibson }
52505a22ba0SDavid Gibson
52605a22ba0SDavid Gibson return offset; /* error from fdt_next_node() */
5270de71d50SPeter Tyser }
5280de71d50SPeter Tyser
fdt_stringlist_contains(const char * strlist,int listlen,const char * str)529e853b324SSimon Glass int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
5300de71d50SPeter Tyser {
5310de71d50SPeter Tyser int len = strlen(str);
5320de71d50SPeter Tyser const char *p;
5330de71d50SPeter Tyser
5340de71d50SPeter Tyser while (listlen >= len) {
5350de71d50SPeter Tyser if (memcmp(str, strlist, len+1) == 0)
5360de71d50SPeter Tyser return 1;
5370de71d50SPeter Tyser p = memchr(strlist, '\0', listlen);
5380de71d50SPeter Tyser if (!p)
5390de71d50SPeter Tyser return 0; /* malformed strlist.. */
5400de71d50SPeter Tyser listlen -= (p-strlist) + 1;
5410de71d50SPeter Tyser strlist = p + 1;
5420de71d50SPeter Tyser }
5430de71d50SPeter Tyser return 0;
5440de71d50SPeter Tyser }
5450de71d50SPeter Tyser
fdt_stringlist_count(const void * fdt,int nodeoffset,const char * property)546b02e4044SSimon Glass int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property)
547bc4147abSThierry Reding {
548b02e4044SSimon Glass const char *list, *end;
549b02e4044SSimon Glass int length, count = 0;
550bc4147abSThierry Reding
551b02e4044SSimon Glass list = fdt_getprop(fdt, nodeoffset, property, &length);
552bc4147abSThierry Reding if (!list)
5537c9786d6SMasahiro Yamada return length;
554bc4147abSThierry Reding
555b02e4044SSimon Glass end = list + length;
556bc4147abSThierry Reding
557b02e4044SSimon Glass while (list < end) {
558b02e4044SSimon Glass length = strnlen(list, end - list) + 1;
559b02e4044SSimon Glass
560b02e4044SSimon Glass /* Abort if the last string isn't properly NUL-terminated. */
561b02e4044SSimon Glass if (list + length > end)
562b02e4044SSimon Glass return -FDT_ERR_BADVALUE;
563b02e4044SSimon Glass
564b02e4044SSimon Glass list += length;
565bc4147abSThierry Reding count++;
566bc4147abSThierry Reding }
567bc4147abSThierry Reding
568bc4147abSThierry Reding return count;
569bc4147abSThierry Reding }
570bc4147abSThierry Reding
fdt_stringlist_search(const void * fdt,int nodeoffset,const char * property,const char * string)571b02e4044SSimon Glass int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
572fc503c17SThierry Reding const char *string)
573fc503c17SThierry Reding {
574b02e4044SSimon Glass int length, len, idx = 0;
575fc503c17SThierry Reding const char *list, *end;
576fc503c17SThierry Reding
577b02e4044SSimon Glass list = fdt_getprop(fdt, nodeoffset, property, &length);
578fc503c17SThierry Reding if (!list)
57901ae56cfSMasahiro Yamada return length;
580fc503c17SThierry Reding
581b02e4044SSimon Glass len = strlen(string) + 1;
582b02e4044SSimon Glass end = list + length;
583fc503c17SThierry Reding
584fc503c17SThierry Reding while (list < end) {
585b02e4044SSimon Glass length = strnlen(list, end - list) + 1;
586fc503c17SThierry Reding
587b02e4044SSimon Glass /* Abort if the last string isn't properly NUL-terminated. */
588b02e4044SSimon Glass if (list + length > end)
589b02e4044SSimon Glass return -FDT_ERR_BADVALUE;
590fc503c17SThierry Reding
591b02e4044SSimon Glass if (length == len && memcmp(list, string, length) == 0)
592b02e4044SSimon Glass return idx;
593b02e4044SSimon Glass
594b02e4044SSimon Glass list += length;
595b02e4044SSimon Glass idx++;
596fc503c17SThierry Reding }
597fc503c17SThierry Reding
598fc503c17SThierry Reding return -FDT_ERR_NOTFOUND;
599fc503c17SThierry Reding }
600fc503c17SThierry Reding
fdt_stringlist_get(const void * fdt,int nodeoffset,const char * property,int idx,int * lenp)601b02e4044SSimon Glass const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
602b02e4044SSimon Glass const char *property, int idx,
603b02e4044SSimon Glass int *lenp)
6045094eb40SThierry Reding {
605b02e4044SSimon Glass const char *list, *end;
606b02e4044SSimon Glass int length;
6075094eb40SThierry Reding
608b02e4044SSimon Glass list = fdt_getprop(fdt, nodeoffset, property, &length);
609b02e4044SSimon Glass if (!list) {
610b02e4044SSimon Glass if (lenp)
611b02e4044SSimon Glass *lenp = length;
6125094eb40SThierry Reding
613b02e4044SSimon Glass return NULL;
6145094eb40SThierry Reding }
6155094eb40SThierry Reding
616b02e4044SSimon Glass end = list + length;
617b02e4044SSimon Glass
618b02e4044SSimon Glass while (list < end) {
619b02e4044SSimon Glass length = strnlen(list, end - list) + 1;
620b02e4044SSimon Glass
621b02e4044SSimon Glass /* Abort if the last string isn't properly NUL-terminated. */
622b02e4044SSimon Glass if (list + length > end) {
623b02e4044SSimon Glass if (lenp)
624b02e4044SSimon Glass *lenp = -FDT_ERR_BADVALUE;
625b02e4044SSimon Glass
626b02e4044SSimon Glass return NULL;
6275094eb40SThierry Reding }
6285094eb40SThierry Reding
629b02e4044SSimon Glass if (idx == 0) {
630b02e4044SSimon Glass if (lenp)
631b02e4044SSimon Glass *lenp = length - 1;
632b02e4044SSimon Glass
633b02e4044SSimon Glass return list;
6345094eb40SThierry Reding }
6355094eb40SThierry Reding
636b02e4044SSimon Glass list += length;
637b02e4044SSimon Glass idx--;
638b02e4044SSimon Glass }
639b02e4044SSimon Glass
640b02e4044SSimon Glass if (lenp)
641b02e4044SSimon Glass *lenp = -FDT_ERR_NOTFOUND;
642b02e4044SSimon Glass
643b02e4044SSimon Glass return NULL;
6445094eb40SThierry Reding }
6455094eb40SThierry Reding
fdt_node_check_compatible(const void * fdt,int nodeoffset,const char * compatible)6460de71d50SPeter Tyser int fdt_node_check_compatible(const void *fdt, int nodeoffset,
6470de71d50SPeter Tyser const char *compatible)
6480de71d50SPeter Tyser {
6490de71d50SPeter Tyser const void *prop;
6500de71d50SPeter Tyser int len;
6510de71d50SPeter Tyser
6520de71d50SPeter Tyser prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
6530de71d50SPeter Tyser if (!prop)
6540de71d50SPeter Tyser return len;
6559c07b987SSimon Glass
6569c07b987SSimon Glass return !fdt_stringlist_contains(prop, len, compatible);
6570de71d50SPeter Tyser }
6580de71d50SPeter Tyser
fdt_node_offset_by_compatible(const void * fdt,int startoffset,const char * compatible)6590de71d50SPeter Tyser int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
6600de71d50SPeter Tyser const char *compatible)
6610de71d50SPeter Tyser {
6620de71d50SPeter Tyser int offset, err;
6630de71d50SPeter Tyser
6640de71d50SPeter Tyser FDT_CHECK_HEADER(fdt);
6650de71d50SPeter Tyser
6660de71d50SPeter Tyser /* FIXME: The algorithm here is pretty horrible: we scan each
6670de71d50SPeter Tyser * property of a node in fdt_node_check_compatible(), then if
6680de71d50SPeter Tyser * that didn't find what we want, we scan over them again
6690de71d50SPeter Tyser * making our way to the next node. Still it's the easiest to
6700de71d50SPeter Tyser * implement approach; performance can come later. */
6710de71d50SPeter Tyser for (offset = fdt_next_node(fdt, startoffset, NULL);
6720de71d50SPeter Tyser offset >= 0;
6730de71d50SPeter Tyser offset = fdt_next_node(fdt, offset, NULL)) {
6740de71d50SPeter Tyser err = fdt_node_check_compatible(fdt, offset, compatible);
6750de71d50SPeter Tyser if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
6760de71d50SPeter Tyser return err;
6770de71d50SPeter Tyser else if (err == 0)
6780de71d50SPeter Tyser return offset;
6790de71d50SPeter Tyser }
6800de71d50SPeter Tyser
6810de71d50SPeter Tyser return offset; /* error from fdt_next_node() */
6820de71d50SPeter Tyser }
683