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

/*
 * OF flat tree builder
 * Written by: Pantelis Antoniou <pantelis.antoniou@gmail.com>
 * Updated by: Matthew McClintock <msm@freescale.com>
 *
 * 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 <malloc.h>
#include <environment.h>

#ifdef CONFIG_OF_FLAT_TREE

#include <asm/errno.h>
#include <stddef.h>

#include <ft_build.h>
#include <linux/ctype.h>

#undef DEBUG

/* align addr on a size boundary - adjust address up if needed -- Cort */
#define _ALIGN(addr,size)       (((addr)+(size)-1)&(~((size)-1)))
#ifndef CONFIG_OF_BOOT_CPU
#define CONFIG_OF_BOOT_CPU 0
#endif
#define SIZE_OF_RSVMAP_ENTRY (2*sizeof(u64))

static void ft_put_word(struct ft_cxt *cxt, u32 v)
{
	memmove(cxt->p + sizeof(u32), cxt->p, cxt->p_end - cxt->p);

	*(u32 *) cxt->p = cpu_to_be32(v);
	cxt->p += sizeof(u32);
	cxt->p_end += sizeof(u32);
}

static inline void ft_put_bin(struct ft_cxt *cxt, const void *data, int sz)
{
	int aligned_size = ((u8 *)_ALIGN((unsigned long)cxt->p + sz,
					sizeof(u32))) - cxt->p;

	memmove(cxt->p + aligned_size, cxt->p, cxt->p_end - cxt->p);

	/* make sure the last bytes are zeroed */
	memset(cxt->p + aligned_size - (aligned_size % sizeof(u32)), 0,
			(aligned_size % sizeof(u32)));

	memcpy(cxt->p, data, sz);

	cxt->p += aligned_size;
	cxt->p_end += aligned_size;
}

void ft_begin_node(struct ft_cxt *cxt, const char *name)
{
	ft_put_word(cxt, OF_DT_BEGIN_NODE);
	ft_put_bin(cxt, name, strlen(name) + 1);
}

void ft_end_node(struct ft_cxt *cxt)
{
	ft_put_word(cxt, OF_DT_END_NODE);
}

void ft_nop(struct ft_cxt *cxt)
{
	ft_put_word(cxt, OF_DT_NOP);
}

static int lookup_string(struct ft_cxt *cxt, const char *name)
{
	u8 *p;

	p = cxt->p;
	while (p < cxt->p_end) {
		if (strcmp((char *)p, name) == 0)
			return p - cxt->p;
		p += strlen((char *)p) + 1;
	}

	return -1;
}

void ft_prop(struct ft_cxt *cxt, const char *name, const void *data, int sz)
{
	int off = 0;

	off = lookup_string(cxt, name);
	if (off == -1) {
		memcpy(cxt->p_end, name, strlen(name) + 1);
		off = cxt->p_end - cxt->p;
		cxt->p_end += strlen(name) + 1;
	}

	/* now put offset from beginning of *STRUCTURE* */
	/* will be fixed up at the end */
	ft_put_word(cxt, OF_DT_PROP);
	ft_put_word(cxt, sz);
	ft_put_word(cxt, off);
	ft_put_bin(cxt, data, sz);
}

void ft_prop_str(struct ft_cxt *cxt, const char *name, const char *str)
{
	ft_prop(cxt, name, str, strlen(str) + 1);
}

void ft_prop_int(struct ft_cxt *cxt, const char *name, int val)
{
	u32 v = cpu_to_be32((u32) val);

	ft_prop(cxt, name, &v, sizeof(u32));
}

/* pick up and start working on a tree in place */
void ft_init_cxt(struct ft_cxt *cxt, void *blob)
{
	struct boot_param_header *bph = blob;

	memset(cxt, 0, sizeof(*cxt));

	cxt->bph = bph;
	bph->boot_cpuid_phys = CONFIG_OF_BOOT_CPU;

	/* find beginning and end of reserve map table (zeros in last entry) */
	cxt->p_rsvmap = (u8 *)bph + bph->off_mem_rsvmap;
	while ( ((uint64_t *)cxt->p_rsvmap)[0] != 0 &&
		     ((uint64_t *)cxt->p_rsvmap)[1] != 0 ) {
	cxt->p_rsvmap += SIZE_OF_RSVMAP_ENTRY;
	}

	cxt->p_start = (u8 *)bph + bph->off_dt_struct;
	cxt->p_end = (u8 *)bph + bph->totalsize;
	cxt->p = (u8 *)bph + bph->off_dt_strings;
}

/* add a reserver physical area to the rsvmap */
void ft_add_rsvmap(struct ft_cxt *cxt, u64 physstart, u64 physend)
{
	memmove(cxt->p_rsvmap + SIZE_OF_RSVMAP_ENTRY, cxt->p_rsvmap,
				 cxt->p_end - cxt->p_rsvmap);

	((u64 *)cxt->p_rsvmap)[0] = cpu_to_be64(physstart);
	((u64 *)cxt->p_rsvmap)[1] = cpu_to_be64(physend);
	((u64 *)cxt->p_rsvmap)[2] = 0;
	((u64 *)cxt->p_rsvmap)[3] = 0;

	cxt->p_rsvmap += SIZE_OF_RSVMAP_ENTRY;
	cxt->p_start += SIZE_OF_RSVMAP_ENTRY;
	cxt->p += SIZE_OF_RSVMAP_ENTRY;
	cxt->p_end += SIZE_OF_RSVMAP_ENTRY;
}

