[people/ms/u-boot.git] / common / fdt_support.c

/*
 * (C) Copyright 2007
 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program 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 program 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 program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <common.h>
#include <linux/ctype.h>
#include <linux/types.h>
#include <asm/global_data.h>
#include <fdt.h>
#include <libfdt.h>
#include <fdt_support.h>
#include <exports.h>

/*
 * Global data (for the gd->bd)
 */
DECLARE_GLOBAL_DATA_PTR;


/**
 * fdt_find_and_setprop: Find a node and set it's property
 *
 * @fdt: ptr to device tree
 * @node: path of node
 * @prop: property name
 * @val: ptr to new value
 * @len: length of new property value
 * @create: flag to create the property if it doesn't exist
 *
 * Convenience function to directly set a property given the path to the node.
 */
int fdt_find_and_setprop(void *fdt, const char *node, const char *prop,
			 const void *val, int len, int create)
{
	int nodeoff = fdt_path_offset(fdt, node);

	if (nodeoff < 0)
		return nodeoff;

	if ((!create) && (fdt_get_property(fdt, nodeoff, prop, 0) == NULL))
		return 0; /* create flag not set; so exit quietly */

	return fdt_setprop(fdt, nodeoff, prop, val, len);
}

#ifdef CONFIG_OF_STDOUT_VIA_ALIAS
static int fdt_fixup_stdout(void *fdt, int choosenoff)
{
	int err = 0;
#ifdef CONFIG_CONS_INDEX
	int node;
	char sername[9] = { 0 };
	const char *path;

	sprintf(sername, "serial%d", CONFIG_CONS_INDEX - 1);

	err = node = fdt_path_offset(fdt, "/aliases");
	if (node >= 0) {
		int len;
		path = fdt_getprop(fdt, node, sername, &len);
		if (path) {
			char *p = malloc(len);
			err = -FDT_ERR_NOSPACE;
			if (p) {
				memcpy(p, path, len);
				err = fdt_setprop(fdt, choosenoff,
					"linux,stdout-path", p, len);
				free(p);
			}
		} else {
			err = len;
		}
	}
#endif
	if (err < 0)
		printf("WARNING: could not set linux,stdout-path %s.\n",
				fdt_strerror(err));

	return err;
}
#endif

int fdt_chosen(void *fdt, ulong initrd_start, ulong initrd_end, int force)
{
	int   nodeoffset;
	int   err;
	u32   tmp;		/* used to set 32 bit integer properties */
	char  *str;		/* used to set string properties */
	const char *path;

	err = fdt_check_header(fdt);
	if (err < 0) {
		printf("fdt_chosen: %s\n", fdt_strerror(err));
		return err;
	}

	if (initrd_start && initrd_end) {
		uint64_t addr, size;
		int  total = fdt_num_mem_rsv(fdt);
		int  j;

		/*
		 * Look for an existing entry and update it.  If we don't find
		 * the entry, we will j be the next available slot.
		 */
		for (j = 0; j < total; j++) {
			err = fdt_get_mem_rsv(fdt, j, &addr, &size);
			if (addr == initrd_start) {
				fdt_del_mem_rsv(fdt, j);
				break;
			}
		}

		err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start + 1);
		if (err < 0) {
			printf("fdt_chosen: %s\n", fdt_strerror(err));
			return err;
		}
	}

	/*
	 * Find the "chosen" node.
	 */
	nodeoffset = fdt_path_offset (fdt, "/chosen");

	/*
	 * If there is no "chosen" node in the blob, create it.
	 */
	if (nodeoffset < 0) {
		/*
		 * Create a new node "/chosen" (offset 0 is root level)
		 */
		nodeoffset = fdt_add_subnode(fdt, 0, "chosen");
		if (nodeoffset < 0) {
			printf("WARNING: could not create /chosen %s.\n",
				fdt_strerror(nodeoffset));
			return nodeoffset;
		}
	}

	/*
	 * Create /chosen properites that don't exist in the fdt.
	 * If the property exists, update it only if the "force" parameter
	 * is true.
	 */
	str = getenv("bootargs");
	if (str != NULL) {
		path = fdt_getprop(fdt, nodeoffset, "bootargs", NULL);
		if ((path == NULL) || force) {
			err = fdt_setprop(fdt, nodeoffset,
				"bootargs", str, strlen(str)+1);
			if (err < 0)
				printf("WARNING: could not set bootargs %s.\n",
					fdt_strerror(err));
		}
	}
	if (initrd_start && initrd_end) {
		path = fdt_getprop(fdt, nodeoffset, "linux,initrd-start", NULL);
		if ((path == NULL) || force) {
			tmp = __cpu_to_be32(initrd_start);
			err = fdt_setprop(fdt, nodeoffset,
				"linux,initrd-start", &tmp, sizeof(tmp));
			if (err < 0)
				printf("WARNING: "
					"could not set linux,initrd-start %s.\n",
					fdt_strerror(err));
			tmp = __cpu_to_be32(initrd_end);
			err = fdt_setprop(fdt, nodeoffset,
				"linux,initrd-end", &tmp, sizeof(tmp));
			if (err < 0)
				printf("WARNING: could not set linux,initrd-end %s.\n",
					fdt_strerror(err));
		}
	}

