10de71d50SPeter Tyser /* 20de71d50SPeter Tyser * libfdt - Flat Device Tree manipulation 30de71d50SPeter Tyser * Copyright (C) 2006 David Gibson, IBM Corporation. 435084760SRoger Meier * SPDX-License-Identifier: GPL-2.0+ BSD-2-Clause 50de71d50SPeter Tyser */ 6*b08c8c48SMasahiro Yamada #include <linux/libfdt_env.h> 70de71d50SPeter Tyser 80de71d50SPeter Tyser #ifndef USE_HOSTCC 90de71d50SPeter Tyser #include <fdt.h> 10*b08c8c48SMasahiro 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 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 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 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 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 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); 790de71d50SPeter Tyser *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address); 800de71d50SPeter Tyser *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size); 810de71d50SPeter Tyser return 0; 820de71d50SPeter Tyser } 830de71d50SPeter Tyser 840de71d50SPeter Tyser int fdt_num_mem_rsv(const void *fdt) 850de71d50SPeter Tyser { 860de71d50SPeter Tyser int i = 0; 870de71d50SPeter Tyser 880de71d50SPeter Tyser while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0) 890de71d50SPeter Tyser i++; 900de71d50SPeter Tyser return i; 910de71d50SPeter Tyser } 920de71d50SPeter Tyser 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 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 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 */ 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 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 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 2120de71d50SPeter Tyser const char *fdt_get_name(const void *fdt, int nodeoffset, int *len) 2130de71d50SPeter Tyser { 2140de71d50SPeter Tyser 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) 2180de71d50SPeter Tyser || ((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 232d1c63148SDavid Gibson int fdt_first_property_offset(const void *fdt, int nodeoffset) 2330de71d50SPeter Tyser { 234d1c63148SDavid Gibson int offset; 235d1c63148SDavid Gibson 236d1c63148SDavid Gibson 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 242d1c63148SDavid Gibson int fdt_next_property_offset(const void *fdt, int offset) 243d1c63148SDavid Gibson { 244d1c63148SDavid Gibson 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 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 257d1c63148SDavid Gibson 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 2630de71d50SPeter Tyser 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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