[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\r
fdt_check_header (\r
  const void  *fdt\r
  )\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
    }\r
\r
    if (fdt_last_comp_version (fdt) > FDT_LAST_SUPPORTED_VERSION) {\r
      return -FDT_ERR_BADVERSION;\r
    }\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
    }\r
  } else {\r
    return -FDT_ERR_BADMAGIC;\r
  }\r
\r
  return 0;\r
}\r
\r
const void *\r
fdt_offset_ptr (\r
  const void    *fdt,\r
  int           offset,\r
  unsigned int  len\r
  )\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
  {\r
    return NULL;\r
  }\r
\r
  if (fdt_version (fdt) >= 0x11) {\r
    if (  ((offset + len) < offset)\r
       || ((offset + len) > fdt_size_dt_struct (fdt)))\r
    {\r
      return NULL;\r
    }\r
  }\r
\r
  return _fdt_offset_ptr (fdt, offset);\r
}\r
\r
uint32_t\r
fdt_next_tag (\r
  const void  *fdt,\r
  int         startoffset,\r
  int         *nextoffset\r
  )\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
  }\r
\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
\r
      if (!p) {\r
        return FDT_END;                 /* premature end */\r
      }\r
\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
      }\r
\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
\r
  *nextoffset = FDT_TAGALIGN (offset);\r
  return tag;\r
}\r
\r
int\r
_fdt_check_node_offset (\r
  const void  *fdt,\r
  int         offset\r
  )\r
{\r
  if (  (offset < 0) || (offset % FDT_TAGSIZE)\r
     || (fdt_next_tag (fdt, offset, &offset) != FDT_BEGIN_NODE))\r
  {\r
    return -FDT_ERR_BADOFFSET;\r
  }\r
\r
  return offset;\r
}\r
\r
int\r
_fdt_check_prop_offset (\r
  const void  *fdt,\r
  int         offset\r
  )\r
{\r
  if (  (offset < 0) || (offset % FDT_TAGSIZE)\r
     || (fdt_next_tag (fdt, offset, &offset) != FDT_PROP))\r
  {\r
    return -FDT_ERR_BADOFFSET;\r
  }\r
\r
  return offset;\r
}\r
\r
int\r
fdt_next_node (\r
  const void  *fdt,\r
  int         offset,\r
  int         *depth\r
  )\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
  }\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
        }\r
\r
        break;\r
\r
      case FDT_END_NODE:\r
        if (depth && ((--(*depth)) < 0)) {\r
          return nextoffset;\r
        }\r
\r
        break;\r
\r
      case FDT_END:\r
        if (  (nextoffset >= 0)\r
           || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))\r
        {\r
          return -FDT_ERR_NOTFOUND;\r
        } else {\r
          return nextoffset;\r
        }\r
    }\r
  } while (tag != FDT_BEGIN_NODE);\r
\r
  return offset;\r
}\r
\r
int\r
fdt_first_subnode (\r
  const void  *fdt,\r
  int         offset\r
  )\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
\r
  return offset;\r
}\r
\r
int\r
fdt_next_subnode (\r
  const void  *fdt,\r
  int         offset\r
  )\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
    }\r
  } while (depth > 1);\r
\r
  return offset;\r
}\r
\r
const char *\r
_fdt_find_string (\r
  const char  *strtab,\r
  int         tabsize,\r
  const char  *s\r
  )\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
    }\r
  }\r
\r
  return NULL;\r
}\r
\r
int\r
fdt_move (\r
  const void  *fdt,\r
  void        *buf,\r
  int         bufsize\r
  )\r
{\r
  FDT_CHECK_HEADER (fdt);\r
\r
  if (fdt_totalsize (fdt) > bufsize) {\r
    return -FDT_ERR_NOSPACE;\r
  }\r
\r
  memmove (buf, fdt, fdt_totalsize (fdt));\r
  return 0;\r
}\r
Commit	Line	Data
1e57a462	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
e7108d0e MK	58	int\r
	59	fdt_check_header (\r
	60	const void *fdt\r
	61	)\r
1e57a462	62	{\r
e7108d0e MK	63	if (fdt_magic (fdt) == FDT_MAGIC) {\r
	64	/* Complete tree */\r
	65	if (fdt_version (fdt) < FDT_FIRST_SUPPORTED_VERSION) {\r
	66	return -FDT_ERR_BADVERSION;\r
	67	}\r
	68	\r
	69	if (fdt_last_comp_version (fdt) > FDT_LAST_SUPPORTED_VERSION) {\r
	70	return -FDT_ERR_BADVERSION;\r
	71	}\r
	72	} else if (fdt_magic (fdt) == FDT_SW_MAGIC) {\r
	73	/* Unfinished sequential-write blob */\r
	74	if (fdt_size_dt_struct (fdt) == 0) {\r
	75	return -FDT_ERR_BADSTATE;\r
	76	}\r
	77	} else {\r
	78	return -FDT_ERR_BADMAGIC;\r
	79	}\r
	80	\r
	81	return 0;\r
1e57a462	82	}\r
1e57a462	83	\r
e7108d0e MK	84	const void *\r
	85	fdt_offset_ptr (\r
	86	const void *fdt,\r
	87	int offset,\r
	88	unsigned int len\r
	89	)\r