#ifdef CONFIG_OF_STDOUT_VIA_ALIAS
	path = fdt_getprop(fdt, nodeoffset, "linux,stdout-path", NULL);
	if ((path == NULL) || force)
		err = fdt_fixup_stdout(fdt, nodeoffset);
#endif

#ifdef OF_STDOUT_PATH
	path = fdt_getprop(fdt, nodeoffset, "linux,stdout-path", NULL);
	if ((path == NULL) || force) {
		err = fdt_setprop(fdt, nodeoffset,
			"linux,stdout-path", OF_STDOUT_PATH, strlen(OF_STDOUT_PATH)+1);
		if (err < 0)
			printf("WARNING: could not set linux,stdout-path %s.\n",
				fdt_strerror(err));
	}
#endif

	return err;
}

void do_fixup_by_path(void *fdt, const char *path, const char *prop,
		      const void *val, int len, int create)
{
#if defined(DEBUG)
	int i;
	debug("Updating property '%s/%s' = ", path, prop);
	for (i = 0; i < len; i++)
		debug(" %.2x", *(u8*)(val+i));
	debug("\n");
#endif
	int rc = fdt_find_and_setprop(fdt, path, prop, val, len, create);
	if (rc)
		printf("Unable to update property %s:%s, err=%s\n",
			path, prop, fdt_strerror(rc));
}

void do_fixup_by_path_u32(void *fdt, const char *path, const char *prop,
			  u32 val, int create)
{
	val = cpu_to_fdt32(val);
	do_fixup_by_path(fdt, path, prop, &val, sizeof(val), create);
}

void do_fixup_by_prop(void *fdt,
		      const char *pname, const void *pval, int plen,
		      const char *prop, const void *val, int len,
		      int create)
{
	int off;
#if defined(DEBUG)
	int i;
	debug("Updating property '%s' = ", prop);
	for (i = 0; i < len; i++)
		debug(" %.2x", *(u8*)(val+i));
	debug("\n");
#endif
	off = fdt_node_offset_by_prop_value(fdt, -1, pname, pval, plen);
	while (off != -FDT_ERR_NOTFOUND) {
		if (create || (fdt_get_property(fdt, off, prop, 0) != NULL))
			fdt_setprop(fdt, off, prop, val, len);
		off = fdt_node_offset_by_prop_value(fdt, off, pname, pval, plen);
	}
}

void do_fixup_by_prop_u32(void *fdt,
			  const char *pname, const void *pval, int plen,
			  const char *prop, u32 val, int create)
{
	val = cpu_to_fdt32(val);
	do_fixup_by_prop(fdt, pname, pval, plen, prop, &val, 4, create);
}

void do_fixup_by_compat(void *fdt, const char *compat,
			const char *prop, const void *val, int len, int create)
{
	int off = -1;
#if defined(DEBUG)
	int i;
	debug("Updating property '%s' = ", prop);
	for (i = 0; i < len; i++)
		debug(" %.2x", *(u8*)(val+i));
	debug("\n");
#endif
	off = fdt_node_offset_by_compatible(fdt, -1, compat);
	while (off != -FDT_ERR_NOTFOUND) {
		if (create || (fdt_get_property(fdt, off, prop, 0) != NULL))
			fdt_setprop(fdt, off, prop, val, len);
		off = fdt_node_offset_by_compatible(fdt, off, compat);
	}
}

