scripts/dtc: Update to upstream version v1.4.6-9-gaadd0b65c987

[u-boot] / scripts / dtc / libfdt / fdt_rw.c

diff --git a/scripts/dtc/libfdt/fdt_rw.c b/scripts/dtc/libfdt/fdt_rw.c
index 5c3a2bb0bc6bc3d208ca1bfd30b6c076db811202..9b829051e4447015aad9972270e299cab4dc3053 100644 (file)
--- a/scripts/dtc/libfdt/fdt_rw.c
+++ b/scripts/dtc/libfdt/fdt_rw.c
@@ -55,8 +55,8 @@
 
 #include "libfdt_internal.h"
 
-static int _fdt_blocks_misordered(const void *fdt,
-                             int mem_rsv_size, int struct_size)
+static int fdt_blocks_misordered_(const void *fdt,
+                                 int mem_rsv_size, int struct_size)
 {
        return (fdt_off_mem_rsvmap(fdt) < FDT_ALIGN(sizeof(struct fdt_header), 8))
                || (fdt_off_dt_struct(fdt) <
@@ -67,13 +67,13 @@ static int _fdt_blocks_misordered(const void *fdt,
                    (fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)));
 }
 
-static int _fdt_rw_check_header(void *fdt)
+static int fdt_rw_check_header_(void *fdt)
 {
        FDT_CHECK_HEADER(fdt);
 
        if (fdt_version(fdt) < 17)
                return -FDT_ERR_BADVERSION;
-       if (_fdt_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry),
+       if (fdt_blocks_misordered_(fdt, sizeof(struct fdt_reserve_entry),
                                   fdt_size_dt_struct(fdt)))
                return -FDT_ERR_BADLAYOUT;
        if (fdt_version(fdt) > 17)
@@ -84,20 +84,20 @@ static int _fdt_rw_check_header(void *fdt)
 
 #define FDT_RW_CHECK_HEADER(fdt) \
        { \
-               int __err; \
-               if ((__err = _fdt_rw_check_header(fdt)) != 0) \
-                       return __err; \
+               int err_; \
+               if ((err_ = fdt_rw_check_header_(fdt)) != 0) \
+                       return err_; \
        }
 
-static inline int _fdt_data_size(void *fdt)
+static inline int fdt_data_size_(void *fdt)
 {
        return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
 }
 
-static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
+static int fdt_splice_(void *fdt, void *splicepoint, int oldlen, int newlen)
 {
        char *p = splicepoint;
-       char *end = (char *)fdt + _fdt_data_size(fdt);
+       char *end = (char *)fdt + fdt_data_size_(fdt);
 
        if (((p + oldlen) < p) || ((p + oldlen) > end))
                return -FDT_ERR_BADOFFSET;
@@ -109,12 +109,12 @@ static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
        return 0;
 }
 
-static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,
+static int fdt_splice_mem_rsv_(void *fdt, struct fdt_reserve_entry *p,
                               int oldn, int newn)
 {
        int delta = (newn - oldn) * sizeof(*p);
        int err;
-       err = _fdt_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));
+       err = fdt_splice_(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));
        if (err)
                return err;
        fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta);
@@ -122,13 +122,13 @@ static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,
        return 0;
 }
 
