EmbeddedPkg/FdtLib: Update FdtLib to v1.4.5

[mirror_edk2.git] / EmbeddedPkg / Library / FdtLib / fdt.c

/*\r
 * libfdt - Flat Device Tree manipulation\r
 * Copyright (C) 2006 David Gibson, IBM Corporation.\r
 *\r
 * libfdt is dual licensed: you can use it either under the terms of\r
 * the GPL, or the BSD license, at your option.\r
 *\r
 *  a) This library is free software; you can redistribute it and/or\r
 *     modify it under the terms of the GNU General Public License as\r
 *     published by the Free Software Foundation; either version 2 of the\r
 *     License, or (at your option) any later version.\r
 *\r
 *     This library is distributed in the hope that it will be useful,\r
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of\r
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
 *     GNU General Public License for more details.\r
 *\r
 *     You should have received a copy of the GNU General Public\r
 *     License along with this library; if not, write to the Free\r
 *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,\r
 *     MA 02110-1301 USA\r
 *\r
 * Alternatively,\r
 *\r
 *  b) Redistribution and use in source and binary forms, with or\r
 *     without modification, are permitted provided that the following\r
 *     conditions are met:\r
 *\r
 *     1. Redistributions of source code must retain the above\r
 *        copyright notice, this list of conditions and the following\r
 *        disclaimer.\r
 *     2. Redistributions in binary form must reproduce the above\r
 *        copyright notice, this list of conditions and the following\r
 *        disclaimer in the documentation and/or other materials\r
 *        provided with the distribution.\r
 *\r
 *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND\r
 *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,\r
 *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r
 *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
 *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\r
 *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
 *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
 *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
 *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
 *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
 *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
 *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,\r
 *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
 */\r
#include "libfdt_env.h"\r
\r
#include <fdt.h>\r
#include <libfdt.h>\r
\r
#include "libfdt_internal.h"\r
\r
int fdt_check_header(const void *fdt)\r
{\r
	if (fdt_magic(fdt) == FDT_MAGIC) {\r
		/* Complete tree */\r
		if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)\r
			return -FDT_ERR_BADVERSION;\r
		if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)\r
			return -FDT_ERR_BADVERSION;\r
	} else if (fdt_magic(fdt) == FDT_SW_MAGIC) {\r
		/* Unfinished sequential-write blob */\r
		if (fdt_size_dt_struct(fdt) == 0)\r
			return -FDT_ERR_BADSTATE;\r
	} else {\r
		return -FDT_ERR_BADMAGIC;\r
	}\r
\r
	return 0;\r
}\r
\r
const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)\r
{\r
	unsigned absoffset = offset + fdt_off_dt_struct(fdt);\r
\r
	if ((absoffset < offset)\r
	    || ((absoffset + len) < absoffset)\r
	    || (absoffset + len) > fdt_totalsize(fdt))\r
		return NULL;\r
\r
	if (fdt_version(fdt) >= 0x11)\r
		if (((offset + len) < offset)\r
		    || ((offset + len) > fdt_size_dt_struct(fdt)))\r
			return NULL;\r
\r
	return _fdt_offset_ptr(fdt, offset);\r
}\r
\r
uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)\r
{\r
	const fdt32_t *tagp, *lenp;\r
	uint32_t tag;\r
	int offset = startoffset;\r
	const char *p;\r
\r
	*nextoffset = -FDT_ERR_TRUNCATED;\r
	tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);\r
	if (!tagp)\r
		return FDT_END; /* premature end */\r
	tag = fdt32_to_cpu(*tagp);\r
	offset += FDT_TAGSIZE;\r
