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