Move dtc and libfdt sources from arch/powerpc/boot to scripts/dtc

The powerpc kernel always requires an Open Firmware like device tree
to supply device information.  On systems without OF, this comes from
a flattened device tree blob.  This blob is usually generated by dtc,
a tool which compiles a text description of the device tree into the
flattened format used by the kernel.  Sometimes, the bootwrapper makes
small changes to the pre-compiled device tree blob (e.g. filling in
the size of RAM).  To do this it uses the libfdt library.

Because these are only used on powerpc, the code for both these tools
is included under arch/powerpc/boot (these were imported and are
periodically updated from the upstream dtc tree).

However, the microblaze architecture, currently being prepared for
merging to mainline also uses dtc to produce device tree blobs.  A few
other archs have also mentioned some interest in using dtc.
Therefore, this patch moves dtc and libfdt from arch/powerpc into
scripts, where it can be used by any architecture.

The vast bulk of this patch is a literal move, the rest is adjusting
the various Makefiles to use dtc and libfdt correctly from their new
locations.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 321 insertions, 0 deletions

diff --git a/scripts/dtc/data.c b/scripts/dtc/data.c
new file mode 100644
index 000000000000..dd2e3d39d4c1
--- /dev/null
+++ b/scripts/dtc/data.c
@@ -0,0 +1,321 @@
+/*
+ * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
+ *
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
+ *                                                                   USA
+ */
+
+#include "dtc.h"
+
+void data_free(struct data d)
+{
+        struct marker *m, *nm;
+
+        m = d.markers;
+        while (m) {
+                nm = m->next;
+                free(m->ref);
+                free(m);
+                m = nm;
+        }
+
+        if (d.val)
+                free(d.val);
+}
+
+struct data data_grow_for(struct data d, int xlen)
+{
+        struct data nd;
+        int newsize;
+
+        if (xlen == 0)
+                return d;
+
+        nd = d;
+
+        newsize = xlen;
+
+        while ((d.len + xlen) > newsize)
+                newsize *= 2;
+
+        nd.val = xrealloc(d.val, newsize);
+
+        return nd;
+}
+
+struct data data_copy_mem(const char *mem, int len)
+{
+        struct data d;
+
+        d = data_grow_for(empty_data, len);
+
+        d.len = len;
+        memcpy(d.val, mem, len);
+
+        return d;
+}
+
+static char get_oct_char(const char *s, int *i)
+{
+        char x[4];
+        char *endx;
+        long val;
+
+        x[3] = '\0';
+        strncpy(x, s + *i, 3);
+
+        val = strtol(x, &endx, 8);
+
+        assert(endx > x);
+
+        (*i) += endx - x;
+        return val;
+}
+
+static char get_hex_char(const char *s, int *i)
+{
+        char x[3];
+        char *endx;
+        long val;
+
+        x[2] = '\0';
+        strncpy(x, s + *i, 2);
+
+        val = strtol(x, &endx, 16);
+        if (!(endx  > x))
+                die("\\x used with no following hex digits\n");
+
+        (*i) += endx - x;
+        return val;
+}
+
+struct data data_copy_escape_string(const char *s, int len)
+{
+        int i = 0;
+        struct data d;
+        char *q;
+
+        d = data_grow_for(empty_data, strlen(s)+1);
+
+        q = d.val;
+        while (i < len) {
+                char c = s[i++];
+
+                if (c != '\\') {
+                        q[d.len++] = c;
+                        continue;
+                }
+
+                c = s[i++];
+                assert(c);
+                switch (c) {
+                case 'a':
+                        q[d.len++] = '\a';
+                        break;
+                case 'b':
+                        q[d.len++] = '\b';
+                        break;
+                case 't':
+                        q[d.len++] = '\t';
+                        break;
+                case 'n':
+                        q[d.len++] = '\n';
+                        break;
+                case 'v':
+                        q[d.len++] = '\v';
+                        break;
+                case 'f':
+                        q[d.len++] = '\f';
+                        break;
+                case 'r':
+                        q[d.len++] = '\r';
+                        break;
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                        i--; /* need to re-read the first digit as
+                              * part of the octal value */
+                        q[d.len++] = get_oct_char(s, &i);
+                        break;
+                case 'x':
+                        q[d.len++] = get_hex_char(s, &i);
+                        break;
+                default:
+                        q[d.len++] = c;
+                }
+        }
+
+        q[d.len++] = '\0';
+        return d;
+}
+
+struct data data_copy_file(FILE *f, size_t maxlen)
+{
+        struct data d = empty_data;
+
+        while (!feof(f) && (d.len < maxlen)) {
+                size_t chunksize, ret;
+
+                if (maxlen == -1)
+                        chunksize = 4096;
+                else
+                        chunksize = maxlen - d.len;
+
+                d = data_grow_for(d, chunksize);
+                ret = fread(d.val + d.len, 1, chunksize, f);
+
+                if (ferror(f))
+                        die("Error reading file into data: %s", strerror(errno));
+
+                if (d.len + ret < d.len)
+                        die("Overflow reading file into data\n");
+
+                d.len += ret;
+        }
+
+        return d;
+}
+
+struct data data_append_data(struct data d, const void *p, int len)
+{
+        d = data_grow_for(d, len);
+        memcpy(d.val + d.len, p, len);
+        d.len += len;
+        return d;
+}
+
+struct data data_insert_at_marker(struct data d, struct marker *m,
+                                  const void *p, int len)
+{
+        d = data_grow_for(d, len);
+        memmove(d.val + m->offset + len, d.val + m->offset, d.len - m->offset);
+        memcpy(d.val + m->offset, p, len);
+        d.len += len;
+
+        /* Adjust all markers after the one we're inserting at */
+        m = m->next;
+        for_each_marker(m)
+                m->offset += len;
+        return d;
+}
+
+struct data data_append_markers(struct data d, struct marker *m)
+{
+        struct marker **mp = &d.markers;
+
+        /* Find the end of the markerlist */
+        while (*mp)
+                mp = &((*mp)->next);
+        *mp = m;
+        return d;
+}
+
+struct data data_merge(struct data d1, struct data d2)
+{
+        struct data d;
+        struct marker *m2 = d2.markers;
+
+        d = data_append_markers(data_append_data(d1, d2.val, d2.len), m2);
+
+        /* Adjust for the length of d1 */
+        for_each_marker(m2)
+                m2->offset += d1.len;
+
+        d2.markers = NULL; /* So data_free() doesn't clobber them */
+        data_free(d2);
+
+        return d;
+}
+
+struct data data_append_cell(struct data d, cell_t word)
+{
+        cell_t beword = cpu_to_fdt32(word);
+
+        return data_append_data(d, &beword, sizeof(beword));
+}
+
+struct data data_append_re(struct data d, const struct fdt_reserve_entry *re)
+{
+        struct fdt_reserve_entry bere;
+
+        bere.address = cpu_to_fdt64(re->address);
+        bere.size = cpu_to_fdt64(re->size);
+
+        return data_append_data(d, &bere, sizeof(bere));
+}
+
+struct data data_append_addr(struct data d, uint64_t addr)
+{
+        uint64_t beaddr = cpu_to_fdt64(addr);
+
+        return data_append_data(d, &beaddr, sizeof(beaddr));
+}
+
+struct data data_append_byte(struct data d, uint8_t byte)
+{
+        return data_append_data(d, &byte, 1);
+}
+
+struct data data_append_zeroes(struct data d, int len)
+{
+        d = data_grow_for(d, len);
+
+        memset(d.val + d.len, 0, len);
+        d.len += len;
+        return d;
+}
+
+struct data data_append_align(struct data d, int align)
+{
+        int newlen = ALIGN(d.len, align);
+        return data_append_zeroes(d, newlen - d.len);
+}
+
+struct data data_add_marker(struct data d, enum markertype type, char *ref)
+{
+        struct marker *m;
+
+        m = xmalloc(sizeof(*m));
+        m->offset = d.len;
+        m->type = type;
+        m->ref = ref;
+        m->next = NULL;
+
+        return data_append_markers(d, m);
+}
+
+int data_is_one_string(struct data d)
+{
+        int i;
+        int len = d.len;
+
+        if (len == 0)
+                return 0;
+
+        for (i = 0; i < len-1; i++)
+                if (d.val[i] == '\0')
+                        return 0;
+
+        if (d.val[len-1] != '\0')
+                return 0;
+
+        return 1;
+}