[rtems commit] libfdt: Initial import
Joel Sherrill
joel.sherrill at oarcorp.com
Mon Oct 19 22:39:02 UTC 2015
Did I miss all discussion and review of this patch set?
On 10/16/2015 12:47 AM, Sebastian Huber wrote:
> Module: rtems
> Branch: master
> Commit: 175263ec91f00f6668ae7f28f385850a1c77bf6b
> Changeset: http://git.rtems.org/rtems/commit/?id=175263ec91f00f6668ae7f28f385850a1c77bf6b
>
> Author: Sebastian Huber <sebastian.huber at embedded-brains.de>
> Date: Thu Oct 15 11:38:03 2015 +0200
>
> libfdt: Initial import
>
> Import from:
>
> git://git.kernel.org/pub/scm/utils/dtc/dtc.git
>
> Commit:
>
> 604e61e081e3c6c8fa1a8189c71cb3908a5bbc1e
>
> Date:
>
> 2015-09-29T09:09:08Z
>
> ---
>
> cpukit/Makefile.am | 1 +
> cpukit/configure.ac | 1 +
> cpukit/dtc/README | 20 +
> cpukit/dtc/README.license | 56 +
> cpukit/dtc/libfdt/Makefile.am | 19 +
> cpukit/dtc/libfdt/TODO | 3 +
> cpukit/dtc/libfdt/fdt.c | 250 +++++
> cpukit/dtc/libfdt/fdt.h | 111 ++
> cpukit/dtc/libfdt/fdt_addresses.c | 96 ++
> cpukit/dtc/libfdt/fdt_empty_tree.c | 84 ++
> cpukit/dtc/libfdt/fdt_ro.c | 679 ++++++++++++
> cpukit/dtc/libfdt/fdt_rw.c | 492 +++++++++
> cpukit/dtc/libfdt/fdt_strerror.c | 96 ++
> cpukit/dtc/libfdt/fdt_sw.c | 288 +++++
> cpukit/dtc/libfdt/fdt_wip.c | 118 ++
> cpukit/dtc/libfdt/libfdt.h | 1653 +++++++++++++++++++++++++++++
> cpukit/dtc/libfdt/libfdt_env.h | 111 ++
> cpukit/dtc/libfdt/libfdt_internal.h | 95 ++
> cpukit/dtc/libfdt/preinstall.am | 46 +
> testsuites/libtests/Makefile.am | 1 +
> testsuites/libtests/configure.ac | 1 +
> testsuites/libtests/libfdt01/Makefile.am | 20 +
> testsuites/libtests/libfdt01/init.c | 145 +++
> testsuites/libtests/libfdt01/libfdt01.doc | 20 +
> testsuites/libtests/libfdt01/libfdt01.scn | 2 +
> testsuites/libtests/libfdt01/some.c | 52 +
> testsuites/libtests/libfdt01/some.dts | 54 +
> testsuites/libtests/libfdt01/some.h | 15 +
> 28 files changed, 4529 insertions(+)
>
> diff --git a/cpukit/Makefile.am b/cpukit/Makefile.am
> index 063a795..86c20a9 100644
> --- a/cpukit/Makefile.am
> +++ b/cpukit/Makefile.am
> @@ -6,6 +6,7 @@ include $(top_srcdir)/automake/multilib.am
> # librtemscpu
> SUBDIRS = . score rtems sapi posix
> SUBDIRS += dev
> +SUBDIRS += dtc/libfdt
> SUBDIRS += libcrypt
> SUBDIRS += libcsupport libblock libfs
> SUBDIRS += libdrvmgr
> diff --git a/cpukit/configure.ac b/cpukit/configure.ac
> index 01da86d..bf01ba0 100644
> --- a/cpukit/configure.ac
> +++ b/cpukit/configure.ac
> @@ -445,6 +445,7 @@ AC_CONFIG_FILES([
> Doxyfile
> Makefile
> dev/Makefile
> +dtc/libfdt/Makefile
> rtems/Makefile
> sapi/Makefile
> score/Makefile
> diff --git a/cpukit/dtc/README b/cpukit/dtc/README
> new file mode 100644
> index 0000000..979974a
> --- /dev/null
> +++ b/cpukit/dtc/README
> @@ -0,0 +1,20 @@
> +The source tree contains the Device Tree Compiler (dtc) toolchain for
> +working with device tree source and binary files and also libfdt, a
> +utility library for reading and manipulating the binary format.
> +
> +DTC and LIBFDT are maintained by:
> +
> +David Gibson <david at gibson.dropbear.id.au>
> +Jon Loeliger <jdl at jdl.com>
> +
> +Mailing list
> +------------
> +The following list is for discussion about dtc and libfdt implementation
> +mailto:devicetree-compiler at vger.kernel.org
> +
> +Core device tree bindings are discussed on the devicetree-spec list:
> +mailto:devicetree-spec at vger.kernel.org
> +
> +Home Page
> +---------
> +http://devicetree.org/Device_Tree_Compiler
> diff --git a/cpukit/dtc/README.license b/cpukit/dtc/README.license
> new file mode 100644
> index 0000000..d56c88f
> --- /dev/null
> +++ b/cpukit/dtc/README.license
> @@ -0,0 +1,56 @@
> +Licensing and contribution policy of dtc and libfdt
> +===================================================
> +
> +This dtc package contains two pieces of software: dtc itself, and
> +libfdt which comprises the files in the libfdt/ subdirectory. These
> +two pieces of software, although closely related, are quite distinct.
> +dtc does not incoporate or rely on libfdt for its operation, nor vice
> +versa. It is important that these two pieces of software have
> +different license conditions.
> +
> +As the copyright banners in each source file attest, dtc is licensed
> +under the GNU GPL. The full text of the GPL can be found in the file
> +entitled 'GPL' which should be included in this package. dtc code,
> +therefore, may not be incorporated into works which do not have a GPL
> +compatible license.
> +
> +libfdt, however, is GPL/BSD dual-licensed. That is, it may be used
> +either under the terms of the GPL, or under the terms of the 2-clause
> +BSD license (aka the ISC license). The full terms of that license are
> +given in the copyright banners of each of the libfdt source files.
> +This is, in practice, equivalent to being BSD licensed, since the
> +terms of the BSD license are strictly more permissive than the GPL.
> +
> +I made the decision to license libfdt in this way because I want to
> +encourage widespread and correct usage of flattened device trees,
> +including by proprietary or otherwise GPL-incompatible firmware or
> +tools. Allowing libfdt to be used under the terms of the BSD license
> +makes that it easier for vendors or authors of such software to do so.
> +
> +This does mean that libfdt code could be "stolen" - say, included in a
> +proprietary fimware and extended without contributing those extensions
> +back to the libfdt mainline. While I hope that doesn't happen, I
> +believe the goal of allowing libfdt to be widely used is more
> +important than avoiding that. libfdt is quite small, and hardly
> +rocket science; so the incentive for such impolite behaviour is small,
> +and the inconvenience caused therby is not dire.
> +
> +Licenses such as the LGPL which would allow code to be used in non-GPL
> +software, but also require contributions to be returned were
> +considered. However, libfdt is designed to be used in firmwares and
> +other environments with unusual technical constraints. It's difficult
> +to anticipate all possible changes which might be needed to meld
> +libfdt into such environments and so difficult to suitably word a
> +license that puts the boundary between what is and isn't permitted in
> +the intended place. Again, I judged encouraging widespread use of
> +libfdt by keeping the license terms simple and familiar to be the more
> +important goal.
> +
> +**IMPORTANT** It's intended that all of libfdt as released remain
> +permissively licensed this way. Therefore only contributions which
> +are released under these terms can be merged into the libfdt mainline.
> +
> +
> +David Gibson <david at gibson.dropbear.id.au>
> +(principal original author of dtc and libfdt)
> +2 November 2007
> diff --git a/cpukit/dtc/libfdt/Makefile.am b/cpukit/dtc/libfdt/Makefile.am
> new file mode 100644
> index 0000000..9d76c63
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/Makefile.am
> @@ -0,0 +1,19 @@
> +include $(top_srcdir)/automake/compile.am
> +
> +include_HEADERS = fdt.h libfdt.h libfdt_env.h
> +
> +project_lib_LIBRARIES = libfdt.a
> +
> +libfdt_a_CPPFLAGS = $(AM_CPPFLAGS) -I$(srcdir)
> +libfdt_a_SOURCES =
> +libfdt_a_SOURCES += fdt_addresses.c
> +libfdt_a_SOURCES += fdt.c
> +libfdt_a_SOURCES += fdt_empty_tree.c
> +libfdt_a_SOURCES += fdt_ro.c
> +libfdt_a_SOURCES += fdt_rw.c
> +libfdt_a_SOURCES += fdt_strerror.c
> +libfdt_a_SOURCES += fdt_sw.c
> +libfdt_a_SOURCES += fdt_wip.c
> +
> +include $(srcdir)/preinstall.am
> +include $(top_srcdir)/automake/local.am
> diff --git a/cpukit/dtc/libfdt/TODO b/cpukit/dtc/libfdt/TODO
> new file mode 100644
> index 0000000..288437e
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/TODO
> @@ -0,0 +1,3 @@
> +- Tree traversal functions
> +- Graft function
> +- Complete libfdt.h documenting comments
> diff --git a/cpukit/dtc/libfdt/fdt.c b/cpukit/dtc/libfdt/fdt.c
> new file mode 100644
> index 0000000..2ce6a44
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/fdt.c
> @@ -0,0 +1,250 @@
> +/*
> + * 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 fdt32_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;
> +}
> +
> +int fdt_first_subnode(const void *fdt, int offset)
> +{
> + int depth = 0;
> +
> + offset = fdt_next_node(fdt, offset, &depth);
> + if (offset < 0 || depth != 1)
> + return -FDT_ERR_NOTFOUND;
> +
> + return offset;
> +}
> +
> +int fdt_next_subnode(const void *fdt, int offset)
> +{
> + int depth = 1;
> +
> + /*
> + * With respect to the parent, the depth of the next subnode will be
> + * the same as the last.
> + */
> + do {
> + offset = fdt_next_node(fdt, offset, &depth);
> + if (offset < 0 || depth < 1)
> + return -FDT_ERR_NOTFOUND;
> + } while (depth > 1);
> +
> + 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/cpukit/dtc/libfdt/fdt.h b/cpukit/dtc/libfdt/fdt.h
> new file mode 100644
> index 0000000..526aedb
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/fdt.h
> @@ -0,0 +1,111 @@
> +#ifndef _FDT_H
> +#define _FDT_H
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + * Copyright 2012 Kim Phillips, Freescale Semiconductor.
> + *
> + * 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.
> + */
> +
> +#ifndef __ASSEMBLY__
> +
> +struct fdt_header {
> + fdt32_t magic; /* magic word FDT_MAGIC */
> + fdt32_t totalsize; /* total size of DT block */
> + fdt32_t off_dt_struct; /* offset to structure */
> + fdt32_t off_dt_strings; /* offset to strings */
> + fdt32_t off_mem_rsvmap; /* offset to memory reserve map */
> + fdt32_t version; /* format version */
> + fdt32_t last_comp_version; /* last compatible version */
> +
> + /* version 2 fields below */
> + fdt32_t boot_cpuid_phys; /* Which physical CPU id we're
> + booting on */
> + /* version 3 fields below */
> + fdt32_t size_dt_strings; /* size of the strings block */
> +
> + /* version 17 fields below */
> + fdt32_t size_dt_struct; /* size of the structure block */
> +};
> +
> +struct fdt_reserve_entry {
> + fdt64_t address;
> + fdt64_t size;
> +};
> +
> +struct fdt_node_header {
> + fdt32_t tag;
> + char name[0];
> +};
> +
> +struct fdt_property {
> + fdt32_t tag;
> + fdt32_t len;
> + fdt32_t nameoff;
> + char data[0];
> +};
> +
> +#endif /* !__ASSEMBLY */
> +
> +#define FDT_MAGIC 0xd00dfeed /* 4: version, 4: total size */
> +#define FDT_TAGSIZE sizeof(fdt32_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(fdt32_t))
> +#define FDT_V2_SIZE (FDT_V1_SIZE + sizeof(fdt32_t))
> +#define FDT_V3_SIZE (FDT_V2_SIZE + sizeof(fdt32_t))
> +#define FDT_V16_SIZE FDT_V3_SIZE
> +#define FDT_V17_SIZE (FDT_V16_SIZE + sizeof(fdt32_t))
> +
> +#endif /* _FDT_H */
> diff --git a/cpukit/dtc/libfdt/fdt_addresses.c b/cpukit/dtc/libfdt/fdt_addresses.c
> new file mode 100644
> index 0000000..eff4dbc
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/fdt_addresses.c
> @@ -0,0 +1,96 @@
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2014 David Gibson <david at gibson.dropbear.id.au>
> + *
> + * 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_address_cells(const void *fdt, int nodeoffset)
> +{
> + const fdt32_t *ac;
> + int val;
> + int len;
> +
> + ac = fdt_getprop(fdt, nodeoffset, "#address-cells", &len);
> + if (!ac)
> + return 2;
> +
> + if (len != sizeof(*ac))
> + return -FDT_ERR_BADNCELLS;
> +
> + val = fdt32_to_cpu(*ac);
> + if ((val <= 0) || (val > FDT_MAX_NCELLS))
> + return -FDT_ERR_BADNCELLS;
> +
> + return val;
> +}
> +
> +int fdt_size_cells(const void *fdt, int nodeoffset)
> +{
> + const fdt32_t *sc;
> + int val;
> + int len;
> +
> + sc = fdt_getprop(fdt, nodeoffset, "#size-cells", &len);
> + if (!sc)
> + return 2;
> +
> + if (len != sizeof(*sc))
> + return -FDT_ERR_BADNCELLS;
> +
> + val = fdt32_to_cpu(*sc);
> + if ((val < 0) || (val > FDT_MAX_NCELLS))
> + return -FDT_ERR_BADNCELLS;
> +
> + return val;
> +}
> diff --git a/cpukit/dtc/libfdt/fdt_empty_tree.c b/cpukit/dtc/libfdt/fdt_empty_tree.c
> new file mode 100644
> index 0000000..f72d13b
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/fdt_empty_tree.c
> @@ -0,0 +1,84 @@
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2012 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_create_empty_tree(void *buf, int bufsize)
> +{
> + int err;
> +
> + err = fdt_create(buf, bufsize);
> + if (err)
> + return err;
> +
> + err = fdt_finish_reservemap(buf);
> + if (err)
> + return err;
> +
> + err = fdt_begin_node(buf, "");
> + if (err)
> + return err;
> +
> + err = fdt_end_node(buf);
> + if (err)
> + return err;
> +
> + err = fdt_finish(buf);
> + if (err)
> + return err;
> +
> + return fdt_open_into(buf, buf, bufsize);
> +}
> +
> diff --git a/cpukit/dtc/libfdt/fdt_ro.c b/cpukit/dtc/libfdt/fdt_ro.c
> new file mode 100644
> index 0000000..e5b3136
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/fdt_ro.c
> @@ -0,0 +1,679 @@
> +/*
> + * 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_namelen(const void *fdt, const char *path, int namelen)
> +{
> + const char *end = path + namelen;
> + const char *p = path;
> + int offset = 0;
> +
> + FDT_CHECK_HEADER(fdt);
> +
> + /* see if we have an alias */
> + if (*path != '/') {
> + const char *q = memchr(path, '/', end - p);
> +
> + 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 < end) {
> + const char *q;
> +
> + while (*p == '/') {
> + p++;
> + if (p == end)
> + return offset;
> + }
> + q = memchr(p, '/', end - p);
> + if (! q)
> + q = end;
> +
> + offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
> + if (offset < 0)
> + return offset;
> +
> + p = q;
> + }
> +
> + return offset;
> +}
> +
> +int fdt_path_offset(const void *fdt, const char *path)
> +{
> + return fdt_path_offset_namelen(fdt, path, strlen(path));
> +}
> +
> +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 fdt32_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() */
> +}
> +
> +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_stringlist_count(const void *fdt, int nodeoffset, const char *property)
> +{
> + const char *list, *end;
> + int length, count = 0;
> +
> + list = fdt_getprop(fdt, nodeoffset, property, &length);
> + if (!list)
> + return -length;
> +
> + end = list + length;
> +
> + while (list < end) {
> + length = strnlen(list, end - list) + 1;
> +
> + /* Abort if the last string isn't properly NUL-terminated. */
> + if (list + length > end)
> + return -FDT_ERR_BADVALUE;
> +
> + list += length;
> + count++;
> + }
> +
> + return count;
> +}
> +
> +int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
> + const char *string)
> +{
> + int length, len, idx = 0;
> + const char *list, *end;
> +
> + list = fdt_getprop(fdt, nodeoffset, property, &length);
> + if (!list)
> + return -length;
> +
> + len = strlen(string) + 1;
> + end = list + length;
> +
> + while (list < end) {
> + length = strnlen(list, end - list) + 1;
> +
> + /* Abort if the last string isn't properly NUL-terminated. */
> + if (list + length > end)
> + return -FDT_ERR_BADVALUE;
> +
> + if (length == len && memcmp(list, string, length) == 0)
> + return idx;
> +
> + list += length;
> + idx++;
> + }
> +
> + return -FDT_ERR_NOTFOUND;
> +}
> +
> +const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
> + const char *property, int idx,
> + int *lenp)
> +{
> + const char *list, *end;
> + int length;
> +
> + list = fdt_getprop(fdt, nodeoffset, property, &length);
> + if (!list) {
> + if (lenp)
> + *lenp = length;
> +
> + return NULL;
> + }
> +
> + end = list + length;
> +
> + while (list < end) {
> + length = strnlen(list, end - list) + 1;
> +
> + /* Abort if the last string isn't properly NUL-terminated. */
> + if (list + length > end) {
> + if (lenp)
> + *lenp = -FDT_ERR_BADVALUE;
> +
> + return NULL;
> + }
> +
> + if (idx == 0) {
> + if (lenp)
> + *lenp = length - 1;
> +
> + return list;
> + }
> +
> + list += length;
> + idx--;
> + }
> +
> + if (lenp)
> + *lenp = -FDT_ERR_NOTFOUND;
> +
> + return NULL;
> +}
> +
> +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/cpukit/dtc/libfdt/fdt_rw.c b/cpukit/dtc/libfdt/fdt_rw.c
> new file mode 100644
> index 0000000..70adec6
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/fdt_rw.c
> @@ -0,0 +1,492 @@
> +/*
> + * 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_appendprop(void *fdt, int nodeoffset, const char *name,
> + const void *val, int len)
> +{
> + struct fdt_property *prop;
> + int err, oldlen, newlen;
> +
> + FDT_RW_CHECK_HEADER(fdt);
> +
> + prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
> + if (prop) {
> + newlen = len + oldlen;
> + err = _fdt_splice_struct(fdt, prop->data,
> + FDT_TAGALIGN(oldlen),
> + FDT_TAGALIGN(newlen));
> + if (err)
> + return err;
> + prop->len = cpu_to_fdt32(newlen);
> + memcpy(prop->data + oldlen, val, len);
> + } else {
> + 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;
> + fdt32_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 = (fdt32_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/cpukit/dtc/libfdt/fdt_strerror.c b/cpukit/dtc/libfdt/fdt_strerror.c
> new file mode 100644
> index 0000000..e6c3cee
> --- /dev/null
> +++ b/cpukit/dtc/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/cpukit/dtc/libfdt/fdt_sw.c b/cpukit/dtc/libfdt/fdt_sw.c
> new file mode 100644
> index 0000000..6a80485
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/fdt_sw.c
> @@ -0,0 +1,288 @@
> +/*
> + * 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_resize(void *fdt, void *buf, int bufsize)
> +{
> + size_t headsize, tailsize;
> + char *oldtail, *newtail;
> +
> + FDT_SW_CHECK_HEADER(fdt);
> +
> + headsize = fdt_off_dt_struct(fdt);
> + tailsize = fdt_size_dt_strings(fdt);
> +
> + if ((headsize + tailsize) > bufsize)
> + return -FDT_ERR_NOSPACE;
> +
> + oldtail = (char *)fdt + fdt_totalsize(fdt) - tailsize;
> + newtail = (char *)buf + bufsize - tailsize;
> +
> + /* Two cases to avoid clobbering data if the old and new
> + * buffers partially overlap */
> + if (buf <= fdt) {
> + memmove(buf, fdt, headsize);
> + memmove(newtail, oldtail, tailsize);
> + } else {
> + memmove(newtail, oldtail, tailsize);
> + memmove(buf, fdt, headsize);
> + }
> +
> + fdt_set_off_dt_strings(buf, bufsize);
> + fdt_set_totalsize(buf, 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)
> +{
> + fdt32_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;
> + fdt32_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/cpukit/dtc/libfdt/fdt_wip.c b/cpukit/dtc/libfdt/fdt_wip.c
> new file mode 100644
> index 0000000..c5bbb68
> --- /dev/null
> +++ b/cpukit/dtc/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)
> +{
> + fdt32_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/cpukit/dtc/libfdt/libfdt.h b/cpukit/dtc/libfdt/libfdt.h
> new file mode 100644
> index 0000000..78adb12
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/libfdt.h
> @@ -0,0 +1,1653 @@
> +#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. */
> +
> +/* Errors in device tree content */
> +#define FDT_ERR_BADNCELLS 14
> + /* FDT_ERR_BADNCELLS: Device tree has a #address-cells, #size-cells
> + * or similar property with a bad format or value */
> +
> +#define FDT_ERR_BADVALUE 15
> + /* FDT_ERR_BADVALUE: Device tree has a property with an unexpected
> + * value. For example: a property expected to contain a string list
> + * is not NUL-terminated within the length of its value. */
> +
> +#define FDT_ERR_MAX 15
> +
> +/**********************************************************************/
> +/* 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);
> +
> +/**
> + * fdt_first_subnode() - get offset of first direct subnode
> + *
> + * @fdt: FDT blob
> + * @offset: Offset of node to check
> + * @return offset of first subnode, or -FDT_ERR_NOTFOUND if there is none
> + */
> +int fdt_first_subnode(const void *fdt, int offset);
> +
> +/**
> + * fdt_next_subnode() - get offset of next direct subnode
> + *
> + * After first calling fdt_first_subnode(), call this function repeatedly to
> + * get direct subnodes of a parent node.
> + *
> + * @fdt: FDT blob
> + * @offset: Offset of previous subnode
> + * @return offset of next subnode, or -FDT_ERR_NOTFOUND if there are no more
> + * subnodes
> + */
> +int fdt_next_subnode(const void *fdt, int offset);
> +
> +/**********************************************************************/
> +/* 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_namelen - find a tree node by its full path
> + * @fdt: pointer to the device tree blob
> + * @path: full path of the node to locate
> + * @namelen: number of characters of path to consider
> + *
> + * Identical to fdt_path_offset(), but only consider the first namelen
> + * characters of path as the path name.
> + */
> +int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen);
> +
> +/**
> + * 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(), 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', if 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);
> +
> +/**
> + * fdt_stringlist_contains - check a string list property for a string
> + * @strlist: Property containing a list of strings to check
> + * @listlen: Length of property
> + * @str: String to search for
> + *
> + * This is a utility function provided for convenience. The list contains
> + * one or more strings, each terminated by \0, as is found in a device tree
> + * "compatible" property.
> + *
> + * @return: 1 if the string is found in the list, 0 not found, or invalid list
> + */
> +int fdt_stringlist_contains(const char *strlist, int listlen, const char *str);
> +
> +/**
> + * fdt_stringlist_count - count the number of strings in a string list
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of a tree node
> + * @property: name of the property containing the string list
> + * @return:
> + * the number of strings in the given property
> + * -FDT_ERR_BADVALUE if the property value is not NUL-terminated
> + * -FDT_ERR_NOTFOUND if the property does not exist
> + */
> +int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property);
> +
> +/**
> + * fdt_stringlist_search - find a string in a string list and return its index
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of a tree node
> + * @property: name of the property containing the string list
> + * @string: string to look up in the string list
> + *
> + * Note that it is possible for this function to succeed on property values
> + * that are not NUL-terminated. That's because the function will stop after
> + * finding the first occurrence of @string. This can for example happen with
> + * small-valued cell properties, such as #address-cells, when searching for
> + * the empty string.
> + *
> + * @return:
> + * the index of the string in the list of strings
> + * -FDT_ERR_BADVALUE if the property value is not NUL-terminated
> + * -FDT_ERR_NOTFOUND if the property does not exist or does not contain
> + * the given string
> + */
> +int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
> + const char *string);
> +
> +/**
> + * fdt_stringlist_get() - obtain the string at a given index in a string list
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of a tree node
> + * @property: name of the property containing the string list
> + * @index: index of the string to return
> + * @lenp: return location for the string length or an error code on failure
> + *
> + * Note that this will successfully extract strings from properties with
> + * non-NUL-terminated values. For example on small-valued cell properties
> + * this function will return the empty string.
> + *
> + * If non-NULL, the length of the string (on success) or a negative error-code
> + * (on failure) will be stored in the integer pointer to by lenp.
> + *
> + * @return:
> + * A pointer to the string at the given index in the string list or NULL on
> + * failure. On success the length of the string will be stored in the memory
> + * location pointed to by the lenp parameter, if non-NULL. On failure one of
> + * the following negative error codes will be returned in the lenp parameter
> + * (if non-NULL):
> + * -FDT_ERR_BADVALUE if the property value is not NUL-terminated
> + * -FDT_ERR_NOTFOUND if the property does not exist
> + */
> +const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
> + const char *property, int index,
> + int *lenp);
> +
> +/**********************************************************************/
> +/* Read-only functions (addressing related) */
> +/**********************************************************************/
> +
> +/**
> + * FDT_MAX_NCELLS - maximum value for #address-cells and #size-cells
> + *
> + * This is the maximum value for #address-cells, #size-cells and
> + * similar properties that will be processed by libfdt. IEE1275
> + * requires that OF implementations handle values up to 4.
> + * Implementations may support larger values, but in practice higher
> + * values aren't used.
> + */
> +#define FDT_MAX_NCELLS 4
> +
> +/**
> + * fdt_address_cells - retrieve address size for a bus represented in the tree
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node to find the address size for
> + *
> + * When the node has a valid #address-cells property, returns its value.
> + *
> + * returns:
> + * 0 <= n < FDT_MAX_NCELLS, on success
> + * 2, if the node has no #address-cells property
> + * -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid #address-cells property
> + * -FDT_ERR_BADMAGIC,
> + * -FDT_ERR_BADVERSION,
> + * -FDT_ERR_BADSTATE,
> + * -FDT_ERR_BADSTRUCTURE,
> + * -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_address_cells(const void *fdt, int nodeoffset);
> +
> +/**
> + * fdt_size_cells - retrieve address range size for a bus represented in the
> + * tree
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node to find the address range size for
> + *
> + * When the node has a valid #size-cells property, returns its value.
> + *
> + * returns:
> + * 0 <= n < FDT_MAX_NCELLS, on success
> + * 2, if the node has no #address-cells property
> + * -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid #size-cells property
> + * -FDT_ERR_BADMAGIC,
> + * -FDT_ERR_BADVERSION,
> + * -FDT_ERR_BADSTATE,
> + * -FDT_ERR_BADSTRUCTURE,
> + * -FDT_ERR_TRUNCATED, standard meanings
> + */
> +int fdt_size_cells(const void *fdt, int nodeoffset);
> +
> +
> +/**********************************************************************/
> +/* 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_u32 - change the value of a 32-bit integer 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: 32-bit integer value to replace the property with
> + *
> + * fdt_setprop_inplace_u32() replaces the value of a given property
> + * with the 32-bit integer 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_u32(void *fdt, int nodeoffset,
> + const char *name, uint32_t val)
> +{
> + fdt32_t tmp = cpu_to_fdt32(val);
> + return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));
> +}
> +
> +/**
> + * fdt_setprop_inplace_u64 - change the value of a 64-bit integer 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: 64-bit integer value to replace the property with
> + *
> + * fdt_setprop_inplace_u64() replaces the value of a given property
> + * with the 64-bit integer 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
> + * 8.
> + *
> + * 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 8
> + * -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_u64(void *fdt, int nodeoffset,
> + const char *name, uint64_t val)
> +{
> + fdt64_t tmp = cpu_to_fdt64(val);
> + return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));
> +}
> +
> +/**
> + * fdt_setprop_inplace_cell - change the value of a single-cell property
> + *
> + * This is an alternative name for fdt_setprop_inplace_u32()
> + */
> +static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset,
> + const char *name, uint32_t val)
> +{
> + return fdt_setprop_inplace_u32(fdt, nodeoffset, name, 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_resize(void *fdt, 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_u32(void *fdt, const char *name, uint32_t val)
> +{
> + fdt32_t tmp = cpu_to_fdt32(val);
> + return fdt_property(fdt, name, &tmp, sizeof(tmp));
> +}
> +static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val)
> +{
> + fdt64_t tmp = cpu_to_fdt64(val);
> + return fdt_property(fdt, name, &tmp, sizeof(tmp));
> +}
> +static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)
> +{
> + return fdt_property_u32(fdt, name, 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_create_empty_tree(void *buf, int bufsize);
> +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_u32 - set a property to a 32-bit integer
> + * @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_u32() sets the value of the named property in the given
> + * node to the given 32-bit integer 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_u32(void *fdt, int nodeoffset, const char *name,
> + uint32_t val)
> +{
> + fdt32_t tmp = cpu_to_fdt32(val);
> + return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
> +}
> +
> +/**
> + * fdt_setprop_u64 - set a property to a 64-bit integer
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to change
> + * @name: name of the property to change
> + * @val: 64-bit integer value for the property (native endian)
> + *
> + * fdt_setprop_u64() sets the value of the named property in the given
> + * node to the given 64-bit integer 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_u64(void *fdt, int nodeoffset, const char *name,
> + uint64_t val)
> +{
> + fdt64_t tmp = cpu_to_fdt64(val);
> + return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
> +}
> +
> +/**
> + * fdt_setprop_cell - set a property to a single cell value
> + *
> + * This is an alternative name for fdt_setprop_u32()
> + */
> +static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
> + uint32_t val)
> +{
> + return fdt_setprop_u32(fdt, nodeoffset, name, 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_appendprop - append to or create a property
> + * @fdt: pointer to the device tree blob
> + * @nodeoffset: offset of the node whose property to change
> + * @name: name of the property to append to
> + * @val: pointer to data to append to the property value
> + * @len: length of the data to append to the property value
> + *
> + * fdt_appendprop() appends the value to the named property in the
> + * given node, creating the property if it does not already exist.
> + *
> + * This function may insert data into 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_appendprop(void *fdt, int nodeoffset, const char *name,
> + const void *val, int len);
> +
> +/**
> + * fdt_appendprop_u32 - append a 32-bit integer value to 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: 32-bit integer value to append to the property (native endian)
> + *
> + * fdt_appendprop_u32() appends the given 32-bit integer value
> + * (converting to big-endian if necessary) to the value of the named
> + * property in the given node, or creates a new property with that
> + * value if it does not already exist.
> + *
> + * This function may insert data into 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_appendprop_u32(void *fdt, int nodeoffset,
> + const char *name, uint32_t val)
> +{
> + fdt32_t tmp = cpu_to_fdt32(val);
> + return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
> +}
> +
> +/**
> + * fdt_appendprop_u64 - append a 64-bit integer value to 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: 64-bit integer value to append to the property (native endian)
> + *
> + * fdt_appendprop_u64() appends the given 64-bit integer value
> + * (converting to big-endian if necessary) to the value of the named
> + * property in the given node, or creates a new property with that
> + * value if it does not already exist.
> + *
> + * This function may insert data into 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_appendprop_u64(void *fdt, int nodeoffset,
> + const char *name, uint64_t val)
> +{
> + fdt64_t tmp = cpu_to_fdt64(val);
> + return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
> +}
> +
> +/**
> + * fdt_appendprop_cell - append a single cell value to a property
> + *
> + * This is an alternative name for fdt_appendprop_u32()
> + */
> +static inline int fdt_appendprop_cell(void *fdt, int nodeoffset,
> + const char *name, uint32_t val)
> +{
> + return fdt_appendprop_u32(fdt, nodeoffset, name, val);
> +}
> +
> +/**
> + * fdt_appendprop_string - append a string to 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
> + * @str: string value to append to the property
> + *
> + * fdt_appendprop_string() appends the given string to the value of
> + * the named property in the given node, or creates a new property
> + * with that value if it does not already exist.
> + *
> + * This function may insert data into 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_appendprop_string(fdt, nodeoffset, name, str) \
> + fdt_appendprop((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/cpukit/dtc/libfdt/libfdt_env.h b/cpukit/dtc/libfdt/libfdt_env.h
> new file mode 100644
> index 0000000..9dea97d
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/libfdt_env.h
> @@ -0,0 +1,111 @@
> +#ifndef _LIBFDT_ENV_H
> +#define _LIBFDT_ENV_H
> +/*
> + * libfdt - Flat Device Tree manipulation
> + * Copyright (C) 2006 David Gibson, IBM Corporation.
> + * Copyright 2012 Kim Phillips, Freescale Semiconductor.
> + *
> + * 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 <stddef.h>
> +#include <stdint.h>
> +#include <string.h>
> +
> +#ifdef __CHECKER__
> +#define __force __attribute__((force))
> +#define __bitwise __attribute__((bitwise))
> +#else
> +#define __force
> +#define __bitwise
> +#endif
> +
> +typedef uint16_t __bitwise fdt16_t;
> +typedef uint32_t __bitwise fdt32_t;
> +typedef uint64_t __bitwise fdt64_t;
> +
> +#define EXTRACT_BYTE(x, n) ((unsigned long long)((uint8_t *)&x)[n])
> +#define CPU_TO_FDT16(x) ((EXTRACT_BYTE(x, 0) << 8) | EXTRACT_BYTE(x, 1))
> +#define CPU_TO_FDT32(x) ((EXTRACT_BYTE(x, 0) << 24) | (EXTRACT_BYTE(x, 1) << 16) | \
> + (EXTRACT_BYTE(x, 2) << 8) | EXTRACT_BYTE(x, 3))
> +#define CPU_TO_FDT64(x) ((EXTRACT_BYTE(x, 0) << 56) | (EXTRACT_BYTE(x, 1) << 48) | \
> + (EXTRACT_BYTE(x, 2) << 40) | (EXTRACT_BYTE(x, 3) << 32) | \
> + (EXTRACT_BYTE(x, 4) << 24) | (EXTRACT_BYTE(x, 5) << 16) | \
> + (EXTRACT_BYTE(x, 6) << 8) | EXTRACT_BYTE(x, 7))
> +
> +static inline uint16_t fdt16_to_cpu(fdt16_t x)
> +{
> + return (__force uint16_t)CPU_TO_FDT16(x);
> +}
> +static inline fdt16_t cpu_to_fdt16(uint16_t x)
> +{
> + return (__force fdt16_t)CPU_TO_FDT16(x);
> +}
> +
> +static inline uint32_t fdt32_to_cpu(fdt32_t x)
> +{
> + return (__force uint32_t)CPU_TO_FDT32(x);
> +}
> +static inline fdt32_t cpu_to_fdt32(uint32_t x)
> +{
> + return (__force fdt32_t)CPU_TO_FDT32(x);
> +}
> +
> +static inline uint64_t fdt64_to_cpu(fdt64_t x)
> +{
> + return (__force uint64_t)CPU_TO_FDT64(x);
> +}
> +static inline fdt64_t cpu_to_fdt64(uint64_t x)
> +{
> + return (__force fdt64_t)CPU_TO_FDT64(x);
> +}
> +#undef CPU_TO_FDT64
> +#undef CPU_TO_FDT32
> +#undef CPU_TO_FDT16
> +#undef EXTRACT_BYTE
> +
> +#endif /* _LIBFDT_ENV_H */
> diff --git a/cpukit/dtc/libfdt/libfdt_internal.h b/cpukit/dtc/libfdt/libfdt_internal.h
> new file mode 100644
> index 0000000..02cfa6f
> --- /dev/null
> +++ b/cpukit/dtc/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/cpukit/dtc/libfdt/preinstall.am b/cpukit/dtc/libfdt/preinstall.am
> new file mode 100644
> index 0000000..2c5c51d
> --- /dev/null
> +++ b/cpukit/dtc/libfdt/preinstall.am
> @@ -0,0 +1,46 @@
> +## Automatically generated by ampolish3 - Do not edit
> +
> +if AMPOLISH3
> +$(srcdir)/preinstall.am: Makefile.am
> + $(AMPOLISH3) $(srcdir)/Makefile.am > $(srcdir)/preinstall.am
> +endif
> +
> +PREINSTALL_DIRS =
> +DISTCLEANFILES = $(PREINSTALL_DIRS)
> +
> +all-am: $(PREINSTALL_FILES)
> +
> +PREINSTALL_FILES =
> +CLEANFILES = $(PREINSTALL_FILES)
> +
> +all-local: $(TMPINSTALL_FILES)
> +
> +TMPINSTALL_FILES =
> +CLEANFILES += $(TMPINSTALL_FILES)
> +
> +$(PROJECT_LIB)/$(dirstamp):
> + @$(MKDIR_P) $(PROJECT_LIB)
> + @: > $(PROJECT_LIB)/$(dirstamp)
> +PREINSTALL_DIRS += $(PROJECT_LIB)/$(dirstamp)
> +
> +$(PROJECT_INCLUDE)/$(dirstamp):
> + @$(MKDIR_P) $(PROJECT_INCLUDE)
> + @: > $(PROJECT_INCLUDE)/$(dirstamp)
> +PREINSTALL_DIRS += $(PROJECT_INCLUDE)/$(dirstamp)
> +
> +$(PROJECT_INCLUDE)/fdt.h: fdt.h $(PROJECT_INCLUDE)/$(dirstamp)
> + $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/fdt.h
> +PREINSTALL_FILES += $(PROJECT_INCLUDE)/fdt.h
> +
> +$(PROJECT_INCLUDE)/libfdt.h: libfdt.h $(PROJECT_INCLUDE)/$(dirstamp)
> + $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/libfdt.h
> +PREINSTALL_FILES += $(PROJECT_INCLUDE)/libfdt.h
> +
> +$(PROJECT_INCLUDE)/libfdt_env.h: libfdt_env.h $(PROJECT_INCLUDE)/$(dirstamp)
> + $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/libfdt_env.h
> +PREINSTALL_FILES += $(PROJECT_INCLUDE)/libfdt_env.h
> +
> +$(PROJECT_LIB)/libfdt.a: libfdt.a $(PROJECT_LIB)/$(dirstamp)
> + $(INSTALL_DATA) $< $(PROJECT_LIB)/libfdt.a
> +TMPINSTALL_FILES += $(PROJECT_LIB)/libfdt.a
> +
> diff --git a/testsuites/libtests/Makefile.am b/testsuites/libtests/Makefile.am
> index ed773c4..d775c77 100644
> --- a/testsuites/libtests/Makefile.am
> +++ b/testsuites/libtests/Makefile.am
> @@ -1,6 +1,7 @@
> ACLOCAL_AMFLAGS = -I ../aclocal
>
> _SUBDIRS = POSIX
> +_SUBDIRS += libfdt01
> _SUBDIRS += defaultconfig01
> _SUBDIRS += pwdgrp02
> _SUBDIRS += shell01
> diff --git a/testsuites/libtests/configure.ac b/testsuites/libtests/configure.ac
> index 4924e0f..89ca57f 100644
> --- a/testsuites/libtests/configure.ac
> +++ b/testsuites/libtests/configure.ac
> @@ -79,6 +79,7 @@ AM_CONDITIONAL(DLTESTS,[test x"$TEST_LIBDL" = x"yes"])
>
> # Explicitly list all Makefiles here
> AC_CONFIG_FILES([Makefile
> +libfdt01/Makefile
> defaultconfig01/Makefile
> pwdgrp02/Makefile
> shell01/Makefile
> diff --git a/testsuites/libtests/libfdt01/Makefile.am b/testsuites/libtests/libfdt01/Makefile.am
> new file mode 100644
> index 0000000..880d221
> --- /dev/null
> +++ b/testsuites/libtests/libfdt01/Makefile.am
> @@ -0,0 +1,20 @@
> +rtems_tests_PROGRAMS = libfdt01
> +libfdt01_SOURCES = init.c some.c
> +libfdt01_LDADD = -lfdt
> +
> +dist_rtems_tests_DATA = libfdt01.scn libfdt01.doc
> +
> +include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP at .cfg
> +include $(top_srcdir)/../automake/compile.am
> +include $(top_srcdir)/../automake/leaf.am
> +
> +AM_CPPFLAGS += -I$(top_srcdir)/../support/include
> +
> +LINK_OBJS = $(libfdt01_OBJECTS) $(libfdt01_LDADD)
> +LINK_LIBS = $(libfdt01_LDLIBS)
> +
> +libfdt01$(EXEEXT): $(libfdt01_OBJECTS) $(libfdt01_DEPENDENCIES)
> + @rm -f libfdt01$(EXEEXT)
> + $(make-exe)
> +
> +include $(top_srcdir)/../automake/local.am
> diff --git a/testsuites/libtests/libfdt01/init.c b/testsuites/libtests/libfdt01/init.c
> new file mode 100644
> index 0000000..a13fc82
> --- /dev/null
> +++ b/testsuites/libtests/libfdt01/init.c
> @@ -0,0 +1,145 @@
> +/*
> + * Copyright (c) 2015 embedded brains GmbH. All rights reserved.
> + *
> + * embedded brains GmbH
> + * Dornierstr. 4
> + * 82178 Puchheim
> + * Germany
> + * <rtems at embedded-brains.de>
> + *
> + * The license and distribution terms for this file may be
> + * found in the file LICENSE in this distribution or at
> + * http://www.rtems.org/license/LICENSE.
> + */
> +
> +#ifdef HAVE_CONFIG_H
> + #include "config.h"
> +#endif
> +
> +#include "tmacros.h"
> +
> +#include <libfdt.h>
> +#include <string.h>
> +
> +#include "some.h"
> +
> +/*
> + * To generate the FDT blob use:
> + *
> + * dtc some.dts -O asm > some.s
> + * as some.s -o some.o
> + * objcopy -O binary some.o some.bin
> + * rtems-bin2c some.bin some.c
> + */
> +
> +const char rtems_test_name[] = "LIBFDT 1";
> +
> +static void test(void)
> +{
> + const void *fdt = some_bin;
> + int status;
> + uint32_t size;
> + const char *alias;
> + int root;
> + int cells;
> + const char *prop;
> + fdt32_t *prop_32;
> + int len;
> + int d;
> + int m;
> + int t;
> + int node;
> + uint32_t phandle;
> + uint32_t cell;
> +
> + status = fdt_check_header(fdt);
> + rtems_test_assert(status == 0);
> +
> + size = fdt_totalsize(fdt);
> + rtems_test_assert(size == some_bin_size);
> +
> + alias = fdt_get_alias(fdt, "nix");
> + rtems_test_assert(alias == NULL);
> +
> + alias = fdt_get_alias(fdt, "k");
> + rtems_test_assert(strcmp(alias, "/m at 1248") == 0);
> +
> + root = fdt_path_offset(fdt, "nix");
> + rtems_test_assert(root == -FDT_ERR_BADPATH);
> +
> + root = fdt_path_offset(fdt, "/");
> + rtems_test_assert(root >= 0);
> +
> + cells = fdt_address_cells(fdt, root);
> + rtems_test_assert(cells == 1);
> +
> + cells = fdt_size_cells(fdt, root);
> + rtems_test_assert(cells == 2);
> +
> + status = fdt_node_check_compatible(fdt, root, "a,b");
> + rtems_test_assert(status == 0);
> +
> + status = fdt_node_check_compatible(fdt, root, "blub");
> + rtems_test_assert(status == 1);
> +
> + prop = fdt_getprop(fdt, root, "model", &len);
> + rtems_test_assert(len == 2);
> + rtems_test_assert(memcmp(prop, "c", 2) == 0);
> +
> + d = fdt_subnode_offset(fdt, root, "slurf");
> + rtems_test_assert(d == -FDT_ERR_NOTFOUND);
> +
> + d = fdt_subnode_offset(fdt, root, "d");
> + rtems_test_assert(d >= 0);
> +
> + prop = fdt_getprop(fdt, d, "e", &len);
> + rtems_test_assert(len == 2);
> + rtems_test_assert(memcmp(prop, "f", 2) == 0);
> +
> + prop = fdt_getprop(fdt, d, "g", &len);
> + rtems_test_assert(len == 0);
> + rtems_test_assert(prop != NULL);
> +
> + m = fdt_subnode_offset(fdt, root, "m at 1248");
> + rtems_test_assert(m >= 0);
> +
> + t = fdt_subnode_offset(fdt, root, "t");
> + rtems_test_assert(t >= 0);
> +
> + prop_32 = (fdt32_t *) fdt_getprop(fdt, t, "u", &len);
> + rtems_test_assert(len == 4);
> + phandle = fdt32_to_cpu(*prop_32);
> +
> + node = fdt_node_offset_by_phandle(fdt, phandle);
> + rtems_test_assert(node == m);
> +
> + prop_32 = (fdt32_t *) fdt_getprop(fdt, m, "n", &len);
> + rtems_test_assert(len == 8);
> + cell = fdt32_to_cpu(prop_32[0]);
> + rtems_test_assert(cell == 0xdeadbeef);
> + cell = fdt32_to_cpu(prop_32[1]);
> + rtems_test_assert(cell == 0x12345678);
> +}
> +
> +static void Init(rtems_task_argument arg)
> +{
> + TEST_BEGIN();
> +
> + test();
> +
> + TEST_END();
> + rtems_test_exit(0);
> +}
> +
> +#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
> +#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
> +
> +#define CONFIGURE_MAXIMUM_TASKS 1
> +
> +#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
> +
> +#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
> +
> +#define CONFIGURE_INIT
> +
> +#include <rtems/confdefs.h>
> diff --git a/testsuites/libtests/libfdt01/libfdt01.doc b/testsuites/libtests/libfdt01/libfdt01.doc
> new file mode 100644
> index 0000000..1e9ab97
> --- /dev/null
> +++ b/testsuites/libtests/libfdt01/libfdt01.doc
> @@ -0,0 +1,20 @@
> +This file describes the directives and concepts tested by this test set.
> +
> +test set name: libfdt01
> +
> +directives:
> +
> + - fdt_address_cells()
> + - fdt_check_header()
> + - fdt_get_alias()
> + - fdt_getprop()
> + - fdt_node_check_compatible()
> + - fdt_node_offset_by_phandle()
> + - fdt_path_offset()
> + - fdt_size_cells()
> + - fdt_subnode_offset()
> + - fdt_totalsize()
> +
> +concepts:
> +
> + - Ensure that some libfdt functions work as expected.
> diff --git a/testsuites/libtests/libfdt01/libfdt01.scn b/testsuites/libtests/libfdt01/libfdt01.scn
> new file mode 100644
> index 0000000..7ea6971
> --- /dev/null
> +++ b/testsuites/libtests/libfdt01/libfdt01.scn
> @@ -0,0 +1,2 @@
> +*** BEGIN OF TEST LIBFDT 1 ***
> +*** END OF TEST LIBFDT 1 ***
> diff --git a/testsuites/libtests/libfdt01/some.c b/testsuites/libtests/libfdt01/some.c
> new file mode 100644
> index 0000000..5eed911
> --- /dev/null
> +++ b/testsuites/libtests/libfdt01/some.c
> @@ -0,0 +1,52 @@
> +/*
> + * Declarations for C structure representing binary file some.bin
> + *
> + * WARNING: Automatically generated -- do not edit!
> + */
> +
> +#include <sys/types.h>
> +
> +const unsigned char some_bin[] = {
> + 0xd0, 0x0d, 0xfe, 0xed, 0x00, 0x00, 0x01, 0xd8, 0x00, 0x00, 0x00, 0x38,
> + 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x11,
> + 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48,
> + 0x00, 0x00, 0x01, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
> + 0x00, 0x00, 0x00, 0x00, 0x61, 0x2c, 0x62, 0x00, 0x00, 0x00, 0x00, 0x03,
> + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
> + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1a,
> + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
> + 0x00, 0x00, 0x00, 0x26, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
> + 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
> + 0x00, 0x00, 0x00, 0x09, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x01,
> + 0x68, 0x40, 0x30, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
> + 0x68, 0x40, 0x31, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
> + 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x02,
> + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x61, 0x6c, 0x69, 0x61,
> + 0x73, 0x65, 0x73, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08,
> + 0x00, 0x00, 0x00, 0x30, 0x2f, 0x6d, 0x40, 0x31, 0x32, 0x34, 0x38, 0x00,
> + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x6d, 0x40, 0x31, 0x32,
> + 0x34, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08,
> + 0x00, 0x00, 0x00, 0x32, 0xde, 0xad, 0xbe, 0xef, 0x12, 0x34, 0x56, 0x78,
> + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x34,
> + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
> + 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
> + 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
> + 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
> + 0x00, 0x00, 0x00, 0x44, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
> + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x74, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46,
> + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
> + 0x00, 0x00, 0x00, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62,
> + 0x6c, 0x65, 0x00, 0x23, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2d,
> + 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x00, 0x23, 0x73, 0x69, 0x7a, 0x65, 0x2d,
> + 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x00, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x00,
> + 0x67, 0x00, 0x77, 0x00, 0x6b, 0x00, 0x6e, 0x00, 0x6c, 0x69, 0x6e, 0x75,
> + 0x78, 0x2c, 0x70, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x00, 0x70, 0x00,
> + 0x72, 0x00, 0x75, 0x00,
> +};
> +
> +const size_t some_bin_size = sizeof(some_bin);
> diff --git a/testsuites/libtests/libfdt01/some.dts b/testsuites/libtests/libfdt01/some.dts
> new file mode 100644
> index 0000000..ac15825
> --- /dev/null
> +++ b/testsuites/libtests/libfdt01/some.dts
> @@ -0,0 +1,54 @@
> +/*
> + * Copyright (c) 2015 embedded brains GmbH. All rights reserved.
> + *
> + * embedded brains GmbH
> + * Dornierstr. 4
> + * 82178 Puchheim
> + * Germany
> + * <rtems at embedded-brains.de>
> + *
> + * The license and distribution terms for this file may be
> + * found in the file LICENSE in this distribution or at
> + * http://www.rtems.org/license/LICENSE.
> + */
> +
> +/dts-v1/;
> +
> +/ {
> + compatible = "a,b";
> + #address-cells = <1>;
> + #size-cells = <2>;
> + model = "c";
> +
> + d {
> + e = "f";
> + g;
> +
> + h at 0 {
> + };
> +
> + h at 1 {
> + w = <123>;
> + };
> + };
> +
> + aliases {
> + k = "/m at 1248";
> + };
> +
> + l: m at 1248 {
> + n = <0xdeadbeef 0x12345678>;
> +
> + o {
> + p;
> + };
> +
> + q {
> + r = "s";
> + };
> + };
> +
> + t {
> + u = <&l>;
> + };
> +};
> diff --git a/testsuites/libtests/libfdt01/some.h b/testsuites/libtests/libfdt01/some.h
> new file mode 100644
> index 0000000..e2e0135
> --- /dev/null
> +++ b/testsuites/libtests/libfdt01/some.h
> @@ -0,0 +1,15 @@
> +/*
> + * Extern declarations for C structure representing binary file some.bin
> + *
> + * WARNING: Automatically generated -- do not edit!
> + */
> +
> +#ifndef __some_h
> +#define __some_h
> +
> +#include <sys/types.h>
> +
> +extern const unsigned char some_bin[];
> +extern const size_t some_bin_size;
> +
> +#endif
>
> _______________________________________________
> vc mailing list
> vc at rtems.org
> http://lists.rtems.org/mailman/listinfo/vc
>
--
Joel Sherrill, Ph.D. Director of Research & Development
joel.sherrill at OARcorp.com On-Line Applications Research
Ask me about RTEMS: a free RTOS Huntsville AL 35805
Support Available (256) 722-9985
More information about the devel
mailing list