void do_fixup_by_compat_u32(void *fdt, const char *compat,
			    const char *prop, u32 val, int create)
{
	val = cpu_to_fdt32(val);
	do_fixup_by_compat(fdt, compat, prop, &val, 4, create);
}

int fdt_fixup_memory(void *blob, u64 start, u64 size)
{
	int err, nodeoffset, len = 0;
	u8 tmp[16];
	const u32 *addrcell, *sizecell;

	err = fdt_check_header(blob);
	if (err < 0) {
		printf("%s: %s\n", __FUNCTION__, fdt_strerror(err));
		return err;
	}

	/* update, or add and update /memory node */
	nodeoffset = fdt_path_offset(blob, "/memory");
	if (nodeoffset < 0) {
		nodeoffset = fdt_add_subnode(blob, 0, "memory");
		if (nodeoffset < 0)
			printf("WARNING: could not create /memory: %s.\n",
					fdt_strerror(nodeoffset));
		return nodeoffset;
	}
	err = fdt_setprop(blob, nodeoffset, "device_type", "memory",
			sizeof("memory"));
	if (err < 0) {
		printf("WARNING: could not set %s %s.\n", "device_type",
				fdt_strerror(err));
		return err;
	}

	addrcell = fdt_getprop(blob, 0, "#address-cells", NULL);
	/* use shifts and mask to ensure endianness */
	if ((addrcell) && (*addrcell == 2)) {
		tmp[0] = (start >> 56) & 0xff;
		tmp[1] = (start >> 48) & 0xff;
		tmp[2] = (start >> 40) & 0xff;
		tmp[3] = (start >> 32) & 0xff;
		tmp[4] = (start >> 24) & 0xff;
		tmp[5] = (start >> 16) & 0xff;
		tmp[6] = (start >>  8) & 0xff;
		tmp[7] = (start      ) & 0xff;
		len = 8;
	} else {
		tmp[0] = (start >> 24) & 0xff;
		tmp[1] = (start >> 16) & 0xff;
		tmp[2] = (start >>  8) & 0xff;
		tmp[3] = (start      ) & 0xff;
		len = 4;
	}

	sizecell = fdt_getprop(blob, 0, "#size-cells", NULL);
	/* use shifts and mask to ensure endianness */
	if ((sizecell) && (*sizecell == 2)) {
		tmp[0+len] = (size >> 56) & 0xff;
		tmp[1+len] = (size >> 48) & 0xff;
		tmp[2+len] = (size >> 40) & 0xff;
		tmp[3+len] = (size >> 32) & 0xff;
		tmp[4+len] = (size >> 24) & 0xff;
		tmp[5+len] = (size >> 16) & 0xff;
		tmp[6+len] = (size >>  8) & 0xff;
		tmp[7+len] = (size      ) & 0xff;
		len += 8;
	} else {
		tmp[0+len] = (size >> 24) & 0xff;
		tmp[1+len] = (size >> 16) & 0xff;
		tmp[2+len] = (size >>  8) & 0xff;
		tmp[3+len] = (size      ) & 0xff;
		len += 4;
	}

	err = fdt_setprop(blob, nodeoffset, "reg", tmp, len);
	if (err < 0) {
		printf("WARNING: could not set %s %s.\n",
				"reg", fdt_strerror(err));
		return err;
	}
	return 0;
}

#if defined(CONFIG_HAS_ETH0) || defined(CONFIG_HAS_ETH1) ||\
    defined(CONFIG_HAS_ETH2) || defined(CONFIG_HAS_ETH3)

