Eric Lee / smarc-uboot | Embedian Git Server

Commit aabd7ddb889aec3c6c4139974f66a44e2ce46ba5

Authored by York Sun 2015-12-08 03:05:29 +0800

Exists in v2017.01-smarct4x and in 30 other branches

common: Rewrite hiding the end of memory

As the name may be confusing, the CONFIG_SYS_MEM_TOP_HIDE reserves
some memory from the end of ram, tracked by gd->ram_size. It is not
always the top of u-boot visible memory. Rewrite the macro with a
weak function to provide flexibility for complex calcuation. Legacy
use of this macro is still supported.

Signed-off-by: York Sun <yorksun@freescale.com>
Reviewed-by: Simon Glass <sjg@chromium.org>

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

README
common/board_f.c

README

Diff comments View file @ aabd7dd

common/board_f.c

Diff comments View file @ aabd7dd

1	/*	1	/*
2	* Copyright (c) 2011 The Chromium OS Authors.	2	* Copyright (c) 2011 The Chromium OS Authors.
3	* (C) Copyright 2002-2006	3	* (C) Copyright 2002-2006
4	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.	4	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5	*	5	*
6	* (C) Copyright 2002	6	* (C) Copyright 2002
7	* Sysgo Real-Time Solutions, GmbH <www.elinos.com>	7	* Sysgo Real-Time Solutions, GmbH <www.elinos.com>
8	* Marius Groeger <mgroeger@sysgo.de>	8	* Marius Groeger <mgroeger@sysgo.de>
9	*	9	*
10	* SPDX-License-Identifier: GPL-2.0+	10	* SPDX-License-Identifier: GPL-2.0+
11	*/	11	*/
12		12
13	#include <common.h>	13	#include <common.h>
14	#include <linux/compiler.h>	14	#include <linux/compiler.h>
15	#include <version.h>	15	#include <version.h>
16	#include <console.h>	16	#include <console.h>
17	#include <environment.h>	17	#include <environment.h>
18	#include <dm.h>	18	#include <dm.h>
19	#include <fdtdec.h>	19	#include <fdtdec.h>
20	#include <fs.h>	20	#include <fs.h>
21	#if defined(CONFIG_CMD_IDE)	21	#if defined(CONFIG_CMD_IDE)
22	#include <ide.h>	22	#include <ide.h>
23	#endif	23	#endif
24	#include <i2c.h>	24	#include <i2c.h>
25	#include <initcall.h>	25	#include <initcall.h>
26	#include <logbuff.h>	26	#include <logbuff.h>
27	#include <malloc.h>	27	#include <malloc.h>
28	#include <mapmem.h>	28	#include <mapmem.h>
29		29
30	/* TODO: Can we move these into arch/ headers? */	30	/* TODO: Can we move these into arch/ headers? */
31	#ifdef CONFIG_8xx	31	#ifdef CONFIG_8xx
32	#include <mpc8xx.h>	32	#include <mpc8xx.h>
33	#endif	33	#endif
34	#ifdef CONFIG_5xx	34	#ifdef CONFIG_5xx
35	#include <mpc5xx.h>	35	#include <mpc5xx.h>
36	#endif	36	#endif
37	#ifdef CONFIG_MPC5xxx	37	#ifdef CONFIG_MPC5xxx
38	#include <mpc5xxx.h>	38	#include <mpc5xxx.h>
39	#endif	39	#endif
40	#if defined(CONFIG_MP) && (defined(CONFIG_MPC86xx) \|\| defined(CONFIG_E500))	40	#if defined(CONFIG_MP) && (defined(CONFIG_MPC86xx) \|\| defined(CONFIG_E500))
41	#include <asm/mp.h>	41	#include <asm/mp.h>
42	#endif	42	#endif
43		43
44	#include <os.h>	44	#include <os.h>
45	#include <post.h>	45	#include <post.h>
46	#include <spi.h>	46	#include <spi.h>
47	#include <status_led.h>	47	#include <status_led.h>
48	#include <trace.h>	48	#include <trace.h>
49	#include <watchdog.h>	49	#include <watchdog.h>
50	#include <asm/errno.h>	50	#include <asm/errno.h>
51	#include <asm/io.h>	51	#include <asm/io.h>
52	#include <asm/sections.h>	52	#include <asm/sections.h>
53	#if defined(CONFIG_X86) \|\| defined(CONFIG_ARC)	53	#if defined(CONFIG_X86) \|\| defined(CONFIG_ARC)
54	#include <asm/init_helpers.h>	54	#include <asm/init_helpers.h>
55	#include <asm/relocate.h>	55	#include <asm/relocate.h>
56	#endif	56	#endif
57	#ifdef CONFIG_SANDBOX	57	#ifdef CONFIG_SANDBOX
58	#include <asm/state.h>	58	#include <asm/state.h>
59	#endif	59	#endif
60	#include <dm/root.h>	60	#include <dm/root.h>
61	#include <linux/compiler.h>	61	#include <linux/compiler.h>
62		62
63	/*	63	/*
64	* Pointer to initial global data area	64	* Pointer to initial global data area
65	*	65	*
66	* Here we initialize it if needed.	66	* Here we initialize it if needed.
67	*/	67	*/
68	#ifdef XTRN_DECLARE_GLOBAL_DATA_PTR	68	#ifdef XTRN_DECLARE_GLOBAL_DATA_PTR
69	#undef XTRN_DECLARE_GLOBAL_DATA_PTR	69	#undef XTRN_DECLARE_GLOBAL_DATA_PTR
70	#define XTRN_DECLARE_GLOBAL_DATA_PTR /* empty = allocate here */	70	#define XTRN_DECLARE_GLOBAL_DATA_PTR /* empty = allocate here */
71	DECLARE_GLOBAL_DATA_PTR = (gd_t *) (CONFIG_SYS_INIT_GD_ADDR);	71	DECLARE_GLOBAL_DATA_PTR = (gd_t *) (CONFIG_SYS_INIT_GD_ADDR);
72	#else	72	#else
73	DECLARE_GLOBAL_DATA_PTR;	73	DECLARE_GLOBAL_DATA_PTR;
74	#endif	74	#endif
75		75
76	/*	76	/*
77	* TODO(sjg@chromium.org): IMO this code should be	77	* TODO(sjg@chromium.org): IMO this code should be
78	* refactored to a single function, something like:	78	* refactored to a single function, something like:
79	*	79	*
80	* void led_set_state(enum led_colour_t colour, int on);	80	* void led_set_state(enum led_colour_t colour, int on);
81	*/	81	*/
82	/************************************************************************	82	/************************************************************************
83	* Coloured LED functionality	83	* Coloured LED functionality
84	************************************************************************	84	************************************************************************
85	* May be supplied by boards if desired	85	* May be supplied by boards if desired
86	*/	86	*/
87	__weak void coloured_LED_init(void) {}	87	__weak void coloured_LED_init(void) {}
88	__weak void red_led_on(void) {}	88	__weak void red_led_on(void) {}
89	__weak void red_led_off(void) {}	89	__weak void red_led_off(void) {}
90	__weak void green_led_on(void) {}	90	__weak void green_led_on(void) {}
91	__weak void green_led_off(void) {}	91	__weak void green_led_off(void) {}
92	__weak void yellow_led_on(void) {}	92	__weak void yellow_led_on(void) {}
93	__weak void yellow_led_off(void) {}	93	__weak void yellow_led_off(void) {}
94	__weak void blue_led_on(void) {}	94	__weak void blue_led_on(void) {}
95	__weak void blue_led_off(void) {}	95	__weak void blue_led_off(void) {}
96		96
97	/*	97	/*
98	* Why is gd allocated a register? Prior to reloc it might be better to	98	* Why is gd allocated a register? Prior to reloc it might be better to
99	* just pass it around to each function in this file?	99	* just pass it around to each function in this file?
100	*	100	*
101	* After reloc one could argue that it is hardly used and doesn't need	101	* After reloc one could argue that it is hardly used and doesn't need
102	* to be in a register. Or if it is it should perhaps hold pointers to all	102	* to be in a register. Or if it is it should perhaps hold pointers to all
103	* global data for all modules, so that post-reloc we can avoid the massive	103	* global data for all modules, so that post-reloc we can avoid the massive
104	* literal pool we get on ARM. Or perhaps just encourage each module to use	104	* literal pool we get on ARM. Or perhaps just encourage each module to use
105	* a structure...	105	* a structure...
106	*/	106	*/
107		107
108	/*	108	/*
109	* Could the CONFIG_SPL_BUILD infection become a flag in gd?	109	* Could the CONFIG_SPL_BUILD infection become a flag in gd?
110	*/	110	*/
111		111
112	#if defined(CONFIG_WATCHDOG) \|\| defined(CONFIG_HW_WATCHDOG)	112	#if defined(CONFIG_WATCHDOG) \|\| defined(CONFIG_HW_WATCHDOG)
113	static int init_func_watchdog_init(void)	113	static int init_func_watchdog_init(void)
114	{	114	{
115	# if defined(CONFIG_HW_WATCHDOG) && (defined(CONFIG_BLACKFIN) \|\| \	115	# if defined(CONFIG_HW_WATCHDOG) && (defined(CONFIG_BLACKFIN) \|\| \
116	defined(CONFIG_M68K) \|\| defined(CONFIG_MICROBLAZE) \|\| \	116	defined(CONFIG_M68K) \|\| defined(CONFIG_MICROBLAZE) \|\| \
117	defined(CONFIG_SH) \|\| defined(CONFIG_AT91SAM9_WATCHDOG) \|\| \	117	defined(CONFIG_SH) \|\| defined(CONFIG_AT91SAM9_WATCHDOG) \|\| \
118	defined(CONFIG_IMX_WATCHDOG))	118	defined(CONFIG_IMX_WATCHDOG))
119	hw_watchdog_init();	119	hw_watchdog_init();
120	# endif	120	# endif
121	puts(" Watchdog enabled\n");	121	puts(" Watchdog enabled\n");
122	WATCHDOG_RESET();	122	WATCHDOG_RESET();
123		123
124	return 0;	124	return 0;
125	}	125	}
126		126
127	int init_func_watchdog_reset(void)	127	int init_func_watchdog_reset(void)
128	{	128	{
129	WATCHDOG_RESET();	129	WATCHDOG_RESET();
130		130
131	return 0;	131	return 0;
132	}	132	}
133	#endif /* CONFIG_WATCHDOG */	133	#endif /* CONFIG_WATCHDOG */
134		134
135	__weak void board_add_ram_info(int use_default)	135	__weak void board_add_ram_info(int use_default)
136	{	136	{
137	/* please define platform specific board_add_ram_info() */	137	/* please define platform specific board_add_ram_info() */
138	}	138	}
139		139
140	static int init_baud_rate(void)	140	static int init_baud_rate(void)
141	{	141	{
142	gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);	142	gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
143	return 0;	143	return 0;
144	}	144	}
145		145
146	static int display_text_info(void)	146	static int display_text_info(void)
147	{	147	{
148	#if !defined(CONFIG_SANDBOX) && !defined(CONFIG_EFI_APP)	148	#if !defined(CONFIG_SANDBOX) && !defined(CONFIG_EFI_APP)
149	ulong bss_start, bss_end, text_base;	149	ulong bss_start, bss_end, text_base;
150		150
151	bss_start = (ulong)&__bss_start;	151	bss_start = (ulong)&__bss_start;
152	bss_end = (ulong)&__bss_end;	152	bss_end = (ulong)&__bss_end;
153		153
154	#ifdef CONFIG_SYS_TEXT_BASE	154	#ifdef CONFIG_SYS_TEXT_BASE
155	text_base = CONFIG_SYS_TEXT_BASE;	155	text_base = CONFIG_SYS_TEXT_BASE;
156	#else	156	#else
157	text_base = CONFIG_SYS_MONITOR_BASE;	157	text_base = CONFIG_SYS_MONITOR_BASE;
158	#endif	158	#endif
159		159
160	debug("U-Boot code: %08lX -> %08lX BSS: -> %08lX\n",	160	debug("U-Boot code: %08lX -> %08lX BSS: -> %08lX\n",
161	text_base, bss_start, bss_end);	161	text_base, bss_start, bss_end);
162	#endif	162	#endif
163		163
164	#ifdef CONFIG_MODEM_SUPPORT	164	#ifdef CONFIG_MODEM_SUPPORT
165	debug("Modem Support enabled\n");	165	debug("Modem Support enabled\n");
166	#endif	166	#endif
167	#ifdef CONFIG_USE_IRQ	167	#ifdef CONFIG_USE_IRQ
168	debug("IRQ Stack: %08lx\n", IRQ_STACK_START);	168	debug("IRQ Stack: %08lx\n", IRQ_STACK_START);
169	debug("FIQ Stack: %08lx\n", FIQ_STACK_START);	169	debug("FIQ Stack: %08lx\n", FIQ_STACK_START);
170	#endif	170	#endif
171		171
172	return 0;	172	return 0;
173	}	173	}
174		174
175	static int announce_dram_init(void)	175	static int announce_dram_init(void)
176	{	176	{
177	puts("DRAM: ");	177	puts("DRAM: ");
178	return 0;	178	return 0;
179	}	179	}
180		180
181	#if defined(CONFIG_MIPS) \|\| defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)	181	#if defined(CONFIG_MIPS) \|\| defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)
182	static int init_func_ram(void)	182	static int init_func_ram(void)
183	{	183	{
184	#ifdef CONFIG_BOARD_TYPES	184	#ifdef CONFIG_BOARD_TYPES
185	int board_type = gd->board_type;	185	int board_type = gd->board_type;
186	#else	186	#else
187	int board_type = 0; /* use dummy arg */	187	int board_type = 0; /* use dummy arg */
188	#endif	188	#endif
189		189
190	gd->ram_size = initdram(board_type);	190	gd->ram_size = initdram(board_type);
191		191
192	if (gd->ram_size > 0)	192	if (gd->ram_size > 0)
193	return 0;	193	return 0;
194		194
195	puts("* failed *\n");	195	puts("* failed *\n");
196	return 1;	196	return 1;
197	}	197	}
198	#endif	198	#endif
199		199
200	static int show_dram_config(void)	200	static int show_dram_config(void)
201	{	201	{
202	unsigned long long size;	202	unsigned long long size;
203		203
204	#ifdef CONFIG_NR_DRAM_BANKS	204	#ifdef CONFIG_NR_DRAM_BANKS
205	int i;	205	int i;
206		206
207	debug("\nRAM Configuration:\n");	207	debug("\nRAM Configuration:\n");
208	for (i = size = 0; i < CONFIG_NR_DRAM_BANKS; i++) {	208	for (i = size = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
209	size += gd->bd->bi_dram[i].size;	209	size += gd->bd->bi_dram[i].size;
210	debug("Bank #%d: %llx ", i,	210	debug("Bank #%d: %llx ", i,
211	(unsigned long long)(gd->bd->bi_dram[i].start));	211	(unsigned long long)(gd->bd->bi_dram[i].start));
212	#ifdef DEBUG	212	#ifdef DEBUG
213	print_size(gd->bd->bi_dram[i].size, "\n");	213	print_size(gd->bd->bi_dram[i].size, "\n");
214	#endif	214	#endif
215	}	215	}
216	debug("\nDRAM: ");	216	debug("\nDRAM: ");
217	#else	217	#else
218	size = gd->ram_size;	218	size = gd->ram_size;
219	#endif	219	#endif
220		220
221	print_size(size, "");	221	print_size(size, "");
222	board_add_ram_info(0);	222	board_add_ram_info(0);
223	putc('\n');	223	putc('\n');
224		224
225	return 0;	225	return 0;
226	}	226	}
227		227
228	__weak void dram_init_banksize(void)	228	__weak void dram_init_banksize(void)
229	{	229	{
230	#if defined(CONFIG_NR_DRAM_BANKS) && defined(CONFIG_SYS_SDRAM_BASE)	230	#if defined(CONFIG_NR_DRAM_BANKS) && defined(CONFIG_SYS_SDRAM_BASE)
231	gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;	231	gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;
232	gd->bd->bi_dram[0].size = get_effective_memsize();	232	gd->bd->bi_dram[0].size = get_effective_memsize();
233	#endif	233	#endif
234	}	234	}
235		235
236	#if defined(CONFIG_HARD_I2C) \|\| defined(CONFIG_SYS_I2C)	236	#if defined(CONFIG_HARD_I2C) \|\| defined(CONFIG_SYS_I2C)
237	static int init_func_i2c(void)	237	static int init_func_i2c(void)
238	{	238	{
239	puts("I2C: ");	239	puts("I2C: ");
240	#ifdef CONFIG_SYS_I2C	240	#ifdef CONFIG_SYS_I2C
241	i2c_init_all();	241	i2c_init_all();
242	#else	242	#else
243	i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);	243	i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
244	#endif	244	#endif
245	puts("ready\n");	245	puts("ready\n");
246	return 0;	246	return 0;
247	}	247	}
248	#endif	248	#endif
249		249
250	#if defined(CONFIG_HARD_SPI)	250	#if defined(CONFIG_HARD_SPI)
251	static int init_func_spi(void)	251	static int init_func_spi(void)
252	{	252	{
253	puts("SPI: ");	253	puts("SPI: ");
254	spi_init();	254	spi_init();
255	puts("ready\n");	255	puts("ready\n");
256	return 0;	256	return 0;
257	}	257	}
258	#endif	258	#endif
259		259
260	__maybe_unused	260	__maybe_unused
261	static int zero_global_data(void)	261	static int zero_global_data(void)
262	{	262	{
263	memset((void *)gd, '\0', sizeof(gd_t));	263	memset((void *)gd, '\0', sizeof(gd_t));
264		264
265	return 0;	265	return 0;
266	}	266	}
267		267
268	static int setup_mon_len(void)	268	static int setup_mon_len(void)
269	{	269	{
270	#if defined(__ARM__) \|\| defined(__MICROBLAZE__)	270	#if defined(__ARM__) \|\| defined(__MICROBLAZE__)
271	gd->mon_len = (ulong)&__bss_end - (ulong)_start;	271	gd->mon_len = (ulong)&__bss_end - (ulong)_start;
272	#elif defined(CONFIG_SANDBOX) \|\| defined(CONFIG_EFI_APP)	272	#elif defined(CONFIG_SANDBOX) \|\| defined(CONFIG_EFI_APP)
273	gd->mon_len = (ulong)&_end - (ulong)_init;	273	gd->mon_len = (ulong)&_end - (ulong)_init;
274	#elif defined(CONFIG_BLACKFIN) \|\| defined(CONFIG_NIOS2)	274	#elif defined(CONFIG_BLACKFIN) \|\| defined(CONFIG_NIOS2)
275	gd->mon_len = CONFIG_SYS_MONITOR_LEN;	275	gd->mon_len = CONFIG_SYS_MONITOR_LEN;
276	#elif defined(CONFIG_NDS32)	276	#elif defined(CONFIG_NDS32)
277	gd->mon_len = (ulong)(&__bss_end) - (ulong)(&_start);	277	gd->mon_len = (ulong)(&__bss_end) - (ulong)(&_start);
278	#else	278	#else
279	/* TODO: use (ulong)&__bss_end - (ulong)&__text_start; ? */	279	/* TODO: use (ulong)&__bss_end - (ulong)&__text_start; ? */
280	gd->mon_len = (ulong)&__bss_end - CONFIG_SYS_MONITOR_BASE;	280	gd->mon_len = (ulong)&__bss_end - CONFIG_SYS_MONITOR_BASE;
281	#endif	281	#endif
282	return 0;	282	return 0;
283	}	283	}
284		284
285	__weak int arch_cpu_init(void)	285	__weak int arch_cpu_init(void)
286	{	286	{
287	return 0;	287	return 0;
288	}	288	}
289		289
290	#ifdef CONFIG_SANDBOX	290	#ifdef CONFIG_SANDBOX
291	static int setup_ram_buf(void)	291	static int setup_ram_buf(void)
292	{	292	{
293	struct sandbox_state *state = state_get_current();	293	struct sandbox_state *state = state_get_current();
294		294
295	gd->arch.ram_buf = state->ram_buf;	295	gd->arch.ram_buf = state->ram_buf;
296	gd->ram_size = state->ram_size;	296	gd->ram_size = state->ram_size;
297		297
298	return 0;	298	return 0;
299	}	299	}
300	#endif	300	#endif
301		301
302	/* Get the top of usable RAM */	302	/* Get the top of usable RAM */
303	__weak ulong board_get_usable_ram_top(ulong total_size)	303	__weak ulong board_get_usable_ram_top(ulong total_size)
304	{	304	{
305	#ifdef CONFIG_SYS_SDRAM_BASE	305	#ifdef CONFIG_SYS_SDRAM_BASE
306	/*	306	/*
307	* Detect whether we have so much RAM that it goes past the end of our	307	* Detect whether we have so much RAM that it goes past the end of our
308	* 32-bit address space. If so, clip the usable RAM so it doesn't.	308	* 32-bit address space. If so, clip the usable RAM so it doesn't.
309	*/	309	*/
310	if (gd->ram_top < CONFIG_SYS_SDRAM_BASE)	310	if (gd->ram_top < CONFIG_SYS_SDRAM_BASE)
311	/*	311	/*
312	* Will wrap back to top of 32-bit space when reservations	312	* Will wrap back to top of 32-bit space when reservations
313	* are made.	313	* are made.
314	*/	314	*/
315	return 0;	315	return 0;
316	#endif	316	#endif
317	return gd->ram_top;	317	return gd->ram_top;
318	}	318	}
319		319
		320	__weak phys_size_t board_reserve_ram_top(phys_size_t ram_size)
		321	{
		322	#ifdef CONFIG_SYS_MEM_TOP_HIDE
		323	return ram_size - CONFIG_SYS_MEM_TOP_HIDE;
		324	#else
		325	return ram_size;
		326	#endif
		327	}
		328
