[deliverable/linux.git] / drivers / of / fdt.c

/*
 * Functions for working with the Flattened Device Tree data format
 *
 * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
 * benh@kernel.crashing.org
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/lmb.h>
#include <linux/of.h>
#include <linux/of_fdt.h>

struct boot_param_header *initial_boot_params;

char *find_flat_dt_string(u32 offset)
{
	return ((char *)initial_boot_params) +
		initial_boot_params->off_dt_strings + offset;
}

/**
 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
 * @it: callback function
 * @data: context data pointer
 *
 * This function is used to scan the flattened device-tree, it is
 * used to extract the memory information at boot before we can
 * unflatten the tree
 */
int __init of_scan_flat_dt(int (*it)(unsigned long node,
				     const char *uname, int depth,
				     void *data),
			   void *data)
{
	unsigned long p = ((unsigned long)initial_boot_params) +
		initial_boot_params->off_dt_struct;
	int rc = 0;
	int depth = -1;

	do {
		u32 tag = *((u32 *)p);
		char *pathp;

		p += 4;
		if (tag == OF_DT_END_NODE) {
			depth--;
			continue;
		}
		if (tag == OF_DT_NOP)
			continue;
		if (tag == OF_DT_END)
			break;
		if (tag == OF_DT_PROP) {
			u32 sz = *((u32 *)p);
			p += 8;
			if (initial_boot_params->version < 0x10)
				p = _ALIGN(p, sz >= 8 ? 8 : 4);
			p += sz;
			p = _ALIGN(p, 4);
			continue;
		}
		if (tag != OF_DT_BEGIN_NODE) {
			pr_err("Invalid tag %x in flat device tree!\n", tag);
			return -EINVAL;
		}
		depth++;
		pathp = (char *)p;
		p = _ALIGN(p + strlen(pathp) + 1, 4);
		if ((*pathp) == '/') {
			char *lp, *np;
			for (lp = NULL, np = pathp; *np; np++)
				if ((*np) == '/')
					lp = np+1;
			if (lp != NULL)
				pathp = lp;
		}
		rc = it(p, pathp, depth, data);
		if (rc != 0)
			break;
	} while (1);

	return rc;
}

/**
 * of_get_flat_dt_root - find the root node in the flat blob
 */
unsigned long __init of_get_flat_dt_root(void)
{
	unsigned long p = ((unsigned long)initial_boot_params) +
		initial_boot_params->off_dt_struct;

	while (*((u32 *)p) == OF_DT_NOP)
		p += 4;
	BUG_ON(*((u32 *)p) != OF_DT_BEGIN_NODE);
	p += 4;
	return _ALIGN(p + strlen((char *)p) + 1, 4);
}

/**
 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
 *
 * This function can be used within scan_flattened_dt callback to get
 * access to properties
 */
void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
				 unsigned long *size)
{
	unsigned long p = node;

	do {
		u32 tag = *((u32 *)p);
		u32 sz, noff;
		const char *nstr;

		p += 4;
		if (tag == OF_DT_NOP)
			continue;
		if (tag != OF_DT_PROP)
			return NULL;

		sz = *((u32 *)p);
		noff = *((u32 *)(p + 4));
		p += 8;
		if (initial_boot_params->version < 0x10)
			p = _ALIGN(p, sz >= 8 ? 8 : 4);

		nstr = find_flat_dt_string(noff);
		if (nstr == NULL) {
			pr_warning("Can't find property index name !\n");
			return NULL;
		}
		if (strcmp(name, nstr) == 0) {
			if (size)
				*size = sz;
			return (void *)p;
		}
		p += sz;
		p = _ALIGN(p, 4);
	} while (1);
}

/**
 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
 * @node: node to test
 * @compat: compatible string to compare with compatible list.
 */
int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
{
	const char *cp;
	unsigned long cplen, l;

	cp = of_get_flat_dt_prop(node, "compatible", &cplen);
	if (cp == NULL)
		return 0;
	while (cplen > 0) {
		if (strncasecmp(cp, compat, strlen(compat)) == 0)
			return 1;
		l = strlen(cp) + 1;
		cp += l;
		cplen -= l;
	}

	return 0;
}

static void *__init unflatten_dt_alloc(unsigned long *mem, unsigned long size,
				       unsigned long align)
{
	void *res;

	*mem = _ALIGN(*mem, align);
	res = (void *)*mem;
	*mem += size;

	return res;
}