-static int _fdt_splice_struct(void *fdt, void *p,
+static int fdt_splice_struct_(void *fdt, void *p,
                              int oldlen, int newlen)
 {
        int delta = newlen - oldlen;
        int err;
 
-       if ((err = _fdt_splice(fdt, p, oldlen, newlen)))
+       if ((err = fdt_splice_(fdt, p, oldlen, newlen)))
                return err;
 
        fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta);
@@ -136,20 +136,20 @@ static int _fdt_splice_struct(void *fdt, void *p,
        return 0;
 }
 
-static int _fdt_splice_string(void *fdt, int newlen)
+static int fdt_splice_string_(void *fdt, int newlen)
 {
        void *p = (char *)fdt
                + fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
        int err;
 
-       if ((err = _fdt_splice(fdt, p, 0, newlen)))
+       if ((err = fdt_splice_(fdt, p, 0, newlen)))
                return err;
 
        fdt_set_size_dt_strings(fdt, fdt_size_dt_strings(fdt) + newlen);
        return 0;
 }
 
-static int _fdt_find_add_string(void *fdt, const char *s)
+static int fdt_find_add_string_(void *fdt, const char *s)
 {
        char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
        const char *p;
@@ -157,13 +157,13 @@ static int _fdt_find_add_string(void *fdt, const char *s)
        int len = strlen(s) + 1;
        int err;
 
-       p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s);
+       p = fdt_find_string_(strtab, fdt_size_dt_strings(fdt), s);
        if (p)
                /* found it */
                return (p - strtab);
 
        new = strtab + fdt_size_dt_strings(fdt);
-       err = _fdt_splice_string(fdt, len);
+       err = fdt_splice_string_(fdt, len);
        if (err)
                return err;
 
@@ -178,8 +178,8 @@ int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)
 
        FDT_RW_CHECK_HEADER(fdt);
 
-       re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt));
-       err = _fdt_splice_mem_rsv(fdt, re, 0, 1);
+       re = fdt_mem_rsv_w_(fdt, fdt_num_mem_rsv(fdt));
+       err = fdt_splice_mem_rsv_(fdt, re, 0, 1);
        if (err)
                return err;
 
@@ -190,17 +190,17 @@ int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)
 
 int fdt_del_mem_rsv(void *fdt, int n)
 {
-       struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n);
+       struct fdt_reserve_entry *re = fdt_mem_rsv_w_(fdt, n);
 
        FDT_RW_CHECK_HEADER(fdt);
 
        if (n >= fdt_num_mem_rsv(fdt))
                return -FDT_ERR_NOTFOUND;
 
-       return _fdt_splice_mem_rsv(fdt, re, 1, 0);
+       return fdt_splice_mem_rsv_(fdt, re, 1, 0);
 }
 
-static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
+static int fdt_resize_property_(void *fdt, int nodeoffset, const char *name,
                                int len, struct fdt_property **prop)
 {
        int oldlen;
@@ -210,7 +210,7 @@ static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
        if (!*prop)
                return oldlen;
 
-       if ((err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),
+       if ((err = fdt_splice_struct_(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),
                                      FDT_TAGALIGN(len))))
                return err;
 
@@ -218,7 +218,7 @@ static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
        return 0;
 }
 
-static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,
+static int fdt_add_property_(void *fdt, int nodeoffset, const char *name,
                             int len, struct fdt_property **prop)
 {
        int proplen;
@@ -226,17 +226,17 @@ static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,
        int namestroff;
        int err;
 
-       if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
+       if ((nextoffset = fdt_check_node_offset_(fdt, nodeoffset)) < 0)
                return nextoffset;
 
-       namestroff = _fdt_find_add_string(fdt, name);
+       namestroff = fdt_find_add_string_(fdt, name);
        if (namestroff < 0)
                return namestroff;
 
-       *prop = _fdt_offset_ptr_w(fdt, nextoffset);
+       *prop = fdt_offset_ptr_w_(fdt, nextoffset);
        proplen = sizeof(**prop) + FDT_TAGALIGN(len);
 
-       err = _fdt_splice_struct(fdt, *prop, 0, proplen);
+       err = fdt_splice_struct_(fdt, *prop, 0, proplen);
        if (err)
                return err;
 
@@ -260,7 +260,7 @@ int fdt_set_name(void *fdt, int nodeoffset, const char *name)
 
        newlen = strlen(name);
 
-       err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1),
+       err = fdt_splice_struct_(fdt, namep, FDT_TAGALIGN(oldlen+1),
                                 FDT_TAGALIGN(newlen+1));
        if (err)
                return err;
