Xen project Mailing List

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

To: David Vrabel <david.vrabel@xxxxxxxxxx>, Keir Fraser <keir@xxxxxxx>

From: Ian Campbell <Ian.Campbell@xxxxxxxxxx>

Date: Fri, 10 Feb 2012 13:38:26 +0000

Cc: "xen-devel@xxxxxxxxxxxxxxxxxxx" <xen-devel@xxxxxxxxxxxxxxxxxxx>

Delivery-date: Fri, 10 Feb 2012 13:38:49 +0000

List-id: Xen developer discussion <xen-devel.lists.xensource.com>

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

©2013 Xen Project, A Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation.
Xen Project is a trademark of The Linux Foundation.