/**
 * unflatten_dt_node - Alloc and populate a device_node from the flat tree
 * @p: pointer to node in flat tree
 * @dad: Parent struct device_node
 * @allnextpp: pointer to ->allnext from last allocated device_node
 * @fpsize: Size of the node path up at the current depth.
 */
unsigned long __init unflatten_dt_node(unsigned long mem,
					unsigned long *p,
					struct device_node *dad,
					struct device_node ***allnextpp,
					unsigned long fpsize)
{
	struct device_node *np;
	struct property *pp, **prev_pp = NULL;
	char *pathp;
	u32 tag;
	unsigned int l, allocl;
	int has_name = 0;
	int new_format = 0;

	tag = *((u32 *)(*p));
	if (tag != OF_DT_BEGIN_NODE) {
		pr_err("Weird tag at start of node: %x\n", tag);
		return mem;
	}
	*p += 4;
	pathp = (char *)*p;
	l = allocl = strlen(pathp) + 1;
	*p = _ALIGN(*p + l, 4);

	/* version 0x10 has a more compact unit name here instead of the full
	 * path. we accumulate the full path size using "fpsize", we'll rebuild
	 * it later. We detect this because the first character of the name is
	 * not '/'.
	 */
	if ((*pathp) != '/') {
		new_format = 1;
		if (fpsize == 0) {
			/* root node: special case. fpsize accounts for path
			 * plus terminating zero. root node only has '/', so
			 * fpsize should be 2, but we want to avoid the first
			 * level nodes to have two '/' so we use fpsize 1 here
			 */
			fpsize = 1;
			allocl = 2;
		} else {
			/* account for '/' and path size minus terminal 0
			 * already in 'l'
			 */
			fpsize += l;
			allocl = fpsize;
		}
	}

	np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
				__alignof__(struct device_node));
	if (allnextpp) {
		memset(np, 0, sizeof(*np));
		np->full_name = ((char *)np) + sizeof(struct device_node);
		if (new_format) {
			char *fn = np->full_name;
			/* rebuild full path for new format */
			if (dad && dad->parent) {
				strcpy(fn, dad->full_name);
#ifdef DEBUG
				if ((strlen(fn) + l + 1) != allocl) {
					pr_debug("%s: p: %d, l: %d, a: %d\n",
						pathp, (int)strlen(fn),
						l, allocl);
				}
#endif
				fn += strlen(fn);
			}
			*(fn++) = '/';
			memcpy(fn, pathp, l);
		} else
			memcpy(np->full_name, pathp, l);
		prev_pp = &np->properties;
		**allnextpp = np;
		*allnextpp = &np->allnext;
		if (dad != NULL) {
			np->parent = dad;
			/* we temporarily use the next field as `last_child'*/
			if (dad->next == NULL)
				dad->child = np;
			else
				dad->next->sibling = np;
			dad->next = np;
		}
		kref_init(&np->kref);
	}
	while (1) {
		u32 sz, noff;
		char *pname;

		tag = *((u32 *)(*p));
		if (tag == OF_DT_NOP) {
			*p += 4;
			continue;
		}
		if (tag != OF_DT_PROP)
			break;
		*p += 4;
		sz = *((u32 *)(*p));
		noff = *((u32 *)((*p) + 4));
		*p += 8;
		if (initial_boot_params->version < 0x10)
			*p = _ALIGN(*p, sz >= 8 ? 8 : 4);

		pname = find_flat_dt_string(noff);
		if (pname == NULL) {
			pr_info("Can't find property name in list !\n");
			break;
		}
		if (strcmp(pname, "name") == 0)
			has_name = 1;
		l = strlen(pname) + 1;
		pp = unflatten_dt_alloc(&mem, sizeof(struct property),
					__alignof__(struct property));
		if (allnextpp) {
			if (strcmp(pname, "linux,phandle") == 0) {
				np->node = *((u32 *)*p);
				if (np->linux_phandle == 0)
					np->linux_phandle = np->node;
			}
			if (strcmp(pname, "ibm,phandle") == 0)
				np->linux_phandle = *((u32 *)*p);
			pp->name = pname;
			pp->length = sz;
			pp->value = (void *)*p;
			*prev_pp = pp;
			prev_pp = &pp->next;
		}
		*p = _ALIGN((*p) + sz, 4);
	}
	/* with version 0x10 we may not have the name property, recreate
	 * it here from the unit name if absent
	 */
	if (!has_name) {
		char *p1 = pathp, *ps = pathp, *pa = NULL;
		int sz;

		while (*p1) {
			if ((*p1) == '@')
				pa = p1;
			if ((*p1) == '/')
				ps = p1 + 1;
			p1++;
		}
		if (pa < ps)
			pa = p1;
		sz = (pa - ps) + 1;
		pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
					__alignof__(struct property));
		if (allnextpp) {
			pp->name = "name";
			pp->length = sz;
			pp->value = pp + 1;
			*prev_pp = pp;
			prev_pp = &pp->next;
			memcpy(pp->value, ps, sz - 1);
			((char *)pp->value)[sz - 1] = 0;
			pr_debug("fixed up name for %s -> %s\n", pathp,
				(char *)pp->value);
		}
	}
	if (allnextpp) {
		*prev_pp = NULL;
		np->name = of_get_property(np, "name", NULL);
		np->type = of_get_property(np, "device_type", NULL);

		if (!np->name)
			np->name = "<NULL>";
		if (!np->type)
			np->type = "<NULL>";
	}
	while (tag == OF_DT_BEGIN_NODE) {
		mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize);
		tag = *((u32 *)(*p));
	}
	if (tag != OF_DT_END_NODE) {
		pr_err("Weird tag at end of node: %x\n", tag);
		return mem;
	}
	*p += 4;
	return mem;
}

