This series adds preliminary device tree support to Xen for ARM. libfdt for parsing a device tree in flattened device tree (fdt) format and added and used to find the location and size of RAM. This info is then used when relocating Xen and setting up the mm and heaps. Since we don''t have a bootloader when using the model the device tree blob (DTB) is linked into .dtb section of the Xen image. The DTB needs to be present in xen/arch/arm/platfom.dtb to build. See the wiki[1] for the Linux kernel which has a DTB for the model. This series is also available in the device-tree-v4 branch of git://xenbits.xen.org/people/dvrabel/xen-unstable.git Changes since v1: - map DTB in head.S using the L2 slot after the fixmap. - new patch 8 for setting up mm/heaps. David [1] http://wiki.xen.org/wiki/Xen_ARMv7_with_Virtualization_Extensions
From: David Vrabel <david.vrabel@citrix.com>
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@citrix.com>
---
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
From: David Vrabel <david.vrabel@citrix.com>
Signed-off-by: David Vrabel <david.vrabel@citrix.com>
---
xen/common/libfdt/libfdt_env.h | 27 ++++++++++-----------------
xen/include/xen/types.h | 2 ++
2 files changed, 12 insertions(+), 17 deletions(-)
diff --git a/xen/common/libfdt/libfdt_env.h b/xen/common/libfdt/libfdt_env.h
index 449bf60..8c0c030 100644
--- a/xen/common/libfdt/libfdt_env.h
+++ b/xen/common/libfdt/libfdt_env.h
@@ -1,23 +1,16 @@
#ifndef _LIBFDT_ENV_H
#define _LIBFDT_ENV_H
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
+#include <xen/config.h>
+#include <xen/types.h>
+#include <xen/string.h>
+#include <asm/byteorder.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
+#define fdt16_to_cpu(x) be16_to_cpu(x)
+#define cpu_to_fdt16(x) cpu_to_be16(x)
+#define fdt32_to_cpu(x) be32_to_cpu(x)
+#define cpu_to_fdt32(x) cpu_to_be32(x)
+#define fdt64_to_cpu(x) be64_to_cpu(x)
+#define cpu_to_fdt64(x) cpu_to_be64(x)
#endif /* _LIBFDT_ENV_H */
diff --git a/xen/include/xen/types.h b/xen/include/xen/types.h
index ac96647..8596ded 100644
--- a/xen/include/xen/types.h
+++ b/xen/include/xen/types.h
@@ -57,4 +57,6 @@ typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;
+typedef unsigned long uintptr_t;
+
#endif /* __TYPES_H__ */
--
1.7.2.5
From: David Vrabel <david.vrabel@citrix.com> Signed-off-by: David Vrabel <david.vrabel@citrix.com> --- xen/arch/arm/Rules.mk | 2 ++ xen/common/Makefile | 1 + xen/common/libfdt/Makefile | 5 +++++ 3 files changed, 8 insertions(+), 0 deletions(-) create mode 100644 xen/common/libfdt/Makefile diff --git a/xen/arch/arm/Rules.mk b/xen/arch/arm/Rules.mk index 336e209..14082dd 100644 --- a/xen/arch/arm/Rules.mk +++ b/xen/arch/arm/Rules.mk @@ -6,6 +6,8 @@ # ''make clean'' before rebuilding. # +HAS_DEVICE_TREE := y + CFLAGS += -fno-builtin -fno-common -Wredundant-decls CFLAGS += -iwithprefix include -Werror -Wno-pointer-arith -pipe CFLAGS += -I$(BASEDIR)/include diff --git a/xen/common/Makefile b/xen/common/Makefile index 9249845..4b1e6f2 100644 --- a/xen/common/Makefile +++ b/xen/common/Makefile @@ -59,3 +59,4 @@ subdir-$(x86_64) += hvm subdir-$(ia64) += hvm subdir-y += libelf +subdir-$(HAS_DEVICE_TREE) += libfdt diff --git a/xen/common/libfdt/Makefile b/xen/common/libfdt/Makefile new file mode 100644 index 0000000..0e65bc0 --- /dev/null +++ b/xen/common/libfdt/Makefile @@ -0,0 +1,5 @@ +include Makefile.libfdt + +obj-y += $(LIBFDT_OBJS) + +CFLAGS += -I. -- 1.7.2.5
David Vrabel
2012-Feb-10 13:03 UTC
[PATCH 4/8] arm: link a device tree blob into the xen image
From: David Vrabel <david.vrabel@citrix.com>
Link a device tree blob (DTB) into the xen image. This is loaded
immediately after Xen and xen_start() is called with the correct
address in atag_paddr.
Signed-off-by: David Vrabel <david.vrabel@citrix.com>
---
xen/arch/arm/Makefile | 7 +++++--
xen/arch/arm/dtb.S | 2 ++
xen/arch/arm/head.S | 4 ++++
xen/arch/arm/xen.lds.S | 5 +++++
4 files changed, 16 insertions(+), 2 deletions(-)
create mode 100644 xen/arch/arm/dtb.S
diff --git a/xen/arch/arm/Makefile b/xen/arch/arm/Makefile
index 9bc2fc8..ac346a5 100644
--- a/xen/arch/arm/Makefile
+++ b/xen/arch/arm/Makefile
@@ -1,5 +1,6 @@
subdir-y += lib
+obj-y += dtb.o
obj-y += dummy.o
obj-y += entry.o
obj-y += domain.o
@@ -27,7 +28,7 @@ ALL_OBJS := head.o $(ALL_OBJS)
$(TARGET): $(TARGET)-syms
# XXX: VE model loads by VMA so instead of
# making a proper ELF we link with LMA == VMA and adjust crudely
- $(OBJCOPY) --change-addresses +0x7fe00000 $< $@
+ $(OBJCOPY) --change-addresses +0x80000000 $< $@
# XXX strip it
#$(TARGET): $(TARGET)-syms $(efi-y) boot/mkelf32
@@ -50,7 +51,7 @@ endif
$(BASEDIR)/common/symbols-dummy.o:
$(MAKE) -f $(BASEDIR)/Rules.mk -C $(BASEDIR)/common symbols-dummy.o
-$(TARGET)-syms: prelink.o xen.lds $(BASEDIR)/common/symbols-dummy.o
+$(TARGET)-syms: prelink.o xen.lds $(BASEDIR)/common/symbols-dummy.o dtb.o
$(LD) $(LDFLAGS) -T xen.lds -N prelink.o \
$(BASEDIR)/common/symbols-dummy.o -o $(@D)/.$(@F).0
$(NM) -n $(@D)/.$(@F).0 | $(BASEDIR)/tools/symbols >$(@D)/.$(@F).0.S
@@ -71,6 +72,8 @@ xen.lds: xen.lds.S
sed -e ''s/xen\.lds\.o:/xen\.lds:/g'' <.xen.lds.d
>.xen.lds.d.new
mv -f .xen.lds.d.new .xen.lds.d
+dtb.o: platform.dtb
+
.PHONY: clean
clean::
rm -f asm-offsets.s xen.lds
diff --git a/xen/arch/arm/dtb.S b/xen/arch/arm/dtb.S
new file mode 100644
index 0000000..0728c04
--- /dev/null
+++ b/xen/arch/arm/dtb.S
@@ -0,0 +1,2 @@
+ .section .dtb,#alloc
+ .incbin "platform.dtb"
diff --git a/xen/arch/arm/head.S b/xen/arch/arm/head.S
index 57b990d..22ac512 100644
--- a/xen/arch/arm/head.S
+++ b/xen/arch/arm/head.S
@@ -55,6 +55,10 @@ start:
adr r9, start /* r9 := paddr (start) */
sub r10, r9, r0 /* r10 := phys-offset */
+ /* XXX: using the DTB in the .dtb section. */
+ ldr r8, =_sdtb
+ add r8, r10 /* r8 := paddr(DTB) */
+
#ifdef EARLY_UART_ADDRESS
/* Say hello */
ldr r11, =EARLY_UART_ADDRESS /* r11 := UART base address */
diff --git a/xen/arch/arm/xen.lds.S b/xen/arch/arm/xen.lds.S
index 5a62e2c..30fc7b7 100644
--- a/xen/arch/arm/xen.lds.S
+++ b/xen/arch/arm/xen.lds.S
@@ -122,6 +122,11 @@ SECTIONS
} :text
_end = . ;
+ /* XXX: don''t yet have a bootloader to provide the DTB, link it into
+ Xen in its own section. */
+ _sdtb = .;
+ .dtb : { dtb.o(.dtb) } :text
+
/* Sections to be discarded */
/DISCARD/ : {
*(.exit.text)
--
1.7.2.5
David Vrabel
2012-Feb-10 13:03 UTC
[PATCH 5/8] arm: map device tree blob in initial page tables
From: David Vrabel <david.vrabel@citrix.com>
Add a mapping for the device tree blob in the initial page tables.
This will allow the DTB to be parsed for memory information prior to
setting up the real page tables.
It is mapped into the first L2 slot after the fixmap. When this slot
is reused in setup_pagetables(), flush the TLB.
Signed-off-by: David Vrabel <david.vrabel@citrix.com>
---
xen/arch/arm/head.S | 9 +++++++++
xen/arch/arm/mm.c | 5 +++--
xen/include/asm-arm/config.h | 6 ++++++
3 files changed, 18 insertions(+), 2 deletions(-)
diff --git a/xen/arch/arm/head.S b/xen/arch/arm/head.S
index 22ac512..51c26f6 100644
--- a/xen/arch/arm/head.S
+++ b/xen/arch/arm/head.S
@@ -200,7 +200,16 @@ hyp:
orr r2, r2, #0x071 /* r2:r3 := 2MB dev map including UART */
add r4, r4, #8
strd r2, r3, [r1, r4] /* Map it in the fixmap''s slot */
+#else
+ add r4, r4, #8 /* Skip over unused fixmap slot */
#endif
+ mov r3, #0x0
+ lsr r2, r8, #21
+ lsl r2, r2, #21 /* 2MB-aligned paddr of DTB */
+ orr r2, r2, #0xf00
+ orr r2, r2, #0x07d /* r2:r3 := 2MB RAM incl. DTB */
+ add r4, r4, #8
+ strd r2, r3, [r1, r4] /* Map it in the early boot slot */
PRINT("- Turning on paging -\r\n")
diff --git a/xen/arch/arm/mm.c b/xen/arch/arm/mm.c
index c863507..f1fe4ba 100644
--- a/xen/arch/arm/mm.c
+++ b/xen/arch/arm/mm.c
@@ -161,10 +161,11 @@ void __init setup_pagetables(unsigned long
boot_phys_offset)
xen_paddr = XEN_PADDR;
- /* Map the destination in the empty L2 above the fixmap */
- dest_va = FIXMAP_ADDR(0) + (1u << SECOND_SHIFT);
+ /* Map the destination in the boot misc area. */
+ dest_va = BOOT_MISC_VIRT_START;
pte = mfn_to_xen_entry(xen_paddr >> PAGE_SHIFT);
write_pte(xen_second + second_table_offset(dest_va), pte);
+ flush_xen_data_tlb_va(dest_va);
/* Calculate virt-to-phys offset for the new location */
phys_offset = xen_paddr - (unsigned long) _start;
diff --git a/xen/include/asm-arm/config.h b/xen/include/asm-arm/config.h
index 9294f8f..c2ab0a2 100644
--- a/xen/include/asm-arm/config.h
+++ b/xen/include/asm-arm/config.h
@@ -55,15 +55,21 @@
* 0 - 2M Unmapped
* 2M - 4M Xen text, data, bss
* 4M - 6M Fixmap: special-purpose 4K mapping slots
+ * 6M - 8M Early boot misc (see below)
*
* 32M - 128M Frametable: 24 bytes per page for 16GB of RAM
*
* 1G - 2G Xenheap: always-mapped memory
* 2G - 4G Domheap: on-demand-mapped
+ *
+ * The early boot misc area is used:
+ * - in head.S for the DTB for device_tree_early_init().
+ * - in setup_pagetables() when relocating Xen.
*/
#define XEN_VIRT_START 0x00200000
#define FIXMAP_ADDR(n) (0x00400000 + (n) * PAGE_SIZE)
+#define BOOT_MISC_VIRT_START 0x00600000
#define FRAMETABLE_VIRT_START 0x02000000
#define XENHEAP_VIRT_START 0x40000000
#define DOMHEAP_VIRT_START 0x80000000
--
1.7.2.5
From: David Vrabel <david.vrabel@citrix.com>
Add early_printk() which can be used before setup_pagetables(). This
will be used when doing the early parsing of the DTB.
Signed-off-by: David Vrabel <david.vrabel@citrix.com>
---
xen/arch/arm/Makefile | 1 +
xen/arch/arm/early_printk.c | 72 ++++++++++++++++++++++++++++++++++++
xen/include/asm-arm/early_printk.h | 27 +++++++++++++
3 files changed, 100 insertions(+), 0 deletions(-)
create mode 100644 xen/arch/arm/early_printk.c
create mode 100644 xen/include/asm-arm/early_printk.h
diff --git a/xen/arch/arm/Makefile b/xen/arch/arm/Makefile
index ac346a5..4794cfc 100644
--- a/xen/arch/arm/Makefile
+++ b/xen/arch/arm/Makefile
@@ -2,6 +2,7 @@ subdir-y += lib
obj-y += dtb.o
obj-y += dummy.o
+obj-y += early_printk.o
obj-y += entry.o
obj-y += domain.o
obj-y += domain_build.o
diff --git a/xen/arch/arm/early_printk.c b/xen/arch/arm/early_printk.c
new file mode 100644
index 0000000..3e51252
--- /dev/null
+++ b/xen/arch/arm/early_printk.c
@@ -0,0 +1,72 @@
+/*
+ * printk() for use before the final page tables are setup.
+ *
+ * Copyright (C) 2012 Citrix Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <xen/config.h>
+#include <xen/init.h>
+#include <xen/lib.h>
+#include <xen/stdarg.h>
+#include <xen/string.h>
+#include <asm/early_printk.h>
+
+#ifdef EARLY_UART_ADDRESS
+
+static void __init early_putch(char c)
+{
+ volatile uint32_t *r;
+
+ r = (uint32_t *)((EARLY_UART_ADDRESS & 0x001fffff)
+ + XEN_VIRT_START + (1 << 21));
+
+ /* XXX: assuming a PL011 UART. */
+ while(*(r + 0x6) & 0x8)
+ ;
+ *r = c;
+}
+
+static void __init early_puts(const char *s)
+{
+ while (*s != ''\0'') {
+ if (*s == ''\n'')
+ early_putch(''\r'');
+ early_putch(*s);
+ s++;
+ }
+}
+
+static void __init early_vprintk(const char *fmt, va_list args)
+{
+ char buf[80];
+
+ vsnprintf(buf, sizeof(buf), fmt, args);
+ early_puts(buf);
+}
+
+void __init early_printk(const char *fmt, ...)
+{
+ va_list args;
+
+ va_start(args, fmt);
+ early_vprintk(fmt, args);
+ va_end(args);
+}
+
+void __attribute__((noreturn)) __init
+early_panic(const char *fmt, ...)
+{
+ va_list args;
+
+ va_start(args, fmt);
+ early_vprintk(fmt, args);
+ va_end(args);
+
+ while(1);
+}
+
+#endif /* #ifdef EARLY_UART_ADDRESS */
diff --git a/xen/include/asm-arm/early_printk.h
b/xen/include/asm-arm/early_printk.h
new file mode 100644
index 0000000..f45f21e
--- /dev/null
+++ b/xen/include/asm-arm/early_printk.h
@@ -0,0 +1,27 @@
+/*
+ * printk() for use before the final page tables are setup.
+ *
+ * Copyright (C) 2012 Citrix Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef __ARM_EARLY_PRINTK_H__
+#define __ARM_EARLY_PRINTK_H__
+
+#include <xen/config.h>
+
+#ifdef EARLY_UART_ADDRESS
+
+void early_printk(const char *fmt, ...);
+void early_panic(const char *fmt, ...);
+
+#else
+
+static inline void early_printk(const char *fmt, ...) {}
+static inline void early_panic(const char *fmt, ...) {}
+
+#endif
+
+#endif
--
1.7.2.5
David Vrabel
2012-Feb-10 13:03 UTC
[PATCH 7/8] arm, device tree: parse the DTB for RAM location and size
From: David Vrabel <david.vrabel@citrix.com>
Prior to setting up the page tables, parse the DTB for the location
and size of RAM.
Use this information to get the physical address to relocate Xen to in
setup_pagetables().
Signed-off-by: David Vrabel <david.vrabel@citrix.com>
---
xen/arch/arm/mm.c | 3 +-
xen/arch/arm/setup.c | 5 +
xen/common/Makefile | 3 +
xen/common/device_tree.c | 179 +++++++++++++++++++++++++++++++++++++++++
xen/include/asm-arm/mm.h | 5 +-
xen/include/xen/device_tree.h | 36 ++++++++
6 files changed, 227 insertions(+), 4 deletions(-)
create mode 100644 xen/common/device_tree.c
create mode 100644 xen/include/xen/device_tree.h
diff --git a/xen/arch/arm/mm.c b/xen/arch/arm/mm.c
index f1fe4ba..24f977c 100644
--- a/xen/arch/arm/mm.c
+++ b/xen/arch/arm/mm.c
@@ -20,6 +20,7 @@
#include <xen/config.h>
#include <xen/compile.h>
#include <xen/types.h>
+#include <xen/device_tree.h>
#include <xen/init.h>
#include <xen/mm.h>
#include <xen/preempt.h>
@@ -159,7 +160,7 @@ void __init setup_pagetables(unsigned long boot_phys_offset)
write_pte(xen_second + second_linear_offset(dest_va), pte);
}
- xen_paddr = XEN_PADDR;
+ xen_paddr = device_tree_get_xen_paddr();
/* Map the destination in the boot misc area. */
dest_va = BOOT_MISC_VIRT_START;
diff --git a/xen/arch/arm/setup.c b/xen/arch/arm/setup.c
index 51afb31..e212a2e 100644
--- a/xen/arch/arm/setup.c
+++ b/xen/arch/arm/setup.c
@@ -19,6 +19,7 @@
#include <xen/config.h>
#include <xen/compile.h>
+#include <xen/device_tree.h>
#include <xen/domain_page.h>
#include <xen/types.h>
#include <xen/string.h>
@@ -68,8 +69,12 @@ void __init start_xen(unsigned long boot_phys_offset,
unsigned long atag_paddr)
{
+ void *fdt;
int i;
+ fdt = (void *)BOOT_MISC_VIRT_START + (atag_paddr & ((1 <<
SECOND_SHIFT) - 1));
+ device_tree_early_init(fdt);
+
setup_pagetables(boot_phys_offset);
#ifdef EARLY_UART_ADDRESS
diff --git a/xen/common/Makefile b/xen/common/Makefile
index 4b1e6f2..372b259 100644
--- a/xen/common/Makefile
+++ b/xen/common/Makefile
@@ -1,6 +1,7 @@
obj-y += bitmap.o
obj-y += cpu.o
obj-y += cpupool.o
+obj-$(HAS_DEVICE_TREE) += device_tree.o
obj-y += domctl.o
obj-y += domain.o
obj-y += event_channel.o
@@ -60,3 +61,5 @@ subdir-$(ia64) += hvm
subdir-y += libelf
subdir-$(HAS_DEVICE_TREE) += libfdt
+
+CFLAGS += -Ilibfdt
diff --git a/xen/common/device_tree.c b/xen/common/device_tree.c
new file mode 100644
index 0000000..a60ff6d
--- /dev/null
+++ b/xen/common/device_tree.c
@@ -0,0 +1,179 @@
+/*
+ * Device Tree
+ *
+ * Copyright (C) 2012 Citrix Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <xen/config.h>
+#include <xen/types.h>
+#include <xen/init.h>
+#include <xen/device_tree.h>
+#include <xen/kernel.h>
+#include <xen/lib.h>
+#include <xen/mm.h>
+#include <xen/stdarg.h>
+#include <xen/string.h>
+#include <asm/early_printk.h>
+
+#include <libfdt.h>
+
+struct dt_early_info __initdata early_info;
+
+static void __init get_val(const u32 **cell, u32 cells, u64 *val)
+{
+ *val = 0;
+
+ while (cells--) {
+ *val <<= 32;
+ *val |= fdt32_to_cpu(*(*cell)++);
+ }
+}
+
+static void __init get_register(const u32 **cell, u32 address_cells, u32
size_cells,
+ u64 *start, u64 *size)
+{
+ get_val(cell, address_cells, start);
+ get_val(cell, size_cells, size);
+}
+
+static u32 __init prop_by_name_u32(const void *fdt, int node, const char
*prop_name)
+{
+ const struct fdt_property *prop;
+
+ prop = fdt_get_property(fdt, node, prop_name, NULL);
+ if (!prop || prop->len < sizeof(u32))
+ return 0; /* default to 0 */
+
+ return fdt32_to_cpu(*(uint32_t*)prop->data);
+}
+
+static void __init process_memory_node(const void *fdt, int node,
+ u32 address_cells, u32 size_cells)
+{
+ const struct fdt_property *prop;
+ size_t reg_cells;
+ int i;
+ int banks;
+ const u32 *cell;
+ paddr_t start, size;
+
+ if (address_cells < 1 || size_cells < 1) {
+ early_printk("fdt: node `%s'': invalid #address-cells or
#size-cells",
+ fdt_get_name(fdt, node, NULL));
+ return;
+ }
+
+ prop = fdt_get_property(fdt, node, "reg", NULL);
+ if (!prop) {
+ early_printk("fdt: node `%s'': missing `reg''
property\n",
+ fdt_get_name(fdt, node, NULL));
+ return;
+ }
+
+ cell = (const u32 *)prop->data;
+ reg_cells = address_cells + size_cells;
+ banks = fdt32_to_cpu(prop->len) / (reg_cells * sizeof(u32));
+
+ for (i = 0; i < banks; i++) {
+ get_register(&cell, address_cells, size_cells, &start,
&size);
+ early_info.mem.bank[early_info.mem.nr_banks].start = start;
+ early_info.mem.bank[early_info.mem.nr_banks].size = size;
+ early_info.mem.nr_banks++;
+ }
+}
+
+#define MAX_DEPTH 16
+
+static void __init early_scan(const void *fdt)
+{
+ int node;
+ int depth;
+ const char *name;
+ u32 address_cells[MAX_DEPTH];
+ u32 size_cells[MAX_DEPTH];
+
+ for (node = 0; depth >= 0; node = fdt_next_node(fdt, node, &depth))
{
+ name = fdt_get_name(fdt, node, NULL);
+
+ if (depth >= MAX_DEPTH) {
+ early_printk("fdt: node ''%s'': nested too
deep\n",
+ fdt_get_name(fdt, node, NULL));
+ continue;
+ }
+
+ address_cells[depth] = prop_by_name_u32(fdt, node,
"#address-cells");
+ size_cells[depth] = prop_by_name_u32(fdt, node,
"#size-cells");
+
+ if (strncmp(name, "memory", 6) == 0)
+ process_memory_node(fdt, node, address_cells[depth-1],
size_cells[depth-1]);
+ }
+}
+
+static void __init early_print_info(void)
+{
+ struct dt_mem_info *mi = &early_info.mem;
+ int i;
+
+ for (i = 0; i < mi->nr_banks; i++)
+ early_printk("RAM: %016llx - %016llx\n",
+ mi->bank[i].start, mi->bank[i].start +
mi->bank[i].size - 1);
+}
+
+/**
+ * device_tree_early_init - initialize early info from a DTB
+ * @fdt: flattened device tree binary
+ */
+void __init device_tree_early_init(const void *fdt)
+{
+ int ret;
+
+ ret = fdt_check_header(fdt);
+ if (ret < 0)
+ early_panic("No valid device tree\n");
+
+ early_scan(fdt);
+ early_print_info();
+}
+
+/**
+ * device_tree_get_xen_paddr - get physical address to relocate Xen to
+ *
+ * Xen is relocated to the top of RAM and aligned to a XEN_PADDR_ALIGN
+ * boundary.
+ */
+paddr_t __init device_tree_get_xen_paddr(void)
+{
+ struct dt_mem_info *mi = &early_info.mem;
+ paddr_t min_size;
+ paddr_t paddr = 0, t;
+ int i;
+
+ min_size = (_end - _start + (XEN_PADDR_ALIGN-1)) &
~(XEN_PADDR_ALIGN-1);
+
+ /* Find the highest bank with enough space. */
+ for (i = 0; i < mi->nr_banks; i++) {
+ if (mi->bank[i].size >= min_size) {
+ t = mi->bank[i].start + mi->bank[i].size - min_size;
+ if (t > paddr)
+ paddr = t;
+ }
+ }
+
+ if (!paddr)
+ early_panic("Not enough memory to relocate Xen\n");
+
+ return paddr;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-set-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/xen/include/asm-arm/mm.h b/xen/include/asm-arm/mm.h
index f721c54..8efa63b 100644
--- a/xen/include/asm-arm/mm.h
+++ b/xen/include/asm-arm/mm.h
@@ -6,9 +6,8 @@
#include <asm/page.h>
#include <public/xen.h>
-/* Find a suitable place at the top of memory for Xen to live */
-/* XXX For now, use the top of the VE''s 4GB RAM, at a 40-bit alias */
-#define XEN_PADDR 0x80ffe00000ull
+/* Align Xen to a 2 MiB boundary. */
+#define XEN_PADDR_ALIGN (1 << 21)
/*
* Per-page-frame information.
diff --git a/xen/include/xen/device_tree.h b/xen/include/xen/device_tree.h
new file mode 100644
index 0000000..eb7f219
--- /dev/null
+++ b/xen/include/xen/device_tree.h
@@ -0,0 +1,36 @@
+/*
+ * Device Tree
+ *
+ * Copyright (C) 2012 Citrix Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef __XEN_DEVICE_TREE_H__
+#define __XEN_DEVICE_TREE_H__
+
+#include <xen/types.h>
+
+#define NR_MEM_BANKS 8
+
+struct membank {
+ paddr_t start;
+ paddr_t size;
+};
+
+struct dt_mem_info {
+ int nr_banks;
+ struct membank bank[NR_MEM_BANKS];
+};
+
+struct dt_early_info {
+ struct dt_mem_info mem;
+};
+
+extern struct dt_early_info early_info;
+
+void device_tree_early_init(const void *fdt);
+paddr_t device_tree_get_xen_paddr(void);
+
+#endif
--
1.7.2.5
David Vrabel
2012-Feb-10 13:03 UTC
[PATCH 8/8] arm: setup MM using information from the device tree
From: David Vrabel <david.vrabel@citrix.com>
Setup memory management, heaps etc. using the location and size of the
first memory bank given in the device tree.
The DTB is also copied so it can be used afterwards.
Signed-off-by: David Vrabel <david.vrabel@citrix.com>
---
xen/arch/arm/kernel.c | 22 +++++----
xen/arch/arm/mm.c | 3 +
xen/arch/arm/setup.c | 98 +++++++++++++++++++++++++++++++----------
xen/common/device_tree.c | 7 +++-
xen/include/asm-arm/mm.h | 11 +++--
xen/include/asm-arm/setup.h | 2 +
xen/include/xen/device_tree.h | 3 +-
7 files changed, 107 insertions(+), 39 deletions(-)
diff --git a/xen/arch/arm/kernel.c b/xen/arch/arm/kernel.c
index d4ffa4f..f2339fa 100644
--- a/xen/arch/arm/kernel.c
+++ b/xen/arch/arm/kernel.c
@@ -11,6 +11,7 @@
#include <xen/domain_page.h>
#include <xen/sched.h>
#include <asm/byteorder.h>
+#include <asm/setup.h>
#include "kernel.h"
@@ -32,25 +33,28 @@ struct minimal_dtb_header {
#define DTB_MAGIC 0xd00dfeed
-static void copy_from_flash(void *dst, paddr_t flash, unsigned long len)
+/**
+ * copy_from_paddr - copy data from a physical address
+ * @dst: destination virtual address
+ * @paddr: source physical address
+ * @len: length to copy
+ */
+void copy_from_paddr(void *dst, paddr_t paddr, unsigned long len)
{
void *src = (void *)FIXMAP_ADDR(FIXMAP_MISC);
- printk("Copying %#lx bytes from flash %"PRIpaddr" to
%p",
- len, flash, dst);
-
while (len) {
paddr_t p;
unsigned long l, s;
- p = flash >> PAGE_SHIFT;
- s = flash & (PAGE_SIZE-1);
+ p = paddr >> PAGE_SHIFT;
+ s = paddr & (PAGE_SIZE-1);
l = min(PAGE_SIZE - s, len);
set_fixmap(FIXMAP_MISC, p, DEV_SHARED);
memcpy(dst, src + s, l);
- flash += l;
+ paddr += l;
dst += l;
len -= l;
}
@@ -108,7 +112,7 @@ static int kernel_try_zimage_prepare(struct kernel_info
*info)
/*
* Check for an appended DTB.
*/
- copy_from_flash(&dtb_hdr, KERNEL_FLASH_ADDRESS + end - start,
sizeof(dtb_hdr));
+ copy_from_paddr(&dtb_hdr, KERNEL_FLASH_ADDRESS + end - start,
sizeof(dtb_hdr));
if (be32_to_cpu(dtb_hdr.magic) == DTB_MAGIC) {
end += be32_to_cpu(dtb_hdr.total_size);
}
@@ -150,7 +154,7 @@ static int kernel_try_elf_prepare(struct kernel_info *info)
if ( info->kernel_img == NULL )
panic("Cannot allocate temporary buffer for kernel.\n");
- copy_from_flash(info->kernel_img, KERNEL_FLASH_ADDRESS,
KERNEL_FLASH_SIZE);
+ copy_from_paddr(info->kernel_img, KERNEL_FLASH_ADDRESS,
KERNEL_FLASH_SIZE);
if ( (rc = elf_init(&info->elf.elf, info->kernel_img,
KERNEL_FLASH_SIZE )) != 0 )
return rc;
diff --git a/xen/arch/arm/mm.c b/xen/arch/arm/mm.c
index 24f977c..0d6c0ca 100644
--- a/xen/arch/arm/mm.c
+++ b/xen/arch/arm/mm.c
@@ -39,6 +39,7 @@ static lpae_t xen_xenmap[LPAE_ENTRIES]
__attribute__((__aligned__(4096)));
unsigned long xenheap_mfn_start, xenheap_mfn_end;
unsigned long xenheap_virt_end;
+unsigned long frametable_base_mfn;
unsigned long frametable_virt_end;
/* Map a 4k page in a fixmap entry */
@@ -301,6 +302,8 @@ void __init setup_frametable_mappings(paddr_t ps, paddr_t
pe)
unsigned long frametable_size = nr_pages * sizeof(struct page_info);
unsigned long base_mfn;
+ frametable_base_mfn = ps >> PAGE_SHIFT;
+
/* Round up to 32M boundary */
frametable_size = (frametable_size + 0x1ffffff) & ~0x1ffffff;
base_mfn = alloc_boot_pages(frametable_size >> PAGE_SHIFT, 5);
diff --git a/xen/arch/arm/setup.c b/xen/arch/arm/setup.c
index e212a2e..eff7098 100644
--- a/xen/arch/arm/setup.c
+++ b/xen/arch/arm/setup.c
@@ -64,16 +64,89 @@ static void __init init_idle_domain(void)
/* TODO: setup_idle_pagetable(); */
}
+static void __init setup_mm(unsigned long dtb_paddr, size_t dtb_size)
+{
+ paddr_t ram_start;
+ paddr_t ram_end;
+ paddr_t ram_size;
+ unsigned long ram_pages;
+ unsigned long heap_pages, xenheap_pages, domheap_pages;
+ unsigned long dtb_pages;
+ unsigned long boot_mfn_start, boot_mfn_end;
+
+ /*
+ * TODO: only using the first RAM bank for now. The heaps and the
+ * frame table assume RAM is physically contiguous.
+ */
+ ram_start = early_info.mem.bank[0].start;
+ ram_size = early_info.mem.bank[0].size;
+ ram_end = ram_start + ram_size;
+ ram_pages = ram_size >> PAGE_SHIFT;
+
+ /*
+ * Calculate the sizes for the heaps using these constraints:
+ *
+ * - heaps must be 32 MiB aligned
+ * - must not include Xen itself
+ * - xen heap must be at most 1 GiB
+ *
+ * XXX: needs a platform with at least 1GiB of RAM or the dom
+ * heap will be empty and no domains can be created.
+ */
+ heap_pages = (ram_size >> PAGE_SHIFT) - (32 << (20 -
PAGE_SHIFT));
+ xenheap_pages = min(1ul << (30 - PAGE_SHIFT), heap_pages);
+ domheap_pages = heap_pages - xenheap_pages;
+
+ printk("Xen heap: %lu pages Dom heap: %lu pages\n",
xenheap_pages, domheap_pages);
+
+ setup_xenheap_mappings(ram_start >> PAGE_SHIFT, xenheap_pages);
+
+ /*
+ * Need a single mapped page for populating bootmem_region_list
+ * and enough mapped pages for copying the DTB.
+ *
+ * TODO: The DTB (and other payloads) are assumed to be towards
+ * the start of RAM.
+ */
+ dtb_pages = (dtb_size + PAGE_SIZE-1) >> PAGE_SHIFT;
+ boot_mfn_start = xenheap_mfn_end - dtb_pages - 1;
+ boot_mfn_end = xenheap_mfn_end;
+
+ init_boot_pages(pfn_to_paddr(boot_mfn_start), pfn_to_paddr(boot_mfn_end));
+
+ /*
+ * Copy the DTB.
+ *
+ * TODO: handle other payloads too.
+ */
+ device_tree_flattened = mfn_to_virt(alloc_boot_pages(dtb_pages, 1));
+ copy_from_paddr(device_tree_flattened, dtb_paddr, dtb_size);
+
+ /* Add non-xenheap memory */
+ init_boot_pages(pfn_to_paddr(xenheap_mfn_start + xenheap_pages),
+ pfn_to_paddr(xenheap_mfn_start + xenheap_pages +
domheap_pages));
+
+ setup_frametable_mappings(ram_start, ram_end);
+
+ /* Add xenheap memory that was not already added to the boot
+ allocator. */
+ init_xenheap_pages(pfn_to_paddr(xenheap_mfn_start),
+ pfn_to_paddr(boot_mfn_start));
+
+ end_boot_allocator();
+}
+
void __init start_xen(unsigned long boot_phys_offset,
unsigned long arm_type,
unsigned long atag_paddr)
{
void *fdt;
+ size_t fdt_size;
int i;
fdt = (void *)BOOT_MISC_VIRT_START + (atag_paddr & ((1 <<
SECOND_SHIFT) - 1));
- device_tree_early_init(fdt);
+ fdt_size = device_tree_early_init(fdt);
setup_pagetables(boot_phys_offset);
@@ -97,28 +170,7 @@ void __init start_xen(unsigned long boot_phys_offset,
init_xen_time();
- /* TODO: This needs some thought, as well as device-tree mapping.
- * For testing, assume that the whole xenheap is contiguous in RAM */
- setup_xenheap_mappings(0x8000000, 0x40000); /* 1 GB @ 512GB */
- /* Must pass a single mapped page for populating bootmem_region_list. */
- init_boot_pages(pfn_to_paddr(xenheap_mfn_start),
- pfn_to_paddr(xenheap_mfn_start+1));
-
- /* Add non-xenheap memory */
- init_boot_pages(0x8040000000, 0x80c0000000); /* 2 GB @513GB */
-
- /* TODO Make sure Xen''s own pages aren''t added
- * -- the memory above doesn''t include our relocation target.
*/
- /* TODO Handle payloads too */
-
- /* TODO Need to find actual memory, for now use 4GB at 512GB */
- setup_frametable_mappings(0x8000000000ULL, 0x8100000000UL);
-
- /* Add xenheap memory */
- init_xenheap_pages(pfn_to_paddr(xenheap_mfn_start+1),
- pfn_to_paddr(xenheap_mfn_end));
-
- end_boot_allocator();
+ setup_mm(atag_paddr, fdt_size);
/* Setup Hyp vector base */
WRITE_CP32((uint32_t) hyp_traps_vector, HVBAR);
diff --git a/xen/common/device_tree.c b/xen/common/device_tree.c
index a60ff6d..788b2d3 100644
--- a/xen/common/device_tree.c
+++ b/xen/common/device_tree.c
@@ -22,6 +22,7 @@
#include <libfdt.h>
struct dt_early_info __initdata early_info;
+void *device_tree_flattened;
static void __init get_val(const u32 **cell, u32 cells, u64 *val)
{
@@ -126,8 +127,10 @@ static void __init early_print_info(void)
/**
* device_tree_early_init - initialize early info from a DTB
* @fdt: flattened device tree binary
+ *
+ * Returns the size of the DTB.
*/
-void __init device_tree_early_init(const void *fdt)
+size_t __init device_tree_early_init(const void *fdt)
{
int ret;
@@ -137,6 +140,8 @@ void __init device_tree_early_init(const void *fdt)
early_scan(fdt);
early_print_info();
+
+ return fdt_totalsize(fdt);
}
/**
diff --git a/xen/include/asm-arm/mm.h b/xen/include/asm-arm/mm.h
index 8efa63b..bfc0f76 100644
--- a/xen/include/asm-arm/mm.h
+++ b/xen/include/asm-arm/mm.h
@@ -128,6 +128,8 @@ extern void share_xen_page_with_privileged_guests(
struct page_info *page, int readonly);
#define frame_table ((struct page_info *)FRAMETABLE_VIRT_START)
+/* MFN of the first page in the frame table. */
+extern unsigned long frametable_base_mfn;
extern unsigned long max_page;
extern unsigned long total_pages;
@@ -151,15 +153,14 @@ extern void clear_fixmap(unsigned map);
})
#define max_pdx max_page
-/* XXX Assume everything in the 40-bit physical alias 0x8000000000 for now */
-#define pfn_to_pdx(pfn) ((pfn) - 0x8000000UL)
-#define pdx_to_pfn(pdx) ((pdx) + 0x8000000UL)
+#define pfn_to_pdx(pfn) (pfn)
+#define pdx_to_pfn(pdx) (pdx)
#define virt_to_pdx(va) virt_to_mfn(va)
#define pdx_to_virt(pdx) mfn_to_virt(pdx)
/* Convert between machine frame numbers and page-info structures. */
-#define mfn_to_page(mfn) (frame_table + pfn_to_pdx(mfn))
-#define page_to_mfn(pg) pdx_to_pfn((unsigned long)((pg) - frame_table))
+#define mfn_to_page(mfn) (frame_table + (pfn_to_pdx(mfn) -
frametable_base_mfn))
+#define page_to_mfn(pg) pdx_to_pfn((unsigned long)((pg) - frame_table) +
frametable_base_mfn)
#define __page_to_mfn(pg) page_to_mfn(pg)
#define __mfn_to_page(mfn) mfn_to_page(mfn)
diff --git a/xen/include/asm-arm/setup.h b/xen/include/asm-arm/setup.h
index 2041f06..05ff89e 100644
--- a/xen/include/asm-arm/setup.h
+++ b/xen/include/asm-arm/setup.h
@@ -3,6 +3,8 @@
#include <public/version.h>
+void copy_from_paddr(void *dst, paddr_t paddr, unsigned long len);
+
void arch_get_xen_caps(xen_capabilities_info_t *info);
int construct_dom0(struct domain *d);
diff --git a/xen/include/xen/device_tree.h b/xen/include/xen/device_tree.h
index eb7f219..3cafdc7 100644
--- a/xen/include/xen/device_tree.h
+++ b/xen/include/xen/device_tree.h
@@ -29,8 +29,9 @@ struct dt_early_info {
};
extern struct dt_early_info early_info;
+extern void *device_tree_flattened;
-void device_tree_early_init(const void *fdt);
+size_t device_tree_early_init(const void *fdt);
paddr_t device_tree_get_xen_paddr(void);
#endif
--
1.7.2.5
Tim Deegan
2012-Feb-10 13:25 UTC
Re: [PATCH 7/8] arm, device tree: parse the DTB for RAM location and size
Hi, At 13:03 +0000 on 10 Feb (1328879023), David Vrabel wrote:> diff --git a/xen/arch/arm/setup.c b/xen/arch/arm/setup.c > index 51afb31..e212a2e 100644 > --- a/xen/arch/arm/setup.c > +++ b/xen/arch/arm/setup.c > @@ -19,6 +19,7 @@ > > #include <xen/config.h> > #include <xen/compile.h> > +#include <xen/device_tree.h> > #include <xen/domain_page.h> > #include <xen/types.h> > #include <xen/string.h> > @@ -68,8 +69,12 @@ void __init start_xen(unsigned long boot_phys_offset, > unsigned long atag_paddr) > > { > + void *fdt; > int i; > > + fdt = (void *)BOOT_MISC_VIRT_START + (atag_paddr & ((1 << SECOND_SHIFT) - 1));Please linewrap below 80 coluns.> +static void __init process_memory_node(const void *fdt, int node, > + u32 address_cells, u32 size_cells) > +{ > + const struct fdt_property *prop; > + size_t reg_cells; > + int i; > + int banks; > + const u32 *cell; > + paddr_t start, size; > + > + if (address_cells < 1 || size_cells < 1) { > + early_printk("fdt: node `%s'': invalid #address-cells or #size-cells", > + fdt_get_name(fdt, node, NULL)); > + return; > + } > + > + prop = fdt_get_property(fdt, node, "reg", NULL); > + if (!prop) { > + early_printk("fdt: node `%s'': missing `reg'' property\n", > + fdt_get_name(fdt, node, NULL)); > + return; > + } > + > + cell = (const u32 *)prop->data; > + reg_cells = address_cells + size_cells; > + banks = fdt32_to_cpu(prop->len) / (reg_cells * sizeof(u32)); > + > + for (i = 0; i < banks; i++) { > + get_register(&cell, address_cells, size_cells, &start, &size); > + early_info.mem.bank[early_info.mem.nr_banks].start = start; > + early_info.mem.bank[early_info.mem.nr_banks].size = size; > + early_info.mem.nr_banks++;This needs a check that you don''t overrun NR_MEM_BANKS. Aside from that, this whole series gets my ack. Cheers, Tim
Ian Campbell
2012-Feb-10 13:35 UTC
Re: [PATCH 4/8] arm: link a device tree blob into the xen image
On Fri, 2012-02-10 at 13:03 +0000, David Vrabel wrote:> From: David Vrabel <david.vrabel@citrix.com> > > Link a device tree blob (DTB) into the xen image. This is loaded > immediately after Xen and xen_start() is called with the correct > address in atag_paddr.Is platform.dtb supposed to be included in this patch/series or is it intended that I should supply it from somewhere? (in which case, how and where etc).> Signed-off-by: David Vrabel <david.vrabel@citrix.com> > --- > xen/arch/arm/Makefile | 7 +++++-- > xen/arch/arm/dtb.S | 2 ++ > xen/arch/arm/head.S | 4 ++++ > xen/arch/arm/xen.lds.S | 5 +++++ > 4 files changed, 16 insertions(+), 2 deletions(-) > create mode 100644 xen/arch/arm/dtb.S > > diff --git a/xen/arch/arm/Makefile b/xen/arch/arm/Makefile > index 9bc2fc8..ac346a5 100644 > --- a/xen/arch/arm/Makefile > +++ b/xen/arch/arm/Makefile > @@ -1,5 +1,6 @@ > subdir-y += lib > > +obj-y += dtb.o > obj-y += dummy.o > obj-y += entry.o > obj-y += domain.o > @@ -27,7 +28,7 @@ ALL_OBJS := head.o $(ALL_OBJS) > $(TARGET): $(TARGET)-syms > # XXX: VE model loads by VMA so instead of > # making a proper ELF we link with LMA == VMA and adjust crudely > - $(OBJCOPY) --change-addresses +0x7fe00000 $< $@ > + $(OBJCOPY) --change-addresses +0x80000000 $< $@ > # XXX strip it > > #$(TARGET): $(TARGET)-syms $(efi-y) boot/mkelf32 > @@ -50,7 +51,7 @@ endif > $(BASEDIR)/common/symbols-dummy.o: > $(MAKE) -f $(BASEDIR)/Rules.mk -C $(BASEDIR)/common symbols-dummy.o > > -$(TARGET)-syms: prelink.o xen.lds $(BASEDIR)/common/symbols-dummy.o > +$(TARGET)-syms: prelink.o xen.lds $(BASEDIR)/common/symbols-dummy.o dtb.o > $(LD) $(LDFLAGS) -T xen.lds -N prelink.o \ > $(BASEDIR)/common/symbols-dummy.o -o $(@D)/.$(@F).0 > $(NM) -n $(@D)/.$(@F).0 | $(BASEDIR)/tools/symbols >$(@D)/.$(@F).0.S > @@ -71,6 +72,8 @@ xen.lds: xen.lds.S > sed -e ''s/xen\.lds\.o:/xen\.lds:/g'' <.xen.lds.d >.xen.lds.d.new > mv -f .xen.lds.d.new .xen.lds.d > > +dtb.o: platform.dtb > + > .PHONY: clean > clean:: > rm -f asm-offsets.s xen.lds > diff --git a/xen/arch/arm/dtb.S b/xen/arch/arm/dtb.S > new file mode 100644 > index 0000000..0728c04 > --- /dev/null > +++ b/xen/arch/arm/dtb.S > @@ -0,0 +1,2 @@ > + .section .dtb,#alloc > + .incbin "platform.dtb" > diff --git a/xen/arch/arm/head.S b/xen/arch/arm/head.S > index 57b990d..22ac512 100644 > --- a/xen/arch/arm/head.S > +++ b/xen/arch/arm/head.S > @@ -55,6 +55,10 @@ start: > adr r9, start /* r9 := paddr (start) */ > sub r10, r9, r0 /* r10 := phys-offset */ > > + /* XXX: using the DTB in the .dtb section. */ > + ldr r8, =_sdtb > + add r8, r10 /* r8 := paddr(DTB) */ > + > #ifdef EARLY_UART_ADDRESS > /* Say hello */ > ldr r11, =EARLY_UART_ADDRESS /* r11 := UART base address */ > diff --git a/xen/arch/arm/xen.lds.S b/xen/arch/arm/xen.lds.S > index 5a62e2c..30fc7b7 100644 > --- a/xen/arch/arm/xen.lds.S > +++ b/xen/arch/arm/xen.lds.S > @@ -122,6 +122,11 @@ SECTIONS > } :text > _end = . ; > > + /* XXX: don''t yet have a bootloader to provide the DTB, link it into > + Xen in its own section. */ > + _sdtb = .; > + .dtb : { dtb.o(.dtb) } :text > + > /* Sections to be discarded */ > /DISCARD/ : { > *(.exit.text)
On Fri, 2012-02-10 at 13:03 +0000, David Vrabel wrote:> From: David Vrabel <david.vrabel@citrix.com> > > 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@citrix.com>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@lists.xensource.com > http://lists.xensource.com/xen-devel
David Vrabel
2012-Feb-10 13:40 UTC
Re: [PATCH 4/8] arm: link a device tree blob into the xen image
On 10/02/12 13:35, Ian Campbell wrote:> On Fri, 2012-02-10 at 13:03 +0000, David Vrabel wrote: >> From: David Vrabel <david.vrabel@citrix.com> >> >> Link a device tree blob (DTB) into the xen image. This is loaded >> immediately after Xen and xen_start() is called with the correct >> address in atag_paddr. > > Is platform.dtb supposed to be included in this patch/series or is it > intended that I should supply it from somewhere? (in which case, how and > where etc).I make a symlink to vexpress-v2p-aem-v7a.dtb built in my Linux tree. Would it be better build the DTB from source included in Xen? Or specify the DTB in some other way (makefile variables?)? David
Ian Campbell
2012-Feb-10 13:52 UTC
Re: [PATCH 4/8] arm: link a device tree blob into the xen image
On Fri, 2012-02-10 at 13:40 +0000, David Vrabel wrote:> On 10/02/12 13:35, Ian Campbell wrote: > > On Fri, 2012-02-10 at 13:03 +0000, David Vrabel wrote: > >> From: David Vrabel <david.vrabel@citrix.com> > >> > >> Link a device tree blob (DTB) into the xen image. This is loaded > >> immediately after Xen and xen_start() is called with the correct > >> address in atag_paddr. > > > > Is platform.dtb supposed to be included in this patch/series or is it > > intended that I should supply it from somewhere? (in which case, how and > > where etc). > > I make a symlink to vexpress-v2p-aem-v7a.dtb built in my Linux tree. > > Would it be better build the DTB from source included in Xen?I guess that''s what Linux has done but I don''t know if we want to replicate all that and keep syncing etc. On the flip side I suppose it''s currently only a single platform. Does Linux have an "upstream" for its DTB stuff or is it all done in tree?> Or specify the DTB in some other way (makefile variables?)?A CONFIG_mumble would be a quick and easy thing to do as a placeholder if nothing else. Ian.
Tim Deegan
2012-Feb-10 16:50 UTC
Re: [PATCH 4/8] arm: link a device tree blob into the xen image
At 13:52 +0000 on 10 Feb (1328881958), Ian Campbell wrote:> On Fri, 2012-02-10 at 13:40 +0000, David Vrabel wrote: > > On 10/02/12 13:35, Ian Campbell wrote: > > > On Fri, 2012-02-10 at 13:03 +0000, David Vrabel wrote: > > >> From: David Vrabel <david.vrabel@citrix.com> > > >> > > >> Link a device tree blob (DTB) into the xen image. This is loaded > > >> immediately after Xen and xen_start() is called with the correct > > >> address in atag_paddr. > > > > > > Is platform.dtb supposed to be included in this patch/series or is it > > > intended that I should supply it from somewhere? (in which case, how and > > > where etc). > > > > I make a symlink to vexpress-v2p-aem-v7a.dtb built in my Linux tree. > > > > Would it be better build the DTB from source included in Xen? > > I guess that''s what Linux has done but I don''t know if we want to > replicate all that and keep syncing etc. On the flip side I suppose it''s > currently only a single platform.I think we should take it into our tree in some form, unless there''s a way to automatically extract it from the dom0 kernel at boot. It should be possible to recompile Xen without needing to configure and build a linux kernel. In theory this will eventually be provided by the bootloader or firmware, right? Tim.
David Vrabel
2012-Feb-10 17:38 UTC
Re: [PATCH 4/8] arm: link a device tree blob into the xen image
On 10/02/12 16:50, Tim Deegan wrote:> At 13:52 +0000 on 10 Feb (1328881958), Ian Campbell wrote: >> On Fri, 2012-02-10 at 13:40 +0000, David Vrabel wrote: >>> On 10/02/12 13:35, Ian Campbell wrote: >>>> On Fri, 2012-02-10 at 13:03 +0000, David Vrabel wrote: >>>>> From: David Vrabel <david.vrabel@citrix.com> >>>>> >>>>> Link a device tree blob (DTB) into the xen image. This is loaded >>>>> immediately after Xen and xen_start() is called with the correct >>>>> address in atag_paddr. >>>> >>>> Is platform.dtb supposed to be included in this patch/series or is it >>>> intended that I should supply it from somewhere? (in which case, how and >>>> where etc). >>> >>> I make a symlink to vexpress-v2p-aem-v7a.dtb built in my Linux tree. >>> >>> Would it be better build the DTB from source included in Xen? >> >> I guess that''s what Linux has done but I don''t know if we want to >> replicate all that and keep syncing etc. On the flip side I suppose it''s >> currently only a single platform. > > I think we should take it into our tree in some form, unless there''s a > way to automatically extract it from the dom0 kernel at boot. It should > be possible to recompile Xen without needing to configure and build a > linux kernel.I''m going to take the device trees out of the kernel and put them in a separate repository. The DTB can be built independantly of Xen and Linux and easily hacked on for local changes (e.g., to change the Xen/Linux command lines). You will be able to specify the DTB to include in Xen by setting the DTB make variable (either on the command line or in .config). This sound ok?> In theory this will eventually be provided by the bootloader or > firmware, right?Yes. David
Ian Campbell
2012-Feb-10 17:46 UTC
Re: [PATCH 4/8] arm: link a device tree blob into the xen image
On Fri, 2012-02-10 at 17:38 +0000, David Vrabel wrote:> On 10/02/12 16:50, Tim Deegan wrote: > > At 13:52 +0000 on 10 Feb (1328881958), Ian Campbell wrote: > >> On Fri, 2012-02-10 at 13:40 +0000, David Vrabel wrote: > >>> On 10/02/12 13:35, Ian Campbell wrote: > >>>> On Fri, 2012-02-10 at 13:03 +0000, David Vrabel wrote: > >>>>> From: David Vrabel <david.vrabel@citrix.com> > >>>>> > >>>>> Link a device tree blob (DTB) into the xen image. This is loaded > >>>>> immediately after Xen and xen_start() is called with the correct > >>>>> address in atag_paddr. > >>>> > >>>> Is platform.dtb supposed to be included in this patch/series or is it > >>>> intended that I should supply it from somewhere? (in which case, how and > >>>> where etc). > >>> > >>> I make a symlink to vexpress-v2p-aem-v7a.dtb built in my Linux tree. > >>> > >>> Would it be better build the DTB from source included in Xen? > >> > >> I guess that''s what Linux has done but I don''t know if we want to > >> replicate all that and keep syncing etc. On the flip side I suppose it''s > >> currently only a single platform. > > > > I think we should take it into our tree in some form, unless there''s a > > way to automatically extract it from the dom0 kernel at boot. It should > > be possible to recompile Xen without needing to configure and build a > > linux kernel. > > I''m going to take the device trees out of the kernel and put them in a > separate repository. The DTB can be built independantly of Xen and > Linux and easily hacked on for local changes (e.g., to change the > Xen/Linux command lines). > > You will be able to specify the DTB to include in Xen by setting the DTB > make variable (either on the command line or in .config).I''m happy with having just the .config option in the hypervisor for the time being until we see how the chips land WRT bootloader adoption of device tree etc. Ian.