]>
Commit | Line | Data |
---|---|---|
4e5ca3eb | 1 | /* |
bf9e3b38 WD |
2 | * (C) Copyright 2003 |
3 | * Josef Baumgartner <josef.baumgartner@telex.de> | |
4 | * | |
5 | * (C) Copyright 2000-2002 | |
4e5ca3eb WD |
6 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
7 | * | |
8 | * See file CREDITS for list of people who contributed to this | |
9 | * project. | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or | |
12 | * modify it under the terms of the GNU General Public License as | |
13 | * published by the Free Software Foundation; either version 2 of | |
14 | * the License, or (at your option) any later version. | |
15 | * | |
16 | * This program is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 | * GNU General Public License for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU General Public License | |
22 | * along with this program; if not, write to the Free Software | |
23 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
24 | * MA 02111-1307 USA | |
25 | */ | |
26 | ||
27 | #include <common.h> | |
28 | #include <watchdog.h> | |
29 | #include <command.h> | |
30 | #include <malloc.h> | |
31 | #include <devices.h> | |
bf9e3b38 | 32 | |
8ae158cd | 33 | #include <asm/immap.h> |
bf9e3b38 | 34 | |
7def6b34 | 35 | #if defined(CONFIG_CMD_IDE) |
4e5ca3eb WD |
36 | #include <ide.h> |
37 | #endif | |
7def6b34 | 38 | #if defined(CONFIG_CMD_SCSI) |
4e5ca3eb WD |
39 | #include <scsi.h> |
40 | #endif | |
7def6b34 | 41 | #if defined(CONFIG_CMD_KGDB) |
4e5ca3eb WD |
42 | #include <kgdb.h> |
43 | #endif | |
44 | #ifdef CONFIG_STATUS_LED | |
45 | #include <status_led.h> | |
46 | #endif | |
47 | #include <net.h> | |
b71190f3 | 48 | #include <serial.h> |
7def6b34 | 49 | #if defined(CONFIG_CMD_BEDBUG) |
4e5ca3eb WD |
50 | #include <cmd_bedbug.h> |
51 | #endif | |
52 | #ifdef CFG_ALLOC_DPRAM | |
53 | #include <commproc.h> | |
54 | #endif | |
55 | #include <version.h> | |
56 | ||
e2c22d78 SR |
57 | #if defined(CONFIG_HARD_I2C) || \ |
58 | defined(CONFIG_SOFT_I2C) | |
59 | #include <i2c.h> | |
60 | #endif | |
61 | ||
d87080b7 WD |
62 | DECLARE_GLOBAL_DATA_PTR; |
63 | ||
4e5ca3eb WD |
64 | static char *failed = "*** failed ***\n"; |
65 | ||
66 | #ifdef CONFIG_PCU_E | |
67 | extern flash_info_t flash_info[]; | |
68 | #endif | |
69 | ||
bf9e3b38 WD |
70 | #include <environment.h> |
71 | ||
4e5ca3eb WD |
72 | #if ( ((CFG_ENV_ADDR+CFG_ENV_SIZE) < CFG_MONITOR_BASE) || \ |
73 | (CFG_ENV_ADDR >= (CFG_MONITOR_BASE + CFG_MONITOR_LEN)) ) || \ | |
74 | defined(CFG_ENV_IS_IN_NVRAM) | |
75 | #define TOTAL_MALLOC_LEN (CFG_MALLOC_LEN + CFG_ENV_SIZE) | |
76 | #else | |
77 | #define TOTAL_MALLOC_LEN CFG_MALLOC_LEN | |
78 | #endif | |
79 | ||
bf9e3b38 WD |
80 | extern ulong __init_end; |
81 | extern ulong _end; | |
82 | ||
83 | extern void timer_init(void); | |
84 | ||
85 | #if defined(CONFIG_WATCHDOG) | |
86 | # define INIT_FUNC_WATCHDOG_INIT watchdog_init, | |
87 | # define WATCHDOG_DISABLE watchdog_disable | |
88 | ||
89 | extern int watchdog_init(void); | |
90 | extern int watchdog_disable(void); | |
91 | #else | |
92 | # define INIT_FUNC_WATCHDOG_INIT /* undef */ | |
93 | # define WATCHDOG_DISABLE /* undef */ | |
94 | #endif /* CONFIG_WATCHDOG */ | |
95 | ||
96 | ulong monitor_flash_len; | |
97 | ||
4e5ca3eb WD |
98 | /* |
99 | * Begin and End of memory area for malloc(), and current "brk" | |
100 | */ | |
bf9e3b38 WD |
101 | static ulong mem_malloc_start = 0; |
102 | static ulong mem_malloc_end = 0; | |
103 | static ulong mem_malloc_brk = 0; | |
4e5ca3eb WD |
104 | |
105 | /************************************************************************ | |
106 | * Utilities * | |
107 | ************************************************************************ | |
108 | */ | |
109 | ||
110 | /* | |
111 | * The Malloc area is immediately below the monitor copy in DRAM | |
112 | */ | |
bf9e3b38 | 113 | static void mem_malloc_init (void) |
4e5ca3eb | 114 | { |
bf9e3b38 WD |
115 | ulong dest_addr = CFG_MONITOR_BASE + gd->reloc_off; |
116 | ||
4e5ca3eb WD |
117 | mem_malloc_end = dest_addr; |
118 | mem_malloc_start = dest_addr - TOTAL_MALLOC_LEN; | |
119 | mem_malloc_brk = mem_malloc_start; | |
120 | ||
bf9e3b38 WD |
121 | memset ((void *) mem_malloc_start, |
122 | 0, | |
4e5ca3eb WD |
123 | mem_malloc_end - mem_malloc_start); |
124 | } | |
125 | ||
126 | void *sbrk (ptrdiff_t increment) | |
127 | { | |
128 | ulong old = mem_malloc_brk; | |
129 | ulong new = old + increment; | |
130 | ||
bf9e3b38 WD |
131 | if ((new < mem_malloc_start) || |
132 | (new > mem_malloc_end) ) { | |
4e5ca3eb WD |
133 | return (NULL); |
134 | } | |
135 | mem_malloc_brk = new; | |
bf9e3b38 | 136 | return ((void *)old); |
4e5ca3eb WD |
137 | } |
138 | ||
bf9e3b38 | 139 | char *strmhz(char *buf, long hz) |
4e5ca3eb | 140 | { |
8ae158cd TL |
141 | long l, n; |
142 | long m; | |
4e5ca3eb | 143 | |
8ae158cd | 144 | n = hz / 1000000L; |
4e5ca3eb | 145 | |
8ae158cd | 146 | l = sprintf (buf, "%ld", n); |
4e5ca3eb | 147 | |
8ae158cd | 148 | m = (hz % 1000000L) / 1000L; |
4e5ca3eb | 149 | |
8ae158cd TL |
150 | if (m != 0) |
151 | sprintf (buf+l, ".%03ld", m); | |
4e5ca3eb | 152 | |
8ae158cd | 153 | return (buf); |
4e5ca3eb WD |
154 | } |
155 | ||
bf9e3b38 WD |
156 | /* |
157 | * All attempts to come up with a "common" initialization sequence | |
158 | * that works for all boards and architectures failed: some of the | |
159 | * requirements are just _too_ different. To get rid of the resulting | |
160 | * mess of board dependend #ifdef'ed code we now make the whole | |
161 | * initialization sequence configurable to the user. | |
162 | * | |
163 | * The requirements for any new initalization function is simple: it | |
164 | * receives a pointer to the "global data" structure as it's only | |
165 | * argument, and returns an integer return code, where 0 means | |
166 | * "continue" and != 0 means "fatal error, hang the system". | |
167 | */ | |
168 | typedef int (init_fnc_t) (void); | |
169 | ||
170 | /************************************************************************ | |
8ae158cd | 171 | * Init Utilities |
bf9e3b38 WD |
172 | ************************************************************************ |
173 | * Some of this code should be moved into the core functions, | |
174 | * but let's get it working (again) first... | |
175 | */ | |
176 | ||
177 | static int init_baudrate (void) | |
4e5ca3eb | 178 | { |
bf9e3b38 WD |
179 | uchar tmp[64]; /* long enough for environment variables */ |
180 | int i = getenv_r ("baudrate", tmp, sizeof (tmp)); | |
181 | ||
182 | gd->baudrate = (i > 0) | |
183 | ? (int) simple_strtoul (tmp, NULL, 10) | |
184 | : CONFIG_BAUDRATE; | |
185 | return (0); | |
186 | } | |
4e5ca3eb | 187 | |
bf9e3b38 | 188 | /***********************************************************************/ |
4e5ca3eb | 189 | |
bf9e3b38 WD |
190 | static int init_func_ram (void) |
191 | { | |
bf9e3b38 WD |
192 | int board_type = 0; /* use dummy arg */ |
193 | puts ("DRAM: "); | |
4e5ca3eb | 194 | |
bf9e3b38 WD |
195 | if ((gd->ram_size = initdram (board_type)) > 0) { |
196 | print_size (gd->ram_size, "\n"); | |
197 | return (0); | |
198 | } | |
199 | puts (failed); | |
200 | return (1); | |
4e5ca3eb WD |
201 | } |
202 | ||
bf9e3b38 WD |
203 | /***********************************************************************/ |
204 | ||
e2c22d78 SR |
205 | #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C) |
206 | static int init_func_i2c (void) | |
207 | { | |
208 | puts ("I2C: "); | |
209 | i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE); | |
210 | puts ("ready\n"); | |
211 | return (0); | |
212 | } | |
213 | #endif | |
214 | ||
215 | /***********************************************************************/ | |
216 | ||
bf9e3b38 WD |
217 | /************************************************************************ |
218 | * Initialization sequence * | |
219 | ************************************************************************ | |
220 | */ | |
221 | ||
222 | init_fnc_t *init_sequence[] = { | |
d61ea148 | 223 | get_clocks, |
bf9e3b38 WD |
224 | env_init, |
225 | init_baudrate, | |
226 | serial_init, | |
227 | console_init_f, | |
228 | display_options, | |
229 | checkcpu, | |
230 | checkboard, | |
e2c22d78 SR |
231 | #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C) |
232 | init_func_i2c, | |
233 | #endif | |
bf9e3b38 WD |
234 | init_func_ram, |
235 | #if defined(CFG_DRAM_TEST) | |
236 | testdram, | |
237 | #endif /* CFG_DRAM_TEST */ | |
238 | INIT_FUNC_WATCHDOG_INIT | |
239 | NULL, /* Terminate this list */ | |
240 | }; | |
241 | ||
242 | ||
4e5ca3eb WD |
243 | /************************************************************************ |
244 | * | |
245 | * This is the first part of the initialization sequence that is | |
246 | * implemented in C, but still running from ROM. | |
247 | * | |
248 | * The main purpose is to provide a (serial) console interface as | |
249 | * soon as possible (so we can see any error messages), and to | |
250 | * initialize the RAM so that we can relocate the monitor code to | |
251 | * RAM. | |
252 | * | |
253 | * Be aware of the restrictions: global data is read-only, BSS is not | |
254 | * initialized, and stack space is limited to a few kB. | |
255 | * | |
256 | ************************************************************************ | |
257 | */ | |
258 | ||
bf9e3b38 WD |
259 | void |
260 | board_init_f (ulong bootflag) | |
4e5ca3eb | 261 | { |
4e5ca3eb | 262 | bd_t *bd; |
bf9e3b38 | 263 | ulong len, addr, addr_sp; |
483a0cf8 | 264 | ulong *paddr; |
bf9e3b38 WD |
265 | gd_t *id; |
266 | init_fnc_t **init_fnc_ptr; | |
267 | #ifdef CONFIG_PRAM | |
268 | int i; | |
269 | ulong reg; | |
4e5ca3eb | 270 | uchar tmp[64]; /* long enough for environment variables */ |
bf9e3b38 | 271 | #endif |
4e5ca3eb | 272 | |
bf9e3b38 WD |
273 | /* Pointer is writable since we allocated a register for it */ |
274 | gd = (gd_t *) (CFG_INIT_RAM_ADDR + CFG_GBL_DATA_OFFSET); | |
93f6a677 WD |
275 | /* compiler optimization barrier needed for GCC >= 3.4 */ |
276 | __asm__ __volatile__("": : :"memory"); | |
4e5ca3eb | 277 | |
bf9e3b38 WD |
278 | /* Clear initial global data */ |
279 | memset ((void *) gd, 0, sizeof (gd_t)); | |
4e5ca3eb | 280 | |
bf9e3b38 WD |
281 | for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) { |
282 | if ((*init_fnc_ptr)() != 0) { | |
283 | hang (); | |
284 | } | |
4e5ca3eb | 285 | } |
4e5ca3eb WD |
286 | |
287 | /* | |
288 | * Now that we have DRAM mapped and working, we can | |
289 | * relocate the code and continue running from DRAM. | |
290 | * | |
291 | * Reserve memory at end of RAM for (top down in that order): | |
bf9e3b38 WD |
292 | * - protected RAM |
293 | * - LCD framebuffer | |
294 | * - monitor code | |
295 | * - board info struct | |
4e5ca3eb | 296 | */ |
bf9e3b38 | 297 | len = (ulong)&_end - CFG_MONITOR_BASE; |
4e5ca3eb | 298 | |
bf9e3b38 | 299 | addr = CFG_SDRAM_BASE + gd->ram_size; |
4e5ca3eb | 300 | |
bf9e3b38 WD |
301 | #ifdef CONFIG_LOGBUFFER |
302 | /* reserve kernel log buffer */ | |
303 | addr -= (LOGBUFF_RESERVE); | |
304 | debug ("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN, addr); | |
305 | #endif | |
306 | ||
307 | #ifdef CONFIG_PRAM | |
308 | /* | |
309 | * reserve protected RAM | |
310 | */ | |
311 | i = getenv_r ("pram", tmp, sizeof (tmp)); | |
312 | reg = (i > 0) ? simple_strtoul (tmp, NULL, 10) : CONFIG_PRAM; | |
313 | addr -= (reg << 10); /* size is in kB */ | |
314 | debug ("Reserving %ldk for protected RAM at %08lx\n", reg, addr); | |
315 | #endif /* CONFIG_PRAM */ | |
4e5ca3eb | 316 | |
1552af70 TL |
317 | /* round down to next 4 kB limit */ |
318 | addr &= ~(4096 - 1); | |
319 | debug ("Top of RAM usable for U-Boot at: %08lx\n", addr); | |
320 | ||
321 | #ifdef CONFIG_LCD | |
322 | /* reserve memory for LCD display (always full pages) */ | |
323 | addr = lcd_setmem (addr); | |
324 | gd->fb_base = addr; | |
325 | #endif /* CONFIG_LCD */ | |
326 | ||
bf9e3b38 WD |
327 | /* |
328 | * reserve memory for U-Boot code, data & bss | |
329 | * round down to next 4 kB limit | |
330 | */ | |
4e5ca3eb | 331 | addr -= len; |
bf9e3b38 WD |
332 | addr &= ~(4096 - 1); |
333 | ||
334 | debug ("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr); | |
4e5ca3eb WD |
335 | |
336 | /* | |
bf9e3b38 | 337 | * reserve memory for malloc() arena |
4e5ca3eb | 338 | */ |
bf9e3b38 WD |
339 | addr_sp = addr - TOTAL_MALLOC_LEN; |
340 | debug ("Reserving %dk for malloc() at: %08lx\n", | |
341 | TOTAL_MALLOC_LEN >> 10, addr_sp); | |
4e5ca3eb | 342 | |
bf9e3b38 WD |
343 | /* |
344 | * (permanently) allocate a Board Info struct | |
345 | * and a permanent copy of the "global" data | |
346 | */ | |
347 | addr_sp -= sizeof (bd_t); | |
348 | bd = (bd_t *) addr_sp; | |
349 | gd->bd = bd; | |
350 | debug ("Reserving %d Bytes for Board Info at: %08lx\n", | |
351 | sizeof (bd_t), addr_sp); | |
352 | addr_sp -= sizeof (gd_t); | |
353 | id = (gd_t *) addr_sp; | |
354 | debug ("Reserving %d Bytes for Global Data at: %08lx\n", | |
355 | sizeof (gd_t), addr_sp); | |
356 | ||
357 | /* Reserve memory for boot params. */ | |
358 | addr_sp -= CFG_BOOTPARAMS_LEN; | |
359 | bd->bi_boot_params = addr_sp; | |
360 | debug ("Reserving %dk for boot parameters at: %08lx\n", | |
361 | CFG_BOOTPARAMS_LEN >> 10, addr_sp); | |
4e5ca3eb | 362 | |
bf9e3b38 WD |
363 | /* |
364 | * Finally, we set up a new (bigger) stack. | |
365 | * | |
366 | * Leave some safety gap for SP, force alignment on 16 byte boundary | |
367 | * Clear initial stack frame | |
368 | */ | |
369 | addr_sp -= 16; | |
370 | addr_sp &= ~0xF; | |
483a0cf8 MB |
371 | |
372 | paddr = (ulong *)addr_sp; | |
373 | *paddr-- = 0; | |
374 | *paddr-- = 0; | |
375 | addr_sp = (ulong)paddr; | |
977b50f8 | 376 | |
bf9e3b38 | 377 | debug ("Stack Pointer at: %08lx\n", addr_sp); |
4e5ca3eb | 378 | |
bf9e3b38 WD |
379 | /* |
380 | * Save local variables to board info struct | |
381 | */ | |
382 | bd->bi_memstart = CFG_SDRAM_BASE; /* start of DRAM memory */ | |
383 | bd->bi_memsize = gd->ram_size; /* size of DRAM memory in bytes */ | |
8e585f02 TL |
384 | #ifdef CFG_INIT_RAM_ADDR |
385 | bd->bi_sramstart = CFG_INIT_RAM_ADDR; /* start of SRAM memory */ | |
386 | bd->bi_sramsize = CFG_INIT_RAM_END; /* size of SRAM memory */ | |
387 | #endif | |
bf9e3b38 WD |
388 | bd->bi_mbar_base = CFG_MBAR; /* base of internal registers */ |
389 | ||
390 | bd->bi_bootflags = bootflag; /* boot / reboot flag (for LynxOS) */ | |
391 | ||
392 | WATCHDOG_RESET (); | |
393 | bd->bi_intfreq = gd->cpu_clk; /* Internal Freq, in Hz */ | |
394 | bd->bi_busfreq = gd->bus_clk; /* Bus Freq, in Hz */ | |
8ae158cd TL |
395 | #ifdef CONFIG_PCI |
396 | bd->bi_pcifreq = gd->pci_clk; /* PCI Freq in Hz */ | |
397 | #endif | |
398 | #ifdef CONFIG_EXTRA_CLOCK | |
399 | bd->bi_inpfreq = gd->inp_clk; /* input Freq in Hz */ | |
400 | bd->bi_vcofreq = gd->vco_clk; /* vco Freq in Hz */ | |
401 | bd->bi_flbfreq = gd->flb_clk; /* flexbus Freq in Hz */ | |
402 | #endif | |
bf9e3b38 | 403 | bd->bi_baudrate = gd->baudrate; /* Console Baudrate */ |
4e5ca3eb WD |
404 | |
405 | #ifdef CFG_EXTBDINFO | |
406 | strncpy (bd->bi_s_version, "1.2", sizeof (bd->bi_s_version)); | |
bf9e3b38 WD |
407 | strncpy (bd->bi_r_version, U_BOOT_VERSION, sizeof (bd->bi_r_version)); |
408 | #endif | |
409 | ||
410 | WATCHDOG_RESET (); | |
4e5ca3eb | 411 | |
bf9e3b38 WD |
412 | #ifdef CONFIG_POST |
413 | post_bootmode_init(); | |
414 | post_run (NULL, POST_ROM | post_bootmode_get(0)); | |
4e5ca3eb WD |
415 | #endif |
416 | ||
bf9e3b38 | 417 | WATCHDOG_RESET(); |
4e5ca3eb | 418 | |
bf9e3b38 WD |
419 | memcpy (id, (void *)gd, sizeof (gd_t)); |
420 | ||
421 | debug ("Start relocate of code from %08x to %08lx\n", CFG_MONITOR_BASE, addr); | |
422 | relocate_code (addr_sp, id, addr); | |
4e5ca3eb | 423 | |
bf9e3b38 WD |
424 | /* NOTREACHED - jump_to_ram() does not return */ |
425 | } | |
4e5ca3eb WD |
426 | |
427 | /************************************************************************ | |
428 | * | |
429 | * This is the next part if the initialization sequence: we are now | |
430 | * running from RAM and have a "normal" C environment, i. e. global | |
431 | * data can be written, BSS has been cleared, the stack size in not | |
432 | * that critical any more, etc. | |
433 | * | |
434 | ************************************************************************ | |
435 | */ | |
bf9e3b38 | 436 | void board_init_r (gd_t *id, ulong dest_addr) |
4e5ca3eb | 437 | { |
4e5ca3eb | 438 | cmd_tbl_t *cmdtp; |
bf9e3b38 | 439 | char *s, *e; |
4e5ca3eb | 440 | bd_t *bd; |
bf9e3b38 WD |
441 | int i; |
442 | extern void malloc_bin_reloc (void); | |
4e5ca3eb | 443 | |
bf9e3b38 WD |
444 | #ifndef CFG_ENV_IS_NOWHERE |
445 | extern char * env_name_spec; | |
446 | #endif | |
447 | #ifndef CFG_NO_FLASH | |
448 | ulong flash_size; | |
449 | #endif | |
450 | gd = id; /* initialize RAM version of global data */ | |
4e5ca3eb | 451 | bd = gd->bd; |
bf9e3b38 WD |
452 | |
453 | gd->flags |= GD_FLG_RELOC; /* tell others: relocation done */ | |
454 | ||
8e585f02 TL |
455 | #ifdef CONFIG_SERIAL_MULTI |
456 | serial_initialize(); | |
457 | #endif | |
458 | ||
bf9e3b38 WD |
459 | debug ("Now running in RAM - U-Boot at: %08lx\n", dest_addr); |
460 | ||
461 | WATCHDOG_RESET (); | |
462 | ||
463 | gd->reloc_off = dest_addr - CFG_MONITOR_BASE; | |
464 | ||
465 | monitor_flash_len = (ulong)&__init_end - dest_addr; | |
466 | ||
467 | /* | |
468 | * We have to relocate the command table manually | |
469 | */ | |
470 | for (cmdtp = &__u_boot_cmd_start; cmdtp != &__u_boot_cmd_end; cmdtp++) { | |
471 | ulong addr; | |
472 | addr = (ulong) (cmdtp->cmd) + gd->reloc_off; | |
473 | #if 0 | |
474 | printf ("Command \"%s\": 0x%08lx => 0x%08lx\n", | |
475 | cmdtp->name, (ulong) (cmdtp->cmd), addr); | |
476 | #endif | |
477 | cmdtp->cmd = | |
478 | (int (*)(struct cmd_tbl_s *, int, int, char *[]))addr; | |
479 | ||
480 | addr = (ulong)(cmdtp->name) + gd->reloc_off; | |
481 | cmdtp->name = (char *)addr; | |
482 | ||
483 | if (cmdtp->usage) { | |
484 | addr = (ulong)(cmdtp->usage) + gd->reloc_off; | |
485 | cmdtp->usage = (char *)addr; | |
486 | } | |
487 | #ifdef CFG_LONGHELP | |
488 | if (cmdtp->help) { | |
489 | addr = (ulong)(cmdtp->help) + gd->reloc_off; | |
490 | cmdtp->help = (char *)addr; | |
491 | } | |
492 | #endif | |
493 | } | |
494 | /* there are some other pointer constants we must deal with */ | |
495 | #ifndef CFG_ENV_IS_NOWHERE | |
496 | env_name_spec += gd->reloc_off; | |
497 | #endif | |
498 | ||
499 | WATCHDOG_RESET (); | |
500 | ||
501 | #ifdef CONFIG_LOGBUFFER | |
502 | logbuff_init_ptrs (); | |
503 | #endif | |
504 | #ifdef CONFIG_POST | |
505 | post_output_backlog (); | |
506 | post_reloc (); | |
507 | #endif | |
508 | WATCHDOG_RESET(); | |
509 | ||
510 | #if 0 | |
511 | /* instruction cache enabled in cpu_init_f() for faster relocation */ | |
512 | icache_enable (); /* it's time to enable the instruction cache */ | |
513 | #endif | |
4e5ca3eb WD |
514 | |
515 | /* | |
516 | * Setup trap handlers | |
517 | */ | |
8e585f02 | 518 | trap_init (CFG_SDRAM_BASE); |
4e5ca3eb | 519 | |
bf9e3b38 | 520 | #if !defined(CFG_NO_FLASH) |
4e5ca3eb WD |
521 | puts ("FLASH: "); |
522 | ||
523 | if ((flash_size = flash_init ()) > 0) { | |
bf9e3b38 WD |
524 | # ifdef CFG_FLASH_CHECKSUM |
525 | print_size (flash_size, ""); | |
4e5ca3eb WD |
526 | /* |
527 | * Compute and print flash CRC if flashchecksum is set to 'y' | |
528 | * | |
bf9e3b38 | 529 | * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX |
4e5ca3eb WD |
530 | */ |
531 | s = getenv ("flashchecksum"); | |
532 | if (s && (*s == 'y')) { | |
533 | printf (" CRC: %08lX", | |
bf9e3b38 WD |
534 | crc32 (0, |
535 | (const unsigned char *) CFG_FLASH_BASE, | |
536 | flash_size) | |
537 | ); | |
4e5ca3eb WD |
538 | } |
539 | putc ('\n'); | |
bf9e3b38 WD |
540 | # else /* !CFG_FLASH_CHECKSUM */ |
541 | print_size (flash_size, "\n"); | |
542 | # endif /* CFG_FLASH_CHECKSUM */ | |
4e5ca3eb WD |
543 | } else { |
544 | puts (failed); | |
545 | hang (); | |
546 | } | |
547 | ||
bf9e3b38 WD |
548 | bd->bi_flashstart = CFG_FLASH_BASE; /* update start of FLASH memory */ |
549 | bd->bi_flashsize = flash_size; /* size of FLASH memory (final value) */ | |
550 | bd->bi_flashoffset = 0; | |
551 | #else /* CFG_NO_FLASH */ | |
552 | bd->bi_flashsize = 0; | |
553 | bd->bi_flashstart = 0; | |
554 | bd->bi_flashoffset = 0; | |
555 | #endif /* !CFG_NO_FLASH */ | |
4e5ca3eb WD |
556 | |
557 | WATCHDOG_RESET (); | |
558 | ||
559 | /* initialize higher level parts of CPU like time base and timers */ | |
560 | cpu_init_r (); | |
561 | ||
562 | WATCHDOG_RESET (); | |
563 | ||
564 | /* initialize malloc() area */ | |
bf9e3b38 WD |
565 | mem_malloc_init (); |
566 | malloc_bin_reloc (); | |
4e5ca3eb WD |
567 | |
568 | #ifdef CONFIG_SPI | |
569 | # if !defined(CFG_ENV_IS_IN_EEPROM) | |
570 | spi_init_f (); | |
571 | # endif | |
572 | spi_init_r (); | |
573 | #endif | |
574 | ||
575 | /* relocate environment function pointers etc. */ | |
576 | env_relocate (); | |
577 | ||
bf9e3b38 WD |
578 | /* |
579 | * Fill in missing fields of bd_info. | |
580 | * We do this here, where we have "normal" access to the | |
581 | * environment; we used to do this still running from ROM, | |
582 | * where had to use getenv_r(), which can be pretty slow when | |
583 | * the environment is in EEPROM. | |
584 | */ | |
585 | s = getenv ("ethaddr"); | |
586 | for (i = 0; i < 6; ++i) { | |
587 | bd->bi_enetaddr[i] = s ? simple_strtoul (s, &e, 16) : 0; | |
588 | if (s) | |
589 | s = (*e) ? e + 1 : e; | |
590 | } | |
8e585f02 TL |
591 | #ifdef CONFIG_HAS_ETH1 |
592 | /* handle the 2nd ethernet address */ | |
593 | ||
594 | s = getenv ("eth1addr"); | |
595 | for (i = 0; i < 6; ++i) { | |
596 | bd->bi_enet1addr[i] = s ? simple_strtoul (s, &e, 16) : 0; | |
597 | if (s) | |
598 | s = (*e) ? e + 1 : e; | |
599 | } | |
600 | #endif | |
601 | #ifdef CONFIG_HAS_ETH2 | |
602 | /* handle the 3rd ethernet address */ | |
603 | ||
604 | s = getenv ("eth2addr"); | |
605 | for (i = 0; i < 6; ++i) { | |
606 | bd->bi_enet2addr[i] = s ? simple_strtoul (s, &e, 16) : 0; | |
607 | if (s) | |
608 | s = (*e) ? e + 1 : e; | |
609 | } | |
610 | #endif | |
611 | ||
612 | #ifdef CONFIG_HAS_ETH3 | |
613 | /* handle 4th ethernet address */ | |
614 | s = getenv("eth3addr"); | |
615 | for (i = 0; i < 6; ++i) { | |
616 | bd->bi_enet3addr[i] = s ? simple_strtoul (s, &e, 16) : 0; | |
617 | if (s) | |
618 | s = (*e) ? e + 1 : e; | |
619 | } | |
620 | #endif | |
bf9e3b38 | 621 | |
4e5ca3eb WD |
622 | /* IP Address */ |
623 | bd->bi_ip_addr = getenv_IPaddr ("ipaddr"); | |
624 | ||
625 | WATCHDOG_RESET (); | |
626 | ||
8e585f02 TL |
627 | #if defined(CONFIG_PCI) |
628 | /* | |
629 | * Do pci configuration | |
630 | */ | |
631 | pci_init (); | |
632 | #endif | |
4e5ca3eb | 633 | |
bf9e3b38 WD |
634 | /** leave this here (after malloc(), environment and PCI are working) **/ |
635 | /* Initialize devices */ | |
636 | devices_init (); | |
4e5ca3eb | 637 | |
bf9e3b38 WD |
638 | /* Initialize the jump table for applications */ |
639 | jumptable_init (); | |
4e5ca3eb | 640 | |
bf9e3b38 WD |
641 | /* Initialize the console (after the relocation and devices init) */ |
642 | console_init_r (); | |
4e5ca3eb | 643 | |
e2c22d78 SR |
644 | #if defined(CONFIG_MISC_INIT_R) |
645 | /* miscellaneous platform dependent initialisations */ | |
646 | misc_init_r (); | |
647 | #endif | |
648 | ||
7def6b34 | 649 | #if defined(CONFIG_CMD_KGDB) |
4e5ca3eb WD |
650 | WATCHDOG_RESET (); |
651 | puts ("KGDB: "); | |
652 | kgdb_init (); | |
653 | #endif | |
654 | ||
bf9e3b38 WD |
655 | debug ("U-Boot relocated to %08lx\n", dest_addr); |
656 | ||
4e5ca3eb WD |
657 | /* |
658 | * Enable Interrupts | |
659 | */ | |
660 | interrupt_init (); | |
bf9e3b38 WD |
661 | |
662 | /* Must happen after interrupts are initialized since | |
663 | * an irq handler gets installed | |
664 | */ | |
665 | timer_init(); | |
666 | ||
42dfe7a1 | 667 | #ifdef CONFIG_SERIAL_SOFTWARE_FIFO |
bf9e3b38 WD |
668 | serial_buffered_init(); |
669 | #endif | |
670 | ||
671 | #ifdef CONFIG_STATUS_LED | |
672 | status_led_set (STATUS_LED_BOOT, STATUS_LED_BLINKING); | |
673 | #endif | |
674 | ||
4e5ca3eb | 675 | udelay (20); |
bf9e3b38 | 676 | |
4e5ca3eb WD |
677 | set_timer (0); |
678 | ||
679 | /* Insert function pointers now that we have relocated the code */ | |
680 | ||
681 | /* Initialize from environment */ | |
682 | if ((s = getenv ("loadaddr")) != NULL) { | |
683 | load_addr = simple_strtoul (s, NULL, 16); | |
684 | } | |
7def6b34 | 685 | #if defined(CONFIG_CMD_NET) |
4e5ca3eb WD |
686 | if ((s = getenv ("bootfile")) != NULL) { |
687 | copy_filename (BootFile, s, sizeof (BootFile)); | |
688 | } | |
b3aff0cb | 689 | #endif |
4e5ca3eb WD |
690 | |
691 | WATCHDOG_RESET (); | |
692 | ||
7def6b34 | 693 | #if defined(CONFIG_CMD_DOC) |
bf9e3b38 WD |
694 | WATCHDOG_RESET (); |
695 | puts ("DOC: "); | |
696 | doc_init (); | |
697 | #endif | |
698 | ||
7def6b34 | 699 | #if defined(CONFIG_CMD_NAND) |
4e5ca3eb | 700 | WATCHDOG_RESET (); |
d860c34f | 701 | puts ("NAND: "); |
bf9e3b38 WD |
702 | nand_init(); /* go init the NAND */ |
703 | #endif | |
704 | ||
d61ea148 | 705 | #if defined(CONFIG_CMD_NET) |
bf9e3b38 | 706 | WATCHDOG_RESET(); |
8e585f02 | 707 | #if defined(FEC_ENET) |
bf9e3b38 WD |
708 | eth_init(bd); |
709 | #endif | |
8e585f02 TL |
710 | #if defined(CONFIG_NET_MULTI) |
711 | puts ("Net: "); | |
ab77bc54 | 712 | eth_initialize (bd); |
8e585f02 TL |
713 | #endif |
714 | #endif | |
bf9e3b38 WD |
715 | |
716 | #ifdef CONFIG_POST | |
717 | post_run (NULL, POST_RAM | post_bootmode_get(0)); | |
4e5ca3eb WD |
718 | #endif |
719 | ||
d61ea148 SR |
720 | #if defined(CONFIG_CMD_PCMCIA) \ |
721 | && !defined(CONFIG_CMD_IDE) | |
8e585f02 TL |
722 | WATCHDOG_RESET (); |
723 | puts ("PCMCIA:"); | |
724 | pcmcia_init (); | |
725 | #endif | |
726 | ||
d61ea148 | 727 | #if defined(CONFIG_CMD_IDE) |
8e585f02 TL |
728 | WATCHDOG_RESET (); |
729 | puts ("IDE: "); | |
730 | ide_init (); | |
d61ea148 | 731 | #endif |
8e585f02 | 732 | |
4e5ca3eb WD |
733 | #ifdef CONFIG_LAST_STAGE_INIT |
734 | WATCHDOG_RESET (); | |
735 | /* | |
736 | * Some parts can be only initialized if all others (like | |
737 | * Interrupts) are up and running (i.e. the PC-style ISA | |
738 | * keyboard). | |
739 | */ | |
740 | last_stage_init (); | |
741 | #endif | |
742 | ||
7def6b34 | 743 | #if defined(CONFIG_CMD_BEDBUG) |
4e5ca3eb WD |
744 | WATCHDOG_RESET (); |
745 | bedbug_init (); | |
746 | #endif | |
747 | ||
bf9e3b38 | 748 | #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER) |
4e5ca3eb WD |
749 | /* |
750 | * Export available size of memory for Linux, | |
751 | * taking into account the protected RAM at top of memory | |
752 | */ | |
753 | { | |
754 | ulong pram; | |
4e5ca3eb | 755 | uchar memsz[32]; |
bf9e3b38 WD |
756 | #ifdef CONFIG_PRAM |
757 | char *s; | |
4e5ca3eb WD |
758 | |
759 | if ((s = getenv ("pram")) != NULL) { | |
760 | pram = simple_strtoul (s, NULL, 10); | |
761 | } else { | |
762 | pram = CONFIG_PRAM; | |
763 | } | |
bf9e3b38 WD |
764 | #else |
765 | pram=0; | |
766 | #endif | |
767 | #ifdef CONFIG_LOGBUFFER | |
768 | /* Also take the logbuffer into account (pram is in kB) */ | |
769 | pram += (LOGBUFF_LEN+LOGBUFF_OVERHEAD)/1024; | |
770 | #endif | |
4e5ca3eb WD |
771 | sprintf (memsz, "%ldk", (bd->bi_memsize / 1024) - pram); |
772 | setenv ("mem", memsz); | |
773 | } | |
774 | #endif | |
775 | ||
bf9e3b38 WD |
776 | #ifdef CONFIG_MODEM_SUPPORT |
777 | { | |
778 | extern int do_mdm_init; | |
779 | do_mdm_init = gd->do_mdm_init; | |
780 | } | |
781 | #endif | |
782 | ||
783 | #ifdef CONFIG_WATCHDOG | |
784 | /* disable watchdog if environment is set */ | |
785 | if ((s = getenv ("watchdog")) != NULL) { | |
786 | if (strncmp (s, "off", 3) == 0) { | |
787 | WATCHDOG_DISABLE (); | |
788 | } | |
789 | } | |
790 | #endif /* CONFIG_WATCHDOG*/ | |
791 | ||
792 | ||
4e5ca3eb WD |
793 | /* Initialization complete - start the monitor */ |
794 | ||
795 | /* main_loop() can return to retry autoboot, if so just run it again. */ | |
796 | for (;;) { | |
797 | WATCHDOG_RESET (); | |
798 | main_loop (); | |
799 | } | |
800 | ||
801 | /* NOTREACHED - no way out of command loop except booting */ | |
802 | } | |
803 | ||
bf9e3b38 WD |
804 | |
805 | void hang(void) | |
4e5ca3eb WD |
806 | { |
807 | puts ("### ERROR ### Please RESET the board ###\n"); | |
808 | for (;;); | |
809 | } |