void ft_end_tree(struct ft_cxt *cxt)
{
	ft_put_word(cxt, OF_DT_END);
}

/* update the boot param header with correct values */
void ft_finalize_tree(struct ft_cxt *cxt) {
	struct boot_param_header *bph = cxt->bph;

	bph->totalsize = cxt->p_end - (u8 *)bph;
	bph->off_dt_struct = cxt->p_start - (u8 *)bph;
	bph->off_dt_strings = cxt->p - (u8 *)bph;
	bph->dt_strings_size = cxt->p_end - cxt->p;
}

static int is_printable_string(const void *data, int len)
{
	const char *s = data;
	const char *ss;

	/* zero length is not */
	if (len == 0)
		return 0;

	/* must terminate with zero */
	if (s[len - 1] != '\0')
		return 0;

	ss = s;
	while (*s && isprint(*s))
		s++;

	/* not zero, or not done yet */
	if (*s != '\0' || (s + 1 - ss) < len)
		return 0;

	return 1;
}

static void print_data(const void *data, int len)
{
	int i;
	const u8 *s;

	/* no data, don't print */
	if (len == 0)
		return;

	if (is_printable_string(data, len)) {
		puts(" = \"");
		puts(data);
		puts("\"");
		return;
	}

	switch (len) {
	case 1:		/* byte */
		printf(" = <%02x>", (*(u8 *) data) & 0xff);
		break;
	case 2:		/* half-word */
		printf(" = <%04x>", be16_to_cpu(*(u16 *) data) & 0xffff);
		break;
	case 4:		/* word */
		printf(" = <%x>", be32_to_cpu(*(u32 *) data) & 0xffffffffU);
		break;
	case 8:		/* double-word */
		printf(" = <%qx>", be64_to_cpu(*(uint64_t *) data));
		break;
	default:		/* anything else... hexdump */
		printf(" = [");
		for (i = 0, s = data; i < len; i++)
			printf("%02x%s", s[i], i < len - 1 ? " " : "");
		printf("]");

		break;
	}
}

void ft_dump_blob(const void *bphp)
{
	const struct boot_param_header *bph = bphp;
	const uint64_t *p_rsvmap = (const uint64_t *)
		((const char *)bph + be32_to_cpu(bph->off_mem_rsvmap));
	const u32 *p_struct = (const u32 *)
		((const char *)bph + be32_to_cpu(bph->off_dt_struct));
	const u32 *p_strings = (const u32 *)
		((const char *)bph + be32_to_cpu(bph->off_dt_strings));
	u32 tag;
	const u32 *p;
	const char *s, *t;
	int depth, sz, shift;
	int i;
	uint64_t addr, size;

	if (be32_to_cpu(bph->magic) != OF_DT_HEADER) {
		/* not valid tree */
		return;
	}

	depth = 0;
	shift = 4;

	for (i = 0;; i++) {
		addr = be64_to_cpu(p_rsvmap[i * 2]);
		size = be64_to_cpu(p_rsvmap[i * 2 + 1]);
		if (addr == 0 && size == 0)
			break;

		printf("/memreserve/ %qx %qx;\n", addr, size);
	}

	p = p_struct;
	while ((tag = be32_to_cpu(*p++)) != OF_DT_END) {

		/* printf("tag: 0x%08x (%d)\n", tag, p - p_struct); */

		if (tag == OF_DT_BEGIN_NODE) {
			s = (const char *)p;
			p = (u32 *) _ALIGN((unsigned long)p + strlen(s) + 1, 4);

			printf("%*s%s {\n", depth * shift, "", s);

			depth++;
			continue;
		}

		if (tag == OF_DT_END_NODE) {
			depth--;

			printf("%*s};\n", depth * shift, "");
			continue;
		}

		if (tag == OF_DT_NOP) {
			printf("%*s[NOP]\n", depth * shift, "");
			continue;
		}

		if (tag != OF_DT_PROP) {
			fprintf(stderr, "%*s ** Unknown tag 0x%08x at 0x%x\n",
				depth * shift, "", tag, --p);
			break;
		}
		sz = be32_to_cpu(*p++);
		s = (const char *)p_strings + be32_to_cpu(*p++);
		t = (const char *)p;
		p = (const u32 *)_ALIGN((unsigned long)p + sz, 4);
		printf("%*s%s", depth * shift, "", s);
		print_data(t, sz);
		printf(";\n");
	}
}

void ft_backtrack_node(struct ft_cxt *cxt)
{
	int i = 4;

	while (be32_to_cpu(*(u32 *) (cxt->p - i)) != OF_DT_END_NODE)
		i += 4;

	memmove (cxt->p - i, cxt->p, cxt->p_end - cxt->p);

	cxt->p_end -= i;
	cxt->p -= i;
}

