ARM Packages: Fixed line endings

[mirror_edk2.git] / EmbeddedPkg / Library / FdtLib / fdt_sw.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
static int _fdt_sw_check_header(void *fdt)\r
{\r
	if (fdt_magic(fdt) != FDT_SW_MAGIC)\r
		return -FDT_ERR_BADMAGIC;\r
	/* FIXME: should check more details about the header state */\r
	return 0;\r
}\r
\r
#define FDT_SW_CHECK_HEADER(fdt) \\r
	{ \\r
		int err; \\r
		if ((err = _fdt_sw_check_header(fdt)) != 0) \\r
			return err; \\r
	}\r
\r
static void *_fdt_grab_space(void *fdt, size_t len)\r
{\r
	int offset = fdt_size_dt_struct(fdt);\r
	int spaceleft;\r
\r
	spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)\r
		- fdt_size_dt_strings(fdt);\r
\r
	if ((offset + len < offset) || (offset + len > spaceleft))\r
		return NULL;\r
\r
	fdt_set_size_dt_struct(fdt, offset + len);\r
	return _fdt_offset_ptr_w(fdt, offset);\r
}\r
\r
int fdt_create(void *buf, int bufsize)\r
{\r
	void *fdt = buf;\r
\r
	if (bufsize < sizeof(struct fdt_header))\r
		return -FDT_ERR_NOSPACE;\r
\r
	memset(buf, 0, bufsize);\r
\r
	fdt_set_magic(fdt, FDT_SW_MAGIC);\r
	fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);\r
	fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);\r
	fdt_set_totalsize(fdt,  bufsize);\r
\r
	fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),\r
					      sizeof(struct fdt_reserve_entry)));\r
	fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));\r
	fdt_set_off_dt_strings(fdt, bufsize);\r
\r
	return 0;\r
}\r
\r
int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size)\r
{\r
	struct fdt_reserve_entry *re;\r
	int offset;\r
\r
	FDT_SW_CHECK_HEADER(fdt);\r
\r
	if (fdt_size_dt_struct(fdt))\r
		return -FDT_ERR_BADSTATE;\r
\r
	offset = fdt_off_dt_struct(fdt);\r
	if ((offset + sizeof(*re)) > fdt_totalsize(fdt))\r
		return -FDT_ERR_NOSPACE;\r
\r
	re = (struct fdt_reserve_entry *)((char *)fdt + offset);\r
	re->address = cpu_to_fdt64(addr);\r
	re->size = cpu_to_fdt64(size);\r
\r
	fdt_set_off_dt_struct(fdt, offset + sizeof(*re));\r
\r
	return 0;\r
}\r
\r
int fdt_finish_reservemap(void *fdt)\r
{\r
	return fdt_add_reservemap_entry(fdt, 0, 0);\r
}\r
\r
int fdt_begin_node(void *fdt, const char *name)\r
{\r
	struct fdt_node_header *nh;\r
	int namelen = strlen(name) + 1;\r
\r
	FDT_SW_CHECK_HEADER(fdt);\r
\r
	nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));\r
	if (! nh)\r
		return -FDT_ERR_NOSPACE;\r
\r
	nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);\r
	memcpy(nh->name, name, namelen);\r
	return 0;\r
}\r
\r
int fdt_end_node(void *fdt)\r
{\r
	uint32_t *en;\r
\r
	FDT_SW_CHECK_HEADER(fdt);\r
\r
	en = _fdt_grab_space(fdt, FDT_TAGSIZE);\r
	if (! en)\r
		return -FDT_ERR_NOSPACE;\r
\r
	*en = cpu_to_fdt32(FDT_END_NODE);\r
	return 0;\r
}\r
\r
static int _fdt_find_add_string(void *fdt, const char *s)\r
{\r
	char *strtab = (char *)fdt + fdt_totalsize(fdt);\r
	const char *p;\r
	int strtabsize = fdt_size_dt_strings(fdt);\r
	int len = strlen(s) + 1;\r
	int struct_top, offset;\r
\r
	p = _fdt_find_string(strtab - strtabsize, strtabsize, s);\r
	if (p)\r
		return p - strtab;\r
\r
	/* Add it */\r
	offset = -strtabsize - len;\r
	struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);\r
	if (fdt_totalsize(fdt) + offset < struct_top)\r
		return 0; /* no more room :( */\r
\r
	memcpy(strtab + offset, s, len);\r
	fdt_set_size_dt_strings(fdt, strtabsize + len);\r
	return offset;\r
}\r
\r
int fdt_property(void *fdt, const char *name, const void *val, int len)\r
{\r
	struct fdt_property *prop;\r
	int nameoff;\r
\r
	FDT_SW_CHECK_HEADER(fdt);\r
\r
	nameoff = _fdt_find_add_string(fdt, name);\r
	if (nameoff == 0)\r
		return -FDT_ERR_NOSPACE;\r
\r
	prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));\r
	if (! prop)\r
		return -FDT_ERR_NOSPACE;\r
\r
	prop->tag = cpu_to_fdt32(FDT_PROP);\r
	prop->nameoff = cpu_to_fdt32(nameoff);\r
	prop->len = cpu_to_fdt32(len);\r
	memcpy(prop->data, val, len);\r
	return 0;\r
}\r
\r
int fdt_finish(void *fdt)\r
{\r
	char *p = (char *)fdt;\r
	uint32_t *end;\r
	int oldstroffset, newstroffset;\r
	uint32_t tag;\r
	int offset, nextoffset;\r
\r
	FDT_SW_CHECK_HEADER(fdt);\r
\r
	/* Add terminator */\r
	end = _fdt_grab_space(fdt, sizeof(*end));\r
	if (! end)\r
		return -FDT_ERR_NOSPACE;\r
	*end = cpu_to_fdt32(FDT_END);\r
\r
	/* Relocate the string table */\r
	oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);\r
	newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);\r
	memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));\r
	fdt_set_off_dt_strings(fdt, newstroffset);\r
\r
	/* Walk the structure, correcting string offsets */\r
	offset = 0;\r
	while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {\r
		if (tag == FDT_PROP) {\r
			struct fdt_property *prop =\r
				_fdt_offset_ptr_w(fdt, offset);\r
			int nameoff;\r
\r
			nameoff = fdt32_to_cpu(prop->nameoff);\r
			nameoff += fdt_size_dt_strings(fdt);\r
			prop->nameoff = cpu_to_fdt32(nameoff);\r
		}\r
		offset = nextoffset;\r
	}\r
	if (nextoffset < 0)\r
		return nextoffset;\r
\r
	/* Finally, adjust the header */\r
	fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));\r
	fdt_set_magic(fdt, FDT_MAGIC);\r
	return 0;\r
}\r