[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;
}

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

void ft_setup(void *blob, bd_t * bd, ulong initrd_start, ulong initrd_end)
{
	u32 *p;
	int len;
	struct ft_cxt cxt;
	ulong clock;

	/* 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);

	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_PPC
	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
1b380ec2	399	void ft_setup(void blob, bd_t bd, ulong initrd_start, ulong initrd_end)
814d98f2	400	{
814d98f2 WD	401	u32 *p;
	402	int len;
	403	struct ft_cxt cxt;
814d98f2	404	ulong clock;
814d98f2 WD	405
	406	/* disable OF tree; booting old kernel */
	407	if (getenv("disable_of") != NULL) {
	408	memcpy(blob, bd, sizeof(*bd));
	409	return;
	410	}
	411
1b380ec2 MM	412	#ifdef DEBUG
	413	printf ("recieved oftree\n");
	414	ft_dump_blob(blob);
	415	#endif
	416
	417	ft_init_cxt(&cxt, blob);
814d98f2	418
e559a690 KG	419	if (initrd_start && initrd_end)
e559a690 KG	420	ft_add_rsvmap(&cxt, initrd_start, initrd_end - initrd_start + 1);
814d98f2	421
814d98f2 WD	422	/* back into root */
	423	ft_backtrack_node(&cxt);
	424
814d98f2	425	ft_begin_node(&cxt, "chosen");
814d98f2	426	ft_prop_str(&cxt, "name", "chosen");
1b380ec2	427
814d98f2 WD	428	ft_prop_str(&cxt, "bootargs", getenv("bootargs"));
814d98f2 WD	429	ft_prop_int(&cxt, "linux,platform", 0x600); /* what is this? */
e559a690 KG	430	if (initrd_start && initrd_end) {
	431	ft_prop_int(&cxt, "linux,initrd-start", initrd_start);
	432	ft_prop_int(&cxt, "linux,initrd-end", initrd_end);
	433	}
c2871f03 KG	434	#ifdef OF_STDOUT_PATH
	435	ft_prop_str(&cxt, "linux,stdout-path", OF_STDOUT_PATH);
	436	#endif
814d98f2 WD	437
	438	ft_end_node(&cxt);
	439
	440	ft_end_node(&cxt); /* end root */
	441
	442	ft_end_tree(&cxt);
1b380ec2	443	ft_finalize_tree(&cxt);
814d98f2	444
814d98f2	445	#ifdef CONFIG_PPC
814d98f2 WD	446	clock = bd->bi_intfreq;
	447	p = ft_get_prop(blob, "/cpus/" OF_CPU "/clock-frequency", &len);
	448	if (p != NULL)
	449	*p = cpu_to_be32(clock);
	450
	451	#ifdef OF_TBCLK
	452	clock = OF_TBCLK;
	453	p = ft_get_prop(blob, "/cpus/" OF_CPU "/timebase-frequency", &len);
	454	if (p != NULL)
e4f880ed	455	*p = cpu_to_be32(clock);
814d98f2	456	#endif
814d98f2 WD	457	#endif /* __powerpc__ */
814d98f2 WD	458
4e253137 KG	459	#ifdef CONFIG_OF_BOARD_SETUP
	460	ft_board_setup(blob, bd);
	461	#endif
	462
1b380ec2 MM	463	/* in case the size changed in the platform code */
1b380ec2 MM	464	ft_finalize_tree(&cxt);
814d98f2	465
1b380ec2 MM	466	#ifdef DEBUG
	467	printf("final OF-tree\n");
	468	ft_dump_blob(blob);
	469	#endif
814d98f2	470	}
814d98f2	471	#endif