[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Xen-devel] [PATCH 1/8] libfdt: add version 1.3.0



On Fri, 2012-02-10 at 13:03 +0000, David Vrabel wrote:
> From: David Vrabel <david.vrabel@xxxxxxxxxx>
> 
> Add libfdt 1.3.0 from http://git.jdl.com/gitweb/?p=dtc.git
> 
> This will be used by Xen to parse the DTBs provided by bootloaders on
> ARM platforms.
> 
> Signed-off-by: David Vrabel <david.vrabel@xxxxxxxxxx>

Seems reasonable to me. I'd like to see an Ack from Keir before I commit
this and the following 2 xen/common/mumble patches (or have Keir take
them directly).

Ian.

> ---
>  xen/common/libfdt/Makefile.libfdt   |   10 +
>  xen/common/libfdt/TODO              |    3 +
>  xen/common/libfdt/fdt.c             |  222 +++++++
>  xen/common/libfdt/fdt.h             |   60 ++
>  xen/common/libfdt/fdt_ro.c          |  574 ++++++++++++++++
>  xen/common/libfdt/fdt_rw.c          |  465 +++++++++++++
>  xen/common/libfdt/fdt_strerror.c    |   96 +++
>  xen/common/libfdt/fdt_sw.c          |  256 ++++++++
>  xen/common/libfdt/fdt_wip.c         |  118 ++++
>  xen/common/libfdt/libfdt.h          | 1235 
> +++++++++++++++++++++++++++++++++++
>  xen/common/libfdt/libfdt_env.h      |   23 +
>  xen/common/libfdt/libfdt_internal.h |   95 +++
>  xen/common/libfdt/version.lds       |   54 ++
>  13 files changed, 3211 insertions(+), 0 deletions(-)
>  create mode 100644 xen/common/libfdt/Makefile.libfdt
>  create mode 100644 xen/common/libfdt/TODO
>  create mode 100644 xen/common/libfdt/fdt.c
>  create mode 100644 xen/common/libfdt/fdt.h
>  create mode 100644 xen/common/libfdt/fdt_ro.c
>  create mode 100644 xen/common/libfdt/fdt_rw.c
>  create mode 100644 xen/common/libfdt/fdt_strerror.c
>  create mode 100644 xen/common/libfdt/fdt_sw.c
>  create mode 100644 xen/common/libfdt/fdt_wip.c
>  create mode 100644 xen/common/libfdt/libfdt.h
>  create mode 100644 xen/common/libfdt/libfdt_env.h
>  create mode 100644 xen/common/libfdt/libfdt_internal.h
>  create mode 100644 xen/common/libfdt/version.lds
> 
> diff --git a/xen/common/libfdt/Makefile.libfdt 
> b/xen/common/libfdt/Makefile.libfdt
> new file mode 100644
> index 0000000..d55a6f8
> --- /dev/null
> +++ b/xen/common/libfdt/Makefile.libfdt
> @@ -0,0 +1,10 @@
> +# Makefile.libfdt
> +#
> +# This is not a complete Makefile of itself.  Instead, it is designed to
> +# be easily embeddable into other systems of Makefiles.
> +#
> +LIBFDT_soname = libfdt.$(SHAREDLIB_EXT).1
> +LIBFDT_INCLUDES = fdt.h libfdt.h
> +LIBFDT_VERSION = version.lds
> +LIBFDT_SRCS = fdt.c fdt_ro.c fdt_wip.c fdt_sw.c fdt_rw.c fdt_strerror.c
> +LIBFDT_OBJS = $(LIBFDT_SRCS:%.c=%.o)
> diff --git a/xen/common/libfdt/TODO b/xen/common/libfdt/TODO
> new file mode 100644
> index 0000000..288437e
> --- /dev/null
> +++ b/xen/common/libfdt/TODO
> @@ -0,0 +1,3 @@
> +- Tree traversal functions
> +- Graft function
> +- Complete libfdt.h documenting comments
> diff --git a/xen/common/libfdt/fdt.c b/xen/common/libfdt/fdt.c
> new file mode 100644
> index 0000000..e56833a
> --- /dev/null
> +++ b/xen/common/libfdt/fdt.c
> @@ -0,0 +1,222 @@
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + *
> + * libfdt is dual licensed: you can use it either under the terms of
> + * the GPL, or the BSD license, at your option.
> + *
> + *  a) This library 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 library 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 library; if not, write to the Free
> + *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
> + *     MA 02110-1301 USA
> + *
> + * Alternatively,
> + *
> + *  b) Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *     1. Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *     2. Redistributions in binary form must reproduce the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer in the documentation and/or other materials
> + *        provided with the distribution.
> + *
> + *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
> + *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
> + *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
> + *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
> + *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
> + *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
> + *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
> + *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
> + *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
> + *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +#include "libfdt_env.h"
> +
> +#include <fdt.h>
> +#include <libfdt.h>
> +
> +#include "libfdt_internal.h"
> +
> +int fdt_check_header(const void *fdt)
> +{
> +       if (fdt_magic(fdt) == FDT_MAGIC) {
> +               /* Complete tree */
> +               if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
> +                       return -FDT_ERR_BADVERSION;
> +               if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)
> +                       return -FDT_ERR_BADVERSION;
> +       } else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
> +               /* Unfinished sequential-write blob */
> +               if (fdt_size_dt_struct(fdt) == 0)
> +                       return -FDT_ERR_BADSTATE;
> +       } else {
> +               return -FDT_ERR_BADMAGIC;
> +       }
> +
> +       return 0;
> +}
> +
> +const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)
> +{
> +       const char *p;
> +
> +       if (fdt_version(fdt) >= 0x11)
> +               if (((offset + len) < offset)
> +                   || ((offset + len) > fdt_size_dt_struct(fdt)))
> +                       return NULL;
> +
> +       p = _fdt_offset_ptr(fdt, offset);
> +
> +       if (p + len < p)
> +               return NULL;
> +       return p;
> +}
> +
> +uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)
> +{
> +       const uint32_t *tagp, *lenp;
> +       uint32_t tag;
> +       int offset = startoffset;
> +       const char *p;
> +
> +       *nextoffset = -FDT_ERR_TRUNCATED;
> +       tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
> +       if (!tagp)
> +               return FDT_END; /* premature end */
> +       tag = fdt32_to_cpu(*tagp);
> +       offset += FDT_TAGSIZE;
> +
> +       *nextoffset = -FDT_ERR_BADSTRUCTURE;
> +       switch (tag) {
> +       case FDT_BEGIN_NODE:
> +               /* skip name */
> +               do {
> +                       p = fdt_offset_ptr(fdt, offset++, 1);
> +               } while (p && (*p != '\0'));
> +               if (!p)
> +                       return FDT_END; /* premature end */
> +               break;
> +
> +       case FDT_PROP:
> +               lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
> +               if (!lenp)
> +                       return FDT_END; /* premature end */
> +               /* skip-name offset, length and value */
> +               offset += sizeof(struct fdt_property) - FDT_TAGSIZE
> +                       + fdt32_to_cpu(*lenp);
> +               break;
> +
> +       case FDT_END:
> +       case FDT_END_NODE:
> +       case FDT_NOP:
> +               break;
> +
> +       default:
> +               return FDT_END;
> +       }
> +
> +       if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))
> +               return FDT_END; /* premature end */
> +
> +       *nextoffset = FDT_TAGALIGN(offset);
> +       return tag;
> +}
> +
> +int _fdt_check_node_offset(const void *fdt, int offset)
> +{
> +       if ((offset < 0) || (offset % FDT_TAGSIZE)
> +           || (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))
> +               return -FDT_ERR_BADOFFSET;
> +
> +       return offset;
> +}
> +
> +int _fdt_check_prop_offset(const void *fdt, int offset)
> +{
> +       if ((offset < 0) || (offset % FDT_TAGSIZE)
> +           || (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))
> +               return -FDT_ERR_BADOFFSET;
> +
> +       return offset;
> +}
> +
> +int fdt_next_node(const void *fdt, int offset, int *depth)
> +{
> +       int nextoffset = 0;
> +       uint32_t tag;
> +
> +       if (offset >= 0)
> +               if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)
> +                       return nextoffset;
> +
> +       do {
> +               offset = nextoffset;
> +               tag = fdt_next_tag(fdt, offset, &nextoffset);
> +
> +               switch (tag) {
> +               case FDT_PROP:
> +               case FDT_NOP:
> +                       break;
> +
> +               case FDT_BEGIN_NODE:
> +                       if (depth)
> +                               (*depth)++;
> +                       break;
> +
> +               case FDT_END_NODE:
> +                       if (depth && ((--(*depth)) < 0))
> +                               return nextoffset;
> +                       break;
> +
> +               case FDT_END:
> +                       if ((nextoffset >= 0)
> +                           || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))
> +                               return -FDT_ERR_NOTFOUND;
> +                       else
> +                               return nextoffset;
> +               }
> +       } while (tag != FDT_BEGIN_NODE);
> +
> +       return offset;
> +}
> +
> +const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)
> +{
> +       int len = strlen(s) + 1;
> +       const char *last = strtab + tabsize - len;
> +       const char *p;
> +
> +       for (p = strtab; p <= last; p++)
> +               if (memcmp(p, s, len) == 0)
> +                       return p;
> +       return NULL;
> +}
> +
> +int fdt_move(const void *fdt, void *buf, int bufsize)
> +{
> +       FDT_CHECK_HEADER(fdt);
> +
> +       if (fdt_totalsize(fdt) > bufsize)
> +               return -FDT_ERR_NOSPACE;
> +
> +       memmove(buf, fdt, fdt_totalsize(fdt));
> +       return 0;
> +}
> diff --git a/xen/common/libfdt/fdt.h b/xen/common/libfdt/fdt.h
> new file mode 100644
> index 0000000..48ccfd9
> --- /dev/null
> +++ b/xen/common/libfdt/fdt.h
> @@ -0,0 +1,60 @@
> +#ifndef _FDT_H
> +#define _FDT_H
> +
> +#ifndef __ASSEMBLY__
> +
> +struct fdt_header {
> +       uint32_t magic;                  /* magic word FDT_MAGIC */
> +       uint32_t totalsize;              /* total size of DT block */
> +       uint32_t off_dt_struct;          /* offset to structure */
> +       uint32_t off_dt_strings;         /* offset to strings */
> +       uint32_t off_mem_rsvmap;         /* offset to memory reserve map */
> +       uint32_t version;                /* format version */
> +       uint32_t last_comp_version;      /* last compatible version */
> +
> +       /* version 2 fields below */
> +       uint32_t boot_cpuid_phys;        /* Which physical CPU id we're
> +                                           booting on */
> +       /* version 3 fields below */
> +       uint32_t size_dt_strings;        /* size of the strings block */
> +
> +       /* version 17 fields below */
> +       uint32_t size_dt_struct;         /* size of the structure block */
> +};
> +
> +struct fdt_reserve_entry {
> +       uint64_t address;
> +       uint64_t size;
> +};
> +
> +struct fdt_node_header {
> +       uint32_t tag;
> +       char name[0];
> +};
> +
> +struct fdt_property {
> +       uint32_t tag;
> +       uint32_t len;
> +       uint32_t nameoff;
> +       char data[0];
> +};
> +
> +#endif /* !__ASSEMBLY */
> +
> +#define FDT_MAGIC      0xd00dfeed      /* 4: version, 4: total size */
> +#define FDT_TAGSIZE    sizeof(uint32_t)
> +
> +#define FDT_BEGIN_NODE 0x1             /* Start node: full name */
> +#define FDT_END_NODE   0x2             /* End node */
> +#define FDT_PROP       0x3             /* Property: name off,
> +                                          size, content */
> +#define FDT_NOP                0x4             /* nop */
> +#define FDT_END                0x9
> +
> +#define FDT_V1_SIZE    (7*sizeof(uint32_t))
> +#define FDT_V2_SIZE    (FDT_V1_SIZE + sizeof(uint32_t))
> +#define FDT_V3_SIZE    (FDT_V2_SIZE + sizeof(uint32_t))
> +#define FDT_V16_SIZE   FDT_V3_SIZE
> +#define FDT_V17_SIZE   (FDT_V16_SIZE + sizeof(uint32_t))
> +
> +#endif /* _FDT_H */
> diff --git a/xen/common/libfdt/fdt_ro.c b/xen/common/libfdt/fdt_ro.c
> new file mode 100644
> index 0000000..02b6d68
> --- /dev/null
> +++ b/xen/common/libfdt/fdt_ro.c
> @@ -0,0 +1,574 @@
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + *
> + * libfdt is dual licensed: you can use it either under the terms of
> + * the GPL, or the BSD license, at your option.
> + *
> + *  a) This library 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 library 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 library; if not, write to the Free
> + *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
> + *     MA 02110-1301 USA
> + *
> + * Alternatively,
> + *
> + *  b) Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *     1. Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *     2. Redistributions in binary form must reproduce the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer in the documentation and/or other materials
> + *        provided with the distribution.
> + *
> + *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
> + *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
> + *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
> + *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
> + *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
> + *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
> + *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
> + *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
> + *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
> + *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +#include "libfdt_env.h"
> +
> +#include <fdt.h>
> +#include <libfdt.h>
> +
> +#include "libfdt_internal.h"
> +
> +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);
> +
> +       if (! p)
> +               /* short match */
> +               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;
> +}
> +
> +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);
> +       *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 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;
> +
> +               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)
> +{
> +       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(const void *fdt, const char *path)
> +{
> +       const char *end = path + strlen(path);
> +       const char *p = path;
> +       int offset = 0;
> +
> +       FDT_CHECK_HEADER(fdt);
> +
> +       /* 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;
> +
> +               while (*p == '/')
> +                       p++;
> +               if (! *p)
> +                       return offset;
> +               q = strchr(p, '/');
> +               if (! q)
> +                       q = end;
> +
> +               offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
> +               if (offset < 0)
> +                       return offset;
> +
> +               p = q;
> +       }
> +
> +       return offset;
> +}
> +
> +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;
> +
> +       if (((err = fdt_check_header(fdt)) != 0)
> +           || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))
> +                       goto fail;
> +
> +       if (len)
> +               *len = strlen(nh->name);
> +
> +       return nh->name;
> +
> + fail:
> +       if (len)
> +               *len = err;
> +       return NULL;
> +}
> +
> +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)
> +{
> +       int err;
> +       const struct fdt_property *prop;
> +
> +       if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {
> +               if (lenp)
> +                       *lenp = err;
> +               return NULL;
> +       }
> +
> +       prop = _fdt_offset_ptr(fdt, offset);
> +
> +       if (lenp)
> +               *lenp = fdt32_to_cpu(prop->len);
> +
> +       return prop;
> +}
> +
> +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;
> +
> +               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;
> +       }
> +
> +       if (lenp)
> +               *lenp = offset;
> +       return NULL;
> +}
> +
> +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_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;
> +
> +       /* 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() */
> +}
> +
> +static 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_node_check_compatible(const void *fdt, int nodeoffset,
> +                             const char *compatible)
> +{
> +       const void *prop;
> +       int len;
> +
> +       prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
> +       if (!prop)
> +               return len;
> +       if (_fdt_stringlist_contains(prop, len, compatible))
> +               return 0;
> +       else
> +               return 1;
> +}
> +
> +int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
> +                                 const char *compatible)
> +{
> +       int offset, err;
> +
> +       FDT_CHECK_HEADER(fdt);
> +
> +       /* 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() */
> +}
> diff --git a/xen/common/libfdt/fdt_rw.c b/xen/common/libfdt/fdt_rw.c
> new file mode 100644
> index 0000000..994037b
> --- /dev/null
> +++ b/xen/common/libfdt/fdt_rw.c
> @@ -0,0 +1,465 @@
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + *
> + * libfdt is dual licensed: you can use it either under the terms of
> + * the GPL, or the BSD license, at your option.
> + *
> + *  a) This library 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 library 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 library; if not, write to the Free
> + *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
> + *     MA 02110-1301 USA
> + *
> + * Alternatively,
> + *
> + *  b) Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *     1. Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *     2. Redistributions in binary form must reproduce the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer in the documentation and/or other materials
> + *        provided with the distribution.
> + *
> + *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
> + *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
> + *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
> + *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
> + *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
> + *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
> + *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
> + *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
> + *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
> + *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +#include "libfdt_env.h"
> +
> +#include <fdt.h>
> +#include <libfdt.h>
> +
> +#include "libfdt_internal.h"
> +
> +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) <
> +                   (fdt_off_mem_rsvmap(fdt) + mem_rsv_size))
> +               || (fdt_off_dt_strings(fdt) <
> +                   (fdt_off_dt_struct(fdt) + struct_size))
> +               || (fdt_totalsize(fdt) <
> +                   (fdt_off_dt_strings(fdt) + fdt_size_dt_strings(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),
> +                                  fdt_size_dt_struct(fdt)))
> +               return -FDT_ERR_BADLAYOUT;
> +       if (fdt_version(fdt) > 17)
> +               fdt_set_version(fdt, 17);
> +
> +       return 0;
> +}
> +
> +#define FDT_RW_CHECK_HEADER(fdt) \
> +       { \
> +               int err; \
> +               if ((err = _fdt_rw_check_header(fdt)) != 0) \
> +                       return err; \
> +       }
> +
> +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)
> +{
> +       char *p = splicepoint;
> +       char *end = (char *)fdt + _fdt_data_size(fdt);
> +
> +       if (((p + oldlen) < p) || ((p + oldlen) > end))
> +               return -FDT_ERR_BADOFFSET;
> +       if ((end - oldlen + newlen) > ((char *)fdt + fdt_totalsize(fdt)))
> +               return -FDT_ERR_NOSPACE;
> +       memmove(p + newlen, p + oldlen, end - p - oldlen);
> +       return 0;
> +}
> +
> +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));
> +       if (err)
> +               return err;
> +       fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta);
> +       fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);
> +       return 0;
> +}
> +
> +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)))
> +               return err;
> +
> +       fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta);
> +       fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);
> +       return 0;
> +}
> +
> +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)))
> +               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)
> +{
> +       char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
> +       const char *p;
> +       char *new;
> +       int len = strlen(s) + 1;
> +       int err;
> +
> +       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);
> +       if (err)
> +               return err;
> +
> +       memcpy(new, s, len);
> +       return (new - strtab);
> +}
> +
> +int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)
> +{
> +       struct fdt_reserve_entry *re;
> +       int err;
> +
> +       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);
> +       if (err)
> +               return err;
> +
> +       re->address = cpu_to_fdt64(address);
> +       re->size = cpu_to_fdt64(size);
> +       return 0;
> +}
> +
> +int fdt_del_mem_rsv(void *fdt, int n)
> +{
> +       struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n);
> +       int err;
> +
> +       FDT_RW_CHECK_HEADER(fdt);
> +
> +       if (n >= fdt_num_mem_rsv(fdt))
> +               return -FDT_ERR_NOTFOUND;
> +
> +       err = _fdt_splice_mem_rsv(fdt, re, 1, 0);
> +       if (err)
> +               return err;
> +       return 0;
> +}
> +
> +static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
> +                               int len, struct fdt_property **prop)
> +{
> +       int oldlen;
> +       int err;
> +
> +       *prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
> +       if (! (*prop))
> +               return oldlen;
> +
> +       if ((err = _fdt_splice_struct(fdt, (*prop)->data, 
> FDT_TAGALIGN(oldlen),
> +                                     FDT_TAGALIGN(len))))
> +               return err;
> +
> +       (*prop)->len = cpu_to_fdt32(len);
> +       return 0;
> +}
> +
> +static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,
> +                            int len, struct fdt_property **prop)
> +{
> +       int proplen;
> +       int nextoffset;
> +       int namestroff;
> +       int err;
> +
> +       if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
> +               return nextoffset;
> +
> +       namestroff = _fdt_find_add_string(fdt, name);
> +       if (namestroff < 0)
> +               return namestroff;
> +
> +       *prop = _fdt_offset_ptr_w(fdt, nextoffset);
> +       proplen = sizeof(**prop) + FDT_TAGALIGN(len);
> +
> +       err = _fdt_splice_struct(fdt, *prop, 0, proplen);
> +       if (err)
> +               return err;
> +
> +       (*prop)->tag = cpu_to_fdt32(FDT_PROP);
> +       (*prop)->nameoff = cpu_to_fdt32(namestroff);
> +       (*prop)->len = cpu_to_fdt32(len);
> +       return 0;
> +}
> +
> +int fdt_set_name(void *fdt, int nodeoffset, const char *name)
> +{
> +       char *namep;
> +       int oldlen, newlen;
> +       int err;
> +
> +       FDT_RW_CHECK_HEADER(fdt);
> +
> +       namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen);
> +       if (!namep)
> +               return oldlen;
> +
> +       newlen = strlen(name);
> +
> +       err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1),
> +                                FDT_TAGALIGN(newlen+1));
> +       if (err)
> +               return err;
> +
> +       memcpy(namep, name, newlen+1);
> +       return 0;
> +}
> +
> +int fdt_setprop(void *fdt, int nodeoffset, const char *name,
> +               const void *val, int len)
> +{
> +       struct fdt_property *prop;
> +       int err;
> +
> +       FDT_RW_CHECK_HEADER(fdt);
> +
> +       err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop);
> +       if (err == -FDT_ERR_NOTFOUND)
> +               err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
> +       if (err)
> +               return err;
> +
> +       memcpy(prop->data, val, len);
> +       return 0;
> +}
> +
> +int fdt_delprop(void *fdt, int nodeoffset, const char *name)
> +{
> +       struct fdt_property *prop;
> +       int len, proplen;
> +
> +       FDT_RW_CHECK_HEADER(fdt);
> +
> +       prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
> +       if (! prop)
> +               return len;
> +
> +       proplen = sizeof(*prop) + FDT_TAGALIGN(len);
> +       return _fdt_splice_struct(fdt, prop, proplen, 0);
> +}
> +
> +int fdt_add_subnode_namelen(void *fdt, int parentoffset,
> +                           const char *name, int namelen)
> +{
> +       struct fdt_node_header *nh;
> +       int offset, nextoffset;
> +       int nodelen;
> +       int err;
> +       uint32_t tag;
> +       uint32_t *endtag;
> +
> +       FDT_RW_CHECK_HEADER(fdt);
> +
> +       offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
> +       if (offset >= 0)
> +               return -FDT_ERR_EXISTS;
> +       else if (offset != -FDT_ERR_NOTFOUND)
> +               return offset;
> +
> +       /* Try to place the new node after the parent's properties */
> +       fdt_next_tag(fdt, parentoffset, &nextoffset); /* skip the BEGIN_NODE 
> */
> +       do {
> +               offset = nextoffset;
> +               tag = fdt_next_tag(fdt, offset, &nextoffset);
> +       } while ((tag == FDT_PROP) || (tag == FDT_NOP));
> +
> +       nh = _fdt_offset_ptr_w(fdt, offset);
> +       nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;
> +
> +       err = _fdt_splice_struct(fdt, nh, 0, nodelen);
> +       if (err)
> +               return err;
> +
> +       nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
> +       memset(nh->name, 0, FDT_TAGALIGN(namelen+1));
> +       memcpy(nh->name, name, namelen);
> +       endtag = (uint32_t *)((char *)nh + nodelen - FDT_TAGSIZE);
> +       *endtag = cpu_to_fdt32(FDT_END_NODE);
> +
> +       return offset;
> +}
> +
> +int fdt_add_subnode(void *fdt, int parentoffset, const char *name)
> +{
> +       return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));
> +}
> +
> +int fdt_del_node(void *fdt, int nodeoffset)
> +{
> +       int endoffset;
> +
> +       FDT_RW_CHECK_HEADER(fdt);
> +
> +       endoffset = _fdt_node_end_offset(fdt, nodeoffset);
> +       if (endoffset < 0)
> +               return endoffset;
> +
> +       return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),
> +                                 endoffset - nodeoffset, 0);
> +}
> +
> +static void _fdt_packblocks(const char *old, char *new,
> +                           int mem_rsv_size, int struct_size)
> +{
> +       int mem_rsv_off, struct_off, strings_off;
> +
> +       mem_rsv_off = FDT_ALIGN(sizeof(struct fdt_header), 8);
> +       struct_off = mem_rsv_off + mem_rsv_size;
> +       strings_off = struct_off + struct_size;
> +
> +       memmove(new + mem_rsv_off, old + fdt_off_mem_rsvmap(old), 
> mem_rsv_size);
> +       fdt_set_off_mem_rsvmap(new, mem_rsv_off);
> +
> +       memmove(new + struct_off, old + fdt_off_dt_struct(old), struct_size);
> +       fdt_set_off_dt_struct(new, struct_off);
> +       fdt_set_size_dt_struct(new, struct_size);
> +
> +       memmove(new + strings_off, old + fdt_off_dt_strings(old),
> +               fdt_size_dt_strings(old));
> +       fdt_set_off_dt_strings(new, strings_off);
> +       fdt_set_size_dt_strings(new, fdt_size_dt_strings(old));
> +}
> +
> +int fdt_open_into(const void *fdt, void *buf, int bufsize)
> +{
> +       int err;
> +       int mem_rsv_size, struct_size;
> +       int newsize;
> +       const char *fdtstart = fdt;
> +       const char *fdtend = fdtstart + fdt_totalsize(fdt);
> +       char *tmp;
> +
> +       FDT_CHECK_HEADER(fdt);
> +
> +       mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
> +               * sizeof(struct fdt_reserve_entry);
> +
> +       if (fdt_version(fdt) >= 17) {
> +               struct_size = fdt_size_dt_struct(fdt);
> +       } else {
> +               struct_size = 0;
> +               while (fdt_next_tag(fdt, struct_size, &struct_size) != 
> FDT_END)
> +                       ;
> +               if (struct_size < 0)
> +                       return struct_size;
> +       }
> +
> +       if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {
> +               /* no further work necessary */
> +               err = fdt_move(fdt, buf, bufsize);
> +               if (err)
> +                       return err;
> +               fdt_set_version(buf, 17);
> +               fdt_set_size_dt_struct(buf, struct_size);
> +               fdt_set_totalsize(buf, bufsize);
> +               return 0;
> +       }
> +
> +       /* Need to reorder */
> +       newsize = FDT_ALIGN(sizeof(struct fdt_header), 8) + mem_rsv_size
> +               + struct_size + fdt_size_dt_strings(fdt);
> +
> +       if (bufsize < newsize)
> +               return -FDT_ERR_NOSPACE;
> +
> +       /* First attempt to build converted tree at beginning of buffer */
> +       tmp = buf;
> +       /* But if that overlaps with the old tree... */
> +       if (((tmp + newsize) > fdtstart) && (tmp < fdtend)) {
> +               /* Try right after the old tree instead */
> +               tmp = (char *)(uintptr_t)fdtend;
> +               if ((tmp + newsize) > ((char *)buf + bufsize))
> +                       return -FDT_ERR_NOSPACE;
> +       }
> +
> +       _fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);
> +       memmove(buf, tmp, newsize);
> +
> +       fdt_set_magic(buf, FDT_MAGIC);
> +       fdt_set_totalsize(buf, bufsize);
> +       fdt_set_version(buf, 17);
> +       fdt_set_last_comp_version(buf, 16);
> +       fdt_set_boot_cpuid_phys(buf, fdt_boot_cpuid_phys(fdt));
> +
> +       return 0;
> +}
> +
> +int fdt_pack(void *fdt)
> +{
> +       int mem_rsv_size;
> +
> +       FDT_RW_CHECK_HEADER(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));
> +
> +       return 0;
> +}
> diff --git a/xen/common/libfdt/fdt_strerror.c 
> b/xen/common/libfdt/fdt_strerror.c
> new file mode 100644
> index 0000000..e6c3cee
> --- /dev/null
> +++ b/xen/common/libfdt/fdt_strerror.c
> @@ -0,0 +1,96 @@
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + *
> + * libfdt is dual licensed: you can use it either under the terms of
> + * the GPL, or the BSD license, at your option.
> + *
> + *  a) This library 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 library 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 library; if not, write to the Free
> + *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
> + *     MA 02110-1301 USA
> + *
> + * Alternatively,
> + *
> + *  b) Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *     1. Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *     2. Redistributions in binary form must reproduce the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer in the documentation and/or other materials
> + *        provided with the distribution.
> + *
> + *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
> + *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
> + *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
> + *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
> + *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
> + *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
> + *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
> + *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
> + *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
> + *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +#include "libfdt_env.h"
> +
> +#include <fdt.h>
> +#include <libfdt.h>
> +
> +#include "libfdt_internal.h"
> +
> +struct fdt_errtabent {
> +       const char *str;
> +};
> +
> +#define FDT_ERRTABENT(val) \
> +       [(val)] = { .str = #val, }
> +
> +static struct fdt_errtabent fdt_errtable[] = {
> +       FDT_ERRTABENT(FDT_ERR_NOTFOUND),
> +       FDT_ERRTABENT(FDT_ERR_EXISTS),
> +       FDT_ERRTABENT(FDT_ERR_NOSPACE),
> +
> +       FDT_ERRTABENT(FDT_ERR_BADOFFSET),
> +       FDT_ERRTABENT(FDT_ERR_BADPATH),
> +       FDT_ERRTABENT(FDT_ERR_BADSTATE),
> +
> +       FDT_ERRTABENT(FDT_ERR_TRUNCATED),
> +       FDT_ERRTABENT(FDT_ERR_BADMAGIC),
> +       FDT_ERRTABENT(FDT_ERR_BADVERSION),
> +       FDT_ERRTABENT(FDT_ERR_BADSTRUCTURE),
> +       FDT_ERRTABENT(FDT_ERR_BADLAYOUT),
> +};
> +#define FDT_ERRTABSIZE (sizeof(fdt_errtable) / sizeof(fdt_errtable[0]))
> +
> +const char *fdt_strerror(int errval)
> +{
> +       if (errval > 0)
> +               return "<valid offset/length>";
> +       else if (errval == 0)
> +               return "<no error>";
> +       else if (errval > -FDT_ERRTABSIZE) {
> +               const char *s = fdt_errtable[-errval].str;
> +
> +               if (s)
> +                       return s;
> +       }
> +
> +       return "<unknown error>";
> +}
> diff --git a/xen/common/libfdt/fdt_sw.c b/xen/common/libfdt/fdt_sw.c
> new file mode 100644
> index 0000000..55ebebf
> --- /dev/null
> +++ b/xen/common/libfdt/fdt_sw.c
> @@ -0,0 +1,256 @@
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + *
> + * libfdt is dual licensed: you can use it either under the terms of
> + * the GPL, or the BSD license, at your option.
> + *
> + *  a) This library 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 library 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 library; if not, write to the Free
> + *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
> + *     MA 02110-1301 USA
> + *
> + * Alternatively,
> + *
> + *  b) Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *     1. Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *     2. Redistributions in binary form must reproduce the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer in the documentation and/or other materials
> + *        provided with the distribution.
> + *
> + *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
> + *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
> + *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
> + *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
> + *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
> + *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
> + *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
> + *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
> + *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
> + *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +#include "libfdt_env.h"
> +
> +#include <fdt.h>
> +#include <libfdt.h>
> +
> +#include "libfdt_internal.h"
> +
> +static int _fdt_sw_check_header(void *fdt)
> +{
> +       if (fdt_magic(fdt) != FDT_SW_MAGIC)
> +               return -FDT_ERR_BADMAGIC;
> +       /* FIXME: should check more details about the header state */
> +       return 0;
> +}
> +
> +#define FDT_SW_CHECK_HEADER(fdt) \
> +       { \
> +               int err; \
> +               if ((err = _fdt_sw_check_header(fdt)) != 0) \
> +                       return err; \
> +       }
> +
> +static void *_fdt_grab_space(void *fdt, size_t len)
> +{
> +       int offset = fdt_size_dt_struct(fdt);
> +       int spaceleft;
> +
> +       spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)
> +               - fdt_size_dt_strings(fdt);
> +
> +       if ((offset + len < offset) || (offset + len > spaceleft))
> +               return NULL;
> +
> +       fdt_set_size_dt_struct(fdt, offset + len);
> +       return _fdt_offset_ptr_w(fdt, offset);
> +}
> +
> +int fdt_create(void *buf, int bufsize)
> +{
> +       void *fdt = buf;
> +
> +       if (bufsize < sizeof(struct fdt_header))
> +               return -FDT_ERR_NOSPACE;
> +
> +       memset(buf, 0, bufsize);
> +
> +       fdt_set_magic(fdt, FDT_SW_MAGIC);
> +       fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);
> +       fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
> +       fdt_set_totalsize(fdt,  bufsize);
> +
> +       fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),
> +                                             sizeof(struct 
> fdt_reserve_entry)));
> +       fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
> +       fdt_set_off_dt_strings(fdt, bufsize);
> +
> +       return 0;
> +}
> +
> +int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size)
> +{
> +       struct fdt_reserve_entry *re;
> +       int offset;
> +
> +       FDT_SW_CHECK_HEADER(fdt);
> +
> +       if (fdt_size_dt_struct(fdt))
> +               return -FDT_ERR_BADSTATE;
> +
> +       offset = fdt_off_dt_struct(fdt);
> +       if ((offset + sizeof(*re)) > fdt_totalsize(fdt))
> +               return -FDT_ERR_NOSPACE;
> +
> +       re = (struct fdt_reserve_entry *)((char *)fdt + offset);
> +       re->address = cpu_to_fdt64(addr);
> +       re->size = cpu_to_fdt64(size);
> +
> +       fdt_set_off_dt_struct(fdt, offset + sizeof(*re));
> +
> +       return 0;
> +}
> +
> +int fdt_finish_reservemap(void *fdt)
> +{
> +       return fdt_add_reservemap_entry(fdt, 0, 0);
> +}
> +
> +int fdt_begin_node(void *fdt, const char *name)
> +{
> +       struct fdt_node_header *nh;
> +       int namelen = strlen(name) + 1;
> +
> +       FDT_SW_CHECK_HEADER(fdt);
> +
> +       nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
> +       if (! nh)
> +               return -FDT_ERR_NOSPACE;
> +
> +       nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
> +       memcpy(nh->name, name, namelen);
> +       return 0;
> +}
> +
> +int fdt_end_node(void *fdt)
> +{
> +       uint32_t *en;
> +
> +       FDT_SW_CHECK_HEADER(fdt);
> +
> +       en = _fdt_grab_space(fdt, FDT_TAGSIZE);
> +       if (! en)
> +               return -FDT_ERR_NOSPACE;
> +
> +       *en = cpu_to_fdt32(FDT_END_NODE);
> +       return 0;
> +}
> +
> +static int _fdt_find_add_string(void *fdt, const char *s)
> +{
> +       char *strtab = (char *)fdt + fdt_totalsize(fdt);
> +       const char *p;
> +       int strtabsize = fdt_size_dt_strings(fdt);
> +       int len = strlen(s) + 1;
> +       int struct_top, offset;
> +
> +       p = _fdt_find_string(strtab - strtabsize, strtabsize, s);
> +       if (p)
> +               return p - strtab;
> +
> +       /* Add it */
> +       offset = -strtabsize - len;
> +       struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
> +       if (fdt_totalsize(fdt) + offset < struct_top)
> +               return 0; /* no more room :( */
> +
> +       memcpy(strtab + offset, s, len);
> +       fdt_set_size_dt_strings(fdt, strtabsize + len);
> +       return offset;
> +}
> +
> +int fdt_property(void *fdt, const char *name, const void *val, int len)
> +{
> +       struct fdt_property *prop;
> +       int nameoff;
> +
> +       FDT_SW_CHECK_HEADER(fdt);
> +
> +       nameoff = _fdt_find_add_string(fdt, name);
> +       if (nameoff == 0)
> +               return -FDT_ERR_NOSPACE;
> +
> +       prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
> +       if (! prop)
> +               return -FDT_ERR_NOSPACE;
> +
> +       prop->tag = cpu_to_fdt32(FDT_PROP);
> +       prop->nameoff = cpu_to_fdt32(nameoff);
> +       prop->len = cpu_to_fdt32(len);
> +       memcpy(prop->data, val, len);
> +       return 0;
> +}
> +
> +int fdt_finish(void *fdt)
> +{
> +       char *p = (char *)fdt;
> +       uint32_t *end;
> +       int oldstroffset, newstroffset;
> +       uint32_t tag;
> +       int offset, nextoffset;
> +
> +       FDT_SW_CHECK_HEADER(fdt);
> +
> +       /* Add terminator */
> +       end = _fdt_grab_space(fdt, sizeof(*end));
> +       if (! end)
> +               return -FDT_ERR_NOSPACE;
> +       *end = cpu_to_fdt32(FDT_END);
> +
> +       /* Relocate the string table */
> +       oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
> +       newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
> +       memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
> +       fdt_set_off_dt_strings(fdt, newstroffset);
> +
> +       /* Walk the structure, correcting string offsets */
> +       offset = 0;
> +       while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {
> +               if (tag == FDT_PROP) {
> +                       struct fdt_property *prop =
> +                               _fdt_offset_ptr_w(fdt, offset);
> +                       int nameoff;
> +
> +                       nameoff = fdt32_to_cpu(prop->nameoff);
> +                       nameoff += fdt_size_dt_strings(fdt);
> +                       prop->nameoff = cpu_to_fdt32(nameoff);
> +               }
> +               offset = nextoffset;
> +       }
> +       if (nextoffset < 0)
> +               return nextoffset;
> +
> +       /* Finally, adjust the header */
> +       fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));
> +       fdt_set_magic(fdt, FDT_MAGIC);
> +       return 0;
> +}
> diff --git a/xen/common/libfdt/fdt_wip.c b/xen/common/libfdt/fdt_wip.c
> new file mode 100644
> index 0000000..6025fa1
> --- /dev/null
> +++ b/xen/common/libfdt/fdt_wip.c
> @@ -0,0 +1,118 @@
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + *
> + * libfdt is dual licensed: you can use it either under the terms of
> + * the GPL, or the BSD license, at your option.
> + *
> + *  a) This library 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 library 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 library; if not, write to the Free
> + *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
> + *     MA 02110-1301 USA
> + *
> + * Alternatively,
> + *
> + *  b) Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *     1. Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *     2. Redistributions in binary form must reproduce the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer in the documentation and/or other materials
> + *        provided with the distribution.
> + *
> + *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
> + *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
> + *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
> + *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
> + *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
> + *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
> + *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
> + *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
> + *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
> + *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +#include "libfdt_env.h"
> +
> +#include <fdt.h>
> +#include <libfdt.h>
> +
> +#include "libfdt_internal.h"
> +
> +int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
> +                       const void *val, int len)
> +{
> +       void *propval;
> +       int proplen;
> +
> +       propval = fdt_getprop_w(fdt, nodeoffset, name, &proplen);
> +       if (! propval)
> +               return proplen;
> +
> +       if (proplen != len)
> +               return -FDT_ERR_NOSPACE;
> +
> +       memcpy(propval, val, len);
> +       return 0;
> +}
> +
> +static void _fdt_nop_region(void *start, int len)
> +{
> +       uint32_t *p;
> +
> +       for (p = start; (char *)p < ((char *)start + len); p++)
> +               *p = cpu_to_fdt32(FDT_NOP);
> +}
> +
> +int fdt_nop_property(void *fdt, int nodeoffset, const char *name)
> +{
> +       struct fdt_property *prop;
> +       int len;
> +
> +       prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
> +       if (! prop)
> +               return len;
> +
> +       _fdt_nop_region(prop, len + sizeof(*prop));
> +
> +       return 0;
> +}
> +
> +int _fdt_node_end_offset(void *fdt, int offset)
> +{
> +       int depth = 0;
> +
> +       while ((offset >= 0) && (depth >= 0))
> +               offset = fdt_next_node(fdt, offset, &depth);
> +
> +       return offset;
> +}
> +
> +int fdt_nop_node(void *fdt, int nodeoffset)
> +{
> +       int endoffset;
> +
> +       endoffset = _fdt_node_end_offset(fdt, nodeoffset);
> +       if (endoffset < 0)
> +               return endoffset;
> +
> +       _fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0),
> +                       endoffset - nodeoffset);
> +       return 0;
> +}
> diff --git a/xen/common/libfdt/libfdt.h b/xen/common/libfdt/libfdt.h
> new file mode 100644
> index 0000000..55f3eb3
> --- /dev/null
> +++ b/xen/common/libfdt/libfdt.h
> @@ -0,0 +1,1235 @@
> +#ifndef _LIBFDT_H
> +#define _LIBFDT_H
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + *
> + * libfdt is dual licensed: you can use it either under the terms of
> + * the GPL, or the BSD license, at your option.
> + *
> + *  a) This library 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 library 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 library; if not, write to the Free
> + *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
> + *     MA 02110-1301 USA
> + *
> + * Alternatively,
> + *
> + *  b) Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *     1. Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *     2. Redistributions in binary form must reproduce the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer in the documentation and/or other materials
> + *        provided with the distribution.
> + *
> + *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
> + *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
> + *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
> + *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
> + *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
> + *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
> + *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
> + *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
> + *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
> + *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +
> +#include <libfdt_env.h>
> +#include <fdt.h>
> +
> +#define FDT_FIRST_SUPPORTED_VERSION    0x10
> +#define FDT_LAST_SUPPORTED_VERSION     0x11
> +
> +/* Error codes: informative error codes */
> +#define FDT_ERR_NOTFOUND       1
> +       /* FDT_ERR_NOTFOUND: The requested node or property does not exist */
> +#define FDT_ERR_EXISTS         2
> +       /* FDT_ERR_EXISTS: Attemped to create a node or property which
> +        * already exists */
> +#define FDT_ERR_NOSPACE                3
> +       /* FDT_ERR_NOSPACE: Operation needed to expand the device
> +        * tree, but its buffer did not have sufficient space to
> +        * contain the expanded tree. Use fdt_open_into() to move the
> +        * device tree to a buffer with more space. */
> +
> +/* Error codes: codes for bad parameters */
> +#define FDT_ERR_BADOFFSET      4
> +       /* FDT_ERR_BADOFFSET: Function was passed a structure block
> +        * offset which is out-of-bounds, or which points to an
> +        * unsuitable part of the structure for the operation. */
> +#define FDT_ERR_BADPATH                5
> +       /* FDT_ERR_BADPATH: Function was passed a badly formatted path
> +        * (e.g. missing a leading / for a function which requires an
> +        * absolute path) */
> +#define FDT_ERR_BADPHANDLE     6
> +       /* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle
> +        * value.  phandle values of 0 and -1 are not permitted. */
> +#define FDT_ERR_BADSTATE       7
> +       /* FDT_ERR_BADSTATE: Function was passed an incomplete device
> +        * tree created by the sequential-write functions, which is
> +        * not sufficiently complete for the requested operation. */
> +
> +/* Error codes: codes for bad device tree blobs */
> +#define FDT_ERR_TRUNCATED      8
> +       /* FDT_ERR_TRUNCATED: Structure block of the given device tree
> +        * ends without an FDT_END tag. */
> +#define FDT_ERR_BADMAGIC       9
> +       /* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a
> +        * device tree at all - it is missing the flattened device
> +        * tree magic number. */
> +#define FDT_ERR_BADVERSION     10
> +       /* FDT_ERR_BADVERSION: Given device tree has a version which
> +        * can't be handled by the requested operation.  For
> +        * read-write functions, this may mean that fdt_open_into() is
> +        * required to convert the tree to the expected version. */
> +#define FDT_ERR_BADSTRUCTURE   11
> +       /* FDT_ERR_BADSTRUCTURE: Given device tree has a corrupt
> +        * structure block or other serious error (e.g. misnested
> +        * nodes, or subnodes preceding properties). */
> +#define FDT_ERR_BADLAYOUT      12
> +       /* FDT_ERR_BADLAYOUT: For read-write functions, the given
> +        * device tree has it's sub-blocks in an order that the
> +        * function can't handle (memory reserve map, then structure,
> +        * then strings).  Use fdt_open_into() to reorganize the tree
> +        * into a form suitable for the read-write operations. */
> +
> +/* "Can't happen" error indicating a bug in libfdt */
> +#define FDT_ERR_INTERNAL       13
> +       /* FDT_ERR_INTERNAL: libfdt has failed an internal assertion.
> +        * Should never be returned, if it is, it indicates a bug in
> +        * libfdt itself. */
> +
> +#define FDT_ERR_MAX            13
> +
> +/**********************************************************************/
> +/* Low-level functions (you probably don't need these)                */
> +/**********************************************************************/
> +
> +const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int 
> checklen);
> +static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
> +{
> +       return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);
> +}
> +
> +uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
> +
> +/**********************************************************************/
> +/* Traversal functions                                                */
> +/**********************************************************************/
> +
> +int fdt_next_node(const void *fdt, int offset, int *depth);
> +
> +/**********************************************************************/
> +/* General functions                                                  */
> +/**********************************************************************/
> +
> +#define fdt_get_header(fdt, field) \
> +       (fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
> +#define fdt_magic(fdt)                         (fdt_get_header(fdt, magic))
> +#define fdt_totalsize(fdt)             (fdt_get_header(fdt, totalsize))
> +#define fdt_off_dt_struct(fdt)         (fdt_get_header(fdt, off_dt_struct))
> +#define fdt_off_dt_strings(fdt)                (fdt_get_header(fdt, 
> off_dt_strings))
> +#define fdt_off_mem_rsvmap(fdt)                (fdt_get_header(fdt, 
> off_mem_rsvmap))
> +#define fdt_version(fdt)               (fdt_get_header(fdt, version))
> +#define fdt_last_comp_version(fdt)     (fdt_get_header(fdt, 
> last_comp_version))
> +#define fdt_boot_cpuid_phys(fdt)       (fdt_get_header(fdt, boot_cpuid_phys))
> +#define fdt_size_dt_strings(fdt)       (fdt_get_header(fdt, size_dt_strings))
> +#define fdt_size_dt_struct(fdt)                (fdt_get_header(fdt, 
> size_dt_struct))
> +
> +#define __fdt_set_hdr(name) \
> +       static inline void fdt_set_##name(void *fdt, uint32_t val) \
> +       { \
> +               struct fdt_header *fdth = (struct fdt_header*)fdt; \
> +               fdth->name = cpu_to_fdt32(val); \
> +       }
> +__fdt_set_hdr(magic);
> +__fdt_set_hdr(totalsize);
> +__fdt_set_hdr(off_dt_struct);
> +__fdt_set_hdr(off_dt_strings);
> +__fdt_set_hdr(off_mem_rsvmap);
> +__fdt_set_hdr(version);
> +__fdt_set_hdr(last_comp_version);
> +__fdt_set_hdr(boot_cpuid_phys);
> +__fdt_set_hdr(size_dt_strings);
> +__fdt_set_hdr(size_dt_struct);
> +#undef __fdt_set_hdr
> +
> +/**
> + * fdt_check_header - sanity check a device tree or possible device tree
> + * @fdt: pointer to data which might be a flattened device tree
> + *
> + * fdt_check_header() checks that the given buffer contains what
> + * appears to be a flattened device tree with sane information in its
> + * header.
> + *
> + * returns:
> + *     0, if the buffer appears to contain a valid device tree
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE, standard meanings, as above
> + */
> +int fdt_check_header(const void *fdt);
> +
> +/**
> + * fdt_move - move a device tree around in memory
> + * @fdt: pointer to the device tree to move
> + * @buf: pointer to memory where the device is to be moved
> + * @bufsize: size of the memory space at buf
> + *
> + * fdt_move() relocates, if possible, the device tree blob located at
> + * fdt to the buffer at buf of size bufsize.  The buffer may overlap
> + * with the existing device tree blob at fdt.  Therefore,
> + *     fdt_move(fdt, fdt, fdt_totalsize(fdt))
> + * should always succeed.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOSPACE, bufsize is insufficient to contain the device tree
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE, standard meanings
> + */
> +int fdt_move(const void *fdt, void *buf, int bufsize);
> +
> +/**********************************************************************/
> +/* Read-only functions                                                */
> +/**********************************************************************/
> +
> +/**
> + * fdt_string - retrieve a string from the strings block of a device tree
> + * @fdt: pointer to the device tree blob
> + * @stroffset: offset of the string within the strings block (native endian)
> + *
> + * fdt_string() retrieves a pointer to a single string from the
> + * strings block of the device tree blob at fdt.
> + *
> + * returns:
> + *     a pointer to the string, on success
> + *     NULL, if stroffset is out of bounds
> + */
> +const char *fdt_string(const void *fdt, int stroffset);
> +
> +/**
> + * fdt_num_mem_rsv - retrieve the number of memory reserve map entries
> + * @fdt: pointer to the device tree blob
> + *
> + * Returns the number of entries in the device tree blob's memory
> + * reservation map.  This does not include the terminating 0,0 entry
> + * or any other (0,0) entries reserved for expansion.
> + *
> + * returns:
> + *     the number of entries
> + */
> +int fdt_num_mem_rsv(const void *fdt);
> +
> +/**
> + * fdt_get_mem_rsv - retrieve one memory reserve map entry
> + * @fdt: pointer to the device tree blob
> + * @address, @size: pointers to 64-bit variables
> + *
> + * On success, *address and *size will contain the address and size of
> + * the n-th reserve map entry from the device tree blob, in
> + * native-endian format.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE, standard meanings
> + */
> +int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t 
> *size);
> +
> +/**
> + * fdt_subnode_offset_namelen - find a subnode based on substring
> + * @fdt: pointer to the device tree blob
> + * @parentoffset: structure block offset of a node
> + * @name: name of the subnode to locate
> + * @namelen: number of characters of name to consider
> + *
> + * Identical to fdt_subnode_offset(), but only examine the first
> + * namelen characters of name for matching the subnode name.  This is
> + * useful for finding subnodes based on a portion of a larger string,
> + * such as a full path.
> + */
> +int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
> +                              const char *name, int namelen);
> +/**
> + * fdt_subnode_offset - find a subnode of a given node
> + * @fdt: pointer to the device tree blob
> + * @parentoffset: structure block offset of a node
> + * @name: name of the subnode to locate
> + *
> + * fdt_subnode_offset() finds a subnode of the node at structure block
> + * offset parentoffset with the given name.  name may include a unit
> + * address, in which case fdt_subnode_offset() will find the subnode
> + * with that unit address, or the unit address may be omitted, in
> + * which case fdt_subnode_offset() will find an arbitrary subnode
> + * whose name excluding unit address matches the given name.
> + *
> + * returns:
> + *     structure block offset of the requested subnode (>=0), on success
> + *     -FDT_ERR_NOTFOUND, if the requested subnode does not exist
> + *     -FDT_ERR_BADOFFSET, if parentoffset did not point to an 
> FDT_BEGIN_NODE tag
> + *      -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings.
> + */
> +int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);
> +
> +/**
> + * fdt_path_offset - find a tree node by its full path
> + * @fdt: pointer to the device tree blob
> + * @path: full path of the node to locate
> + *
> + * fdt_path_offset() finds a node of a given path in the device tree.
> + * Each path component may omit the unit address portion, but the
> + * results of this are undefined if any such path component is
> + * ambiguous (that is if there are multiple nodes at the relevant
> + * level matching the given component, differentiated only by unit
> + * address).
> + *
> + * returns:
> + *     structure block offset of the node with the requested path (>=0), on 
> success
> + *     -FDT_ERR_BADPATH, given path does not begin with '/' or is invalid
> + *     -FDT_ERR_NOTFOUND, if the requested node does not exist
> + *      -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings.
> + */
> +int fdt_path_offset(const void *fdt, const char *path);
> +
> +/**
> + * fdt_get_name - retrieve the name of a given node
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: structure block offset of the starting node
> + * @lenp: pointer to an integer variable (will be overwritten) or NULL
> + *
> + * fdt_get_name() retrieves the name (including unit address) of the
> + * device tree node at structure block offset nodeoffset.  If lenp is
> + * non-NULL, the length of this name is also returned, in the integer
> + * pointed to by lenp.
> + *
> + * returns:
> + *     pointer to the node's name, on success
> + *             If lenp is non-NULL, *lenp contains the length of that name 
> (>=0)
> + *     NULL, on error
> + *             if lenp is non-NULL *lenp contains an error code (<0):
> + *             -FDT_ERR_BADOFFSET, nodeoffset did not point to 
> FDT_BEGIN_NODE tag
> + *             -FDT_ERR_BADMAGIC,
> + *             -FDT_ERR_BADVERSION,
> + *             -FDT_ERR_BADSTATE, standard meanings
> + */
> +const char *fdt_get_name(const void *fdt, int nodeoffset, int *lenp);
> +
> +/**
> + * fdt_first_property_offset - find the offset of a node's first property
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: structure block offset of a node
> + *
> + * fdt_first_property_offset() finds the first property of the node at
> + * the given structure block offset.
> + *
> + * returns:
> + *     structure block offset of the property (>=0), on success
> + *     -FDT_ERR_NOTFOUND, if the requested node has no properties
> + *     -FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_BEGIN_NODE 
> tag
> + *      -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings.
> + */
> +int fdt_first_property_offset(const void *fdt, int nodeoffset);
> +
> +/**
> + * fdt_next_property_offset - step through a node's properties
> + * @fdt: pointer to the device tree blob
> + * @offset: structure block offset of a property
> + *
> + * fdt_next_property_offset() finds the property immediately after the
> + * one at the given structure block offset.  This will be a property
> + * of the same node as the given property.
> + *
> + * returns:
> + *     structure block offset of the next property (>=0), on success
> + *     -FDT_ERR_NOTFOUND, if the given property is the last in its node
> + *     -FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_PROP tag
> + *      -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings.
> + */
> +int fdt_next_property_offset(const void *fdt, int offset);
> +
> +/**
> + * fdt_get_property_by_offset - retrieve the property at a given offset
> + * @fdt: pointer to the device tree blob
> + * @offset: offset of the property to retrieve
> + * @lenp: pointer to an integer variable (will be overwritten) or NULL
> + *
> + * fdt_get_property_by_offset() retrieves a pointer to the
> + * fdt_property structure within the device tree blob at the given
> + * offset.  If lenp is non-NULL, the length of the property value is
> + * also returned, in the integer pointed to by lenp.
> + *
> + * returns:
> + *     pointer to the structure representing the property
> + *             if lenp is non-NULL, *lenp contains the length of the property
> + *             value (>=0)
> + *     NULL, on error
> + *             if lenp is non-NULL, *lenp contains an error code (<0):
> + *             -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
> + *             -FDT_ERR_BADMAGIC,
> + *             -FDT_ERR_BADVERSION,
> + *             -FDT_ERR_BADSTATE,
> + *             -FDT_ERR_BADSTRUCTURE,
> + *             -FDT_ERR_TRUNCATED, standard meanings
> + */
> +const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
> +                                                     int offset,
> +                                                     int *lenp);
> +
> +/**
> + * fdt_get_property_namelen - find a property based on substring
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to find
> + * @name: name of the property to find
> + * @namelen: number of characters of name to consider
> + * @lenp: pointer to an integer variable (will be overwritten) or NULL
> + *
> + * Identical to fdt_get_property_namelen(), but only examine the first
> + * namelen characters of name for matching the property name.
> + */
> +const struct fdt_property *fdt_get_property_namelen(const void *fdt,
> +                                                   int nodeoffset,
> +                                                   const char *name,
> +                                                   int namelen, int *lenp);
> +
> +/**
> + * fdt_get_property - find a given property in a given node
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to find
> + * @name: name of the property to find
> + * @lenp: pointer to an integer variable (will be overwritten) or NULL
> + *
> + * fdt_get_property() retrieves a pointer to the fdt_property
> + * structure within the device tree blob corresponding to the property
> + * named 'name' of the node at offset nodeoffset.  If lenp is
> + * non-NULL, the length of the property value is also returned, in the
> + * integer pointed to by lenp.
> + *
> + * returns:
> + *     pointer to the structure representing the property
> + *             if lenp is non-NULL, *lenp contains the length of the property
> + *             value (>=0)
> + *     NULL, on error
> + *             if lenp is non-NULL, *lenp contains an error code (<0):
> + *             -FDT_ERR_NOTFOUND, node does not have named property
> + *             -FDT_ERR_BADOFFSET, nodeoffset did not point to 
> FDT_BEGIN_NODE tag
> + *             -FDT_ERR_BADMAGIC,
> + *             -FDT_ERR_BADVERSION,
> + *             -FDT_ERR_BADSTATE,
> + *             -FDT_ERR_BADSTRUCTURE,
> + *             -FDT_ERR_TRUNCATED, standard meanings
> + */
> +const struct fdt_property *fdt_get_property(const void *fdt, int nodeoffset,
> +                                           const char *name, int *lenp);
> +static inline struct fdt_property *fdt_get_property_w(void *fdt, int 
> nodeoffset,
> +                                                     const char *name,
> +                                                     int *lenp)
> +{
> +       return (struct fdt_property *)(uintptr_t)
> +               fdt_get_property(fdt, nodeoffset, name, lenp);
> +}
> +
> +/**
> + * fdt_getprop_by_offset - retrieve the value of a property at a given offset
> + * @fdt: pointer to the device tree blob
> + * @ffset: offset of the property to read
> + * @namep: pointer to a string variable (will be overwritten) or NULL
> + * @lenp: pointer to an integer variable (will be overwritten) or NULL
> + *
> + * fdt_getprop_by_offset() retrieves a pointer to the value of the
> + * property at structure block offset 'offset' (this will be a pointer
> + * to within the device blob itself, not a copy of the value).  If
> + * lenp is non-NULL, the length of the property value is also
> + * returned, in the integer pointed to by lenp.  If namep is non-NULL,
> + * the property's namne will also be returned in the char * pointed to
> + * by namep (this will be a pointer to within the device tree's string
> + * block, not a new copy of the name).
> + *
> + * returns:
> + *     pointer to the property's value
> + *             if lenp is non-NULL, *lenp contains the length of the property
> + *             value (>=0)
> + *             if namep is non-NULL *namep contiains a pointer to the 
> property
> + *             name.
> + *     NULL, on error
> + *             if lenp is non-NULL, *lenp contains an error code (<0):
> + *             -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
> + *             -FDT_ERR_BADMAGIC,
> + *             -FDT_ERR_BADVERSION,
> + *             -FDT_ERR_BADSTATE,
> + *             -FDT_ERR_BADSTRUCTURE,
> + *             -FDT_ERR_TRUNCATED, standard meanings
> + */
> +const void *fdt_getprop_by_offset(const void *fdt, int offset,
> +                                 const char **namep, int *lenp);
> +
> +/**
> + * fdt_getprop_namelen - get property value based on substring
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to find
> + * @name: name of the property to find
> + * @namelen: number of characters of name to consider
> + * @lenp: pointer to an integer variable (will be overwritten) or NULL
> + *
> + * Identical to fdt_getprop(), but only examine the first namelen
> + * characters of name for matching the property name.
> + */
> +const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
> +                               const char *name, int namelen, int *lenp);
> +
> +/**
> + * fdt_getprop - retrieve the value of a given property
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to find
> + * @name: name of the property to find
> + * @lenp: pointer to an integer variable (will be overwritten) or NULL
> + *
> + * fdt_getprop() retrieves a pointer to the value of the property
> + * named 'name' of the node at offset nodeoffset (this will be a
> + * pointer to within the device blob itself, not a copy of the value).
> + * If lenp is non-NULL, the length of the property value is also
> + * returned, in the integer pointed to by lenp.
> + *
> + * returns:
> + *     pointer to the property's value
> + *             if lenp is non-NULL, *lenp contains the length of the property
> + *             value (>=0)
> + *     NULL, on error
> + *             if lenp is non-NULL, *lenp contains an error code (<0):
> + *             -FDT_ERR_NOTFOUND, node does not have named property
> + *             -FDT_ERR_BADOFFSET, nodeoffset did not point to 
> FDT_BEGIN_NODE tag
> + *             -FDT_ERR_BADMAGIC,
> + *             -FDT_ERR_BADVERSION,
> + *             -FDT_ERR_BADSTATE,
> + *             -FDT_ERR_BADSTRUCTURE,
> + *             -FDT_ERR_TRUNCATED, standard meanings
> + */
> +const void *fdt_getprop(const void *fdt, int nodeoffset,
> +                       const char *name, int *lenp);
> +static inline void *fdt_getprop_w(void *fdt, int nodeoffset,
> +                                 const char *name, int *lenp)
> +{
> +       return (void *)(uintptr_t)fdt_getprop(fdt, nodeoffset, name, lenp);
> +}
> +
> +/**
> + * fdt_get_phandle - retrieve the phandle of a given node
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: structure block offset of the node
> + *
> + * fdt_get_phandle() retrieves the phandle of the device tree node at
> + * structure block offset nodeoffset.
> + *
> + * returns:
> + *     the phandle of the node at nodeoffset, on success (!= 0, != -1)
> + *     0, if the node has no phandle, or another error occurs
> + */
> +uint32_t fdt_get_phandle(const void *fdt, int nodeoffset);
> +
> +/**
> + * fdt_get_alias_namelen - get alias based on substring
> + * @fdt: pointer to the device tree blob
> + * @name: name of the alias th look up
> + * @namelen: number of characters of name to consider
> + *
> + * Identical to fdt_get_alias(), but only examine the first namelen
> + * characters of name for matching the alias name.
> + */
> +const char *fdt_get_alias_namelen(const void *fdt,
> +                                 const char *name, int namelen);
> +
> +/**
> + * fdt_get_alias - retreive the path referenced by a given alias
> + * @fdt: pointer to the device tree blob
> + * @name: name of the alias th look up
> + *
> + * fdt_get_alias() retrieves the value of a given alias.  That is, the
> + * value of the property named 'name' in the node /aliases.
> + *
> + * returns:
> + *     a pointer to the expansion of the alias named 'name', of it exists
> + *     NULL, if the given alias or the /aliases node does not exist
> + */
> +const char *fdt_get_alias(const void *fdt, const char *name);
> +
> +/**
> + * fdt_get_path - determine the full path of a node
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose path to find
> + * @buf: character buffer to contain the returned path (will be overwritten)
> + * @buflen: size of the character buffer at buf
> + *
> + * fdt_get_path() computes the full path of the node at offset
> + * nodeoffset, and records that path in the buffer at buf.
> + *
> + * NOTE: This function is expensive, as it must scan the device tree
> + * structure from the start to nodeoffset.
> + *
> + * returns:
> + *     0, on success
> + *             buf contains the absolute path of the node at
> + *             nodeoffset, as a NUL-terminated string.
> + *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
> + *     -FDT_ERR_NOSPACE, the path of the given node is longer than 
> (bufsize-1)
> + *             characters and will not fit in the given buffer.
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE, standard meanings
> + */
> +int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);
> +
> +/**
> + * fdt_supernode_atdepth_offset - find a specific ancestor of a node
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose parent to find
> + * @supernodedepth: depth of the ancestor to find
> + * @nodedepth: pointer to an integer variable (will be overwritten) or NULL
> + *
> + * fdt_supernode_atdepth_offset() finds an ancestor of the given node
> + * at a specific depth from the root (where the root itself has depth
> + * 0, its immediate subnodes depth 1 and so forth).  So
> + *     fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, NULL);
> + * will always return 0, the offset of the root node.  If the node at
> + * nodeoffset has depth D, then:
> + *     fdt_supernode_atdepth_offset(fdt, nodeoffset, D, NULL);
> + * will return nodeoffset itself.
> + *
> + * NOTE: This function is expensive, as it must scan the device tree
> + * structure from the start to nodeoffset.
> + *
> + * returns:
> +
> + *     structure block offset of the node at node offset's ancestor
> + *             of depth supernodedepth (>=0), on success
> + *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
> +*      -FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of 
> nodeoffset
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE, standard meanings
> + */
> +int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
> +                                int supernodedepth, int *nodedepth);
> +
> +/**
> + * fdt_node_depth - find the depth of a given node
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose parent to find
> + *
> + * fdt_node_depth() finds the depth of a given node.  The root node
> + * has depth 0, its immediate subnodes depth 1 and so forth.
> + *
> + * NOTE: This function is expensive, as it must scan the device tree
> + * structure from the start to nodeoffset.
> + *
> + * returns:
> + *     depth of the node at nodeoffset (>=0), on success
> + *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE, standard meanings
> + */
> +int fdt_node_depth(const void *fdt, int nodeoffset);
> +
> +/**
> + * fdt_parent_offset - find the parent of a given node
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose parent to find
> + *
> + * fdt_parent_offset() locates the parent node of a given node (that
> + * is, it finds the offset of the node which contains the node at
> + * nodeoffset as a subnode).
> + *
> + * NOTE: This function is expensive, as it must scan the device tree
> + * structure from the start to nodeoffset, *twice*.
> + *
> + * returns:
> + *     structure block offset of the parent of the node at nodeoffset
> + *             (>=0), on success
> + *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE, standard meanings
> + */
> +int fdt_parent_offset(const void *fdt, int nodeoffset);
> +
> +/**
> + * fdt_node_offset_by_prop_value - find nodes with a given property value
> + * @fdt: pointer to the device tree blob
> + * @startoffset: only find nodes after this offset
> + * @propname: property name to check
> + * @propval: property value to search for
> + * @proplen: length of the value in propval
> + *
> + * fdt_node_offset_by_prop_value() returns the offset of the first
> + * node after startoffset, which has a property named propname whose
> + * value is of length proplen and has value equal to propval; or if
> + * startoffset is -1, the very first such node in the tree.
> + *
> + * To iterate through all nodes matching the criterion, the following
> + * idiom can be used:
> + *     offset = fdt_node_offset_by_prop_value(fdt, -1, propname,
> + *                                            propval, proplen);
> + *     while (offset != -FDT_ERR_NOTFOUND) {
> + *             // other code here
> + *             offset = fdt_node_offset_by_prop_value(fdt, offset, propname,
> + *                                                    propval, proplen);
> + *     }
> + *
> + * Note the -1 in the first call to the function, if 0 is used here
> + * instead, the function will never locate the root node, even if it
> + * matches the criterion.
> + *
> + * returns:
> + *     structure block offset of the located node (>= 0, >startoffset),
> + *              on success
> + *     -FDT_ERR_NOTFOUND, no node matching the criterion exists in the
> + *             tree after startoffset
> + *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE, standard meanings
> + */
> +int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
> +                                 const char *propname,
> +                                 const void *propval, int proplen);
> +
> +/**
> + * fdt_node_offset_by_phandle - find the node with a given phandle
> + * @fdt: pointer to the device tree blob
> + * @phandle: phandle value
> + *
> + * fdt_node_offset_by_phandle() returns the offset of the node
> + * which has the given phandle value.  If there is more than one node
> + * in the tree with the given phandle (an invalid tree), results are
> + * undefined.
> + *
> + * returns:
> + *     structure block offset of the located node (>= 0), on success
> + *     -FDT_ERR_NOTFOUND, no node with that phandle exists
> + *     -FDT_ERR_BADPHANDLE, given phandle value was invalid (0 or -1)
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE, standard meanings
> + */
> +int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle);
> +
> +/**
> + * fdt_node_check_compatible: check a node's compatible property
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of a tree node
> + * @compatible: string to match against
> + *
> + *
> + * fdt_node_check_compatible() returns 0 if the given node contains a
> + * 'compatible' property with the given string as one of its elements,
> + * it returns non-zero otherwise, or on error.
> + *
> + * returns:
> + *     0, if the node has a 'compatible' property listing the given string
> + *     1, if the node has a 'compatible' property, but it does not list
> + *             the given string
> + *     -FDT_ERR_NOTFOUND, if the given node has no 'compatible' property
> + *     -FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE, standard meanings
> + */
> +int fdt_node_check_compatible(const void *fdt, int nodeoffset,
> +                             const char *compatible);
> +
> +/**
> + * fdt_node_offset_by_compatible - find nodes with a given 'compatible' value
> + * @fdt: pointer to the device tree blob
> + * @startoffset: only find nodes after this offset
> + * @compatible: 'compatible' string to match against
> + *
> + * fdt_node_offset_by_compatible() returns the offset of the first
> + * node after startoffset, which has a 'compatible' property which
> + * lists the given compatible string; or if startoffset is -1, the
> + * very first such node in the tree.
> + *
> + * To iterate through all nodes matching the criterion, the following
> + * idiom can be used:
> + *     offset = fdt_node_offset_by_compatible(fdt, -1, compatible);
> + *     while (offset != -FDT_ERR_NOTFOUND) {
> + *             // other code here
> + *             offset = fdt_node_offset_by_compatible(fdt, offset, 
> compatible);
> + *     }
> + *
> + * Note the -1 in the first call to the function, if 0 is used here
> + * instead, the function will never locate the root node, even if it
> + * matches the criterion.
> + *
> + * returns:
> + *     structure block offset of the located node (>= 0, >startoffset),
> + *              on success
> + *     -FDT_ERR_NOTFOUND, no node matching the criterion exists in the
> + *             tree after startoffset
> + *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE, standard meanings
> + */
> +int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
> +                                 const char *compatible);
> +
> +/**********************************************************************/
> +/* Write-in-place functions                                           */
> +/**********************************************************************/
> +
> +/**
> + * fdt_setprop_inplace - change a property's value, but not its size
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to change
> + * @name: name of the property to change
> + * @val: pointer to data to replace the property value with
> + * @len: length of the property value
> + *
> + * fdt_setprop_inplace() replaces the value of a given property with
> + * the data in val, of length len.  This function cannot change the
> + * size of a property, and so will only work if len is equal to the
> + * current length of the property.
> + *
> + * This function will alter only the bytes in the blob which contain
> + * the given property value, and will not alter or move any other part
> + * of the tree.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOSPACE, if len is not equal to the property's current length
> + *     -FDT_ERR_NOTFOUND, node does not have the named property
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
> +                       const void *val, int len);
> +
> +/**
> + * fdt_setprop_inplace_cell - change the value of a single-cell property
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to change
> + * @name: name of the property to change
> + * @val: cell (32-bit integer) value to replace the property with
> + *
> + * fdt_setprop_inplace_cell() replaces the value of a given property
> + * with the 32-bit integer cell value in val, converting val to
> + * big-endian if necessary.  This function cannot change the size of a
> + * property, and so will only work if the property already exists and
> + * has length 4.
> + *
> + * This function will alter only the bytes in the blob which contain
> + * the given property value, and will not alter or move any other part
> + * of the tree.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOSPACE, if the property's length is not equal to 4
> +  *    -FDT_ERR_NOTFOUND, node does not have the named property
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset,
> +                                          const char *name, uint32_t val)
> +{
> +       val = cpu_to_fdt32(val);
> +       return fdt_setprop_inplace(fdt, nodeoffset, name, &val, sizeof(val));
> +}
> +
> +/**
> + * fdt_nop_property - replace a property with nop tags
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to nop
> + * @name: name of the property to nop
> + *
> + * fdt_nop_property() will replace a given property's representation
> + * in the blob with FDT_NOP tags, effectively removing it from the
> + * tree.
> + *
> + * This function will alter only the bytes in the blob which contain
> + * the property, and will not alter or move any other part of the
> + * tree.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOTFOUND, node does not have the named property
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_nop_property(void *fdt, int nodeoffset, const char *name);
> +
> +/**
> + * fdt_nop_node - replace a node (subtree) with nop tags
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node to nop
> + *
> + * fdt_nop_node() will replace a given node's representation in the
> + * blob, including all its subnodes, if any, with FDT_NOP tags,
> + * effectively removing it from the tree.
> + *
> + * This function will alter only the bytes in the blob which contain
> + * the node and its properties and subnodes, and will not alter or
> + * move any other part of the tree.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_nop_node(void *fdt, int nodeoffset);
> +
> +/**********************************************************************/
> +/* Sequential write functions                                         */
> +/**********************************************************************/
> +
> +int fdt_create(void *buf, int bufsize);
> +int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size);
> +int fdt_finish_reservemap(void *fdt);
> +int fdt_begin_node(void *fdt, const char *name);
> +int fdt_property(void *fdt, const char *name, const void *val, int len);
> +static inline int fdt_property_cell(void *fdt, const char *name, uint32_t 
> val)
> +{
> +       val = cpu_to_fdt32(val);
> +       return fdt_property(fdt, name, &val, sizeof(val));
> +}
> +#define fdt_property_string(fdt, name, str) \
> +       fdt_property(fdt, name, str, strlen(str)+1)
> +int fdt_end_node(void *fdt);
> +int fdt_finish(void *fdt);
> +
> +/**********************************************************************/
> +/* Read-write functions                                               */
> +/**********************************************************************/
> +
> +int fdt_open_into(const void *fdt, void *buf, int bufsize);
> +int fdt_pack(void *fdt);
> +
> +/**
> + * fdt_add_mem_rsv - add one memory reserve map entry
> + * @fdt: pointer to the device tree blob
> + * @address, @size: 64-bit values (native endian)
> + *
> + * Adds a reserve map entry to the given blob reserving a region at
> + * address address of length size.
> + *
> + * This function will insert data into the reserve map and will
> + * therefore change the indexes of some entries in the table.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
> + *             contain the new reservation entry
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size);
> +
> +/**
> + * fdt_del_mem_rsv - remove a memory reserve map entry
> + * @fdt: pointer to the device tree blob
> + * @n: entry to remove
> + *
> + * fdt_del_mem_rsv() removes the n-th memory reserve map entry from
> + * the blob.
> + *
> + * This function will delete data from the reservation table and will
> + * therefore change the indexes of some entries in the table.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOTFOUND, there is no entry of the given index (i.e. there
> + *             are less than n+1 reserve map entries)
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_del_mem_rsv(void *fdt, int n);
> +
> +/**
> + * fdt_set_name - change the name of a given node
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: structure block offset of a node
> + * @name: name to give the node
> + *
> + * fdt_set_name() replaces the name (including unit address, if any)
> + * of the given node with the given string.  NOTE: this function can't
> + * efficiently check if the new name is unique amongst the given
> + * node's siblings; results are undefined if this function is invoked
> + * with a name equal to one of the given node's siblings.
> + *
> + * This function may insert or delete data from the blob, and will
> + * therefore change the offsets of some existing nodes.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOSPACE, there is insufficient free space in the blob
> + *             to contain the new name
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE, standard meanings
> + */
> +int fdt_set_name(void *fdt, int nodeoffset, const char *name);
> +
> +/**
> + * fdt_setprop - create or change a property
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to change
> + * @name: name of the property to change
> + * @val: pointer to data to set the property value to
> + * @len: length of the property value
> + *
> + * fdt_setprop() sets the value of the named property in the given
> + * node to the given value and length, creating the property if it
> + * does not already exist.
> + *
> + * This function may insert or delete data from the blob, and will
> + * therefore change the offsets of some existing nodes.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
> + *             contain the new property value
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_setprop(void *fdt, int nodeoffset, const char *name,
> +               const void *val, int len);
> +
> +/**
> + * fdt_setprop_cell - set a property to a single cell value
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to change
> + * @name: name of the property to change
> + * @val: 32-bit integer value for the property (native endian)
> + *
> + * fdt_setprop_cell() sets the value of the named property in the
> + * given node to the given cell value (converting to big-endian if
> + * necessary), or creates a new property with that value if it does
> + * not already exist.
> + *
> + * This function may insert or delete data from the blob, and will
> + * therefore change the offsets of some existing nodes.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
> + *             contain the new property value
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char 
> *name,
> +                                  uint32_t val)
> +{
> +       val = cpu_to_fdt32(val);
> +       return fdt_setprop(fdt, nodeoffset, name, &val, sizeof(val));
> +}
> +
> +/**
> + * fdt_setprop_string - set a property to a string value
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to change
> + * @name: name of the property to change
> + * @str: string value for the property
> + *
> + * fdt_setprop_string() sets the value of the named property in the
> + * given node to the given string value (using the length of the
> + * string to determine the new length of the property), or creates a
> + * new property with that value if it does not already exist.
> + *
> + * This function may insert or delete data from the blob, and will
> + * therefore change the offsets of some existing nodes.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
> + *             contain the new property value
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +#define fdt_setprop_string(fdt, nodeoffset, name, str) \
> +       fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
> +
> +/**
> + * fdt_delprop - delete a property
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to nop
> + * @name: name of the property to nop
> + *
> + * fdt_del_property() will delete the given property.
> + *
> + * This function will delete data from the blob, and will therefore
> + * change the offsets of some existing nodes.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_NOTFOUND, node does not have the named property
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_delprop(void *fdt, int nodeoffset, const char *name);
> +
> +/**
> + * fdt_add_subnode_namelen - creates a new node based on substring
> + * @fdt: pointer to the device tree blob
> + * @parentoffset: structure block offset of a node
> + * @name: name of the subnode to locate
> + * @namelen: number of characters of name to consider
> + *
> + * Identical to fdt_add_subnode(), but use only the first namelen
> + * characters of name as the name of the new node.  This is useful for
> + * creating subnodes based on a portion of a larger string, such as a
> + * full path.
> + */
> +int fdt_add_subnode_namelen(void *fdt, int parentoffset,
> +                           const char *name, int namelen);
> +
> +/**
> + * fdt_add_subnode - creates a new node
> + * @fdt: pointer to the device tree blob
> + * @parentoffset: structure block offset of a node
> + * @name: name of the subnode to locate
> + *
> + * fdt_add_subnode() creates a new node as a subnode of the node at
> + * structure block offset parentoffset, with the given name (which
> + * should include the unit address, if any).
> + *
> + * This function will insert data into the blob, and will therefore
> + * change the offsets of some existing nodes.
> +
> + * returns:
> + *     structure block offset of the created nodeequested subnode (>=0), on 
> success
> + *     -FDT_ERR_NOTFOUND, if the requested subnode does not exist
> + *     -FDT_ERR_BADOFFSET, if parentoffset did not point to an 
> FDT_BEGIN_NODE tag
> + *     -FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of
> + *             the given name
> + *     -FDT_ERR_NOSPACE, if there is insufficient free space in the
> + *             blob to contain the new node
> + *     -FDT_ERR_NOSPACE
> + *     -FDT_ERR_BADLAYOUT
> + *      -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings.
> + */
> +int fdt_add_subnode(void *fdt, int parentoffset, const char *name);
> +
> +/**
> + * fdt_del_node - delete a node (subtree)
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node to nop
> + *
> + * fdt_del_node() will remove the given node, including all its
> + * subnodes if any, from the blob.
> + *
> + * This function will delete data from the blob, and will therefore
> + * change the offsets of some existing nodes.
> + *
> + * returns:
> + *     0, on success
> + *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
> + *     -FDT_ERR_BADLAYOUT,
> + *     -FDT_ERR_BADMAGIC,
> + *     -FDT_ERR_BADVERSION,
> + *     -FDT_ERR_BADSTATE,
> + *     -FDT_ERR_BADSTRUCTURE,
> + *     -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_del_node(void *fdt, int nodeoffset);
> +
> +/**********************************************************************/
> +/* Debugging / informational functions                                */
> +/**********************************************************************/
> +
> +const char *fdt_strerror(int errval);
> +
> +#endif /* _LIBFDT_H */
> diff --git a/xen/common/libfdt/libfdt_env.h b/xen/common/libfdt/libfdt_env.h
> new file mode 100644
> index 0000000..449bf60
> --- /dev/null
> +++ b/xen/common/libfdt/libfdt_env.h
> @@ -0,0 +1,23 @@
> +#ifndef _LIBFDT_ENV_H
> +#define _LIBFDT_ENV_H
> +
> +#include <stddef.h>
> +#include <stdint.h>
> +#include <string.h>
> +
> +#define _B(n)  ((unsigned long long)((uint8_t *)&x)[n])
> +static inline uint32_t fdt32_to_cpu(uint32_t x)
> +{
> +       return (_B(0) << 24) | (_B(1) << 16) | (_B(2) << 8) | _B(3);
> +}
> +#define cpu_to_fdt32(x) fdt32_to_cpu(x)
> +
> +static inline uint64_t fdt64_to_cpu(uint64_t x)
> +{
> +       return (_B(0) << 56) | (_B(1) << 48) | (_B(2) << 40) | (_B(3) << 32)
> +               | (_B(4) << 24) | (_B(5) << 16) | (_B(6) << 8) | _B(7);
> +}
> +#define cpu_to_fdt64(x) fdt64_to_cpu(x)
> +#undef _B
> +
> +#endif /* _LIBFDT_ENV_H */
> diff --git a/xen/common/libfdt/libfdt_internal.h 
> b/xen/common/libfdt/libfdt_internal.h
> new file mode 100644
> index 0000000..381133b
> --- /dev/null
> +++ b/xen/common/libfdt/libfdt_internal.h
> @@ -0,0 +1,95 @@
> +#ifndef _LIBFDT_INTERNAL_H
> +#define _LIBFDT_INTERNAL_H
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + *
> + * libfdt is dual licensed: you can use it either under the terms of
> + * the GPL, or the BSD license, at your option.
> + *
> + *  a) This library 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 library 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 library; if not, write to the Free
> + *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
> + *     MA 02110-1301 USA
> + *
> + * Alternatively,
> + *
> + *  b) Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *     1. Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *     2. Redistributions in binary form must reproduce the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer in the documentation and/or other materials
> + *        provided with the distribution.
> + *
> + *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
> + *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
> + *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
> + *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
> + *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
> + *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
> + *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
> + *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
> + *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
> + *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +#include <fdt.h>
> +
> +#define FDT_ALIGN(x, a)                (((x) + (a) - 1) & ~((a) - 1))
> +#define FDT_TAGALIGN(x)                (FDT_ALIGN((x), FDT_TAGSIZE))
> +
> +#define FDT_CHECK_HEADER(fdt) \
> +       { \
> +               int err; \
> +               if ((err = fdt_check_header(fdt)) != 0) \
> +                       return err; \
> +       }
> +
> +int _fdt_check_node_offset(const void *fdt, int offset);
> +int _fdt_check_prop_offset(const void *fdt, int offset);
> +const char *_fdt_find_string(const char *strtab, int tabsize, const char *s);
> +int _fdt_node_end_offset(void *fdt, int nodeoffset);
> +
> +static inline const void *_fdt_offset_ptr(const void *fdt, int offset)
> +{
> +       return (const char *)fdt + fdt_off_dt_struct(fdt) + offset;
> +}
> +
> +static inline void *_fdt_offset_ptr_w(void *fdt, int offset)
> +{
> +       return (void *)(uintptr_t)_fdt_offset_ptr(fdt, offset);
> +}
> +
> +static inline const struct fdt_reserve_entry *_fdt_mem_rsv(const void *fdt, 
> int n)
> +{
> +       const struct fdt_reserve_entry *rsv_table =
> +               (const struct fdt_reserve_entry *)
> +               ((const char *)fdt + fdt_off_mem_rsvmap(fdt));
> +
> +       return rsv_table + n;
> +}
> +static inline struct fdt_reserve_entry *_fdt_mem_rsv_w(void *fdt, int n)
> +{
> +       return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n);
> +}
> +
> +#define FDT_SW_MAGIC           (~FDT_MAGIC)
> +
> +#endif /* _LIBFDT_INTERNAL_H */
> diff --git a/xen/common/libfdt/version.lds b/xen/common/libfdt/version.lds
> new file mode 100644
> index 0000000..3c3994e
> --- /dev/null
> +++ b/xen/common/libfdt/version.lds
> @@ -0,0 +1,54 @@
> +LIBFDT_1.2 {
> +       global:
> +               fdt_next_node;
> +               fdt_check_header;
> +               fdt_move;
> +               fdt_string;
> +               fdt_num_mem_rsv;
> +               fdt_get_mem_rsv;
> +               fdt_subnode_offset_namelen;
> +               fdt_subnode_offset;
> +               fdt_path_offset;
> +               fdt_get_name;
> +               fdt_get_property_namelen;
> +               fdt_get_property;
> +               fdt_getprop_namelen;
> +               fdt_getprop;
> +               fdt_get_phandle;
> +               fdt_get_alias_namelen;
> +               fdt_get_alias;
> +               fdt_get_path;
> +               fdt_supernode_atdepth_offset;
> +               fdt_node_depth;
> +               fdt_parent_offset;
> +               fdt_node_offset_by_prop_value;
> +               fdt_node_offset_by_phandle;
> +               fdt_node_check_compatible;
> +               fdt_node_offset_by_compatible;
> +               fdt_setprop_inplace;
> +               fdt_nop_property;
> +               fdt_nop_node;
> +               fdt_create;
> +               fdt_add_reservemap_entry;
> +               fdt_finish_reservemap;
> +               fdt_begin_node;
> +               fdt_property;
> +               fdt_end_node;
> +               fdt_finish;
> +               fdt_open_into;
> +               fdt_pack;
> +               fdt_add_mem_rsv;
> +               fdt_del_mem_rsv;
> +               fdt_set_name;
> +               fdt_setprop;
> +               fdt_delprop;
> +               fdt_add_subnode_namelen;
> +               fdt_add_subnode;
> +               fdt_del_node;
> +               fdt_strerror;
> +               fdt_offset_ptr;
> +               fdt_next_tag;
> +
> +       local:
> +               *;
> +};
> --
> 1.7.2.5
> 
> 
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@xxxxxxxxxxxxxxxxxxx
> http://lists.xensource.com/xen-devel



_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.