void *ft_get_prop(void *bphp, const char *propname, int *szp)
{
	struct boot_param_header *bph = bphp;
	uint32_t *p_struct =
	    (uint32_t *) ((char *)bph + be32_to_cpu(bph->off_dt_struct));
	uint32_t *p_strings =
	    (uint32_t *) ((char *)bph + be32_to_cpu(bph->off_dt_strings));
	uint32_t version = be32_to_cpu(bph->version);
	uint32_t tag;
	uint32_t *p;
	char *s, *t;
	char *ss;
	int sz;
	static char path[256], prop[256];

	path[0] = '\0';

	p = p_struct;
	while ((tag = be32_to_cpu(*p++)) != OF_DT_END) {

		if (tag == OF_DT_BEGIN_NODE) {
			s = (char *)p;
			p = (uint32_t *) _ALIGN((unsigned long)p + strlen(s) +
						1, 4);
			strcat(path, s);
			strcat(path, "/");
			continue;
		}

		if (tag == OF_DT_END_NODE) {
			path[strlen(path) - 1] = '\0';
			ss = strrchr(path, '/');
			if (ss != NULL)
				ss[1] = '\0';
			continue;
		}

		if (tag == OF_DT_NOP)
			continue;

		if (tag != OF_DT_PROP)
			break;

		sz = be32_to_cpu(*p++);
		s = (char *)p_strings + be32_to_cpu(*p++);
		if (version < 0x10 && sz >= 8)
			p = (uint32_t *) _ALIGN((unsigned long)p, 8);
		t = (char *)p;
		p = (uint32_t *) _ALIGN((unsigned long)p + sz, 4);

		strcpy(prop, path);
		strcat(prop, s);

		if (strcmp(prop, propname) == 0) {
			*szp = sz;
			return t;
		}
	}

	return NULL;
}

/********************************************************************/

/* Function that returns a character from the environment */
extern uchar(*env_get_char) (int);

#define BDM(x)	{	.name = #x, .offset = offsetof(bd_t, bi_ ##x ) }

#ifdef CONFIG_OF_HAS_BD_T
static const struct {
	const char *name;
	int offset;
} bd_map[] = {
	BDM(memstart),
	BDM(memsize),
	BDM(flashstart),
	BDM(flashsize),
	BDM(flashoffset),
	BDM(sramstart),
	BDM(sramsize),
#if defined(CONFIG_5xx) || defined(CONFIG_8xx) || defined(CONFIG_8260) \
	|| defined(CONFIG_E500)
	BDM(immr_base),
#endif
#if defined(CONFIG_MPC5xxx)
	BDM(mbar_base),
#endif
#if defined(CONFIG_MPC83XX)
	BDM(immrbar),
#endif
#if defined(CONFIG_MPC8220)
	BDM(mbar_base),
	BDM(inpfreq),
	BDM(pcifreq),
	BDM(pevfreq),
	BDM(flbfreq),
	BDM(vcofreq),
#endif
	BDM(bootflags),
	BDM(ip_addr),
	BDM(intfreq),
	BDM(busfreq),
#ifdef CONFIG_CPM2
	BDM(cpmfreq),
	BDM(brgfreq),
	BDM(sccfreq),
	BDM(vco),
#endif
#if defined(CONFIG_MPC5xxx)
	BDM(ipbfreq),
	BDM(pcifreq),
#endif
	BDM(baudrate),
};
#endif

void ft_setup(void *blob, bd_t * bd, ulong initrd_start, ulong initrd_end)
{
	u32 *p;
	int len;
	struct ft_cxt cxt;
	ulong clock;
#if defined(CONFIG_OF_HAS_UBOOT_ENV)
	int k, nxt;
#endif
#if defined(CONFIG_OF_HAS_BD_T)
	u8 *end;
#endif
#if defined(CONFIG_OF_HAS_UBOOT_ENV) || defined(CONFIG_OF_HAS_BD_T)
	int i;
	static char tmpenv[256];
#endif

	/* disable OF tree; booting old kernel */
	if (getenv("disable_of") != NULL) {
		memcpy(blob, bd, sizeof(*bd));
		return;
	}

#ifdef DEBUG
	printf ("recieved oftree\n");
	ft_dump_blob(blob);
#endif

	ft_init_cxt(&cxt, blob);

	if (initrd_start && initrd_end)
		ft_add_rsvmap(&cxt, initrd_start, initrd_end - initrd_start + 1);

	/* back into root */
	ft_backtrack_node(&cxt);

#ifdef CONFIG_OF_HAS_UBOOT_ENV
	ft_begin_node(&cxt, "u-boot-env");

	for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) {
		char *s, *lval, *rval;

		for (nxt = i; env_get_char(nxt) != '\0'; ++nxt) ;
		s = tmpenv;
		for (k = i; k < nxt && s < &tmpenv[sizeof(tmpenv) - 1]; ++k)
			*s++ = env_get_char(k);
		*s++ = '\0';
		lval = tmpenv;
		s = strchr(tmpenv, '=');
		if (s != NULL) {
			*s++ = '\0';
			rval = s;
		} else
			continue;
		ft_prop_str(&cxt, lval, rval);
	}

	ft_end_node(&cxt);
#endif

	ft_begin_node(&cxt, "chosen");
	ft_prop_str(&cxt, "name", "chosen");

	ft_prop_str(&cxt, "bootargs", getenv("bootargs"));
	ft_prop_int(&cxt, "linux,platform", 0x600);	/* what is this? */
	if (initrd_start && initrd_end) {
		ft_prop_int(&cxt, "linux,initrd-start", initrd_start);
		ft_prop_int(&cxt, "linux,initrd-end", initrd_end);
	}
#ifdef OF_STDOUT_PATH
	ft_prop_str(&cxt, "linux,stdout-path", OF_STDOUT_PATH);