void fdt_fixup_ethernet(void *fdt, bd_t *bd)
{
	int node;
	const char *path;

	node = fdt_path_offset(fdt, "/aliases");
	if (node >= 0) {
#if defined(CONFIG_HAS_ETH0)
		path = fdt_getprop(fdt, node, "ethernet0", NULL);
		if (path) {
			do_fixup_by_path(fdt, path, "mac-address",
				bd->bi_enetaddr, 6, 0);
			do_fixup_by_path(fdt, path, "local-mac-address",
				bd->bi_enetaddr, 6, 1);
		}
#endif
#if defined(CONFIG_HAS_ETH1)
		path = fdt_getprop(fdt, node, "ethernet1", NULL);
		if (path) {
			do_fixup_by_path(fdt, path, "mac-address",
				bd->bi_enet1addr, 6, 0);
			do_fixup_by_path(fdt, path, "local-mac-address",
				bd->bi_enet1addr, 6, 1);
		}
#endif
#if defined(CONFIG_HAS_ETH2)
		path = fdt_getprop(fdt, node, "ethernet2", NULL);
		if (path) {
			do_fixup_by_path(fdt, path, "mac-address",
				bd->bi_enet2addr, 6, 0);
			do_fixup_by_path(fdt, path, "local-mac-address",
				bd->bi_enet2addr, 6, 1);
		}
#endif
#if defined(CONFIG_HAS_ETH3)
		path = fdt_getprop(fdt, node, "ethernet3", NULL);
		if (path) {
			do_fixup_by_path(fdt, path, "mac-address",
				bd->bi_enet3addr, 6, 0);
			do_fixup_by_path(fdt, path, "local-mac-address",
				bd->bi_enet3addr, 6, 1);
		}
#endif
	}
}
#endif

#ifdef CONFIG_HAS_FSL_DR_USB
void fdt_fixup_dr_usb(void *blob, bd_t *bd)
{
	char *mode;
	const char *compat = "fsl-usb2-dr";
	const char *prop = "dr_mode";
	int node_offset;
	int err;

	mode = getenv("usb_dr_mode");
	if (!mode)
		return;

	node_offset = fdt_node_offset_by_compatible(blob, 0, compat);
	if (node_offset < 0)
		printf("WARNING: could not find compatible node %s: %s.\n",
			compat, fdt_strerror(node_offset));

	err = fdt_setprop(blob, node_offset, prop, mode, strlen(mode) + 1);
	if (err < 0)
		printf("WARNING: could not set %s for %s: %s.\n",
		       prop, compat, fdt_strerror(err));
}
#endif /* CONFIG_HAS_FSL_DR_USB */
Commit	Line	Data
64dbbd40 GVB	1	/*
	2	* (C) Copyright 2007
	3	* Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com
	4	*
	5	* See file CREDITS for list of people who contributed to this
	6	* project.
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation; either version 2 of
	11	* the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	21	* MA 02111-1307 USA
	22	*/
	23
	24	#include <common.h>
	25	#include <linux/ctype.h>
	26	#include <linux/types.h>
64dbbd40 GVB	27	#include <asm/global_data.h>
	28	#include <fdt.h>
	29	#include <libfdt.h>
	30	#include <fdt_support.h>
151c8b09	31	#include <exports.h>
64dbbd40 GVB	32
	33	/*
	34	* Global data (for the gd->bd)
	35	*/
	36	DECLARE_GLOBAL_DATA_PTR;
	37
64dbbd40	38
a3c2933e KG	39	/**
	40	* fdt_find_and_setprop: Find a node and set it's property
	41	*
	42	* @fdt: ptr to device tree
	43	* @node: path of node
	44	* @prop: property name
	45	* @val: ptr to new value
	46	* @len: length of new property value
	47	* @create: flag to create the property if it doesn't exist
	48	*
	49	* Convenience function to directly set a property given the path to the node.
	50	*/
	51	int fdt_find_and_setprop(void fdt, const char node, const char *prop,
	52	const void *val, int len, int create)
	53	{
8d04f02f	54	int nodeoff = fdt_path_offset(fdt, node);
a3c2933e KG	55
	56	if (nodeoff < 0)
	57	return nodeoff;
	58
	59	if ((!create) && (fdt_get_property(fdt, nodeoff, prop, 0) == NULL))
	60	return 0; /* create flag not set; so exit quietly */
	61
	62	return fdt_setprop(fdt, nodeoff, prop, val, len);
	63	}
	64
