dtc: import latest upstream dtc

This updates scripts/dtc to commit 317a5d9 "dtc: zero out new label
objects" from git://git.jdl.com/software/dtc.git.

This adds features such as:
* /bits/ syntax for cell data.
* Math expressions within cell data.
* The ability to delete properties or nodes.
* Support for #line directives in the input file, which allows the use of
  cpp on *.dts.
* -i command-line option (/include/ path)
* -W/-E command-line options for error/warning control.
* Removal of spew to STDOUT containing the filename being compiled.
* Many additions to the libfdt API.

Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Jon Loeliger <jdl@jdl.com>
Signed-off-by: Rob Herring <rob.herring@calxeda.com>

1 files changed, 190 insertions, 85 deletions

diff --git a/scripts/dtc/libfdt/fdt_ro.c b/scripts/dtc/libfdt/fdt_ro.c
index 22e692919ff9..02b6d687537f 100644
--- a/scripts/dtc/libfdt/fdt_ro.c
+++ b/scripts/dtc/libfdt/fdt_ro.c
@@ -80,6 +80,14 @@ const char *fdt_string(const void *fdt, int 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)
+{
+        const char *p = fdt_string(fdt, stroffset);
+
+        return (strlen(p) == len) && (memcmp(p, s, len) == 0);
+}
+
 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
 {
         FDT_CHECK_HEADER(fdt);
@@ -97,6 +105,30 @@ int fdt_num_mem_rsv(const void *fdt)
         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;
+
+                case FDT_PROP:
+                        return offset;
+                }
+                offset = nextoffset;
+        } while (tag == FDT_NOP);
+
+        return -FDT_ERR_NOTFOUND;
+}
+
 int fdt_subnode_offset_namelen(const void *fdt, int offset,
                                const char *name, int namelen)
 {
@@ -104,20 +136,16 @@ int fdt_subnode_offset_namelen(const void *fdt, int offset,
 
         FDT_CHECK_HEADER(fdt);
 
-        for (depth = 0, offset = fdt_next_node(fdt, offset, &depth);
-             (offset >= 0) && (depth > 0);
-             offset = fdt_next_node(fdt, offset, &depth)) {
-                if (depth < 0)
-                        return -FDT_ERR_NOTFOUND;
-                else if ((depth == 1)
-                         && _fdt_nodename_eq(fdt, offset, name, namelen))
+        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 (offset < 0)
-                return offset; /* error */
-        else
+        if (depth < 0)
                 return -FDT_ERR_NOTFOUND;
+        return offset; /* error */
 }
 
 int fdt_subnode_offset(const void *fdt, int parentoffset,
@@ -134,8 +162,20 @@ int fdt_path_offset(const void *fdt, const char *path)
 
         FDT_CHECK_HEADER(fdt);
 
-        if (*path != '/')
-                return -FDT_ERR_BADPATH;
+        /* see if we have an alias */
+        if (*path != '/') {
+                const char *q = strchr(path, '/');
+
+                if (!q)
+                        q = end;
+
+                p = fdt_get_alias_namelen(fdt, p, q - p);
+                if (!p)
+                        return -FDT_ERR_BADPATH;
+                offset = fdt_path_offset(fdt, p);
+
+                p = q;
+        }
 
         while (*p) {
                 const char *q;
@@ -178,93 +218,142 @@ const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
         return NULL;
 }
 
-const struct fdt_property *fdt_get_property(const void *fdt,
-                                            int nodeoffset,
-                                            const char *name, int *lenp)
+int fdt_first_property_offset(const void *fdt, int nodeoffset)
+{
+        int offset;
+
+        if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
+                return offset;
+
+        return _nextprop(fdt, offset);
+}
+
+int fdt_next_property_offset(const void *fdt, int offset)
+{
+        if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0)
+                return offset;
+
+        return _nextprop(fdt, offset);
+}
+
+const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
+                                                      int offset,
+                                                      int *lenp)
 {
-        uint32_t tag;
-        const struct fdt_property *prop;
-        int namestroff;
-        int offset, nextoffset;
         int err;
+        const struct fdt_property *prop;
 
-        if (((err = fdt_check_header(fdt)) != 0)
-            || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))
-                        goto fail;
+        if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {
+                if (lenp)
+                        *lenp = err;
+                return NULL;
+        }
 
-        nextoffset = err;
-        do {
-                offset = nextoffset;
+        prop = _fdt_offset_ptr(fdt, offset);
 
-                tag = fdt_next_tag(fdt, offset, &nextoffset);
-                switch (tag) {
-                case FDT_END:
-                        err = -FDT_ERR_TRUNCATED;
-                        goto fail;
+        if (lenp)
+                *lenp = fdt32_to_cpu(prop->len);
 
-                case FDT_BEGIN_NODE:
-                case FDT_END_NODE:
-                case FDT_NOP:
-                        break;
+        return prop;
+}
 
-                case FDT_PROP:
-                        err = -FDT_ERR_BADSTRUCTURE;
-                        prop = fdt_offset_ptr(fdt, offset, sizeof(*prop));
-                        if (! prop)
-                                goto fail;
-                        namestroff = fdt32_to_cpu(prop->nameoff);
-                        if (strcmp(fdt_string(fdt, namestroff), name) == 0) {
-                                /* Found it! */
-                                int len = fdt32_to_cpu(prop->len);
-                                prop = fdt_offset_ptr(fdt, offset,
-                                                      sizeof(*prop)+len);
-                                if (! prop)
-                                        goto fail;
-
-                                if (lenp)
-                                        *lenp = len;
-
-                                return prop;
-                        }
-                        break;
+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;
 
-                default:
-                        err = -FDT_ERR_BADSTRUCTURE;
-                        goto fail;
+                if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) {
+                        offset = -FDT_ERR_INTERNAL;
+                        break;
                 }
-        } while ((tag != FDT_BEGIN_NODE) && (tag != FDT_END_NODE));
+                if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
+                                   name, namelen))
+                        return prop;
+        }
 
