From 030d01f800469a1969a343a7b41d916c8e6820f2 Mon Sep 17 00:00:00 2001 From: Leif Lindholm Date: Thu, 29 May 2025 16:55:28 +0100 Subject: [PATCH] EmbeddedPkg: delete ancient libfdt semi-integration With all in-tree users migrated, finally delete this. Any out-of-tree users need to migrate to MdePkg BaseFdtLib. Signed-off-by: Leif Lindholm --- EmbeddedPkg/EmbeddedPkg.dsc | 1 - EmbeddedPkg/Include/fdt.h | 112 - EmbeddedPkg/Include/libfdt.h | 2344 ------------------ EmbeddedPkg/Include/libfdt_env.h | 165 -- EmbeddedPkg/Library/FdtLib/FdtLib.inf | 41 - EmbeddedPkg/Library/FdtLib/Makefile.libfdt | 11 - EmbeddedPkg/Library/FdtLib/TODO | 3 - EmbeddedPkg/Library/FdtLib/fdt.c | 330 --- EmbeddedPkg/Library/FdtLib/fdt_addresses.c | 110 - EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c | 92 - EmbeddedPkg/Library/FdtLib/fdt_overlay.c | 1127 --------- EmbeddedPkg/Library/FdtLib/fdt_ro.c | 963 ------- EmbeddedPkg/Library/FdtLib/fdt_rw.c | 686 ----- EmbeddedPkg/Library/FdtLib/fdt_strerror.c | 106 - EmbeddedPkg/Library/FdtLib/fdt_strtoul.c | 37 - EmbeddedPkg/Library/FdtLib/fdt_sw.c | 375 --- EmbeddedPkg/Library/FdtLib/fdt_wip.c | 189 -- EmbeddedPkg/Library/FdtLib/libfdt_internal.h | 133 - EmbeddedPkg/Library/FdtLib/version.lds | 67 - ReadMe.rst | 3 - 20 files changed, 6895 deletions(-) delete mode 100644 EmbeddedPkg/Include/fdt.h delete mode 100644 EmbeddedPkg/Include/libfdt.h delete mode 100644 EmbeddedPkg/Include/libfdt_env.h delete mode 100644 EmbeddedPkg/Library/FdtLib/FdtLib.inf delete mode 100644 EmbeddedPkg/Library/FdtLib/Makefile.libfdt delete mode 100644 EmbeddedPkg/Library/FdtLib/TODO delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_addresses.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_overlay.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_ro.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_rw.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_strerror.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_strtoul.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_sw.c delete mode 100644 EmbeddedPkg/Library/FdtLib/fdt_wip.c delete mode 100644 EmbeddedPkg/Library/FdtLib/libfdt_internal.h delete mode 100644 EmbeddedPkg/Library/FdtLib/version.lds diff --git a/EmbeddedPkg/EmbeddedPkg.dsc b/EmbeddedPkg/EmbeddedPkg.dsc index 482329127e..4334dd2447 100644 --- a/EmbeddedPkg/EmbeddedPkg.dsc +++ b/EmbeddedPkg/EmbeddedPkg.dsc @@ -224,7 +224,6 @@ EmbeddedPkg/Library/AcpiLib/AcpiLib.inf EmbeddedPkg/Library/DebugAgentTimerLibNull/DebugAgentTimerLibNull.inf - EmbeddedPkg/Library/FdtLib/FdtLib.inf EmbeddedPkg/Library/PrePiHobLib/PrePiHobLib.inf EmbeddedPkg/Library/PrePiMemoryAllocationLib/PrePiMemoryAllocationLib.inf diff --git a/EmbeddedPkg/Include/fdt.h b/EmbeddedPkg/Include/fdt.h deleted file mode 100644 index 120dbc8bc6..0000000000 --- a/EmbeddedPkg/Include/fdt.h +++ /dev/null @@ -1,112 +0,0 @@ -#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/EmbeddedPkg/Include/libfdt.h b/EmbeddedPkg/Include/libfdt.h deleted file mode 100644 index a2db686629..0000000000 --- a/EmbeddedPkg/Include/libfdt.h +++ /dev/null @@ -1,2344 +0,0 @@ -#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 -#include - -#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: Attempted 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. - * This can be caused either by an invalid phandle property - * length, or the phandle value was either 0 or -1, which 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_BADOVERLAY 16 - -/* FDT_ERR_BADOVERLAY: The device tree overlay, while - * correctly structured, cannot be applied due to some - * unexpected or missing value, property or node. */ - -#define FDT_ERR_NOPHANDLES 17 - -/* FDT_ERR_NOPHANDLES: The device tree doesn't have any - * phandle available anymore without causing an overflow */ - -#define FDT_ERR_MAX 17 - -/**********************************************************************/ -/* Low-level functions (you probably don't need these) */ -/**********************************************************************/ - -#ifndef SWIG /* This function is not useful in Python */ -const void * -fdt_offset_ptr ( - const void *fdt, - int offset, - unsigned int checklen - ); - -#endif -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 - ); - -/** - * fdt_for_each_subnode - iterate over all subnodes of a parent - * - * @node: child node (int, lvalue) - * @fdt: FDT blob (const void *) - * @parent: parent node (int) - * - * This is actually a wrapper around a for loop and would be used like so: - * - * fdt_for_each_subnode(node, fdt, parent) { - * Use node - * ... - * } - * - * if ((node < 0) && (node != -FDT_ERR_NOT_FOUND)) { - * Error handling - * } - * - * Note that this is implemented as a macro and @node is used as - * iterator in the loop. The parent variable be constant or even a - * literal. - * - */ -#define fdt_for_each_subnode(node, fdt, parent) \ - for (node = fdt_first_subnode(fdt, parent); \ - node >= 0; \ - node = fdt_next_subnode(fdt, node)) - -/**********************************************************************/ -/* 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_get_max_phandle - retrieves the highest phandle in a tree - * @fdt: pointer to the device tree blob - * - * fdt_get_max_phandle retrieves the highest phandle in the given - * device tree. This will ignore badly formatted phandles, or phandles - * with a value of 0 or -1. - * - * returns: - * the highest phandle on success - * 0, if no phandle was found in the device tree - * -1, if an error occurred - */ -uint32_t -fdt_get_max_phandle ( - const void *fdt - ); - -/** - * 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. - */ -#ifndef SWIG /* Not available in Python */ -int -fdt_subnode_offset_namelen ( - const void *fdt, - int parentoffset, - const char *name, - int namelen - ); - -#endif - -/** - * 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. - */ -#ifndef SWIG /* Not available in Python */ -int -fdt_path_offset_namelen ( - const void *fdt, - const char *path, - int namelen - ); - -#endif - -/** - * 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_for_each_property_offset - iterate over all properties of a node - * - * @property_offset: property offset (int, lvalue) - * @fdt: FDT blob (const void *) - * @node: node offset (int) - * - * This is actually a wrapper around a for loop and would be used like so: - * - * fdt_for_each_property_offset(property, fdt, node) { - * Use property - * ... - * } - * - * if ((property < 0) && (property != -FDT_ERR_NOT_FOUND)) { - * Error handling - * } - * - * Note that this is implemented as a macro and property is used as - * iterator in the loop. The node variable can be constant or even a - * literal. - */ -#define fdt_for_each_property_offset(property, fdt, node) \ - for (property = fdt_first_property_offset(fdt, node); \ - property >= 0; \ - property = fdt_next_property_offset(fdt, property)) - -/** - * 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. - */ -#ifndef SWIG /* Not available in Python */ -const struct fdt_property * -fdt_get_property_namelen ( - const void *fdt, - int nodeoffset, - const char *name, - int namelen, - int *lenp - ); - -#endif - -/** - * 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 - */ -#ifndef SWIG /* This function is not useful in Python */ -const void * -fdt_getprop_by_offset ( - const void *fdt, - int offset, - const char **namep, - int *lenp - ); - -#endif - -/** - * 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. - */ -#ifndef SWIG /* Not available in Python */ -const void * -fdt_getprop_namelen ( - const void *fdt, - int nodeoffset, - const char *name, - int namelen, - int *lenp - ); - -static inline void * -fdt_getprop_namelen_w ( - void *fdt, - int nodeoffset, - const char *name, - int namelen, - int *lenp - ) -{ - return (void *)(uintptr_t)fdt_getprop_namelen ( - fdt, - nodeoffset, - name, - namelen, - lenp - ); -} - -#endif - -/** - * 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. - */ -#ifndef SWIG /* Not available in Python */ -const char * -fdt_get_alias_namelen ( - const void *fdt, - const char *name, - int namelen - ); - -#endif - -/** - * fdt_get_alias - retrieve 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_namelen_partial - 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 - * @namelen: number of characters of name to consider - * @idx: index of the property to change in the array - * @val: pointer to data to replace the property value with - * @len: length of the property value - * - * Identical to fdt_setprop_inplace(), but modifies the given property - * starting from the given index, and using only the first characters - * of the name. It is useful when you want to manipulate only one value of - * an array and you have a string that doesn't end with \0. - */ -#ifndef SWIG /* Not available in Python */ -int -fdt_setprop_inplace_namelen_partial ( - void *fdt, - int nodeoffset, - const char *name, - int namelen, - uint32_t idx, - const void *val, - int len - ); - -#endif - -/** - * 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 - */ -#ifndef SWIG /* Not available in Python */ -int -fdt_setprop_inplace ( - void *fdt, - int nodeoffset, - const char *name, - const void *val, - int len - ); - -#endif - -/** - * 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); -} - -/** - * fdt_property_placeholder - add a new property and return a ptr to its value - * - * @fdt: pointer to the device tree blob - * @name: name of property to add - * @len: length of property value in bytes - * @valp: returns a pointer to where where the value should be placed - * - * returns: - * 0, on success - * -FDT_ERR_BADMAGIC, - * -FDT_ERR_NOSPACE, standard meanings - */ -int -fdt_property_placeholder ( - void *fdt, - const char *name, - int len, - void **valp - ); - -#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 _placeholder - allocate space for 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 - * @len: length of the property value - * @prop_data: return pointer to property data - * - * fdt_setprop_placeholer() allocates the named property in the given node. - * If the property exists it is resized. In either case a pointer to the - * property data is returned. - * - * 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_placeholder ( - void *fdt, - int nodeoffset, - const char *name, - int len, - void **prop_data - ); - -/** - * 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_setprop_empty - set a property to an empty value - * @fdt: pointer to the device tree blob - * @nodeoffset: offset of the node whose property to change - * @name: name of the property to change - * - * fdt_setprop_empty() sets the value of the named property in the - * given node to an empty (zero length) value, or creates a new empty - * 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 - */ -#define fdt_setprop_empty(fdt, nodeoffset, name) \ - fdt_setprop((fdt), (nodeoffset), (name), NULL, 0) - -/** - * 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. - */ -#ifndef SWIG /* Not available in Python */ -int -fdt_add_subnode_namelen ( - void *fdt, - int parentoffset, - const char *name, - int namelen - ); - -#endif - -/** - * 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 - ); - -/** - * fdt_overlay_apply - Applies a DT overlay on a base DT - * @fdt: pointer to the base device tree blob - * @fdto: pointer to the device tree overlay blob - * - * fdt_overlay_apply() will apply the given device tree overlay on the - * given base device tree. - * - * Expect the base device tree to be modified, even if the function - * returns an error. - * - * returns: - * 0, on success - * -FDT_ERR_NOSPACE, there's not enough space in the base device tree - * -FDT_ERR_NOTFOUND, the overlay points to some nonexistant nodes or - * properties in the base DT - * -FDT_ERR_BADPHANDLE, - * -FDT_ERR_BADOVERLAY, - * -FDT_ERR_NOPHANDLES, - * -FDT_ERR_INTERNAL, - * -FDT_ERR_BADLAYOUT, - * -FDT_ERR_BADMAGIC, - * -FDT_ERR_BADOFFSET, - * -FDT_ERR_BADPATH, - * -FDT_ERR_BADVERSION, - * -FDT_ERR_BADSTRUCTURE, - * -FDT_ERR_BADSTATE, - * -FDT_ERR_TRUNCATED, standard meanings - */ -int -fdt_overlay_apply ( - void *fdt, - void *fdto - ); - -/**********************************************************************/ -/* Debugging / informational functions */ -/**********************************************************************/ - -const char * -fdt_strerror ( - int errval - ); - -#endif /* _LIBFDT_H */ diff --git a/EmbeddedPkg/Include/libfdt_env.h b/EmbeddedPkg/Include/libfdt_env.h deleted file mode 100644 index dfd3bac01f..0000000000 --- a/EmbeddedPkg/Include/libfdt_env.h +++ /dev/null @@ -1,165 +0,0 @@ -/** @file -* -* Copyright (c) 2011-2014, ARM Limited. All rights reserved. -* -* SPDX-License-Identifier: BSD-2-Clause-Patent -* -**/ - -#ifndef _LIBFDT_ENV_H -#define _LIBFDT_ENV_H - -#include -#include - -typedef UINT16 fdt16_t; -typedef UINT32 fdt32_t; -typedef UINT64 fdt64_t; - -typedef UINT8 uint8_t; -typedef UINT16 uint16_t; -typedef UINT32 uint32_t; -typedef UINT64 uint64_t; -typedef UINTN uintptr_t; -typedef UINTN size_t; - -static inline uint16_t -fdt16_to_cpu ( - fdt16_t x - ) -{ - return SwapBytes16 (x); -} - -#define cpu_to_fdt16(x) fdt16_to_cpu(x) - -static inline uint32_t -fdt32_to_cpu ( - fdt32_t x - ) -{ - return SwapBytes32 (x); -} - -#define cpu_to_fdt32(x) fdt32_to_cpu(x) - -static inline uint64_t -fdt64_to_cpu ( - fdt64_t x - ) -{ - return SwapBytes64 (x); -} - -#define cpu_to_fdt64(x) fdt64_to_cpu(x) - -static inline void * -memcpy ( - void *dest, - const void *src, - size_t len - ) -{ - return CopyMem (dest, src, len); -} - -static inline void * -memmove ( - void *dest, - const void *src, - size_t n - ) -{ - return CopyMem (dest, src, n); -} - -static inline void * -memset ( - void *s, - int c, - size_t n - ) -{ - return SetMem (s, n, c); -} - -static inline int -memcmp ( - const void *dest, - const void *src, - int len - ) -{ - return CompareMem (dest, src, len); -} - -static inline void * -memchr ( - const void *s, - int c, - size_t n - ) -{ - return ScanMem8 (s, n, c); -} - -static inline size_t -strlen ( - const char *str - ) -{ - return AsciiStrLen (str); -} - -static inline char * -strchr ( - const char *s, - int c - ) -{ - char pattern[2]; - - pattern[0] = c; - pattern[1] = 0; - return AsciiStrStr (s, pattern); -} - -static inline size_t -strnlen ( - const char *str, - size_t strsz - ) -{ - return AsciiStrnLenS (str, strsz); -} - -static inline size_t -strcmp ( - const char *str1, - const char *str2 - ) -{ - return AsciiStrCmp (str1, str2); -} - -static inline size_t -strncmp ( - const char *str1, - const char *str2, - size_t strsz - ) -{ - return AsciiStrnCmp (str1, str2, strsz); -} - -static inline size_t -strncpy ( - char *dest, - const char *source, - size_t dest_max - ) -{ - return AsciiStrCpyS (dest, dest_max, source); -} - -#endif /* _LIBFDT_ENV_H */ diff --git a/EmbeddedPkg/Library/FdtLib/FdtLib.inf b/EmbeddedPkg/Library/FdtLib/FdtLib.inf deleted file mode 100644 index 354c1709c9..0000000000 --- a/EmbeddedPkg/Library/FdtLib/FdtLib.inf +++ /dev/null @@ -1,41 +0,0 @@ -#/* @file -# Copyright (c) 2011-2014, ARM Limited. All rights reserved. -# -# SPDX-License-Identifier: BSD-2-Clause-Patent -# -#*/ - -[Defines] - INF_VERSION = 0x00010005 - BASE_NAME = FdtLib - FILE_GUID = 6b2478c0-be23-11e0-a28c-0002a5d5c51b - MODULE_TYPE = BASE - VERSION_STRING = 1.0 - LIBRARY_CLASS = FdtLib - -# -# The following information is for reference only and not required by the build tools. -# -# VALID_ARCHITECTURES = ARM AARCH64 -# - -[Sources] - libfdt_internal.h - fdt_empty_tree.c - fdt_overlay.c - fdt_ro.c - fdt_rw.c - fdt_strerror.c - fdt_strtoul.c - fdt_sw.c - fdt_wip.c - fdt.c - fdt_addresses.c - -[Packages] - MdePkg/MdePkg.dec - EmbeddedPkg/EmbeddedPkg.dec - -[LibraryClasses] - BaseLib - DebugLib diff --git a/EmbeddedPkg/Library/FdtLib/Makefile.libfdt b/EmbeddedPkg/Library/FdtLib/Makefile.libfdt deleted file mode 100644 index 5b74948d9e..0000000000 --- a/EmbeddedPkg/Library/FdtLib/Makefile.libfdt +++ /dev/null @@ -1,11 +0,0 @@ -# Makefile.libfdt -# -# This is not a complete Makefile of itself. Instead, it is designed to -# be easily embeddable into other systems of Makefiles. -# -LIBFDT_soname = libfdt.$(SHAREDLIB_EXT).1 -LIBFDT_INCLUDES = fdt.h libfdt.h libfdt_env.h -LIBFDT_VERSION = version.lds -LIBFDT_SRCS = fdt.c fdt_ro.c fdt_wip.c fdt_sw.c fdt_rw.c fdt_strerror.c fdt_empty_tree.c \ - fdt_addresses.c -LIBFDT_OBJS = $(LIBFDT_SRCS:%.c=%.o) diff --git a/EmbeddedPkg/Library/FdtLib/TODO b/EmbeddedPkg/Library/FdtLib/TODO deleted file mode 100644 index 288437e394..0000000000 --- a/EmbeddedPkg/Library/FdtLib/TODO +++ /dev/null @@ -1,3 +0,0 @@ -- Tree traversal functions -- Graft function -- Complete libfdt.h documenting comments diff --git a/EmbeddedPkg/Library/FdtLib/fdt.c b/EmbeddedPkg/Library/FdtLib/fdt.c deleted file mode 100644 index 56a9787cd0..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt.c +++ /dev/null @@ -1,330 +0,0 @@ -/* - * 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 -#include - -#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 - ) -{ - unsigned absoffset = offset + fdt_off_dt_struct (fdt); - - if ( (absoffset < offset) - || ((absoffset + len) < absoffset) - || ((absoffset + len) > fdt_totalsize (fdt))) - { - return NULL; - } - - if (fdt_version (fdt) >= 0x11) { - if ( ((offset + len) < offset) - || ((offset + len) > fdt_size_dt_struct (fdt))) - { - return NULL; - } - } - - return _fdt_offset_ptr (fdt, offset); -} - -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/EmbeddedPkg/Library/FdtLib/fdt_addresses.c b/EmbeddedPkg/Library/FdtLib/fdt_addresses.c deleted file mode 100644 index a0f531aac9..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_addresses.c +++ /dev/null @@ -1,110 +0,0 @@ -/* - * libfdt - Flat Device Tree manipulation - * Copyright (C) 2014 David Gibson - * - * 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 -#include - -#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/EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c b/EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c deleted file mode 100644 index 65a128f2b8..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c +++ /dev/null @@ -1,92 +0,0 @@ -/* - * 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 -#include - -#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/EmbeddedPkg/Library/FdtLib/fdt_overlay.c b/EmbeddedPkg/Library/FdtLib/fdt_overlay.c deleted file mode 100644 index 0e6b8715e4..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_overlay.c +++ /dev/null @@ -1,1127 +0,0 @@ -/* - * libfdt - Flat Device Tree manipulation - * Copyright (C) 2016 Free Electrons - * Copyright (C) 2016 NextThing Co. - * - * 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 -#include - -#include "libfdt_internal.h" - -/** - * overlay_get_target_phandle - retrieves the target phandle of a fragment - * @fdto: pointer to the device tree overlay blob - * @fragment: node offset of the fragment in the overlay - * - * overlay_get_target_phandle() retrieves the target phandle of an - * overlay fragment when that fragment uses a phandle (target - * property) instead of a path (target-path property). - * - * returns: - * the phandle pointed by the target property - * 0, if the phandle was not found - * -1, if the phandle was malformed - */ -static uint32_t -overlay_get_target_phandle ( - const void *fdto, - int fragment - ) -{ - const fdt32_t *val; - int len; - - val = fdt_getprop (fdto, fragment, "target", &len); - if (!val) { - return 0; - } - - if ((len != sizeof (*val)) || (fdt32_to_cpu (*val) == (uint32_t)-1)) { - return (uint32_t)-1; - } - - return fdt32_to_cpu (*val); -} - -/** - * overlay_get_target - retrieves the offset of a fragment's target - * @fdt: Base device tree blob - * @fdto: Device tree overlay blob - * @fragment: node offset of the fragment in the overlay - * @pathp: pointer which receives the path of the target (or NULL) - * - * overlay_get_target() retrieves the target offset in the base - * device tree of a fragment, no matter how the actual targetting is - * done (through a phandle or a path) - * - * returns: - * the targetted node offset in the base device tree - * Negative error code on error - */ -static int -overlay_get_target ( - const void *fdt, - const void *fdto, - int fragment, - char const **pathp - ) -{ - uint32_t phandle; - const char *path = NULL; - int path_len = 0, ret; - - /* Try first to do a phandle based lookup */ - phandle = overlay_get_target_phandle (fdto, fragment); - if (phandle == (uint32_t)-1) { - return -FDT_ERR_BADPHANDLE; - } - - /* no phandle, try path */ - if (!phandle) { - /* And then a path based lookup */ - path = fdt_getprop (fdto, fragment, "target-path", &path_len); - if (path) { - ret = fdt_path_offset (fdt, path); - } else { - ret = path_len; - } - } else { - ret = fdt_node_offset_by_phandle (fdt, phandle); - } - - /* - * If we haven't found either a target or a - * target-path property in a node that contains a - * __overlay__ subnode (we wouldn't be called - * otherwise), consider it a improperly written - * overlay - */ - if ((ret < 0) && (path_len == -FDT_ERR_NOTFOUND)) { - ret = -FDT_ERR_BADOVERLAY; - } - - /* return on error */ - if (ret < 0) { - return ret; - } - - /* return pointer to path (if available) */ - if (pathp) { - *pathp = path ? path : NULL; - } - - return ret; -} - -/** - * overlay_phandle_add_offset - Increases a phandle by an offset - * @fdt: Base device tree blob - * @node: Device tree overlay blob - * @name: Name of the property to modify (phandle or linux,phandle) - * @delta: offset to apply - * - * overlay_phandle_add_offset() increments a node phandle by a given - * offset. - * - * returns: - * 0 on success. - * Negative error code on error - */ -static int -overlay_phandle_add_offset ( - void *fdt, - int node, - const char *name, - uint32_t delta - ) -{ - const fdt32_t *val; - uint32_t adj_val; - int len; - - val = fdt_getprop (fdt, node, name, &len); - if (!val) { - return len; - } - - if (len != sizeof (*val)) { - return -FDT_ERR_BADPHANDLE; - } - - adj_val = fdt32_to_cpu (*val); - if ((adj_val + delta) < adj_val) { - return -FDT_ERR_NOPHANDLES; - } - - adj_val += delta; - if (adj_val == (uint32_t)-1) { - return -FDT_ERR_NOPHANDLES; - } - - return fdt_setprop_inplace_u32 (fdt, node, name, adj_val); -} - -/** - * overlay_adjust_node_phandles - Offsets the phandles of a node - * @fdto: Device tree overlay blob - * @node: Offset of the node we want to adjust - * @delta: Offset to shift the phandles of - * - * overlay_adjust_node_phandles() adds a constant to all the phandles - * of a given node. This is mainly use as part of the overlay - * application process, when we want to update all the overlay - * phandles to not conflict with the overlays of the base device tree. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_adjust_node_phandles ( - void *fdto, - int node, - uint32_t delta - ) -{ - int child; - int ret; - - ret = overlay_phandle_add_offset (fdto, node, "phandle", delta); - if (ret && (ret != -FDT_ERR_NOTFOUND)) { - return ret; - } - - ret = overlay_phandle_add_offset (fdto, node, "linux,phandle", delta); - if (ret && (ret != -FDT_ERR_NOTFOUND)) { - return ret; - } - - fdt_for_each_subnode (child, fdto, node) { - ret = overlay_adjust_node_phandles (fdto, child, delta); - if (ret) { - return ret; - } - } - - return 0; -} - -/** - * overlay_adjust_local_phandles - Adjust the phandles of a whole overlay - * @fdto: Device tree overlay blob - * @delta: Offset to shift the phandles of - * - * overlay_adjust_local_phandles() adds a constant to all the - * phandles of an overlay. This is mainly use as part of the overlay - * application process, when we want to update all the overlay - * phandles to not conflict with the overlays of the base device tree. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_adjust_local_phandles ( - void *fdto, - uint32_t delta - ) -{ - /* - * Start adjusting the phandles from the overlay root - */ - return overlay_adjust_node_phandles (fdto, 0, delta); -} - -/** - * overlay_update_local_node_references - Adjust the overlay references - * @fdto: Device tree overlay blob - * @tree_node: Node offset of the node to operate on - * @fixup_node: Node offset of the matching local fixups node - * @delta: Offset to shift the phandles of - * - * overlay_update_local_nodes_references() update the phandles - * pointing to a node within the device tree overlay by adding a - * constant delta. - * - * This is mainly used as part of a device tree application process, - * where you want the device tree overlays phandles to not conflict - * with the ones from the base device tree before merging them. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_update_local_node_references ( - void *fdto, - int tree_node, - int fixup_node, - uint32_t delta - ) -{ - int fixup_prop; - int fixup_child; - int ret; - - fdt_for_each_property_offset (fixup_prop, fdto, fixup_node) { - const fdt32_t *fixup_val; - const char *tree_val; - const char *name; - int fixup_len; - int tree_len; - int i; - - fixup_val = fdt_getprop_by_offset ( - fdto, - fixup_prop, - &name, - &fixup_len - ); - if (!fixup_val) { - return fixup_len; - } - - if (fixup_len % sizeof (uint32_t)) { - return -FDT_ERR_BADOVERLAY; - } - - tree_val = fdt_getprop (fdto, tree_node, name, &tree_len); - if (!tree_val) { - if (tree_len == -FDT_ERR_NOTFOUND) { - return -FDT_ERR_BADOVERLAY; - } - - return tree_len; - } - - for (i = 0; i < (fixup_len / sizeof (uint32_t)); i++) { - fdt32_t adj_val; - uint32_t poffset; - - poffset = fdt32_to_cpu (fixup_val[i]); - - /* - * phandles to fixup can be unaligned. - * - * Use a memcpy for the architectures that do - * not support unaligned accesses. - */ - memcpy (&adj_val, tree_val + poffset, sizeof (adj_val)); - - adj_val = cpu_to_fdt32 (fdt32_to_cpu (adj_val) + delta); - - ret = fdt_setprop_inplace_namelen_partial ( - fdto, - tree_node, - name, - strlen (name), - poffset, - &adj_val, - sizeof (adj_val) - ); - if (ret == -FDT_ERR_NOSPACE) { - return -FDT_ERR_BADOVERLAY; - } - - if (ret) { - return ret; - } - } - } - - fdt_for_each_subnode (fixup_child, fdto, fixup_node) { - const char *fixup_child_name = fdt_get_name ( - fdto, - fixup_child, - NULL - ); - int tree_child; - - tree_child = fdt_subnode_offset ( - fdto, - tree_node, - fixup_child_name - ); - if (tree_child == -FDT_ERR_NOTFOUND) { - return -FDT_ERR_BADOVERLAY; - } - - if (tree_child < 0) { - return tree_child; - } - - ret = overlay_update_local_node_references ( - fdto, - tree_child, - fixup_child, - delta - ); - if (ret) { - return ret; - } - } - - return 0; -} - -/** - * overlay_update_local_references - Adjust the overlay references - * @fdto: Device tree overlay blob - * @delta: Offset to shift the phandles of - * - * overlay_update_local_references() update all the phandles pointing - * to a node within the device tree overlay by adding a constant - * delta to not conflict with the base overlay. - * - * This is mainly used as part of a device tree application process, - * where you want the device tree overlays phandles to not conflict - * with the ones from the base device tree before merging them. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_update_local_references ( - void *fdto, - uint32_t delta - ) -{ - int fixups; - - fixups = fdt_path_offset (fdto, "/__local_fixups__"); - if (fixups < 0) { - /* There's no local phandles to adjust, bail out */ - if (fixups == -FDT_ERR_NOTFOUND) { - return 0; - } - - return fixups; - } - - /* - * Update our local references from the root of the tree - */ - return overlay_update_local_node_references ( - fdto, - 0, - fixups, - delta - ); -} - -/** - * overlay_fixup_one_phandle - Set an overlay phandle to the base one - * @fdt: Base Device Tree blob - * @fdto: Device tree overlay blob - * @symbols_off: Node offset of the symbols node in the base device tree - * @path: Path to a node holding a phandle in the overlay - * @path_len: number of path characters to consider - * @name: Name of the property holding the phandle reference in the overlay - * @name_len: number of name characters to consider - * @poffset: Offset within the overlay property where the phandle is stored - * @label: Label of the node referenced by the phandle - * - * overlay_fixup_one_phandle() resolves an overlay phandle pointing to - * a node in the base device tree. - * - * This is part of the device tree overlay application process, when - * you want all the phandles in the overlay to point to the actual - * base dt nodes. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_fixup_one_phandle ( - void *fdt, - void *fdto, - int symbols_off, - const char *path, - uint32_t path_len, - const char *name, - uint32_t name_len, - int poffset, - const char *label - ) -{ - const char *symbol_path; - uint32_t phandle; - fdt32_t phandle_prop; - int symbol_off, fixup_off; - int prop_len; - - if (symbols_off < 0) { - return symbols_off; - } - - symbol_path = fdt_getprop ( - fdt, - symbols_off, - label, - &prop_len - ); - if (!symbol_path) { - return prop_len; - } - - symbol_off = fdt_path_offset (fdt, symbol_path); - if (symbol_off < 0) { - return symbol_off; - } - - phandle = fdt_get_phandle (fdt, symbol_off); - if (!phandle) { - return -FDT_ERR_NOTFOUND; - } - - fixup_off = fdt_path_offset_namelen (fdto, path, path_len); - if (fixup_off == -FDT_ERR_NOTFOUND) { - return -FDT_ERR_BADOVERLAY; - } - - if (fixup_off < 0) { - return fixup_off; - } - - phandle_prop = cpu_to_fdt32 (phandle); - return fdt_setprop_inplace_namelen_partial ( - fdto, - fixup_off, - name, - name_len, - poffset, - &phandle_prop, - sizeof (phandle_prop) - ); -} - -unsigned long -strtoul ( - const char *nptr, - char **endptr, - int base - ); - -/** - * overlay_fixup_phandle - Set an overlay phandle to the base one - * @fdt: Base Device Tree blob - * @fdto: Device tree overlay blob - * @symbols_off: Node offset of the symbols node in the base device tree - * @property: Property offset in the overlay holding the list of fixups - * - * overlay_fixup_phandle() resolves all the overlay phandles pointed - * to in a __fixups__ property, and updates them to match the phandles - * in use in the base device tree. - * - * This is part of the device tree overlay application process, when - * you want all the phandles in the overlay to point to the actual - * base dt nodes. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_fixup_phandle ( - void *fdt, - void *fdto, - int symbols_off, - int property - ) -{ - const char *value; - const char *label; - int len; - - value = fdt_getprop_by_offset ( - fdto, - property, - &label, - &len - ); - if (!value) { - if (len == -FDT_ERR_NOTFOUND) { - return -FDT_ERR_INTERNAL; - } - - return len; - } - - do { - const char *path, *name, *fixup_end; - const char *fixup_str = value; - uint32_t path_len, name_len; - uint32_t fixup_len; - char *sep, *endptr; - int poffset, ret; - - fixup_end = memchr (value, '\0', len); - if (!fixup_end) { - return -FDT_ERR_BADOVERLAY; - } - - fixup_len = fixup_end - fixup_str; - - len -= fixup_len + 1; - value += fixup_len + 1; - - path = fixup_str; - sep = memchr (fixup_str, ':', fixup_len); - if (!sep || (*sep != ':')) { - return -FDT_ERR_BADOVERLAY; - } - - path_len = sep - path; - if (path_len == (fixup_len - 1)) { - return -FDT_ERR_BADOVERLAY; - } - - fixup_len -= path_len + 1; - name = sep + 1; - sep = memchr (name, ':', fixup_len); - if (!sep || (*sep != ':')) { - return -FDT_ERR_BADOVERLAY; - } - - name_len = sep - name; - if (!name_len) { - return -FDT_ERR_BADOVERLAY; - } - - poffset = strtoul (sep + 1, &endptr, 10); - if ((*endptr != '\0') || (endptr <= (sep + 1))) { - return -FDT_ERR_BADOVERLAY; - } - - ret = overlay_fixup_one_phandle ( - fdt, - fdto, - symbols_off, - path, - path_len, - name, - name_len, - poffset, - label - ); - if (ret) { - return ret; - } - } while (len > 0); - - return 0; -} - -/** - * overlay_fixup_phandles - Resolve the overlay phandles to the base - * device tree - * @fdt: Base Device Tree blob - * @fdto: Device tree overlay blob - * - * overlay_fixup_phandles() resolves all the overlay phandles pointing - * to nodes in the base device tree. - * - * This is one of the steps of the device tree overlay application - * process, when you want all the phandles in the overlay to point to - * the actual base dt nodes. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_fixup_phandles ( - void *fdt, - void *fdto - ) -{ - int fixups_off, symbols_off; - int property; - - /* We can have overlays without any fixups */ - fixups_off = fdt_path_offset (fdto, "/__fixups__"); - if (fixups_off == -FDT_ERR_NOTFOUND) { - return 0; /* nothing to do */ - } - - if (fixups_off < 0) { - return fixups_off; - } - - /* And base DTs without symbols */ - symbols_off = fdt_path_offset (fdt, "/__symbols__"); - if (((symbols_off < 0) && (symbols_off != -FDT_ERR_NOTFOUND))) { - return symbols_off; - } - - fdt_for_each_property_offset (property, fdto, fixups_off) { - int ret; - - ret = overlay_fixup_phandle (fdt, fdto, symbols_off, property); - if (ret) { - return ret; - } - } - - return 0; -} - -/** - * overlay_apply_node - Merges a node into the base device tree - * @fdt: Base Device Tree blob - * @target: Node offset in the base device tree to apply the fragment to - * @fdto: Device tree overlay blob - * @node: Node offset in the overlay holding the changes to merge - * - * overlay_apply_node() merges a node into a target base device tree - * node pointed. - * - * This is part of the final step in the device tree overlay - * application process, when all the phandles have been adjusted and - * resolved and you just have to merge overlay into the base device - * tree. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_apply_node ( - void *fdt, - int target, - void *fdto, - int node - ) -{ - int property; - int subnode; - - fdt_for_each_property_offset (property, fdto, node) { - const char *name; - const void *prop; - int prop_len; - int ret; - - prop = fdt_getprop_by_offset ( - fdto, - property, - &name, - &prop_len - ); - if (prop_len == -FDT_ERR_NOTFOUND) { - return -FDT_ERR_INTERNAL; - } - - if (prop_len < 0) { - return prop_len; - } - - ret = fdt_setprop (fdt, target, name, prop, prop_len); - if (ret) { - return ret; - } - } - - fdt_for_each_subnode (subnode, fdto, node) { - const char *name = fdt_get_name (fdto, subnode, NULL); - int nnode; - int ret; - - nnode = fdt_add_subnode (fdt, target, name); - if (nnode == -FDT_ERR_EXISTS) { - nnode = fdt_subnode_offset (fdt, target, name); - if (nnode == -FDT_ERR_NOTFOUND) { - return -FDT_ERR_INTERNAL; - } - } - - if (nnode < 0) { - return nnode; - } - - ret = overlay_apply_node (fdt, nnode, fdto, subnode); - if (ret) { - return ret; - } - } - - return 0; -} - -/** - * overlay_merge - Merge an overlay into its base device tree - * @fdt: Base Device Tree blob - * @fdto: Device tree overlay blob - * - * overlay_merge() merges an overlay into its base device tree. - * - * This is the next to last step in the device tree overlay application - * process, when all the phandles have been adjusted and resolved and - * you just have to merge overlay into the base device tree. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_merge ( - void *fdt, - void *fdto - ) -{ - int fragment; - - fdt_for_each_subnode (fragment, fdto, 0) { - int overlay; - int target; - int ret; - - /* - * Each fragments will have an __overlay__ node. If - * they don't, it's not supposed to be merged - */ - overlay = fdt_subnode_offset (fdto, fragment, "__overlay__"); - if (overlay == -FDT_ERR_NOTFOUND) { - continue; - } - - if (overlay < 0) { - return overlay; - } - - target = overlay_get_target (fdt, fdto, fragment, NULL); - if (target < 0) { - return target; - } - - ret = overlay_apply_node (fdt, target, fdto, overlay); - if (ret) { - return ret; - } - } - - return 0; -} - -static int -get_path_len ( - const void *fdt, - int nodeoffset - ) -{ - int len = 0, namelen; - const char *name; - - FDT_CHECK_HEADER (fdt); - - for ( ; ;) { - name = fdt_get_name (fdt, nodeoffset, &namelen); - if (!name) { - return namelen; - } - - /* root? we're done */ - if (namelen == 0) { - break; - } - - nodeoffset = fdt_parent_offset (fdt, nodeoffset); - if (nodeoffset < 0) { - return nodeoffset; - } - - len += namelen + 1; - } - - /* in case of root pretend it's "/" */ - if (len == 0) { - len++; - } - - return len; -} - -/** - * overlay_symbol_update - Update the symbols of base tree after a merge - * @fdt: Base Device Tree blob - * @fdto: Device tree overlay blob - * - * overlay_symbol_update() updates the symbols of the base tree with the - * symbols of the applied overlay - * - * This is the last step in the device tree overlay application - * process, allowing the reference of overlay symbols by subsequent - * overlay operations. - * - * returns: - * 0 on success - * Negative error code on failure - */ -static int -overlay_symbol_update ( - void *fdt, - void *fdto - ) -{ - int root_sym, ov_sym, prop, path_len, fragment, target; - int len, frag_name_len, ret, rel_path_len; - const char *s, *e; - const char *path; - const char *name; - const char *frag_name; - const char *rel_path; - const char *target_path; - char *buf; - void *p; - - ov_sym = fdt_subnode_offset (fdto, 0, "__symbols__"); - - /* if no overlay symbols exist no problem */ - if (ov_sym < 0) { - return 0; - } - - root_sym = fdt_subnode_offset (fdt, 0, "__symbols__"); - - /* it no root symbols exist we should create them */ - if (root_sym == -FDT_ERR_NOTFOUND) { - root_sym = fdt_add_subnode (fdt, 0, "__symbols__"); - } - - /* any error is fatal now */ - if (root_sym < 0) { - return root_sym; - } - - /* iterate over each overlay symbol */ - fdt_for_each_property_offset (prop, fdto, ov_sym) { - path = fdt_getprop_by_offset (fdto, prop, &name, &path_len); - if (!path) { - return path_len; - } - - /* verify it's a string property (terminated by a single \0) */ - if ((path_len < 1) || (memchr (path, '\0', path_len) != &path[path_len - 1])) { - return -FDT_ERR_BADVALUE; - } - - /* keep end marker to avoid strlen() */ - e = path + path_len; - - /* format: //__overlay__/ */ - - if (*path != '/') { - return -FDT_ERR_BADVALUE; - } - - /* get fragment name first */ - s = strchr (path + 1, '/'); - if (!s) { - return -FDT_ERR_BADOVERLAY; - } - - frag_name = path + 1; - frag_name_len = s - path - 1; - - /* verify format; safe since "s" lies in \0 terminated prop */ - len = sizeof ("/__overlay__/") - 1; - if (((e - s) < len) || memcmp (s, "/__overlay__/", len)) { - return -FDT_ERR_BADOVERLAY; - } - - rel_path = s + len; - rel_path_len = e - rel_path; - - /* find the fragment index in which the symbol lies */ - ret = fdt_subnode_offset_namelen ( - fdto, - 0, - frag_name, - frag_name_len - ); - /* not found? */ - if (ret < 0) { - return -FDT_ERR_BADOVERLAY; - } - - fragment = ret; - - /* an __overlay__ subnode must exist */ - ret = fdt_subnode_offset (fdto, fragment, "__overlay__"); - if (ret < 0) { - return -FDT_ERR_BADOVERLAY; - } - - /* get the target of the fragment */ - ret = overlay_get_target (fdt, fdto, fragment, &target_path); - if (ret < 0) { - return ret; - } - - target = ret; - - /* if we have a target path use */ - if (!target_path) { - ret = get_path_len (fdt, target); - if (ret < 0) { - return ret; - } - - len = ret; - } else { - len = strlen (target_path); - } - - ret = fdt_setprop_placeholder ( - fdt, - root_sym, - name, - len + (len > 1) + rel_path_len + 1, - &p - ); - if (ret < 0) { - return ret; - } - - if (!target_path) { - /* again in case setprop_placeholder changed it */ - ret = overlay_get_target (fdt, fdto, fragment, &target_path); - if (ret < 0) { - return ret; - } - - target = ret; - } - - buf = p; - if (len > 1) { - /* target is not root */ - if (!target_path) { - ret = fdt_get_path (fdt, target, buf, len + 1); - if (ret < 0) { - return ret; - } - } else { - memcpy (buf, target_path, len + 1); - } - } else { - len--; - } - - buf[len] = '/'; - memcpy (buf + len + 1, rel_path, rel_path_len); - buf[len + 1 + rel_path_len] = '\0'; - } - - return 0; -} - -int -fdt_overlay_apply ( - void *fdt, - void *fdto - ) -{ - uint32_t delta = fdt_get_max_phandle (fdt); - int ret; - - FDT_CHECK_HEADER (fdt); - FDT_CHECK_HEADER (fdto); - - ret = overlay_adjust_local_phandles (fdto, delta); - if (ret) { - goto err; - } - - ret = overlay_update_local_references (fdto, delta); - if (ret) { - goto err; - } - - ret = overlay_fixup_phandles (fdt, fdto); - if (ret) { - goto err; - } - - ret = overlay_merge (fdt, fdto); - if (ret) { - goto err; - } - - ret = overlay_symbol_update (fdt, fdto); - if (ret) { - goto err; - } - - /* - * The overlay has been damaged, erase its magic. - */ - fdt_set_magic (fdto, ~0); - - return 0; - -err: - - /* - * The overlay might have been damaged, erase its magic. - */ - fdt_set_magic (fdto, ~0); - - /* - * The base device tree might have been damaged, erase its - * magic. - */ - fdt_set_magic (fdt, ~0); - - return ret; -} diff --git a/EmbeddedPkg/Library/FdtLib/fdt_ro.c b/EmbeddedPkg/Library/FdtLib/fdt_ro.c deleted file mode 100644 index 30aac37958..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_ro.c +++ /dev/null @@ -1,963 +0,0 @@ -/* - * 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 -#include - -#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); -} - -uint32_t -fdt_get_max_phandle ( - const void *fdt - ) -{ - uint32_t max_phandle = 0; - int offset; - - for (offset = fdt_next_node (fdt, -1, NULL); ; - offset = fdt_next_node (fdt, offset, NULL)) - { - uint32_t phandle; - - if (offset == -FDT_ERR_NOTFOUND) { - return max_phandle; - } - - if (offset < 0) { - return (uint32_t)-1; - } - - phandle = fdt_get_phandle (fdt, offset); - if (phandle == (uint32_t)-1) { - continue; - } - - if (phandle > max_phandle) { - max_phandle = phandle; - } - } - - return 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; - } - - return !fdt_stringlist_contains (prop, len, compatible); -} - -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/EmbeddedPkg/Library/FdtLib/fdt_rw.c b/EmbeddedPkg/Library/FdtLib/fdt_rw.c deleted file mode 100644 index cb5088a3af..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_rw.c +++ /dev/null @@ -1,686 +0,0 @@ -/* - * 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 -#include - -#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 ((p < (char *)fdt) || ((end - oldlen + newlen) < (char *)fdt)) { - 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); - - FDT_RW_CHECK_HEADER (fdt); - - if (n >= fdt_num_mem_rsv (fdt)) { - return -FDT_ERR_NOTFOUND; - } - - return _fdt_splice_mem_rsv (fdt, re, 1, 0); -} - -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_placeholder ( - void *fdt, - int nodeoffset, - const char *name, - int len, - void **prop_data - ) -{ - 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; - } - - *prop_data = prop->data; - return 0; -} - -int -fdt_setprop ( - void *fdt, - int nodeoffset, - const char *name, - const void *val, - int len - ) -{ - void *prop_data; - int err; - - err = fdt_setprop_placeholder (fdt, nodeoffset, name, len, &prop_data); - if (err) { - return err; - } - - if (len) { - 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/EmbeddedPkg/Library/FdtLib/fdt_strerror.c b/EmbeddedPkg/Library/FdtLib/fdt_strerror.c deleted file mode 100644 index cb07f6166e..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_strerror.c +++ /dev/null @@ -1,106 +0,0 @@ -/* - * 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 -#include - -#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_BADPHANDLE), - 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), - FDT_ERRTABENT (FDT_ERR_INTERNAL), - FDT_ERRTABENT (FDT_ERR_BADNCELLS), - FDT_ERRTABENT (FDT_ERR_BADVALUE), - FDT_ERRTABENT (FDT_ERR_BADOVERLAY), - FDT_ERRTABENT (FDT_ERR_NOPHANDLES), -}; -#define FDT_ERRTABSIZE (sizeof(fdt_errtable) / sizeof(fdt_errtable[0])) - -const char * -fdt_strerror ( - int errval - ) -{ - if (errval > 0) { - return ""; - } else if (errval == 0) { - return ""; - } else if (errval > -FDT_ERRTABSIZE) { - const char *s = fdt_errtable[-errval].str; - - if (s) { - return s; - } - } - - return ""; -} diff --git a/EmbeddedPkg/Library/FdtLib/fdt_strtoul.c b/EmbeddedPkg/Library/FdtLib/fdt_strtoul.c deleted file mode 100644 index e615d6f4c0..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_strtoul.c +++ /dev/null @@ -1,37 +0,0 @@ -#/* @file -# Copyright (c) 2018, Linaro Limited. All rights reserved. -# -# SPDX-License-Identifier: BSD-2-Clause-Patent -# -#*/ - -#include -#include -#include - -unsigned long -strtoul ( - const char *nptr, - char **endptr, - int base - ) -{ - RETURN_STATUS Status; - UINTN ReturnValue; - - ASSERT (base == 10 || base == 16); - - if (base == 10) { - Status = AsciiStrDecimalToUintnS (nptr, endptr, &ReturnValue); - } else if (base == 16) { - Status = AsciiStrHexToUintnS (nptr, endptr, &ReturnValue); - } else { - Status = RETURN_INVALID_PARAMETER; - } - - if (RETURN_ERROR (Status)) { - return MAX_UINTN; - } - - return ReturnValue; -} diff --git a/EmbeddedPkg/Library/FdtLib/fdt_sw.c b/EmbeddedPkg/Library/FdtLib/fdt_sw.c deleted file mode 100644 index 6bcdd1fc7b..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_sw.c +++ /dev/null @@ -1,375 +0,0 @@ -/* - * 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 -#include - -#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_placeholder ( - void *fdt, - const char *name, - int len, - void **valp - ) -{ - 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); - *valp = prop->data; - return 0; -} - -int -fdt_property ( - void *fdt, - const char *name, - const void *val, - int len - ) -{ - void *ptr; - int ret; - - ret = fdt_property_placeholder (fdt, name, len, &ptr); - if (ret) { - return ret; - } - - memcpy (ptr, 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/EmbeddedPkg/Library/FdtLib/fdt_wip.c b/EmbeddedPkg/Library/FdtLib/fdt_wip.c deleted file mode 100644 index 8447706919..0000000000 --- a/EmbeddedPkg/Library/FdtLib/fdt_wip.c +++ /dev/null @@ -1,189 +0,0 @@ -/* - * 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 -#include - -#include "libfdt_internal.h" - -int -fdt_setprop_inplace_namelen_partial ( - void *fdt, - int nodeoffset, - const char *name, - int namelen, - uint32_t idx, - const void *val, - int len - ) -{ - void *propval; - int proplen; - - propval = fdt_getprop_namelen_w ( - fdt, - nodeoffset, - name, - namelen, - &proplen - ); - if (!propval) { - return proplen; - } - - if (proplen < (len + idx)) { - return -FDT_ERR_NOSPACE; - } - - memcpy ((char *)propval + idx, val, len); - return 0; -} - -int -fdt_setprop_inplace ( - void *fdt, - int nodeoffset, - const char *name, - const void *val, - int len - ) -{ - const void *propval; - int proplen; - - propval = fdt_getprop (fdt, nodeoffset, name, &proplen); - if (!propval) { - return proplen; - } - - if (proplen != len) { - return -FDT_ERR_NOSPACE; - } - - return fdt_setprop_inplace_namelen_partial ( - fdt, - nodeoffset, - name, - strlen (name), - 0, - val, - len - ); -} - -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/EmbeddedPkg/Library/FdtLib/libfdt_internal.h b/EmbeddedPkg/Library/FdtLib/libfdt_internal.h deleted file mode 100644 index f3c89581a8..0000000000 --- a/EmbeddedPkg/Library/FdtLib/libfdt_internal.h +++ /dev/null @@ -1,133 +0,0 @@ -#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 - -#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/EmbeddedPkg/Library/FdtLib/version.lds b/EmbeddedPkg/Library/FdtLib/version.lds deleted file mode 100644 index 84538f697d..0000000000 --- a/EmbeddedPkg/Library/FdtLib/version.lds +++ /dev/null @@ -1,67 +0,0 @@ -LIBFDT_1.2 { - global: - fdt_next_node; - fdt_check_header; - fdt_move; - fdt_string; - fdt_num_mem_rsv; - fdt_get_mem_rsv; - fdt_subnode_offset_namelen; - fdt_subnode_offset; - fdt_path_offset_namelen; - fdt_path_offset; - fdt_get_name; - fdt_get_property_namelen; - fdt_get_property; - fdt_getprop_namelen; - fdt_getprop; - fdt_get_phandle; - fdt_get_alias_namelen; - fdt_get_alias; - fdt_get_path; - fdt_supernode_atdepth_offset; - fdt_node_depth; - fdt_parent_offset; - fdt_node_offset_by_prop_value; - fdt_node_offset_by_phandle; - fdt_node_check_compatible; - fdt_node_offset_by_compatible; - fdt_setprop_inplace; - fdt_nop_property; - fdt_nop_node; - fdt_create; - fdt_add_reservemap_entry; - fdt_finish_reservemap; - fdt_begin_node; - fdt_property; - fdt_end_node; - fdt_finish; - fdt_open_into; - fdt_pack; - fdt_add_mem_rsv; - fdt_del_mem_rsv; - fdt_set_name; - fdt_setprop; - fdt_delprop; - fdt_add_subnode_namelen; - fdt_add_subnode; - fdt_del_node; - fdt_strerror; - fdt_offset_ptr; - fdt_next_tag; - fdt_appendprop; - fdt_create_empty_tree; - fdt_first_property_offset; - fdt_get_property_by_offset; - fdt_getprop_by_offset; - fdt_next_property_offset; - fdt_first_subnode; - fdt_next_subnode; - fdt_address_cells; - fdt_size_cells; - fdt_stringlist_contains; - fdt_resize; - - local: - *; -}; diff --git a/ReadMe.rst b/ReadMe.rst index 17aa206871..ecde5cc2eb 100644 --- a/ReadMe.rst +++ b/ReadMe.rst @@ -84,9 +84,6 @@ licenses: - `CryptoPkg\Library\BaseCryptLib\SysCall\inet_pton.c `__ - `CryptoPkg\Library\Include\crypto\dso_conf.h `__ - `CryptoPkg\Library\Include\openssl\opensslconf.h `__ -- `EmbeddedPkg/Library/FdtLib `__. (EDK II uses BSD License) -- `EmbeddedPkg/Include/fdt.h `__. (EDK II uses BSD Licence) -- `EmbeddedPkg/Include/libfdt.h `__. (EDK II uses BSD License) - `MdeModulePkg/Library/LzmaCustomDecompressLib `__ - `OvmfPkg `__