Merge branch 'master' of git://git.denx.de/u-boot-arm
[platform/kernel/u-boot.git] / arch / powerpc / lib / board.c
1 /*
2  * (C) Copyright 2000-2011
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7
8 #include <common.h>
9 #include <watchdog.h>
10 #include <command.h>
11 #include <malloc.h>
12 #include <stdio_dev.h>
13 #ifdef CONFIG_8xx
14 #include <mpc8xx.h>
15 #endif
16 #ifdef CONFIG_5xx
17 #include <mpc5xx.h>
18 #endif
19 #ifdef CONFIG_MPC5xxx
20 #include <mpc5xxx.h>
21 #endif
22 #if defined(CONFIG_CMD_IDE)
23 #include <ide.h>
24 #endif
25 #if defined(CONFIG_CMD_SCSI)
26 #include <scsi.h>
27 #endif
28 #if defined(CONFIG_CMD_KGDB)
29 #include <kgdb.h>
30 #endif
31 #ifdef CONFIG_STATUS_LED
32 #include <status_led.h>
33 #endif
34 #include <net.h>
35 #ifdef CONFIG_GENERIC_MMC
36 #include <mmc.h>
37 #endif
38 #include <serial.h>
39 #ifdef CONFIG_SYS_ALLOC_DPRAM
40 #if !defined(CONFIG_CPM2)
41 #include <commproc.h>
42 #endif
43 #endif
44 #include <version.h>
45 #if defined(CONFIG_BAB7xx)
46 #include <w83c553f.h>
47 #endif
48 #include <dtt.h>
49 #if defined(CONFIG_POST)
50 #include <post.h>
51 #endif
52 #if defined(CONFIG_LOGBUFFER)
53 #include <logbuff.h>
54 #endif
55 #if defined(CONFIG_SYS_INIT_RAM_LOCK) && defined(CONFIG_E500)
56 #include <asm/cache.h>
57 #endif
58 #ifdef CONFIG_PS2KBD
59 #include <keyboard.h>
60 #endif
61
62 #ifdef CONFIG_ADDR_MAP
63 #include <asm/mmu.h>
64 #endif
65
66 #ifdef CONFIG_MP
67 #include <asm/mp.h>
68 #endif
69
70 #ifdef CONFIG_BITBANGMII
71 #include <miiphy.h>
72 #endif
73
74 #ifdef CONFIG_SYS_UPDATE_FLASH_SIZE
75 extern int update_flash_size(int flash_size);
76 #endif
77
78 #if defined(CONFIG_SC3)
79 extern void sc3_read_eeprom(void);
80 #endif
81
82 #if defined(CONFIG_CMD_DOC)
83 void doc_init(void);
84 #endif
85 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C)
86 #include <i2c.h>
87 #endif
88 #include <spi.h>
89 #include <nand.h>
90
91 static char *failed = "*** failed ***\n";
92
93 #if defined(CONFIG_OXC) || defined(CONFIG_RMU)
94 extern flash_info_t flash_info[];
95 #endif
96
97 #if defined(CONFIG_START_IDE)
98 extern int board_start_ide(void);
99 #endif
100 #include <environment.h>
101
102 DECLARE_GLOBAL_DATA_PTR;
103
104 #if !defined(CONFIG_SYS_MEM_TOP_HIDE)
105 #define CONFIG_SYS_MEM_TOP_HIDE 0
106 #endif
107
108 extern ulong __init_end;
109 extern ulong __bss_end;
110 ulong monitor_flash_len;
111
112 #if defined(CONFIG_CMD_BEDBUG)
113 #include <bedbug/type.h>
114 #endif
115
116 /*
117  * Utilities
118  */
119
120 /*
121  * All attempts to come up with a "common" initialization sequence
122  * that works for all boards and architectures failed: some of the
123  * requirements are just _too_ different. To get rid of the resulting
124  * mess of board dependend #ifdef'ed code we now make the whole
125  * initialization sequence configurable to the user.
126  *
127  * The requirements for any new initalization function is simple: it
128  * receives a pointer to the "global data" structure as it's only
129  * argument, and returns an integer return code, where 0 means
130  * "continue" and != 0 means "fatal error, hang the system".
131  */
132 typedef int (init_fnc_t)(void);
133
134 /*
135  * Init Utilities
136  *
137  * Some of this code should be moved into the core functions,
138  * but let's get it working (again) first...
139  */
140
141 static int init_baudrate(void)
142 {
143         gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
144         return 0;
145 }
146
147 /***********************************************************************/
148
149 static void __board_add_ram_info(int use_default)
150 {
151         /* please define platform specific board_add_ram_info() */
152 }
153
154 void board_add_ram_info(int)
155         __attribute__ ((weak, alias("__board_add_ram_info")));
156
157 static int __board_flash_wp_on(void)
158 {
159         /*
160          * Most flashes can't be detected when write protection is enabled,
161          * so provide a way to let U-Boot gracefully ignore write protected
162          * devices.
163          */
164         return 0;
165 }
166
167 int board_flash_wp_on(void)
168         __attribute__ ((weak, alias("__board_flash_wp_on")));
169
170 static void __cpu_secondary_init_r(void)
171 {
172 }
173
174 void cpu_secondary_init_r(void)
175         __attribute__ ((weak, alias("__cpu_secondary_init_r")));
176
177 static int init_func_ram(void)
178 {
179 #ifdef  CONFIG_BOARD_TYPES
180         int board_type = gd->board_type;
181 #else
182         int board_type = 0;     /* use dummy arg */
183 #endif
184         puts("DRAM:  ");
185
186         gd->ram_size = initdram(board_type);
187
188         if (gd->ram_size > 0) {
189                 print_size(gd->ram_size, "");
190                 board_add_ram_info(0);
191                 putc('\n');
192                 return 0;
193         }
194         puts(failed);
195         return 1;
196 }
197
198 /***********************************************************************/
199
200 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C)
201 static int init_func_i2c(void)
202 {
203         puts("I2C:   ");
204 #ifdef CONFIG_SYS_I2C
205         i2c_init_all();
206 #else
207         i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
208 #endif
209         puts("ready\n");
210         return 0;
211 }
212 #endif
213
214 #if defined(CONFIG_HARD_SPI)
215 static int init_func_spi(void)
216 {
217         puts("SPI:   ");
218         spi_init();
219         puts("ready\n");
220         return 0;
221 }
222 #endif
223
224 /***********************************************************************/
225
226 #if defined(CONFIG_WATCHDOG)
227 int init_func_watchdog_init(void)
228 {
229         puts("       Watchdog enabled\n");
230         WATCHDOG_RESET();
231         return 0;
232 }
233
234 int init_func_watchdog_reset(void)
235 {
236         WATCHDOG_RESET();
237         return 0;
238 }
239 #endif /* CONFIG_WATCHDOG */
240
241 /*
242  * Initialization sequence
243  */
244
245 static init_fnc_t *init_sequence[] = {
246 #if defined(CONFIG_MPC85xx) || defined(CONFIG_MPC86xx)
247         probecpu,
248 #endif
249 #if defined(CONFIG_BOARD_EARLY_INIT_F)
250         board_early_init_f,
251 #endif
252 #if !defined(CONFIG_8xx_CPUCLK_DEFAULT)
253         get_clocks,             /* get CPU and bus clocks (etc.) */
254 #if defined(CONFIG_TQM8xxL) && !defined(CONFIG_TQM866M) \
255     && !defined(CONFIG_TQM885D)
256         adjust_sdram_tbs_8xx,
257 #endif
258         init_timebase,
259 #endif
260 #ifdef CONFIG_SYS_ALLOC_DPRAM
261 #if !defined(CONFIG_CPM2)
262         dpram_init,
263 #endif
264 #endif
265 #if defined(CONFIG_BOARD_POSTCLK_INIT)
266         board_postclk_init,
267 #endif
268         env_init,
269 #if defined(CONFIG_8xx_CPUCLK_DEFAULT)
270         /* get CPU and bus clocks according to the environment variable */
271         get_clocks_866,
272         /* adjust sdram refresh rate according to the new clock */
273         sdram_adjust_866,
274         init_timebase,
275 #endif
276         init_baudrate,
277         serial_init,
278         console_init_f,
279         display_options,
280 #if defined(CONFIG_MPC8260)
281         prt_8260_rsr,
282         prt_8260_clks,
283 #endif /* CONFIG_MPC8260 */
284 #if defined(CONFIG_MPC83xx)
285         prt_83xx_rsr,
286 #endif
287         checkcpu,
288 #if defined(CONFIG_MPC5xxx)
289         prt_mpc5xxx_clks,
290 #endif /* CONFIG_MPC5xxx */
291         checkboard,
292         INIT_FUNC_WATCHDOG_INIT
293 #if defined(CONFIG_MISC_INIT_F)
294         misc_init_f,
295 #endif
296         INIT_FUNC_WATCHDOG_RESET
297 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C)
298         init_func_i2c,
299 #endif
300 #if defined(CONFIG_HARD_SPI)
301         init_func_spi,
302 #endif
303 #ifdef CONFIG_POST
304         post_init_f,
305 #endif
306         INIT_FUNC_WATCHDOG_RESET
307         init_func_ram,
308 #if defined(CONFIG_SYS_DRAM_TEST)
309         testdram,
310 #endif /* CONFIG_SYS_DRAM_TEST */
311         INIT_FUNC_WATCHDOG_RESET
312         NULL,   /* Terminate this list */
313 };
314
315 static int __fixup_cpu(void)
316 {
317         return 0;
318 }
319
320 int fixup_cpu(void) __attribute__((weak, alias("__fixup_cpu")));
321
322 /*
323  * This is the first part of the initialization sequence that is
324  * implemented in C, but still running from ROM.
325  *
326  * The main purpose is to provide a (serial) console interface as
327  * soon as possible (so we can see any error messages), and to
328  * initialize the RAM so that we can relocate the monitor code to
329  * RAM.
330  *
331  * Be aware of the restrictions: global data is read-only, BSS is not
332  * initialized, and stack space is limited to a few kB.
333  */
334
335 void board_init_f(ulong bootflag)
336 {
337         bd_t *bd;
338         ulong len, addr, addr_sp;
339         ulong *s;
340         gd_t *id;
341         init_fnc_t **init_fnc_ptr;
342
343 #ifdef CONFIG_PRAM
344         ulong reg;
345 #endif
346 #ifdef CONFIG_DEEP_SLEEP
347         const ccsr_gur_t *gur = (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
348         struct ccsr_scfg *scfg = (void *)CONFIG_SYS_MPC85xx_SCFG;
349         u32 start_addr;
350         typedef void (*func_t)(void);
351         func_t kernel_resume;
352 #endif
353
354         /* Pointer is writable since we allocated a register for it */
355         gd = (gd_t *) (CONFIG_SYS_INIT_RAM_ADDR + CONFIG_SYS_GBL_DATA_OFFSET);
356         /* compiler optimization barrier needed for GCC >= 3.4 */
357         __asm__ __volatile__("":::"memory");
358
359 #if !defined(CONFIG_CPM2) && !defined(CONFIG_MPC512X) && \
360     !defined(CONFIG_MPC83xx) && !defined(CONFIG_MPC85xx) && \
361     !defined(CONFIG_MPC86xx)
362         /* Clear initial global data */
363         memset((void *) gd, 0, sizeof(gd_t));
364 #endif
365
366         for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr)
367                 if ((*init_fnc_ptr) () != 0)
368                         hang();
369
370 #ifdef CONFIG_DEEP_SLEEP
371         /* Jump to kernel in deep sleep case */
372         if (in_be32(&gur->scrtsr[0]) & (1 << 3)) {
373                 start_addr = in_be32(&scfg->sparecr[1]);
374                 kernel_resume = (func_t)start_addr;
375                 kernel_resume();
376         }
377 #endif
378
379 #ifdef CONFIG_POST
380         post_bootmode_init();
381         post_run(NULL, POST_ROM | post_bootmode_get(NULL));
382 #endif
383
384         WATCHDOG_RESET();
385
386         /*
387          * Now that we have DRAM mapped and working, we can
388          * relocate the code and continue running from DRAM.
389          *
390          * Reserve memory at end of RAM for (top down in that order):
391          *  - area that won't get touched by U-Boot and Linux (optional)
392          *  - kernel log buffer
393          *  - protected RAM
394          *  - LCD framebuffer
395          *  - monitor code
396          *  - board info struct
397          */
398         len = (ulong)&__bss_end - CONFIG_SYS_MONITOR_BASE;
399
400         /*
401          * Subtract specified amount of memory to hide so that it won't
402          * get "touched" at all by U-Boot. By fixing up gd->ram_size
403          * the Linux kernel should now get passed the now "corrected"
404          * memory size and won't touch it either. This should work
405          * for arch/ppc and arch/powerpc. Only Linux board ports in
406          * arch/powerpc with bootwrapper support, that recalculate the
407          * memory size from the SDRAM controller setup will have to
408          * get fixed.
409          */
410         gd->ram_size -= CONFIG_SYS_MEM_TOP_HIDE;
411
412         addr = CONFIG_SYS_SDRAM_BASE + get_effective_memsize();
413
414 #if defined(CONFIG_MP) && (defined(CONFIG_MPC86xx) || defined(CONFIG_E500))
415         /*
416          * We need to make sure the location we intend to put secondary core
417          * boot code is reserved and not used by any part of u-boot
418          */
419         if (addr > determine_mp_bootpg(NULL)) {
420                 addr = determine_mp_bootpg(NULL);
421                 debug("Reserving MP boot page to %08lx\n", addr);
422         }
423 #endif
424
425 #ifdef CONFIG_LOGBUFFER
426 #ifndef CONFIG_ALT_LB_ADDR
427         /* reserve kernel log buffer */
428         addr -= (LOGBUFF_RESERVE);
429         debug("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN,
430               addr);
431 #endif
432 #endif
433
434 #ifdef CONFIG_PRAM
435         /*
436          * reserve protected RAM
437          */
438         reg = getenv_ulong("pram", 10, CONFIG_PRAM);
439         addr -= (reg << 10);    /* size is in kB */
440         debug("Reserving %ldk for protected RAM at %08lx\n", reg, addr);
441 #endif /* CONFIG_PRAM */
442
443         /* round down to next 4 kB limit */
444         addr &= ~(4096 - 1);
445         debug("Top of RAM usable for U-Boot at: %08lx\n", addr);
446
447 #ifdef CONFIG_LCD
448 #ifdef CONFIG_FB_ADDR
449         gd->fb_base = CONFIG_FB_ADDR;
450 #else
451         /* reserve memory for LCD display (always full pages) */
452         addr = lcd_setmem(addr);
453         gd->fb_base = addr;
454 #endif /* CONFIG_FB_ADDR */
455 #endif /* CONFIG_LCD */
456
457 #if defined(CONFIG_VIDEO) && defined(CONFIG_8xx)
458         /* reserve memory for video display (always full pages) */
459         addr = video_setmem(addr);
460         gd->fb_base = addr;
461 #endif /* CONFIG_VIDEO  */
462
463         /*
464          * reserve memory for U-Boot code, data & bss
465          * round down to next 4 kB limit
466          */
467         addr -= len;
468         addr &= ~(4096 - 1);
469 #ifdef CONFIG_E500
470         /* round down to next 64 kB limit so that IVPR stays aligned */
471         addr &= ~(65536 - 1);
472 #endif
473
474         debug("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr);
475
476         /*
477          * reserve memory for malloc() arena
478          */
479         addr_sp = addr - TOTAL_MALLOC_LEN;
480         debug("Reserving %dk for malloc() at: %08lx\n",
481               TOTAL_MALLOC_LEN >> 10, addr_sp);
482
483         /*
484          * (permanently) allocate a Board Info struct
485          * and a permanent copy of the "global" data
486          */
487         addr_sp -= sizeof(bd_t);
488         bd = (bd_t *) addr_sp;
489         memset(bd, 0, sizeof(bd_t));
490         gd->bd = bd;
491         debug("Reserving %zu Bytes for Board Info at: %08lx\n",
492               sizeof(bd_t), addr_sp);
493         addr_sp -= sizeof(gd_t);
494         id = (gd_t *) addr_sp;
495         debug("Reserving %zu Bytes for Global Data at: %08lx\n",
496               sizeof(gd_t), addr_sp);
497
498         /*
499          * Finally, we set up a new (bigger) stack.
500          *
501          * Leave some safety gap for SP, force alignment on 16 byte boundary
502          * Clear initial stack frame
503          */
504         addr_sp -= 16;
505         addr_sp &= ~0xF;
506         s = (ulong *) addr_sp;
507         *s = 0; /* Terminate back chain */
508         *++s = 0; /* NULL return address */
509         debug("Stack Pointer at: %08lx\n", addr_sp);
510
511         /*
512          * Save local variables to board info struct
513          */
514
515         bd->bi_memstart = CONFIG_SYS_SDRAM_BASE;        /* start of memory */
516         bd->bi_memsize = gd->ram_size;                  /* size in bytes */
517
518 #ifdef CONFIG_SYS_SRAM_BASE
519         bd->bi_sramstart = CONFIG_SYS_SRAM_BASE;        /* start of SRAM */
520         bd->bi_sramsize = CONFIG_SYS_SRAM_SIZE;         /* size  of SRAM */
521 #endif
522
523 #if defined(CONFIG_8xx) || defined(CONFIG_MPC8260) || defined(CONFIG_5xx) || \
524     defined(CONFIG_E500) || defined(CONFIG_MPC86xx)
525         bd->bi_immr_base = CONFIG_SYS_IMMR;     /* base  of IMMR register     */
526 #endif
527 #if defined(CONFIG_MPC5xxx)
528         bd->bi_mbar_base = CONFIG_SYS_MBAR;     /* base of internal registers */
529 #endif
530 #if defined(CONFIG_MPC83xx)
531         bd->bi_immrbar = CONFIG_SYS_IMMR;
532 #endif
533
534         WATCHDOG_RESET();
535         bd->bi_intfreq = gd->cpu_clk;   /* Internal Freq, in Hz */
536         bd->bi_busfreq = gd->bus_clk;   /* Bus Freq,      in Hz */
537 #if defined(CONFIG_CPM2)
538         bd->bi_cpmfreq = gd->arch.cpm_clk;
539         bd->bi_brgfreq = gd->arch.brg_clk;
540         bd->bi_sccfreq = gd->arch.scc_clk;
541         bd->bi_vco = gd->arch.vco_out;
542 #endif /* CONFIG_CPM2 */
543 #if defined(CONFIG_MPC512X)
544         bd->bi_ipsfreq = gd->arch.ips_clk;
545 #endif /* CONFIG_MPC512X */
546 #if defined(CONFIG_MPC5xxx)
547         bd->bi_ipbfreq = gd->arch.ipb_clk;
548         bd->bi_pcifreq = gd->pci_clk;
549 #endif /* CONFIG_MPC5xxx */
550
551 #ifdef CONFIG_SYS_EXTBDINFO
552         strncpy((char *) bd->bi_s_version, "1.2", sizeof(bd->bi_s_version));
553         strncpy((char *) bd->bi_r_version, U_BOOT_VERSION,
554                 sizeof(bd->bi_r_version));
555
556         bd->bi_procfreq = gd->cpu_clk;  /* Processor Speed, In Hz */
557         bd->bi_plb_busfreq = gd->bus_clk;
558 #if defined(CONFIG_405GP) || defined(CONFIG_405EP) || \
559     defined(CONFIG_440EP) || defined(CONFIG_440GR) || \
560     defined(CONFIG_440EPX) || defined(CONFIG_440GRX)
561         bd->bi_pci_busfreq = get_PCI_freq();
562         bd->bi_opbfreq = get_OPB_freq();
563 #elif defined(CONFIG_XILINX_405)
564         bd->bi_pci_busfreq = get_PCI_freq();
565 #endif
566 #endif
567
568         debug("New Stack Pointer is: %08lx\n", addr_sp);
569
570         WATCHDOG_RESET();
571
572         gd->relocaddr = addr;   /* Store relocation addr, useful for debug */
573
574         memcpy(id, (void *) gd, sizeof(gd_t));
575
576         relocate_code(addr_sp, id, addr);
577
578         /* NOTREACHED - relocate_code() does not return */
579 }
580
581 /*
582  * This is the next part if the initialization sequence: we are now
583  * running from RAM and have a "normal" C environment, i. e. global
584  * data can be written, BSS has been cleared, the stack size in not
585  * that critical any more, etc.
586  */
587 void board_init_r(gd_t *id, ulong dest_addr)
588 {
589         bd_t *bd;
590         ulong malloc_start;
591
592 #ifndef CONFIG_SYS_NO_FLASH
593         ulong flash_size;
594 #endif
595
596         gd = id;                /* initialize RAM version of global data */
597         bd = gd->bd;
598
599         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
600
601         /* The Malloc area is immediately below the monitor copy in DRAM */
602         malloc_start = dest_addr - TOTAL_MALLOC_LEN;
603
604 #if defined(CONFIG_MPC85xx) || defined(CONFIG_MPC86xx)
605         /*
606          * The gd->arch.cpu pointer is set to an address in flash before
607          * relocation.  We need to update it to point to the same CPU entry
608          * in RAM.
609          */
610         gd->arch.cpu += dest_addr - CONFIG_SYS_MONITOR_BASE;
611
612         /*
613          * If we didn't know the cpu mask & # cores, we can save them of
614          * now rather than 'computing' them constantly
615          */
616         fixup_cpu();
617 #endif
618
619 #ifdef CONFIG_SYS_EXTRA_ENV_RELOC
620         /*
621          * Some systems need to relocate the env_addr pointer early because the
622          * location it points to will get invalidated before env_relocate is
623          * called.  One example is on systems that might use a L2 or L3 cache
624          * in SRAM mode and initialize that cache from SRAM mode back to being
625          * a cache in cpu_init_r.
626          */
627         gd->env_addr += dest_addr - CONFIG_SYS_MONITOR_BASE;
628 #endif
629
630         serial_initialize();
631
632         debug("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
633
634         WATCHDOG_RESET();
635
636         /*
637          * Setup trap handlers
638          */
639         trap_init(dest_addr);
640
641 #ifdef CONFIG_ADDR_MAP
642         init_addr_map();
643 #endif
644
645 #if defined(CONFIG_BOARD_EARLY_INIT_R)
646         board_early_init_r();
647 #endif
648
649         monitor_flash_len = (ulong)&__init_end - dest_addr;
650
651         WATCHDOG_RESET();
652
653 #ifdef CONFIG_LOGBUFFER
654         logbuff_init_ptrs();
655 #endif
656 #ifdef CONFIG_POST
657         post_output_backlog();
658 #endif
659
660         WATCHDOG_RESET();
661
662 #if defined(CONFIG_SYS_DELAYED_ICACHE)
663         icache_enable();        /* it's time to enable the instruction cache */
664 #endif
665
666 #if defined(CONFIG_SYS_INIT_RAM_LOCK) && defined(CONFIG_E500)
667         unlock_ram_in_cache();  /* it's time to unlock D-cache in e500 */
668 #endif
669
670 #if defined(CONFIG_PCI) && defined(CONFIG_SYS_EARLY_PCI_INIT)
671         /*
672          * Do early PCI configuration _before_ the flash gets initialised,
673          * because PCU ressources are crucial for flash access on some boards.
674          */
675         pci_init();
676 #endif
677 #if defined(CONFIG_WINBOND_83C553)
678         /*
679          * Initialise the ISA bridge
680          */
681         initialise_w83c553f();
682 #endif
683
684         asm("sync ; isync");
685
686         mem_malloc_init(malloc_start, TOTAL_MALLOC_LEN);
687
688 #if !defined(CONFIG_SYS_NO_FLASH)
689         puts("Flash: ");
690
691         if (board_flash_wp_on()) {
692                 printf("Uninitialized - Write Protect On\n");
693                 /* Since WP is on, we can't find real size.  Set to 0 */
694                 flash_size = 0;
695         } else if ((flash_size = flash_init()) > 0) {
696 #ifdef CONFIG_SYS_FLASH_CHECKSUM
697                 print_size(flash_size, "");
698                 /*
699                  * Compute and print flash CRC if flashchecksum is set to 'y'
700                  *
701                  * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX
702                  */
703                 if (getenv_yesno("flashchecksum") == 1) {
704                         printf("  CRC: %08X",
705                                crc32(0,
706                                      (const unsigned char *)
707                                      CONFIG_SYS_FLASH_BASE, flash_size)
708                                 );
709                 }
710                 putc('\n');
711 #else  /* !CONFIG_SYS_FLASH_CHECKSUM */
712                 print_size(flash_size, "\n");
713 #endif /* CONFIG_SYS_FLASH_CHECKSUM */
714         } else {
715                 puts(failed);
716                 hang();
717         }
718
719         /* update start of FLASH memory    */
720         bd->bi_flashstart = CONFIG_SYS_FLASH_BASE;
721         /* size of FLASH memory (final value) */
722         bd->bi_flashsize = flash_size;
723
724 #if defined(CONFIG_SYS_UPDATE_FLASH_SIZE)
725         /* Make a update of the Memctrl. */
726         update_flash_size(flash_size);
727 #endif
728
729
730 #if defined(CONFIG_OXC) || defined(CONFIG_RMU)
731         /* flash mapped at end of memory map */
732         bd->bi_flashoffset = CONFIG_SYS_TEXT_BASE + flash_size;
733 #elif CONFIG_SYS_MONITOR_BASE == CONFIG_SYS_FLASH_BASE
734         bd->bi_flashoffset = monitor_flash_len; /* reserved area for monitor */
735 #endif
736 #endif /* !CONFIG_SYS_NO_FLASH */
737
738         WATCHDOG_RESET();
739
740         /* initialize higher level parts of CPU like time base and timers */
741         cpu_init_r();
742
743         WATCHDOG_RESET();
744
745 #ifdef CONFIG_SPI
746 #if !defined(CONFIG_ENV_IS_IN_EEPROM)
747         spi_init_f();
748 #endif
749         spi_init_r();
750 #endif
751
752 #if defined(CONFIG_CMD_NAND)
753         WATCHDOG_RESET();
754         puts("NAND:  ");
755         nand_init();            /* go init the NAND */
756 #endif
757
758 #ifdef CONFIG_GENERIC_MMC
759 /*
760  * MMC initialization is called before relocating env.
761  * Thus It is required that operations like pin multiplexer
762  * be put in board_init.
763  */
764         WATCHDOG_RESET();
765         puts("MMC:  ");
766         mmc_initialize(bd);
767 #endif
768
769         /* relocate environment function pointers etc. */
770         env_relocate();
771
772         /*
773          * after non-volatile devices & environment is setup and cpu code have
774          * another round to deal with any initialization that might require
775          * full access to the environment or loading of some image (firmware)
776          * from a non-volatile device
777          */
778         cpu_secondary_init_r();
779
780         /*
781          * Fill in missing fields of bd_info.
782          * We do this here, where we have "normal" access to the
783          * environment; we used to do this still running from ROM,
784          * where had to use getenv_f(), which can be pretty slow when
785          * the environment is in EEPROM.
786          */
787
788 #if defined(CONFIG_SYS_EXTBDINFO)
789 #if defined(CONFIG_405GP) || defined(CONFIG_405EP)
790 #if defined(CONFIG_I2CFAST)
791         /*
792          * set bi_iic_fast for linux taking environment variable
793          * "i2cfast" into account
794          */
795         {
796                 if (getenv_yesno("i2cfast") == 1) {
797                         bd->bi_iic_fast[0] = 1;
798                         bd->bi_iic_fast[1] = 1;
799                 }
800         }
801 #endif /* CONFIG_I2CFAST */
802 #endif /* CONFIG_405GP, CONFIG_405EP */
803 #endif /* CONFIG_SYS_EXTBDINFO */
804
805 #if defined(CONFIG_SC3)
806         sc3_read_eeprom();
807 #endif
808
809 #if defined(CONFIG_ID_EEPROM) || defined(CONFIG_SYS_I2C_MAC_OFFSET)
810         mac_read_from_eeprom();
811 #endif
812
813 #ifdef  CONFIG_HERMES
814         if ((gd->board_type >> 16) == 2)
815                 bd->bi_ethspeed = gd->board_type & 0xFFFF;
816         else
817                 bd->bi_ethspeed = 0xFFFF;
818 #endif
819
820 #ifdef CONFIG_CMD_NET
821         /* kept around for legacy kernels only ... ignore the next section */
822         eth_getenv_enetaddr("ethaddr", bd->bi_enetaddr);
823 #ifdef CONFIG_HAS_ETH1
824         eth_getenv_enetaddr("eth1addr", bd->bi_enet1addr);
825 #endif
826 #ifdef CONFIG_HAS_ETH2
827         eth_getenv_enetaddr("eth2addr", bd->bi_enet2addr);
828 #endif
829 #ifdef CONFIG_HAS_ETH3
830         eth_getenv_enetaddr("eth3addr", bd->bi_enet3addr);
831 #endif
832 #ifdef CONFIG_HAS_ETH4
833         eth_getenv_enetaddr("eth4addr", bd->bi_enet4addr);
834 #endif
835 #ifdef CONFIG_HAS_ETH5
836         eth_getenv_enetaddr("eth5addr", bd->bi_enet5addr);
837 #endif
838 #endif /* CONFIG_CMD_NET */
839
840         WATCHDOG_RESET();
841
842 #if defined(CONFIG_PCI) && !defined(CONFIG_SYS_EARLY_PCI_INIT)
843         /*
844          * Do pci configuration
845          */
846         pci_init();
847 #endif
848
849 /** leave this here (after malloc(), environment and PCI are working) **/
850         /* Initialize stdio devices */
851         stdio_init();
852
853         /* Initialize the jump table for applications */
854         jumptable_init();
855
856 #if defined(CONFIG_API)
857         /* Initialize API */
858         api_init();
859 #endif
860
861         /* Initialize the console (after the relocation and devices init) */
862         console_init_r();
863
864 #if defined(CONFIG_MISC_INIT_R)
865         /* miscellaneous platform dependent initialisations */
866         misc_init_r();
867 #endif
868
869 #ifdef  CONFIG_HERMES
870         if (bd->bi_ethspeed != 0xFFFF)
871                 hermes_start_lxt980((int) bd->bi_ethspeed);
872 #endif
873
874 #if defined(CONFIG_CMD_KGDB)
875         WATCHDOG_RESET();
876         puts("KGDB:  ");
877         kgdb_init();
878 #endif
879
880         debug("U-Boot relocated to %08lx\n", dest_addr);
881
882         /*
883          * Enable Interrupts
884          */
885         interrupt_init();
886
887 #if defined(CONFIG_STATUS_LED) && defined(STATUS_LED_BOOT)
888         status_led_set(STATUS_LED_BOOT, STATUS_LED_BLINKING);
889 #endif
890
891         udelay(20);
892
893         /* Initialize from environment */
894         load_addr = getenv_ulong("loadaddr", 16, load_addr);
895
896         WATCHDOG_RESET();
897
898 #if defined(CONFIG_CMD_SCSI)
899         WATCHDOG_RESET();
900         puts("SCSI:  ");
901         scsi_init();
902 #endif
903
904 #if defined(CONFIG_CMD_DOC)
905         WATCHDOG_RESET();
906         puts("DOC:   ");
907         doc_init();
908 #endif
909
910 #ifdef CONFIG_BITBANGMII
911         bb_miiphy_init();
912 #endif
913 #if defined(CONFIG_CMD_NET)
914         WATCHDOG_RESET();
915         puts("Net:   ");
916         eth_initialize(bd);
917 #endif
918
919 #if defined(CONFIG_CMD_NET) && defined(CONFIG_RESET_PHY_R)
920         WATCHDOG_RESET();
921         debug("Reset Ethernet PHY\n");
922         reset_phy();
923 #endif
924
925 #ifdef CONFIG_POST
926         post_run(NULL, POST_RAM | post_bootmode_get(0));
927 #endif
928
929 #if defined(CONFIG_CMD_PCMCIA) \
930     && !defined(CONFIG_CMD_IDE)
931         WATCHDOG_RESET();
932         puts("PCMCIA:");
933         pcmcia_init();
934 #endif
935
936 #if defined(CONFIG_CMD_IDE)
937         WATCHDOG_RESET();
938 #ifdef  CONFIG_IDE_8xx_PCCARD
939         puts("PCMCIA:");
940 #else
941         puts("IDE:   ");
942 #endif
943 #if defined(CONFIG_START_IDE)
944         if (board_start_ide())
945                 ide_init();
946 #else
947         ide_init();
948 #endif
949 #endif
950
951 #ifdef CONFIG_LAST_STAGE_INIT
952         WATCHDOG_RESET();
953         /*
954          * Some parts can be only initialized if all others (like
955          * Interrupts) are up and running (i.e. the PC-style ISA
956          * keyboard).
957          */
958         last_stage_init();
959 #endif
960
961 #if defined(CONFIG_CMD_BEDBUG)
962         WATCHDOG_RESET();
963         bedbug_init();
964 #endif
965
966 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
967         /*
968          * Export available size of memory for Linux,
969          * taking into account the protected RAM at top of memory
970          */
971         {
972                 ulong pram = 0;
973                 char memsz[32];
974
975 #ifdef CONFIG_PRAM
976                 pram = getenv_ulong("pram", 10, CONFIG_PRAM);
977 #endif
978 #ifdef CONFIG_LOGBUFFER
979 #ifndef CONFIG_ALT_LB_ADDR
980                 /* Also take the logbuffer into account (pram is in kB) */
981                 pram += (LOGBUFF_LEN + LOGBUFF_OVERHEAD) / 1024;
982 #endif
983 #endif
984                 sprintf(memsz, "%ldk", (ulong) (bd->bi_memsize / 1024) - pram);
985                 setenv("mem", memsz);
986         }
987 #endif
988
989 #ifdef CONFIG_PS2KBD
990         puts("PS/2:  ");
991         kbd_init();
992 #endif
993
994         /* Initialization complete - start the monitor */
995
996         /* main_loop() can return to retry autoboot, if so just run it again. */
997         for (;;) {
998                 WATCHDOG_RESET();
999                 main_loop();
1000         }
1001
1002         /* NOTREACHED - no way out of command loop except booting */
1003 }
1004
1005 #if 0   /* We could use plain global data, but the resulting code is bigger */
1006 /*
1007  * Pointer to initial global data area
1008  *
1009  * Here we initialize it.
1010  */
1011 #undef  XTRN_DECLARE_GLOBAL_DATA_PTR
1012 #define XTRN_DECLARE_GLOBAL_DATA_PTR    /* empty = allocate here */
1013 DECLARE_GLOBAL_DATA_PTR =
1014         (gd_t *) (CONFIG_SYS_INIT_RAM_ADDR + CONFIG_SYS_GBL_DATA_OFFSET);
1015 #endif /* 0 */
1016
1017 /************************************************************************/