3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * See file CREDITS for list of people who contributed to this
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
30 #include <environment.h>
32 #include "LzmaWrapper.h"
34 /*#define DEBUG_ENABLE_BOOTSTRAP_PRINTF*/
36 DECLARE_GLOBAL_DATA_PTR;
38 #if (((CFG_ENV_ADDR+CFG_ENV_SIZE) < BOOTSTRAP_CFG_MONITOR_BASE) || \
39 (CFG_ENV_ADDR >= (BOOTSTRAP_CFG_MONITOR_BASE + CFG_MONITOR_LEN))) \
40 || defined(CFG_ENV_IS_IN_NVRAM)
41 #define TOTAL_MALLOC_LEN (CFG_MALLOC_LEN + CFG_ENV_SIZE)
43 #define TOTAL_MALLOC_LEN CFG_MALLOC_LEN
48 extern void bootstrap_relocate_code(ulong addr_sp, gd_t *gd, ulong addr_moni);
50 extern int timer_init(void);
52 extern ulong uboot_end_data_bootstrap;
53 extern ulong uboot_end_bootstrap;
56 * Begin and End of memory area for malloc(), and current "brk"
58 static ulong mem_malloc_start;
59 static ulong mem_malloc_end;
60 static ulong mem_malloc_brk;
63 * The Malloc area is immediately below the monitor copy in DRAM
65 static void mem_malloc_init(ulong dest_addr)
67 /* ulong dest_addr = BOOTSTRAP_CFG_MONITOR_BASE + gd->reloc_off; */
68 mem_malloc_end = dest_addr;
69 mem_malloc_start = dest_addr - TOTAL_MALLOC_LEN;
70 mem_malloc_brk = mem_malloc_start;
72 memset((void *)mem_malloc_start, 0, mem_malloc_end - mem_malloc_start);
75 void *malloc(unsigned int size)
77 if (size < (mem_malloc_end - mem_malloc_start)) {
78 mem_malloc_start += size;
79 return (void *)(mem_malloc_start - size);
85 void *realloc(void *src, unsigned int size)
95 static int init_func_ram(void)
97 if ((gd->ram_size = dram_init()) > 0)
104 * Breath some life into the board...
106 * The first part of initialization is running from Flash memory;
107 * its main purpose is to initialize the RAM so that we
108 * can relocate the monitor code to RAM.
112 * All attempts to come up with a "common" initialization sequence
113 * that works for all boards and architectures failed: some of the
114 * requirements are just _too_ different. To get rid of the resulting
115 * mess of board dependend #ifdef'ed code we now make the whole
116 * initialization sequence configurable to the user.
118 * The requirements for any new initalization function is simple: it
119 * receives a pointer to the "global data" structure as it's only
120 * argument, and returns an integer return code, where 0 means
121 * "continue" and != 0 means "fatal error, hang the system".
123 typedef int(init_fnc_t)(void);
125 init_fnc_t *init_sequence[] = { init_func_ram,
128 void bootstrap_board_init_f(ulong bootflag)
132 init_fnc_t **init_fnc_ptr;
133 ulong addr, addr_sp, len = (ulong)&uboot_end_bootstrap - BOOTSTRAP_CFG_MONITOR_BASE;
136 /* Pointer is writable since we allocated a register for it */
139 /* Compiler optimization barrier needed for GCC >= 3.4 */
140 __asm__ __volatile__("": : :"memory");
142 memset((void *)gd, 0, sizeof(gd_t));
144 for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
145 if ((*init_fnc_ptr)() != 0)
150 * Now that we have DRAM mapped and working, we can
151 * relocate the code and continue running from DRAM
153 addr = CFG_SDRAM_BASE + gd->ram_size;
156 * We can reserve some RAM "on top" here,
157 * round down to next 4 kB limit
162 * Reserve memory for U-Boot code, data & bss,
163 * round down to next 16 kB limit
166 addr &= ~(16 * 1024 - 1);
168 /* Reserve memory for malloc() arena */
169 addr_sp = addr - TOTAL_MALLOC_LEN;
172 * (permanently) allocate a Board Info struct
173 * and a permanent copy of the "global" data
175 addr_sp -= sizeof(bd_t);
176 bd = (bd_t *)addr_sp;
179 addr_sp -= sizeof(gd_t);
180 id = (gd_t *)addr_sp;
182 /* Reserve memory for boot params */
183 addr_sp -= CFG_BOOTPARAMS_LEN;
184 bd->bi_boot_params = addr_sp;
187 * Finally, we set up a new (bigger) stack
189 * Leave some safety gap for SP, force alignment on 16 byte boundary,
190 * clear initial stack frame
194 s = (ulong *)addr_sp;
200 * Save local variables to board info struct:
201 * - start of DRAM memory
202 * - size of DRAM memory in bytes
204 bd->bi_memstart = CFG_SDRAM_BASE;
205 bd->bi_memsize = gd->ram_size;
207 memcpy(id, (void *)gd, sizeof(gd_t));
209 bootstrap_relocate_code(addr_sp, id, addr);
210 /* NOTREACHED - relocate_code() does not return */
213 /************************************************************************
215 * This is the next part if the initialization sequence: we are now
216 * running from RAM and have a "normal" C environment, i. e. global
217 * data can be written, BSS has been cleared, the stack size in not
218 * that critical any more, etc.
220 ************************************************************************
222 void bootstrap_board_init_r(gd_t *id, ulong dest_addr)
226 ulong data, len, checksum;
227 image_header_t header;
228 image_header_t *hdr = &header;
229 unsigned int destLen;
232 /* Initialize malloc() area */
233 mem_malloc_init(dest_addr);
235 addr = (ulong)((char *)(BOOTSTRAP_CFG_MONITOR_BASE + ((ulong)&uboot_end_data_bootstrap - dest_addr)));
236 memmove(&header, (char *)addr, sizeof(image_header_t));
238 if (ntohl(hdr->ih_magic) != IH_MAGIC)
241 data = (ulong)&header;
242 len = sizeof(image_header_t);
244 checksum = ntohl(hdr->ih_hcrc);
247 if (tinf_crc32((unsigned char *)data, len) != checksum)
250 data = addr + sizeof(image_header_t);
251 len = ntohl(hdr->ih_size);
254 * If we've got less than 4 MB of malloc() space,
255 * use slower decompression algorithm which requires
256 * at most 2300 KB of memory.
261 i = lzma_inflate((unsigned char *)data, len, (unsigned char*)ntohl(hdr->ih_load), (int *)&destLen);
263 if (i != LZMA_RESULT_OK)
267 fn = (void *)ntohl(hdr->ih_load);