151c8b09 KG	65	#ifdef CONFIG_OF_STDOUT_VIA_ALIAS
	66	static int fdt_fixup_stdout(void *fdt, int choosenoff)
	67	{
	68	int err = 0;
	69	#ifdef CONFIG_CONS_INDEX
	70	int node;
	71	char sername[9] = { 0 };
	72	const char *path;
	73
	74	sprintf(sername, "serial%d", CONFIG_CONS_INDEX - 1);
	75
	76	err = node = fdt_path_offset(fdt, "/aliases");
	77	if (node >= 0) {
	78	int len;
	79	path = fdt_getprop(fdt, node, sername, &len);
	80	if (path) {
	81	char *p = malloc(len);
	82	err = -FDT_ERR_NOSPACE;
	83	if (p) {
	84	memcpy(p, path, len);
	85	err = fdt_setprop(fdt, choosenoff,
	86	"linux,stdout-path", p, len);
	87	free(p);
	88	}
	89	} else {
	90	err = len;
	91	}
	92	}
	93	#endif
	94	if (err < 0)
	95	printf("WARNING: could not set linux,stdout-path %s.\n",
	96	fdt_strerror(err));
	97
	98	return err;
	99	}
	100	#endif
	101
64dbbd40 GVB	102	int fdt_chosen(void *fdt, ulong initrd_start, ulong initrd_end, int force)
64dbbd40 GVB	103	{
64dbbd40 GVB	104	int nodeoffset;
64dbbd40 GVB	105	int err;
35ec398f GVB	106	u32 tmp; /* used to set 32 bit integer properties */
35ec398f GVB	107	char str; / used to set string properties */
b60af3d4	108	const char *path;
64dbbd40 GVB	109
	110	err = fdt_check_header(fdt);
	111	if (err < 0) {
5fe6be62	112	printf("fdt_chosen: %s\n", fdt_strerror(err));
64dbbd40 GVB	113	return err;
	114	}
	115
64dbbd40	116	if (initrd_start && initrd_end) {
8d04f02f KG	117	uint64_t addr, size;
8d04f02f KG	118	int total = fdt_num_mem_rsv(fdt);
c28abb9c GVB	119	int j;
c28abb9c GVB	120
c28abb9c GVB	121	/*
	122	* Look for an existing entry and update it. If we don't find
	123	* the entry, we will j be the next available slot.
	124	*/
8d04f02f KG	125	for (j = 0; j < total; j++) {
	126	err = fdt_get_mem_rsv(fdt, j, &addr, &size);
	127	if (addr == initrd_start) {
	128	fdt_del_mem_rsv(fdt, j);
c28abb9c GVB	129	break;
	130	}
	131	}
8d04f02f KG	132
8d04f02f KG	133	err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start + 1);
64dbbd40	134	if (err < 0) {
5fe6be62	135	printf("fdt_chosen: %s\n", fdt_strerror(err));
64dbbd40 GVB	136	return err;
	137	}
	138	}
	139
	140	/*
	141	* Find the "chosen" node.
	142	*/