#endif

	ft_end_node(&cxt);

	ft_end_node(&cxt);	/* end root */

	ft_end_tree(&cxt);
	ft_finalize_tree(&cxt);

#ifdef CONFIG_OF_HAS_BD_T
	/* paste the bd_t at the end of the flat tree */
	end = (char *)blob +
	    be32_to_cpu(((struct boot_param_header *)blob)->totalsize);
	memcpy(end, bd, sizeof(*bd));
#endif

#ifdef CONFIG_PPC

#ifdef CONFIG_OF_HAS_BD_T
	for (i = 0; i < sizeof(bd_map)/sizeof(bd_map[0]); i++) {
		uint32_t v;

		sprintf(tmpenv, "/bd_t/%s", bd_map[i].name);
		v = *(uint32_t *)((char *)bd + bd_map[i].offset);

		p = ft_get_prop(blob, tmpenv, &len);
		if (p != NULL)
			*p = cpu_to_be32(v);
	}

	p = ft_get_prop(blob, "/bd_t/enetaddr", &len);
	if (p != NULL)
		memcpy(p, bd->bi_enetaddr, 6);

	p = ft_get_prop(blob, "/bd_t/ethspeed", &len);
	if (p != NULL)
		*p = cpu_to_be32((uint32_t) bd->bi_ethspeed);
#endif

	clock = bd->bi_intfreq;
	p = ft_get_prop(blob, "/cpus/" OF_CPU "/clock-frequency", &len);
	if (p != NULL)
		*p = cpu_to_be32(clock);

#ifdef OF_TBCLK
	clock = OF_TBCLK;
	p = ft_get_prop(blob, "/cpus/" OF_CPU "/timebase-frequency", &len);
	if (p != NULL)
		*p = cpu_to_be32(clock);
#endif
#endif				/* __powerpc__ */

#ifdef CONFIG_OF_BOARD_SETUP
	ft_board_setup(blob, bd);
#endif

	/* in case the size changed in the platform code */
	ft_finalize_tree(&cxt);

#ifdef DEBUG
	printf("final OF-tree\n");
	ft_dump_blob(blob);
#endif
}
#endif
Commit	Line	Data
814d98f2 WD	1	/*
814d98f2 WD	2	* OF flat tree builder
1b380ec2 MM	3	* Written by: Pantelis Antoniou <pantelis.antoniou@gmail.com>
	4	* Updated by: Matthew McClintock <msm@freescale.com>
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation; either version 2 of
	9	* the License, or (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	19	* MA 02111-1307 USA
814d98f2 WD	20	*/
	21
	22	#include <common.h>
	23	#include <malloc.h>
	24	#include <environment.h>
	25
fe93483a MB	26	#ifdef CONFIG_OF_FLAT_TREE
fe93483a MB	27
814d98f2 WD	28	#include <asm/errno.h>
	29	#include <stddef.h>
	30
	31	#include <ft_build.h>
80ba981d	32	#include <linux/ctype.h>
814d98f2	33
1b380ec2 MM	34	#undef DEBUG
1b380ec2 MM	35
814d98f2 WD	36	/* align addr on a size boundary - adjust address up if needed -- Cort */
814d98f2 WD	37	#define _ALIGN(addr,size) (((addr)+(size)-1)&(~((size)-1)))
1b380ec2 MM	38	#ifndef CONFIG_OF_BOOT_CPU
	39	#define CONFIG_OF_BOOT_CPU 0
	40	#endif
	41	#define SIZE_OF_RSVMAP_ENTRY (2*sizeof(u64))