-        err = -FDT_ERR_NOTFOUND;
- fail:
         if (lenp)
-                *lenp = err;
+                *lenp = offset;
         return NULL;
 }
 
-const void *fdt_getprop(const void *fdt, int nodeoffset,
-                  const char *name, int *lenp)
+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);
+}
+
+const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
+                                const char *name, int namelen, int *lenp)
 {
         const struct fdt_property *prop;
 
-        prop = fdt_get_property(fdt, nodeoffset, name, lenp);
+        prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
         if (! prop)
                 return NULL;
 
         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 uint32_t *php;
         int len;
 
-        php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
-        if (!php || (len != sizeof(*php)))
-                return 0;
+        /* 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;
@@ -279,9 +368,6 @@ int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
         for (offset = 0, depth = 0;
              (offset >= 0) && (offset <= nodeoffset);
              offset = fdt_next_node(fdt, offset, &depth)) {
-                if (pdepth < depth)
-                        continue; /* overflowed buffer */
-
                 while (pdepth > depth) {
                         do {
                                 p--;
@@ -289,14 +375,16 @@ int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
                         pdepth--;
                 }
 
-                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 (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) {
@@ -306,7 +394,7 @@ int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
                         if (p > 1) /* special case so that root path is "/", not "" */
                                 p--;
                         buf[p] = '\0';
-                        return p;
+                        return 0;
                 }
         }
 
@@ -404,14 +492,31 @@ int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
 
 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
 {
+        int offset;
+
         if ((phandle == 0) || (phandle == -1))
                 return -FDT_ERR_BADPHANDLE;
-        phandle = cpu_to_fdt32(phandle);
-        return fdt_node_offset_by_prop_value(fdt, -1, "linux,phandle",
-                                             &phandle, sizeof(phandle));
+
+        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() */
 }
 
-static int _stringlist_contains(const char *strlist, int listlen, const char *str)
+static int _fdt_stringlist_contains(const char *strlist, int listlen,
+                                    const char *str)
 {
         int len = strlen(str);
         const char *p;
@@ -437,7 +542,7 @@ int fdt_node_check_compatible(const void *fdt, int nodeoffset,
         prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
         if (!prop)
                 return len;
-        if (_stringlist_contains(prop, len, compatible))
+        if (_fdt_stringlist_contains(prop, len, compatible))
                 return 0;
         else
                 return 1;