8e7a3ac74cd297c8f9ad2539650f1a94ab1f34da
[platform/kernel/u-boot.git] / common / board_r.c
1 /*
2  * Copyright (c) 2011 The Chromium OS Authors.
3  * (C) Copyright 2002-2006
4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5  *
6  * (C) Copyright 2002
7  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
8  * Marius Groeger <mgroeger@sysgo.de>
9  *
10  * SPDX-License-Identifier:     GPL-2.0+
11  */
12
13 #include <common.h>
14 /* TODO: can we just include all these headers whether needed or not? */
15 #if defined(CONFIG_CMD_BEDBUG)
16 #include <bedbug/type.h>
17 #endif
18 #ifdef CONFIG_HAS_DATAFLASH
19 #include <dataflash.h>
20 #endif
21 #include <dm.h>
22 #include <environment.h>
23 #include <fdtdec.h>
24 #if defined(CONFIG_CMD_IDE)
25 #include <ide.h>
26 #endif
27 #include <initcall.h>
28 #ifdef CONFIG_PS2KBD
29 #include <keyboard.h>
30 #endif
31 #if defined(CONFIG_CMD_KGDB)
32 #include <kgdb.h>
33 #endif
34 #include <logbuff.h>
35 #include <malloc.h>
36 #ifdef CONFIG_BITBANGMII
37 #include <miiphy.h>
38 #endif
39 #include <mmc.h>
40 #include <nand.h>
41 #include <onenand_uboot.h>
42 #include <scsi.h>
43 #include <serial.h>
44 #include <spi.h>
45 #include <stdio_dev.h>
46 #include <trace.h>
47 #include <watchdog.h>
48 #ifdef CONFIG_ADDR_MAP
49 #include <asm/mmu.h>
50 #endif
51 #include <asm/sections.h>
52 #ifdef CONFIG_X86
53 #include <asm/init_helpers.h>
54 #endif
55 #include <dm/root.h>
56 #include <linux/compiler.h>
57 #include <linux/err.h>
58
59 DECLARE_GLOBAL_DATA_PTR;
60
61 ulong monitor_flash_len;
62
63 int __board_flash_wp_on(void)
64 {
65         /*
66          * Most flashes can't be detected when write protection is enabled,
67          * so provide a way to let U-Boot gracefully ignore write protected
68          * devices.
69          */
70         return 0;
71 }
72
73 int board_flash_wp_on(void)
74         __attribute__ ((weak, alias("__board_flash_wp_on")));
75
76 void __cpu_secondary_init_r(void)
77 {
78 }
79
80 void cpu_secondary_init_r(void)
81         __attribute__ ((weak, alias("__cpu_secondary_init_r")));
82
83 static int initr_secondary_cpu(void)
84 {
85         /*
86          * after non-volatile devices & environment is setup and cpu code have
87          * another round to deal with any initialization that might require
88          * full access to the environment or loading of some image (firmware)
89          * from a non-volatile device
90          */
91         /* TODO: maybe define this for all archs? */
92         cpu_secondary_init_r();
93
94         return 0;
95 }
96
97 static int initr_trace(void)
98 {
99 #ifdef CONFIG_TRACE
100         trace_init(gd->trace_buff, CONFIG_TRACE_BUFFER_SIZE);
101 #endif
102
103         return 0;
104 }
105
106 static int initr_reloc(void)
107 {
108         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
109         bootstage_mark_name(BOOTSTAGE_ID_START_UBOOT_R, "board_init_r");
110
111         return 0;
112 }
113
114 #ifdef CONFIG_ARM
115 /*
116  * Some of these functions are needed purely because the functions they
117  * call return void. If we change them to return 0, these stubs can go away.
118  */
119 static int initr_caches(void)
120 {
121         /* Enable caches */
122         enable_caches();
123         return 0;
124 }
125 #endif
126
127 __weak int fixup_cpu(void)
128 {
129         return 0;
130 }
131
132 static int initr_reloc_global_data(void)
133 {
134 #ifdef __ARM__
135         monitor_flash_len = _end - __image_copy_start;
136 #elif !defined(CONFIG_SANDBOX)
137         monitor_flash_len = (ulong)&__init_end - gd->relocaddr;
138 #endif
139 #if defined(CONFIG_MPC85xx) || defined(CONFIG_MPC86xx)
140         /*
141          * The gd->cpu pointer is set to an address in flash before relocation.
142          * We need to update it to point to the same CPU entry in RAM.
143          * TODO: why not just add gd->reloc_ofs?
144          */
145         gd->arch.cpu += gd->relocaddr - CONFIG_SYS_MONITOR_BASE;
146
147         /*
148          * If we didn't know the cpu mask & # cores, we can save them of
149          * now rather than 'computing' them constantly
150          */
151         fixup_cpu();
152 #endif
153 #ifdef CONFIG_SYS_EXTRA_ENV_RELOC
154         /*
155          * Some systems need to relocate the env_addr pointer early because the
156          * location it points to will get invalidated before env_relocate is
157          * called.  One example is on systems that might use a L2 or L3 cache
158          * in SRAM mode and initialize that cache from SRAM mode back to being
159          * a cache in cpu_init_r.
160          */
161         gd->env_addr += gd->relocaddr - CONFIG_SYS_MONITOR_BASE;
162 #endif
163         return 0;
164 }
165
166 static int initr_serial(void)
167 {
168         serial_initialize();
169         return 0;
170 }
171
172 #ifdef CONFIG_PPC
173 static int initr_trap(void)
174 {
175         /*
176          * Setup trap handlers
177          */
178         trap_init(gd->relocaddr);
179
180         return 0;
181 }
182 #endif
183
184 #ifdef CONFIG_ADDR_MAP
185 static int initr_addr_map(void)
186 {
187         init_addr_map();
188
189         return 0;
190 }
191 #endif
192
193 #ifdef CONFIG_LOGBUFFER
194 unsigned long logbuffer_base(void)
195 {
196         return gd->ram_top - LOGBUFF_LEN;
197 }
198
199 static int initr_logbuffer(void)
200 {
201         logbuff_init_ptrs();
202         return 0;
203 }
204 #endif
205
206 #ifdef CONFIG_POST
207 static int initr_post_backlog(void)
208 {
209         post_output_backlog();
210         return 0;
211 }
212 #endif
213
214 #ifdef CONFIG_SYS_DELAYED_ICACHE
215 static int initr_icache_enable(void)
216 {
217         return 0;
218 }
219 #endif
220
221 #if defined(CONFIG_SYS_INIT_RAM_LOCK) && defined(CONFIG_E500)
222 static int initr_unlock_ram_in_cache(void)
223 {
224         unlock_ram_in_cache();  /* it's time to unlock D-cache in e500 */
225         return 0;
226 }
227 #endif
228
229 #ifdef CONFIG_PCI
230 static int initr_pci(void)
231 {
232         pci_init();
233
234         return 0;
235 }
236 #endif
237
238 #ifdef CONFIG_WINBOND_83C553
239 static int initr_w83c553f(void)
240 {
241         /*
242          * Initialise the ISA bridge
243          */
244         initialise_w83c553f();
245         return 0;
246 }
247 #endif
248
249 static int initr_barrier(void)
250 {
251 #ifdef CONFIG_PPC
252         /* TODO: Can we not use dmb() macros for this? */
253         asm("sync ; isync");
254 #endif
255         return 0;
256 }
257
258 static int initr_malloc(void)
259 {
260         ulong malloc_start;
261
262 #ifdef CONFIG_SYS_MALLOC_F_LEN
263         debug("Pre-reloc malloc() used %#lx bytes (%ld KB)\n", gd->malloc_ptr,
264               gd->malloc_ptr / 1024);
265 #endif
266         /* The malloc area is immediately below the monitor copy in DRAM */
267         malloc_start = gd->relocaddr - TOTAL_MALLOC_LEN;
268         mem_malloc_init((ulong)map_sysmem(malloc_start, TOTAL_MALLOC_LEN),
269                         TOTAL_MALLOC_LEN);
270         return 0;
271 }
272
273 #ifdef CONFIG_DM
274 static int initr_dm(void)
275 {
276         /* Save the pre-reloc driver model and start a new one */
277         gd->dm_root_f = gd->dm_root;
278         gd->dm_root = NULL;
279         return dm_init_and_scan(false);
280 }
281 #endif
282
283 __weak int power_init_board(void)
284 {
285         return 0;
286 }
287
288 static int initr_announce(void)
289 {
290         debug("Now running in RAM - U-Boot at: %08lx\n", gd->relocaddr);
291         return 0;
292 }
293
294 #if !defined(CONFIG_SYS_NO_FLASH)
295 static int initr_flash(void)
296 {
297         ulong flash_size = 0;
298         bd_t *bd = gd->bd;
299         int ok;
300
301         puts("Flash: ");
302
303         if (board_flash_wp_on()) {
304                 printf("Uninitialized - Write Protect On\n");
305                 /* Since WP is on, we can't find real size.  Set to 0 */
306                 ok = 1;
307         } else {
308                 flash_size = flash_init();
309                 ok = flash_size > 0;
310         }
311         if (!ok) {
312                 puts("*** failed ***\n");
313 #ifdef CONFIG_PPC
314                 /* Why does PPC do this? */
315                 hang();
316 #endif
317                 return -1;
318         }
319         print_size(flash_size, "");
320 #ifdef CONFIG_SYS_FLASH_CHECKSUM
321         /*
322         * Compute and print flash CRC if flashchecksum is set to 'y'
323         *
324         * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX
325         */
326         if (getenv_yesno("flashchecksum") == 1) {
327                 printf("  CRC: %08X", crc32(0,
328                         (const unsigned char *) CONFIG_SYS_FLASH_BASE,
329                         flash_size));
330         }
331 #endif /* CONFIG_SYS_FLASH_CHECKSUM */
332         putc('\n');
333
334         /* update start of FLASH memory    */
335 #ifdef CONFIG_SYS_FLASH_BASE
336         bd->bi_flashstart = CONFIG_SYS_FLASH_BASE;
337 #endif
338         /* size of FLASH memory (final value) */
339         bd->bi_flashsize = flash_size;
340
341 #if defined(CONFIG_SYS_UPDATE_FLASH_SIZE)
342         /* Make a update of the Memctrl. */
343         update_flash_size(flash_size);
344 #endif
345
346
347 #if defined(CONFIG_OXC) || defined(CONFIG_RMU)
348         /* flash mapped at end of memory map */
349         bd->bi_flashoffset = CONFIG_SYS_TEXT_BASE + flash_size;
350 #elif CONFIG_SYS_MONITOR_BASE == CONFIG_SYS_FLASH_BASE
351         bd->bi_flashoffset = monitor_flash_len; /* reserved area for monitor */
352 #endif
353         return 0;
354 }
355 #endif
356
357 #ifdef CONFIG_PPC
358 static int initr_spi(void)
359 {
360         /* PPC does this here */
361 #ifdef CONFIG_SPI
362 #if !defined(CONFIG_ENV_IS_IN_EEPROM)
363         spi_init_f();
364 #endif
365         spi_init_r();
366 #endif
367         return 0;
368 }
369 #endif
370
371 #ifdef CONFIG_CMD_NAND
372 /* go init the NAND */
373 int initr_nand(void)
374 {
375         puts("NAND:  ");
376         nand_init();
377         return 0;
378 }
379 #endif
380
381 #if defined(CONFIG_CMD_ONENAND)
382 /* go init the NAND */
383 int initr_onenand(void)
384 {
385         puts("NAND:  ");
386         onenand_init();
387         return 0;
388 }
389 #endif
390
391 #ifdef CONFIG_GENERIC_MMC
392 int initr_mmc(void)
393 {
394         puts("MMC:   ");
395         mmc_initialize(gd->bd);
396         return 0;
397 }
398 #endif
399
400 #ifdef CONFIG_HAS_DATAFLASH
401 int initr_dataflash(void)
402 {
403         AT91F_DataflashInit();
404         dataflash_print_info();
405         return 0;
406 }
407 #endif
408
409 /*
410  * Tell if it's OK to load the environment early in boot.
411  *
412  * If CONFIG_OF_CONFIG is defined, we'll check with the FDT to see
413  * if this is OK (defaulting to saying it's OK).
414  *
415  * NOTE: Loading the environment early can be a bad idea if security is
416  *       important, since no verification is done on the environment.
417  *
418  * @return 0 if environment should not be loaded, !=0 if it is ok to load
419  */
420 static int should_load_env(void)
421 {
422 #ifdef CONFIG_OF_CONTROL
423         return fdtdec_get_config_int(gd->fdt_blob, "load-environment", 1);
424 #elif defined CONFIG_DELAY_ENVIRONMENT
425         return 0;
426 #else
427         return 1;
428 #endif
429 }
430
431 static int initr_env(void)
432 {
433         /* initialize environment */
434         if (should_load_env())
435                 env_relocate();
436         else
437                 set_default_env(NULL);
438
439         /* Initialize from environment */
440         load_addr = getenv_ulong("loadaddr", 16, load_addr);
441 #if defined(CONFIG_SYS_EXTBDINFO)
442 #if defined(CONFIG_405GP) || defined(CONFIG_405EP)
443 #if defined(CONFIG_I2CFAST)
444         /*
445          * set bi_iic_fast for linux taking environment variable
446          * "i2cfast" into account
447          */
448         {
449                 char *s = getenv("i2cfast");
450
451                 if (s && ((*s == 'y') || (*s == 'Y'))) {
452                         gd->bd->bi_iic_fast[0] = 1;
453                         gd->bd->bi_iic_fast[1] = 1;
454                 }
455         }
456 #endif /* CONFIG_I2CFAST */
457 #endif /* CONFIG_405GP, CONFIG_405EP */
458 #endif /* CONFIG_SYS_EXTBDINFO */
459         return 0;
460 }
461
462 #ifdef  CONFIG_HERMES
463 static int initr_hermes(void)
464 {
465         if ((gd->board_type >> 16) == 2)
466                 gd->bd->bi_ethspeed = gd->board_type & 0xFFFF;
467         else
468                 gd->bd->bi_ethspeed = 0xFFFF;
469         return 0;
470 }
471
472 static int initr_hermes_start(void)
473 {
474         if (gd->bd->bi_ethspeed != 0xFFFF)
475                 hermes_start_lxt980((int) gd->bd->bi_ethspeed);
476         return 0;
477 }
478 #endif
479
480 #ifdef CONFIG_SC3
481 /* TODO: with new initcalls, move this into the driver */
482 extern void sc3_read_eeprom(void);
483
484 static int initr_sc3_read_eeprom(void)
485 {
486         sc3_read_eeprom();
487         return 0;
488 }
489 #endif
490
491 static int initr_jumptable(void)
492 {
493         jumptable_init();
494         return 0;
495 }
496
497 #if defined(CONFIG_API)
498 static int initr_api(void)
499 {
500         /* Initialize API */
501         api_init();
502         return 0;
503 }
504 #endif
505
506 #ifdef CONFIG_DISPLAY_BOARDINFO_LATE
507 static int show_model_r(void)
508 {
509         /* Put this here so it appears on the LCD, now it is ready */
510 # ifdef CONFIG_OF_CONTROL
511         const char *model;
512
513         model = (char *)fdt_getprop(gd->fdt_blob, 0, "model", NULL);
514         printf("Model: %s\n", model ? model : "<unknown>");
515 # else
516         checkboard();
517 # endif
518         return 0;
519 }
520 #endif
521
522 /* enable exceptions */
523 #ifdef CONFIG_ARM
524 static int initr_enable_interrupts(void)
525 {
526         enable_interrupts();
527         return 0;
528 }
529 #endif
530
531 #ifdef CONFIG_CMD_NET
532 static int initr_ethaddr(void)
533 {
534         bd_t *bd = gd->bd;
535
536         /* kept around for legacy kernels only ... ignore the next section */
537         eth_getenv_enetaddr("ethaddr", bd->bi_enetaddr);
538 #ifdef CONFIG_HAS_ETH1
539         eth_getenv_enetaddr("eth1addr", bd->bi_enet1addr);
540 #endif
541 #ifdef CONFIG_HAS_ETH2
542         eth_getenv_enetaddr("eth2addr", bd->bi_enet2addr);
543 #endif
544 #ifdef CONFIG_HAS_ETH3
545         eth_getenv_enetaddr("eth3addr", bd->bi_enet3addr);
546 #endif
547 #ifdef CONFIG_HAS_ETH4
548         eth_getenv_enetaddr("eth4addr", bd->bi_enet4addr);
549 #endif
550 #ifdef CONFIG_HAS_ETH5
551         eth_getenv_enetaddr("eth5addr", bd->bi_enet5addr);
552 #endif
553         return 0;
554 }
555 #endif /* CONFIG_CMD_NET */
556
557 #ifdef CONFIG_CMD_KGDB
558 static int initr_kgdb(void)
559 {
560         puts("KGDB:  ");
561         kgdb_init();
562         return 0;
563 }
564 #endif
565
566 #if defined(CONFIG_STATUS_LED) && defined(STATUS_LED_BOOT)
567 static int initr_status_led(void)
568 {
569         status_led_set(STATUS_LED_BOOT, STATUS_LED_BLINKING);
570
571         return 0;
572 }
573 #endif
574
575 #if defined(CONFIG_CMD_SCSI)
576 static int initr_scsi(void)
577 {
578         puts("SCSI:  ");
579         scsi_init();
580
581         return 0;
582 }
583 #endif
584
585 #if defined(CONFIG_CMD_DOC)
586 static int initr_doc(void)
587 {
588         puts("DOC:   ");
589         doc_init();
590 }
591 #endif
592
593 #ifdef CONFIG_BITBANGMII
594 static int initr_bbmii(void)
595 {
596         bb_miiphy_init();
597         return 0;
598 }
599 #endif
600
601 #ifdef CONFIG_CMD_NET
602 static int initr_net(void)
603 {
604         puts("Net:   ");
605         eth_initialize(gd->bd);
606 #if defined(CONFIG_RESET_PHY_R)
607         debug("Reset Ethernet PHY\n");
608         reset_phy();
609 #endif
610         return 0;
611 }
612 #endif
613
614 #ifdef CONFIG_POST
615 static int initr_post(void)
616 {
617         post_run(NULL, POST_RAM | post_bootmode_get(0));
618         return 0;
619 }
620 #endif
621
622 #if defined(CONFIG_CMD_PCMCIA) && !defined(CONFIG_CMD_IDE)
623 static int initr_pcmcia(void)
624 {
625         puts("PCMCIA:");
626         pcmcia_init();
627         return 0;
628 }
629 #endif
630
631 #if defined(CONFIG_CMD_IDE)
632 static int initr_ide(void)
633 {
634 #ifdef  CONFIG_IDE_8xx_PCCARD
635         puts("PCMCIA:");
636 #else
637         puts("IDE:   ");
638 #endif
639 #if defined(CONFIG_START_IDE)
640         if (board_start_ide())
641                 ide_init();
642 #else
643         ide_init();
644 #endif
645         return 0;
646 }
647 #endif
648
649 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
650 /*
651  * Export available size of memory for Linux, taking into account the
652  * protected RAM at top of memory
653  */
654 int initr_mem(void)
655 {
656         ulong pram = 0;
657         char memsz[32];
658
659 # ifdef CONFIG_PRAM
660         pram = getenv_ulong("pram", 10, CONFIG_PRAM);
661 # endif
662 # if defined(CONFIG_LOGBUFFER) && !defined(CONFIG_ALT_LB_ADDR)
663         /* Also take the logbuffer into account (pram is in kB) */
664         pram += (LOGBUFF_LEN + LOGBUFF_OVERHEAD) / 1024;
665 # endif
666         sprintf(memsz, "%ldk", (gd->ram_size / 1024) - pram);
667         setenv("mem", memsz);
668
669         return 0;
670 }
671 #endif
672
673 #ifdef CONFIG_CMD_BEDBUG
674 static int initr_bedbug(void)
675 {
676         bedbug_init();
677
678         return 0;
679 }
680 #endif
681
682 #ifdef CONFIG_PS2KBD
683 static int initr_kbd(void)
684 {
685         puts("PS/2:  ");
686         kbd_init();
687         return 0;
688 }
689 #endif
690
691 static int run_main_loop(void)
692 {
693 #ifdef CONFIG_SANDBOX
694         sandbox_main_loop_init();
695 #endif
696         /* main_loop() can return to retry autoboot, if so just run it again */
697         for (;;)
698                 main_loop();
699         return 0;
700 }
701
702 /*
703  * Over time we hope to remove these functions with code fragments and
704  * stub funtcions, and instead call the relevant function directly.
705  *
706  * We also hope to remove most of the driver-related init and do it if/when
707  * the driver is later used.
708  *
709  * TODO: perhaps reset the watchdog in the initcall function after each call?
710  */
711 init_fnc_t init_sequence_r[] = {
712         initr_trace,
713         initr_reloc,
714         /* TODO: could x86/PPC have this also perhaps? */
715 #ifdef CONFIG_ARM
716         initr_caches,
717         board_init,     /* Setup chipselects */
718 #endif
719         /*
720          * TODO: printing of the clock inforamtion of the board is now
721          * implemented as part of bdinfo command. Currently only support for
722          * davinci SOC's is added. Remove this check once all the board
723          * implement this.
724          */
725 #ifdef CONFIG_CLOCKS
726         set_cpu_clk_info, /* Setup clock information */
727 #endif
728         initr_reloc_global_data,
729         initr_serial,
730         initr_announce,
731         INIT_FUNC_WATCHDOG_RESET
732 #ifdef CONFIG_PPC
733         initr_trap,
734 #endif
735 #ifdef CONFIG_ADDR_MAP
736         initr_addr_map,
737 #endif
738 #if defined(CONFIG_BOARD_EARLY_INIT_R)
739         board_early_init_r,
740 #endif
741         INIT_FUNC_WATCHDOG_RESET
742 #ifdef CONFIG_LOGBUFFER
743         initr_logbuffer,
744 #endif
745 #ifdef CONFIG_POST
746         initr_post_backlog,
747 #endif
748         INIT_FUNC_WATCHDOG_RESET
749 #ifdef CONFIG_SYS_DELAYED_ICACHE
750         initr_icache_enable,
751 #endif
752 #if defined(CONFIG_SYS_INIT_RAM_LOCK) && defined(CONFIG_E500)
753         initr_unlock_ram_in_cache,
754 #endif
755 #if defined(CONFIG_PCI) && defined(CONFIG_SYS_EARLY_PCI_INIT)
756         /*
757          * Do early PCI configuration _before_ the flash gets initialised,
758          * because PCU ressources are crucial for flash access on some boards.
759          */
760         initr_pci,
761 #endif
762 #ifdef CONFIG_WINBOND_83C553
763         initr_w83c553f,
764 #endif
765         initr_barrier,
766         initr_malloc,
767         bootstage_relocate,
768 #ifdef CONFIG_DM
769         initr_dm,
770 #endif
771 #ifdef CONFIG_ARCH_EARLY_INIT_R
772         arch_early_init_r,
773 #endif
774         power_init_board,
775 #ifndef CONFIG_SYS_NO_FLASH
776         initr_flash,
777 #endif
778         INIT_FUNC_WATCHDOG_RESET
779 #if defined(CONFIG_PPC) || defined(CONFIG_X86)
780         /* initialize higher level parts of CPU like time base and timers */
781         cpu_init_r,
782 #endif
783 #ifdef CONFIG_PPC
784         initr_spi,
785 #endif
786 #if defined(CONFIG_X86) && defined(CONFIG_SPI)
787         init_func_spi,
788 #endif
789 #ifdef CONFIG_CMD_NAND
790         initr_nand,
791 #endif
792 #ifdef CONFIG_CMD_ONENAND
793         initr_onenand,
794 #endif
795 #ifdef CONFIG_GENERIC_MMC
796         initr_mmc,
797 #endif
798 #ifdef CONFIG_HAS_DATAFLASH
799         initr_dataflash,
800 #endif
801         initr_env,
802         INIT_FUNC_WATCHDOG_RESET
803         initr_secondary_cpu,
804 #ifdef CONFIG_SC3
805         initr_sc3_read_eeprom,
806 #endif
807 #ifdef  CONFIG_HERMES
808         initr_hermes,
809 #endif
810 #if defined(CONFIG_ID_EEPROM) || defined(CONFIG_SYS_I2C_MAC_OFFSET)
811         mac_read_from_eeprom,
812 #endif
813         INIT_FUNC_WATCHDOG_RESET
814 #if defined(CONFIG_PCI) && !defined(CONFIG_SYS_EARLY_PCI_INIT)
815         /*
816          * Do pci configuration
817          */
818         initr_pci,
819 #endif
820         stdio_init,
821         initr_jumptable,
822 #ifdef CONFIG_API
823         initr_api,
824 #endif
825         console_init_r,         /* fully init console as a device */
826 #ifdef CONFIG_DISPLAY_BOARDINFO_LATE
827         show_model_r,
828 #endif
829 #ifdef CONFIG_ARCH_MISC_INIT
830         arch_misc_init,         /* miscellaneous arch-dependent init */
831 #endif
832 #ifdef CONFIG_MISC_INIT_R
833         misc_init_r,            /* miscellaneous platform-dependent init */
834 #endif
835 #ifdef CONFIG_HERMES
836         initr_hermes_start,
837 #endif
838         INIT_FUNC_WATCHDOG_RESET
839 #ifdef CONFIG_CMD_KGDB
840         initr_kgdb,
841 #endif
842 #ifdef CONFIG_X86
843         board_early_init_r,
844 #endif
845         interrupt_init,
846 #if defined(CONFIG_ARM) || defined(CONFIG_x86)
847         initr_enable_interrupts,
848 #endif
849 #ifdef CONFIG_X86
850         timer_init,             /* initialize timer */
851 #endif
852 #if defined(CONFIG_STATUS_LED) && defined(STATUS_LED_BOOT)
853         initr_status_led,
854 #endif
855         /* PPC has a udelay(20) here dating from 2002. Why? */
856 #ifdef CONFIG_CMD_NET
857         initr_ethaddr,
858 #endif
859 #ifdef CONFIG_BOARD_LATE_INIT
860         board_late_init,
861 #endif
862 #ifdef CONFIG_CMD_SCSI
863         INIT_FUNC_WATCHDOG_RESET
864         initr_scsi,
865 #endif
866 #ifdef CONFIG_CMD_DOC
867         INIT_FUNC_WATCHDOG_RESET
868         initr_doc,
869 #endif
870 #ifdef CONFIG_BITBANGMII
871         initr_bbmii,
872 #endif
873 #ifdef CONFIG_CMD_NET
874         INIT_FUNC_WATCHDOG_RESET
875         initr_net,
876 #endif
877 #ifdef CONFIG_POST
878         initr_post,
879 #endif
880 #if defined(CONFIG_CMD_PCMCIA) && !defined(CONFIG_CMD_IDE)
881         initr_pcmcia,
882 #endif
883 #if defined(CONFIG_CMD_IDE)
884         initr_ide,
885 #endif
886 #ifdef CONFIG_LAST_STAGE_INIT
887         INIT_FUNC_WATCHDOG_RESET
888         /*
889          * Some parts can be only initialized if all others (like
890          * Interrupts) are up and running (i.e. the PC-style ISA
891          * keyboard).
892          */
893         last_stage_init,
894 #endif
895 #ifdef CONFIG_CMD_BEDBUG
896         INIT_FUNC_WATCHDOG_RESET
897         initr_bedbug,
898 #endif
899 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
900         initr_mem,
901 #endif
902 #ifdef CONFIG_PS2KBD
903         initr_kbd,
904 #endif
905         run_main_loop,
906 };
907
908 void board_init_r(gd_t *new_gd, ulong dest_addr)
909 {
910 #ifdef CONFIG_NEEDS_MANUAL_RELOC
911         int i;
912 #endif
913
914 #ifndef CONFIG_X86
915         gd = new_gd;
916 #endif
917
918 #ifdef CONFIG_NEEDS_MANUAL_RELOC
919         for (i = 0; i < ARRAY_SIZE(init_sequence_r); i++)
920                 init_sequence_r[i] += gd->reloc_off;
921 #endif
922
923         if (initcall_run_list(init_sequence_r))
924                 hang();
925
926         /* NOTREACHED - run_main_loop() does not return */
927         hang();
928 }