8d04f02f	143	nodeoffset = fdt_path_offset (fdt, "/chosen");
64dbbd40 GVB	144
64dbbd40 GVB	145	/*
b60af3d4	146	* If there is no "chosen" node in the blob, create it.
64dbbd40 GVB	147	*/
	148	if (nodeoffset < 0) {
	149	/*
	150	* Create a new node "/chosen" (offset 0 is root level)
	151	*/
	152	nodeoffset = fdt_add_subnode(fdt, 0, "chosen");
	153	if (nodeoffset < 0) {
5fe6be62	154	printf("WARNING: could not create /chosen %s.\n",
35ec398f	155	fdt_strerror(nodeoffset));
64dbbd40 GVB	156	return nodeoffset;
	157	}
	158	}
	159
	160	/*
b60af3d4 GVB	161	* Create /chosen properites that don't exist in the fdt.
	162	* If the property exists, update it only if the "force" parameter
	163	* is true.
64dbbd40 GVB	164	*/
	165	str = getenv("bootargs");
	166	if (str != NULL) {
b60af3d4 GVB	167	path = fdt_getprop(fdt, nodeoffset, "bootargs", NULL);
	168	if ((path == NULL) \|\| force) {
	169	err = fdt_setprop(fdt, nodeoffset,
	170	"bootargs", str, strlen(str)+1);
	171	if (err < 0)
	172	printf("WARNING: could not set bootargs %s.\n",
	173	fdt_strerror(err));
	174	}
64dbbd40 GVB	175	}
64dbbd40 GVB	176	if (initrd_start && initrd_end) {
b60af3d4 GVB	177	path = fdt_getprop(fdt, nodeoffset, "linux,initrd-start", NULL);
	178	if ((path == NULL) \|\| force) {
	179	tmp = __cpu_to_be32(initrd_start);
	180	err = fdt_setprop(fdt, nodeoffset,
	181	"linux,initrd-start", &tmp, sizeof(tmp));
	182	if (err < 0)
	183	printf("WARNING: "
	184	"could not set linux,initrd-start %s.\n",
	185	fdt_strerror(err));
	186	tmp = __cpu_to_be32(initrd_end);
	187	err = fdt_setprop(fdt, nodeoffset,
	188	"linux,initrd-end", &tmp, sizeof(tmp));
	189	if (err < 0)
	190	printf("WARNING: could not set linux,initrd-end %s.\n",
	191	fdt_strerror(err));
	192	}
64dbbd40	193	}
151c8b09 KG	194
151c8b09 KG	195	#ifdef CONFIG_OF_STDOUT_VIA_ALIAS
b60af3d4 GVB	196	path = fdt_getprop(fdt, nodeoffset, "linux,stdout-path", NULL);
	197	if ((path == NULL) \|\| force)
	198	err = fdt_fixup_stdout(fdt, nodeoffset);
151c8b09 KG	199	#endif
151c8b09 KG	200
64dbbd40	201	#ifdef OF_STDOUT_PATH
b60af3d4 GVB	202	path = fdt_getprop(fdt, nodeoffset, "linux,stdout-path", NULL);
	203	if ((path == NULL) \|\| force) {
	204	err = fdt_setprop(fdt, nodeoffset,
	205	"linux,stdout-path", OF_STDOUT_PATH, strlen(OF_STDOUT_PATH)+1);
	206	if (err < 0)
	207	printf("WARNING: could not set linux,stdout-path %s.\n",
	208	fdt_strerror(err));
	209	}
64dbbd40 GVB	210	#endif
64dbbd40 GVB	211
64dbbd40 GVB	212	return err;
	213	}
	214
e93becf8 KG	215	void do_fixup_by_path(void fdt, const char path, const char *prop,
	216	const void *val, int len, int create)
	217	{
	218	#if defined(DEBUG)
	219	int i;
d9ad115b	220	debug("Updating property '%s/%s' = ", path, prop);
e93becf8 KG	221	for (i = 0; i < len; i++)
	222	debug(" %.2x", (u8)(val+i));
	223	debug("\n");
	224	#endif
	225	int rc = fdt_find_and_setprop(fdt, path, prop, val, len, create);
	226	if (rc)
	227	printf("Unable to update property %s:%s, err=%s\n",
	228	path, prop, fdt_strerror(rc));
	229	}
	230
	231	void do_fixup_by_path_u32(void fdt, const char path, const char *prop,
	232	u32 val, int create)
	233	{
	234	val = cpu_to_fdt32(val);
	235	do_fixup_by_path(fdt, path, prop, &val, sizeof(val), create);
	236	}
	237