814d98f2 WD	42
	43	static void ft_put_word(struct ft_cxt *cxt, u32 v)
	44	{
1b380ec2	45	memmove(cxt->p + sizeof(u32), cxt->p, cxt->p_end - cxt->p);
814d98f2 WD	46
814d98f2 WD	47	(u32 ) cxt->p = cpu_to_be32(v);
1b380ec2 MM	48	cxt->p += sizeof(u32);
1b380ec2 MM	49	cxt->p_end += sizeof(u32);
814d98f2 WD	50	}
	51
	52	static inline void ft_put_bin(struct ft_cxt cxt, const void data, int sz)
	53	{
1b380ec2 MM	54	int aligned_size = ((u8 *)_ALIGN((unsigned long)cxt->p + sz,
1b380ec2 MM	55	sizeof(u32))) - cxt->p;
814d98f2	56
1b380ec2	57	memmove(cxt->p + aligned_size, cxt->p, cxt->p_end - cxt->p);
814d98f2	58
1b380ec2 MM	59	/* make sure the last bytes are zeroed */
	60	memset(cxt->p + aligned_size - (aligned_size % sizeof(u32)), 0,
	61	(aligned_size % sizeof(u32)));
814d98f2 WD	62
814d98f2 WD	63	memcpy(cxt->p, data, sz);
1b380ec2 MM	64
	65	cxt->p += aligned_size;
	66	cxt->p_end += aligned_size;
814d98f2 WD	67	}
	68
	69	void ft_begin_node(struct ft_cxt cxt, const char name)
	70	{
	71	ft_put_word(cxt, OF_DT_BEGIN_NODE);
	72	ft_put_bin(cxt, name, strlen(name) + 1);
	73	}
	74
	75	void ft_end_node(struct ft_cxt *cxt)
	76	{
	77	ft_put_word(cxt, OF_DT_END_NODE);
	78	}
	79
	80	void ft_nop(struct ft_cxt *cxt)
	81	{
	82	ft_put_word(cxt, OF_DT_NOP);
	83	}
	84
	85	static int lookup_string(struct ft_cxt cxt, const char name)
	86	{
	87	u8 *p;
	88
1b380ec2 MM	89	p = cxt->p;
1b380ec2 MM	90	while (p < cxt->p_end) {
7376eb87	91	if (strcmp((char *)p, name) == 0)
1b380ec2	92	return p - cxt->p;
7376eb87	93	p += strlen((char *)p) + 1;
814d98f2 WD	94	}
	95
	96	return -1;
	97	}
	98
	99	void ft_prop(struct ft_cxt cxt, const char name, const void *data, int sz)
	100	{
1b380ec2	101	int off = 0;
814d98f2 WD	102
	103	off = lookup_string(cxt, name);
	104	if (off == -1) {
1b380ec2 MM	105	memcpy(cxt->p_end, name, strlen(name) + 1);
1b380ec2 MM	106	off = cxt->p_end - cxt->p;
88c8f492	107	cxt->p_end += strlen(name) + 1;
814d98f2 WD	108	}
	109
	110	/* now put offset from beginning of STRUCTURE */
	111	/* will be fixed up at the end */
	112	ft_put_word(cxt, OF_DT_PROP);
	113	ft_put_word(cxt, sz);
	114	ft_put_word(cxt, off);
	115	ft_put_bin(cxt, data, sz);
	116	}
	117
	118	void ft_prop_str(struct ft_cxt cxt, const char name, const char *str)
	119	{
	120	ft_prop(cxt, name, str, strlen(str) + 1);
	121	}
	122
	123	void ft_prop_int(struct ft_cxt cxt, const char name, int val)
	124	{
	125	u32 v = cpu_to_be32((u32) val);
	126
1b380ec2	127	ft_prop(cxt, name, &v, sizeof(u32));
814d98f2 WD	128	}
814d98f2 WD	129
1b380ec2 MM	130	/* pick up and start working on a tree in place */
1b380ec2 MM	131	void ft_init_cxt(struct ft_cxt cxt, void blob)
814d98f2 WD	132	{
814d98f2 WD	133	struct boot_param_header *bph = blob;
814d98f2	134
814d98f2 WD	135	memset(cxt, 0, sizeof(*cxt));
	136
	137	cxt->bph = bph;
1b380ec2	138	bph->boot_cpuid_phys = CONFIG_OF_BOOT_CPU;
814d98f2	139
1b380ec2 MM	140	/* find beginning and end of reserve map table (zeros in last entry) */
	141	cxt->p_rsvmap = (u8 *)bph + bph->off_mem_rsvmap;
	142	while ( ((uint64_t *)cxt->p_rsvmap)[0] != 0 &&
	143	((uint64_t *)cxt->p_rsvmap)[1] != 0 ) {
	144	cxt->p_rsvmap += SIZE_OF_RSVMAP_ENTRY;
	145	}
814d98f2	146
7376eb87 MM	147	cxt->p_start = (u8 *)bph + bph->off_dt_struct;
	148	cxt->p_end = (u8 *)bph + bph->totalsize;
	149	cxt->p = (u8 *)bph + bph->off_dt_strings;
814d98f2 WD	150	}
	151
	152	/* add a reserver physical area to the rsvmap */
