]> git.kernelconcepts.de Git - karo-tx-uboot.git/blob - common/board_r.c
Merge branch 'master' of git://git.denx.de/u-boot-ti
[karo-tx-uboot.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) && !defined(CONFIG_NIOS2)
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         return 0;
591 }
592 #endif
593
594 #ifdef CONFIG_BITBANGMII
595 static int initr_bbmii(void)
596 {
597         bb_miiphy_init();
598         return 0;
599 }
600 #endif
601
602 #ifdef CONFIG_CMD_NET
603 static int initr_net(void)
604 {
605         puts("Net:   ");
606         eth_initialize(gd->bd);
607 #if defined(CONFIG_RESET_PHY_R)
608         debug("Reset Ethernet PHY\n");
609         reset_phy();
610 #endif
611         return 0;
612 }
613 #endif
614
615 #ifdef CONFIG_POST
616 static int initr_post(void)
617 {
618         post_run(NULL, POST_RAM | post_bootmode_get(0));
619         return 0;
620 }
621 #endif
622
623 #if defined(CONFIG_CMD_PCMCIA) && !defined(CONFIG_CMD_IDE)
624 static int initr_pcmcia(void)
625 {
626         puts("PCMCIA:");
627         pcmcia_init();
628         return 0;
629 }
630 #endif
631
632 #if defined(CONFIG_CMD_IDE)
633 static int initr_ide(void)
634 {
635 #ifdef  CONFIG_IDE_8xx_PCCARD
636         puts("PCMCIA:");
637 #else
638         puts("IDE:   ");
639 #endif
640 #if defined(CONFIG_START_IDE)
641         if (board_start_ide())
642                 ide_init();
643 #else
644         ide_init();
645 #endif
646         return 0;
647 }
648 #endif
649
650 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
651 /*
652  * Export available size of memory for Linux, taking into account the
653  * protected RAM at top of memory
654  */
655 int initr_mem(void)
656 {
657         ulong pram = 0;
658         char memsz[32];
659
660 # ifdef CONFIG_PRAM
661         pram = getenv_ulong("pram", 10, CONFIG_PRAM);
662 # endif
663 # if defined(CONFIG_LOGBUFFER) && !defined(CONFIG_ALT_LB_ADDR)
664         /* Also take the logbuffer into account (pram is in kB) */
665         pram += (LOGBUFF_LEN + LOGBUFF_OVERHEAD) / 1024;
666 # endif
667         sprintf(memsz, "%ldk", (gd->ram_size / 1024) - pram);
668         setenv("mem", memsz);
669
670         return 0;
671 }
672 #endif
673
674 #ifdef CONFIG_CMD_BEDBUG
675 static int initr_bedbug(void)
676 {
677         bedbug_init();
678
679         return 0;
680 }
681 #endif
682
683 #ifdef CONFIG_PS2KBD
684 static int initr_kbd(void)
685 {
686         puts("PS/2:  ");
687         kbd_init();
688         return 0;
689 }
690 #endif
691
692 static int run_main_loop(void)
693 {
694 #ifdef CONFIG_SANDBOX
695         sandbox_main_loop_init();
696 #endif
697         /* main_loop() can return to retry autoboot, if so just run it again */
698         for (;;)
699                 main_loop();
700         return 0;
701 }
702
703 /*
704  * Over time we hope to remove these functions with code fragments and
705  * stub funtcions, and instead call the relevant function directly.
706  *
707  * We also hope to remove most of the driver-related init and do it if/when
708  * the driver is later used.
709  *
710  * TODO: perhaps reset the watchdog in the initcall function after each call?
711  */
712 init_fnc_t init_sequence_r[] = {
713         initr_trace,
714         initr_reloc,
715         /* TODO: could x86/PPC have this also perhaps? */
716 #ifdef CONFIG_ARM
717         initr_caches,
718         board_init,     /* Setup chipselects */
719 #endif
720         /*
721          * TODO: printing of the clock inforamtion of the board is now
722          * implemented as part of bdinfo command. Currently only support for
723          * davinci SOC's is added. Remove this check once all the board
724          * implement this.
725          */
726 #ifdef CONFIG_CLOCKS
727         set_cpu_clk_info, /* Setup clock information */
728 #endif
729         initr_reloc_global_data,
730         initr_serial,
731         initr_announce,
732         INIT_FUNC_WATCHDOG_RESET
733 #ifdef CONFIG_PPC
734         initr_trap,
735 #endif
736 #ifdef CONFIG_ADDR_MAP
737         initr_addr_map,
738 #endif
739 #if defined(CONFIG_BOARD_EARLY_INIT_R)
740         board_early_init_r,
741 #endif
742         INIT_FUNC_WATCHDOG_RESET
743 #ifdef CONFIG_LOGBUFFER
744         initr_logbuffer,
745 #endif
746 #ifdef CONFIG_POST
747         initr_post_backlog,
748 #endif
749         INIT_FUNC_WATCHDOG_RESET
750 #ifdef CONFIG_SYS_DELAYED_ICACHE
751         initr_icache_enable,
752 #endif
753 #if defined(CONFIG_SYS_INIT_RAM_LOCK) && defined(CONFIG_E500)
754         initr_unlock_ram_in_cache,
755 #endif
756 #if defined(CONFIG_PCI) && defined(CONFIG_SYS_EARLY_PCI_INIT)
757         /*
758          * Do early PCI configuration _before_ the flash gets initialised,
759          * because PCU ressources are crucial for flash access on some boards.
760          */
761         initr_pci,
762 #endif
763 #ifdef CONFIG_WINBOND_83C553
764         initr_w83c553f,
765 #endif
766         initr_barrier,
767         initr_malloc,
768         bootstage_relocate,
769 #ifdef CONFIG_DM
770         initr_dm,
771 #endif
772 #ifdef CONFIG_ARCH_EARLY_INIT_R
773         arch_early_init_r,
774 #endif
775         power_init_board,
776 #ifndef CONFIG_SYS_NO_FLASH
777         initr_flash,
778 #endif
779         INIT_FUNC_WATCHDOG_RESET
780 #if defined(CONFIG_PPC) || defined(CONFIG_X86)
781         /* initialize higher level parts of CPU like time base and timers */
782         cpu_init_r,
783 #endif
784 #ifdef CONFIG_PPC
785         initr_spi,
786 #endif
787 #if defined(CONFIG_X86) && defined(CONFIG_SPI)
788         init_func_spi,
789 #endif
790 #ifdef CONFIG_CMD_NAND
791         initr_nand,
792 #endif
793 #ifdef CONFIG_CMD_ONENAND
794         initr_onenand,
795 #endif
796 #ifdef CONFIG_GENERIC_MMC
797         initr_mmc,
798 #endif
799 #ifdef CONFIG_HAS_DATAFLASH
800         initr_dataflash,
801 #endif
802         initr_env,
803         INIT_FUNC_WATCHDOG_RESET
804         initr_secondary_cpu,
805 #ifdef CONFIG_SC3
806         initr_sc3_read_eeprom,
807 #endif
808 #ifdef  CONFIG_HERMES
809         initr_hermes,
810 #endif
811 #if defined(CONFIG_ID_EEPROM) || defined(CONFIG_SYS_I2C_MAC_OFFSET)
812         mac_read_from_eeprom,
813 #endif
814         INIT_FUNC_WATCHDOG_RESET
815 #if defined(CONFIG_PCI) && !defined(CONFIG_SYS_EARLY_PCI_INIT)
816         /*
817          * Do pci configuration
818          */
819         initr_pci,
820 #endif
821         stdio_init,
822         initr_jumptable,
823 #ifdef CONFIG_API
824         initr_api,
825 #endif
826         console_init_r,         /* fully init console as a device */
827 #ifdef CONFIG_DISPLAY_BOARDINFO_LATE
828         show_model_r,
829 #endif
830 #ifdef CONFIG_ARCH_MISC_INIT
831         arch_misc_init,         /* miscellaneous arch-dependent init */
832 #endif
833 #ifdef CONFIG_MISC_INIT_R
834         misc_init_r,            /* miscellaneous platform-dependent init */
835 #endif
836 #ifdef CONFIG_HERMES
837         initr_hermes_start,
838 #endif
839         INIT_FUNC_WATCHDOG_RESET
840 #ifdef CONFIG_CMD_KGDB
841         initr_kgdb,
842 #endif
843 #ifdef CONFIG_X86
844         board_early_init_r,
845 #endif
846         interrupt_init,
847 #if defined(CONFIG_ARM) || defined(CONFIG_x86)
848         initr_enable_interrupts,
849 #endif
850 #ifdef CONFIG_X86
851         timer_init,             /* initialize timer */
852 #endif
853 #if defined(CONFIG_STATUS_LED) && defined(STATUS_LED_BOOT)
854         initr_status_led,
855 #endif
856         /* PPC has a udelay(20) here dating from 2002. Why? */
857 #ifdef CONFIG_CMD_NET
858         initr_ethaddr,
859 #endif
860 #ifdef CONFIG_BOARD_LATE_INIT
861         board_late_init,
862 #endif
863 #ifdef CONFIG_CMD_SCSI
864         INIT_FUNC_WATCHDOG_RESET
865         initr_scsi,
866 #endif
867 #ifdef CONFIG_CMD_DOC
868         INIT_FUNC_WATCHDOG_RESET
869         initr_doc,
870 #endif
871 #ifdef CONFIG_BITBANGMII
872         initr_bbmii,
873 #endif
874 #ifdef CONFIG_CMD_NET
875         INIT_FUNC_WATCHDOG_RESET
876         initr_net,
877 #endif
878 #ifdef CONFIG_POST
879         initr_post,
880 #endif
881 #if defined(CONFIG_CMD_PCMCIA) && !defined(CONFIG_CMD_IDE)
882         initr_pcmcia,
883 #endif
884 #if defined(CONFIG_CMD_IDE)
885         initr_ide,
886 #endif
887 #ifdef CONFIG_LAST_STAGE_INIT
888         INIT_FUNC_WATCHDOG_RESET
889         /*
890          * Some parts can be only initialized if all others (like
891          * Interrupts) are up and running (i.e. the PC-style ISA
892          * keyboard).
893          */
894         last_stage_init,
895 #endif
896 #ifdef CONFIG_CMD_BEDBUG
897         INIT_FUNC_WATCHDOG_RESET
898         initr_bedbug,
899 #endif
900 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
901         initr_mem,
902 #endif
903 #ifdef CONFIG_PS2KBD
904         initr_kbd,
905 #endif
906         run_main_loop,
907 };
908
909 void board_init_r(gd_t *new_gd, ulong dest_addr)
910 {
911 #ifdef CONFIG_NEEDS_MANUAL_RELOC
912         int i;
913 #endif
914
915 #ifndef CONFIG_X86
916         gd = new_gd;
917 #endif
918
919 #ifdef CONFIG_NEEDS_MANUAL_RELOC
920         for (i = 0; i < ARRAY_SIZE(init_sequence_r); i++)
921                 init_sequence_r[i] += gd->reloc_off;
922 #endif
923
924         if (initcall_run_list(init_sequence_r))
925                 hang();
926
927         /* NOTREACHED - run_main_loop() does not return */
928         hang();
929 }