[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
	const char *p;\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
	p = _fdt_offset_ptr(fdt, offset);\r
\r
	if (p + len < p)\r
		return NULL;\r
	return p;\r
}\r
\r
uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)\r
{\r
	const uint32_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
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
Commit	Line	Data
	1	/*\r
	2	* libfdt - Flat Device Tree manipulation\r
	3	* Copyright (C) 2006 David Gibson, IBM Corporation.\r
	4	*\r
	5	* libfdt is dual licensed: you can use it either under the terms of\r
	6	* the GPL, or the BSD license, at your option.\r
	7	*\r
	8	* a) This library is free software; you can redistribute it and/or\r
	9	* modify it under the terms of the GNU General Public License as\r
	10	* published by the Free Software Foundation; either version 2 of the\r
	11	* License, or (at your option) any later version.\r
	12	*\r
	13	* This library is distributed in the hope that it will be useful,\r
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of\r
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
	16	* GNU General Public License for more details.\r
	17	*\r
	18	* You should have received a copy of the GNU General Public\r
	19	* License along with this library; if not, write to the Free\r
	20	* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,\r
	21	* MA 02110-1301 USA\r
	22	*\r
	23	* Alternatively,\r
	24	*\r
	25	* b) Redistribution and use in source and binary forms, with or\r
	26	* without modification, are permitted provided that the following\r
	27	* conditions are met:\r
	28	*\r
	29	* 1. Redistributions of source code must retain the above\r
	30	* copyright notice, this list of conditions and the following\r
	31	* disclaimer.\r
	32	* 2. Redistributions in binary form must reproduce the above\r
	33	* copyright notice, this list of conditions and the following\r
	34	* disclaimer in the documentation and/or other materials\r
	35	* provided with the distribution.\r
	36	*\r
	37	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND\r
	38	* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,\r
	39	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r
	40	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
	41	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\r
	42	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
	43	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
	44	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
	45	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
	46	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
	47	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
	48	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,\r
	49	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
	50	*/\r
	51	#include "libfdt_env.h"\r
	52	\r
	53	#include <fdt.h>\r
	54	#include <libfdt.h>\r
	55	\r
	56	#include "libfdt_internal.h"\r
	57	\r
	58	int fdt_check_header(const void *fdt)\r
	59	{\r
	60	if (fdt_magic(fdt) == FDT_MAGIC) {\r
	61	/* Complete tree */\r
	62	if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)\r
	63	return -FDT_ERR_BADVERSION;\r
	64	if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)\r
	65	return -FDT_ERR_BADVERSION;\r
	66	} else if (fdt_magic(fdt) == FDT_SW_MAGIC) {\r
	67	/* Unfinished sequential-write blob */\r
	68	if (fdt_size_dt_struct(fdt) == 0)\r
	69	return -FDT_ERR_BADSTATE;\r
	70	} else {\r
	71	return -FDT_ERR_BADMAGIC;\r
	72	}\r
	73	\r
	74	return 0;\r
	75	}\r
	76	\r
	77	const void fdt_offset_ptr(const void fdt, int offset, unsigned int len)\r
	78	{\r
	79	const char *p;\r
	80	\r
	81	if (fdt_version(fdt) >= 0x11)\r
	82	if (((offset + len) < offset)\r
	83	\|\| ((offset + len) > fdt_size_dt_struct(fdt)))\r
	84	return NULL;\r
	85	\r
	86	p = _fdt_offset_ptr(fdt, offset);\r
	87	\r
	88	if (p + len < p)\r
	89	return NULL;\r
	90	return p;\r
	91	}\r
	92	\r
	93	uint32_t fdt_next_tag(const void fdt, int startoffset, int nextoffset)\r
	94	{\r
	95	const uint32_t tagp, lenp;\r
	96	uint32_t tag;\r
	97	int offset = startoffset;\r
	98	const char *p;\r
	99	\r
	100	*nextoffset = -FDT_ERR_TRUNCATED;\r
	101	tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);\r
	102	if (!tagp)\r
	103	return FDT_END; /* premature end */\r
	104	tag = fdt32_to_cpu(*tagp);\r
	105	offset += FDT_TAGSIZE;\r
	106	\r
	107	*nextoffset = -FDT_ERR_BADSTRUCTURE;\r
	108	switch (tag) {\r
	109	case FDT_BEGIN_NODE:\r
	110	/* skip name */\r
	111	do {\r
	112	p = fdt_offset_ptr(fdt, offset++, 1);\r
	113	} while (p && (*p != '\0'));\r
	114	if (!p)\r
	115	return FDT_END; /* premature end */\r
	116	break;\r
	117	\r
	118	case FDT_PROP:\r
	119	lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));\r
	120	if (!lenp)\r
	121	return FDT_END; /* premature end */\r
	122	/* skip-name offset, length and value */\r
	123	offset += sizeof(struct fdt_property) - FDT_TAGSIZE\r
	124	+ fdt32_to_cpu(*lenp);\r
	125	break;\r
	126	\r
	127	case FDT_END:\r
	128	case FDT_END_NODE:\r
	129	case FDT_NOP:\r
	130	break;\r
	131	\r
	132	default:\r
	133	return FDT_END;\r
	134	}\r
	135	\r
	136	if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))\r
	137	return FDT_END; /* premature end */\r
	138	\r
	139	*nextoffset = FDT_TAGALIGN(offset);\r
	140	return tag;\r
	141	}\r
	142	\r
	143	int _fdt_check_node_offset(const void *fdt, int offset)\r
	144	{\r
	145	if ((offset < 0) \|\| (offset % FDT_TAGSIZE)\r
	146	\|\| (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))\r
	147	return -FDT_ERR_BADOFFSET;\r
	148	\r
	149	return offset;\r
	150	}\r
	151	\r
	152	int _fdt_check_prop_offset(const void *fdt, int offset)\r
	153	{\r
	154	if ((offset < 0) \|\| (offset % FDT_TAGSIZE)\r
	155	\|\| (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))\r
	156	return -FDT_ERR_BADOFFSET;\r
	157	\r
	158	return offset;\r
	159	}\r
	160	\r
	161	int fdt_next_node(const void fdt, int offset, int depth)\r
	162	{\r
	163	int nextoffset = 0;\r
	164	uint32_t tag;\r
	165	\r
	166	if (offset >= 0)\r
	167	if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)\r
	168	return nextoffset;\r
	169	\r
	170	do {\r
	171	offset = nextoffset;\r
	172	tag = fdt_next_tag(fdt, offset, &nextoffset);\r
	173	\r
	174	switch (tag) {\r
	175	case FDT_PROP:\r
	176	case FDT_NOP:\r
	177	break;\r
	178	\r
	179	case FDT_BEGIN_NODE:\r
	180	if (depth)\r
	181	(*depth)++;\r
	182	break;\r
	183	\r
	184	case FDT_END_NODE:\r
	185	if (depth && ((--(*depth)) < 0))\r
	186	return nextoffset;\r
	187	break;\r
	188	\r
	189	case FDT_END:\r
	190	if ((nextoffset >= 0)\r
	191	\|\| ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))\r
	192	return -FDT_ERR_NOTFOUND;\r
	193	else\r
	194	return nextoffset;\r
	195	}\r
	196	} while (tag != FDT_BEGIN_NODE);\r
	197	\r
	198	return offset;\r
	199	}\r
	200	\r
	201	const char _fdt_find_string(const char strtab, int tabsize, const char *s)\r
	202	{\r
	203	int len = strlen(s) + 1;\r
	204	const char *last = strtab + tabsize - len;\r
	205	const char *p;\r
	206	\r
	207	for (p = strtab; p <= last; p++)\r
	208	if (memcmp(p, s, len) == 0)\r
	209	return p;\r
	210	return NULL;\r
	211	}\r
	212	\r
	213	int fdt_move(const void fdt, void buf, int bufsize)\r
	214	{\r
	215	FDT_CHECK_HEADER(fdt);\r
	216	\r
	217	if (fdt_totalsize(fdt) > bufsize)\r
	218	return -FDT_ERR_NOSPACE;\r
	219	\r
	220	memmove(buf, fdt, fdt_totalsize(fdt));\r
	221	return 0;\r
	222	}\r