9eb77cea KG	238	void do_fixup_by_prop(void *fdt,
	239	const char pname, const void pval, int plen,
	240	const char prop, const void val, int len,
	241	int create)
	242	{
	243	int off;
	244	#if defined(DEBUG)
	245	int i;
d9ad115b	246	debug("Updating property '%s' = ", prop);
9eb77cea KG	247	for (i = 0; i < len; i++)
	248	debug(" %.2x", (u8)(val+i));
	249	debug("\n");
	250	#endif
	251	off = fdt_node_offset_by_prop_value(fdt, -1, pname, pval, plen);
	252	while (off != -FDT_ERR_NOTFOUND) {
	253	if (create \|\| (fdt_get_property(fdt, off, prop, 0) != NULL))
	254	fdt_setprop(fdt, off, prop, val, len);
	255	off = fdt_node_offset_by_prop_value(fdt, off, pname, pval, plen);
	256	}
	257	}
	258
	259	void do_fixup_by_prop_u32(void *fdt,
	260	const char pname, const void pval, int plen,
	261	const char *prop, u32 val, int create)
	262	{
	263	val = cpu_to_fdt32(val);
	264	do_fixup_by_prop(fdt, pname, pval, plen, prop, &val, 4, create);
	265	}
	266
	267	void do_fixup_by_compat(void fdt, const char compat,
	268	const char prop, const void val, int len, int create)
	269	{
	270	int off = -1;
	271	#if defined(DEBUG)
	272	int i;
d9ad115b	273	debug("Updating property '%s' = ", prop);
9eb77cea KG	274	for (i = 0; i < len; i++)
	275	debug(" %.2x", (u8)(val+i));
	276	debug("\n");
	277	#endif
	278	off = fdt_node_offset_by_compatible(fdt, -1, compat);
	279	while (off != -FDT_ERR_NOTFOUND) {
	280	if (create \|\| (fdt_get_property(fdt, off, prop, 0) != NULL))
	281	fdt_setprop(fdt, off, prop, val, len);
	282	off = fdt_node_offset_by_compatible(fdt, off, compat);
	283	}
	284	}
	285
	286	void do_fixup_by_compat_u32(void fdt, const char compat,
	287	const char *prop, u32 val, int create)
	288	{
	289	val = cpu_to_fdt32(val);
	290	do_fixup_by_compat(fdt, compat, prop, &val, 4, create);
	291	}
	292
3c927281 KG	293	int fdt_fixup_memory(void *blob, u64 start, u64 size)
	294	{
	295	int err, nodeoffset, len = 0;
	296	u8 tmp[16];
	297	const u32 addrcell, sizecell;
	298
	299	err = fdt_check_header(blob);
	300	if (err < 0) {
	301	printf("%s: %s\n", __FUNCTION__, fdt_strerror(err));
	302	return err;
	303	}
	304
	305	/* update, or add and update /memory node */
	306	nodeoffset = fdt_path_offset(blob, "/memory");
	307	if (nodeoffset < 0) {
	308	nodeoffset = fdt_add_subnode(blob, 0, "memory");
	309	if (nodeoffset < 0)
	310	printf("WARNING: could not create /memory: %s.\n",
	311	fdt_strerror(nodeoffset));
	312	return nodeoffset;
	313	}
	314	err = fdt_setprop(blob, nodeoffset, "device_type", "memory",
	315	sizeof("memory"));
	316	if (err < 0) {
	317	printf("WARNING: could not set %s %s.\n", "device_type",
	318	fdt_strerror(err));
	319	return err;
	320	}
	321
	322	addrcell = fdt_getprop(blob, 0, "#address-cells", NULL);
	323	/* use shifts and mask to ensure endianness */
	324	if ((addrcell) && (*addrcell == 2)) {
	325	tmp[0] = (start >> 56) & 0xff;
	326	tmp[1] = (start >> 48) & 0xff;
	327	tmp[2] = (start >> 40) & 0xff;
	328	tmp[3] = (start >> 32) & 0xff;
	329	tmp[4] = (start >> 24) & 0xff;
	330	tmp[5] = (start >> 16) & 0xff;
	331	tmp[6] = (start >> 8) & 0xff;
	332	tmp[7] = (start ) & 0xff;
	333	len = 8;
	334	} else {
	335	tmp[0] = (start >> 24) & 0xff;
	336	tmp[1] = (start >> 16) & 0xff;
	337	tmp[2] = (start >> 8) & 0xff;
	338	tmp[3] = (start ) & 0xff;
	339	len = 4;
	340	}
	341
	342	sizecell = fdt_getprop(blob, 0, "#size-cells", NULL);
	343	/* use shifts and mask to ensure endianness */
	344	if ((sizecell) && (*sizecell == 2)) {
	345	tmp[0+len] = (size >> 56) & 0xff;
	346	tmp[1+len] = (size >> 48) & 0xff;
	347	tmp[2+len] = (size >> 40) & 0xff;
	348	tmp[3+len] = (size >> 32) & 0xff;
	349	tmp[4+len] = (size >> 24) & 0xff;
	350	tmp[5+len] = (size >> 16) & 0xff;
	351	tmp[6+len] = (size >> 8) & 0xff;
	352	tmp[7+len] = (size ) & 0xff;
	353	len += 8;
	354	} else {
	355	tmp[0+len] = (size >> 24) & 0xff;
	356	tmp[1+len] = (size >> 16) & 0xff;
357	tmp[2+len] = (size >> 8) & 0xff;
358	tmp[3+len] = (size ) & 0xff;
359	len += 4;
360	}
361
362	err = fdt_setprop(blob, nodeoffset, "reg", tmp, len);
363	if (err < 0) {
364	printf("WARNING: could not set %s %s.\n",
365	"reg", fdt_strerror(err));
366	return err;
367	}
368	return 0;
369	}
370
c01b17dd GVB	371	#if defined(CONFIG_HAS_ETH0) \|\| defined(CONFIG_HAS_ETH1) \|\|\
	372	defined(CONFIG_HAS_ETH2) \|\| defined(CONFIG_HAS_ETH3)
	373
