diff options
Diffstat (limited to 'EmbeddedPkg/Library/FdtLib/fdt_ro.c')
| -rw-r--r-- | EmbeddedPkg/Library/FdtLib/fdt_ro.c | 1272 |
1 files changed, 766 insertions, 506 deletions
diff --git a/EmbeddedPkg/Library/FdtLib/fdt_ro.c b/EmbeddedPkg/Library/FdtLib/fdt_ro.c index 9413f50a11..30aac37958 100644 --- a/EmbeddedPkg/Library/FdtLib/fdt_ro.c +++ b/EmbeddedPkg/Library/FdtLib/fdt_ro.c @@ -55,649 +55,909 @@ #include "libfdt_internal.h"
-static int _fdt_nodename_eq(const void *fdt, int offset,
- const char *s, int len)
+static int
+_fdt_nodename_eq (
+ const void *fdt,
+ int offset,
+ const char *s,
+ int len
+ )
{
- const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
+ const char *p = fdt_offset_ptr (fdt, offset + FDT_TAGSIZE, len+1);
- if (!p)
- /* short match */
- return 0;
+ if (!p) {
+ /* short match */
+ return 0;
+ }
- if (memcmp(p, s, len) != 0)
- return 0;
+ if (memcmp (p, s, len) != 0) {
+ return 0;
+ }
- if (p[len] == '\0')
- return 1;
- else if (!memchr(s, '@', len) && (p[len] == '@'))
- return 1;
- else
- return 0;
+ if (p[len] == '\0') {
+ return 1;
+ } else if (!memchr (s, '@', len) && (p[len] == '@')) {
+ return 1;
+ } else {
+ return 0;
+ }
}
-const char *fdt_string(const void *fdt, int stroffset)
+const char *
+fdt_string (
+ const void *fdt,
+ int stroffset
+ )
{
- return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
+ return (const char *)fdt + fdt_off_dt_strings (fdt) + stroffset;
}
-static int _fdt_string_eq(const void *fdt, int stroffset,
- const char *s, int len)
+static int
+_fdt_string_eq (
+ const void *fdt,
+ int stroffset,
+ const char *s,
+ int len
+ )
{
- const char *p = fdt_string(fdt, stroffset);
+ const char *p = fdt_string (fdt, stroffset);
- return (strlen(p) == len) && (memcmp(p, s, len) == 0);
+ return (strlen (p) == len) && (memcmp (p, s, len) == 0);
}
-uint32_t fdt_get_max_phandle(const void *fdt)
+uint32_t
+fdt_get_max_phandle (
+ const void *fdt
+ )
{
- uint32_t max_phandle = 0;
- int offset;
+ uint32_t max_phandle = 0;
+ int offset;
- for (offset = fdt_next_node(fdt, -1, NULL);;
- offset = fdt_next_node(fdt, offset, NULL)) {
- uint32_t phandle;
+ for (offset = fdt_next_node (fdt, -1, NULL); ;
+ offset = fdt_next_node (fdt, offset, NULL))
+ {
+ uint32_t phandle;
- if (offset == -FDT_ERR_NOTFOUND)
- return max_phandle;
+ if (offset == -FDT_ERR_NOTFOUND) {
+ return max_phandle;
+ }
- if (offset < 0)
- return (uint32_t)-1;
+ if (offset < 0) {
+ return (uint32_t)-1;
+ }
- phandle = fdt_get_phandle(fdt, offset);
- if (phandle == (uint32_t)-1)
- continue;
+ phandle = fdt_get_phandle (fdt, offset);
+ if (phandle == (uint32_t)-1) {
+ continue;
+ }
- if (phandle > max_phandle)
- max_phandle = phandle;
- }
+ if (phandle > max_phandle) {
+ max_phandle = phandle;
+ }
+ }
- return 0;
+ return 0;
}
-int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
+int
+fdt_get_mem_rsv (
+ const void *fdt,
+ int n,
+ uint64_t *address,
+ uint64_t *size
+ )
{
- FDT_CHECK_HEADER(fdt);
- *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
- *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
- return 0;
+ FDT_CHECK_HEADER (fdt);
+ *address = fdt64_to_cpu (_fdt_mem_rsv (fdt, n)->address);
+ *size = fdt64_to_cpu (_fdt_mem_rsv (fdt, n)->size);
+ return 0;
}
-int fdt_num_mem_rsv(const void *fdt)
+int
+fdt_num_mem_rsv (
+ const void *fdt
+ )
{
- int i = 0;
+ int i = 0;
- while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)
- i++;
- return i;
-}
-
-static int _nextprop(const void *fdt, int offset)
-{
- uint32_t tag;
- int nextoffset;
-
- do {
- tag = fdt_next_tag(fdt, offset, &nextoffset);
-
- switch (tag) {
- case FDT_END:
- if (nextoffset >= 0)
- return -FDT_ERR_BADSTRUCTURE;
- else
- return nextoffset;
+ while (fdt64_to_cpu (_fdt_mem_rsv (fdt, i)->size) != 0) {
+ i++;
+ }
- case FDT_PROP:
- return offset;
- }
- offset = nextoffset;
- } while (tag == FDT_NOP);
-
- return -FDT_ERR_NOTFOUND;
+ return i;
}
-int fdt_subnode_offset_namelen(const void *fdt, int offset,
- const char *name, int namelen)
+static int
+_nextprop (
+ const void *fdt,
+ int offset
+ )
{
- int depth;
-
- FDT_CHECK_HEADER(fdt);
-
- for (depth = 0;
- (offset >= 0) && (depth >= 0);
- offset = fdt_next_node(fdt, offset, &depth))
- if ((depth == 1)
- && _fdt_nodename_eq(fdt, offset, name, namelen))
- return offset;
-
- if (depth < 0)
- return -FDT_ERR_NOTFOUND;
- return offset; /* error */
-}
-
-int fdt_subnode_offset(const void *fdt, int parentoffset,
- const char *name)
-{
- return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
-}
-
-int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen)
-{
- const char *end = path + namelen;
- const char *p = path;
- int offset = 0;
-
- FDT_CHECK_HEADER(fdt);
-
- /* see if we have an alias */
- if (*path != '/') {
- const char *q = memchr(path, '/', end - p);
+ uint32_t tag;
+ int nextoffset;
- if (!q)
- q = end;
+ do {
+ tag = fdt_next_tag (fdt, offset, &nextoffset);
- p = fdt_get_alias_namelen(fdt, p, q - p);
- if (!p)
- return -FDT_ERR_BADPATH;
- offset = fdt_path_offset(fdt, p);
+ switch (tag) {
+ case FDT_END:
+ if (nextoffset >= 0) {
+ return -FDT_ERR_BADSTRUCTURE;
+ } else {
+ return nextoffset;
+ }
- p = q;
- }
+ case FDT_PROP:
+ return offset;
+ }
- while (p < end) {
- const char *q;
+ offset = nextoffset;
+ } while (tag == FDT_NOP);
- while (*p == '/') {
- p++;
- if (p == end)
- return offset;
- }
- q = memchr(p, '/', end - p);
- if (! q)
- q = end;
-
- offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
- if (offset < 0)
- return offset;
-
- p = q;
- }
-
- return offset;
+ return -FDT_ERR_NOTFOUND;
}
-int fdt_path_offset(const void *fdt, const char *path)
+int
+fdt_subnode_offset_namelen (
+ const void *fdt,
+ int offset,
+ const char *name,
+ int namelen
+ )
{
- return fdt_path_offset_namelen(fdt, path, strlen(path));
-}
+ int depth;
-const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
-{
- const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset);
- int err;
+ FDT_CHECK_HEADER (fdt);
- if (((err = fdt_check_header(fdt)) != 0)
- || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))
- goto fail;
+ for (depth = 0;
+ (offset >= 0) && (depth >= 0);
+ offset = fdt_next_node (fdt, offset, &depth))
+ {
+ if ( (depth == 1)
+ && _fdt_nodename_eq (fdt, offset, name, namelen))
+ {
+ return offset;
+ }
+ }
- if (len)
- *len = strlen(nh->name);
+ if (depth < 0) {
+ return -FDT_ERR_NOTFOUND;
+ }
- return nh->name;
-
- fail:
- if (len)
- *len = err;
- return NULL;
+ return offset; /* error */
}
-int fdt_first_property_offset(const void *fdt, int nodeoffset)
+int
+fdt_subnode_offset (
+ const void *fdt,
+ int parentoffset,
+ const char *name
+ )
{
- int offset;
-
- if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
- return offset;
-
- return _nextprop(fdt, offset);
+ return fdt_subnode_offset_namelen (fdt, parentoffset, name, strlen (name));
}
-int fdt_next_property_offset(const void *fdt, int offset)
+int
+fdt_path_offset_namelen (
+ const void *fdt,
+ const char *path,
+ int namelen
+ )
{
- if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0)
- return offset;
+ const char *end = path + namelen;
+ const char *p = path;
+ int offset = 0;
- return _nextprop(fdt, offset);
-}
+ FDT_CHECK_HEADER (fdt);
-const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
- int offset,
- int *lenp)
-{
- int err;
- const struct fdt_property *prop;
-
- if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {
- if (lenp)
- *lenp = err;
- return NULL;
- }
+ /* see if we have an alias */
+ if (*path != '/') {
+ const char *q = memchr (path, '/', end - p);
- prop = _fdt_offset_ptr(fdt, offset);
+ if (!q) {
+ q = end;
+ }
- if (lenp)
- *lenp = fdt32_to_cpu(prop->len);
+ p = fdt_get_alias_namelen (fdt, p, q - p);
+ if (!p) {
+ return -FDT_ERR_BADPATH;
+ }
- return prop;
-}
+ offset = fdt_path_offset (fdt, p);
-const struct fdt_property *fdt_get_property_namelen(const void *fdt,
- int offset,
- const char *name,
- int namelen, int *lenp)
-{
- for (offset = fdt_first_property_offset(fdt, offset);
- (offset >= 0);
- (offset = fdt_next_property_offset(fdt, offset))) {
- const struct fdt_property *prop;
+ p = q;
+ }
- if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) {
- offset = -FDT_ERR_INTERNAL;
- break;
- }
- if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
- name, namelen))
- return prop;
- }
+ while (p < end) {
+ const char *q;
- if (lenp)
- *lenp = offset;
- return NULL;
-}
+ while (*p == '/') {
+ p++;
+ if (p == end) {
+ return offset;
+ }
+ }
-const struct fdt_property *fdt_get_property(const void *fdt,
- int nodeoffset,
- const char *name, int *lenp)
-{
- return fdt_get_property_namelen(fdt, nodeoffset, name,
- strlen(name), lenp);
-}
+ q = memchr (p, '/', end - p);
+ if (!q) {
+ q = end;
+ }
-const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
- const char *name, int namelen, int *lenp)
-{
- const struct fdt_property *prop;
+ offset = fdt_subnode_offset_namelen (fdt, offset, p, q-p);
+ if (offset < 0) {
+ return offset;
+ }
- prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
- if (!prop)
- return NULL;
+ p = q;
+ }
- return prop->data;
+ return offset;
}
-const void *fdt_getprop_by_offset(const void *fdt, int offset,
- const char **namep, int *lenp)
+int
+fdt_path_offset (
+ const void *fdt,
+ const char *path
+ )
{
- const struct fdt_property *prop;
-
- prop = fdt_get_property_by_offset(fdt, offset, lenp);
- if (!prop)
- return NULL;
- if (namep)
- *namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
- return prop->data;
+ return fdt_path_offset_namelen (fdt, path, strlen (path));
}
-const void *fdt_getprop(const void *fdt, int nodeoffset,
- const char *name, int *lenp)
+const char *
+fdt_get_name (
+ const void *fdt,
+ int nodeoffset,
+ int *len
+ )
{
- return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
-}
+ const struct fdt_node_header *nh = _fdt_offset_ptr (fdt, nodeoffset);
+ int err;
-uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
-{
- const fdt32_t *php;
- int len;
+ if ( ((err = fdt_check_header (fdt)) != 0)
+ || ((err = _fdt_check_node_offset (fdt, nodeoffset)) < 0))
+ {
+ goto fail;
+ }
- /* FIXME: This is a bit sub-optimal, since we potentially scan
- * over all the properties twice. */
- php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
- if (!php || (len != sizeof(*php))) {
- php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
- if (!php || (len != sizeof(*php)))
- return 0;
- }
+ if (len) {
+ *len = strlen (nh->name);
+ }
- return fdt32_to_cpu(*php);
-}
+ return nh->name;
-const char *fdt_get_alias_namelen(const void *fdt,
- const char *name, int namelen)
-{
- int aliasoffset;
+fail:
+ if (len) {
+ *len = err;
+ }
- aliasoffset = fdt_path_offset(fdt, "/aliases");
- if (aliasoffset < 0)
- return NULL;
-
- return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);
-}
-
-const char *fdt_get_alias(const void *fdt, const char *name)
-{
- return fdt_get_alias_namelen(fdt, name, strlen(name));
+ return NULL;
}
-int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
+int
+fdt_first_property_offset (
+ const void *fdt,
+ int nodeoffset
+ )
{
- int pdepth = 0, p = 0;
- int offset, depth, namelen;
- const char *name;
+ int offset;
- FDT_CHECK_HEADER(fdt);
+ if ((offset = _fdt_check_node_offset (fdt, nodeoffset)) < 0) {
+ return offset;
+ }
- if (buflen < 2)
- return -FDT_ERR_NOSPACE;
-
- for (offset = 0, depth = 0;
- (offset >= 0) && (offset <= nodeoffset);
- offset = fdt_next_node(fdt, offset, &depth)) {
- while (pdepth > depth) {
- do {
- p--;
- } while (buf[p-1] != '/');
- pdepth--;
- }
-
- if (pdepth >= depth) {
- name = fdt_get_name(fdt, offset, &namelen);
- if (!name)
- return namelen;
- if ((p + namelen + 1) <= buflen) {
- memcpy(buf + p, name, namelen);
- p += namelen;
- buf[p++] = '/';
- pdepth++;
- }
- }
-
- if (offset == nodeoffset) {
- if (pdepth < (depth + 1))
- return -FDT_ERR_NOSPACE;
-
- if (p > 1) /* special case so that root path is "/", not "" */
- p--;
- buf[p] = '\0';
- return 0;
- }
- }
-
- if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
- return -FDT_ERR_BADOFFSET;
- else if (offset == -FDT_ERR_BADOFFSET)
- return -FDT_ERR_BADSTRUCTURE;
-
- return offset; /* error from fdt_next_node() */
+ return _nextprop (fdt, offset);
}
-int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
- int supernodedepth, int *nodedepth)
+int
+fdt_next_property_offset (
+ const void *fdt,
+ int offset
+ )
{
- int offset, depth;
- int supernodeoffset = -FDT_ERR_INTERNAL;
-
- FDT_CHECK_HEADER(fdt);
-
- if (supernodedepth < 0)
- return -FDT_ERR_NOTFOUND;
+ if ((offset = _fdt_check_prop_offset (fdt, offset)) < 0) {
+ return offset;
+ }
- for (offset = 0, depth = 0;
- (offset >= 0) && (offset <= nodeoffset);
- offset = fdt_next_node(fdt, offset, &depth)) {
- if (depth == supernodedepth)
- supernodeoffset = offset;
-
- if (offset == nodeoffset) {
- if (nodedepth)
- *nodedepth = depth;
-
- if (supernodedepth > depth)
- return -FDT_ERR_NOTFOUND;
- else
- return supernodeoffset;
- }
- }
-
- if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
- return -FDT_ERR_BADOFFSET;
- else if (offset == -FDT_ERR_BADOFFSET)
- return -FDT_ERR_BADSTRUCTURE;
-
- return offset; /* error from fdt_next_node() */
-}
-
-int fdt_node_depth(const void *fdt, int nodeoffset)
-{
- int nodedepth;
- int err;
-
- err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
- if (err)
- return (err < 0) ? err : -FDT_ERR_INTERNAL;
- return nodedepth;
+ return _nextprop (fdt, offset);
}
-int fdt_parent_offset(const void *fdt, int nodeoffset)
+const struct fdt_property *
+fdt_get_property_by_offset (
+ const void *fdt,
+ int offset,
+ int *lenp
+ )
{
- int nodedepth = fdt_node_depth(fdt, nodeoffset);
+ int err;
+ const struct fdt_property *prop;
- if (nodedepth < 0)
- return nodedepth;
- return fdt_supernode_atdepth_offset(fdt, nodeoffset,
- nodedepth - 1, NULL);
-}
+ if ((err = _fdt_check_prop_offset (fdt, offset)) < 0) {
+ if (lenp) {
+ *lenp = err;
+ }
-int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
- const char *propname,
- const void *propval, int proplen)
-{
- int offset;
- const void *val;
- int len;
+ return NULL;
+ }
- FDT_CHECK_HEADER(fdt);
+ prop = _fdt_offset_ptr (fdt, offset);
- /* FIXME: The algorithm here is pretty horrible: we scan each
- * property of a node in fdt_getprop(), then if that didn't
- * find what we want, we scan over them again making our way
- * to the next node. Still it's the easiest to implement
- * approach; performance can come later. */
- for (offset = fdt_next_node(fdt, startoffset, NULL);
- offset >= 0;
- offset = fdt_next_node(fdt, offset, NULL)) {
- val = fdt_getprop(fdt, offset, propname, &len);
- if (val && (len == proplen)
- && (memcmp(val, propval, len) == 0))
- return offset;
- }
+ if (lenp) {
+ *lenp = fdt32_to_cpu (prop->len);
+ }
- return offset; /* error from fdt_next_node() */
+ return prop;
}
-int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
+const struct fdt_property *
+fdt_get_property_namelen (
+ const void *fdt,
+ int offset,
+ const char *name,
+ int namelen,
+ int *lenp
+ )
{
- int offset;
+ for (offset = fdt_first_property_offset (fdt, offset);
+ (offset >= 0);
+ (offset = fdt_next_property_offset (fdt, offset)))
+ {
+ const struct fdt_property *prop;
- if ((phandle == 0) || (phandle == -1))
- return -FDT_ERR_BADPHANDLE;
+ if (!(prop = fdt_get_property_by_offset (fdt, offset, lenp))) {
+ offset = -FDT_ERR_INTERNAL;
+ break;
+ }
- FDT_CHECK_HEADER(fdt);
+ if (_fdt_string_eq (
+ fdt,
+ fdt32_to_cpu (prop->nameoff),
+ name,
+ namelen
+ ))
+ {
+ return prop;
+ }
+ }
- /* FIXME: The algorithm here is pretty horrible: we
- * potentially scan each property of a node in
- * fdt_get_phandle(), then if that didn't find what
- * we want, we scan over them again making our way to the next
- * node. Still it's the easiest to implement approach;
- * performance can come later. */
- for (offset = fdt_next_node(fdt, -1, NULL);
- offset >= 0;
- offset = fdt_next_node(fdt, offset, NULL)) {
- if (fdt_get_phandle(fdt, offset) == phandle)
- return offset;
- }
+ if (lenp) {
+ *lenp = offset;
+ }
- return offset; /* error from fdt_next_node() */
+ return NULL;
}
-int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
+const struct fdt_property *
+fdt_get_property (
+ const void *fdt,
+ int nodeoffset,
+ const char *name,
+ int *lenp
+ )
{
- int len = strlen(str);
- const char *p;
-
- while (listlen >= len) {
- if (memcmp(str, strlist, len+1) == 0)
- return 1;
- p = memchr(strlist, '\0', listlen);
- if (!p)
- return 0; /* malformed strlist.. */
- listlen -= (p-strlist) + 1;
- strlist = p + 1;
- }
- return 0;
+ return fdt_get_property_namelen (
+ fdt,
+ nodeoffset,
+ name,
+ strlen (name),
+ lenp
+ );
}
-int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property)
+const void *
+fdt_getprop_namelen (
+ const void *fdt,
+ int nodeoffset,
+ const char *name,
+ int namelen,
+ int *lenp
+ )
{
- const char *list, *end;
- int length, count = 0;
-
- list = fdt_getprop(fdt, nodeoffset, property, &length);
- if (!list)
- return length;
+ const struct fdt_property *prop;
- end = list + length;
+ prop = fdt_get_property_namelen (fdt, nodeoffset, name, namelen, lenp);
+ if (!prop) {
+ return NULL;
+ }
- while (list < end) {
- length = strnlen(list, end - list) + 1;
-
- /* Abort if the last string isn't properly NUL-terminated. */
- if (list + length > end)
- return -FDT_ERR_BADVALUE;
+ return prop->data;
+}
+
+const void *
+fdt_getprop_by_offset (
+ const void *fdt,
+ int offset,
+ const char **namep,
+ int *lenp
+ )
+{
+ const struct fdt_property *prop;
+
+ prop = fdt_get_property_by_offset (fdt, offset, lenp);
+ if (!prop) {
+ return NULL;
+ }
+
+ if (namep) {
+ *namep = fdt_string (fdt, fdt32_to_cpu (prop->nameoff));
+ }
+
+ return prop->data;
+}
+
+const void *
+fdt_getprop (
+ const void *fdt,
+ int nodeoffset,
+ const char *name,
+ int *lenp
+ )
+{
+ return fdt_getprop_namelen (fdt, nodeoffset, name, strlen (name), lenp);
+}
+
+uint32_t
+fdt_get_phandle (
+ const void *fdt,
+ int nodeoffset
+ )
+{
+ const fdt32_t *php;
+ int len;
+
+ /* FIXME: This is a bit sub-optimal, since we potentially scan
+ * over all the properties twice. */
+ php = fdt_getprop (fdt, nodeoffset, "phandle", &len);
+ if (!php || (len != sizeof (*php))) {
+ php = fdt_getprop (fdt, nodeoffset, "linux,phandle", &len);
+ if (!php || (len != sizeof (*php))) {
+ return 0;
+ }
+ }
+
+ return fdt32_to_cpu (*php);
+}
+
+const char *
+fdt_get_alias_namelen (
+ const void *fdt,
+ const char *name,
+ int namelen
+ )
+{
+ int aliasoffset;
+
+ aliasoffset = fdt_path_offset (fdt, "/aliases");
+ if (aliasoffset < 0) {
+ return NULL;
+ }
+
+ return fdt_getprop_namelen (fdt, aliasoffset, name, namelen, NULL);
+}
+
+const char *
+fdt_get_alias (
+ const void *fdt,
+ const char *name
+ )
+{
+ return fdt_get_alias_namelen (fdt, name, strlen (name));
+}
+
+int
+fdt_get_path (
+ const void *fdt,
+ int nodeoffset,
+ char *buf,
+ int buflen
+ )
+{
+ int pdepth = 0, p = 0;
+ int offset, depth, namelen;
+ const char *name;
+
+ FDT_CHECK_HEADER (fdt);
+
+ if (buflen < 2) {
+ return -FDT_ERR_NOSPACE;
+ }
+
+ for (offset = 0, depth = 0;
+ (offset >= 0) && (offset <= nodeoffset);
+ offset = fdt_next_node (fdt, offset, &depth))
+ {
+ while (pdepth > depth) {
+ do {
+ p--;
+ } while (buf[p-1] != '/');
+
+ pdepth--;
+ }
+
+ if (pdepth >= depth) {
+ name = fdt_get_name (fdt, offset, &namelen);
+ if (!name) {
+ return namelen;
+ }
+
+ if ((p + namelen + 1) <= buflen) {
+ memcpy (buf + p, name, namelen);
+ p += namelen;
+ buf[p++] = '/';
+ pdepth++;
+ }
+ }
+
+ if (offset == nodeoffset) {
+ if (pdepth < (depth + 1)) {
+ return -FDT_ERR_NOSPACE;
+ }
+
+ if (p > 1) {
+ /* special case so that root path is "/", not "" */
+ p--;
+ }
+
+ buf[p] = '\0';
+ return 0;
+ }
+ }
+
+ if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0)) {
+ return -FDT_ERR_BADOFFSET;
+ } else if (offset == -FDT_ERR_BADOFFSET) {
+ return -FDT_ERR_BADSTRUCTURE;
+ }
+
+ return offset; /* error from fdt_next_node() */
+}
+
+int
+fdt_supernode_atdepth_offset (
+ const void *fdt,
+ int nodeoffset,
+ int supernodedepth,
+ int *nodedepth
+ )
+{
+ int offset, depth;
+ int supernodeoffset = -FDT_ERR_INTERNAL;
+
+ FDT_CHECK_HEADER (fdt);
+
+ if (supernodedepth < 0) {
+ return -FDT_ERR_NOTFOUND;
+ }
+
+ for (offset = 0, depth = 0;
+ (offset >= 0) && (offset <= nodeoffset);
+ offset = fdt_next_node (fdt, offset, &depth))
+ {
+ if (depth == supernodedepth) {
+ supernodeoffset = offset;
+ }
+
+ if (offset == nodeoffset) {
+ if (nodedepth) {
+ *nodedepth = depth;
+ }
+
+ if (supernodedepth > depth) {
+ return -FDT_ERR_NOTFOUND;
+ } else {
+ return supernodeoffset;
+ }
+ }
+ }
+
+ if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0)) {
+ return -FDT_ERR_BADOFFSET;
+ } else if (offset == -FDT_ERR_BADOFFSET) {
+ return -FDT_ERR_BADSTRUCTURE;
+ }
+
+ return offset; /* error from fdt_next_node() */
+}
+
+int
+fdt_node_depth (
+ const void *fdt,
+ int nodeoffset
+ )
+{
+ int nodedepth;
+ int err;
+
+ err = fdt_supernode_atdepth_offset (fdt, nodeoffset, 0, &nodedepth);
+ if (err) {
+ return (err < 0) ? err : -FDT_ERR_INTERNAL;
+ }
+
+ return nodedepth;
+}
+
+int
+fdt_parent_offset (
+ const void *fdt,
+ int nodeoffset
+ )
+{
+ int nodedepth = fdt_node_depth (fdt, nodeoffset);
+
+ if (nodedepth < 0) {
+ return nodedepth;
+ }
+
+ return fdt_supernode_atdepth_offset (
+ fdt,
+ nodeoffset,
+ nodedepth - 1,
+ NULL
+ );
+}
+
+int
+fdt_node_offset_by_prop_value (
+ const void *fdt,
+ int startoffset,
+ const char *propname,
+ const void *propval,
+ int proplen
+ )
+{
+ int offset;
+ const void *val;
+ int len;
+
+ FDT_CHECK_HEADER (fdt);
+
+ /* FIXME: The algorithm here is pretty horrible: we scan each
+ * property of a node in fdt_getprop(), then if that didn't
+ * find what we want, we scan over them again making our way
+ * to the next node. Still it's the easiest to implement
+ * approach; performance can come later. */
+ for (offset = fdt_next_node (fdt, startoffset, NULL);
+ offset >= 0;
+ offset = fdt_next_node (fdt, offset, NULL))
+ {
+ val = fdt_getprop (fdt, offset, propname, &len);
+ if ( val && (len == proplen)
+ && (memcmp (val, propval, len) == 0))
+ {
+ return offset;
+ }
+ }
+
+ return offset; /* error from fdt_next_node() */
+}
+
+int
+fdt_node_offset_by_phandle (
+ const void *fdt,
+ uint32_t phandle
+ )
+{
+ int offset;
+
+ if ((phandle == 0) || (phandle == -1)) {
+ return -FDT_ERR_BADPHANDLE;
+ }
+
+ FDT_CHECK_HEADER (fdt);
+
+ /* FIXME: The algorithm here is pretty horrible: we
+ * potentially scan each property of a node in
+ * fdt_get_phandle(), then if that didn't find what
+ * we want, we scan over them again making our way to the next
+ * node. Still it's the easiest to implement approach;
+ * performance can come later. */
+ for (offset = fdt_next_node (fdt, -1, NULL);
+ offset >= 0;
+ offset = fdt_next_node (fdt, offset, NULL))
+ {
+ if (fdt_get_phandle (fdt, offset) == phandle) {
+ return offset;
+ }
+ }
+
+ return offset; /* error from fdt_next_node() */
+}
+
+int
+fdt_stringlist_contains (
+ const char *strlist,
+ int listlen,
+ const char *str
+ )
+{
+ int len = strlen (str);
+ const char *p;
+
+ while (listlen >= len) {
+ if (memcmp (str, strlist, len+1) == 0) {
+ return 1;
+ }
+
+ p = memchr (strlist, '\0', listlen);
+ if (!p) {
+ return 0; /* malformed strlist.. */
+ }
+
+ listlen -= (p-strlist) + 1;
+ strlist = p + 1;
+ }
+
+ return 0;
+}
+
+int
+fdt_stringlist_count (
+ const void *fdt,
+ int nodeoffset,
+ const char *property
+ )
+{
+ const char *list, *end;
+ int length, count = 0;
+
+ list = fdt_getprop (fdt, nodeoffset, property, &length);
+ if (!list) {
+ return length;
+ }
+
+ end = list + length;
+
+ while (list < end) {
+ length = strnlen (list, end - list) + 1;
+
+ /* Abort if the last string isn't properly NUL-terminated. */
+ if (list + length > end) {
+ return -FDT_ERR_BADVALUE;
+ }
- list += length;
- count++;
- }
+ list += length;
+ count++;
+ }
- return count;
+ return count;
}
-int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
- const char *string)
+int
+fdt_stringlist_search (
+ const void *fdt,
+ int nodeoffset,
+ const char *property,
+ const char *string
+ )
{
- int length, len, idx = 0;
- const char *list, *end;
+ int length, len, idx = 0;
+ const char *list, *end;
- list = fdt_getprop(fdt, nodeoffset, property, &length);
- if (!list)
- return length;
+ list = fdt_getprop (fdt, nodeoffset, property, &length);
+ if (!list) {
+ return length;
+ }
- len = strlen(string) + 1;
- end = list + length;
+ len = strlen (string) + 1;
+ end = list + length;
- while (list < end) {
- length = strnlen(list, end - list) + 1;
+ while (list < end) {
+ length = strnlen (list, end - list) + 1;
- /* Abort if the last string isn't properly NUL-terminated. */
- if (list + length > end)
- return -FDT_ERR_BADVALUE;
+ /* Abort if the last string isn't properly NUL-terminated. */
+ if (list + length > end) {
+ return -FDT_ERR_BADVALUE;
+ }
- if (length == len && memcmp(list, string, length) == 0)
- return idx;
+ if ((length == len) && (memcmp (list, string, length) == 0)) {
+ return idx;
+ }
- list += length;
- idx++;
- }
+ list += length;
+ idx++;
+ }
- return -FDT_ERR_NOTFOUND;
+ return -FDT_ERR_NOTFOUND;
}
-const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
- const char *property, int idx,
- int *lenp)
+const char *
+fdt_stringlist_get (
+ const void *fdt,
+ int nodeoffset,
+ const char *property,
+ int idx,
+ int *lenp
+ )
{
- const char *list, *end;
- int length;
+ const char *list, *end;
+ int length;
- list = fdt_getprop(fdt, nodeoffset, property, &length);
- if (!list) {
- if (lenp)
- *lenp = length;
+ list = fdt_getprop (fdt, nodeoffset, property, &length);
+ if (!list) {
+ if (lenp) {
+ *lenp = length;
+ }
- return NULL;
- }
+ return NULL;
+ }
- end = list + length;
+ end = list + length;
- while (list < end) {
- length = strnlen(list, end - list) + 1;
+ while (list < end) {
+ length = strnlen (list, end - list) + 1;
- /* Abort if the last string isn't properly NUL-terminated. */
- if (list + length > end) {
- if (lenp)
- *lenp = -FDT_ERR_BADVALUE;
+ /* Abort if the last string isn't properly NUL-terminated. */
+ if (list + length > end) {
+ if (lenp) {
+ *lenp = -FDT_ERR_BADVALUE;
+ }
- return NULL;
- }
+ return NULL;
+ }
- if (idx == 0) {
- if (lenp)
- *lenp = length - 1;
+ if (idx == 0) {
+ if (lenp) {
+ *lenp = length - 1;
+ }
- return list;
- }
+ return list;
+ }
- list += length;
- idx--;
- }
+ list += length;
+ idx--;
+ }
- if (lenp)
- *lenp = -FDT_ERR_NOTFOUND;
+ if (lenp) {
+ *lenp = -FDT_ERR_NOTFOUND;
+ }
- return NULL;
+ return NULL;
}
-int fdt_node_check_compatible(const void *fdt, int nodeoffset,
- const char *compatible)
+int
+fdt_node_check_compatible (
+ const void *fdt,
+ int nodeoffset,
+ const char *compatible
+ )
{
- const void *prop;
- int len;
+ const void *prop;
+ int len;
+
+ prop = fdt_getprop (fdt, nodeoffset, "compatible", &len);
+ if (!prop) {
+ return len;
+ }
- prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
- if (!prop)
- return len;
-
- return !fdt_stringlist_contains(prop, len, compatible);
+ return !fdt_stringlist_contains (prop, len, compatible);
}
-int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
- const char *compatible)
+int
+fdt_node_offset_by_compatible (
+ const void *fdt,
+ int startoffset,
+ const char *compatible
+ )
{
- int offset, err;
-
- FDT_CHECK_HEADER(fdt);
+ int offset, err;
- /* FIXME: The algorithm here is pretty horrible: we scan each
- * property of a node in fdt_node_check_compatible(), then if
- * that didn't find what we want, we scan over them again
- * making our way to the next node. Still it's the easiest to
- * implement approach; performance can come later. */
- for (offset = fdt_next_node(fdt, startoffset, NULL);
- offset >= 0;
- offset = fdt_next_node(fdt, offset, NULL)) {
- err = fdt_node_check_compatible(fdt, offset, compatible);
- if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
- return err;
- else if (err == 0)
- return offset;
- }
+ FDT_CHECK_HEADER (fdt);
- return offset; /* error from fdt_next_node() */
+ /* FIXME: The algorithm here is pretty horrible: we scan each
+ * property of a node in fdt_node_check_compatible(), then if
+ * that didn't find what we want, we scan over them again
+ * making our way to the next node. Still it's the easiest to
+ * implement approach; performance can come later. */
+ for (offset = fdt_next_node (fdt, startoffset, NULL);
+ offset >= 0;
+ offset = fdt_next_node (fdt, offset, NULL))
+ {
+ err = fdt_node_check_compatible (fdt, offset, compatible);
+ if ((err < 0) && (err != -FDT_ERR_NOTFOUND)) {
+ return err;
+ } else if (err == 0) {
+ return offset;
+ }
+ }
+
+ return offset; /* error from fdt_next_node() */
}
|