\r
	*nextoffset = -FDT_ERR_BADSTRUCTURE;\r
	switch (tag) {\r
	case FDT_BEGIN_NODE:\r
		/* skip name */\r
		do {\r
			p = fdt_offset_ptr(fdt, offset++, 1);\r
		} while (p && (*p != '\0'));\r
		if (!p)\r
			return FDT_END; /* premature end */\r
		break;\r
\r
	case FDT_PROP:\r
		lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));\r
		if (!lenp)\r
			return FDT_END; /* premature end */\r
		/* skip-name offset, length and value */\r
		offset += sizeof(struct fdt_property) - FDT_TAGSIZE\r
			+ fdt32_to_cpu(*lenp);\r
		break;\r
\r
	case FDT_END:\r
	case FDT_END_NODE:\r
	case FDT_NOP:\r
		break;\r
\r
	default:\r
		return FDT_END;\r
	}\r
\r
	if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))\r
		return FDT_END; /* premature end */\r
\r
	*nextoffset = FDT_TAGALIGN(offset);\r
	return tag;\r
}\r
\r
int _fdt_check_node_offset(const void *fdt, int offset)\r
{\r
	if ((offset < 0) || (offset % FDT_TAGSIZE)\r
	    || (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))\r
		return -FDT_ERR_BADOFFSET;\r
\r
	return offset;\r
}\r
\r
int _fdt_check_prop_offset(const void *fdt, int offset)\r
{\r
	if ((offset < 0) || (offset % FDT_TAGSIZE)\r
	    || (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))\r
		return -FDT_ERR_BADOFFSET;\r
\r
	return offset;\r
}\r
\r
int fdt_next_node(const void *fdt, int offset, int *depth)\r
{\r
	int nextoffset = 0;\r
	uint32_t tag;\r
\r
	if (offset >= 0)\r
		if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)\r
			return nextoffset;\r
\r
	do {\r
		offset = nextoffset;\r
		tag = fdt_next_tag(fdt, offset, &nextoffset);\r
\r
		switch (tag) {\r
		case FDT_PROP:\r
		case FDT_NOP:\r
			break;\r
\r
		case FDT_BEGIN_NODE:\r
			if (depth)\r
				(*depth)++;\r
			break;\r
\r
		case FDT_END_NODE:\r
			if (depth && ((--(*depth)) < 0))\r
				return nextoffset;\r
			break;\r
\r
		case FDT_END:\r
			if ((nextoffset >= 0)\r
			    || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))\r
				return -FDT_ERR_NOTFOUND;\r
			else\r
				return nextoffset;\r
		}\r
	} while (tag != FDT_BEGIN_NODE);\r
\r
	return offset;\r
}\r
\r
int fdt_first_subnode(const void *fdt, int offset)\r
{\r
	int depth = 0;\r
\r
	offset = fdt_next_node(fdt, offset, &depth);\r
	if (offset < 0 || depth != 1)\r
		return -FDT_ERR_NOTFOUND;\r
\r
	return offset;\r
}\r
\r
int fdt_next_subnode(const void *fdt, int offset)\r
{\r
	int depth = 1;\r
\r
	/*\r
	 * With respect to the parent, the depth of the next subnode will be\r
	 * the same as the last.\r
	 */\r
	do {\r
		offset = fdt_next_node(fdt, offset, &depth);\r
		if (offset < 0 || depth < 1)\r
			return -FDT_ERR_NOTFOUND;\r
	} while (depth > 1);\r
\r
	return offset;\r
}\r
\r
const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)\r
{\r
	int len = strlen(s) + 1;\r
	const char *last = strtab + tabsize - len;\r
	const char *p;\r
\r
	for (p = strtab; p <= last; p++)\r
		if (memcmp(p, s, len) == 0)\r
			return p;\r
	return NULL;\r
}\r
\r
int fdt_move(const void *fdt, void *buf, int bufsize)\r
{\r
	FDT_CHECK_HEADER(fdt);\r
\r
	if (fdt_totalsize(fdt) > bufsize)\r
		return -FDT_ERR_NOSPACE;\r
\r
	memmove(buf, fdt, fdt_totalsize(fdt));\r
	return 0;\r
}\r