ab544633 KG	374	void fdt_fixup_ethernet(void fdt, bd_t bd)
	375	{
	376	int node;
	377	const char *path;
	378
	379	node = fdt_path_offset(fdt, "/aliases");
	380	if (node >= 0) {
	381	#if defined(CONFIG_HAS_ETH0)
	382	path = fdt_getprop(fdt, node, "ethernet0", NULL);
	383	if (path) {
	384	do_fixup_by_path(fdt, path, "mac-address",
	385	bd->bi_enetaddr, 6, 0);
	386	do_fixup_by_path(fdt, path, "local-mac-address",
	387	bd->bi_enetaddr, 6, 1);
	388	}
	389	#endif
	390	#if defined(CONFIG_HAS_ETH1)
	391	path = fdt_getprop(fdt, node, "ethernet1", NULL);
	392	if (path) {
	393	do_fixup_by_path(fdt, path, "mac-address",
	394	bd->bi_enet1addr, 6, 0);
	395	do_fixup_by_path(fdt, path, "local-mac-address",
	396	bd->bi_enet1addr, 6, 1);
	397	}
	398	#endif
	399	#if defined(CONFIG_HAS_ETH2)
	400	path = fdt_getprop(fdt, node, "ethernet2", NULL);
	401	if (path) {
	402	do_fixup_by_path(fdt, path, "mac-address",
	403	bd->bi_enet2addr, 6, 0);
	404	do_fixup_by_path(fdt, path, "local-mac-address",
	405	bd->bi_enet2addr, 6, 1);
	406	}
	407	#endif
	408	#if defined(CONFIG_HAS_ETH3)
	409	path = fdt_getprop(fdt, node, "ethernet3", NULL);
	410	if (path) {
	411	do_fixup_by_path(fdt, path, "mac-address",
	412	bd->bi_enet3addr, 6, 0);
	413	do_fixup_by_path(fdt, path, "local-mac-address",
	414	bd->bi_enet3addr, 6, 1);
	415	}
	416	#endif
	417	}
	418	}
c01b17dd	419	#endif
18e69a35 AV	420
	421	#ifdef CONFIG_HAS_FSL_DR_USB
	422	void fdt_fixup_dr_usb(void blob, bd_t bd)
	423	{
	424	char *mode;
	425	const char *compat = "fsl-usb2-dr";
	426	const char *prop = "dr_mode";
	427	int node_offset;
	428	int err;
	429
	430	mode = getenv("usb_dr_mode");
	431	if (!mode)
	432	return;
	433
	434	node_offset = fdt_node_offset_by_compatible(blob, 0, compat);
	435	if (node_offset < 0)
	436	printf("WARNING: could not find compatible node %s: %s.\n",
	437	compat, fdt_strerror(node_offset));
	438
	439	err = fdt_setprop(blob, node_offset, prop, mode, strlen(mode) + 1);
	440	if (err < 0)
	441	printf("WARNING: could not set %s for %s: %s.\n",
	442	prop, compat, fdt_strerror(err));
	443	}
	444	#endif /* CONFIG_HAS_FSL_DR_USB */