/**
 * unflatten_device_tree - create tree of device_nodes from flat blob
 *
 * unflattens the device-tree passed by the firmware, creating the
 * tree of struct device_node. It also fills the "name" and "type"
 * pointers of the nodes so the normal device-tree walking functions
 * can be used.
 */
void __init unflatten_device_tree(void)
{
	unsigned long start, mem, size;
	struct device_node **allnextp = &allnodes;

	pr_debug(" -> unflatten_device_tree()\n");

	/* First pass, scan for size */
	start = ((unsigned long)initial_boot_params) +
		initial_boot_params->off_dt_struct;
	size = unflatten_dt_node(0, &start, NULL, NULL, 0);
	size = (size | 3) + 1;

	pr_debug("  size is %lx, allocating...\n", size);

	/* Allocate memory for the expanded device tree */
	mem = lmb_alloc(size + 4, __alignof__(struct device_node));
	mem = (unsigned long) __va(mem);

	((u32 *)mem)[size / 4] = 0xdeadbeef;

	pr_debug("  unflattening %lx...\n", mem);

	/* Second pass, do actual unflattening */
	start = ((unsigned long)initial_boot_params) +
		initial_boot_params->off_dt_struct;
	unflatten_dt_node(mem, &start, NULL, &allnextp, 0);
	if (*((u32 *)start) != OF_DT_END)
		pr_warning("Weird tag at end of tree: %08x\n", *((u32 *)start));
	if (((u32 *)mem)[size / 4] != 0xdeadbeef)
		pr_warning("End of tree marker overwritten: %08x\n",
			   ((u32 *)mem)[size / 4]);
	*allnextp = NULL;

	/* Get pointer to OF "/chosen" node for use everywhere */
	of_chosen = of_find_node_by_path("/chosen");
	if (of_chosen == NULL)
		of_chosen = of_find_node_by_path("/chosen@0");

	pr_debug(" <- unflatten_device_tree()\n");
}
Commit	Line	Data
e169cfbe GL	1	/*
	2	* Functions for working with the Flattened Device Tree data format
	3	*
	4	* Copyright 2009 Benjamin Herrenschmidt, IBM Corp
	5	* benh@kernel.crashing.org
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* version 2 as published by the Free Software Foundation.
	10	*/
	11
41f88009 GL	12	#include <linux/kernel.h>
41f88009 GL	13	#include <linux/lmb.h>
e169cfbe GL	14	#include <linux/of.h>
	15	#include <linux/of_fdt.h>
	16
	17	struct boot_param_header *initial_boot_params;
	18
	19	char *find_flat_dt_string(u32 offset)
	20	{
	21	return ((char *)initial_boot_params) +
	22	initial_boot_params->off_dt_strings + offset;
	23	}
