[linux-2.6-block.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/initrd.h>
#include <linux/of.h>
#include <linux/of_fdt.h>
#include <linux/string.h>
#include <linux/errno.h>

#ifdef CONFIG_PPC
#include <asm/machdep.h>
#endif /* CONFIG_PPC */

#include <asm/page.h>

int __initdata dt_root_addr_cells;
int __initdata dt_root_size_cells;

struct boot_param_header *initial_boot_params;

char *find_flat_dt_string(u32 offset)
{
	return ((char *)initial_boot_params) +
		be32_to_cpu(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) +
		be32_to_cpu(initial_boot_params->off_dt_struct);
	int rc = 0;
	int depth = -1;

	do {
		u32 tag = be32_to_cpup((__be32 *)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 = be32_to_cpup((__be32 *)p);
			p += 8;
			if (be32_to_cpu(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) +
		be32_to_cpu(initial_boot_params->off_dt_struct);

	while (be32_to_cpup((__be32 *)p) == OF_DT_NOP)
		p += 4;
	BUG_ON(be32_to_cpup((__be32 *)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 = be32_to_cpup((__be32 *)p);
		u32 sz, noff;
		const char *nstr;

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

		sz = be32_to_cpup((__be32 *)p);
		noff = be32_to_cpup((__be32 *)(p + 4));
		p += 8;
		if (be32_to_cpu(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 = be32_to_cpup((__be32 *)(*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 = be32_to_cpup((__be32 *)(*p));
		if (tag == OF_DT_NOP) {
			*p += 4;
			continue;
		}
		if (tag != OF_DT_PROP)
			break;
		*p += 4;
		sz = be32_to_cpup((__be32 *)(*p));
		noff = be32_to_cpup((__be32 *)((*p) + 4));
		*p += 8;
		if (be32_to_cpu(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) {
			/* We accept flattened tree phandles either in
			 * ePAPR-style "phandle" properties, or the
			 * legacy "linux,phandle" properties.  If both
			 * appear and have different values, things
			 * will get weird.  Don't do that. */
			if ((strcmp(pname, "phandle") == 0) ||
			    (strcmp(pname, "linux,phandle") == 0)) {
				if (np->phandle == 0)
					np->phandle = *((u32 *)*p);
			}
			/* And we process the "ibm,phandle" property
			 * used in pSeries dynamic device tree
			 * stuff */
			if (strcmp(pname, "ibm,phandle") == 0)
				np->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 || tag == OF_DT_NOP) {
		if (tag == OF_DT_NOP)
			*p += 4;
		else
			mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize);
		tag = be32_to_cpup((__be32 *)(*p));
	}
	if (tag != OF_DT_END_NODE) {
		pr_err("Weird tag at end of node: %x\n", tag);
		return mem;
	}
	*p += 4;
	return mem;
}

#ifdef CONFIG_BLK_DEV_INITRD
/**
 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
 * @node: reference to node containing initrd location ('chosen')
 */
void __init early_init_dt_check_for_initrd(unsigned long node)
{
	unsigned long start, end, len;
	__be32 *prop;

	pr_debug("Looking for initrd properties... ");

	prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
	if (!prop)
		return;
	start = of_read_ulong(prop, len/4);

	prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
	if (!prop)
		return;
	end = of_read_ulong(prop, len/4);

	early_init_dt_setup_initrd_arch(start, end);
	pr_debug("initrd_start=0x%lx  initrd_end=0x%lx\n", start, end);
}
#else
inline void early_init_dt_check_for_initrd(unsigned long node)
{
}
#endif /* CONFIG_BLK_DEV_INITRD */

/**
 * early_init_dt_scan_root - fetch the top level address and size cells
 */
int __init early_init_dt_scan_root(unsigned long node, const char *uname,
				   int depth, void *data)
{
	__be32 *prop;

	if (depth != 0)
		return 0;

	dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
	dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;

	prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
	if (prop)
		dt_root_size_cells = be32_to_cpup(prop);
	pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);

	prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
	if (prop)
		dt_root_addr_cells = be32_to_cpup(prop);
	pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);

	/* break now */
	return 1;
}

u64 __init dt_mem_next_cell(int s, __be32 **cellp)
{
	__be32 *p = *cellp;

	*cellp = p + s;
	return of_read_number(p, s);
}

/**
 * early_init_dt_scan_memory - Look for an parse memory nodes
 */
int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
				     int depth, void *data)
{
	char *type = of_get_flat_dt_prop(node, "device_type", NULL);
	__be32 *reg, *endp;
	unsigned long l;

	/* We are scanning "memory" nodes only */
	if (type == NULL) {
		/*
		 * The longtrail doesn't have a device_type on the
		 * /memory node, so look for the node called /memory@0.
		 */
		if (depth != 1 || strcmp(uname, "memory@0") != 0)
			return 0;
	} else if (strcmp(type, "memory") != 0)
		return 0;

	reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
	if (reg == NULL)
		reg = of_get_flat_dt_prop(node, "reg", &l);
	if (reg == NULL)
		return 0;

	endp = reg + (l / sizeof(__be32));

	pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
	    uname, l, reg[0], reg[1], reg[2], reg[3]);

	while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
		u64 base, size;

		base = dt_mem_next_cell(dt_root_addr_cells, &reg);
		size = dt_mem_next_cell(dt_root_size_cells, &reg);

		if (size == 0)
			continue;
		pr_debug(" - %llx ,  %llx\n", (unsigned long long)base,
		    (unsigned long long)size);

		early_init_dt_add_memory_arch(base, size);
	}

	return 0;
}

int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
				     int depth, void *data)
{
	unsigned long l;
	char *p;

	pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);

	if (depth != 1 ||
	    (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
		return 0;

	early_init_dt_check_for_initrd(node);

	/* Retreive command line */
	p = of_get_flat_dt_prop(node, "bootargs", &l);
	if (p != NULL && l > 0)
		strlcpy(cmd_line, p, min((int)l, COMMAND_LINE_SIZE));

#ifdef CONFIG_CMDLINE
#ifndef CONFIG_CMDLINE_FORCE
	if (p == NULL || l == 0 || (l == 1 && (*p) == 0))
#endif
		strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
#endif /* CONFIG_CMDLINE */

	early_init_dt_scan_chosen_arch(node);

	pr_debug("Command line is: %s\n", cmd_line);

	/* break now */
	return 1;
}

/**
 * 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) +
		be32_to_cpu(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 = early_init_dt_alloc_memory_arch(size + 4,
			__alignof__(struct device_node));
	mem = (unsigned long) __va(mem);

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

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

	/* Second pass, do actual unflattening */
	start = ((unsigned long)initial_boot_params) +
		be32_to_cpu(initial_boot_params->off_dt_struct);
	unflatten_dt_node(mem, &start, NULL, &allnextp, 0);
	if (be32_to_cpup((__be32 *)start) != OF_DT_END)
		pr_warning("Weird tag at end of tree: %08x\n", *((u32 *)start));
	if (be32_to_cpu(((__be32 *)mem)[size / 4]) != 0xdeadbeef)
		pr_warning("End of tree marker overwritten: %08x\n",
			   be32_to_cpu(((__be32 *)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	12	#include <linux/kernel.h>
f7b3a835	13	#include <linux/initrd.h>
e169cfbe GL	14	#include <linux/of.h>
e169cfbe GL	15	#include <linux/of_fdt.h>
4ef7b373 JK	16	#include <linux/string.h>
4ef7b373 JK	17	#include <linux/errno.h>
51975db0	18
86e03221 GL	19	#ifdef CONFIG_PPC
	20	#include <asm/machdep.h>
	21	#endif /* CONFIG_PPC */
	22
4ef7b373 JK	23	#include <asm/page.h>
4ef7b373 JK	24
f00abd94 GL	25	int __initdata dt_root_addr_cells;
	26	int __initdata dt_root_size_cells;
	27
e169cfbe GL	28	struct boot_param_header *initial_boot_params;
	29
	30	char *find_flat_dt_string(u32 offset)
	31	{
	32	return ((char *)initial_boot_params) +
087f79c4	33	be32_to_cpu(initial_boot_params->off_dt_strings) + offset;
e169cfbe	34	}
c8cb7a59 GL	35
	36	/**
	37	* of_scan_flat_dt - scan flattened tree blob and call callback on each.
	38	* @it: callback function
	39	* @data: context data pointer
	40	*
	41	* This function is used to scan the flattened device-tree, it is
	42	* used to extract the memory information at boot before we can
	43	* unflatten the tree
	44	*/
	45	int __init of_scan_flat_dt(int (*it)(unsigned long node,
	46	const char *uname, int depth,
	47	void *data),
	48	void *data)
	49	{
	50	unsigned long p = ((unsigned long)initial_boot_params) +
087f79c4	51	be32_to_cpu(initial_boot_params->off_dt_struct);
c8cb7a59 GL	52	int rc = 0;
	53	int depth = -1;
	54
	55	do {
33714881	56	u32 tag = be32_to_cpup((__be32 *)p);
c8cb7a59 GL	57	char *pathp;
	58
	59	p += 4;
	60	if (tag == OF_DT_END_NODE) {
	61	depth--;
	62	continue;
	63	}
	64	if (tag == OF_DT_NOP)
	65	continue;
	66	if (tag == OF_DT_END)
	67	break;
	68	if (tag == OF_DT_PROP) {
33714881	69	u32 sz = be32_to_cpup((__be32 *)p);
c8cb7a59	70	p += 8;
087f79c4	71	if (be32_to_cpu(initial_boot_params->version) < 0x10)
c8cb7a59 GL	72	p = _ALIGN(p, sz >= 8 ? 8 : 4);
	73	p += sz;
	74	p = _ALIGN(p, 4);
	75	continue;
	76	}
	77	if (tag != OF_DT_BEGIN_NODE) {
	78	pr_err("Invalid tag %x in flat device tree!\n", tag);
	79	return -EINVAL;
	80	}
	81	depth++;
	82	pathp = (char *)p;
	83	p = _ALIGN(p + strlen(pathp) + 1, 4);
	84	if ((*pathp) == '/') {
	85	char lp, np;
	86	for (lp = NULL, np = pathp; *np; np++)
	87	if ((*np) == '/')
	88	lp = np+1;
	89	if (lp != NULL)
	90	pathp = lp;
	91	}
	92	rc = it(p, pathp, depth, data);
	93	if (rc != 0)
	94	break;
	95	} while (1);
	96
	97	return rc;
	98	}
819d2819 GL	99
	100	/**
	101	* of_get_flat_dt_root - find the root node in the flat blob
	102	*/
	103	unsigned long __init of_get_flat_dt_root(void)
	104	{
	105	unsigned long p = ((unsigned long)initial_boot_params) +
087f79c4	106	be32_to_cpu(initial_boot_params->off_dt_struct);
819d2819	107
33714881	108	while (be32_to_cpup((__be32 *)p) == OF_DT_NOP)
819d2819	109	p += 4;
33714881	110	BUG_ON(be32_to_cpup((__be32 *)p) != OF_DT_BEGIN_NODE);
819d2819 GL	111	p += 4;
	112	return _ALIGN(p + strlen((char *)p) + 1, 4);
	113	}
	114
ca900cfa GL	115	/**
	116	* of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
	117	*
	118	* This function can be used within scan_flattened_dt callback to get
	119	* access to properties
	120	*/
	121	void __init of_get_flat_dt_prop(unsigned long node, const char name,
	122	unsigned long *size)
	123	{
	124	unsigned long p = node;
	125
	126	do {
33714881	127	u32 tag = be32_to_cpup((__be32 *)p);
ca900cfa GL	128	u32 sz, noff;
	129	const char *nstr;
	130
	131	p += 4;
	132	if (tag == OF_DT_NOP)
	133	continue;
	134	if (tag != OF_DT_PROP)
	135	return NULL;
	136
33714881 JK	137	sz = be32_to_cpup((__be32 *)p);
33714881 JK	138	noff = be32_to_cpup((__be32 *)(p + 4));
ca900cfa	139	p += 8;
087f79c4	140	if (be32_to_cpu(initial_boot_params->version) < 0x10)
ca900cfa GL	141	p = _ALIGN(p, sz >= 8 ? 8 : 4);
	142
	143	nstr = find_flat_dt_string(noff);
	144	if (nstr == NULL) {
	145	pr_warning("Can't find property index name !\n");
	146	return NULL;
	147	}
	148	if (strcmp(name, nstr) == 0) {
	149	if (size)
	150	*size = sz;
	151	return (void *)p;
	152	}
	153	p += sz;
	154	p = _ALIGN(p, 4);
	155	} while (1);
	156	}
	157
00e38efd GL	158	/**
	159	* of_flat_dt_is_compatible - Return true if given node has compat in compatible list
	160	* @node: node to test
	161	* @compat: compatible string to compare with compatible list.
	162	*/
	163	int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
	164	{
	165	const char *cp;
	166	unsigned long cplen, l;
	167
	168	cp = of_get_flat_dt_prop(node, "compatible", &cplen);
	169	if (cp == NULL)
	170	return 0;
	171	while (cplen > 0) {
	172	if (strncasecmp(cp, compat, strlen(compat)) == 0)
	173	return 1;
	174	l = strlen(cp) + 1;
	175	cp += l;
	176	cplen -= l;
	177	}
	178
	179	return 0;
	180	}
	181
bbd33931 GL	182	static void __init unflatten_dt_alloc(unsigned long mem, unsigned long size,
	183	unsigned long align)
	184	{
	185	void *res;
	186
	187	mem = _ALIGN(mem, align);
	188	res = (void )mem;
	189	*mem += size;
	190
	191	return res;
	192	}
	193
	194	/**
	195	* unflatten_dt_node - Alloc and populate a device_node from the flat tree
	196	* @p: pointer to node in flat tree
	197	* @dad: Parent struct device_node
	198	* @allnextpp: pointer to ->allnext from last allocated device_node
	199	* @fpsize: Size of the node path up at the current depth.
	200	*/
	201	unsigned long __init unflatten_dt_node(unsigned long mem,
	202	unsigned long *p,
	203	struct device_node *dad,
	204	struct device_node ***allnextpp,
	205	unsigned long fpsize)
	206	{
	207	struct device_node *np;
	208	struct property pp, *prev_pp = NULL;
	209	char *pathp;
	210	u32 tag;
	211	unsigned int l, allocl;
	212	int has_name = 0;
	213	int new_format = 0;
	214
33714881	215	tag = be32_to_cpup((__be32 )(p));
bbd33931 GL	216	if (tag != OF_DT_BEGIN_NODE) {
	217	pr_err("Weird tag at start of node: %x\n", tag);
	218	return mem;
	219	}
	220	*p += 4;
	221	pathp = (char )p;
	222	l = allocl = strlen(pathp) + 1;
	223	p = _ALIGN(p + l, 4);
	224
	225	/* version 0x10 has a more compact unit name here instead of the full
	226	* path. we accumulate the full path size using "fpsize", we'll rebuild
	227	* it later. We detect this because the first character of the name is
	228	* not '/'.
	229	*/
	230	if ((*pathp) != '/') {
	231	new_format = 1;
	232	if (fpsize == 0) {
	233	/* root node: special case. fpsize accounts for path
	234	* plus terminating zero. root node only has '/', so
	235	* fpsize should be 2, but we want to avoid the first
	236	* level nodes to have two '/' so we use fpsize 1 here
	237	*/
	238	fpsize = 1;
	239	allocl = 2;
	240	} else {
	241	/* account for '/' and path size minus terminal 0
	242	* already in 'l'
	243	*/
	244	fpsize += l;
	245	allocl = fpsize;
	246	}
	247	}
	248
	249	np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
	250	__alignof__(struct device_node));
	251	if (allnextpp) {
	252	memset(np, 0, sizeof(*np));
	253	np->full_name = ((char *)np) + sizeof(struct device_node);
	254	if (new_format) {
	255	char *fn = np->full_name;
	256	/* rebuild full path for new format */
	257	if (dad && dad->parent) {
	258	strcpy(fn, dad->full_name);
	259	#ifdef DEBUG
	260	if ((strlen(fn) + l + 1) != allocl) {
	261	pr_debug("%s: p: %d, l: %d, a: %d\n",
	262	pathp, (int)strlen(fn),
	263	l, allocl);
	264	}
	265	#endif
	266	fn += strlen(fn);
	267	}
	268	*(fn++) = '/';
	269	memcpy(fn, pathp, l);
	270	} else
	271	memcpy(np->full_name, pathp, l);
	272	prev_pp = &np->properties;
	273	**allnextpp = np;
	274	*allnextpp = &np->allnext;
	275	if (dad != NULL) {
	276	np->parent = dad;
	277	/* we temporarily use the next field as `last_child'*/
	278	if (dad->next == NULL)
	279	dad->child = np;
280	else
281	dad->next->sibling = np;
282	dad->next = np;
283	}
284	kref_init(&np->kref);
285	}
286	while (1) {
287	u32 sz, noff;
288	char *pname;
289
33714881	290	tag = be32_to_cpup((__be32 )(p));
bbd33931 GL	291	if (tag == OF_DT_NOP) {
	292	*p += 4;
	293	continue;
	294	}
	295	if (tag != OF_DT_PROP)
	296	break;
	297	*p += 4;
33714881 JK	298	sz = be32_to_cpup((__be32 )(p));
33714881 JK	299	noff = be32_to_cpup((__be32 )((p) + 4));
bbd33931	300	*p += 8;
087f79c4	301	if (be32_to_cpu(initial_boot_params->version) < 0x10)
bbd33931 GL	302	p = _ALIGN(p, sz >= 8 ? 8 : 4);
	303
	304	pname = find_flat_dt_string(noff);
	305	if (pname == NULL) {
	306	pr_info("Can't find property name in list !\n");
	307	break;
	308	}
	309	if (strcmp(pname, "name") == 0)
	310	has_name = 1;
	311	l = strlen(pname) + 1;
	312	pp = unflatten_dt_alloc(&mem, sizeof(struct property),
	313	__alignof__(struct property));
	314	if (allnextpp) {
04b954a6 DG	315	/* We accept flattened tree phandles either in
	316	* ePAPR-style "phandle" properties, or the
	317	* legacy "linux,phandle" properties. If both
	318	* appear and have different values, things
	319	* will get weird. Don't do that. */
	320	if ((strcmp(pname, "phandle") == 0) \|\|
	321	(strcmp(pname, "linux,phandle") == 0)) {
6016a363 GL	322	if (np->phandle == 0)
6016a363 GL	323	np->phandle = ((u32 )*p);
bbd33931	324	}
04b954a6 DG	325	/* And we process the "ibm,phandle" property
	326	* used in pSeries dynamic device tree
	327	* stuff */
bbd33931	328	if (strcmp(pname, "ibm,phandle") == 0)
6016a363	329	np->phandle = ((u32 )*p);
bbd33931 GL	330	pp->name = pname;
	331	pp->length = sz;
	332	pp->value = (void )p;
	333	*prev_pp = pp;
	334	prev_pp = &pp->next;
	335	}
	336	p = _ALIGN((p) + sz, 4);
	337	}
	338	/* with version 0x10 we may not have the name property, recreate
	339	* it here from the unit name if absent
	340	*/
	341	if (!has_name) {
	342	char p1 = pathp, ps = pathp, *pa = NULL;
	343	int sz;
	344
	345	while (*p1) {
	346	if ((*p1) == '@')
	347	pa = p1;
	348	if ((*p1) == '/')
	349	ps = p1 + 1;
	350	p1++;
	351	}
	352	if (pa < ps)
	353	pa = p1;
	354	sz = (pa - ps) + 1;
	355	pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
	356	__alignof__(struct property));
	357	if (allnextpp) {
	358	pp->name = "name";
	359	pp->length = sz;
	360	pp->value = pp + 1;
	361	*prev_pp = pp;
	362	prev_pp = &pp->next;
	363	memcpy(pp->value, ps, sz - 1);
	364	((char *)pp->value)[sz - 1] = 0;
	365	pr_debug("fixed up name for %s -> %s\n", pathp,
	366	(char *)pp->value);
	367	}
	368	}
	369	if (allnextpp) {
	370	*prev_pp = NULL;
	371	np->name = of_get_property(np, "name", NULL);
	372	np->type = of_get_property(np, "device_type", NULL);
	373
	374	if (!np->name)
	375	np->name = "<NULL>";
	376	if (!np->type)
	377	np->type = "<NULL>";
	378	}
7f809e1f JG	379	while (tag == OF_DT_BEGIN_NODE \|\| tag == OF_DT_NOP) {
	380	if (tag == OF_DT_NOP)
	381	*p += 4;
	382	else
	383	mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize);
33714881	384	tag = be32_to_cpup((__be32 )(p));
bbd33931 GL	385	}
	386	if (tag != OF_DT_END_NODE) {
	387	pr_err("Weird tag at end of node: %x\n", tag);
	388	return mem;
	389	}
	390	*p += 4;
	391	return mem;
	392	}
41f88009	393
f7b3a835 GL	394	#ifdef CONFIG_BLK_DEV_INITRD
	395	/**
	396	* early_init_dt_check_for_initrd - Decode initrd location from flat tree
	397	* @node: reference to node containing initrd location ('chosen')
	398	*/
	399	void __init early_init_dt_check_for_initrd(unsigned long node)
	400	{
1406bc2f	401	unsigned long start, end, len;
33714881	402	__be32 *prop;
f7b3a835 GL	403
	404	pr_debug("Looking for initrd properties... ");
	405
	406	prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
1406bc2f JK	407	if (!prop)
	408	return;
	409	start = of_read_ulong(prop, len/4);
	410
	411	prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
	412	if (!prop)
	413	return;
	414	end = of_read_ulong(prop, len/4);
f7b3a835	415
1406bc2f JK	416	early_init_dt_setup_initrd_arch(start, end);
1406bc2f JK	417	pr_debug("initrd_start=0x%lx initrd_end=0x%lx\n", start, end);
f7b3a835 GL	418	}
	419	#else
	420	inline void early_init_dt_check_for_initrd(unsigned long node)
	421	{
	422	}
	423	#endif /* CONFIG_BLK_DEV_INITRD */
	424
f00abd94 GL	425	/**
	426	* early_init_dt_scan_root - fetch the top level address and size cells
	427	*/
	428	int __init early_init_dt_scan_root(unsigned long node, const char *uname,
	429	int depth, void *data)
	430	{
33714881	431	__be32 *prop;
f00abd94 GL	432
	433	if (depth != 0)
	434	return 0;
	435
33714881 JK	436	dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
	437	dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
	438
f00abd94	439	prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
33714881 JK	440	if (prop)
33714881 JK	441	dt_root_size_cells = be32_to_cpup(prop);
f00abd94 GL	442	pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
	443
	444	prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
33714881 JK	445	if (prop)
33714881 JK	446	dt_root_addr_cells = be32_to_cpup(prop);
f00abd94 GL	447	pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
	448
	449	/* break now */
	450	return 1;
	451	}
	452
2e89e685	453	u64 __init dt_mem_next_cell(int s, __be32 **cellp)
83f7a06e	454	{
2e89e685	455	__be32 p = cellp;
83f7a06e GL	456
	457	*cellp = p + s;
	458	return of_read_number(p, s);
	459	}
	460
51975db0 GL	461	/**
	462	* early_init_dt_scan_memory - Look for an parse memory nodes
	463	*/
	464	int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
	465	int depth, void *data)
	466	{
	467	char *type = of_get_flat_dt_prop(node, "device_type", NULL);
	468	__be32 reg, endp;
	469	unsigned long l;
	470
	471	/* We are scanning "memory" nodes only */
	472	if (type == NULL) {
	473	/*
	474	* The longtrail doesn't have a device_type on the
	475	* /memory node, so look for the node called /memory@0.
	476	*/
	477	if (depth != 1 \|\| strcmp(uname, "memory@0") != 0)
	478	return 0;
	479	} else if (strcmp(type, "memory") != 0)
	480	return 0;
	481
	482	reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
	483	if (reg == NULL)
	484	reg = of_get_flat_dt_prop(node, "reg", &l);
	485	if (reg == NULL)
	486	return 0;
	487
	488	endp = reg + (l / sizeof(__be32));
	489
	490	pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
	491	uname, l, reg[0], reg[1], reg[2], reg[3]);
	492
	493	while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
	494	u64 base, size;
	495
	496	base = dt_mem_next_cell(dt_root_addr_cells, &reg);
	497	size = dt_mem_next_cell(dt_root_size_cells, &reg);
	498
	499	if (size == 0)
	500	continue;
	501	pr_debug(" - %llx , %llx\n", (unsigned long long)base,
	502	(unsigned long long)size);
	503
	504	early_init_dt_add_memory_arch(base, size);
	505	}
	506
	507	return 0;
	508	}
	509
86e03221 GL	510	int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
	511	int depth, void *data)
	512	{
	513	unsigned long l;
	514	char *p;
	515
	516	pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
	517
	518	if (depth != 1 \|\|
	519	(strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
	520	return 0;
	521
	522	early_init_dt_check_for_initrd(node);
	523
	524	/* Retreive command line */
	525	p = of_get_flat_dt_prop(node, "bootargs", &l);
	526	if (p != NULL && l > 0)
	527	strlcpy(cmd_line, p, min((int)l, COMMAND_LINE_SIZE));
	528
	529	#ifdef CONFIG_CMDLINE
	530	#ifndef CONFIG_CMDLINE_FORCE
	531	if (p == NULL \|\| l == 0 \|\| (l == 1 && (*p) == 0))
	532	#endif
	533	strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
	534	#endif /* CONFIG_CMDLINE */
	535
	536	early_init_dt_scan_chosen_arch(node);
	537
	538	pr_debug("Command line is: %s\n", cmd_line);
	539
	540	/* break now */
	541	return 1;
	542	}
	543
41f88009 GL	544	/**
	545	* unflatten_device_tree - create tree of device_nodes from flat blob
	546	*
	547	* unflattens the device-tree passed by the firmware, creating the
	548	* tree of struct device_node. It also fills the "name" and "type"
	549	* pointers of the nodes so the normal device-tree walking functions
	550	* can be used.
	551	*/
	552	void __init unflatten_device_tree(void)
	553	{
	554	unsigned long start, mem, size;
	555	struct device_node **allnextp = &allnodes;
	556
	557	pr_debug(" -> unflatten_device_tree()\n");
	558
	559	/* First pass, scan for size */
	560	start = ((unsigned long)initial_boot_params) +
087f79c4	561	be32_to_cpu(initial_boot_params->off_dt_struct);
41f88009 GL	562	size = unflatten_dt_node(0, &start, NULL, NULL, 0);
	563	size = (size \| 3) + 1;
	564
	565	pr_debug(" size is %lx, allocating...\n", size);
	566
	567	/* Allocate memory for the expanded device tree */
4ef7b373 JK	568	mem = early_init_dt_alloc_memory_arch(size + 4,
4ef7b373 JK	569	__alignof__(struct device_node));
41f88009 GL	570	mem = (unsigned long) __va(mem);
41f88009 GL	571
33714881	572	((__be32 *)mem)[size / 4] = cpu_to_be32(0xdeadbeef);
41f88009 GL	573
	574	pr_debug(" unflattening %lx...\n", mem);
	575
	576	/* Second pass, do actual unflattening */
	577	start = ((unsigned long)initial_boot_params) +
087f79c4	578	be32_to_cpu(initial_boot_params->off_dt_struct);
41f88009	579	unflatten_dt_node(mem, &start, NULL, &allnextp, 0);
33714881	580	if (be32_to_cpup((__be32 *)start) != OF_DT_END)
41f88009	581	pr_warning("Weird tag at end of tree: %08x\n", ((u32 )start));
33714881	582	if (be32_to_cpu(((__be32 *)mem)[size / 4]) != 0xdeadbeef)
41f88009	583	pr_warning("End of tree marker overwritten: %08x\n",
33714881	584	be32_to_cpu(((__be32 *)mem)[size / 4]));
41f88009 GL	585	*allnextp = NULL;
	586
	587	/* Get pointer to OF "/chosen" node for use everywhere */
	588	of_chosen = of_find_node_by_path("/chosen");
	589	if (of_chosen == NULL)
	590	of_chosen = of_find_node_by_path("/chosen@0");
	591
	592	pr_debug(" <- unflatten_device_tree()\n");
	593	}