1b380ec2	153	void ft_add_rsvmap(struct ft_cxt *cxt, u64 physstart, u64 physend)
814d98f2	154	{
1b380ec2 MM	155	memmove(cxt->p_rsvmap + SIZE_OF_RSVMAP_ENTRY, cxt->p_rsvmap,
	156	cxt->p_end - cxt->p_rsvmap);
	157
	158	((u64 *)cxt->p_rsvmap)[0] = cpu_to_be64(physstart);
	159	((u64 *)cxt->p_rsvmap)[1] = cpu_to_be64(physend);
	160	((u64 *)cxt->p_rsvmap)[2] = 0;
	161	((u64 *)cxt->p_rsvmap)[3] = 0;
	162
	163	cxt->p_rsvmap += SIZE_OF_RSVMAP_ENTRY;
	164	cxt->p_start += SIZE_OF_RSVMAP_ENTRY;
	165	cxt->p += SIZE_OF_RSVMAP_ENTRY;
	166	cxt->p_end += SIZE_OF_RSVMAP_ENTRY;
814d98f2 WD	167	}
814d98f2 WD	168
1b380ec2	169	void ft_end_tree(struct ft_cxt *cxt)
814d98f2	170	{
1b380ec2	171	ft_put_word(cxt, OF_DT_END);
814d98f2 WD	172	}
814d98f2 WD	173
1b380ec2 MM	174	/* update the boot param header with correct values */
1b380ec2 MM	175	void ft_finalize_tree(struct ft_cxt *cxt) {
814d98f2	176	struct boot_param_header *bph = cxt->bph;
814d98f2	177
1b380ec2 MM	178	bph->totalsize = cxt->p_end - (u8 *)bph;
	179	bph->off_dt_struct = cxt->p_start - (u8 *)bph;
	180	bph->off_dt_strings = cxt->p - (u8 *)bph;
	181	bph->dt_strings_size = cxt->p_end - cxt->p;
814d98f2 WD	182	}
814d98f2 WD	183
814d98f2 WD	184	static int is_printable_string(const void *data, int len)
	185	{
	186	const char *s = data;
	187	const char *ss;
	188
	189	/* zero length is not */
	190	if (len == 0)
	191	return 0;
	192
	193	/* must terminate with zero */
	194	if (s[len - 1] != '\0')
	195	return 0;
	196
	197	ss = s;
	198	while (s && isprint(s))
	199	s++;
	200
	201	/* not zero, or not done yet */
	202	if (*s != '\0' \|\| (s + 1 - ss) < len)
	203	return 0;
	204
	205	return 1;
	206	}
	207
	208	static void print_data(const void *data, int len)
	209	{
	210	int i;
	211	const u8 *s;
	212
	213	/* no data, don't print */
	214	if (len == 0)
	215	return;
	216
	217	if (is_printable_string(data, len)) {
d262a92f WD	218	puts(" = \"");
	219	puts(data);
	220	puts("\"");
814d98f2 WD	221	return;
	222	}
	223
	224	switch (len) {
	225	case 1: /* byte */
1b380ec2	226	printf(" = <%02x>", ((u8 ) data) & 0xff);
814d98f2 WD	227	break;
814d98f2 WD	228	case 2: /* half-word */
1b380ec2	229	printf(" = <%04x>", be16_to_cpu((u16 ) data) & 0xffff);
814d98f2 WD	230	break;
814d98f2 WD	231	case 4: /* word */
1b380ec2	232	printf(" = <%x>", be32_to_cpu((u32 ) data) & 0xffffffffU);
814d98f2 WD	233	break;
814d98f2 WD	234	case 8: /* double-word */
1b380ec2	235	printf(" = <%qx>", be64_to_cpu((uint64_t ) data));
814d98f2 WD	236	break;
	237	default: /* anything else... hexdump */
	238	printf(" = [");
	239	for (i = 0, s = data; i < len; i++)
	240	printf("%02x%s", s[i], i < len - 1 ? " " : "");
	241	printf("]");
	242
	243	break;
	244	}
	245	}
	246
	247	void ft_dump_blob(const void *bphp)
	248	{
	249	const struct boot_param_header *bph = bphp;
	250	const uint64_t p_rsvmap = (const uint64_t )
	251	((const char *)bph + be32_to_cpu(bph->off_mem_rsvmap));
	252	const u32 p_struct = (const u32 )
	253	((const char *)bph + be32_to_cpu(bph->off_dt_struct));
	254	const u32 p_strings = (const u32 )
	255	((const char *)bph + be32_to_cpu(bph->off_dt_strings));
	256	u32 tag;
	257	const u32 *p;
	258	const char s, t;
	259	int depth, sz, shift;
	260	int i;
	261	uint64_t addr, size;
	262
	263	if (be32_to_cpu(bph->magic) != OF_DT_HEADER) {
	264	/* not valid tree */
	265	return;
	266	}
	267
	268	depth = 0;
	269	shift = 4;
	270
	271	for (i = 0;; i++) {
	272	addr = be64_to_cpu(p_rsvmap[i * 2]);
	273	size = be64_to_cpu(p_rsvmap[i * 2 + 1]);
	274	if (addr == 0 && size == 0)
	275	break;
	276
1b380ec2	277	printf("/memreserve/ %qx %qx;\n", addr, size);
814d98f2 WD	278	}
	279
	280	p = p_struct;
	281	while ((tag = be32_to_cpu(*p++)) != OF_DT_END) {
	282
	283	/* printf("tag: 0x%08x (%d)\n", tag, p - p_struct); */
	284
	285	if (tag == OF_DT_BEGIN_NODE) {
	286	s = (const char *)p;
	287	p = (u32 *) _ALIGN((unsigned long)p + strlen(s) + 1, 4);
	288
	289	printf("%s%s {\n", depth shift, "", s);
	290
	291	depth++;
	292	continue;
	293	}
	294
	295	if (tag == OF_DT_END_NODE) {
	296	depth--;
	297
	298	printf("%s};\n", depth shift, "");
	299	continue;
	300	}
	301
	302	if (tag == OF_DT_NOP) {
	303	printf("%s[NOP]\n", depth shift, "");
	304	continue;
	305	}
	306
	307	if (tag != OF_DT_PROP) {
1b380ec2 MM	308	fprintf(stderr, "%s * Unknown tag 0x%08x at 0x%x\n",
1b380ec2 MM	309	depth * shift, "", tag, --p);
814d98f2 WD	310	break;
	311	}
	312	sz = be32_to_cpu(*p++);
	313	s = (const char )p_strings + be32_to_cpu(p++);
	314	t = (const char *)p;
	315	p = (const u32 *)_ALIGN((unsigned long)p + sz, 4);
	316	printf("%s%s", depth shift, "", s);
	317	print_data(t, sz);
	318	printf(";\n");
	319	}
	320	}
	321
	322	void ft_backtrack_node(struct ft_cxt *cxt)
	323	{
1b380ec2	324	int i = 4;
814d98f2	325
1b380ec2 MM	326	while (be32_to_cpu((u32 ) (cxt->p - i)) != OF_DT_END_NODE)
1b380ec2 MM	327	i += 4;
814d98f2	328
1b380ec2	329	memmove (cxt->p - i, cxt->p, cxt->p_end - cxt->p);
814d98f2	330
1b380ec2 MM	331	cxt->p_end -= i;
1b380ec2 MM	332	cxt->p -= i;
814d98f2 WD	333	}
	334
	335	void ft_get_prop(void bphp, const char propname, int szp)
	336	{
	337	struct boot_param_header *bph = bphp;
	338	uint32_t *p_struct =
	339	(uint32_t ) ((char )bph + be32_to_cpu(bph->off_dt_struct));
	340	uint32_t *p_strings =
	341	(uint32_t ) ((char )bph + be32_to_cpu(bph->off_dt_strings));
	342	uint32_t version = be32_to_cpu(bph->version);
	343	uint32_t tag;
	344	uint32_t *p;
	345	char s, t;
	346	char *ss;
	347	int sz;
	348	static char path[256], prop[256];
	349
	350	path[0] = '\0';
	351
	352	p = p_struct;
	353	while ((tag = be32_to_cpu(*p++)) != OF_DT_END) {
	354
	355	if (tag == OF_DT_BEGIN_NODE) {
	356	s = (char *)p;
	357	p = (uint32_t *) _ALIGN((unsigned long)p + strlen(s) +
	358	1, 4);
	359	strcat(path, s);
	360	strcat(path, "/");
	361	continue;
	362	}
	363
	364	if (tag == OF_DT_END_NODE) {
	365	path[strlen(path) - 1] = '\0';
	366	ss = strrchr(path, '/');
	367	if (ss != NULL)
	368	ss[1] = '\0';
	369	continue;
	370	}
	371
	372	if (tag == OF_DT_NOP)
	373	continue;
	374
	375	if (tag != OF_DT_PROP)
	376	break;
	377
	378	sz = be32_to_cpu(*p++);
	379	s = (char )p_strings + be32_to_cpu(p++);
	380	if (version < 0x10 && sz >= 8)
	381	p = (uint32_t *) _ALIGN((unsigned long)p, 8);
	382	t = (char *)p;
	383	p = (uint32_t *) _ALIGN((unsigned long)p + sz, 4);
	384
	385	strcpy(prop, path);
	386	strcat(prop, s);
	387
	388	if (strcmp(prop, propname) == 0) {
	389	*szp = sz;
	390	return t;
	391	}
	392	}
	393
	394	return NULL;
	395	}
	396
