Eric Lee / smarc-uboot | Embedian Git Server

Commit ec002119cf30a7e7ef721071d890a0d8248232da

Authored by Simon Glass 2017-05-19 10:09:00 +0800

fdt: Update fdt_get_base_address() to use const

This function does not change the device tree so adjust it to use const
for this parameter.

Signed-off-by: Simon Glass <sjg@chromium.org>

Showing 2 changed files with 2 additions and 2 deletions Inline Diff

common/fdt_support.c
include/fdt_support.h

common/fdt_support.c

Diff comments View file @ ec00211

1	/*	1	/*
2	* (C) Copyright 2007	2	* (C) Copyright 2007
3	* Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com	3	* Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com
4	*	4	*
5	* Copyright 2010-2011 Freescale Semiconductor, Inc.	5	* Copyright 2010-2011 Freescale Semiconductor, Inc.
6	*	6	*
7	* SPDX-License-Identifier: GPL-2.0+	7	* SPDX-License-Identifier: GPL-2.0+
8	*/	8	*/
9		9
10	#include <common.h>	10	#include <common.h>
11	#include <inttypes.h>	11	#include <inttypes.h>
12	#include <stdio_dev.h>	12	#include <stdio_dev.h>
13	#include <linux/ctype.h>	13	#include <linux/ctype.h>
14	#include <linux/types.h>	14	#include <linux/types.h>
15	#include <asm/global_data.h>	15	#include <asm/global_data.h>
16	#include <libfdt.h>	16	#include <libfdt.h>
17	#include <fdt_support.h>	17	#include <fdt_support.h>
18	#include <exports.h>	18	#include <exports.h>
19	#include <fdtdec.h>	19	#include <fdtdec.h>
20		20
21	/**	21	/**
22	* fdt_getprop_u32_default_node - Return a node's property or a default	22	* fdt_getprop_u32_default_node - Return a node's property or a default
23	*	23	*
24	* @fdt: ptr to device tree	24	* @fdt: ptr to device tree
25	* @off: offset of node	25	* @off: offset of node
26	* @cell: cell offset in property	26	* @cell: cell offset in property
27	* @prop: property name	27	* @prop: property name
28	* @dflt: default value if the property isn't found	28	* @dflt: default value if the property isn't found
29	*	29	*
30	* Convenience function to return a node's property or a default value if	30	* Convenience function to return a node's property or a default value if
31	* the property doesn't exist.	31	* the property doesn't exist.
32	*/	32	*/
33	u32 fdt_getprop_u32_default_node(const void *fdt, int off, int cell,	33	u32 fdt_getprop_u32_default_node(const void *fdt, int off, int cell,
34	const char *prop, const u32 dflt)	34	const char *prop, const u32 dflt)
35	{	35	{
36	const fdt32_t *val;	36	const fdt32_t *val;
37	int len;	37	int len;
38		38
39	val = fdt_getprop(fdt, off, prop, &len);	39	val = fdt_getprop(fdt, off, prop, &len);
40		40
41	/* Check if property exists */	41	/* Check if property exists */
42	if (!val)	42	if (!val)
43	return dflt;	43	return dflt;
44		44
45	/* Check if property is long enough */	45	/* Check if property is long enough */
46	if (len < ((cell + 1) * sizeof(uint32_t)))	46	if (len < ((cell + 1) * sizeof(uint32_t)))
47	return dflt;	47	return dflt;
48		48
49	return fdt32_to_cpu(*val);	49	return fdt32_to_cpu(*val);
50	}	50	}
51		51
52	/**	52	/**
53	* fdt_getprop_u32_default - Find a node and return it's property or a default	53	* fdt_getprop_u32_default - Find a node and return it's property or a default
54	*	54	*
55	* @fdt: ptr to device tree	55	* @fdt: ptr to device tree
56	* @path: path of node	56	* @path: path of node
57	* @prop: property name	57	* @prop: property name
58	* @dflt: default value if the property isn't found	58	* @dflt: default value if the property isn't found
59	*	59	*
60	* Convenience function to find a node and return it's property or a	60	* Convenience function to find a node and return it's property or a
61	* default value if it doesn't exist.	61	* default value if it doesn't exist.
62	*/	62	*/
63	u32 fdt_getprop_u32_default(const void fdt, const char path,	63	u32 fdt_getprop_u32_default(const void fdt, const char path,
64	const char *prop, const u32 dflt)	64	const char *prop, const u32 dflt)
65	{	65	{
66	int off;	66	int off;
67		67
68	off = fdt_path_offset(fdt, path);	68	off = fdt_path_offset(fdt, path);
69	if (off < 0)	69	if (off < 0)
70	return dflt;	70	return dflt;
71		71
72	return fdt_getprop_u32_default_node(fdt, off, 0, prop, dflt);	72	return fdt_getprop_u32_default_node(fdt, off, 0, prop, dflt);
73	}	73	}
74		74
75	/**	75	/**
76	* fdt_find_and_setprop: Find a node and set it's property	76	* fdt_find_and_setprop: Find a node and set it's property
77	*	77	*
78	* @fdt: ptr to device tree	78	* @fdt: ptr to device tree
79	* @node: path of node	79	* @node: path of node
80	* @prop: property name	80	* @prop: property name
81	* @val: ptr to new value	81	* @val: ptr to new value
82	* @len: length of new property value	82	* @len: length of new property value
83	* @create: flag to create the property if it doesn't exist	83	* @create: flag to create the property if it doesn't exist
84	*	84	*
85	* Convenience function to directly set a property given the path to the node.	85	* Convenience function to directly set a property given the path to the node.
86	*/	86	*/
87	int fdt_find_and_setprop(void fdt, const char node, const char *prop,	87	int fdt_find_and_setprop(void fdt, const char node, const char *prop,
88	const void *val, int len, int create)	88	const void *val, int len, int create)
89	{	89	{
90	int nodeoff = fdt_path_offset(fdt, node);	90	int nodeoff = fdt_path_offset(fdt, node);
91		91
92	if (nodeoff < 0)	92	if (nodeoff < 0)
93	return nodeoff;	93	return nodeoff;
94		94
95	if ((!create) && (fdt_get_property(fdt, nodeoff, prop, NULL) == NULL))	95	if ((!create) && (fdt_get_property(fdt, nodeoff, prop, NULL) == NULL))
96	return 0; /* create flag not set; so exit quietly */	96	return 0; /* create flag not set; so exit quietly */
97		97
98	return fdt_setprop(fdt, nodeoff, prop, val, len);	98	return fdt_setprop(fdt, nodeoff, prop, val, len);
99	}	99	}
100		100
101	/**	101	/**
102	* fdt_find_or_add_subnode() - find or possibly add a subnode of a given node	102	* fdt_find_or_add_subnode() - find or possibly add a subnode of a given node
103	*	103	*
104	* @fdt: pointer to the device tree blob	104	* @fdt: pointer to the device tree blob
105	* @parentoffset: structure block offset of a node	105	* @parentoffset: structure block offset of a node
106	* @name: name of the subnode to locate	106	* @name: name of the subnode to locate
107	*	107	*
108	* fdt_subnode_offset() finds a subnode of the node with a given name.	108	* fdt_subnode_offset() finds a subnode of the node with a given name.
109	* If the subnode does not exist, it will be created.	109	* If the subnode does not exist, it will be created.
110	*/	110	*/
111	int fdt_find_or_add_subnode(void fdt, int parentoffset, const char name)	111	int fdt_find_or_add_subnode(void fdt, int parentoffset, const char name)
112	{	112	{
113	int offset;	113	int offset;
114		114
115	offset = fdt_subnode_offset(fdt, parentoffset, name);	115	offset = fdt_subnode_offset(fdt, parentoffset, name);
116		116
117	if (offset == -FDT_ERR_NOTFOUND)	117	if (offset == -FDT_ERR_NOTFOUND)
118	offset = fdt_add_subnode(fdt, parentoffset, name);	118	offset = fdt_add_subnode(fdt, parentoffset, name);
119		119
120	if (offset < 0)	120	if (offset < 0)
121	printf("%s: %s: %s\n", __func__, name, fdt_strerror(offset));	121	printf("%s: %s: %s\n", __func__, name, fdt_strerror(offset));
122		122
123	return offset;	123	return offset;
124	}	124	}
125		125
126	/* rename to CONFIG_OF_STDOUT_PATH ? */	126	/* rename to CONFIG_OF_STDOUT_PATH ? */
127	#if defined(OF_STDOUT_PATH)	127	#if defined(OF_STDOUT_PATH)
128	static int fdt_fixup_stdout(void *fdt, int chosenoff)	128	static int fdt_fixup_stdout(void *fdt, int chosenoff)
129	{	129	{
130	return fdt_setprop(fdt, chosenoff, "linux,stdout-path",	130	return fdt_setprop(fdt, chosenoff, "linux,stdout-path",
131	OF_STDOUT_PATH, strlen(OF_STDOUT_PATH) + 1);	131	OF_STDOUT_PATH, strlen(OF_STDOUT_PATH) + 1);
132	}	132	}
133	#elif defined(CONFIG_OF_STDOUT_VIA_ALIAS) && defined(CONFIG_CONS_INDEX)	133	#elif defined(CONFIG_OF_STDOUT_VIA_ALIAS) && defined(CONFIG_CONS_INDEX)
134	static int fdt_fixup_stdout(void *fdt, int chosenoff)	134	static int fdt_fixup_stdout(void *fdt, int chosenoff)
135	{	135	{
136	int err;	136	int err;
137	int aliasoff;	137	int aliasoff;
138	char sername[9] = { 0 };	138	char sername[9] = { 0 };
139	const void *path;	139	const void *path;
140	int len;	140	int len;
141	char tmp[256]; /* long enough */	141	char tmp[256]; /* long enough */
142		142
143	sprintf(sername, "serial%d", CONFIG_CONS_INDEX - 1);	143	sprintf(sername, "serial%d", CONFIG_CONS_INDEX - 1);
144		144
145	aliasoff = fdt_path_offset(fdt, "/aliases");	145	aliasoff = fdt_path_offset(fdt, "/aliases");
146	if (aliasoff < 0) {	146	if (aliasoff < 0) {
147	err = aliasoff;	147	err = aliasoff;
148	goto noalias;	148	goto noalias;
149	}	149	}
150		150
151	path = fdt_getprop(fdt, aliasoff, sername, &len);	151	path = fdt_getprop(fdt, aliasoff, sername, &len);
152	if (!path) {	152	if (!path) {
153	err = len;	153	err = len;
154	goto noalias;	154	goto noalias;
155	}	155	}
156		156
157	/* fdt_setprop may break "path" so we copy it to tmp buffer */	157	/* fdt_setprop may break "path" so we copy it to tmp buffer */
158	memcpy(tmp, path, len);	158	memcpy(tmp, path, len);
159		159
160	err = fdt_setprop(fdt, chosenoff, "linux,stdout-path", tmp, len);	160	err = fdt_setprop(fdt, chosenoff, "linux,stdout-path", tmp, len);
161	if (err < 0)	161	if (err < 0)
162	printf("WARNING: could not set linux,stdout-path %s.\n",	162	printf("WARNING: could not set linux,stdout-path %s.\n",
163	fdt_strerror(err));	163	fdt_strerror(err));
164		164
165	return err;	165	return err;
166		166
167	noalias:	167	noalias:
168	printf("WARNING: %s: could not read %s alias: %s\n",	168	printf("WARNING: %s: could not read %s alias: %s\n",
169	__func__, sername, fdt_strerror(err));	169	__func__, sername, fdt_strerror(err));
170		170
171	return 0;	171	return 0;
172	}	172	}
173	#else	173	#else
174	static int fdt_fixup_stdout(void *fdt, int chosenoff)	174	static int fdt_fixup_stdout(void *fdt, int chosenoff)
175	{	175	{
176	return 0;	176	return 0;
177	}	177	}
178	#endif	178	#endif
179		179
180	static inline int fdt_setprop_uxx(void fdt, int nodeoffset, const char name,	180	static inline int fdt_setprop_uxx(void fdt, int nodeoffset, const char name,
181	uint64_t val, int is_u64)	181	uint64_t val, int is_u64)
182	{	182	{
183	if (is_u64)	183	if (is_u64)
184	return fdt_setprop_u64(fdt, nodeoffset, name, val);	184	return fdt_setprop_u64(fdt, nodeoffset, name, val);
185	else	185	else
186	return fdt_setprop_u32(fdt, nodeoffset, name, (uint32_t)val);	186	return fdt_setprop_u32(fdt, nodeoffset, name, (uint32_t)val);
187	}	187	}
188		188
189	int fdt_root(void *fdt)	189	int fdt_root(void *fdt)
190	{	190	{
191	char *serial;	191	char *serial;
192	int err;	192	int err;
193		193
194	err = fdt_check_header(fdt);	194	err = fdt_check_header(fdt);
195	if (err < 0) {	195	if (err < 0) {
196	printf("fdt_root: %s\n", fdt_strerror(err));	196	printf("fdt_root: %s\n", fdt_strerror(err));
197	return err;	197	return err;
198	}	198	}
199		199
200	serial = getenv("serial#");	200	serial = getenv("serial#");
201	if (serial) {	201	if (serial) {
202	err = fdt_setprop(fdt, 0, "serial-number", serial,	202	err = fdt_setprop(fdt, 0, "serial-number", serial,
203	strlen(serial) + 1);	203	strlen(serial) + 1);
204		204
205	if (err < 0) {	205	if (err < 0) {
206	printf("WARNING: could not set serial-number %s.\n",	206	printf("WARNING: could not set serial-number %s.\n",
207	fdt_strerror(err));	207	fdt_strerror(err));
208	return err;	208	return err;
209	}	209	}
210	}	210	}
211		211
212	return 0;	212	return 0;
213	}	213	}
214		214
215	int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end)	215	int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end)
216	{	216	{
217	int nodeoffset;	217	int nodeoffset;
218	int err, j, total;	218	int err, j, total;
219	int is_u64;	219	int is_u64;
220	uint64_t addr, size;	220	uint64_t addr, size;
221		221
222	/* just return if the size of initrd is zero */	222	/* just return if the size of initrd is zero */
223	if (initrd_start == initrd_end)	223	if (initrd_start == initrd_end)
224	return 0;	224	return 0;
225		225
226	/* find or create "/chosen" node. */	226	/* find or create "/chosen" node. */
227	nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");	227	nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");
228	if (nodeoffset < 0)	228	if (nodeoffset < 0)
229	return nodeoffset;	229	return nodeoffset;
230		230
231	total = fdt_num_mem_rsv(fdt);	231	total = fdt_num_mem_rsv(fdt);
232		232
233	/*	233	/*
234	* Look for an existing entry and update it. If we don't find	234	* Look for an existing entry and update it. If we don't find
235	* the entry, we will j be the next available slot.	235	* the entry, we will j be the next available slot.
236	*/	236	*/
237	for (j = 0; j < total; j++) {	237	for (j = 0; j < total; j++) {
238	err = fdt_get_mem_rsv(fdt, j, &addr, &size);	238	err = fdt_get_mem_rsv(fdt, j, &addr, &size);
239	if (addr == initrd_start) {	239	if (addr == initrd_start) {
240	fdt_del_mem_rsv(fdt, j);	240	fdt_del_mem_rsv(fdt, j);
241	break;	241	break;
242	}	242	}
243	}	243	}
244		244
245	err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start);	245	err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start);
246	if (err < 0) {	246	if (err < 0) {
247	printf("fdt_initrd: %s\n", fdt_strerror(err));	247	printf("fdt_initrd: %s\n", fdt_strerror(err));
248	return err;	248	return err;
249	}	249	}
250		250
251	is_u64 = (fdt_address_cells(fdt, 0) == 2);	251	is_u64 = (fdt_address_cells(fdt, 0) == 2);
252		252
253	err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-start",	253	err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-start",
254	(uint64_t)initrd_start, is_u64);	254	(uint64_t)initrd_start, is_u64);
255		255
256	if (err < 0) {	256	if (err < 0) {
257	printf("WARNING: could not set linux,initrd-start %s.\n",	257	printf("WARNING: could not set linux,initrd-start %s.\n",
258	fdt_strerror(err));	258	fdt_strerror(err));
259	return err;	259	return err;
260	}	260	}
261		261
262	err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-end",	262	err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-end",
263	(uint64_t)initrd_end, is_u64);	263	(uint64_t)initrd_end, is_u64);
264		264
265	if (err < 0) {	265	if (err < 0) {
266	printf("WARNING: could not set linux,initrd-end %s.\n",	266	printf("WARNING: could not set linux,initrd-end %s.\n",
267	fdt_strerror(err));	267	fdt_strerror(err));
268		268
269	return err;	269	return err;
270	}	270	}
271		271
272	return 0;	272	return 0;
273	}	273	}
274		274
275	int fdt_chosen(void *fdt)	275	int fdt_chosen(void *fdt)
276	{	276	{
277	int nodeoffset;	277	int nodeoffset;
278	int err;	278	int err;
279	char str; / used to set string properties */	279	char str; / used to set string properties */
280		280
281	err = fdt_check_header(fdt);	281	err = fdt_check_header(fdt);
282	if (err < 0) {	282	if (err < 0) {
283	printf("fdt_chosen: %s\n", fdt_strerror(err));	283	printf("fdt_chosen: %s\n", fdt_strerror(err));
284	return err;	284	return err;
285	}	285	}
286		286
287	/* find or create "/chosen" node. */	287	/* find or create "/chosen" node. */
288	nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");	288	nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");
289	if (nodeoffset < 0)	289	if (nodeoffset < 0)
290	return nodeoffset;	290	return nodeoffset;
291		291
292	str = getenv("bootargs");	292	str = getenv("bootargs");
293	if (str) {	293	if (str) {
294	err = fdt_setprop(fdt, nodeoffset, "bootargs", str,	294	err = fdt_setprop(fdt, nodeoffset, "bootargs", str,
295	strlen(str) + 1);	295	strlen(str) + 1);
296	if (err < 0) {	296	if (err < 0) {
297	printf("WARNING: could not set bootargs %s.\n",	297	printf("WARNING: could not set bootargs %s.\n",
298	fdt_strerror(err));	298	fdt_strerror(err));
299	return err;	299	return err;
300	}	300	}
301	}	301	}
302		302
303	return fdt_fixup_stdout(fdt, nodeoffset);	303	return fdt_fixup_stdout(fdt, nodeoffset);
304	}	304	}
305		305
306	void do_fixup_by_path(void fdt, const char path, const char *prop,	306	void do_fixup_by_path(void fdt, const char path, const char *prop,
307	const void *val, int len, int create)	307	const void *val, int len, int create)
308	{	308	{
309	#if defined(DEBUG)	309	#if defined(DEBUG)
310	int i;	310	int i;
311	debug("Updating property '%s/%s' = ", path, prop);	311	debug("Updating property '%s/%s' = ", path, prop);
312	for (i = 0; i < len; i++)	312	for (i = 0; i < len; i++)
313	debug(" %.2x", (u8)(val+i));	313	debug(" %.2x", (u8)(val+i));
314	debug("\n");	314	debug("\n");
315	#endif	315	#endif
316	int rc = fdt_find_and_setprop(fdt, path, prop, val, len, create);	316	int rc = fdt_find_and_setprop(fdt, path, prop, val, len, create);
317	if (rc)	317	if (rc)
318	printf("Unable to update property %s:%s, err=%s\n",	318	printf("Unable to update property %s:%s, err=%s\n",
319	path, prop, fdt_strerror(rc));	319	path, prop, fdt_strerror(rc));
320	}	320	}
321		321
322	void do_fixup_by_path_u32(void fdt, const char path, const char *prop,	322	void do_fixup_by_path_u32(void fdt, const char path, const char *prop,
323	u32 val, int create)	323	u32 val, int create)
324	{	324	{
325	fdt32_t tmp = cpu_to_fdt32(val);	325	fdt32_t tmp = cpu_to_fdt32(val);
326	do_fixup_by_path(fdt, path, prop, &tmp, sizeof(tmp), create);	326	do_fixup_by_path(fdt, path, prop, &tmp, sizeof(tmp), create);
327	}	327	}
328		328
329	void do_fixup_by_prop(void *fdt,	329	void do_fixup_by_prop(void *fdt,
330	const char pname, const void pval, int plen,	330	const char pname, const void pval, int plen,
331	const char prop, const void val, int len,	331	const char prop, const void val, int len,
332	int create)	332	int create)
333	{	333	{
334	int off;	334	int off;
335	#if defined(DEBUG)	335	#if defined(DEBUG)
336	int i;	336	int i;
337	debug("Updating property '%s' = ", prop);	337	debug("Updating property '%s' = ", prop);
338	for (i = 0; i < len; i++)	338	for (i = 0; i < len; i++)
339	debug(" %.2x", (u8)(val+i));	339	debug(" %.2x", (u8)(val+i));
340	debug("\n");	340	debug("\n");
341	#endif	341	#endif
342	off = fdt_node_offset_by_prop_value(fdt, -1, pname, pval, plen);	342	off = fdt_node_offset_by_prop_value(fdt, -1, pname, pval, plen);
343	while (off != -FDT_ERR_NOTFOUND) {	343	while (off != -FDT_ERR_NOTFOUND) {
344	if (create \|\| (fdt_get_property(fdt, off, prop, NULL) != NULL))	344	if (create \|\| (fdt_get_property(fdt, off, prop, NULL) != NULL))
345	fdt_setprop(fdt, off, prop, val, len);	345	fdt_setprop(fdt, off, prop, val, len);
346	off = fdt_node_offset_by_prop_value(fdt, off, pname, pval, plen);	346	off = fdt_node_offset_by_prop_value(fdt, off, pname, pval, plen);
347	}	347	}
348	}	348	}
349		349
350	void do_fixup_by_prop_u32(void *fdt,	350	void do_fixup_by_prop_u32(void *fdt,
351	const char pname, const void pval, int plen,	351	const char pname, const void pval, int plen,
352	const char *prop, u32 val, int create)	352	const char *prop, u32 val, int create)
353	{	353	{
354	fdt32_t tmp = cpu_to_fdt32(val);	354	fdt32_t tmp = cpu_to_fdt32(val);
355	do_fixup_by_prop(fdt, pname, pval, plen, prop, &tmp, 4, create);	355	do_fixup_by_prop(fdt, pname, pval, plen, prop, &tmp, 4, create);
356	}	356	}
357		357
358	void do_fixup_by_compat(void fdt, const char compat,	358	void do_fixup_by_compat(void fdt, const char compat,
359	const char prop, const void val, int len, int create)	359	const char prop, const void val, int len, int create)
360	{	360	{
361	int off = -1;	361	int off = -1;
362	#if defined(DEBUG)	362	#if defined(DEBUG)
363	int i;	363	int i;
364	debug("Updating property '%s' = ", prop);	364	debug("Updating property '%s' = ", prop);
365	for (i = 0; i < len; i++)	365	for (i = 0; i < len; i++)
366	debug(" %.2x", (u8)(val+i));	366	debug(" %.2x", (u8)(val+i));
367	debug("\n");	367	debug("\n");
368	#endif	368	#endif
369	off = fdt_node_offset_by_compatible(fdt, -1, compat);	369	off = fdt_node_offset_by_compatible(fdt, -1, compat);
370	while (off != -FDT_ERR_NOTFOUND) {	370	while (off != -FDT_ERR_NOTFOUND) {
371	if (create \|\| (fdt_get_property(fdt, off, prop, NULL) != NULL))	371	if (create \|\| (fdt_get_property(fdt, off, prop, NULL) != NULL))
372	fdt_setprop(fdt, off, prop, val, len);	372	fdt_setprop(fdt, off, prop, val, len);
373	off = fdt_node_offset_by_compatible(fdt, off, compat);	373	off = fdt_node_offset_by_compatible(fdt, off, compat);
374	}	374	}
375	}	375	}
376		376
377	void do_fixup_by_compat_u32(void fdt, const char compat,	377	void do_fixup_by_compat_u32(void fdt, const char compat,
378	const char *prop, u32 val, int create)	378	const char *prop, u32 val, int create)
379	{	379	{
380	fdt32_t tmp = cpu_to_fdt32(val);	380	fdt32_t tmp = cpu_to_fdt32(val);
381	do_fixup_by_compat(fdt, compat, prop, &tmp, 4, create);	381	do_fixup_by_compat(fdt, compat, prop, &tmp, 4, create);
382	}	382	}
383		383
384	#ifdef CONFIG_ARCH_FIXUP_FDT_MEMORY	384	#ifdef CONFIG_ARCH_FIXUP_FDT_MEMORY
385	/*	385	/*
386	* fdt_pack_reg - pack address and size array into the "reg"-suitable stream	386	* fdt_pack_reg - pack address and size array into the "reg"-suitable stream
387	*/	387	*/
388	static int fdt_pack_reg(const void fdt, void buf, u64 address, u64 size,	388	static int fdt_pack_reg(const void fdt, void buf, u64 address, u64 size,
389	int n)	389	int n)
390	{	390	{
391	int i;	391	int i;
392	int address_cells = fdt_address_cells(fdt, 0);	392	int address_cells = fdt_address_cells(fdt, 0);
393	int size_cells = fdt_size_cells(fdt, 0);	393	int size_cells = fdt_size_cells(fdt, 0);
394	char *p = buf;	394	char *p = buf;
395		395
396	for (i = 0; i < n; i++) {	396	for (i = 0; i < n; i++) {
397	if (address_cells == 2)	397	if (address_cells == 2)
398	(fdt64_t )p = cpu_to_fdt64(address[i]);	398	(fdt64_t )p = cpu_to_fdt64(address[i]);
399	else	399	else
400	(fdt32_t )p = cpu_to_fdt32(address[i]);	400	(fdt32_t )p = cpu_to_fdt32(address[i]);
401	p += 4 * address_cells;	401	p += 4 * address_cells;
402		402
403	if (size_cells == 2)	403	if (size_cells == 2)
404	(fdt64_t )p = cpu_to_fdt64(size[i]);	404	(fdt64_t )p = cpu_to_fdt64(size[i]);
405	else	405	else
406	(fdt32_t )p = cpu_to_fdt32(size[i]);	406	(fdt32_t )p = cpu_to_fdt32(size[i]);
407	p += 4 * size_cells;	407	p += 4 * size_cells;
408	}	408	}
409		409
410	return p - (char *)buf;	410	return p - (char *)buf;
411	}	411	}
412		412
413	#ifdef CONFIG_NR_DRAM_BANKS	413	#ifdef CONFIG_NR_DRAM_BANKS
414	#define MEMORY_BANKS_MAX CONFIG_NR_DRAM_BANKS	414	#define MEMORY_BANKS_MAX CONFIG_NR_DRAM_BANKS
415	#else	415	#else
416	#define MEMORY_BANKS_MAX 4	416	#define MEMORY_BANKS_MAX 4
417	#endif	417	#endif
418	int fdt_fixup_memory_banks(void *blob, u64 start[], u64 size[], int banks)	418	int fdt_fixup_memory_banks(void *blob, u64 start[], u64 size[], int banks)
419	{	419	{
420	int err, nodeoffset;	420	int err, nodeoffset;
421	int len;	421	int len;
422	u8 tmp[MEMORY_BANKS_MAX * 16]; /* Up to 64-bit address + 64-bit size */	422	u8 tmp[MEMORY_BANKS_MAX * 16]; /* Up to 64-bit address + 64-bit size */
423		423
424	if (banks > MEMORY_BANKS_MAX) {	424	if (banks > MEMORY_BANKS_MAX) {
425	printf("%s: num banks %d exceeds hardcoded limit %d."	425	printf("%s: num banks %d exceeds hardcoded limit %d."
426	" Recompile with higher MEMORY_BANKS_MAX?\n",	426	" Recompile with higher MEMORY_BANKS_MAX?\n",
427	__FUNCTION__, banks, MEMORY_BANKS_MAX);	427	__FUNCTION__, banks, MEMORY_BANKS_MAX);
428	return -1;	428	return -1;
429	}	429	}
430		430
431	err = fdt_check_header(blob);	431	err = fdt_check_header(blob);
432	if (err < 0) {	432	if (err < 0) {
433	printf("%s: %s\n", __FUNCTION__, fdt_strerror(err));	433	printf("%s: %s\n", __FUNCTION__, fdt_strerror(err));
434	return err;	434	return err;
435	}	435	}
436		436
437	/* find or create "/memory" node. */	437	/* find or create "/memory" node. */
438	nodeoffset = fdt_find_or_add_subnode(blob, 0, "memory");	438	nodeoffset = fdt_find_or_add_subnode(blob, 0, "memory");
439	if (nodeoffset < 0)	439	if (nodeoffset < 0)
440	return nodeoffset;	440	return nodeoffset;
441		441
442	err = fdt_setprop(blob, nodeoffset, "device_type", "memory",	442	err = fdt_setprop(blob, nodeoffset, "device_type", "memory",
443	sizeof("memory"));	443	sizeof("memory"));
444	if (err < 0) {	444	if (err < 0) {
445	printf("WARNING: could not set %s %s.\n", "device_type",	445	printf("WARNING: could not set %s %s.\n", "device_type",
446	fdt_strerror(err));	446	fdt_strerror(err));
447	return err;	447	return err;
448	}	448	}
449		449
450	if (!banks)	450	if (!banks)
451	return 0;	451	return 0;
452		452
453	len = fdt_pack_reg(blob, tmp, start, size, banks);	453	len = fdt_pack_reg(blob, tmp, start, size, banks);
454		454
455	err = fdt_setprop(blob, nodeoffset, "reg", tmp, len);	455	err = fdt_setprop(blob, nodeoffset, "reg", tmp, len);
456	if (err < 0) {	456	if (err < 0) {
457	printf("WARNING: could not set %s %s.\n",	457	printf("WARNING: could not set %s %s.\n",
458	"reg", fdt_strerror(err));	458	"reg", fdt_strerror(err));
459	return err;	459	return err;
460	}	460	}
461	return 0;	461	return 0;
462	}	462	}
463	#endif	463	#endif
464		464
465	int fdt_fixup_memory(void *blob, u64 start, u64 size)	465	int fdt_fixup_memory(void *blob, u64 start, u64 size)
466	{	466	{
467	return fdt_fixup_memory_banks(blob, &start, &size, 1);	467	return fdt_fixup_memory_banks(blob, &start, &size, 1);
468	}	468	}
469		469
470	void fdt_fixup_ethernet(void *fdt)	470	void fdt_fixup_ethernet(void *fdt)
471	{	471	{
472	int i, j, prop;	472	int i, j, prop;
473	char tmp, end;	473	char tmp, end;
474	char mac[16];	474	char mac[16];
475	const char *path;	475	const char *path;
476	unsigned char mac_addr[ARP_HLEN];	476	unsigned char mac_addr[ARP_HLEN];
477	int offset;	477	int offset;
478		478
479	if (fdt_path_offset(fdt, "/aliases") < 0)	479	if (fdt_path_offset(fdt, "/aliases") < 0)
480	return;	480	return;
481		481
482	/* Cycle through all aliases */	482	/* Cycle through all aliases */
483	for (prop = 0; ; prop++) {	483	for (prop = 0; ; prop++) {
484	const char *name;	484	const char *name;
485		485
486	/* FDT might have been edited, recompute the offset */	486	/* FDT might have been edited, recompute the offset */
487	offset = fdt_first_property_offset(fdt,	487	offset = fdt_first_property_offset(fdt,
488	fdt_path_offset(fdt, "/aliases"));	488	fdt_path_offset(fdt, "/aliases"));
489	/* Select property number 'prop' */	489	/* Select property number 'prop' */
490	for (i = 0; i < prop; i++)	490	for (i = 0; i < prop; i++)
491	offset = fdt_next_property_offset(fdt, offset);	491	offset = fdt_next_property_offset(fdt, offset);
492		492
493	if (offset < 0)	493	if (offset < 0)
494	break;	494	break;
495		495
496	path = fdt_getprop_by_offset(fdt, offset, &name, NULL);	496	path = fdt_getprop_by_offset(fdt, offset, &name, NULL);
497	if (!strncmp(name, "ethernet", 8)) {	497	if (!strncmp(name, "ethernet", 8)) {
498	/* Treat plain "ethernet" same as "ethernet0". */	498	/* Treat plain "ethernet" same as "ethernet0". */
499	if (!strcmp(name, "ethernet"))	499	if (!strcmp(name, "ethernet"))
500	i = 0;	500	i = 0;
501	else	501	else
502	i = trailing_strtol(name);	502	i = trailing_strtol(name);
503		503
504	if (i != -1) {	504	if (i != -1) {
505	if (i == 0)	505	if (i == 0)
506	strcpy(mac, "ethaddr");	506	strcpy(mac, "ethaddr");
507	else	507	else
508	sprintf(mac, "eth%daddr", i);	508	sprintf(mac, "eth%daddr", i);
509	} else {	509	} else {
510	continue;	510	continue;
511	}	511	}
512	tmp = getenv(mac);	512	tmp = getenv(mac);
513	if (!tmp)	513	if (!tmp)
514	continue;	514	continue;
515		515
516	for (j = 0; j < 6; j++) {	516	for (j = 0; j < 6; j++) {
517	mac_addr[j] = tmp ?	517	mac_addr[j] = tmp ?
518	simple_strtoul(tmp, &end, 16) : 0;	518	simple_strtoul(tmp, &end, 16) : 0;
519	if (tmp)	519	if (tmp)
520	tmp = (*end) ? end + 1 : end;	520	tmp = (*end) ? end + 1 : end;
521	}	521	}
522		522
523	do_fixup_by_path(fdt, path, "mac-address",	523	do_fixup_by_path(fdt, path, "mac-address",
524	&mac_addr, 6, 0);	524	&mac_addr, 6, 0);
525	do_fixup_by_path(fdt, path, "local-mac-address",	525	do_fixup_by_path(fdt, path, "local-mac-address",
526	&mac_addr, 6, 1);	526	&mac_addr, 6, 1);
527	}	527	}
528	}	528	}
529	}	529	}
530		530
531	/* Resize the fdt to its actual size + a bit of padding */	531	/* Resize the fdt to its actual size + a bit of padding */
532	int fdt_shrink_to_minimum(void *blob, uint extrasize)	532	int fdt_shrink_to_minimum(void *blob, uint extrasize)
533	{	533	{
534	int i;	534	int i;
535	uint64_t addr, size;	535	uint64_t addr, size;
536	int total, ret;	536	int total, ret;
537	uint actualsize;	537	uint actualsize;
538		538
539	if (!blob)	539	if (!blob)
540	return 0;	540	return 0;
541		541
542	total = fdt_num_mem_rsv(blob);	542	total = fdt_num_mem_rsv(blob);
543	for (i = 0; i < total; i++) {	543	for (i = 0; i < total; i++) {
544	fdt_get_mem_rsv(blob, i, &addr, &size);	544	fdt_get_mem_rsv(blob, i, &addr, &size);
545	if (addr == (uintptr_t)blob) {	545	if (addr == (uintptr_t)blob) {
546	fdt_del_mem_rsv(blob, i);	546	fdt_del_mem_rsv(blob, i);
547	break;	547	break;
548	}	548	}
549	}	549	}
550		550
551	/*	551	/*
552	* Calculate the actual size of the fdt	552	* Calculate the actual size of the fdt
553	* plus the size needed for 5 fdt_add_mem_rsv, one	553	* plus the size needed for 5 fdt_add_mem_rsv, one
554	* for the fdt itself and 4 for a possible initrd	554	* for the fdt itself and 4 for a possible initrd
555	* ((initrd-start + initrd-end) * 2 (name & value))	555	* ((initrd-start + initrd-end) * 2 (name & value))
556	*/	556	*/
557	actualsize = fdt_off_dt_strings(blob) +	557	actualsize = fdt_off_dt_strings(blob) +
558	fdt_size_dt_strings(blob) + 5 * sizeof(struct fdt_reserve_entry);	558	fdt_size_dt_strings(blob) + 5 * sizeof(struct fdt_reserve_entry);
559		559
560	actualsize += extrasize;	560	actualsize += extrasize;
561	/* Make it so the fdt ends on a page boundary */	561	/* Make it so the fdt ends on a page boundary */
562	actualsize = ALIGN(actualsize + ((uintptr_t)blob & 0xfff), 0x1000);	562	actualsize = ALIGN(actualsize + ((uintptr_t)blob & 0xfff), 0x1000);
563	actualsize = actualsize - ((uintptr_t)blob & 0xfff);	563	actualsize = actualsize - ((uintptr_t)blob & 0xfff);
564		564
565	/* Change the fdt header to reflect the correct size */	565	/* Change the fdt header to reflect the correct size */
566	fdt_set_totalsize(blob, actualsize);	566	fdt_set_totalsize(blob, actualsize);
567		567
568	/* Add the new reservation */	568	/* Add the new reservation */
569	ret = fdt_add_mem_rsv(blob, (uintptr_t)blob, actualsize);	569	ret = fdt_add_mem_rsv(blob, (uintptr_t)blob, actualsize);
570	if (ret < 0)	570	if (ret < 0)
571	return ret;	571	return ret;
572		572
573	return actualsize;	573	return actualsize;
574	}	574	}
575		575
576	#ifdef CONFIG_PCI	576	#ifdef CONFIG_PCI
577	#define CONFIG_SYS_PCI_NR_INBOUND_WIN 4	577	#define CONFIG_SYS_PCI_NR_INBOUND_WIN 4
578		578
579	#define FDT_PCI_PREFETCH (0x40000000)	579	#define FDT_PCI_PREFETCH (0x40000000)
580	#define FDT_PCI_MEM32 (0x02000000)	580	#define FDT_PCI_MEM32 (0x02000000)
581	#define FDT_PCI_IO (0x01000000)	581	#define FDT_PCI_IO (0x01000000)
582	#define FDT_PCI_MEM64 (0x03000000)	582	#define FDT_PCI_MEM64 (0x03000000)
583		583
584	int fdt_pci_dma_ranges(void blob, int phb_off, struct pci_controller hose) {	584	int fdt_pci_dma_ranges(void blob, int phb_off, struct pci_controller hose) {
585		585
586	int addrcell, sizecell, len, r;	586	int addrcell, sizecell, len, r;
587	u32 *dma_range;	587	u32 *dma_range;
588	/* sized based on pci addr cells, size-cells, & address-cells */	588	/* sized based on pci addr cells, size-cells, & address-cells */
589	u32 dma_ranges[(3 + 2 + 2) * CONFIG_SYS_PCI_NR_INBOUND_WIN];	589	u32 dma_ranges[(3 + 2 + 2) * CONFIG_SYS_PCI_NR_INBOUND_WIN];
590		590
591	addrcell = fdt_getprop_u32_default(blob, "/", "#address-cells", 1);	591	addrcell = fdt_getprop_u32_default(blob, "/", "#address-cells", 1);
592	sizecell = fdt_getprop_u32_default(blob, "/", "#size-cells", 1);	592	sizecell = fdt_getprop_u32_default(blob, "/", "#size-cells", 1);
593		593
594	dma_range = &dma_ranges[0];	594	dma_range = &dma_ranges[0];
595	for (r = 0; r < hose->region_count; r++) {	595	for (r = 0; r < hose->region_count; r++) {
596	u64 bus_start, phys_start, size;	596	u64 bus_start, phys_start, size;
597		597
598	/* skip if !PCI_REGION_SYS_MEMORY */	598	/* skip if !PCI_REGION_SYS_MEMORY */
599	if (!(hose->regions[r].flags & PCI_REGION_SYS_MEMORY))	599	if (!(hose->regions[r].flags & PCI_REGION_SYS_MEMORY))
600	continue;	600	continue;
601		601
602	bus_start = (u64)hose->regions[r].bus_start;	602	bus_start = (u64)hose->regions[r].bus_start;
603	phys_start = (u64)hose->regions[r].phys_start;	603	phys_start = (u64)hose->regions[r].phys_start;
604	size = (u64)hose->regions[r].size;	604	size = (u64)hose->regions[r].size;
605		605
606	dma_range[0] = 0;	606	dma_range[0] = 0;
607	if (size >= 0x100000000ull)	607	if (size >= 0x100000000ull)
608	dma_range[0] \|= FDT_PCI_MEM64;	608	dma_range[0] \|= FDT_PCI_MEM64;
609	else	609	else
610	dma_range[0] \|= FDT_PCI_MEM32;	610	dma_range[0] \|= FDT_PCI_MEM32;
611	if (hose->regions[r].flags & PCI_REGION_PREFETCH)	611	if (hose->regions[r].flags & PCI_REGION_PREFETCH)
612	dma_range[0] \|= FDT_PCI_PREFETCH;	612	dma_range[0] \|= FDT_PCI_PREFETCH;
613	#ifdef CONFIG_SYS_PCI_64BIT	613	#ifdef CONFIG_SYS_PCI_64BIT
614	dma_range[1] = bus_start >> 32;	614	dma_range[1] = bus_start >> 32;
615	#else	615	#else
616	dma_range[1] = 0;	616	dma_range[1] = 0;
617	#endif	617	#endif
618	dma_range[2] = bus_start & 0xffffffff;	618	dma_range[2] = bus_start & 0xffffffff;
619		619
620	if (addrcell == 2) {	620	if (addrcell == 2) {
621	dma_range[3] = phys_start >> 32;	621	dma_range[3] = phys_start >> 32;
622	dma_range[4] = phys_start & 0xffffffff;	622	dma_range[4] = phys_start & 0xffffffff;
623	} else {	623	} else {
624	dma_range[3] = phys_start & 0xffffffff;	624	dma_range[3] = phys_start & 0xffffffff;
625	}	625	}
626		626
627	if (sizecell == 2) {	627	if (sizecell == 2) {
628	dma_range[3 + addrcell + 0] = size >> 32;	628	dma_range[3 + addrcell + 0] = size >> 32;
629	dma_range[3 + addrcell + 1] = size & 0xffffffff;	629	dma_range[3 + addrcell + 1] = size & 0xffffffff;
630	} else {	630	} else {
631	dma_range[3 + addrcell + 0] = size & 0xffffffff;	631	dma_range[3 + addrcell + 0] = size & 0xffffffff;
632	}	632	}
633		633
634	dma_range += (3 + addrcell + sizecell);	634	dma_range += (3 + addrcell + sizecell);
635	}	635	}
636		636
637	len = dma_range - &dma_ranges[0];	637	len = dma_range - &dma_ranges[0];
638	if (len)	638	if (len)
639	fdt_setprop(blob, phb_off, "dma-ranges", &dma_ranges[0], len*4);	639	fdt_setprop(blob, phb_off, "dma-ranges", &dma_ranges[0], len*4);
640		640
641	return 0;	641	return 0;
642	}	642	}
643	#endif	643	#endif
644		644
645	#ifdef CONFIG_FDT_FIXUP_NOR_FLASH_SIZE	645	#ifdef CONFIG_FDT_FIXUP_NOR_FLASH_SIZE
646	/*	646	/*
647	* Provide a weak default function to return the flash bank size.	647	* Provide a weak default function to return the flash bank size.
648	* There might be multiple non-identical flash chips connected to one	648	* There might be multiple non-identical flash chips connected to one
649	* chip-select, so we need to pass an index as well.	649	* chip-select, so we need to pass an index as well.
650	*/	650	*/
651	u32 __flash_get_bank_size(int cs, int idx)	651	u32 __flash_get_bank_size(int cs, int idx)
652	{	652	{
653	extern flash_info_t flash_info[];	653	extern flash_info_t flash_info[];
654		654
655	/*	655	/*
656	* As default, a simple 1:1 mapping is provided. Boards with	656	* As default, a simple 1:1 mapping is provided. Boards with
657	* a different mapping need to supply a board specific mapping	657	* a different mapping need to supply a board specific mapping
658	* routine.	658	* routine.
659	*/	659	*/
660	return flash_info[cs].size;	660	return flash_info[cs].size;
661	}	661	}
662	u32 flash_get_bank_size(int cs, int idx)	662	u32 flash_get_bank_size(int cs, int idx)
663	__attribute__((weak, alias("__flash_get_bank_size")));	663	__attribute__((weak, alias("__flash_get_bank_size")));
664		664
665	/*	665	/*
666	* This function can be used to update the size in the "reg" property	666	* This function can be used to update the size in the "reg" property
667	* of all NOR FLASH device nodes. This is necessary for boards with	667	* of all NOR FLASH device nodes. This is necessary for boards with
668	* non-fixed NOR FLASH sizes.	668	* non-fixed NOR FLASH sizes.
669	*/	669	*/
670	int fdt_fixup_nor_flash_size(void *blob)	670	int fdt_fixup_nor_flash_size(void *blob)
671	{	671	{
672	char compat[][16] = { "cfi-flash", "jedec-flash" };	672	char compat[][16] = { "cfi-flash", "jedec-flash" };
673	int off;	673	int off;
674	int len;	674	int len;
675	struct fdt_property *prop;	675	struct fdt_property *prop;
676	u32 reg, reg2;	676	u32 reg, reg2;
677	int i;	677	int i;
678		678
679	for (i = 0; i < 2; i++) {	679	for (i = 0; i < 2; i++) {
680	off = fdt_node_offset_by_compatible(blob, -1, compat[i]);	680	off = fdt_node_offset_by_compatible(blob, -1, compat[i]);
681	while (off != -FDT_ERR_NOTFOUND) {	681	while (off != -FDT_ERR_NOTFOUND) {
682	int idx;	682	int idx;
683		683
684	/*	684	/*
685	* Found one compatible node, so fixup the size	685	* Found one compatible node, so fixup the size
686	* int its reg properties	686	* int its reg properties
687	*/	687	*/
688	prop = fdt_get_property_w(blob, off, "reg", &len);	688	prop = fdt_get_property_w(blob, off, "reg", &len);
689	if (prop) {	689	if (prop) {
690	int tuple_size = 3 * sizeof(reg);	690	int tuple_size = 3 * sizeof(reg);
691		691
692	/*	692	/*
693	* There might be multiple reg-tuples,	693	* There might be multiple reg-tuples,
694	* so loop through them all	694	* so loop through them all
695	*/	695	*/
696	reg = reg2 = (u32 *)&prop->data[0];	696	reg = reg2 = (u32 *)&prop->data[0];
697	for (idx = 0; idx < (len / tuple_size); idx++) {	697	for (idx = 0; idx < (len / tuple_size); idx++) {
698	/*	698	/*
699	* Update size in reg property	699	* Update size in reg property
700	*/	700	*/
701	reg[2] = flash_get_bank_size(reg[0],	701	reg[2] = flash_get_bank_size(reg[0],
702	idx);	702	idx);
703		703
704	/*	704	/*
705	* Point to next reg tuple	705	* Point to next reg tuple
706	*/	706	*/
707	reg += 3;	707	reg += 3;
708	}	708	}
709		709
710	fdt_setprop(blob, off, "reg", reg2, len);	710	fdt_setprop(blob, off, "reg", reg2, len);
711	}	711	}
712		712
713	/* Move to next compatible node */	713	/* Move to next compatible node */
714	off = fdt_node_offset_by_compatible(blob, off,	714	off = fdt_node_offset_by_compatible(blob, off,
715	compat[i]);	715	compat[i]);
716	}	716	}
717	}	717	}
718		718
719	return 0;	719	return 0;
720	}	720	}
721	#endif	721	#endif
722		722
723	int fdt_increase_size(void *fdt, int add_len)	723	int fdt_increase_size(void *fdt, int add_len)
724	{	724	{
725	int newlen;	725	int newlen;
726		726
727	newlen = fdt_totalsize(fdt) + add_len;	727	newlen = fdt_totalsize(fdt) + add_len;
728		728
729	/* Open in place with a new len */	729	/* Open in place with a new len */
730	return fdt_open_into(fdt, fdt, newlen);	730	return fdt_open_into(fdt, fdt, newlen);
731	}	731	}
732		732
733	#ifdef CONFIG_FDT_FIXUP_PARTITIONS	733	#ifdef CONFIG_FDT_FIXUP_PARTITIONS
734	#include <jffs2/load_kernel.h>	734	#include <jffs2/load_kernel.h>
735	#include <mtd_node.h>	735	#include <mtd_node.h>
736		736
737	struct reg_cell {	737	struct reg_cell {
738	unsigned int r0;	738	unsigned int r0;
739	unsigned int r1;	739	unsigned int r1;
740	};	740	};
741		741
742	int fdt_del_subnodes(const void *blob, int parent_offset)	742	int fdt_del_subnodes(const void *blob, int parent_offset)
743	{	743	{
744	int off, ndepth;	744	int off, ndepth;
745	int ret;	745	int ret;
746		746
747	for (ndepth = 0, off = fdt_next_node(blob, parent_offset, &ndepth);	747	for (ndepth = 0, off = fdt_next_node(blob, parent_offset, &ndepth);
748	(off >= 0) && (ndepth > 0);	748	(off >= 0) && (ndepth > 0);
749	off = fdt_next_node(blob, off, &ndepth)) {	749	off = fdt_next_node(blob, off, &ndepth)) {
750	if (ndepth == 1) {	750	if (ndepth == 1) {
751	debug("delete %s: offset: %x\n",	751	debug("delete %s: offset: %x\n",
752	fdt_get_name(blob, off, 0), off);	752	fdt_get_name(blob, off, 0), off);
753	ret = fdt_del_node((void *)blob, off);	753	ret = fdt_del_node((void *)blob, off);
754	if (ret < 0) {	754	if (ret < 0) {
755	printf("Can't delete node: %s\n",	755	printf("Can't delete node: %s\n",
756	fdt_strerror(ret));	756	fdt_strerror(ret));
757	return ret;	757	return ret;
758	} else {	758	} else {
759	ndepth = 0;	759	ndepth = 0;
760	off = parent_offset;	760	off = parent_offset;
761	}	761	}
762	}	762	}
763	}	763	}
764	return 0;	764	return 0;
765	}	765	}
766		766
767	int fdt_del_partitions(void *blob, int parent_offset)	767	int fdt_del_partitions(void *blob, int parent_offset)
768	{	768	{
769	const void *prop;	769	const void *prop;
770	int ndepth = 0;	770	int ndepth = 0;
771	int off;	771	int off;
772	int ret;	772	int ret;
773		773
774	off = fdt_next_node(blob, parent_offset, &ndepth);	774	off = fdt_next_node(blob, parent_offset, &ndepth);
775	if (off > 0 && ndepth == 1) {	775	if (off > 0 && ndepth == 1) {
776	prop = fdt_getprop(blob, off, "label", NULL);	776	prop = fdt_getprop(blob, off, "label", NULL);
777	if (prop == NULL) {	777	if (prop == NULL) {
778	/*	778	/*
779	* Could not find label property, nand {}; node?	779	* Could not find label property, nand {}; node?
780	* Check subnode, delete partitions there if any.	780	* Check subnode, delete partitions there if any.
781	*/	781	*/
782	return fdt_del_partitions(blob, off);	782	return fdt_del_partitions(blob, off);
783	} else {	783	} else {
784	ret = fdt_del_subnodes(blob, parent_offset);	784	ret = fdt_del_subnodes(blob, parent_offset);
785	if (ret < 0) {	785	if (ret < 0) {
786	printf("Can't remove subnodes: %s\n",	786	printf("Can't remove subnodes: %s\n",
787	fdt_strerror(ret));	787	fdt_strerror(ret));
788	return ret;	788	return ret;
789	}	789	}
790	}	790	}
791	}	791	}
792	return 0;	792	return 0;
793	}	793	}
794		794
795	int fdt_node_set_part_info(void *blob, int parent_offset,	795	int fdt_node_set_part_info(void *blob, int parent_offset,
796	struct mtd_device *dev)	796	struct mtd_device *dev)
797	{	797	{
798	struct list_head *pentry;	798	struct list_head *pentry;
799	struct part_info *part;	799	struct part_info *part;
800	struct reg_cell cell;	800	struct reg_cell cell;
801	int off, ndepth = 0;	801	int off, ndepth = 0;
802	int part_num, ret;	802	int part_num, ret;
803	char buf[64];	803	char buf[64];
804		804
805	ret = fdt_del_partitions(blob, parent_offset);	805	ret = fdt_del_partitions(blob, parent_offset);
806	if (ret < 0)	806	if (ret < 0)
807	return ret;	807	return ret;
808		808
809	/*	809	/*
810	* Check if it is nand {}; subnode, adjust	810	* Check if it is nand {}; subnode, adjust
811	* the offset in this case	811	* the offset in this case
812	*/	812	*/
813	off = fdt_next_node(blob, parent_offset, &ndepth);	813	off = fdt_next_node(blob, parent_offset, &ndepth);
814	if (off > 0 && ndepth == 1)	814	if (off > 0 && ndepth == 1)
815	parent_offset = off;	815	parent_offset = off;
816		816
817	part_num = 0;	817	part_num = 0;
818	list_for_each_prev(pentry, &dev->parts) {	818	list_for_each_prev(pentry, &dev->parts) {
819	int newoff;	819	int newoff;
820		820
821	part = list_entry(pentry, struct part_info, link);	821	part = list_entry(pentry, struct part_info, link);
822		822
823	debug("%2d: %-20s0x%08llx\t0x%08llx\t%d\n",	823	debug("%2d: %-20s0x%08llx\t0x%08llx\t%d\n",
824	part_num, part->name, part->size,	824	part_num, part->name, part->size,
825	part->offset, part->mask_flags);	825	part->offset, part->mask_flags);
826		826
827	sprintf(buf, "partition@%llx", part->offset);	827	sprintf(buf, "partition@%llx", part->offset);
828	add_sub:	828	add_sub:
829	ret = fdt_add_subnode(blob, parent_offset, buf);	829	ret = fdt_add_subnode(blob, parent_offset, buf);
830	if (ret == -FDT_ERR_NOSPACE) {	830	if (ret == -FDT_ERR_NOSPACE) {
831	ret = fdt_increase_size(blob, 512);	831	ret = fdt_increase_size(blob, 512);
832	if (!ret)	832	if (!ret)
833	goto add_sub;	833	goto add_sub;
834	else	834	else
835	goto err_size;	835	goto err_size;
836	} else if (ret < 0) {	836	} else if (ret < 0) {
837	printf("Can't add partition node: %s\n",	837	printf("Can't add partition node: %s\n",
838	fdt_strerror(ret));	838	fdt_strerror(ret));
839	return ret;	839	return ret;
840	}	840	}
841	newoff = ret;	841	newoff = ret;
842		842
843	/* Check MTD_WRITEABLE_CMD flag */	843	/* Check MTD_WRITEABLE_CMD flag */
844	if (part->mask_flags & 1) {	844	if (part->mask_flags & 1) {
845	add_ro:	845	add_ro:
846	ret = fdt_setprop(blob, newoff, "read_only", NULL, 0);	846	ret = fdt_setprop(blob, newoff, "read_only", NULL, 0);
847	if (ret == -FDT_ERR_NOSPACE) {	847	if (ret == -FDT_ERR_NOSPACE) {
848	ret = fdt_increase_size(blob, 512);	848	ret = fdt_increase_size(blob, 512);
849	if (!ret)	849	if (!ret)
850	goto add_ro;	850	goto add_ro;
851	else	851	else
852	goto err_size;	852	goto err_size;
853	} else if (ret < 0)	853	} else if (ret < 0)
854	goto err_prop;	854	goto err_prop;
855	}	855	}
856		856
857	cell.r0 = cpu_to_fdt32(part->offset);	857	cell.r0 = cpu_to_fdt32(part->offset);
858	cell.r1 = cpu_to_fdt32(part->size);	858	cell.r1 = cpu_to_fdt32(part->size);
859	add_reg:	859	add_reg:
860	ret = fdt_setprop(blob, newoff, "reg", &cell, sizeof(cell));	860	ret = fdt_setprop(blob, newoff, "reg", &cell, sizeof(cell));
861	if (ret == -FDT_ERR_NOSPACE) {	861	if (ret == -FDT_ERR_NOSPACE) {
862	ret = fdt_increase_size(blob, 512);	862	ret = fdt_increase_size(blob, 512);
863	if (!ret)	863	if (!ret)
864	goto add_reg;	864	goto add_reg;
865	else	865	else
866	goto err_size;	866	goto err_size;
867	} else if (ret < 0)	867	} else if (ret < 0)
868	goto err_prop;	868	goto err_prop;
869		869
870	add_label:	870	add_label:
871	ret = fdt_setprop_string(blob, newoff, "label", part->name);	871	ret = fdt_setprop_string(blob, newoff, "label", part->name);
872	if (ret == -FDT_ERR_NOSPACE) {	872	if (ret == -FDT_ERR_NOSPACE) {
873	ret = fdt_increase_size(blob, 512);	873	ret = fdt_increase_size(blob, 512);
874	if (!ret)	874	if (!ret)
875	goto add_label;	875	goto add_label;
876	else	876	else
877	goto err_size;	877	goto err_size;
878	} else if (ret < 0)	878	} else if (ret < 0)
879	goto err_prop;	879	goto err_prop;
880		880
881	part_num++;	881	part_num++;
882	}	882	}
883	return 0;	883	return 0;
884	err_size:	884	err_size:
885	printf("Can't increase blob size: %s\n", fdt_strerror(ret));	885	printf("Can't increase blob size: %s\n", fdt_strerror(ret));
886	return ret;	886	return ret;
887	err_prop:	887	err_prop:
888	printf("Can't add property: %s\n", fdt_strerror(ret));	888	printf("Can't add property: %s\n", fdt_strerror(ret));
889	return ret;	889	return ret;
890	}	890	}
891		891
892	/*	892	/*
893	* Update partitions in nor/nand nodes using info from	893	* Update partitions in nor/nand nodes using info from
894	* mtdparts environment variable. The nodes to update are	894	* mtdparts environment variable. The nodes to update are
895	* specified by node_info structure which contains mtd device	895	* specified by node_info structure which contains mtd device
896	* type and compatible string: E. g. the board code in	896	* type and compatible string: E. g. the board code in
897	* ft_board_setup() could use:	897	* ft_board_setup() could use:
898	*	898	*
899	* struct node_info nodes[] = {	899	* struct node_info nodes[] = {
900	* { "fsl,mpc5121-nfc", MTD_DEV_TYPE_NAND, },	900	* { "fsl,mpc5121-nfc", MTD_DEV_TYPE_NAND, },
901	* { "cfi-flash", MTD_DEV_TYPE_NOR, },	901	* { "cfi-flash", MTD_DEV_TYPE_NOR, },
902	* };	902	* };
903	*	903	*
904	* fdt_fixup_mtdparts(blob, nodes, ARRAY_SIZE(nodes));	904	* fdt_fixup_mtdparts(blob, nodes, ARRAY_SIZE(nodes));
905	*/	905	*/
906	void fdt_fixup_mtdparts(void blob, void node_info, int node_info_size)	906	void fdt_fixup_mtdparts(void blob, void node_info, int node_info_size)
907	{	907	{
908	struct node_info *ni = node_info;	908	struct node_info *ni = node_info;
909	struct mtd_device *dev;	909	struct mtd_device *dev;
910	int i, idx;	910	int i, idx;
911	int noff;	911	int noff;
912		912
913	if (mtdparts_init() != 0)	913	if (mtdparts_init() != 0)
914	return;	914	return;
915		915
916	for (i = 0; i < node_info_size; i++) {	916	for (i = 0; i < node_info_size; i++) {
917	idx = 0;	917	idx = 0;
918	noff = fdt_node_offset_by_compatible(blob, -1, ni[i].compat);	918	noff = fdt_node_offset_by_compatible(blob, -1, ni[i].compat);
919	while (noff != -FDT_ERR_NOTFOUND) {	919	while (noff != -FDT_ERR_NOTFOUND) {
920	debug("%s: %s, mtd dev type %d\n",	920	debug("%s: %s, mtd dev type %d\n",
921	fdt_get_name(blob, noff, 0),	921	fdt_get_name(blob, noff, 0),
922	ni[i].compat, ni[i].type);	922	ni[i].compat, ni[i].type);
923	dev = device_find(ni[i].type, idx++);	923	dev = device_find(ni[i].type, idx++);
924	if (dev) {	924	if (dev) {
925	if (fdt_node_set_part_info(blob, noff, dev))	925	if (fdt_node_set_part_info(blob, noff, dev))
926	return; /* return on error */	926	return; /* return on error */
927	}	927	}
928		928
929	/* Jump to next flash node */	929	/* Jump to next flash node */
930	noff = fdt_node_offset_by_compatible(blob, noff,	930	noff = fdt_node_offset_by_compatible(blob, noff,
931	ni[i].compat);	931	ni[i].compat);
932	}	932	}
933	}	933	}
934	}	934	}
935	#endif	935	#endif
936		936
937	void fdt_del_node_and_alias(void blob, const char alias)	937	void fdt_del_node_and_alias(void blob, const char alias)
938	{	938	{
939	int off = fdt_path_offset(blob, alias);	939	int off = fdt_path_offset(blob, alias);
940		940
941	if (off < 0)	941	if (off < 0)
942	return;	942	return;
943		943
944	fdt_del_node(blob, off);	944	fdt_del_node(blob, off);
945		945
946	off = fdt_path_offset(blob, "/aliases");	946	off = fdt_path_offset(blob, "/aliases");
947	fdt_delprop(blob, off, alias);	947	fdt_delprop(blob, off, alias);
948	}	948	}
949		949
950	/* Max address size we deal with */	950	/* Max address size we deal with */
951	#define OF_MAX_ADDR_CELLS 4	951	#define OF_MAX_ADDR_CELLS 4
952	#define OF_BAD_ADDR FDT_ADDR_T_NONE	952	#define OF_BAD_ADDR FDT_ADDR_T_NONE
953	#define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \	953	#define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \
954	(ns) > 0)	954	(ns) > 0)
955		955
956	/* Debug utility */	956	/* Debug utility */
957	#ifdef DEBUG	957	#ifdef DEBUG
958	static void of_dump_addr(const char s, const fdt32_t addr, int na)	958	static void of_dump_addr(const char s, const fdt32_t addr, int na)
959	{	959	{
960	printf("%s", s);	960	printf("%s", s);
961	while(na--)	961	while(na--)
962	printf(" %08x", *(addr++));	962	printf(" %08x", *(addr++));
963	printf("\n");	963	printf("\n");
964	}	964	}
965	#else	965	#else
966	static void of_dump_addr(const char s, const fdt32_t addr, int na) { }	966	static void of_dump_addr(const char s, const fdt32_t addr, int na) { }
967	#endif	967	#endif
968		968
969	/**	969	/**
970	* struct of_bus - Callbacks for bus specific translators	970	* struct of_bus - Callbacks for bus specific translators
971	* @name: A string used to identify this bus in debug output.	971	* @name: A string used to identify this bus in debug output.
972	* @addresses: The name of the DT property from which addresses are	972	* @addresses: The name of the DT property from which addresses are
973	* to be read, typically "reg".	973	* to be read, typically "reg".
974	* @match: Return non-zero if the node whose parent is at	974	* @match: Return non-zero if the node whose parent is at
975	* parentoffset in the FDT blob corresponds to a bus	975	* parentoffset in the FDT blob corresponds to a bus
976	* of this type, otherwise return zero. If NULL a match	976	* of this type, otherwise return zero. If NULL a match
977	* is assumed.	977	* is assumed.
978	* @count_cells:Count how many cells (be32 values) a node whose parent	978	* @count_cells:Count how many cells (be32 values) a node whose parent
979	* is at parentoffset in the FDT blob will require to	979	* is at parentoffset in the FDT blob will require to
980	* represent its address (written to *addrc) & size	980	* represent its address (written to *addrc) & size
981	* (written to *sizec).	981	* (written to *sizec).
982	* @map: Map the address addr from the address space of this	982	* @map: Map the address addr from the address space of this
983	* bus to that of its parent, making use of the ranges	983	* bus to that of its parent, making use of the ranges
984	* read from DT to an array at range. na and ns are the	984	* read from DT to an array at range. na and ns are the
985	* number of cells (be32 values) used to hold and address	985	* number of cells (be32 values) used to hold and address
986	* or size, respectively, for this bus. pna is the number	986	* or size, respectively, for this bus. pna is the number
987	* of cells used to hold an address for the parent bus.	987	* of cells used to hold an address for the parent bus.
988	* Returns the address in the address space of the parent	988	* Returns the address in the address space of the parent
989	* bus.	989	* bus.
990	* @translate: Update the value of the address cells at addr within an	990	* @translate: Update the value of the address cells at addr within an
991	* FDT by adding offset to it. na specifies the number of	991	* FDT by adding offset to it. na specifies the number of
992	* cells used to hold the address being translated. Returns	992	* cells used to hold the address being translated. Returns
993	* zero on success, non-zero on error.	993	* zero on success, non-zero on error.
994	*	994	*
995	* Each bus type will include a struct of_bus in the of_busses array,	995	* Each bus type will include a struct of_bus in the of_busses array,
996	* providing implementations of some or all of the functions used to	996	* providing implementations of some or all of the functions used to
997	* match the bus & handle address translation for its children.	997	* match the bus & handle address translation for its children.
998	*/	998	*/
999	struct of_bus {	999	struct of_bus {
1000	const char *name;	1000	const char *name;
1001	const char *addresses;	1001	const char *addresses;
1002	int (match)(const void blob, int parentoffset);	1002	int (match)(const void blob, int parentoffset);
1003	void (count_cells)(const void blob, int parentoffset,	1003	void (count_cells)(const void blob, int parentoffset,
1004	int addrc, int sizec);	1004	int addrc, int sizec);
1005	u64 (map)(fdt32_t addr, const fdt32_t *range,	1005	u64 (map)(fdt32_t addr, const fdt32_t *range,
1006	int na, int ns, int pna);	1006	int na, int ns, int pna);
1007	int (translate)(fdt32_t addr, u64 offset, int na);	1007	int (translate)(fdt32_t addr, u64 offset, int na);
1008	};	1008	};
1009		1009
1010	/* Default translator (generic bus) */	1010	/* Default translator (generic bus) */
1011	void of_bus_default_count_cells(const void *blob, int parentoffset,	1011	void of_bus_default_count_cells(const void *blob, int parentoffset,
1012	int addrc, int sizec)	1012	int addrc, int sizec)
1013	{	1013	{
1014	const fdt32_t *prop;	1014	const fdt32_t *prop;
1015		1015
1016	if (addrc)	1016	if (addrc)
1017	*addrc = fdt_address_cells(blob, parentoffset);	1017	*addrc = fdt_address_cells(blob, parentoffset);
1018		1018
1019	if (sizec) {	1019	if (sizec) {
1020	prop = fdt_getprop(blob, parentoffset, "#size-cells", NULL);	1020	prop = fdt_getprop(blob, parentoffset, "#size-cells", NULL);
1021	if (prop)	1021	if (prop)
1022	*sizec = be32_to_cpup(prop);	1022	*sizec = be32_to_cpup(prop);
1023	else	1023	else
1024	*sizec = 1;	1024	*sizec = 1;
1025	}	1025	}
1026	}	1026	}
1027		1027
1028	static u64 of_bus_default_map(fdt32_t addr, const fdt32_t range,	1028	static u64 of_bus_default_map(fdt32_t addr, const fdt32_t range,
1029	int na, int ns, int pna)	1029	int na, int ns, int pna)
1030	{	1030	{
1031	u64 cp, s, da;	1031	u64 cp, s, da;
1032		1032
1033	cp = of_read_number(range, na);	1033	cp = of_read_number(range, na);
1034	s = of_read_number(range + na + pna, ns);	1034	s = of_read_number(range + na + pna, ns);
1035	da = of_read_number(addr, na);	1035	da = of_read_number(addr, na);
1036		1036
1037	debug("OF: default map, cp=%" PRIu64 ", s=%" PRIu64	1037	debug("OF: default map, cp=%" PRIu64 ", s=%" PRIu64
1038	", da=%" PRIu64 "\n", cp, s, da);	1038	", da=%" PRIu64 "\n", cp, s, da);
1039		1039
1040	if (da < cp \|\| da >= (cp + s))	1040	if (da < cp \|\| da >= (cp + s))
1041	return OF_BAD_ADDR;	1041	return OF_BAD_ADDR;
1042	return da - cp;	1042	return da - cp;
1043	}	1043	}
1044		1044
1045	static int of_bus_default_translate(fdt32_t *addr, u64 offset, int na)	1045	static int of_bus_default_translate(fdt32_t *addr, u64 offset, int na)
1046	{	1046	{
1047	u64 a = of_read_number(addr, na);	1047	u64 a = of_read_number(addr, na);
1048	memset(addr, 0, na * 4);	1048	memset(addr, 0, na * 4);
1049	a += offset;	1049	a += offset;
1050	if (na > 1)	1050	if (na > 1)
1051	addr[na - 2] = cpu_to_fdt32(a >> 32);	1051	addr[na - 2] = cpu_to_fdt32(a >> 32);
1052	addr[na - 1] = cpu_to_fdt32(a & 0xffffffffu);	1052	addr[na - 1] = cpu_to_fdt32(a & 0xffffffffu);
1053		1053
1054	return 0;	1054	return 0;
1055	}	1055	}
1056		1056
1057	#ifdef CONFIG_OF_ISA_BUS	1057	#ifdef CONFIG_OF_ISA_BUS
1058		1058
1059	/* ISA bus translator */	1059	/* ISA bus translator */
1060	static int of_bus_isa_match(const void *blob, int parentoffset)	1060	static int of_bus_isa_match(const void *blob, int parentoffset)
1061	{	1061	{
1062	const char *name;	1062	const char *name;
1063		1063
1064	name = fdt_get_name(blob, parentoffset, NULL);	1064	name = fdt_get_name(blob, parentoffset, NULL);
1065	if (!name)	1065	if (!name)
1066	return 0;	1066	return 0;
1067		1067
1068	return !strcmp(name, "isa");	1068	return !strcmp(name, "isa");
1069	}	1069	}
1070		1070
1071	static void of_bus_isa_count_cells(const void *blob, int parentoffset,	1071	static void of_bus_isa_count_cells(const void *blob, int parentoffset,
1072	int addrc, int sizec)	1072	int addrc, int sizec)
1073	{	1073	{
1074	if (addrc)	1074	if (addrc)
1075	*addrc = 2;	1075	*addrc = 2;
1076	if (sizec)	1076	if (sizec)
1077	*sizec = 1;	1077	*sizec = 1;
1078	}	1078	}
1079		1079
1080	static u64 of_bus_isa_map(fdt32_t addr, const fdt32_t range,	1080	static u64 of_bus_isa_map(fdt32_t addr, const fdt32_t range,
1081	int na, int ns, int pna)	1081	int na, int ns, int pna)
1082	{	1082	{
1083	u64 cp, s, da;	1083	u64 cp, s, da;
1084		1084
1085	/* Check address type match */	1085	/* Check address type match */
1086	if ((addr[0] ^ range[0]) & cpu_to_be32(1))	1086	if ((addr[0] ^ range[0]) & cpu_to_be32(1))
1087	return OF_BAD_ADDR;	1087	return OF_BAD_ADDR;
1088		1088
1089	cp = of_read_number(range + 1, na - 1);	1089	cp = of_read_number(range + 1, na - 1);
1090	s = of_read_number(range + na + pna, ns);	1090	s = of_read_number(range + na + pna, ns);
1091	da = of_read_number(addr + 1, na - 1);	1091	da = of_read_number(addr + 1, na - 1);
1092		1092
1093	debug("OF: ISA map, cp=%" PRIu64 ", s=%" PRIu64	1093	debug("OF: ISA map, cp=%" PRIu64 ", s=%" PRIu64
1094	", da=%" PRIu64 "\n", cp, s, da);	1094	", da=%" PRIu64 "\n", cp, s, da);
1095		1095
1096	if (da < cp \|\| da >= (cp + s))	1096	if (da < cp \|\| da >= (cp + s))
1097	return OF_BAD_ADDR;	1097	return OF_BAD_ADDR;
1098	return da - cp;	1098	return da - cp;
1099	}	1099	}
1100		1100
1101	static int of_bus_isa_translate(fdt32_t *addr, u64 offset, int na)	1101	static int of_bus_isa_translate(fdt32_t *addr, u64 offset, int na)
1102	{	1102	{
1103	return of_bus_default_translate(addr + 1, offset, na - 1);	1103	return of_bus_default_translate(addr + 1, offset, na - 1);
1104	}	1104	}
1105		1105
1106	#endif /* CONFIG_OF_ISA_BUS */	1106	#endif /* CONFIG_OF_ISA_BUS */
1107		1107
1108	/* Array of bus specific translators */	1108	/* Array of bus specific translators */
1109	static struct of_bus of_busses[] = {	1109	static struct of_bus of_busses[] = {
1110	#ifdef CONFIG_OF_ISA_BUS	1110	#ifdef CONFIG_OF_ISA_BUS
1111	/* ISA */	1111	/* ISA */
1112	{	1112	{
1113	.name = "isa",	1113	.name = "isa",
1114	.addresses = "reg",	1114	.addresses = "reg",
1115	.match = of_bus_isa_match,	1115	.match = of_bus_isa_match,
1116	.count_cells = of_bus_isa_count_cells,	1116	.count_cells = of_bus_isa_count_cells,
1117	.map = of_bus_isa_map,	1117	.map = of_bus_isa_map,
1118	.translate = of_bus_isa_translate,	1118	.translate = of_bus_isa_translate,
1119	},	1119	},
1120	#endif /* CONFIG_OF_ISA_BUS */	1120	#endif /* CONFIG_OF_ISA_BUS */
1121	/* Default */	1121	/* Default */
1122	{	1122	{
1123	.name = "default",	1123	.name = "default",
1124	.addresses = "reg",	1124	.addresses = "reg",
1125	.count_cells = of_bus_default_count_cells,	1125	.count_cells = of_bus_default_count_cells,
1126	.map = of_bus_default_map,	1126	.map = of_bus_default_map,
1127	.translate = of_bus_default_translate,	1127	.translate = of_bus_default_translate,
1128	},	1128	},
1129	};	1129	};
1130		1130
1131	static struct of_bus of_match_bus(const void blob, int parentoffset)	1131	static struct of_bus of_match_bus(const void blob, int parentoffset)
1132	{	1132	{
1133	struct of_bus *bus;	1133	struct of_bus *bus;
1134		1134
1135	if (ARRAY_SIZE(of_busses) == 1)	1135	if (ARRAY_SIZE(of_busses) == 1)
1136	return of_busses;	1136	return of_busses;
1137		1137
1138	for (bus = of_busses; bus; bus++) {	1138	for (bus = of_busses; bus; bus++) {
1139	if (!bus->match \|\| bus->match(blob, parentoffset))	1139	if (!bus->match \|\| bus->match(blob, parentoffset))
1140	return bus;	1140	return bus;
1141	}	1141	}
1142		1142
1143	/*	1143	/*
1144	* We should always have matched the default bus at least, since	1144	* We should always have matched the default bus at least, since
1145	* it has a NULL match field. If we didn't then it somehow isn't	1145	* it has a NULL match field. If we didn't then it somehow isn't
1146	* in the of_busses array or something equally catastrophic has	1146	* in the of_busses array or something equally catastrophic has
1147	* gone wrong.	1147	* gone wrong.
1148	*/	1148	*/
1149	assert(0);	1149	assert(0);
1150	return NULL;	1150	return NULL;
1151	}	1151	}
1152		1152
1153	static int of_translate_one(const void blob, int parent, struct of_bus bus,	1153	static int of_translate_one(const void blob, int parent, struct of_bus bus,
1154	struct of_bus pbus, fdt32_t addr,	1154	struct of_bus pbus, fdt32_t addr,
1155	int na, int ns, int pna, const char *rprop)	1155	int na, int ns, int pna, const char *rprop)
1156	{	1156	{
1157	const fdt32_t *ranges;	1157	const fdt32_t *ranges;
1158	int rlen;	1158	int rlen;
1159	int rone;	1159	int rone;
1160	u64 offset = OF_BAD_ADDR;	1160	u64 offset = OF_BAD_ADDR;
1161		1161
1162	/* Normally, an absence of a "ranges" property means we are	1162	/* Normally, an absence of a "ranges" property means we are
1163	* crossing a non-translatable boundary, and thus the addresses	1163	* crossing a non-translatable boundary, and thus the addresses
1164	* below the current not cannot be converted to CPU physical ones.	1164	* below the current not cannot be converted to CPU physical ones.
1165	* Unfortunately, while this is very clear in the spec, it's not	1165	* Unfortunately, while this is very clear in the spec, it's not
1166	* what Apple understood, and they do have things like /uni-n or	1166	* what Apple understood, and they do have things like /uni-n or
1167	* /ht nodes with no "ranges" property and a lot of perfectly	1167	* /ht nodes with no "ranges" property and a lot of perfectly
1168	* useable mapped devices below them. Thus we treat the absence of	1168	* useable mapped devices below them. Thus we treat the absence of
1169	* "ranges" as equivalent to an empty "ranges" property which means	1169	* "ranges" as equivalent to an empty "ranges" property which means
1170	* a 1:1 translation at that level. It's up to the caller not to try	1170	* a 1:1 translation at that level. It's up to the caller not to try
1171	* to translate addresses that aren't supposed to be translated in	1171	* to translate addresses that aren't supposed to be translated in
1172	* the first place. --BenH.	1172	* the first place. --BenH.
1173	*/	1173	*/
1174	ranges = fdt_getprop(blob, parent, rprop, &rlen);	1174	ranges = fdt_getprop(blob, parent, rprop, &rlen);
1175	if (ranges == NULL \|\| rlen == 0) {	1175	if (ranges == NULL \|\| rlen == 0) {
1176	offset = of_read_number(addr, na);	1176	offset = of_read_number(addr, na);
1177	memset(addr, 0, pna * 4);	1177	memset(addr, 0, pna * 4);
1178	debug("OF: no ranges, 1:1 translation\n");	1178	debug("OF: no ranges, 1:1 translation\n");
1179	goto finish;	1179	goto finish;
1180	}	1180	}
1181		1181
1182	debug("OF: walking ranges...\n");	1182	debug("OF: walking ranges...\n");
1183		1183
1184	/* Now walk through the ranges */	1184	/* Now walk through the ranges */
1185	rlen /= 4;	1185	rlen /= 4;
1186	rone = na + pna + ns;	1186	rone = na + pna + ns;
1187	for (; rlen >= rone; rlen -= rone, ranges += rone) {	1187	for (; rlen >= rone; rlen -= rone, ranges += rone) {
1188	offset = bus->map(addr, ranges, na, ns, pna);	1188	offset = bus->map(addr, ranges, na, ns, pna);
1189	if (offset != OF_BAD_ADDR)	1189	if (offset != OF_BAD_ADDR)
1190	break;	1190	break;
1191	}	1191	}
1192	if (offset == OF_BAD_ADDR) {	1192	if (offset == OF_BAD_ADDR) {
1193	debug("OF: not found !\n");	1193	debug("OF: not found !\n");
1194	return 1;	1194	return 1;
1195	}	1195	}
1196	memcpy(addr, ranges + na, 4 * pna);	1196	memcpy(addr, ranges + na, 4 * pna);
1197		1197
1198	finish:	1198	finish:
1199	of_dump_addr("OF: parent translation for:", addr, pna);	1199	of_dump_addr("OF: parent translation for:", addr, pna);
1200	debug("OF: with offset: %" PRIu64 "\n", offset);	1200	debug("OF: with offset: %" PRIu64 "\n", offset);
1201		1201
1202	/* Translate it into parent bus space */	1202	/* Translate it into parent bus space */
1203	return pbus->translate(addr, offset, pna);	1203	return pbus->translate(addr, offset, pna);
1204	}	1204	}
1205		1205
1206	/*	1206	/*
1207	* Translate an address from the device-tree into a CPU physical address,	1207	* Translate an address from the device-tree into a CPU physical address,
1208	* this walks up the tree and applies the various bus mappings on the	1208	* this walks up the tree and applies the various bus mappings on the
1209	* way.	1209	* way.
1210	*	1210	*
1211	* Note: We consider that crossing any level with #size-cells == 0 to mean	1211	* Note: We consider that crossing any level with #size-cells == 0 to mean
1212	* that translation is impossible (that is we are not dealing with a value	1212	* that translation is impossible (that is we are not dealing with a value
1213	* that can be mapped to a cpu physical address). This is not really specified	1213	* that can be mapped to a cpu physical address). This is not really specified
1214	* that way, but this is traditionally the way IBM at least do things	1214	* that way, but this is traditionally the way IBM at least do things
1215	*/	1215	*/
1216	static u64 __of_translate_address(const void *blob, int node_offset,	1216	static u64 __of_translate_address(const void *blob, int node_offset,
1217	const fdt32_t in_addr, const char rprop)	1217	const fdt32_t in_addr, const char rprop)
1218	{	1218	{
1219	int parent;	1219	int parent;
1220	struct of_bus bus, pbus;	1220	struct of_bus bus, pbus;
1221	fdt32_t addr[OF_MAX_ADDR_CELLS];	1221	fdt32_t addr[OF_MAX_ADDR_CELLS];
1222	int na, ns, pna, pns;	1222	int na, ns, pna, pns;
1223	u64 result = OF_BAD_ADDR;	1223	u64 result = OF_BAD_ADDR;
1224		1224
1225	debug("OF: translation for device %s \n",	1225	debug("OF: translation for device %s \n",
1226	fdt_get_name(blob, node_offset, NULL));	1226	fdt_get_name(blob, node_offset, NULL));
1227		1227
1228	/* Get parent & match bus type */	1228	/* Get parent & match bus type */
1229	parent = fdt_parent_offset(blob, node_offset);	1229	parent = fdt_parent_offset(blob, node_offset);
1230	if (parent < 0)	1230	if (parent < 0)
1231	goto bail;	1231	goto bail;
1232	bus = of_match_bus(blob, parent);	1232	bus = of_match_bus(blob, parent);
1233		1233
1234	/* Cound address cells & copy address locally */	1234	/* Cound address cells & copy address locally */
1235	bus->count_cells(blob, parent, &na, &ns);	1235	bus->count_cells(blob, parent, &na, &ns);
1236	if (!OF_CHECK_COUNTS(na, ns)) {	1236	if (!OF_CHECK_COUNTS(na, ns)) {
1237	printf("%s: Bad cell count for %s\n", __FUNCTION__,	1237	printf("%s: Bad cell count for %s\n", __FUNCTION__,
1238	fdt_get_name(blob, node_offset, NULL));	1238	fdt_get_name(blob, node_offset, NULL));
1239	goto bail;	1239	goto bail;
1240	}	1240	}
1241	memcpy(addr, in_addr, na * 4);	1241	memcpy(addr, in_addr, na * 4);
1242		1242
1243	debug("OF: bus is %s (na=%d, ns=%d) on %s\n",	1243	debug("OF: bus is %s (na=%d, ns=%d) on %s\n",
1244	bus->name, na, ns, fdt_get_name(blob, parent, NULL));	1244	bus->name, na, ns, fdt_get_name(blob, parent, NULL));
1245	of_dump_addr("OF: translating address:", addr, na);	1245	of_dump_addr("OF: translating address:", addr, na);
1246		1246
1247	/* Translate */	1247	/* Translate */
1248	for (;;) {	1248	for (;;) {
1249	/* Switch to parent bus */	1249	/* Switch to parent bus */
1250	node_offset = parent;	1250	node_offset = parent;
1251	parent = fdt_parent_offset(blob, node_offset);	1251	parent = fdt_parent_offset(blob, node_offset);
1252		1252
1253	/* If root, we have finished */	1253	/* If root, we have finished */
1254	if (parent < 0) {	1254	if (parent < 0) {
1255	debug("OF: reached root node\n");	1255	debug("OF: reached root node\n");
1256	result = of_read_number(addr, na);	1256	result = of_read_number(addr, na);
1257	break;	1257	break;
1258	}	1258	}
1259		1259
1260	/* Get new parent bus and counts */	1260	/* Get new parent bus and counts */
1261	pbus = of_match_bus(blob, parent);	1261	pbus = of_match_bus(blob, parent);
1262	pbus->count_cells(blob, parent, &pna, &pns);	1262	pbus->count_cells(blob, parent, &pna, &pns);
1263	if (!OF_CHECK_COUNTS(pna, pns)) {	1263	if (!OF_CHECK_COUNTS(pna, pns)) {
1264	printf("%s: Bad cell count for %s\n", __FUNCTION__,	1264	printf("%s: Bad cell count for %s\n", __FUNCTION__,
1265	fdt_get_name(blob, node_offset, NULL));	1265	fdt_get_name(blob, node_offset, NULL));
1266	break;	1266	break;
1267	}	1267	}
1268		1268
1269	debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n",	1269	debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
1270	pbus->name, pna, pns, fdt_get_name(blob, parent, NULL));	1270	pbus->name, pna, pns, fdt_get_name(blob, parent, NULL));
1271		1271
1272	/* Apply bus translation */	1272	/* Apply bus translation */
1273	if (of_translate_one(blob, node_offset, bus, pbus,	1273	if (of_translate_one(blob, node_offset, bus, pbus,
1274	addr, na, ns, pna, rprop))	1274	addr, na, ns, pna, rprop))
1275	break;	1275	break;
1276		1276
1277	/* Complete the move up one level */	1277	/* Complete the move up one level */
1278	na = pna;	1278	na = pna;
1279	ns = pns;	1279	ns = pns;
1280	bus = pbus;	1280	bus = pbus;
1281		1281
1282	of_dump_addr("OF: one level translation:", addr, na);	1282	of_dump_addr("OF: one level translation:", addr, na);
1283	}	1283	}
1284	bail:	1284	bail:
1285		1285
1286	return result;	1286	return result;
1287	}	1287	}
1288		1288
1289	u64 fdt_translate_address(const void *blob, int node_offset,	1289	u64 fdt_translate_address(const void *blob, int node_offset,
1290	const fdt32_t *in_addr)	1290	const fdt32_t *in_addr)
1291	{	1291	{
1292	return __of_translate_address(blob, node_offset, in_addr, "ranges");	1292	return __of_translate_address(blob, node_offset, in_addr, "ranges");
1293	}	1293	}
1294		1294
1295	/**	1295	/**
1296	* fdt_node_offset_by_compat_reg: Find a node that matches compatiable and	1296	* fdt_node_offset_by_compat_reg: Find a node that matches compatiable and
1297	* who's reg property matches a physical cpu address	1297	* who's reg property matches a physical cpu address
1298	*	1298	*
1299	* @blob: ptr to device tree	1299	* @blob: ptr to device tree
1300	* @compat: compatiable string to match	1300	* @compat: compatiable string to match
1301	* @compat_off: property name	1301	* @compat_off: property name
1302	*	1302	*
1303	*/	1303	*/
1304	int fdt_node_offset_by_compat_reg(void blob, const char compat,	1304	int fdt_node_offset_by_compat_reg(void blob, const char compat,
1305	phys_addr_t compat_off)	1305	phys_addr_t compat_off)
1306	{	1306	{
1307	int len, off = fdt_node_offset_by_compatible(blob, -1, compat);	1307	int len, off = fdt_node_offset_by_compatible(blob, -1, compat);
1308	while (off != -FDT_ERR_NOTFOUND) {	1308	while (off != -FDT_ERR_NOTFOUND) {
1309	const fdt32_t *reg = fdt_getprop(blob, off, "reg", &len);	1309	const fdt32_t *reg = fdt_getprop(blob, off, "reg", &len);
1310	if (reg) {	1310	if (reg) {
1311	if (compat_off == fdt_translate_address(blob, off, reg))	1311	if (compat_off == fdt_translate_address(blob, off, reg))
1312	return off;	1312	return off;
1313	}	1313	}
1314	off = fdt_node_offset_by_compatible(blob, off, compat);	1314	off = fdt_node_offset_by_compatible(blob, off, compat);
1315	}	1315	}
1316		1316
1317	return -FDT_ERR_NOTFOUND;	1317	return -FDT_ERR_NOTFOUND;
1318	}	1318	}
1319		1319
1320	/**	1320	/**
1321	* fdt_alloc_phandle: Return next free phandle value	1321	* fdt_alloc_phandle: Return next free phandle value
1322	*	1322	*
1323	* @blob: ptr to device tree	1323	* @blob: ptr to device tree
1324	*/	1324	*/
1325	int fdt_alloc_phandle(void *blob)	1325	int fdt_alloc_phandle(void *blob)
1326	{	1326	{
1327	int offset;	1327	int offset;
1328	uint32_t phandle = 0;	1328	uint32_t phandle = 0;
1329		1329
1330	for (offset = fdt_next_node(blob, -1, NULL); offset >= 0;	1330	for (offset = fdt_next_node(blob, -1, NULL); offset >= 0;
1331	offset = fdt_next_node(blob, offset, NULL)) {	1331	offset = fdt_next_node(blob, offset, NULL)) {
1332	phandle = max(phandle, fdt_get_phandle(blob, offset));	1332	phandle = max(phandle, fdt_get_phandle(blob, offset));
1333	}	1333	}
1334		1334
1335	return phandle + 1;	1335	return phandle + 1;
1336	}	1336	}
1337		1337
1338	/*	1338	/*
1339	* fdt_set_phandle: Create a phandle property for the given node	1339	* fdt_set_phandle: Create a phandle property for the given node
1340	*	1340	*
1341	* @fdt: ptr to device tree	1341	* @fdt: ptr to device tree
1342	* @nodeoffset: node to update	1342	* @nodeoffset: node to update
1343	* @phandle: phandle value to set (must be unique)	1343	* @phandle: phandle value to set (must be unique)
1344	*/	1344	*/
1345	int fdt_set_phandle(void *fdt, int nodeoffset, uint32_t phandle)	1345	int fdt_set_phandle(void *fdt, int nodeoffset, uint32_t phandle)
1346	{	1346	{
1347	int ret;	1347	int ret;
1348		1348
1349	#ifdef DEBUG	1349	#ifdef DEBUG
1350	int off = fdt_node_offset_by_phandle(fdt, phandle);	1350	int off = fdt_node_offset_by_phandle(fdt, phandle);
1351		1351
1352	if ((off >= 0) && (off != nodeoffset)) {	1352	if ((off >= 0) && (off != nodeoffset)) {
1353	char buf[64];	1353	char buf[64];
1354		1354
1355	fdt_get_path(fdt, nodeoffset, buf, sizeof(buf));	1355	fdt_get_path(fdt, nodeoffset, buf, sizeof(buf));
1356	printf("Trying to update node %s with phandle %u ",	1356	printf("Trying to update node %s with phandle %u ",
1357	buf, phandle);	1357	buf, phandle);
1358		1358
1359	fdt_get_path(fdt, off, buf, sizeof(buf));	1359	fdt_get_path(fdt, off, buf, sizeof(buf));
1360	printf("that already exists in node %s.\n", buf);	1360	printf("that already exists in node %s.\n", buf);
1361	return -FDT_ERR_BADPHANDLE;	1361	return -FDT_ERR_BADPHANDLE;
1362	}	1362	}
1363	#endif	1363	#endif
1364		1364
1365	ret = fdt_setprop_cell(fdt, nodeoffset, "phandle", phandle);	1365	ret = fdt_setprop_cell(fdt, nodeoffset, "phandle", phandle);
1366	if (ret < 0)	1366	if (ret < 0)
1367	return ret;	1367	return ret;
1368		1368
1369	/*	1369	/*
1370	* For now, also set the deprecated "linux,phandle" property, so that we	1370	* For now, also set the deprecated "linux,phandle" property, so that we
1371	* don't break older kernels.	1371	* don't break older kernels.
1372	*/	1372	*/
1373	ret = fdt_setprop_cell(fdt, nodeoffset, "linux,phandle", phandle);	1373	ret = fdt_setprop_cell(fdt, nodeoffset, "linux,phandle", phandle);
1374		1374
1375	return ret;	1375	return ret;
1376	}	1376	}
1377		1377
1378	/*	1378	/*
1379	* fdt_create_phandle: Create a phandle property for the given node	1379	* fdt_create_phandle: Create a phandle property for the given node
1380	*	1380	*
1381	* @fdt: ptr to device tree	1381	* @fdt: ptr to device tree
1382	* @nodeoffset: node to update	1382	* @nodeoffset: node to update
1383	*/	1383	*/
1384	unsigned int fdt_create_phandle(void *fdt, int nodeoffset)	1384	unsigned int fdt_create_phandle(void *fdt, int nodeoffset)
1385	{	1385	{
1386	/* see if there is a phandle already */	1386	/* see if there is a phandle already */
1387	int phandle = fdt_get_phandle(fdt, nodeoffset);	1387	int phandle = fdt_get_phandle(fdt, nodeoffset);
1388		1388
1389	/* if we got 0, means no phandle so create one */	1389	/* if we got 0, means no phandle so create one */
1390	if (phandle == 0) {	1390	if (phandle == 0) {
1391	int ret;	1391	int ret;
1392		1392
1393	phandle = fdt_alloc_phandle(fdt);	1393	phandle = fdt_alloc_phandle(fdt);
1394	ret = fdt_set_phandle(fdt, nodeoffset, phandle);	1394	ret = fdt_set_phandle(fdt, nodeoffset, phandle);
1395	if (ret < 0) {	1395	if (ret < 0) {
1396	printf("Can't set phandle %u: %s\n", phandle,	1396	printf("Can't set phandle %u: %s\n", phandle,
1397	fdt_strerror(ret));	1397	fdt_strerror(ret));
1398	return 0;	1398	return 0;
1399	}	1399	}
1400	}	1400	}
1401		1401
1402	return phandle;	1402	return phandle;
1403	}	1403	}
1404		1404
1405	/*	1405	/*
1406	* fdt_set_node_status: Set status for the given node	1406	* fdt_set_node_status: Set status for the given node
1407	*	1407	*
1408	* @fdt: ptr to device tree	1408	* @fdt: ptr to device tree
1409	* @nodeoffset: node to update	1409	* @nodeoffset: node to update
1410	* @status: FDT_STATUS_OKAY, FDT_STATUS_DISABLED,	1410	* @status: FDT_STATUS_OKAY, FDT_STATUS_DISABLED,
1411	* FDT_STATUS_FAIL, FDT_STATUS_FAIL_ERROR_CODE	1411	* FDT_STATUS_FAIL, FDT_STATUS_FAIL_ERROR_CODE
1412	* @error_code: optional, only used if status is FDT_STATUS_FAIL_ERROR_CODE	1412	* @error_code: optional, only used if status is FDT_STATUS_FAIL_ERROR_CODE
1413	*/	1413	*/
1414	int fdt_set_node_status(void *fdt, int nodeoffset,	1414	int fdt_set_node_status(void *fdt, int nodeoffset,
1415	enum fdt_status status, unsigned int error_code)	1415	enum fdt_status status, unsigned int error_code)
1416	{	1416	{
1417	char buf[16];	1417	char buf[16];
1418	int ret = 0;	1418	int ret = 0;
1419		1419
1420	if (nodeoffset < 0)	1420	if (nodeoffset < 0)
1421	return nodeoffset;	1421	return nodeoffset;
1422		1422
1423	switch (status) {	1423	switch (status) {
1424	case FDT_STATUS_OKAY:	1424	case FDT_STATUS_OKAY:
1425	ret = fdt_setprop_string(fdt, nodeoffset, "status", "okay");	1425	ret = fdt_setprop_string(fdt, nodeoffset, "status", "okay");
1426	break;	1426	break;
1427	case FDT_STATUS_DISABLED:	1427	case FDT_STATUS_DISABLED:
1428	ret = fdt_setprop_string(fdt, nodeoffset, "status", "disabled");	1428	ret = fdt_setprop_string(fdt, nodeoffset, "status", "disabled");
1429	break;	1429	break;
1430	case FDT_STATUS_FAIL:	1430	case FDT_STATUS_FAIL:
1431	ret = fdt_setprop_string(fdt, nodeoffset, "status", "fail");	1431	ret = fdt_setprop_string(fdt, nodeoffset, "status", "fail");
1432	break;	1432	break;
1433	case FDT_STATUS_FAIL_ERROR_CODE:	1433	case FDT_STATUS_FAIL_ERROR_CODE:
1434	sprintf(buf, "fail-%d", error_code);	1434	sprintf(buf, "fail-%d", error_code);
1435	ret = fdt_setprop_string(fdt, nodeoffset, "status", buf);	1435	ret = fdt_setprop_string(fdt, nodeoffset, "status", buf);
1436	break;	1436	break;
1437	default:	1437	default:
1438	printf("Invalid fdt status: %x\n", status);	1438	printf("Invalid fdt status: %x\n", status);
1439	ret = -1;	1439	ret = -1;
1440	break;	1440	break;
1441	}	1441	}
1442		1442
1443	return ret;	1443	return ret;
1444	}	1444	}
1445		1445
1446	/*	1446	/*
1447	* fdt_set_status_by_alias: Set status for the given node given an alias	1447	* fdt_set_status_by_alias: Set status for the given node given an alias
1448	*	1448	*
1449	* @fdt: ptr to device tree	1449	* @fdt: ptr to device tree
1450	* @alias: alias of node to update	1450	* @alias: alias of node to update
1451	* @status: FDT_STATUS_OKAY, FDT_STATUS_DISABLED,	1451	* @status: FDT_STATUS_OKAY, FDT_STATUS_DISABLED,
1452	* FDT_STATUS_FAIL, FDT_STATUS_FAIL_ERROR_CODE	1452	* FDT_STATUS_FAIL, FDT_STATUS_FAIL_ERROR_CODE
1453	* @error_code: optional, only used if status is FDT_STATUS_FAIL_ERROR_CODE	1453	* @error_code: optional, only used if status is FDT_STATUS_FAIL_ERROR_CODE
1454	*/	1454	*/
1455	int fdt_set_status_by_alias(void fdt, const char alias,	1455	int fdt_set_status_by_alias(void fdt, const char alias,
1456	enum fdt_status status, unsigned int error_code)	1456	enum fdt_status status, unsigned int error_code)
1457	{	1457	{
1458	int offset = fdt_path_offset(fdt, alias);	1458	int offset = fdt_path_offset(fdt, alias);
1459		1459
1460	return fdt_set_node_status(fdt, offset, status, error_code);	1460	return fdt_set_node_status(fdt, offset, status, error_code);
1461	}	1461	}
1462		1462
1463	#if defined(CONFIG_VIDEO) \|\| defined(CONFIG_LCD)	1463	#if defined(CONFIG_VIDEO) \|\| defined(CONFIG_LCD)
1464	int fdt_add_edid(void blob, const char compat, unsigned char *edid_buf)	1464	int fdt_add_edid(void blob, const char compat, unsigned char *edid_buf)
1465	{	1465	{
1466	int noff;	1466	int noff;
1467	int ret;	1467	int ret;
1468		1468
1469	noff = fdt_node_offset_by_compatible(blob, -1, compat);	1469	noff = fdt_node_offset_by_compatible(blob, -1, compat);
1470	if (noff != -FDT_ERR_NOTFOUND) {	1470	if (noff != -FDT_ERR_NOTFOUND) {
1471	debug("%s: %s\n", fdt_get_name(blob, noff, 0), compat);	1471	debug("%s: %s\n", fdt_get_name(blob, noff, 0), compat);
1472	add_edid:	1472	add_edid:
1473	ret = fdt_setprop(blob, noff, "edid", edid_buf, 128);	1473	ret = fdt_setprop(blob, noff, "edid", edid_buf, 128);
1474	if (ret == -FDT_ERR_NOSPACE) {	1474	if (ret == -FDT_ERR_NOSPACE) {
1475	ret = fdt_increase_size(blob, 512);	1475	ret = fdt_increase_size(blob, 512);
1476	if (!ret)	1476	if (!ret)
1477	goto add_edid;	1477	goto add_edid;
1478	else	1478	else
1479	goto err_size;	1479	goto err_size;
1480	} else if (ret < 0) {	1480	} else if (ret < 0) {
1481	printf("Can't add property: %s\n", fdt_strerror(ret));	1481	printf("Can't add property: %s\n", fdt_strerror(ret));
1482	return ret;	1482	return ret;
1483	}	1483	}
1484	}	1484	}
1485	return 0;	1485	return 0;
1486	err_size:	1486	err_size:
1487	printf("Can't increase blob size: %s\n", fdt_strerror(ret));	1487	printf("Can't increase blob size: %s\n", fdt_strerror(ret));
1488	return ret;	1488	return ret;
1489	}	1489	}
1490	#endif	1490	#endif
1491		1491
1492	/*	1492	/*
1493	* Verify the physical address of device tree node for a given alias	1493	* Verify the physical address of device tree node for a given alias
1494	*	1494	*
1495	* This function locates the device tree node of a given alias, and then	1495	* This function locates the device tree node of a given alias, and then
1496	* verifies that the physical address of that device matches the given	1496	* verifies that the physical address of that device matches the given
1497	* parameter. It displays a message if there is a mismatch.	1497	* parameter. It displays a message if there is a mismatch.
1498	*	1498	*
1499	* Returns 1 on success, 0 on failure	1499	* Returns 1 on success, 0 on failure
1500	*/	1500	*/
1501	int fdt_verify_alias_address(void fdt, int anode, const char alias, u64 addr)	1501	int fdt_verify_alias_address(void fdt, int anode, const char alias, u64 addr)
1502	{	1502	{
1503	const char *path;	1503	const char *path;
1504	const fdt32_t *reg;	1504	const fdt32_t *reg;
1505	int node, len;	1505	int node, len;
1506	u64 dt_addr;	1506	u64 dt_addr;
1507		1507
1508	path = fdt_getprop(fdt, anode, alias, NULL);	1508	path = fdt_getprop(fdt, anode, alias, NULL);
1509	if (!path) {	1509	if (!path) {
1510	/* If there's no such alias, then it's not a failure */	1510	/* If there's no such alias, then it's not a failure */
1511	return 1;	1511	return 1;
1512	}	1512	}
1513		1513
1514	node = fdt_path_offset(fdt, path);	1514	node = fdt_path_offset(fdt, path);
1515	if (node < 0) {	1515	if (node < 0) {
1516	printf("Warning: device tree alias '%s' points to invalid "	1516	printf("Warning: device tree alias '%s' points to invalid "
1517	"node %s.\n", alias, path);	1517	"node %s.\n", alias, path);
1518	return 0;	1518	return 0;
1519	}	1519	}
1520		1520
1521	reg = fdt_getprop(fdt, node, "reg", &len);	1521	reg = fdt_getprop(fdt, node, "reg", &len);
1522	if (!reg) {	1522	if (!reg) {
1523	printf("Warning: device tree node '%s' has no address.\n",	1523	printf("Warning: device tree node '%s' has no address.\n",
1524	path);	1524	path);
1525	return 0;	1525	return 0;
1526	}	1526	}
1527		1527
1528	dt_addr = fdt_translate_address(fdt, node, reg);	1528	dt_addr = fdt_translate_address(fdt, node, reg);
1529	if (addr != dt_addr) {	1529	if (addr != dt_addr) {
1530	printf("Warning: U-Boot configured device %s at address %"	1530	printf("Warning: U-Boot configured device %s at address %"
1531	PRIx64 ",\n but the device tree has it address %"	1531	PRIx64 ",\n but the device tree has it address %"
1532	PRIx64 ".\n", alias, addr, dt_addr);	1532	PRIx64 ".\n", alias, addr, dt_addr);
1533	return 0;	1533	return 0;
1534	}	1534	}
1535		1535
1536	return 1;	1536	return 1;
1537	}	1537	}
1538		1538
1539	/*	1539	/*
1540	* Returns the base address of an SOC or PCI node	1540	* Returns the base address of an SOC or PCI node
1541	*/	1541	*/
1542	u64 fdt_get_base_address(void *fdt, int node)	1542	u64 fdt_get_base_address(const void *fdt, int node)
1543	{	1543	{
1544	int size;	1544	int size;
1545	u32 naddr;	1545	u32 naddr;
1546	const fdt32_t *prop;	1546	const fdt32_t *prop;
1547		1547
1548	naddr = fdt_address_cells(fdt, node);	1548	naddr = fdt_address_cells(fdt, node);
1549		1549
1550	prop = fdt_getprop(fdt, node, "ranges", &size);	1550	prop = fdt_getprop(fdt, node, "ranges", &size);
1551		1551
1552	return prop ? fdt_translate_address(fdt, node, prop + naddr) : 0;	1552	return prop ? fdt_translate_address(fdt, node, prop + naddr) : 0;
1553	}	1553	}
1554		1554
1555	/*	1555	/*
1556	* Read a property of size <prop_len>. Currently only supports 1 or 2 cells.	1556	* Read a property of size <prop_len>. Currently only supports 1 or 2 cells.
1557	*/	1557	*/
1558	static int fdt_read_prop(const fdt32_t *prop, int prop_len, int cell_off,	1558	static int fdt_read_prop(const fdt32_t *prop, int prop_len, int cell_off,
1559	uint64_t *val, int cells)	1559	uint64_t *val, int cells)
1560	{	1560	{
1561	const fdt32_t *prop32 = &prop[cell_off];	1561	const fdt32_t *prop32 = &prop[cell_off];
1562	const fdt64_t prop64 = (const fdt64_t )&prop[cell_off];	1562	const fdt64_t prop64 = (const fdt64_t )&prop[cell_off];
1563		1563
1564	if ((cell_off + cells) > prop_len)	1564	if ((cell_off + cells) > prop_len)
1565	return -FDT_ERR_NOSPACE;	1565	return -FDT_ERR_NOSPACE;
1566		1566
1567	switch (cells) {	1567	switch (cells) {
1568	case 1:	1568	case 1:
1569	val = fdt32_to_cpu(prop32);	1569	val = fdt32_to_cpu(prop32);
1570	break;	1570	break;
1571	case 2:	1571	case 2:
1572	val = fdt64_to_cpu(prop64);	1572	val = fdt64_to_cpu(prop64);
1573	break;	1573	break;
1574	default:	1574	default:
1575	return -FDT_ERR_NOSPACE;	1575	return -FDT_ERR_NOSPACE;
1576	}	1576	}
1577		1577
1578	return 0;	1578	return 0;
1579	}	1579	}
1580		1580
1581	/**	1581	/**
1582	* fdt_read_range - Read a node's n'th range property	1582	* fdt_read_range - Read a node's n'th range property
1583	*	1583	*
1584	* @fdt: ptr to device tree	1584	* @fdt: ptr to device tree
1585	* @node: offset of node	1585	* @node: offset of node
1586	* @n: range index	1586	* @n: range index
1587	* @child_addr: pointer to storage for the "child address" field	1587	* @child_addr: pointer to storage for the "child address" field
1588	* @addr: pointer to storage for the CPU view translated physical start	1588	* @addr: pointer to storage for the CPU view translated physical start
1589	* @len: pointer to storage for the range length	1589	* @len: pointer to storage for the range length
1590	*	1590	*
1591	* Convenience function that reads and interprets a specific range out of	1591	* Convenience function that reads and interprets a specific range out of
1592	* a number of the "ranges" property array.	1592	* a number of the "ranges" property array.
1593	*/	1593	*/
1594	int fdt_read_range(void fdt, int node, int n, uint64_t child_addr,	1594	int fdt_read_range(void fdt, int node, int n, uint64_t child_addr,
1595	uint64_t addr, uint64_t len)	1595	uint64_t addr, uint64_t len)
1596	{	1596	{
1597	int pnode = fdt_parent_offset(fdt, node);	1597	int pnode = fdt_parent_offset(fdt, node);
1598	const fdt32_t *ranges;	1598	const fdt32_t *ranges;
1599	int pacells;	1599	int pacells;
1600	int acells;	1600	int acells;
1601	int scells;	1601	int scells;
1602	int ranges_len;	1602	int ranges_len;
1603	int cell = 0;	1603	int cell = 0;
1604	int r = 0;	1604	int r = 0;
1605		1605
1606	/*	1606	/*
1607	* The "ranges" property is an array of	1607	* The "ranges" property is an array of
1608	* { <child address> <parent address> <size in child address space> }	1608	* { <child address> <parent address> <size in child address space> }
1609	*	1609	*
1610	* All 3 elements can span a diffent number of cells. Fetch their size.	1610	* All 3 elements can span a diffent number of cells. Fetch their size.
1611	*/	1611	*/
1612	pacells = fdt_getprop_u32_default_node(fdt, pnode, 0, "#address-cells", 1);	1612	pacells = fdt_getprop_u32_default_node(fdt, pnode, 0, "#address-cells", 1);
1613	acells = fdt_getprop_u32_default_node(fdt, node, 0, "#address-cells", 1);	1613	acells = fdt_getprop_u32_default_node(fdt, node, 0, "#address-cells", 1);
1614	scells = fdt_getprop_u32_default_node(fdt, node, 0, "#size-cells", 1);	1614	scells = fdt_getprop_u32_default_node(fdt, node, 0, "#size-cells", 1);
1615		1615
1616	/* Now try to get the ranges property */	1616	/* Now try to get the ranges property */
1617	ranges = fdt_getprop(fdt, node, "ranges", &ranges_len);	1617	ranges = fdt_getprop(fdt, node, "ranges", &ranges_len);
1618	if (!ranges)	1618	if (!ranges)
1619	return -FDT_ERR_NOTFOUND;	1619	return -FDT_ERR_NOTFOUND;
1620	ranges_len /= sizeof(uint32_t);	1620	ranges_len /= sizeof(uint32_t);
1621		1621
1622	/* Jump to the n'th entry */	1622	/* Jump to the n'th entry */
1623	cell = n * (pacells + acells + scells);	1623	cell = n * (pacells + acells + scells);
1624		1624
1625	/* Read <child address> */	1625	/* Read <child address> */
1626	if (child_addr) {	1626	if (child_addr) {
1627	r = fdt_read_prop(ranges, ranges_len, cell, child_addr,	1627	r = fdt_read_prop(ranges, ranges_len, cell, child_addr,
1628	acells);	1628	acells);
1629	if (r)	1629	if (r)
1630	return r;	1630	return r;
1631	}	1631	}
1632	cell += acells;	1632	cell += acells;
1633		1633
1634	/* Read <parent address> */	1634	/* Read <parent address> */
1635	if (addr)	1635	if (addr)
1636	*addr = fdt_translate_address(fdt, node, ranges + cell);	1636	*addr = fdt_translate_address(fdt, node, ranges + cell);
1637	cell += pacells;	1637	cell += pacells;
1638		1638
1639	/* Read <size in child address space> */	1639	/* Read <size in child address space> */
1640	if (len) {	1640	if (len) {
1641	r = fdt_read_prop(ranges, ranges_len, cell, len, scells);	1641	r = fdt_read_prop(ranges, ranges_len, cell, len, scells);
1642	if (r)	1642	if (r)
1643	return r;	1643	return r;
1644	}	1644	}
1645		1645
1646	return 0;	1646	return 0;
1647	}	1647	}
1648		1648
1649	/**	1649	/**
1650	* fdt_setup_simplefb_node - Fill and enable a simplefb node	1650	* fdt_setup_simplefb_node - Fill and enable a simplefb node
1651	*	1651	*
1652	* @fdt: ptr to device tree	1652	* @fdt: ptr to device tree
1653	* @node: offset of the simplefb node	1653	* @node: offset of the simplefb node
1654	* @base_address: framebuffer base address	1654	* @base_address: framebuffer base address
1655	* @width: width in pixels	1655	* @width: width in pixels
1656	* @height: height in pixels	1656	* @height: height in pixels
1657	* @stride: bytes per line	1657	* @stride: bytes per line
1658	* @format: pixel format string	1658	* @format: pixel format string
1659	*	1659	*
1660	* Convenience function to fill and enable a simplefb node.	1660	* Convenience function to fill and enable a simplefb node.
1661	*/	1661	*/
1662	int fdt_setup_simplefb_node(void *fdt, int node, u64 base_address, u32 width,	1662	int fdt_setup_simplefb_node(void *fdt, int node, u64 base_address, u32 width,
1663	u32 height, u32 stride, const char *format)	1663	u32 height, u32 stride, const char *format)
1664	{	1664	{
1665	char name[32];	1665	char name[32];
1666	fdt32_t cells[4];	1666	fdt32_t cells[4];
1667	int i, addrc, sizec, ret;	1667	int i, addrc, sizec, ret;
1668		1668
1669	of_bus_default_count_cells(fdt, fdt_parent_offset(fdt, node),	1669	of_bus_default_count_cells(fdt, fdt_parent_offset(fdt, node),
1670	&addrc, &sizec);	1670	&addrc, &sizec);
1671	i = 0;	1671	i = 0;
1672	if (addrc == 2)	1672	if (addrc == 2)
1673	cells[i++] = cpu_to_fdt32(base_address >> 32);	1673	cells[i++] = cpu_to_fdt32(base_address >> 32);
1674	cells[i++] = cpu_to_fdt32(base_address);	1674	cells[i++] = cpu_to_fdt32(base_address);
1675	if (sizec == 2)	1675	if (sizec == 2)
1676	cells[i++] = 0;	1676	cells[i++] = 0;
1677	cells[i++] = cpu_to_fdt32(height * stride);	1677	cells[i++] = cpu_to_fdt32(height * stride);
1678		1678
1679	ret = fdt_setprop(fdt, node, "reg", cells, sizeof(cells[0]) * i);	1679	ret = fdt_setprop(fdt, node, "reg", cells, sizeof(cells[0]) * i);
1680	if (ret < 0)	1680	if (ret < 0)
1681	return ret;	1681	return ret;
1682		1682
1683	snprintf(name, sizeof(name), "framebuffer@%" PRIx64, base_address);	1683	snprintf(name, sizeof(name), "framebuffer@%" PRIx64, base_address);
1684	ret = fdt_set_name(fdt, node, name);	1684	ret = fdt_set_name(fdt, node, name);
1685	if (ret < 0)	1685	if (ret < 0)
1686	return ret;	1686	return ret;
1687		1687
1688	ret = fdt_setprop_u32(fdt, node, "width", width);	1688	ret = fdt_setprop_u32(fdt, node, "width", width);
1689	if (ret < 0)	1689	if (ret < 0)
1690	return ret;	1690	return ret;
1691		1691
1692	ret = fdt_setprop_u32(fdt, node, "height", height);	1692	ret = fdt_setprop_u32(fdt, node, "height", height);
1693	if (ret < 0)	1693	if (ret < 0)
1694	return ret;	1694	return ret;
1695		1695
1696	ret = fdt_setprop_u32(fdt, node, "stride", stride);	1696	ret = fdt_setprop_u32(fdt, node, "stride", stride);
1697	if (ret < 0)	1697	if (ret < 0)
1698	return ret;	1698	return ret;
1699		1699
1700	ret = fdt_setprop_string(fdt, node, "format", format);	1700	ret = fdt_setprop_string(fdt, node, "format", format);
1701	if (ret < 0)	1701	if (ret < 0)
1702	return ret;	1702	return ret;
1703		1703
1704	ret = fdt_setprop_string(fdt, node, "status", "okay");	1704	ret = fdt_setprop_string(fdt, node, "status", "okay");
1705	if (ret < 0)	1705	if (ret < 0)
1706	return ret;	1706	return ret;
1707		1707
1708	return 0;	1708	return 0;
1709	}	1709	}
1710		1710
1711	/*	1711	/*
1712	* Update native-mode in display-timings from display environment variable.	1712	* Update native-mode in display-timings from display environment variable.
1713	* The node to update are specified by path.	1713	* The node to update are specified by path.
1714	*/	1714	*/
1715	int fdt_fixup_display(void blob, const char path, const char *display)	1715	int fdt_fixup_display(void blob, const char path, const char *display)
1716	{	1716	{
1717	int off, toff;	1717	int off, toff;
1718		1718
1719	if (!display \|\| !path)	1719	if (!display \|\| !path)
1720	return -FDT_ERR_NOTFOUND;	1720	return -FDT_ERR_NOTFOUND;
1721		1721
1722	toff = fdt_path_offset(blob, path);	1722	toff = fdt_path_offset(blob, path);
1723	if (toff >= 0)	1723	if (toff >= 0)
1724	toff = fdt_subnode_offset(blob, toff, "display-timings");	1724	toff = fdt_subnode_offset(blob, toff, "display-timings");
1725	if (toff < 0)	1725	if (toff < 0)
1726	return toff;	1726	return toff;
1727		1727
1728	for (off = fdt_first_subnode(blob, toff);	1728	for (off = fdt_first_subnode(blob, toff);
1729	off >= 0;	1729	off >= 0;
1730	off = fdt_next_subnode(blob, off)) {	1730	off = fdt_next_subnode(blob, off)) {
1731	uint32_t h = fdt_get_phandle(blob, off);	1731	uint32_t h = fdt_get_phandle(blob, off);
1732	debug("%s:0x%x\n", fdt_get_name(blob, off, NULL),	1732	debug("%s:0x%x\n", fdt_get_name(blob, off, NULL),
1733	fdt32_to_cpu(h));	1733	fdt32_to_cpu(h));
1734	if (strcasecmp(fdt_get_name(blob, off, NULL), display) == 0)	1734	if (strcasecmp(fdt_get_name(blob, off, NULL), display) == 0)
1735	return fdt_setprop_u32(blob, toff, "native-mode", h);	1735	return fdt_setprop_u32(blob, toff, "native-mode", h);
1736	}	1736	}
1737	return toff;	1737	return toff;
1738	}	1738	}
1739		1739

include/fdt_support.h

Diff comments View file @ ec00211