320	static int setup_dest_addr(void)	329	static int setup_dest_addr(void)
321	{	330	{
322	debug("Monitor len: %08lX\n", gd->mon_len);	331	debug("Monitor len: %08lX\n", gd->mon_len);
323	/*	332	/*
324	* Ram is setup, size stored in gd !!	333	* Ram is setup, size stored in gd !!
325	*/	334	*/
326	debug("Ram size: %08lX\n", (ulong)gd->ram_size);	335	debug("Ram size: %08lX\n", (ulong)gd->ram_size);
327	#ifdef CONFIG_SYS_MEM_RESERVE_SECURE	336	#ifdef CONFIG_SYS_MEM_RESERVE_SECURE
328	/* Reserve memory for secure MMU tables, and/or security monitor */	337	/* Reserve memory for secure MMU tables, and/or security monitor */
329	gd->ram_size -= CONFIG_SYS_MEM_RESERVE_SECURE;	338	gd->ram_size -= CONFIG_SYS_MEM_RESERVE_SECURE;
330	/*	339	/*
331	* Record secure memory location. Need recalcuate if memory splits	340	* Record secure memory location. Need recalcuate if memory splits
332	* into banks, or the ram base is not zero.	341	* into banks, or the ram base is not zero.
333	*/	342	*/
334	gd->secure_ram = gd->ram_size;	343	gd->secure_ram = gd->ram_size;
335	#endif	344	#endif
336	#if defined(CONFIG_SYS_MEM_TOP_HIDE)
337	/*	345	/*
338	* Subtract specified amount of memory to hide so that it won't	346	* Subtract specified amount of memory to hide so that it won't
339	* get "touched" at all by U-Boot. By fixing up gd->ram_size	347	* get "touched" at all by U-Boot. By fixing up gd->ram_size
340	* the Linux kernel should now get passed the now "corrected"	348	* the Linux kernel should now get passed the now "corrected"
341	* memory size and won't touch it either. This should work	349	* memory size and won't touch it either. This has been used
342	* for arch/ppc and arch/powerpc. Only Linux board ports in	350	* by arch/powerpc exclusively. Now ARMv8 takes advantage of
343	* arch/powerpc with bootwrapper support, that recalculate the	351	* thie mechanism. If memory is split into banks, addresses
344	* memory size from the SDRAM controller setup will have to	352	* need to be calculated.
345	* get fixed.
346	*/	353	*/
347	gd->ram_size -= CONFIG_SYS_MEM_TOP_HIDE;	354	gd->ram_size = board_reserve_ram_top(gd->ram_size);
348	#endif	355
349	#ifdef CONFIG_SYS_SDRAM_BASE	356	#ifdef CONFIG_SYS_SDRAM_BASE
350	gd->ram_top = CONFIG_SYS_SDRAM_BASE;	357	gd->ram_top = CONFIG_SYS_SDRAM_BASE;
351	#endif	358	#endif
352	gd->ram_top += get_effective_memsize();	359	gd->ram_top += get_effective_memsize();
353	gd->ram_top = board_get_usable_ram_top(gd->mon_len);	360	gd->ram_top = board_get_usable_ram_top(gd->mon_len);
354	gd->relocaddr = gd->ram_top;	361	gd->relocaddr = gd->ram_top;
355	debug("Ram top: %08lX\n", (ulong)gd->ram_top);	362	debug("Ram top: %08lX\n", (ulong)gd->ram_top);
356	#if defined(CONFIG_MP) && (defined(CONFIG_MPC86xx) \|\| defined(CONFIG_E500))	363	#if defined(CONFIG_MP) && (defined(CONFIG_MPC86xx) \|\| defined(CONFIG_E500))
357	/*	364	/*
358	* We need to make sure the location we intend to put secondary core	365	* We need to make sure the location we intend to put secondary core
359	* boot code is reserved and not used by any part of u-boot	366	* boot code is reserved and not used by any part of u-boot
360	*/	367	*/
361	if (gd->relocaddr > determine_mp_bootpg(NULL)) {	368	if (gd->relocaddr > determine_mp_bootpg(NULL)) {
362	gd->relocaddr = determine_mp_bootpg(NULL);	369	gd->relocaddr = determine_mp_bootpg(NULL);
363	debug("Reserving MP boot page to %08lx\n", gd->relocaddr);	370	debug("Reserving MP boot page to %08lx\n", gd->relocaddr);
364	}	371	}
365	#endif	372	#endif
366	return 0;	373	return 0;
367	}	374	}
368		375
369	#if defined(CONFIG_SPARC)	376	#if defined(CONFIG_SPARC)
370	static int reserve_prom(void)	377	static int reserve_prom(void)
371	{	378	{
372	/* defined in arch/sparc/cpu/leon?/prom.c */	379	/* defined in arch/sparc/cpu/leon?/prom.c */
373	extern void *__prom_start_reloc;	380	extern void *__prom_start_reloc;
374	int size = 8192; /* page table = 2k, prom = 6k */	381	int size = 8192; /* page table = 2k, prom = 6k */
375	gd->relocaddr -= size;	382	gd->relocaddr -= size;
376	__prom_start_reloc = map_sysmem(gd->relocaddr + 2048, size - 2048);	383	__prom_start_reloc = map_sysmem(gd->relocaddr + 2048, size - 2048);
377	debug("Reserving %dk for PROM and page table at %08lx\n", size,	384	debug("Reserving %dk for PROM and page table at %08lx\n", size,
378	gd->relocaddr);	385	gd->relocaddr);
379	return 0;	386	return 0;
380	}	387	}
381	#endif	388	#endif
382		389
383	#if defined(CONFIG_LOGBUFFER) && !defined(CONFIG_ALT_LB_ADDR)	390	#if defined(CONFIG_LOGBUFFER) && !defined(CONFIG_ALT_LB_ADDR)
384	static int reserve_logbuffer(void)	391	static int reserve_logbuffer(void)
385	{	392	{
386	/* reserve kernel log buffer */	393	/* reserve kernel log buffer */
387	gd->relocaddr -= LOGBUFF_RESERVE;	394	gd->relocaddr -= LOGBUFF_RESERVE;
388	debug("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN,	395	debug("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN,
389	gd->relocaddr);	396	gd->relocaddr);
390	return 0;	397	return 0;
391	}	398	}
392	#endif	399	#endif
393		400
394	#ifdef CONFIG_PRAM	401	#ifdef CONFIG_PRAM
395	/* reserve protected RAM */	402	/* reserve protected RAM */
396	static int reserve_pram(void)	403	static int reserve_pram(void)
397	{	404	{
398	ulong reg;	405	ulong reg;
399		406
400	reg = getenv_ulong("pram", 10, CONFIG_PRAM);	407	reg = getenv_ulong("pram", 10, CONFIG_PRAM);
401	gd->relocaddr -= (reg << 10); /* size is in kB */	408	gd->relocaddr -= (reg << 10); /* size is in kB */
402	debug("Reserving %ldk for protected RAM at %08lx\n", reg,	409	debug("Reserving %ldk for protected RAM at %08lx\n", reg,
403	gd->relocaddr);	410	gd->relocaddr);
404	return 0;	411	return 0;
405	}	412	}
406	#endif /* CONFIG_PRAM */	413	#endif /* CONFIG_PRAM */
407		414
408	/* Round memory pointer down to next 4 kB limit */	415	/* Round memory pointer down to next 4 kB limit */
409	static int reserve_round_4k(void)	416	static int reserve_round_4k(void)
410	{	417	{
411	gd->relocaddr &= ~(4096 - 1);	418	gd->relocaddr &= ~(4096 - 1);
412	return 0;	419	return 0;
413	}	420	}
414		421
415	#if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF)) && \	422	#if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF)) && \
416	defined(CONFIG_ARM)	423	defined(CONFIG_ARM)
417	static int reserve_mmu(void)	424	static int reserve_mmu(void)
418	{	425	{
419	/* reserve TLB table */	426	/* reserve TLB table */
420	gd->arch.tlb_size = PGTABLE_SIZE;	427	gd->arch.tlb_size = PGTABLE_SIZE;
421	gd->relocaddr -= gd->arch.tlb_size;	428	gd->relocaddr -= gd->arch.tlb_size;
422		429
423	/* round down to next 64 kB limit */	430	/* round down to next 64 kB limit */
424	gd->relocaddr &= ~(0x10000 - 1);	431	gd->relocaddr &= ~(0x10000 - 1);
425		432
426	gd->arch.tlb_addr = gd->relocaddr;	433	gd->arch.tlb_addr = gd->relocaddr;
427	debug("TLB table from %08lx to %08lx\n", gd->arch.tlb_addr,	434	debug("TLB table from %08lx to %08lx\n", gd->arch.tlb_addr,
428	gd->arch.tlb_addr + gd->arch.tlb_size);	435	gd->arch.tlb_addr + gd->arch.tlb_size);
429	return 0;	436	return 0;
430	}	437	}
431	#endif	438	#endif
432		439
433	#ifdef CONFIG_LCD	440	#ifdef CONFIG_LCD
434	static int reserve_lcd(void)	441	static int reserve_lcd(void)
435	{	442	{
436	#ifdef CONFIG_FB_ADDR	443	#ifdef CONFIG_FB_ADDR
437	gd->fb_base = CONFIG_FB_ADDR;	444	gd->fb_base = CONFIG_FB_ADDR;
438	#else	445	#else
439	/* reserve memory for LCD display (always full pages) */	446	/* reserve memory for LCD display (always full pages) */
440	gd->relocaddr = lcd_setmem(gd->relocaddr);	447	gd->relocaddr = lcd_setmem(gd->relocaddr);
441	gd->fb_base = gd->relocaddr;	448	gd->fb_base = gd->relocaddr;
442	#endif /* CONFIG_FB_ADDR */	449	#endif /* CONFIG_FB_ADDR */
443	return 0;	450	return 0;
444	}	451	}
445	#endif /* CONFIG_LCD */	452	#endif /* CONFIG_LCD */
446		453
447	static int reserve_trace(void)	454	static int reserve_trace(void)
448	{	455	{
449	#ifdef CONFIG_TRACE	456	#ifdef CONFIG_TRACE
450	gd->relocaddr -= CONFIG_TRACE_BUFFER_SIZE;	457	gd->relocaddr -= CONFIG_TRACE_BUFFER_SIZE;
451	gd->trace_buff = map_sysmem(gd->relocaddr, CONFIG_TRACE_BUFFER_SIZE);	458	gd->trace_buff = map_sysmem(gd->relocaddr, CONFIG_TRACE_BUFFER_SIZE);
452	debug("Reserving %dk for trace data at: %08lx\n",	459	debug("Reserving %dk for trace data at: %08lx\n",
453	CONFIG_TRACE_BUFFER_SIZE >> 10, gd->relocaddr);	460	CONFIG_TRACE_BUFFER_SIZE >> 10, gd->relocaddr);
454	#endif	461	#endif
455		462
456	return 0;	463	return 0;
457	}	464	}
458		465
459	#if defined(CONFIG_VIDEO) && (!defined(CONFIG_PPC) \|\| defined(CONFIG_8xx)) && \	466	#if defined(CONFIG_VIDEO) && (!defined(CONFIG_PPC) \|\| defined(CONFIG_8xx)) && \
460	!defined(CONFIG_ARM) && !defined(CONFIG_X86) && \	467	!defined(CONFIG_ARM) && !defined(CONFIG_X86) && \
461	!defined(CONFIG_BLACKFIN) && !defined(CONFIG_M68K)	468	!defined(CONFIG_BLACKFIN) && !defined(CONFIG_M68K)
462	static int reserve_video(void)	469	static int reserve_video(void)
463	{	470	{
464	/* reserve memory for video display (always full pages) */	471	/* reserve memory for video display (always full pages) */
465	gd->relocaddr = video_setmem(gd->relocaddr);	472	gd->relocaddr = video_setmem(gd->relocaddr);
466	gd->fb_base = gd->relocaddr;	473	gd->fb_base = gd->relocaddr;
467		474
468	return 0;	475	return 0;
469	}	476	}
470	#endif	477	#endif
471		478
472	static int reserve_uboot(void)	479	static int reserve_uboot(void)
473	{	480	{
474	/*	481	/*
475	* reserve memory for U-Boot code, data & bss	482	* reserve memory for U-Boot code, data & bss
476	* round down to next 4 kB limit	483	* round down to next 4 kB limit
477	*/	484	*/
478	gd->relocaddr -= gd->mon_len;	485	gd->relocaddr -= gd->mon_len;
479	gd->relocaddr &= ~(4096 - 1);	486	gd->relocaddr &= ~(4096 - 1);
480	#ifdef CONFIG_E500	487	#ifdef CONFIG_E500
481	/* round down to next 64 kB limit so that IVPR stays aligned */	488	/* round down to next 64 kB limit so that IVPR stays aligned */
482	gd->relocaddr &= ~(65536 - 1);	489	gd->relocaddr &= ~(65536 - 1);
483	#endif	490	#endif
484		491
485	debug("Reserving %ldk for U-Boot at: %08lx\n", gd->mon_len >> 10,	492	debug("Reserving %ldk for U-Boot at: %08lx\n", gd->mon_len >> 10,
486	gd->relocaddr);	493	gd->relocaddr);
487		494
488	gd->start_addr_sp = gd->relocaddr;	495	gd->start_addr_sp = gd->relocaddr;
489		496
490	return 0;	497	return 0;
491	}	498	}
492		499
493	#ifndef CONFIG_SPL_BUILD	500	#ifndef CONFIG_SPL_BUILD
494	/* reserve memory for malloc() area */	501	/* reserve memory for malloc() area */
495	static int reserve_malloc(void)	502	static int reserve_malloc(void)
496	{	503	{
497	gd->start_addr_sp = gd->start_addr_sp - TOTAL_MALLOC_LEN;	504	gd->start_addr_sp = gd->start_addr_sp - TOTAL_MALLOC_LEN;
498	debug("Reserving %dk for malloc() at: %08lx\n",	505	debug("Reserving %dk for malloc() at: %08lx\n",
499	TOTAL_MALLOC_LEN >> 10, gd->start_addr_sp);	506	TOTAL_MALLOC_LEN >> 10, gd->start_addr_sp);
500	return 0;	507	return 0;
501	}	508	}
502		509
503	/* (permanently) allocate a Board Info struct */	510	/* (permanently) allocate a Board Info struct */
504	static int reserve_board(void)	511	static int reserve_board(void)
505	{	512	{
506	if (!gd->bd) {	513	if (!gd->bd) {
507	gd->start_addr_sp -= sizeof(bd_t);	514	gd->start_addr_sp -= sizeof(bd_t);
508	gd->bd = (bd_t *)map_sysmem(gd->start_addr_sp, sizeof(bd_t));	515	gd->bd = (bd_t *)map_sysmem(gd->start_addr_sp, sizeof(bd_t));
509	memset(gd->bd, '\0', sizeof(bd_t));	516	memset(gd->bd, '\0', sizeof(bd_t));
510	debug("Reserving %zu Bytes for Board Info at: %08lx\n",	517	debug("Reserving %zu Bytes for Board Info at: %08lx\n",
511	sizeof(bd_t), gd->start_addr_sp);	518	sizeof(bd_t), gd->start_addr_sp);
512	}	519	}
513	return 0;	520	return 0;
514	}	521	}
515	#endif	522	#endif
516		523
517	static int setup_machine(void)	524	static int setup_machine(void)
518	{	525	{
519	#ifdef CONFIG_MACH_TYPE	526	#ifdef CONFIG_MACH_TYPE
520	gd->bd->bi_arch_number = CONFIG_MACH_TYPE; /* board id for Linux */	527	gd->bd->bi_arch_number = CONFIG_MACH_TYPE; /* board id for Linux */
521	#endif	528	#endif
522	return 0;	529	return 0;
523	}	530	}
524		531
525	static int reserve_global_data(void)	532	static int reserve_global_data(void)
526	{	533	{
527	gd->start_addr_sp -= sizeof(gd_t);	534	gd->start_addr_sp -= sizeof(gd_t);
528	gd->new_gd = (gd_t *)map_sysmem(gd->start_addr_sp, sizeof(gd_t));	535	gd->new_gd = (gd_t *)map_sysmem(gd->start_addr_sp, sizeof(gd_t));
529	debug("Reserving %zu Bytes for Global Data at: %08lx\n",	536	debug("Reserving %zu Bytes for Global Data at: %08lx\n",
530	sizeof(gd_t), gd->start_addr_sp);	537	sizeof(gd_t), gd->start_addr_sp);
531	return 0;	538	return 0;
532	}	539	}
533		540
534	static int reserve_fdt(void)	541	static int reserve_fdt(void)
535	{	542	{
536	#ifndef CONFIG_OF_EMBED	543	#ifndef CONFIG_OF_EMBED
537	/*	544	/*
538	* If the device tree is sitting immediately above our image then we	545	* If the device tree is sitting immediately above our image then we
539	* must relocate it. If it is embedded in the data section, then it	546	* must relocate it. If it is embedded in the data section, then it
540	* will be relocated with other data.	547	* will be relocated with other data.
541	*/	548	*/
542	if (gd->fdt_blob) {	549	if (gd->fdt_blob) {
543	gd->fdt_size = ALIGN(fdt_totalsize(gd->fdt_blob) + 0x1000, 32);	550	gd->fdt_size = ALIGN(fdt_totalsize(gd->fdt_blob) + 0x1000, 32);
544		551
545	gd->start_addr_sp -= gd->fdt_size;	552	gd->start_addr_sp -= gd->fdt_size;
546	gd->new_fdt = map_sysmem(gd->start_addr_sp, gd->fdt_size);	553	gd->new_fdt = map_sysmem(gd->start_addr_sp, gd->fdt_size);
547	debug("Reserving %lu Bytes for FDT at: %08lx\n",	554	debug("Reserving %lu Bytes for FDT at: %08lx\n",
548	gd->fdt_size, gd->start_addr_sp);	555	gd->fdt_size, gd->start_addr_sp);
549	}	556	}
550	#endif	557	#endif
551		558
552	return 0;	559	return 0;
553	}	560	}
554		561
555	int arch_reserve_stacks(void)	562	int arch_reserve_stacks(void)
556	{	563	{
557	return 0;	564	return 0;
558	}	565	}
559		566
560	static int reserve_stacks(void)	567	static int reserve_stacks(void)
561	{	568	{
562	/* make stack pointer 16-byte aligned */	569	/* make stack pointer 16-byte aligned */
563	gd->start_addr_sp -= 16;	570	gd->start_addr_sp -= 16;
564	gd->start_addr_sp &= ~0xf;	571	gd->start_addr_sp &= ~0xf;
565		572
566	/*	573	/*
567	* let the architecture-specific code tailor gd->start_addr_sp and	574	* let the architecture-specific code tailor gd->start_addr_sp and
568	* gd->irq_sp	575	* gd->irq_sp
569	*/	576	*/
570	return arch_reserve_stacks();	577	return arch_reserve_stacks();
571	}	578	}
572		579
573	static int display_new_sp(void)	580	static int display_new_sp(void)
574	{	581	{
575	debug("New Stack Pointer is: %08lx\n", gd->start_addr_sp);	582	debug("New Stack Pointer is: %08lx\n", gd->start_addr_sp);
576		583
577	return 0;	584	return 0;
578	}	585	}
579		586
580	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K) \|\| defined(CONFIG_MIPS)	587	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K) \|\| defined(CONFIG_MIPS)
581	static int setup_board_part1(void)	588	static int setup_board_part1(void)
582	{	589	{
583	bd_t *bd = gd->bd;	590	bd_t *bd = gd->bd;
584		591
585	/*	592	/*
586	* Save local variables to board info struct	593	* Save local variables to board info struct
587	*/	594	*/
588	bd->bi_memstart = CONFIG_SYS_SDRAM_BASE; /* start of memory */	595	bd->bi_memstart = CONFIG_SYS_SDRAM_BASE; /* start of memory */
589	bd->bi_memsize = gd->ram_size; /* size in bytes */	596	bd->bi_memsize = gd->ram_size; /* size in bytes */
590		597
591	#ifdef CONFIG_SYS_SRAM_BASE	598	#ifdef CONFIG_SYS_SRAM_BASE
592	bd->bi_sramstart = CONFIG_SYS_SRAM_BASE; /* start of SRAM */	599	bd->bi_sramstart = CONFIG_SYS_SRAM_BASE; /* start of SRAM */
593	bd->bi_sramsize = CONFIG_SYS_SRAM_SIZE; /* size of SRAM */	600	bd->bi_sramsize = CONFIG_SYS_SRAM_SIZE; /* size of SRAM */
594	#endif	601	#endif
595		602
596	#if defined(CONFIG_8xx) \|\| defined(CONFIG_MPC8260) \|\| defined(CONFIG_5xx) \|\| \	603	#if defined(CONFIG_8xx) \|\| defined(CONFIG_MPC8260) \|\| defined(CONFIG_5xx) \|\| \
597	defined(CONFIG_E500) \|\| defined(CONFIG_MPC86xx)	604	defined(CONFIG_E500) \|\| defined(CONFIG_MPC86xx)
598	bd->bi_immr_base = CONFIG_SYS_IMMR; /* base of IMMR register */	605	bd->bi_immr_base = CONFIG_SYS_IMMR; /* base of IMMR register */
599	#endif	606	#endif
600	#if defined(CONFIG_MPC5xxx) \|\| defined(CONFIG_M68K)	607	#if defined(CONFIG_MPC5xxx) \|\| defined(CONFIG_M68K)
601	bd->bi_mbar_base = CONFIG_SYS_MBAR; /* base of internal registers */	608	bd->bi_mbar_base = CONFIG_SYS_MBAR; /* base of internal registers */
602	#endif	609	#endif
603	#if defined(CONFIG_MPC83xx)	610	#if defined(CONFIG_MPC83xx)
604	bd->bi_immrbar = CONFIG_SYS_IMMR;	611	bd->bi_immrbar = CONFIG_SYS_IMMR;
605	#endif	612	#endif
606		613
607	return 0;	614	return 0;
608	}	615	}
609	#endif	616	#endif
610		617
611	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)	618	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)
612	static int setup_board_part2(void)	619	static int setup_board_part2(void)
613	{	620	{
614	bd_t *bd = gd->bd;	621	bd_t *bd = gd->bd;
615		622
616	bd->bi_intfreq = gd->cpu_clk; /* Internal Freq, in Hz */	623	bd->bi_intfreq = gd->cpu_clk; /* Internal Freq, in Hz */
617	bd->bi_busfreq = gd->bus_clk; /* Bus Freq, in Hz */	624	bd->bi_busfreq = gd->bus_clk; /* Bus Freq, in Hz */
618	#if defined(CONFIG_CPM2)	625	#if defined(CONFIG_CPM2)
619	bd->bi_cpmfreq = gd->arch.cpm_clk;	626	bd->bi_cpmfreq = gd->arch.cpm_clk;
620	bd->bi_brgfreq = gd->arch.brg_clk;	627	bd->bi_brgfreq = gd->arch.brg_clk;
621	bd->bi_sccfreq = gd->arch.scc_clk;	628	bd->bi_sccfreq = gd->arch.scc_clk;
622	bd->bi_vco = gd->arch.vco_out;	629	bd->bi_vco = gd->arch.vco_out;
623	#endif /* CONFIG_CPM2 */	630	#endif /* CONFIG_CPM2 */
624	#if defined(CONFIG_MPC512X)	631	#if defined(CONFIG_MPC512X)
625	bd->bi_ipsfreq = gd->arch.ips_clk;	632	bd->bi_ipsfreq = gd->arch.ips_clk;
626	#endif /* CONFIG_MPC512X */	633	#endif /* CONFIG_MPC512X */
627	#if defined(CONFIG_MPC5xxx)	634	#if defined(CONFIG_MPC5xxx)
628	bd->bi_ipbfreq = gd->arch.ipb_clk;	635	bd->bi_ipbfreq = gd->arch.ipb_clk;
629	bd->bi_pcifreq = gd->pci_clk;	636	bd->bi_pcifreq = gd->pci_clk;
630	#endif /* CONFIG_MPC5xxx */	637	#endif /* CONFIG_MPC5xxx */
631	#if defined(CONFIG_M68K) && defined(CONFIG_PCI)	638	#if defined(CONFIG_M68K) && defined(CONFIG_PCI)
632	bd->bi_pcifreq = gd->pci_clk;	639	bd->bi_pcifreq = gd->pci_clk;
633	#endif	640	#endif
634	#if defined(CONFIG_EXTRA_CLOCK)	641	#if defined(CONFIG_EXTRA_CLOCK)
635	bd->bi_inpfreq = gd->arch.inp_clk; /* input Freq in Hz */	642	bd->bi_inpfreq = gd->arch.inp_clk; /* input Freq in Hz */
636	bd->bi_vcofreq = gd->arch.vco_clk; /* vco Freq in Hz */	643	bd->bi_vcofreq = gd->arch.vco_clk; /* vco Freq in Hz */
637	bd->bi_flbfreq = gd->arch.flb_clk; /* flexbus Freq in Hz */	644	bd->bi_flbfreq = gd->arch.flb_clk; /* flexbus Freq in Hz */
638	#endif	645	#endif
639		646
640	return 0;	647	return 0;
641	}	648	}
642	#endif	649	#endif
643		650
644	#ifdef CONFIG_SYS_EXTBDINFO	651	#ifdef CONFIG_SYS_EXTBDINFO
645	static int setup_board_extra(void)	652	static int setup_board_extra(void)
646	{	653	{
647	bd_t *bd = gd->bd;	654	bd_t *bd = gd->bd;
648		655
649	strncpy((char *) bd->bi_s_version, "1.2", sizeof(bd->bi_s_version));	656	strncpy((char *) bd->bi_s_version, "1.2", sizeof(bd->bi_s_version));
650	strncpy((char *) bd->bi_r_version, U_BOOT_VERSION,	657	strncpy((char *) bd->bi_r_version, U_BOOT_VERSION,
651	sizeof(bd->bi_r_version));	658	sizeof(bd->bi_r_version));
652		659
653	bd->bi_procfreq = gd->cpu_clk; /* Processor Speed, In Hz */	660	bd->bi_procfreq = gd->cpu_clk; /* Processor Speed, In Hz */
654	bd->bi_plb_busfreq = gd->bus_clk;	661	bd->bi_plb_busfreq = gd->bus_clk;
655	#if defined(CONFIG_405GP) \|\| defined(CONFIG_405EP) \|\| \	662	#if defined(CONFIG_405GP) \|\| defined(CONFIG_405EP) \|\| \
656	defined(CONFIG_440EP) \|\| defined(CONFIG_440GR) \|\| \	663	defined(CONFIG_440EP) \|\| defined(CONFIG_440GR) \|\| \
657	defined(CONFIG_440EPX) \|\| defined(CONFIG_440GRX)	664	defined(CONFIG_440EPX) \|\| defined(CONFIG_440GRX)
658	bd->bi_pci_busfreq = get_PCI_freq();	665	bd->bi_pci_busfreq = get_PCI_freq();
659	bd->bi_opbfreq = get_OPB_freq();	666	bd->bi_opbfreq = get_OPB_freq();
660	#elif defined(CONFIG_XILINX_405)	667	#elif defined(CONFIG_XILINX_405)
661	bd->bi_pci_busfreq = get_PCI_freq();	668	bd->bi_pci_busfreq = get_PCI_freq();
662	#endif	669	#endif
663		670
664	return 0;	671	return 0;
665	}	672	}
666	#endif	673	#endif
667		674
668	#ifdef CONFIG_POST	675	#ifdef CONFIG_POST
669	static int init_post(void)	676	static int init_post(void)
670	{	677	{
671	post_bootmode_init();	678	post_bootmode_init();
672	post_run(NULL, POST_ROM \| post_bootmode_get(0));	679	post_run(NULL, POST_ROM \| post_bootmode_get(0));
673		680
674	return 0;	681	return 0;
675	}	682	}
676	#endif	683	#endif
677		684
678	static int setup_dram_config(void)	685	static int setup_dram_config(void)
679	{	686	{
680	/* Ram is board specific, so move it to board code ... */	687	/* Ram is board specific, so move it to board code ... */
681	dram_init_banksize();	688	dram_init_banksize();
682		689
683	return 0;	690	return 0;
684	}	691	}
685		692
686	static int reloc_fdt(void)	693	static int reloc_fdt(void)
687	{	694	{
688	#ifndef CONFIG_OF_EMBED	695	#ifndef CONFIG_OF_EMBED
689	if (gd->flags & GD_FLG_SKIP_RELOC)	696	if (gd->flags & GD_FLG_SKIP_RELOC)
690	return 0;	697	return 0;
691	if (gd->new_fdt) {	698	if (gd->new_fdt) {
692	memcpy(gd->new_fdt, gd->fdt_blob, gd->fdt_size);	699	memcpy(gd->new_fdt, gd->fdt_blob, gd->fdt_size);
693	gd->fdt_blob = gd->new_fdt;	700	gd->fdt_blob = gd->new_fdt;
694	}	701	}
695	#endif	702	#endif
696		703
697	return 0;	704	return 0;
698	}	705	}
699		706
700	static int setup_reloc(void)	707	static int setup_reloc(void)
701	{	708	{
702	if (gd->flags & GD_FLG_SKIP_RELOC) {	709	if (gd->flags & GD_FLG_SKIP_RELOC) {
703	debug("Skipping relocation due to flag\n");	710	debug("Skipping relocation due to flag\n");
704	return 0;	711	return 0;
705	}	712	}
706		713
707	#ifdef CONFIG_SYS_TEXT_BASE	714	#ifdef CONFIG_SYS_TEXT_BASE
708	gd->reloc_off = gd->relocaddr - CONFIG_SYS_TEXT_BASE;	715	gd->reloc_off = gd->relocaddr - CONFIG_SYS_TEXT_BASE;
709	#ifdef CONFIG_M68K	716	#ifdef CONFIG_M68K
710	/*	717	/*
711	* On all ColdFire arch cpu, monitor code starts always	718	* On all ColdFire arch cpu, monitor code starts always
712	* just after the default vector table location, so at 0x400	719	* just after the default vector table location, so at 0x400
713	*/	720	*/
714	gd->reloc_off = gd->relocaddr - (CONFIG_SYS_TEXT_BASE + 0x400);	721	gd->reloc_off = gd->relocaddr - (CONFIG_SYS_TEXT_BASE + 0x400);
715	#endif	722	#endif
716	#endif	723	#endif
717	memcpy(gd->new_gd, (char *)gd, sizeof(gd_t));	724	memcpy(gd->new_gd, (char *)gd, sizeof(gd_t));
718		725
719	debug("Relocation Offset is: %08lx\n", gd->reloc_off);	726	debug("Relocation Offset is: %08lx\n", gd->reloc_off);
720	debug("Relocating to %08lx, new gd at %08lx, sp at %08lx\n",	727	debug("Relocating to %08lx, new gd at %08lx, sp at %08lx\n",
721	gd->relocaddr, (ulong)map_to_sysmem(gd->new_gd),	728	gd->relocaddr, (ulong)map_to_sysmem(gd->new_gd),
722	gd->start_addr_sp);	729	gd->start_addr_sp);
723		730
724	return 0;	731	return 0;
725	}	732	}
726		733
727	/* ARM calls relocate_code from its crt0.S */	734	/* ARM calls relocate_code from its crt0.S */
728	#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX)	735	#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX)
729		736
730	static int jump_to_copy(void)	737	static int jump_to_copy(void)
731	{	738	{
732	if (gd->flags & GD_FLG_SKIP_RELOC)	739	if (gd->flags & GD_FLG_SKIP_RELOC)
733	return 0;	740	return 0;
734	/*	741	/*
735	* x86 is special, but in a nice way. It uses a trampoline which	742	* x86 is special, but in a nice way. It uses a trampoline which
736	* enables the dcache if possible.	743	* enables the dcache if possible.
737	*	744	*
738	* For now, other archs use relocate_code(), which is implemented	745	* For now, other archs use relocate_code(), which is implemented
739	* similarly for all archs. When we do generic relocation, hopefully	746	* similarly for all archs. When we do generic relocation, hopefully
740	* we can make all archs enable the dcache prior to relocation.	747	* we can make all archs enable the dcache prior to relocation.
741	*/	748	*/
742	#if defined(CONFIG_X86) \|\| defined(CONFIG_ARC)	749	#if defined(CONFIG_X86) \|\| defined(CONFIG_ARC)
743	/*	750	/*
744	* SDRAM and console are now initialised. The final stack can now	751	* SDRAM and console are now initialised. The final stack can now
745	* be setup in SDRAM. Code execution will continue in Flash, but	752	* be setup in SDRAM. Code execution will continue in Flash, but
746	* with the stack in SDRAM and Global Data in temporary memory	753	* with the stack in SDRAM and Global Data in temporary memory
747	* (CPU cache)	754	* (CPU cache)
748	*/	755	*/
749	arch_setup_gd(gd->new_gd);	756	arch_setup_gd(gd->new_gd);
750	board_init_f_r_trampoline(gd->start_addr_sp);	757	board_init_f_r_trampoline(gd->start_addr_sp);
751	#else	758	#else
752	relocate_code(gd->start_addr_sp, gd->new_gd, gd->relocaddr);	759	relocate_code(gd->start_addr_sp, gd->new_gd, gd->relocaddr);
753	#endif	760	#endif
754		761
755	return 0;	762	return 0;
756	}	763	}
757	#endif	764	#endif
758		765
759	/* Record the board_init_f() bootstage (after arch_cpu_init()) */	766	/* Record the board_init_f() bootstage (after arch_cpu_init()) */
760	static int mark_bootstage(void)	767	static int mark_bootstage(void)
761	{	768	{
762	bootstage_mark_name(BOOTSTAGE_ID_START_UBOOT_F, "board_init_f");	769	bootstage_mark_name(BOOTSTAGE_ID_START_UBOOT_F, "board_init_f");
763		770
764	return 0;	771	return 0;
765	}	772	}
766		773
767	static int initf_console_record(void)	774	static int initf_console_record(void)
768	{	775	{
769	#if defined(CONFIG_CONSOLE_RECORD) && defined(CONFIG_SYS_MALLOC_F_LEN)	776	#if defined(CONFIG_CONSOLE_RECORD) && defined(CONFIG_SYS_MALLOC_F_LEN)
770	return console_record_init();	777	return console_record_init();
771	#else	778	#else
772	return 0;	779	return 0;
773	#endif	780	#endif
774	}	781	}
775		782
776	static int initf_dm(void)	783	static int initf_dm(void)
777	{	784	{
778	#if defined(CONFIG_DM) && defined(CONFIG_SYS_MALLOC_F_LEN)	785	#if defined(CONFIG_DM) && defined(CONFIG_SYS_MALLOC_F_LEN)
779	int ret;	786	int ret;
780		787
781	ret = dm_init_and_scan(true);	788	ret = dm_init_and_scan(true);
782	if (ret)	789	if (ret)
783	return ret;	790	return ret;
784	#endif	791	#endif
785		792
786	return 0;	793	return 0;
787	}	794	}
788		795
789	/* Architecture-specific memory reservation */	796	/* Architecture-specific memory reservation */
790	__weak int reserve_arch(void)	797	__weak int reserve_arch(void)
791	{	798	{
792	return 0;	799	return 0;
793	}	800	}
794		801
795	__weak int arch_cpu_init_dm(void)	802	__weak int arch_cpu_init_dm(void)
796	{	803	{
797	return 0;	804	return 0;
798	}	805	}
799		806
800	static init_fnc_t init_sequence_f[] = {	807	static init_fnc_t init_sequence_f[] = {
801	#ifdef CONFIG_SANDBOX	808	#ifdef CONFIG_SANDBOX
802	setup_ram_buf,	809	setup_ram_buf,
803	#endif	810	#endif
804	setup_mon_len,	811	setup_mon_len,
805	#ifdef CONFIG_OF_CONTROL	812	#ifdef CONFIG_OF_CONTROL
806	fdtdec_setup,	813	fdtdec_setup,
807	#endif	814	#endif
808	#ifdef CONFIG_TRACE	815	#ifdef CONFIG_TRACE
809	trace_early_init,	816	trace_early_init,
810	#endif	817	#endif
811	initf_malloc,	818	initf_malloc,
812	initf_console_record,	819	initf_console_record,
813	#if defined(CONFIG_MPC85xx) \|\| defined(CONFIG_MPC86xx)	820	#if defined(CONFIG_MPC85xx) \|\| defined(CONFIG_MPC86xx)
814	/* TODO: can this go into arch_cpu_init()? */	821	/* TODO: can this go into arch_cpu_init()? */
815	probecpu,	822	probecpu,
816	#endif	823	#endif
817	#if defined(CONFIG_X86) && defined(CONFIG_HAVE_FSP)	824	#if defined(CONFIG_X86) && defined(CONFIG_HAVE_FSP)
818	x86_fsp_init,	825	x86_fsp_init,
819	#endif	826	#endif
820	arch_cpu_init, /* basic arch cpu dependent setup */	827	arch_cpu_init, /* basic arch cpu dependent setup */
821	initf_dm,	828	initf_dm,
822	arch_cpu_init_dm,	829	arch_cpu_init_dm,
823	mark_bootstage, /* need timer, go after init dm */	830	mark_bootstage, /* need timer, go after init dm */
824	#if defined(CONFIG_BOARD_EARLY_INIT_F)	831	#if defined(CONFIG_BOARD_EARLY_INIT_F)
825	board_early_init_f,	832	board_early_init_f,
826	#endif	833	#endif
827	/* TODO: can any of this go into arch_cpu_init()? */	834	/* TODO: can any of this go into arch_cpu_init()? */
828	#if defined(CONFIG_PPC) && !defined(CONFIG_8xx_CPUCLK_DEFAULT)	835	#if defined(CONFIG_PPC) && !defined(CONFIG_8xx_CPUCLK_DEFAULT)
829	get_clocks, /* get CPU and bus clocks (etc.) */	836	get_clocks, /* get CPU and bus clocks (etc.) */
830	#if defined(CONFIG_TQM8xxL) && !defined(CONFIG_TQM866M) \	837	#if defined(CONFIG_TQM8xxL) && !defined(CONFIG_TQM866M) \
831	&& !defined(CONFIG_TQM885D)	838	&& !defined(CONFIG_TQM885D)
832	adjust_sdram_tbs_8xx,	839	adjust_sdram_tbs_8xx,
833	#endif	840	#endif
834	/* TODO: can we rename this to timer_init()? */	841	/* TODO: can we rename this to timer_init()? */
835	init_timebase,	842	init_timebase,
836	#endif	843	#endif
837	#if defined(CONFIG_ARM) \|\| defined(CONFIG_MIPS) \|\| \	844	#if defined(CONFIG_ARM) \|\| defined(CONFIG_MIPS) \|\| \
838	defined(CONFIG_BLACKFIN) \|\| defined(CONFIG_NDS32) \|\| \	845	defined(CONFIG_BLACKFIN) \|\| defined(CONFIG_NDS32) \|\| \
839	defined(CONFIG_SPARC)	846	defined(CONFIG_SPARC)
840	timer_init, /* initialize timer */	847	timer_init, /* initialize timer */
841	#endif	848	#endif
842	#ifdef CONFIG_SYS_ALLOC_DPRAM	849	#ifdef CONFIG_SYS_ALLOC_DPRAM
843	#if !defined(CONFIG_CPM2)	850	#if !defined(CONFIG_CPM2)
844	dpram_init,	851	dpram_init,
845	#endif	852	#endif
846	#endif	853	#endif
847	#if defined(CONFIG_BOARD_POSTCLK_INIT)	854	#if defined(CONFIG_BOARD_POSTCLK_INIT)
848	board_postclk_init,	855	board_postclk_init,
849	#endif	856	#endif
850	#if defined(CONFIG_SYS_FSL_CLK) \|\| defined(CONFIG_M68K)	857	#if defined(CONFIG_SYS_FSL_CLK) \|\| defined(CONFIG_M68K)
851	get_clocks,	858	get_clocks,
852	#endif	859	#endif
853	env_init, /* initialize environment */	860	env_init, /* initialize environment */
854	#if defined(CONFIG_8xx_CPUCLK_DEFAULT)	861	#if defined(CONFIG_8xx_CPUCLK_DEFAULT)
855	/* get CPU and bus clocks according to the environment variable */	862	/* get CPU and bus clocks according to the environment variable */
856	get_clocks_866,	863	get_clocks_866,
857	/* adjust sdram refresh rate according to the new clock */	864	/* adjust sdram refresh rate according to the new clock */
858	sdram_adjust_866,	865	sdram_adjust_866,
859	init_timebase,	866	init_timebase,
860	#endif	867	#endif
861	init_baud_rate, /* initialze baudrate settings */	868	init_baud_rate, /* initialze baudrate settings */
862	serial_init, /* serial communications setup */	869	serial_init, /* serial communications setup */
863	console_init_f, /* stage 1 init of console */	870	console_init_f, /* stage 1 init of console */
864	#ifdef CONFIG_SANDBOX	871	#ifdef CONFIG_SANDBOX
865	sandbox_early_getopt_check,	872	sandbox_early_getopt_check,
866	#endif	873	#endif
867	#ifdef CONFIG_OF_CONTROL	874	#ifdef CONFIG_OF_CONTROL
868	fdtdec_prepare_fdt,	875	fdtdec_prepare_fdt,
869	#endif	876	#endif
870	display_options, /* say that we are here */	877	display_options, /* say that we are here */
871	display_text_info, /* show debugging info if required */	878	display_text_info, /* show debugging info if required */
872	#if defined(CONFIG_MPC8260)	879	#if defined(CONFIG_MPC8260)
873	prt_8260_rsr,	880	prt_8260_rsr,
874	prt_8260_clks,	881	prt_8260_clks,
875	#endif /* CONFIG_MPC8260 */	882	#endif /* CONFIG_MPC8260 */
876	#if defined(CONFIG_MPC83xx)	883	#if defined(CONFIG_MPC83xx)
877	prt_83xx_rsr,	884	prt_83xx_rsr,
878	#endif	885	#endif
879	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)	886	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)
880	checkcpu,	887	checkcpu,
881	#endif	888	#endif
882	print_cpuinfo, /* display cpu info (and speed) */	889	print_cpuinfo, /* display cpu info (and speed) */
883	#if defined(CONFIG_MPC5xxx)	890	#if defined(CONFIG_MPC5xxx)
884	prt_mpc5xxx_clks,	891	prt_mpc5xxx_clks,
885	#endif /* CONFIG_MPC5xxx */	892	#endif /* CONFIG_MPC5xxx */
886	#if defined(CONFIG_DISPLAY_BOARDINFO)	893	#if defined(CONFIG_DISPLAY_BOARDINFO)
887	show_board_info,	894	show_board_info,
888	#endif	895	#endif
889	INIT_FUNC_WATCHDOG_INIT	896	INIT_FUNC_WATCHDOG_INIT
890	#if defined(CONFIG_MISC_INIT_F)	897	#if defined(CONFIG_MISC_INIT_F)
891	misc_init_f,	898	misc_init_f,
892	#endif	899	#endif
893	INIT_FUNC_WATCHDOG_RESET	900	INIT_FUNC_WATCHDOG_RESET
894	#if defined(CONFIG_HARD_I2C) \|\| defined(CONFIG_SYS_I2C)	901	#if defined(CONFIG_HARD_I2C) \|\| defined(CONFIG_SYS_I2C)
895	init_func_i2c,	902	init_func_i2c,
896	#endif	903	#endif
897	#if defined(CONFIG_HARD_SPI)	904	#if defined(CONFIG_HARD_SPI)
898	init_func_spi,	905	init_func_spi,
899	#endif	906	#endif
900	announce_dram_init,	907	announce_dram_init,
901	/* TODO: unify all these dram functions? */	908	/* TODO: unify all these dram functions? */
902	#if defined(CONFIG_ARM) \|\| defined(CONFIG_X86) \|\| defined(CONFIG_NDS32) \|\| \	909	#if defined(CONFIG_ARM) \|\| defined(CONFIG_X86) \|\| defined(CONFIG_NDS32) \|\| \
903	defined(CONFIG_MICROBLAZE) \|\| defined(CONFIG_AVR32)	910	defined(CONFIG_MICROBLAZE) \|\| defined(CONFIG_AVR32)
904	dram_init, /* configure available RAM banks */	911	dram_init, /* configure available RAM banks */
905	#endif	912	#endif
906	#if defined(CONFIG_MIPS) \|\| defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)	913	#if defined(CONFIG_MIPS) \|\| defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)
907	init_func_ram,	914	init_func_ram,
908	#endif	915	#endif
909	#ifdef CONFIG_POST	916	#ifdef CONFIG_POST
910	post_init_f,	917	post_init_f,
911	#endif	918	#endif
912	INIT_FUNC_WATCHDOG_RESET	919	INIT_FUNC_WATCHDOG_RESET
913	#if defined(CONFIG_SYS_DRAM_TEST)	920	#if defined(CONFIG_SYS_DRAM_TEST)
914	testdram,	921	testdram,
915	#endif /* CONFIG_SYS_DRAM_TEST */	922	#endif /* CONFIG_SYS_DRAM_TEST */
916	INIT_FUNC_WATCHDOG_RESET	923	INIT_FUNC_WATCHDOG_RESET
917		924
918	#ifdef CONFIG_POST	925	#ifdef CONFIG_POST
919	init_post,	926	init_post,
920	#endif	927	#endif
921	INIT_FUNC_WATCHDOG_RESET	928	INIT_FUNC_WATCHDOG_RESET
922	/*	929	/*
923	* Now that we have DRAM mapped and working, we can	930	* Now that we have DRAM mapped and working, we can
924	* relocate the code and continue running from DRAM.	931	* relocate the code and continue running from DRAM.
925	*	932	*
926	* Reserve memory at end of RAM for (top down in that order):	933	* Reserve memory at end of RAM for (top down in that order):
927	* - area that won't get touched by U-Boot and Linux (optional)	934	* - area that won't get touched by U-Boot and Linux (optional)
928	* - kernel log buffer	935	* - kernel log buffer
929	* - protected RAM	936	* - protected RAM
930	* - LCD framebuffer	937	* - LCD framebuffer
931	* - monitor code	938	* - monitor code
932	* - board info struct	939	* - board info struct
933	*/	940	*/
934	setup_dest_addr,	941	setup_dest_addr,
935	#if defined(CONFIG_BLACKFIN)	942	#if defined(CONFIG_BLACKFIN)
936	/* Blackfin u-boot monitor should be on top of the ram */	943	/* Blackfin u-boot monitor should be on top of the ram */
937	reserve_uboot,	944	reserve_uboot,
938	#endif	945	#endif
939	#if defined(CONFIG_SPARC)	946	#if defined(CONFIG_SPARC)
940	reserve_prom,	947	reserve_prom,
941	#endif	948	#endif
942	#if defined(CONFIG_LOGBUFFER) && !defined(CONFIG_ALT_LB_ADDR)	949	#if defined(CONFIG_LOGBUFFER) && !defined(CONFIG_ALT_LB_ADDR)
943	reserve_logbuffer,	950	reserve_logbuffer,
944	#endif	951	#endif
945	#ifdef CONFIG_PRAM	952	#ifdef CONFIG_PRAM
946	reserve_pram,	953	reserve_pram,
947	#endif	954	#endif
948	reserve_round_4k,	955	reserve_round_4k,
949	#if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF)) && \	956	#if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF)) && \
950	defined(CONFIG_ARM)	957	defined(CONFIG_ARM)
951	reserve_mmu,	958	reserve_mmu,
952	#endif	959	#endif
953	#ifdef CONFIG_LCD	960	#ifdef CONFIG_LCD
954	reserve_lcd,	961	reserve_lcd,
955	#endif	962	#endif
956	reserve_trace,	963	reserve_trace,
957	/* TODO: Why the dependency on CONFIG_8xx? */	964	/* TODO: Why the dependency on CONFIG_8xx? */
958	#if defined(CONFIG_VIDEO) && (!defined(CONFIG_PPC) \|\| defined(CONFIG_8xx)) && \	965	#if defined(CONFIG_VIDEO) && (!defined(CONFIG_PPC) \|\| defined(CONFIG_8xx)) && \
959	!defined(CONFIG_ARM) && !defined(CONFIG_X86) && \	966	!defined(CONFIG_ARM) && !defined(CONFIG_X86) && \
960	!defined(CONFIG_BLACKFIN) && !defined(CONFIG_M68K)	967	!defined(CONFIG_BLACKFIN) && !defined(CONFIG_M68K)
961	reserve_video,	968	reserve_video,
962	#endif	969	#endif
963	#if !defined(CONFIG_BLACKFIN)	970	#if !defined(CONFIG_BLACKFIN)
964	reserve_uboot,	971	reserve_uboot,
965	#endif	972	#endif
966	#ifndef CONFIG_SPL_BUILD	973	#ifndef CONFIG_SPL_BUILD
967	reserve_malloc,	974	reserve_malloc,
968	reserve_board,	975	reserve_board,
969	#endif	976	#endif
970	setup_machine,	977	setup_machine,
971	reserve_global_data,	978	reserve_global_data,
972	reserve_fdt,	979	reserve_fdt,
973	reserve_arch,	980	reserve_arch,
974	reserve_stacks,	981	reserve_stacks,
975	setup_dram_config,	982	setup_dram_config,
976	show_dram_config,	983	show_dram_config,
977	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K) \|\| defined(CONFIG_MIPS)	984	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K) \|\| defined(CONFIG_MIPS)
978	setup_board_part1,	985	setup_board_part1,
979	#endif	986	#endif
980	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)	987	#if defined(CONFIG_PPC) \|\| defined(CONFIG_M68K)
981	INIT_FUNC_WATCHDOG_RESET	988	INIT_FUNC_WATCHDOG_RESET
982	setup_board_part2,	989	setup_board_part2,
983	#endif	990	#endif
984	display_new_sp,	991	display_new_sp,
985	#ifdef CONFIG_SYS_EXTBDINFO	992	#ifdef CONFIG_SYS_EXTBDINFO
986	setup_board_extra,	993	setup_board_extra,
987	#endif	994	#endif
988	INIT_FUNC_WATCHDOG_RESET	995	INIT_FUNC_WATCHDOG_RESET
989	reloc_fdt,	996	reloc_fdt,
990	setup_reloc,	997	setup_reloc,
991	#if defined(CONFIG_X86) \|\| defined(CONFIG_ARC)	998	#if defined(CONFIG_X86) \|\| defined(CONFIG_ARC)
992	copy_uboot_to_ram,	999	copy_uboot_to_ram,
993	clear_bss,	1000	clear_bss,
994	do_elf_reloc_fixups,	1001	do_elf_reloc_fixups,
995	#endif	1002	#endif
996	#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX)	1003	#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX)
997	jump_to_copy,	1004	jump_to_copy,
998	#endif	1005	#endif
999	NULL,	1006	NULL,
1000	};	1007	};
1001		1008
1002	void board_init_f(ulong boot_flags)	1009	void board_init_f(ulong boot_flags)
1003	{	1010	{
1004	#ifdef CONFIG_SYS_GENERIC_GLOBAL_DATA	1011	#ifdef CONFIG_SYS_GENERIC_GLOBAL_DATA
1005	/*	1012	/*
1006	* For some archtectures, global data is initialized and used before	1013	* For some archtectures, global data is initialized and used before
1007	* calling this function. The data should be preserved. For others,	1014	* calling this function. The data should be preserved. For others,
1008	* CONFIG_SYS_GENERIC_GLOBAL_DATA should be defined and use the stack	1015	* CONFIG_SYS_GENERIC_GLOBAL_DATA should be defined and use the stack
1009	* here to host global data until relocation.	1016	* here to host global data until relocation.
1010	*/	1017	*/
1011	gd_t data;	1018	gd_t data;
1012		1019
1013	gd = &data;	1020	gd = &data;
1014		1021
1015	/*	1022	/*
1016	* Clear global data before it is accessed at debug print	1023	* Clear global data before it is accessed at debug print
1017	* in initcall_run_list. Otherwise the debug print probably	1024	* in initcall_run_list. Otherwise the debug print probably
1018	* get the wrong vaule of gd->have_console.	1025	* get the wrong vaule of gd->have_console.
1019	*/	1026	*/
1020	zero_global_data();	1027	zero_global_data();
1021	#endif	1028	#endif
1022		1029
1023	gd->flags = boot_flags;	1030	gd->flags = boot_flags;
1024	gd->have_console = 0;	1031	gd->have_console = 0;
1025		1032
1026	if (initcall_run_list(init_sequence_f))	1033	if (initcall_run_list(init_sequence_f))
1027	hang();	1034	hang();
1028		1035
1029	#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX) && \	1036	#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX) && \
1030	!defined(CONFIG_EFI_APP)	1037	!defined(CONFIG_EFI_APP)
1031	/* NOTREACHED - jump_to_copy() does not return */	1038	/* NOTREACHED - jump_to_copy() does not return */
1032	hang();	1039	hang();
1033	#endif	1040	#endif
1034	}	1041	}
1035		1042
1036	#if defined(CONFIG_X86) \|\| defined(CONFIG_ARC)	1043	#if defined(CONFIG_X86) \|\| defined(CONFIG_ARC)
1037	/*	1044	/*
1038	* For now this code is only used on x86.	1045	* For now this code is only used on x86.
1039	*	1046	*
1040	* init_sequence_f_r is the list of init functions which are run when	1047	* init_sequence_f_r is the list of init functions which are run when
1041	* U-Boot is executing from Flash with a semi-limited 'C' environment.	1048	* U-Boot is executing from Flash with a semi-limited 'C' environment.
1042	* The following limitations must be considered when implementing an	1049	* The following limitations must be considered when implementing an
1043	* '_f_r' function:	1050	* '_f_r' function:
1044	* - 'static' variables are read-only	1051	* - 'static' variables are read-only
1045	* - Global Data (gd->xxx) is read/write	1052	* - Global Data (gd->xxx) is read/write
1046	*	1053	*
1047	* The '_f_r' sequence must, as a minimum, copy U-Boot to RAM (if	1054	* The '_f_r' sequence must, as a minimum, copy U-Boot to RAM (if
1048	* supported). It _should_, if possible, copy global data to RAM and	1055	* supported). It _should_, if possible, copy global data to RAM and
1049	* initialise the CPU caches (to speed up the relocation process)	1056	* initialise the CPU caches (to speed up the relocation process)
1050	*	1057	*
1051	* NOTE: At present only x86 uses this route, but it is intended that	1058	* NOTE: At present only x86 uses this route, but it is intended that
1052	* all archs will move to this when generic relocation is implemented.	1059	* all archs will move to this when generic relocation is implemented.
1053	*/	1060	*/
1054	static init_fnc_t init_sequence_f_r[] = {	1061	static init_fnc_t init_sequence_f_r[] = {
1055	init_cache_f_r,	1062	init_cache_f_r,
1056		1063
1057	NULL,	1064	NULL,
1058	};	1065	};
1059		1066
1060	void board_init_f_r(void)	1067	void board_init_f_r(void)
1061	{	1068	{
1062	if (initcall_run_list(init_sequence_f_r))	1069	if (initcall_run_list(init_sequence_f_r))
1063	hang();	1070	hang();
1064		1071
1065	/*	1072	/*
1066	* U-Boot has been copied into SDRAM, the BSS has been cleared etc.	1073	* U-Boot has been copied into SDRAM, the BSS has been cleared etc.
1067	* Transfer execution from Flash to RAM by calculating the address	1074	* Transfer execution from Flash to RAM by calculating the address
1068	* of the in-RAM copy of board_init_r() and calling it	1075	* of the in-RAM copy of board_init_r() and calling it
1069	*/	1076	*/
1070	(board_init_r + gd->reloc_off)((gd_t *)gd, gd->relocaddr);	1077	(board_init_r + gd->reloc_off)((gd_t *)gd, gd->relocaddr);
1071		1078
1072	/* NOTREACHED - board_init_r() does not return */	1079	/* NOTREACHED - board_init_r() does not return */
1073	hang();	1080	hang();
1074	}	1081	}