@@ -277,9 +277,9 @@ int fdt_setprop_placeholder(void *fdt, int nodeoffset, const char *name,
 
        FDT_RW_CHECK_HEADER(fdt);
 
-       err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop);
+       err = fdt_resize_property_(fdt, nodeoffset, name, len, &prop);
        if (err == -FDT_ERR_NOTFOUND)
-               err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
+               err = fdt_add_property_(fdt, nodeoffset, name, len, &prop);
        if (err)
                return err;
 
@@ -313,7 +313,7 @@ int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
        prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
        if (prop) {
                newlen = len + oldlen;
-               err = _fdt_splice_struct(fdt, prop->data,
+               err = fdt_splice_struct_(fdt, prop->data,
                                         FDT_TAGALIGN(oldlen),
                                         FDT_TAGALIGN(newlen));
                if (err)
@@ -321,7 +321,7 @@ int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
                prop->len = cpu_to_fdt32(newlen);
                memcpy(prop->data + oldlen, val, len);
        } else {
-               err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
+               err = fdt_add_property_(fdt, nodeoffset, name, len, &prop);
                if (err)
                        return err;
                memcpy(prop->data, val, len);
@@ -341,7 +341,7 @@ int fdt_delprop(void *fdt, int nodeoffset, const char *name)
                return len;
 
        proplen = sizeof(*prop) + FDT_TAGALIGN(len);
-       return _fdt_splice_struct(fdt, prop, proplen, 0);
+       return fdt_splice_struct_(fdt, prop, proplen, 0);
 }
 
 int fdt_add_subnode_namelen(void *fdt, int parentoffset,
@@ -369,10 +369,10 @@ int fdt_add_subnode_namelen(void *fdt, int parentoffset,
                tag = fdt_next_tag(fdt, offset, &nextoffset);
        } while ((tag == FDT_PROP) || (tag == FDT_NOP));
 
-       nh = _fdt_offset_ptr_w(fdt, offset);
+       nh = fdt_offset_ptr_w_(fdt, offset);
        nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;
 
-       err = _fdt_splice_struct(fdt, nh, 0, nodelen);
+       err = fdt_splice_struct_(fdt, nh, 0, nodelen);
        if (err)
                return err;
 
@@ -396,15 +396,15 @@ int fdt_del_node(void *fdt, int nodeoffset)
 
        FDT_RW_CHECK_HEADER(fdt);
 
-       endoffset = _fdt_node_end_offset(fdt, nodeoffset);
+       endoffset = fdt_node_end_offset_(fdt, nodeoffset);
        if (endoffset < 0)
                return endoffset;
 
-       return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),
+       return fdt_splice_struct_(fdt, fdt_offset_ptr_w_(fdt, nodeoffset),
                                  endoffset - nodeoffset, 0);
 }
 
-static void _fdt_packblocks(const char *old, char *new,
+static void fdt_packblocks_(const char *old, char *new,
                            int mem_rsv_size, int struct_size)
 {
        int mem_rsv_off, struct_off, strings_off;
@@ -450,7 +450,7 @@ int fdt_open_into(const void *fdt, void *buf, int bufsize)
                        return struct_size;
        }
 
-       if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {
+       if (!fdt_blocks_misordered_(fdt, mem_rsv_size, struct_size)) {
                /* no further work necessary */
                err = fdt_move(fdt, buf, bufsize);
                if (err)
@@ -478,7 +478,7 @@ int fdt_open_into(const void *fdt, void *buf, int bufsize)
                        return -FDT_ERR_NOSPACE;
        }
 
-       _fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);
+       fdt_packblocks_(fdt, tmp, mem_rsv_size, struct_size);
        memmove(buf, tmp, newsize);
 
        fdt_set_magic(buf, FDT_MAGIC);
@@ -498,8 +498,8 @@ int fdt_pack(void *fdt)
 
        mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
                * sizeof(struct fdt_reserve_entry);
-       _fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
-       fdt_set_totalsize(fdt, _fdt_data_size(fdt));
+       fdt_packblocks_(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
+       fdt_set_totalsize(fdt, fdt_data_size_(fdt));
 
        return 0;
 }