397	/********************************************************************/
398
814d98f2 WD	399	/* Function that returns a character from the environment */
	400	extern uchar(*env_get_char) (int);
	401
	402	#define BDM(x) { .name = #x, .offset = offsetof(bd_t, bi_ ##x ) }
	403
e4f880ed	404	#ifdef CONFIG_OF_HAS_BD_T
814d98f2 WD	405	static const struct {
	406	const char *name;
	407	int offset;
	408	} bd_map[] = {
	409	BDM(memstart),
	410	BDM(memsize),
	411	BDM(flashstart),
	412	BDM(flashsize),
	413	BDM(flashoffset),
	414	BDM(sramstart),
	415	BDM(sramsize),
	416	#if defined(CONFIG_5xx) \|\| defined(CONFIG_8xx) \|\| defined(CONFIG_8260) \
	417	\|\| defined(CONFIG_E500)
	418	BDM(immr_base),
	419	#endif
	420	#if defined(CONFIG_MPC5xxx)
	421	BDM(mbar_base),
	422	#endif
	423	#if defined(CONFIG_MPC83XX)
	424	BDM(immrbar),
	425	#endif
	426	#if defined(CONFIG_MPC8220)
	427	BDM(mbar_base),
	428	BDM(inpfreq),
	429	BDM(pcifreq),
	430	BDM(pevfreq),
	431	BDM(flbfreq),
	432	BDM(vcofreq),
	433	#endif
	434	BDM(bootflags),
	435	BDM(ip_addr),
	436	BDM(intfreq),
	437	BDM(busfreq),
	438	#ifdef CONFIG_CPM2
	439	BDM(cpmfreq),
	440	BDM(brgfreq),
	441	BDM(sccfreq),
	442	BDM(vco),
	443	#endif
	444	#if defined(CONFIG_MPC5xxx)
	445	BDM(ipbfreq),
	446	BDM(pcifreq),
	447	#endif
	448	BDM(baudrate),
	449	};