Link here
Eric Lee 2019-04-25 04:08:07 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-11-01 15:11:23 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-11-11 02:57:47 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-11-25 03:16:59 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-01-15 02:28:02 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-04-16 06:17:47 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-05-08 05:44:52 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-07-07 10:56:46 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-08-14 06:05:04 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-09-08 08:37:02 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-04-28 07:23:41 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-05-03 05:00:26 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-11-23 09:40:25 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-11-23 09:41:37 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-12-03 07:18:47 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-12-10 07:03:19 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-12-14 03:31:24 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-12-20 10:47:37 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2022-06-14 07:58:02 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel
Link here
Eric Lee 2023-05-08 10:06:12 UTC

mentioned in commit 36cc0d

_mentioned in commit 36cc0d_

Choose File ... File name...
Cancel

1	#	1	#
2	# (C) Copyright 2000 - 2013	2	# (C) Copyright 2000 - 2013
3	# Wolfgang Denk, DENX Software Engineering, wd@denx.de.	3	# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4	#	4	#
5	# SPDX-License-Identifier: GPL-2.0+	5	# SPDX-License-Identifier: GPL-2.0+
6	#	6	#
7		7
8	Summary:	8	Summary:
9	========	9	========
10		10
11	This directory contains the source code for U-Boot, a boot loader for	11	This directory contains the source code for U-Boot, a boot loader for
12	Embedded boards based on PowerPC, ARM, MIPS and several other	12	Embedded boards based on PowerPC, ARM, MIPS and several other
13	processors, which can be installed in a boot ROM and used to	13	processors, which can be installed in a boot ROM and used to
14	initialize and test the hardware or to download and run application	14	initialize and test the hardware or to download and run application
15	code.	15	code.
16		16
17	The development of U-Boot is closely related to Linux: some parts of	17	The development of U-Boot is closely related to Linux: some parts of
18	the source code originate in the Linux source tree, we have some	18	the source code originate in the Linux source tree, we have some
19	header files in common, and special provision has been made to	19	header files in common, and special provision has been made to
20	support booting of Linux images.	20	support booting of Linux images.
21		21
22	Some attention has been paid to make this software easily	22	Some attention has been paid to make this software easily
23	configurable and extendable. For instance, all monitor commands are	23	configurable and extendable. For instance, all monitor commands are
24	implemented with the same call interface, so that it's very easy to	24	implemented with the same call interface, so that it's very easy to
25	add new commands. Also, instead of permanently adding rarely used	25	add new commands. Also, instead of permanently adding rarely used
26	code (for instance hardware test utilities) to the monitor, you can	26	code (for instance hardware test utilities) to the monitor, you can
27	load and run it dynamically.	27	load and run it dynamically.
28		28
29		29
30	Status:	30	Status:
31	=======	31	=======
32		32
33	In general, all boards for which a configuration option exists in the	33	In general, all boards for which a configuration option exists in the
34	Makefile have been tested to some extent and can be considered	34	Makefile have been tested to some extent and can be considered
35	"working". In fact, many of them are used in production systems.	35	"working". In fact, many of them are used in production systems.
36		36
37	In case of problems see the CHANGELOG and CREDITS files to find out	37	In case of problems see the CHANGELOG and CREDITS files to find out
38	who contributed the specific port. The boards.cfg file lists board	38	who contributed the specific port. The boards.cfg file lists board
39	maintainers.	39	maintainers.
40		40