c8cb7a59 GL	24
	25	/**
	26	* of_scan_flat_dt - scan flattened tree blob and call callback on each.
	27	* @it: callback function
	28	* @data: context data pointer
	29	*
	30	* This function is used to scan the flattened device-tree, it is
	31	* used to extract the memory information at boot before we can
	32	* unflatten the tree
	33	*/
	34	int __init of_scan_flat_dt(int (*it)(unsigned long node,
	35	const char *uname, int depth,
	36	void *data),
	37	void *data)
	38	{
	39	unsigned long p = ((unsigned long)initial_boot_params) +
	40	initial_boot_params->off_dt_struct;
	41	int rc = 0;
	42	int depth = -1;
	43
	44	do {
	45	u32 tag = ((u32 )p);
	46	char *pathp;
	47
	48	p += 4;
	49	if (tag == OF_DT_END_NODE) {
	50	depth--;
	51	continue;
	52	}
	53	if (tag == OF_DT_NOP)
	54	continue;
	55	if (tag == OF_DT_END)
	56	break;
	57	if (tag == OF_DT_PROP) {
	58	u32 sz = ((u32 )p);
	59	p += 8;
	60	if (initial_boot_params->version < 0x10)
	61	p = _ALIGN(p, sz >= 8 ? 8 : 4);
	62	p += sz;
	63	p = _ALIGN(p, 4);
	64	continue;
	65	}
	66	if (tag != OF_DT_BEGIN_NODE) {
	67	pr_err("Invalid tag %x in flat device tree!\n", tag);
	68	return -EINVAL;
	69	}
	70	depth++;
	71	pathp = (char *)p;
	72	p = _ALIGN(p + strlen(pathp) + 1, 4);
	73	if ((*pathp) == '/') {
	74	char lp, np;
	75	for (lp = NULL, np = pathp; *np; np++)
	76	if ((*np) == '/')
	77	lp = np+1;
	78	if (lp != NULL)
	79	pathp = lp;
	80	}
	81	rc = it(p, pathp, depth, data);
	82	if (rc != 0)
	83	break;
	84	} while (1);
	85
	86	return rc;
	87	}
819d2819 GL	88
	89	/**
	90	* of_get_flat_dt_root - find the root node in the flat blob
	91	*/
	92	unsigned long __init of_get_flat_dt_root(void)
	93	{
	94	unsigned long p = ((unsigned long)initial_boot_params) +
	95	initial_boot_params->off_dt_struct;
	96
	97	while (((u32 )p) == OF_DT_NOP)
	98	p += 4;
	99	BUG_ON(((u32 )p) != OF_DT_BEGIN_NODE);
	100	p += 4;
	101	return _ALIGN(p + strlen((char *)p) + 1, 4);
	102	}
	103
ca900cfa GL	104	/**
	105	* of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
	106	*
	107	* This function can be used within scan_flattened_dt callback to get
	108	* access to properties
	109	*/
	110	void __init of_get_flat_dt_prop(unsigned long node, const char name,
	111	unsigned long *size)
	112	{
	113	unsigned long p = node;
	114
	115	do {
	116	u32 tag = ((u32 )p);
	117	u32 sz, noff;
	118	const char *nstr;
	119
	120	p += 4;
	121	if (tag == OF_DT_NOP)
	122	continue;
	123	if (tag != OF_DT_PROP)
	124	return NULL;
	125
	126	sz = ((u32 )p);
	127	noff = ((u32 )(p + 4));
	128	p += 8;
	129	if (initial_boot_params->version < 0x10)
	130	p = _ALIGN(p, sz >= 8 ? 8 : 4);
	131
	132	nstr = find_flat_dt_string(noff);
	133	if (nstr == NULL) {
	134	pr_warning("Can't find property index name !\n");
	135	return NULL;
	136	}
	137	if (strcmp(name, nstr) == 0) {
	138	if (size)
	139	*size = sz;
	140	return (void *)p;
	141	}
	142	p += sz;
	143	p = _ALIGN(p, 4);
	144	} while (1);
	145	}
	146
00e38efd GL	147	/**
	148	* of_flat_dt_is_compatible - Return true if given node has compat in compatible list
	149	* @node: node to test
	150	* @compat: compatible string to compare with compatible list.
	151	*/
	152	int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
	153	{
	154	const char *cp;
	155	unsigned long cplen, l;
	156
	157	cp = of_get_flat_dt_prop(node, "compatible", &cplen);
	158	if (cp == NULL)
	159	return 0;
	160	while (cplen > 0) {
	161	if (strncasecmp(cp, compat, strlen(compat)) == 0)
	162	return 1;
	163	l = strlen(cp) + 1;
	164	cp += l;
	165	cplen -= l;
	166	}
	167
	168	return 0;
	169	}
	170