1e57a462	90	{\r
e7108d0e MK	91	unsigned absoffset = offset + fdt_off_dt_struct (fdt);\r
	92	\r
	93	if ( (absoffset < offset)\r
	94	\|\| ((absoffset + len) < absoffset)\r
	95	\|\| ((absoffset + len) > fdt_totalsize (fdt)))\r
	96	{\r
	97	return NULL;\r
	98	}\r
	99	\r
	100	if (fdt_version (fdt) >= 0x11) {\r
	101	if ( ((offset + len) < offset)\r
	102	\|\| ((offset + len) > fdt_size_dt_struct (fdt)))\r
	103	{\r
	104	return NULL;\r
	105	}\r
	106	}\r
	107	\r
	108	return _fdt_offset_ptr (fdt, offset);\r
1e57a462	109	}\r
1e57a462	110	\r
e7108d0e MK	111	uint32_t\r
	112	fdt_next_tag (\r
	113	const void *fdt,\r
	114	int startoffset,\r
	115	int *nextoffset\r
	116	)\r
1e57a462	117	{\r
e7108d0e MK	118	const fdt32_t tagp, lenp;\r
	119	uint32_t tag;\r
	120	int offset = startoffset;\r
	121	const char *p;\r
	122	\r
	123	*nextoffset = -FDT_ERR_TRUNCATED;\r
	124	tagp = fdt_offset_ptr (fdt, offset, FDT_TAGSIZE);\r
	125	if (!tagp) {\r
	126	return FDT_END; /* premature end */\r
	127	}\r
	128	\r
	129	tag = fdt32_to_cpu (*tagp);\r
	130	offset += FDT_TAGSIZE;\r
	131	\r
	132	*nextoffset = -FDT_ERR_BADSTRUCTURE;\r
	133	switch (tag) {\r
	134	case FDT_BEGIN_NODE:\r
	135	/* skip name */\r
	136	do {\r
	137	p = fdt_offset_ptr (fdt, offset++, 1);\r
	138	} while (p && (*p != '\0'));\r
	139	\r
	140	if (!p) {\r
	141	return FDT_END; /* premature end */\r
	142	}\r
	143	\r
	144	break;\r
	145	\r
	146	case FDT_PROP:\r
	147	lenp = fdt_offset_ptr (fdt, offset, sizeof (*lenp));\r
	148	if (!lenp) {\r
	149	return FDT_END; /* premature end */\r
	150	}\r
	151	\r
	152	/* skip-name offset, length and value */\r
	153	offset += sizeof (struct fdt_property) - FDT_TAGSIZE\r
	154	+ fdt32_to_cpu (*lenp);\r
	155	break;\r
	156	\r
	157	case FDT_END:\r
	158	case FDT_END_NODE:\r
	159	case FDT_NOP:\r
	160	break;\r
	161	\r
	162	default:\r
	163	return FDT_END;\r
	164	}\r
	165	\r
	166	if (!fdt_offset_ptr (fdt, startoffset, offset - startoffset)) {\r
	167	return FDT_END; /* premature end */\r
	168	}\r
	169	\r
	170	*nextoffset = FDT_TAGALIGN (offset);\r
	171	return tag;\r
1e57a462	172	}\r
1e57a462	173	\r
e7108d0e MK	174	int\r
	175	_fdt_check_node_offset (\r
	176	const void *fdt,\r
	177	int offset\r
	178	)\r
1e57a462	179	{\r
e7108d0e MK	180	if ( (offset < 0) \|\| (offset % FDT_TAGSIZE)\r
	181	\|\| (fdt_next_tag (fdt, offset, &offset) != FDT_BEGIN_NODE))\r
	182	{\r
	183	return -FDT_ERR_BADOFFSET;\r
	184	}\r
1e57a462	185	\r
e7108d0e	186	return offset;\r
1e57a462	187	}\r
1e57a462	188	\r
e7108d0e MK	189	int\r
	190	_fdt_check_prop_offset (\r
	191	const void *fdt,\r
	192	int offset\r
	193	)\r
