1 /*
2 * (C) Copyright 2003
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
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.
12 *
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.
17 *
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,
21 * MA 02111-1307 USA
22 */
24 #include <common.h>
25 #include <command.h>
26 #include <malloc.h>
27 #include <serial.h>
28 #include <stdio_dev.h>
29 #include <version.h>
30 #include <net.h>
31 #include <environment.h>
32 #include <nand.h>
33 #include <onenand_uboot.h>
34 #include <spi.h>
36 #ifdef CONFIG_BITBANGMII
37 #include <miiphy.h>
38 #endif
40 DECLARE_GLOBAL_DATA_PTR;
42 ulong monitor_flash_len;
44 static char *failed = "*** failed ***\n";
46 /*
47 * mips_io_port_base is the begin of the address space to which x86 style
48 * I/O ports are mapped.
49 */
50 const unsigned long mips_io_port_base = -1;
52 int __board_early_init_f(void)
53 {
54 /*
55 * Nothing to do in this dummy implementation
56 */
57 return 0;
58 }
59 int board_early_init_f(void)
60 __attribute__((weak, alias("__board_early_init_f")));
62 static int init_func_ram(void)
63 {
64 #ifdef CONFIG_BOARD_TYPES
65 int board_type = gd->board_type;
66 #else
67 int board_type = 0; /* use dummy arg */
68 #endif
69 puts("DRAM: ");
71 gd->ram_size = initdram(board_type);
72 if (gd->ram_size > 0) {
73 print_size(gd->ram_size, "\n");
74 return 0;
75 }
76 puts(failed);
77 return 1;
78 }
80 static int display_banner(void)
81 {
83 printf("\n\n%s\n\n", version_string);
84 return 0;
85 }
87 #ifndef CONFIG_SYS_NO_FLASH
88 static void display_flash_config(ulong size)
89 {
90 puts("Flash: ");
91 print_size(size, "\n");
92 }
93 #endif
95 static int init_baudrate(void)
96 {
97 gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
98 return 0;
99 }
102 /*
103 * Breath some life into the board...
104 *
105 * The first part of initialization is running from Flash memory;
106 * its main purpose is to initialize the RAM so that we
107 * can relocate the monitor code to RAM.
108 */
110 /*
111 * All attempts to come up with a "common" initialization sequence
112 * that works for all boards and architectures failed: some of the
113 * requirements are just _too_ different. To get rid of the resulting
114 * mess of board dependend #ifdef'ed code we now make the whole
115 * initialization sequence configurable to the user.
116 *
117 * The requirements for any new initalization function is simple: it
118 * receives a pointer to the "global data" structure as it's only
119 * argument, and returns an integer return code, where 0 means
120 * "continue" and != 0 means "fatal error, hang the system".
121 */
122 typedef int (init_fnc_t)(void);
124 init_fnc_t *init_sequence[] = {
125 board_early_init_f,
126 timer_init,
127 env_init, /* initialize environment */
128 #ifdef CONFIG_INCA_IP
129 incaip_set_cpuclk, /* set cpu clock according to env. variable */
130 #endif
131 init_baudrate, /* initialize baudrate settings */
132 serial_init, /* serial communications setup */
133 console_init_f,
134 display_banner, /* say that we are here */
135 checkboard,
136 init_func_ram,
137 NULL,
138 };
141 void board_init_f(ulong bootflag)
142 {
143 gd_t gd_data, *id;
144 bd_t *bd;
145 init_fnc_t **init_fnc_ptr;
146 ulong addr, addr_sp, len;
147 ulong *s;
149 /* Pointer is writable since we allocated a register for it.
150 */
151 gd = &gd_data;
152 /* compiler optimization barrier needed for GCC >= 3.4 */
153 __asm__ __volatile__("" : : : "memory");
155 memset((void *)gd, 0, sizeof(gd_t));
157 for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
158 if ((*init_fnc_ptr)() != 0)
159 hang();
160 }
162 /*
163 * Now that we have DRAM mapped and working, we can
164 * relocate the code and continue running from DRAM.
165 */
166 addr = CONFIG_SYS_SDRAM_BASE + gd->ram_size;
168 /* We can reserve some RAM "on top" here.
169 */
171 /* round down to next 4 kB limit.
172 */
173 addr &= ~(4096 - 1);
174 debug("Top of RAM usable for U-Boot at: %08lx\n", addr);
176 /* Reserve memory for U-Boot code, data & bss
177 * round down to next 16 kB limit
178 */
179 len = bss_end() - CONFIG_SYS_MONITOR_BASE;
180 addr -= len;
181 addr &= ~(16 * 1024 - 1);
183 debug("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr);
185 /* Reserve memory for malloc() arena.
186 */
187 addr_sp = addr - TOTAL_MALLOC_LEN;
188 debug("Reserving %dk for malloc() at: %08lx\n",
189 TOTAL_MALLOC_LEN >> 10, addr_sp);
191 /*
192 * (permanently) allocate a Board Info struct
193 * and a permanent copy of the "global" data
194 */
195 addr_sp -= sizeof(bd_t);
196 bd = (bd_t *)addr_sp;
197 gd->bd = bd;
198 debug("Reserving %zu Bytes for Board Info at: %08lx\n",
199 sizeof(bd_t), addr_sp);
201 addr_sp -= sizeof(gd_t);
202 id = (gd_t *)addr_sp;
203 debug("Reserving %zu Bytes for Global Data at: %08lx\n",
204 sizeof(gd_t), addr_sp);
206 /* Reserve memory for boot params.
207 */
208 addr_sp -= CONFIG_SYS_BOOTPARAMS_LEN;
209 bd->bi_boot_params = addr_sp;
210 debug("Reserving %dk for boot params() at: %08lx\n",
211 CONFIG_SYS_BOOTPARAMS_LEN >> 10, addr_sp);
213 /*
214 * Finally, we set up a new (bigger) stack.
215 *
216 * Leave some safety gap for SP, force alignment on 16 byte boundary
217 * Clear initial stack frame
218 */
219 addr_sp -= 16;
220 addr_sp &= ~0xF;
221 s = (ulong *)addr_sp;
222 *s-- = 0;
223 *s-- = 0;
224 addr_sp = (ulong)s;
225 debug("Stack Pointer at: %08lx\n", addr_sp);
227 /*
228 * Save local variables to board info struct
229 */
230 bd->bi_memstart = CONFIG_SYS_SDRAM_BASE; /* start of DRAM */
231 bd->bi_memsize = gd->ram_size; /* size of DRAM in bytes */
232 bd->bi_baudrate = gd->baudrate; /* Console Baudrate */
234 memcpy(id, (void *)gd, sizeof(gd_t));
236 relocate_code(addr_sp, id, addr);
238 /* NOTREACHED - relocate_code() does not return */
239 }
241 /*
242 * This is the next part if the initialization sequence: we are now
243 * running from RAM and have a "normal" C environment, i. e. global
244 * data can be written, BSS has been cleared, the stack size in not
245 * that critical any more, etc.
246 */
248 void board_init_r(gd_t *id, ulong dest_addr)
249 {
250 #ifndef CONFIG_SYS_NO_FLASH
251 ulong size;
252 #endif
253 #ifndef CONFIG_ENV_IS_NOWHERE
254 extern char *env_name_spec;
255 #endif
256 bd_t *bd;
258 gd = id;
259 gd->flags |= GD_FLG_RELOC; /* tell others: relocation done */
261 debug("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
263 gd->reloc_off = dest_addr - CONFIG_SYS_MONITOR_BASE;
265 monitor_flash_len = image_copy_end() - dest_addr;
267 serial_initialize();
269 /* there are some other pointer constants we must deal with */
270 #ifndef CONFIG_ENV_IS_NOWHERE
271 env_name_spec += gd->reloc_off;
272 #endif
274 bd = gd->bd;
276 /* The Malloc area is immediately below the monitor copy in DRAM */
277 mem_malloc_init(CONFIG_SYS_MONITOR_BASE + gd->reloc_off -
278 TOTAL_MALLOC_LEN, TOTAL_MALLOC_LEN);
280 #ifndef CONFIG_SYS_NO_FLASH
281 /* configure available FLASH banks */
282 size = flash_init();
283 display_flash_config(size);
284 bd->bi_flashstart = CONFIG_SYS_FLASH_BASE;
285 bd->bi_flashsize = size;
287 #if CONFIG_SYS_MONITOR_BASE == CONFIG_SYS_FLASH_BASE
288 bd->bi_flashoffset = monitor_flash_len; /* reserved area for U-Boot */
289 #else
290 bd->bi_flashoffset = 0;
291 #endif
292 #else
293 bd->bi_flashstart = 0;
294 bd->bi_flashsize = 0;
295 bd->bi_flashoffset = 0;
296 #endif
298 #ifdef CONFIG_CMD_NAND
299 puts("NAND: ");
300 nand_init(); /* go init the NAND */
301 #endif
303 #if defined(CONFIG_CMD_ONENAND)
304 onenand_init();
305 #endif
307 /* relocate environment function pointers etc. */
308 env_relocate();
310 #if defined(CONFIG_PCI)
311 /*
312 * Do pci configuration
313 */
314 pci_init();
315 #endif
317 /** leave this here (after malloc(), environment and PCI are working) **/
318 /* Initialize stdio devices */
319 stdio_init();
321 jumptable_init();
323 /* Initialize the console (after the relocation and devices init) */
324 console_init_r();
325 /** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **/
327 /* Initialize from environment */
328 load_addr = getenv_ulong("loadaddr", 16, load_addr);
330 #ifdef CONFIG_CMD_SPI
331 puts("SPI: ");
332 spi_init(); /* go init the SPI */
333 puts("ready\n");
334 #endif
336 #if defined(CONFIG_MISC_INIT_R)
337 /* miscellaneous platform dependent initialisations */
338 misc_init_r();
339 #endif
341 #ifdef CONFIG_BITBANGMII
342 bb_miiphy_init();
343 #endif
344 #if defined(CONFIG_CMD_NET)
345 puts("Net: ");
346 eth_initialize(gd->bd);
347 #endif
349 /* main_loop() can return to retry autoboot, if so just run it again. */
350 for (;;)
351 main_loop();
353 /* NOTREACHED - no way out of command loop except booting */
354 }
356 void hang(void)
357 {
358 puts("### ERROR ### Please RESET the board ###\n");
359 for (;;)
360 ;
361 }