e4f880ed	450	#endif
814d98f2	451
1b380ec2	452	void ft_setup(void blob, bd_t bd, ulong initrd_start, ulong initrd_end)
814d98f2	453	{
814d98f2 WD	454	u32 *p;
	455	int len;
	456	struct ft_cxt cxt;
814d98f2	457	ulong clock;
e4f880ed KG	458	#if defined(CONFIG_OF_HAS_UBOOT_ENV)
	459	int k, nxt;
	460	#endif
	461	#if defined(CONFIG_OF_HAS_BD_T)
	462	u8 *end;
	463	#endif
	464	#if defined(CONFIG_OF_HAS_UBOOT_ENV) \|\| defined(CONFIG_OF_HAS_BD_T)
	465	int i;
	466	static char tmpenv[256];
	467	#endif
814d98f2 WD	468
	469	/* disable OF tree; booting old kernel */
	470	if (getenv("disable_of") != NULL) {
	471	memcpy(blob, bd, sizeof(*bd));
	472	return;
	473	}
	474
1b380ec2 MM	475	#ifdef DEBUG
	476	printf ("recieved oftree\n");
	477	ft_dump_blob(blob);
	478	#endif
	479
	480	ft_init_cxt(&cxt, blob);
814d98f2	481
e559a690 KG	482	if (initrd_start && initrd_end)
e559a690 KG	483	ft_add_rsvmap(&cxt, initrd_start, initrd_end - initrd_start + 1);
814d98f2	484
814d98f2 WD	485	/* back into root */
	486	ft_backtrack_node(&cxt);
	487
e4f880ed	488	#ifdef CONFIG_OF_HAS_UBOOT_ENV
814d98f2 WD	489	ft_begin_node(&cxt, "u-boot-env");
	490
	491	for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) {
e4f880ed KG	492	char s, lval, *rval;
e4f880ed KG	493
814d98f2 WD	494	for (nxt = i; env_get_char(nxt) != '\0'; ++nxt) ;
	495	s = tmpenv;
	496	for (k = i; k < nxt && s < &tmpenv[sizeof(tmpenv) - 1]; ++k)
	497	*s++ = env_get_char(k);
	498	*s++ = '\0';
	499	lval = tmpenv;
	500	s = strchr(tmpenv, '=');
	501	if (s != NULL) {
	502	*s++ = '\0';
	503	rval = s;
	504	} else
	505	continue;
	506	ft_prop_str(&cxt, lval, rval);
	507	}
	508
	509	ft_end_node(&cxt);
e4f880ed	510	#endif
814d98f2 WD	511
814d98f2 WD	512	ft_begin_node(&cxt, "chosen");
814d98f2	513	ft_prop_str(&cxt, "name", "chosen");
1b380ec2	514
814d98f2 WD	515	ft_prop_str(&cxt, "bootargs", getenv("bootargs"));
814d98f2 WD	516	ft_prop_int(&cxt, "linux,platform", 0x600); /* what is this? */
e559a690 KG	517	if (initrd_start && initrd_end) {
	518	ft_prop_int(&cxt, "linux,initrd-start", initrd_start);
	519	ft_prop_int(&cxt, "linux,initrd-end", initrd_end);
	520	}
c2871f03 KG	521	#ifdef OF_STDOUT_PATH
	522	ft_prop_str(&cxt, "linux,stdout-path", OF_STDOUT_PATH);
	523	#endif
814d98f2 WD	524
	525	ft_end_node(&cxt);
	526
	527	ft_end_node(&cxt); /* end root */
	528
	529	ft_end_tree(&cxt);
1b380ec2	530	ft_finalize_tree(&cxt);
814d98f2	531
e4f880ed	532	#ifdef CONFIG_OF_HAS_BD_T
814d98f2 WD	533	/* paste the bd_t at the end of the flat tree */
	534	end = (char *)blob +
	535	be32_to_cpu(((struct boot_param_header *)blob)->totalsize);
	536	memcpy(end, bd, sizeof(*bd));
e4f880ed	537	#endif
814d98f2 WD	538
	539	#ifdef CONFIG_PPC
	540
e4f880ed	541	#ifdef CONFIG_OF_HAS_BD_T
814d98f2	542	for (i = 0; i < sizeof(bd_map)/sizeof(bd_map[0]); i++) {
e4f880ed KG	543	uint32_t v;
e4f880ed KG	544
814d98f2 WD	545	sprintf(tmpenv, "/bd_t/%s", bd_map[i].name);
	546	v = (uint32_t )((char *)bd + bd_map[i].offset);
	547
	548	p = ft_get_prop(blob, tmpenv, &len);
	549	if (p != NULL)
	550	*p = cpu_to_be32(v);
	551	}
	552
	553	p = ft_get_prop(blob, "/bd_t/enetaddr", &len);
	554	if (p != NULL)
	555	memcpy(p, bd->bi_enetaddr, 6);
	556
	557	p = ft_get_prop(blob, "/bd_t/ethspeed", &len);
	558	if (p != NULL)
	559	*p = cpu_to_be32((uint32_t) bd->bi_ethspeed);
e4f880ed	560	#endif
814d98f2 WD	561
	562	clock = bd->bi_intfreq;
	563	p = ft_get_prop(blob, "/cpus/" OF_CPU "/clock-frequency", &len);
	564	if (p != NULL)
	565	*p = cpu_to_be32(clock);
	566
	567	#ifdef OF_TBCLK
	568	clock = OF_TBCLK;
	569	p = ft_get_prop(blob, "/cpus/" OF_CPU "/timebase-frequency", &len);
	570	if (p != NULL)
e4f880ed	571	*p = cpu_to_be32(clock);
814d98f2	572	#endif
814d98f2 WD	573	#endif /* __powerpc__ */
814d98f2 WD	574
4e253137 KG	575	#ifdef CONFIG_OF_BOARD_SETUP
	576	ft_board_setup(blob, bd);
	577	#endif
	578
1b380ec2 MM	579	/* in case the size changed in the platform code */
1b380ec2 MM	580	ft_finalize_tree(&cxt);
814d98f2	581
1b380ec2 MM	582	#ifdef DEBUG
	583	printf("final OF-tree\n");
	584	ft_dump_blob(blob);
	585	#endif
814d98f2	586	}
814d98f2	587	#endif