1e57a462	194	{\r
e7108d0e MK	195	if ( (offset < 0) \|\| (offset % FDT_TAGSIZE)\r
	196	\|\| (fdt_next_tag (fdt, offset, &offset) != FDT_PROP))\r
	197	{\r
	198	return -FDT_ERR_BADOFFSET;\r
	199	}\r
1e57a462	200	\r
e7108d0e	201	return offset;\r
1e57a462	202	}\r
1e57a462	203	\r
e7108d0e MK	204	int\r
	205	fdt_next_node (\r
	206	const void *fdt,\r
	207	int offset,\r
	208	int *depth\r
	209	)\r
1e57a462	210	{\r
e7108d0e MK	211	int nextoffset = 0;\r
	212	uint32_t tag;\r
	213	\r
	214	if (offset >= 0) {\r
	215	if ((nextoffset = _fdt_check_node_offset (fdt, offset)) < 0) {\r
	216	return nextoffset;\r
	217	}\r
	218	}\r
	219	\r
	220	do {\r
	221	offset = nextoffset;\r
	222	tag = fdt_next_tag (fdt, offset, &nextoffset);\r
	223	\r
	224	switch (tag) {\r
	225	case FDT_PROP:\r
	226	case FDT_NOP:\r
	227	break;\r
	228	\r
	229	case FDT_BEGIN_NODE:\r
	230	if (depth) {\r
	231	(*depth)++;\r
	232	}\r
	233	\r
	234	break;\r
	235	\r
	236	case FDT_END_NODE:\r
	237	if (depth && ((--(*depth)) < 0)) {\r
	238	return nextoffset;\r
	239	}\r
	240	\r
	241	break;\r
	242	\r
	243	case FDT_END:\r
	244	if ( (nextoffset >= 0)\r
	245	\|\| ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))\r
	246	{\r
	247	return -FDT_ERR_NOTFOUND;\r
	248	} else {\r
	249	return nextoffset;\r
	250	}\r
	251	}\r
	252	} while (tag != FDT_BEGIN_NODE);\r
	253	\r
	254	return offset;\r
1e57a462	255	}\r
1e57a462	256	\r
e7108d0e MK	257	int\r
	258	fdt_first_subnode (\r
	259	const void *fdt,\r
	260	int offset\r
	261	)\r
3e8576dd	262	{\r
e7108d0e	263	int depth = 0;\r
3e8576dd	264	\r
e7108d0e MK	265	offset = fdt_next_node (fdt, offset, &depth);\r
	266	if ((offset < 0) \|\| (depth != 1)) {\r
	267	return -FDT_ERR_NOTFOUND;\r
	268	}\r
3e8576dd	269	\r
e7108d0e	270	return offset;\r
3e8576dd OM	271	}\r
3e8576dd OM	272	\r
e7108d0e MK	273	int\r
	274	fdt_next_subnode (\r
	275	const void *fdt,\r
	276	int offset\r
	277	)\r
3e8576dd	278	{\r
e7108d0e MK	279	int depth = 1;\r
	280	\r
	281	/*\r
	282	* With respect to the parent, the depth of the next subnode will be\r
	283	* the same as the last.\r
	284	*/\r
	285	do {\r
	286	offset = fdt_next_node (fdt, offset, &depth);\r
	287	if ((offset < 0) \|\| (depth < 1)) {\r
	288	return -FDT_ERR_NOTFOUND;\r
	289	}\r
	290	} while (depth > 1);\r
	291	\r
	292	return offset;\r
3e8576dd OM	293	}\r
3e8576dd OM	294	\r
e7108d0e MK	295	const char *\r
	296	_fdt_find_string (\r
	297	const char *strtab,\r
	298	int tabsize,\r
	299	const char *s\r
	300	)\r
1e57a462	301	{\r
e7108d0e MK	302	int len = strlen (s) + 1;\r
	303	const char *last = strtab + tabsize - len;\r
	304	const char *p;\r
	305	\r
	306	for (p = strtab; p <= last; p++) {\r
	307	if (memcmp (p, s, len) == 0) {\r
	308	return p;\r
	309	}\r
	310	}\r
	311	\r
	312	return NULL;\r
1e57a462	313	}\r
1e57a462	314	\r
e7108d0e MK	315	int\r
	316	fdt_move (\r
	317	const void *fdt,\r
	318	void *buf,\r
	319	int bufsize\r
	320	)\r
1e57a462	321	{\r
e7108d0e	322	FDT_CHECK_HEADER (fdt);\r
1e57a462	323	\r
e7108d0e MK	324	if (fdt_totalsize (fdt) > bufsize) {\r
	325	return -FDT_ERR_NOSPACE;\r
	326	}\r
1e57a462	327	\r
e7108d0e MK	328	memmove (buf, fdt, fdt_totalsize (fdt));\r
e7108d0e MK	329	return 0;\r
1e57a462	330	}\r