bbd33931 GL	171	static void __init unflatten_dt_alloc(unsigned long mem, unsigned long size,
	172	unsigned long align)
	173	{
	174	void *res;
	175
	176	mem = _ALIGN(mem, align);
	177	res = (void )mem;
	178	*mem += size;
	179
	180	return res;
	181	}
	182
	183	/**
	184	* unflatten_dt_node - Alloc and populate a device_node from the flat tree
	185	* @p: pointer to node in flat tree
	186	* @dad: Parent struct device_node
	187	* @allnextpp: pointer to ->allnext from last allocated device_node
	188	* @fpsize: Size of the node path up at the current depth.
	189	*/
	190	unsigned long __init unflatten_dt_node(unsigned long mem,
	191	unsigned long *p,
	192	struct device_node *dad,
	193	struct device_node ***allnextpp,
	194	unsigned long fpsize)
	195	{
	196	struct device_node *np;
	197	struct property pp, *prev_pp = NULL;
	198	char *pathp;
	199	u32 tag;
	200	unsigned int l, allocl;
	201	int has_name = 0;
	202	int new_format = 0;
	203
	204	tag = ((u32 )(*p));
	205	if (tag != OF_DT_BEGIN_NODE) {
	206	pr_err("Weird tag at start of node: %x\n", tag);
	207	return mem;
	208	}
	209	*p += 4;
	210	pathp = (char )p;
	211	l = allocl = strlen(pathp) + 1;
	212	p = _ALIGN(p + l, 4);
	213
	214	/* version 0x10 has a more compact unit name here instead of the full
	215	* path. we accumulate the full path size using "fpsize", we'll rebuild
	216	* it later. We detect this because the first character of the name is
	217	* not '/'.
	218	*/
	219	if ((*pathp) != '/') {
	220	new_format = 1;
	221	if (fpsize == 0) {
	222	/* root node: special case. fpsize accounts for path
	223	* plus terminating zero. root node only has '/', so
	224	* fpsize should be 2, but we want to avoid the first
	225	* level nodes to have two '/' so we use fpsize 1 here
	226	*/
	227	fpsize = 1;
	228	allocl = 2;
	229	} else {
	230	/* account for '/' and path size minus terminal 0
	231	* already in 'l'
	232	*/
	233	fpsize += l;
	234	allocl = fpsize;
235	}
236	}
237
238	np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
239	__alignof__(struct device_node));
240	if (allnextpp) {
241	memset(np, 0, sizeof(*np));
242	np->full_name = ((char *)np) + sizeof(struct device_node);
243	if (new_format) {
244	char *fn = np->full_name;
245	/* rebuild full path for new format */
246	if (dad && dad->parent) {
247	strcpy(fn, dad->full_name);
248	#ifdef DEBUG
249	if ((strlen(fn) + l + 1) != allocl) {
250	pr_debug("%s: p: %d, l: %d, a: %d\n",
251	pathp, (int)strlen(fn),
252	l, allocl);
253	}
254	#endif
255	fn += strlen(fn);
256	}
257	*(fn++) = '/';
258	memcpy(fn, pathp, l);
259	} else
260	memcpy(np->full_name, pathp, l);
261	prev_pp = &np->properties;
262	**allnextpp = np;
263	*allnextpp = &np->allnext;
264	if (dad != NULL) {
265	np->parent = dad;
266	/* we temporarily use the next field as `last_child'*/
267	if (dad->next == NULL)
268	dad->child = np;
269	else
270	dad->next->sibling = np;
271	dad->next = np;
272	}
273	kref_init(&np->kref);
274	}
275	while (1) {
276	u32 sz, noff;
277	char *pname;
278
279	tag = ((u32 )(*p));
280	if (tag == OF_DT_NOP) {
281	*p += 4;
282	continue;
283	}
284	if (tag != OF_DT_PROP)
285	break;
286	*p += 4;
287	sz = ((u32 )(*p));
288	noff = ((u32 )((*p) + 4));
289	*p += 8;
290	if (initial_boot_params->version < 0x10)
291	p = _ALIGN(p, sz >= 8 ? 8 : 4);
292
293	pname = find_flat_dt_string(noff);
294	if (pname == NULL) {
295	pr_info("Can't find property name in list !\n");
296	break;
297	}
298	if (strcmp(pname, "name") == 0)
299	has_name = 1;
300	l = strlen(pname) + 1;
301	pp = unflatten_dt_alloc(&mem, sizeof(struct property),
302	__alignof__(struct property));
303	if (allnextpp) {
304	if (strcmp(pname, "linux,phandle") == 0) {
305	np->node = ((u32 )*p);
306	if (np->linux_phandle == 0)
307	np->linux_phandle = np->node;
308	}
309	if (strcmp(pname, "ibm,phandle") == 0)
310	np->linux_phandle = ((u32 )*p);
311	pp->name = pname;
312	pp->length = sz;
313	pp->value = (void )p;
314	*prev_pp = pp;
315	prev_pp = &pp->next;
316	}
317	p = _ALIGN((p) + sz, 4);
318	}
319	/* with version 0x10 we may not have the name property, recreate
320	* it here from the unit name if absent
321	*/
322	if (!has_name) {
323	char p1 = pathp, ps = pathp, *pa = NULL;
324	int sz;
325
326	while (*p1) {
327	if ((*p1) == '@')
328	pa = p1;
329	if ((*p1) == '/')
330	ps = p1 + 1;
331	p1++;
332	}
333	if (pa < ps)
334	pa = p1;
335	sz = (pa - ps) + 1;
336	pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
337	__alignof__(struct property));
338	if (allnextpp) {
339	pp->name = "name";
340	pp->length = sz;
341	pp->value = pp + 1;
342	*prev_pp = pp;
343	prev_pp = &pp->next;
344	memcpy(pp->value, ps, sz - 1);
345	((char *)pp->value)[sz - 1] = 0;
346	pr_debug("fixed up name for %s -> %s\n", pathp,
347	(char *)pp->value);
348	}
349	}
350	if (allnextpp) {
351	*prev_pp = NULL;
352	np->name = of_get_property(np, "name", NULL);
353	np->type = of_get_property(np, "device_type", NULL);
354
355	if (!np->name)
356	np->name = "<NULL>";
357	if (!np->type)
358	np->type = "<NULL>";
359	}
360	while (tag == OF_DT_BEGIN_NODE) {
361	mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize);
362	tag = ((u32 )(*p));
363	}
364	if (tag != OF_DT_END_NODE) {
365	pr_err("Weird tag at end of node: %x\n", tag);
366	return mem;
367	}
368	*p += 4;
369	return mem;
370	}
41f88009 GL	371
	372	/**
	373	* unflatten_device_tree - create tree of device_nodes from flat blob
	374	*
	375	* unflattens the device-tree passed by the firmware, creating the
	376	* tree of struct device_node. It also fills the "name" and "type"
	377	* pointers of the nodes so the normal device-tree walking functions
	378	* can be used.
	379	*/
	380	void __init unflatten_device_tree(void)
	381	{
	382	unsigned long start, mem, size;
	383	struct device_node **allnextp = &allnodes;
	384
	385	pr_debug(" -> unflatten_device_tree()\n");
	386
	387	/* First pass, scan for size */
	388	start = ((unsigned long)initial_boot_params) +
	389	initial_boot_params->off_dt_struct;
	390	size = unflatten_dt_node(0, &start, NULL, NULL, 0);
	391	size = (size \| 3) + 1;
	392
	393	pr_debug(" size is %lx, allocating...\n", size);
	394
	395	/* Allocate memory for the expanded device tree */
	396	mem = lmb_alloc(size + 4, __alignof__(struct device_node));
	397	mem = (unsigned long) __va(mem);
	398
	399	((u32 *)mem)[size / 4] = 0xdeadbeef;
	400
	401	pr_debug(" unflattening %lx...\n", mem);
	402
	403	/* Second pass, do actual unflattening */
	404	start = ((unsigned long)initial_boot_params) +
	405	initial_boot_params->off_dt_struct;
	406	unflatten_dt_node(mem, &start, NULL, &allnextp, 0);
	407	if (((u32 )start) != OF_DT_END)
	408	pr_warning("Weird tag at end of tree: %08x\n", ((u32 )start));
	409	if (((u32 *)mem)[size / 4] != 0xdeadbeef)
	410	pr_warning("End of tree marker overwritten: %08x\n",
	411	((u32 *)mem)[size / 4]);
	412	*allnextp = NULL;
	413
	414	/* Get pointer to OF "/chosen" node for use everywhere */
	415	of_chosen = of_find_node_by_path("/chosen");
	416	if (of_chosen == NULL)
	417	of_chosen = of_find_node_by_path("/chosen@0");
	418
	419	pr_debug(" <- unflatten_device_tree()\n");
	420	}