Merge branch 'next'
[platform/kernel/u-boot.git] / common / board_r.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2011 The Chromium OS Authors.
4  * (C) Copyright 2002-2006
5  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
6  *
7  * (C) Copyright 2002
8  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
9  * Marius Groeger <mgroeger@sysgo.de>
10  */
11
12 #include <common.h>
13 #include <api.h>
14 #include <cpu_func.h>
15 #include <irq_func.h>
16 #include <u-boot/crc.h>
17 /* TODO: can we just include all these headers whether needed or not? */
18 #if defined(CONFIG_CMD_BEDBUG)
19 #include <bedbug/type.h>
20 #endif
21 #include <binman.h>
22 #include <command.h>
23 #include <console.h>
24 #include <dm.h>
25 #include <env.h>
26 #include <env_internal.h>
27 #include <fdtdec.h>
28 #include <ide.h>
29 #include <initcall.h>
30 #if defined(CONFIG_CMD_KGDB)
31 #include <kgdb.h>
32 #endif
33 #include <irq_func.h>
34 #include <malloc.h>
35 #include <mapmem.h>
36 #ifdef CONFIG_BITBANGMII
37 #include <miiphy.h>
38 #endif
39 #include <mmc.h>
40 #include <nand.h>
41 #include <of_live.h>
42 #include <onenand_uboot.h>
43 #include <scsi.h>
44 #include <serial.h>
45 #include <status_led.h>
46 #include <stdio_dev.h>
47 #include <timer.h>
48 #include <trace.h>
49 #include <watchdog.h>
50 #ifdef CONFIG_ADDR_MAP
51 #include <asm/mmu.h>
52 #endif
53 #include <asm/sections.h>
54 #include <dm/root.h>
55 #include <linux/compiler.h>
56 #include <linux/err.h>
57 #include <efi_loader.h>
58 #include <wdt.h>
59 #if defined(CONFIG_GPIO_HOG)
60 #include <asm/gpio.h>
61 #endif
62
63 DECLARE_GLOBAL_DATA_PTR;
64
65 ulong monitor_flash_len;
66
67 __weak int board_flash_wp_on(void)
68 {
69         /*
70          * Most flashes can't be detected when write protection is enabled,
71          * so provide a way to let U-Boot gracefully ignore write protected
72          * devices.
73          */
74         return 0;
75 }
76
77 __weak void cpu_secondary_init_r(void)
78 {
79 }
80
81 static int initr_secondary_cpu(void)
82 {
83         /*
84          * after non-volatile devices & environment is setup and cpu code have
85          * another round to deal with any initialization that might require
86          * full access to the environment or loading of some image (firmware)
87          * from a non-volatile device
88          */
89         /* TODO: maybe define this for all archs? */
90         cpu_secondary_init_r();
91
92         return 0;
93 }
94
95 static int initr_trace(void)
96 {
97 #ifdef CONFIG_TRACE
98         trace_init(gd->trace_buff, CONFIG_TRACE_BUFFER_SIZE);
99 #endif
100
101         return 0;
102 }
103
104 static int initr_reloc(void)
105 {
106         /* tell others: relocation done */
107         gd->flags |= GD_FLG_RELOC | GD_FLG_FULL_MALLOC_INIT;
108
109         return 0;
110 }
111
112 #ifdef CONFIG_ARM
113 /*
114  * Some of these functions are needed purely because the functions they
115  * call return void. If we change them to return 0, these stubs can go away.
116  */
117 static int initr_caches(void)
118 {
119         /* Enable caches */
120         enable_caches();
121         return 0;
122 }
123 #endif
124
125 __weak int fixup_cpu(void)
126 {
127         return 0;
128 }
129
130 static int initr_reloc_global_data(void)
131 {
132 #ifdef __ARM__
133         monitor_flash_len = _end - __image_copy_start;
134 #elif defined(CONFIG_NDS32) || defined(CONFIG_RISCV)
135         monitor_flash_len = (ulong)&_end - (ulong)&_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_RELOC_GD_ENV_ADDR
154         /*
155          * Relocate the early env_addr pointer unless we know it is not inside
156          * the binary. Some systems need this and for the rest, it doesn't hurt.
157          */
158         gd->env_addr += gd->reloc_off;
159 #endif
160 #ifdef CONFIG_OF_EMBED
161         /*
162          * The fdt_blob needs to be moved to new relocation address
163          * incase of FDT blob is embedded with in image
164          */
165         gd->fdt_blob += gd->reloc_off;
166 #endif
167 #ifdef CONFIG_EFI_LOADER
168         /*
169          * On the ARM architecture gd is mapped to a fixed register (r9 or x18).
170          * As this register may be overwritten by an EFI payload we save it here
171          * and restore it on every callback entered.
172          */
173         efi_save_gd();
174
175         efi_runtime_relocate(gd->relocaddr, NULL);
176 #endif
177
178         return 0;
179 }
180
181 static int initr_serial(void)
182 {
183         serial_initialize();
184         return 0;
185 }
186
187 #if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_MIPS)
188 static int initr_trap(void)
189 {
190         /*
191          * Setup trap handlers
192          */
193 #if defined(CONFIG_PPC)
194         trap_init(gd->relocaddr);
195 #else
196         trap_init(CONFIG_SYS_SDRAM_BASE);
197 #endif
198         return 0;
199 }
200 #endif
201
202 #ifdef CONFIG_ADDR_MAP
203 static int initr_addr_map(void)
204 {
205         init_addr_map();
206
207         return 0;
208 }
209 #endif
210
211 #ifdef CONFIG_POST
212 static int initr_post_backlog(void)
213 {
214         post_output_backlog();
215         return 0;
216 }
217 #endif
218
219 #if defined(CONFIG_SYS_INIT_RAM_LOCK) && defined(CONFIG_E500)
220 static int initr_unlock_ram_in_cache(void)
221 {
222         unlock_ram_in_cache();  /* it's time to unlock D-cache in e500 */
223         return 0;
224 }
225 #endif
226
227 #ifdef CONFIG_PCI
228 static int initr_pci(void)
229 {
230 #ifndef CONFIG_DM_PCI
231         pci_init();
232 #endif
233
234         return 0;
235 }
236 #endif
237
238 static int initr_barrier(void)
239 {
240 #ifdef CONFIG_PPC
241         /* TODO: Can we not use dmb() macros for this? */
242         asm("sync ; isync");
243 #endif
244         return 0;
245 }
246
247 static int initr_malloc(void)
248 {
249         ulong malloc_start;
250
251 #if CONFIG_VAL(SYS_MALLOC_F_LEN)
252         debug("Pre-reloc malloc() used %#lx bytes (%ld KB)\n", gd->malloc_ptr,
253               gd->malloc_ptr / 1024);
254 #endif
255         /* The malloc area is immediately below the monitor copy in DRAM */
256         /*
257          * This value MUST match the value of gd->start_addr_sp in board_f.c:
258          * reserve_noncached().
259          */
260         malloc_start = gd->relocaddr - TOTAL_MALLOC_LEN;
261         mem_malloc_init((ulong)map_sysmem(malloc_start, TOTAL_MALLOC_LEN),
262                         TOTAL_MALLOC_LEN);
263         return 0;
264 }
265
266 static int initr_console_record(void)
267 {
268 #if defined(CONFIG_CONSOLE_RECORD)
269         return console_record_init();
270 #else
271         return 0;
272 #endif
273 }
274
275 #ifdef CONFIG_SYS_NONCACHED_MEMORY
276 static int initr_noncached(void)
277 {
278         noncached_init();
279         return 0;
280 }
281 #endif
282
283 #ifdef CONFIG_OF_LIVE
284 static int initr_of_live(void)
285 {
286         int ret;
287
288         bootstage_start(BOOTSTAGE_ID_ACCUM_OF_LIVE, "of_live");
289         ret = of_live_build(gd->fdt_blob, (struct device_node **)&gd->of_root);
290         bootstage_accum(BOOTSTAGE_ID_ACCUM_OF_LIVE);
291         if (ret)
292                 return ret;
293
294         return 0;
295 }
296 #endif
297
298 #ifdef CONFIG_DM
299 static int initr_dm(void)
300 {
301         int ret;
302
303         /* Save the pre-reloc driver model and start a new one */
304         gd->dm_root_f = gd->dm_root;
305         gd->dm_root = NULL;
306 #ifdef CONFIG_TIMER
307         gd->timer = NULL;
308 #endif
309         bootstage_start(BOOTSTATE_ID_ACCUM_DM_R, "dm_r");
310         ret = dm_init_and_scan(false);
311         bootstage_accum(BOOTSTATE_ID_ACCUM_DM_R);
312         if (ret)
313                 return ret;
314
315         return 0;
316 }
317 #endif
318
319 static int initr_dm_devices(void)
320 {
321         int ret;
322
323         if (IS_ENABLED(CONFIG_TIMER_EARLY)) {
324                 ret = dm_timer_init();
325                 if (ret)
326                         return ret;
327         }
328
329         return 0;
330 }
331
332 static int initr_bootstage(void)
333 {
334         bootstage_mark_name(BOOTSTAGE_ID_START_UBOOT_R, "board_init_r");
335
336         return 0;
337 }
338
339 __weak int power_init_board(void)
340 {
341         return 0;
342 }
343
344 static int initr_announce(void)
345 {
346         debug("Now running in RAM - U-Boot at: %08lx\n", gd->relocaddr);
347         return 0;
348 }
349
350 #ifdef CONFIG_NEEDS_MANUAL_RELOC
351 static int initr_manual_reloc_cmdtable(void)
352 {
353         fixup_cmdtable(ll_entry_start(cmd_tbl_t, cmd),
354                        ll_entry_count(cmd_tbl_t, cmd));
355         return 0;
356 }
357 #endif
358
359 static int initr_binman(void)
360 {
361         if (!CONFIG_IS_ENABLED(BINMAN_FDT))
362                 return 0;
363
364         return binman_init();
365 }
366
367 #if defined(CONFIG_MTD_NOR_FLASH)
368 static int initr_flash(void)
369 {
370         ulong flash_size = 0;
371         bd_t *bd = gd->bd;
372
373         puts("Flash: ");
374
375         if (board_flash_wp_on())
376                 printf("Uninitialized - Write Protect On\n");
377         else
378                 flash_size = flash_init();
379
380         print_size(flash_size, "");
381 #ifdef CONFIG_SYS_FLASH_CHECKSUM
382         /*
383          * Compute and print flash CRC if flashchecksum is set to 'y'
384          *
385          * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX
386          */
387         if (env_get_yesno("flashchecksum") == 1) {
388                 const uchar *flash_base = (const uchar *)CONFIG_SYS_FLASH_BASE;
389
390                 printf("  CRC: %08X", crc32(0,
391                                             flash_base,
392                                             flash_size));
393         }
394 #endif /* CONFIG_SYS_FLASH_CHECKSUM */
395         putc('\n');
396
397         /* update start of FLASH memory    */
398 #ifdef CONFIG_SYS_FLASH_BASE
399         bd->bi_flashstart = CONFIG_SYS_FLASH_BASE;
400 #endif
401         /* size of FLASH memory (final value) */
402         bd->bi_flashsize = flash_size;
403
404 #if defined(CONFIG_SYS_UPDATE_FLASH_SIZE)
405         /* Make a update of the Memctrl. */
406         update_flash_size(flash_size);
407 #endif
408
409 #if defined(CONFIG_OXC) || defined(CONFIG_RMU)
410         /* flash mapped at end of memory map */
411         bd->bi_flashoffset = CONFIG_SYS_TEXT_BASE + flash_size;
412 #elif CONFIG_SYS_MONITOR_BASE == CONFIG_SYS_FLASH_BASE
413         bd->bi_flashoffset = monitor_flash_len; /* reserved area for monitor */
414 #endif
415         return 0;
416 }
417 #endif
418
419 #ifdef CONFIG_CMD_NAND
420 /* go init the NAND */
421 static int initr_nand(void)
422 {
423         puts("NAND:  ");
424         nand_init();
425         printf("%lu MiB\n", nand_size() / 1024);
426         return 0;
427 }
428 #endif
429
430 #if defined(CONFIG_CMD_ONENAND)
431 /* go init the NAND */
432 static int initr_onenand(void)
433 {
434         puts("NAND:  ");
435         onenand_init();
436         return 0;
437 }
438 #endif
439
440 #ifdef CONFIG_MMC
441 static int initr_mmc(void)
442 {
443         puts("MMC:   ");
444         mmc_initialize(gd->bd);
445         return 0;
446 }
447 #endif
448
449 /*
450  * Tell if it's OK to load the environment early in boot.
451  *
452  * If CONFIG_OF_CONTROL is defined, we'll check with the FDT to see
453  * if this is OK (defaulting to saying it's OK).
454  *
455  * NOTE: Loading the environment early can be a bad idea if security is
456  *       important, since no verification is done on the environment.
457  *
458  * @return 0 if environment should not be loaded, !=0 if it is ok to load
459  */
460 static int should_load_env(void)
461 {
462 #ifdef CONFIG_OF_CONTROL
463         return fdtdec_get_config_int(gd->fdt_blob, "load-environment", 1);
464 #elif defined CONFIG_DELAY_ENVIRONMENT
465         return 0;
466 #else
467         return 1;
468 #endif
469 }
470
471 static int initr_env(void)
472 {
473         /* initialize environment */
474         if (should_load_env())
475                 env_relocate();
476         else
477                 env_set_default(NULL, 0);
478 #ifdef CONFIG_OF_CONTROL
479         env_set_hex("fdtcontroladdr",
480                     (unsigned long)map_to_sysmem(gd->fdt_blob));
481 #endif
482
483         /* Initialize from environment */
484         load_addr = env_get_ulong("loadaddr", 16, load_addr);
485
486         return 0;
487 }
488
489 #ifdef CONFIG_SYS_BOOTPARAMS_LEN
490 static int initr_malloc_bootparams(void)
491 {
492         gd->bd->bi_boot_params = (ulong)malloc(CONFIG_SYS_BOOTPARAMS_LEN);
493         if (!gd->bd->bi_boot_params) {
494                 puts("WARNING: Cannot allocate space for boot parameters\n");
495                 return -ENOMEM;
496         }
497         return 0;
498 }
499 #endif
500
501 static int initr_jumptable(void)
502 {
503         jumptable_init();
504         return 0;
505 }
506
507 #if defined(CONFIG_API)
508 static int initr_api(void)
509 {
510         /* Initialize API */
511         api_init();
512         return 0;
513 }
514 #endif
515
516 /* enable exceptions */
517 #ifdef CONFIG_ARM
518 static int initr_enable_interrupts(void)
519 {
520         enable_interrupts();
521         return 0;
522 }
523 #endif
524
525 #ifdef CONFIG_CMD_NET
526 static int initr_ethaddr(void)
527 {
528         bd_t *bd = gd->bd;
529
530         /* kept around for legacy kernels only ... ignore the next section */
531         eth_env_get_enetaddr("ethaddr", bd->bi_enetaddr);
532 #ifdef CONFIG_HAS_ETH1
533         eth_env_get_enetaddr("eth1addr", bd->bi_enet1addr);
534 #endif
535 #ifdef CONFIG_HAS_ETH2
536         eth_env_get_enetaddr("eth2addr", bd->bi_enet2addr);
537 #endif
538 #ifdef CONFIG_HAS_ETH3
539         eth_env_get_enetaddr("eth3addr", bd->bi_enet3addr);
540 #endif
541 #ifdef CONFIG_HAS_ETH4
542         eth_env_get_enetaddr("eth4addr", bd->bi_enet4addr);
543 #endif
544 #ifdef CONFIG_HAS_ETH5
545         eth_env_get_enetaddr("eth5addr", bd->bi_enet5addr);
546 #endif
547         return 0;
548 }
549 #endif /* CONFIG_CMD_NET */
550
551 #ifdef CONFIG_CMD_KGDB
552 static int initr_kgdb(void)
553 {
554         puts("KGDB:  ");
555         kgdb_init();
556         return 0;
557 }
558 #endif
559
560 #if defined(CONFIG_LED_STATUS)
561 static int initr_status_led(void)
562 {
563 #if defined(CONFIG_LED_STATUS_BOOT)
564         status_led_set(CONFIG_LED_STATUS_BOOT, CONFIG_LED_STATUS_BLINKING);
565 #else
566         status_led_init();
567 #endif
568         return 0;
569 }
570 #endif
571
572 #if defined(CONFIG_SCSI) && !defined(CONFIG_DM_SCSI)
573 static int initr_scsi(void)
574 {
575         puts("SCSI:  ");
576         scsi_init();
577         puts("\n");
578
579         return 0;
580 }
581 #endif
582
583 #ifdef CONFIG_BITBANGMII
584 static int initr_bbmii(void)
585 {
586         bb_miiphy_init();
587         return 0;
588 }
589 #endif
590
591 #ifdef CONFIG_CMD_NET
592 static int initr_net(void)
593 {
594         puts("Net:   ");
595         eth_initialize();
596 #if defined(CONFIG_RESET_PHY_R)
597         debug("Reset Ethernet PHY\n");
598         reset_phy();
599 #endif
600         return 0;
601 }
602 #endif
603
604 #ifdef CONFIG_POST
605 static int initr_post(void)
606 {
607         post_run(NULL, POST_RAM | post_bootmode_get(0));
608         return 0;
609 }
610 #endif
611
612 #if defined(CONFIG_IDE) && !defined(CONFIG_BLK)
613 static int initr_ide(void)
614 {
615         puts("IDE:   ");
616 #if defined(CONFIG_START_IDE)
617         if (board_start_ide())
618                 ide_init();
619 #else
620         ide_init();
621 #endif
622         return 0;
623 }
624 #endif
625
626 #if defined(CONFIG_PRAM)
627 /*
628  * Export available size of memory for Linux, taking into account the
629  * protected RAM at top of memory
630  */
631 int initr_mem(void)
632 {
633         ulong pram = 0;
634         char memsz[32];
635
636         pram = env_get_ulong("pram", 10, CONFIG_PRAM);
637         sprintf(memsz, "%ldk", (long int)((gd->ram_size / 1024) - pram));
638         env_set("mem", memsz);
639
640         return 0;
641 }
642 #endif
643
644 #ifdef CONFIG_CMD_BEDBUG
645 static int initr_bedbug(void)
646 {
647         bedbug_init();
648
649         return 0;
650 }
651 #endif
652
653 static int run_main_loop(void)
654 {
655 #ifdef CONFIG_SANDBOX
656         sandbox_main_loop_init();
657 #endif
658         /* main_loop() can return to retry autoboot, if so just run it again */
659         for (;;)
660                 main_loop();
661         return 0;
662 }
663
664 /*
665  * We hope to remove most of the driver-related init and do it if/when
666  * the driver is later used.
667  *
668  * TODO: perhaps reset the watchdog in the initcall function after each call?
669  */
670 static init_fnc_t init_sequence_r[] = {
671         initr_trace,
672         initr_reloc,
673         /* TODO: could x86/PPC have this also perhaps? */
674 #ifdef CONFIG_ARM
675         initr_caches,
676         /* Note: For Freescale LS2 SoCs, new MMU table is created in DDR.
677          *       A temporary mapping of IFC high region is since removed,
678          *       so environmental variables in NOR flash is not available
679          *       until board_init() is called below to remap IFC to high
680          *       region.
681          */
682 #endif
683         initr_reloc_global_data,
684 #if defined(CONFIG_SYS_INIT_RAM_LOCK) && defined(CONFIG_E500)
685         initr_unlock_ram_in_cache,
686 #endif
687         initr_barrier,
688         initr_malloc,
689         log_init,
690         initr_bootstage,        /* Needs malloc() but has its own timer */
691         initr_console_record,
692 #ifdef CONFIG_SYS_NONCACHED_MEMORY
693         initr_noncached,
694 #endif
695 #ifdef CONFIG_OF_LIVE
696         initr_of_live,
697 #endif
698 #ifdef CONFIG_DM
699         initr_dm,
700 #endif
701 #if defined(CONFIG_ARM) || defined(CONFIG_NDS32) || defined(CONFIG_RISCV) || \
702         defined(CONFIG_SANDBOX)
703         board_init,     /* Setup chipselects */
704 #endif
705         /*
706          * TODO: printing of the clock inforamtion of the board is now
707          * implemented as part of bdinfo command. Currently only support for
708          * davinci SOC's is added. Remove this check once all the board
709          * implement this.
710          */
711 #ifdef CONFIG_CLOCKS
712         set_cpu_clk_info, /* Setup clock information */
713 #endif
714 #ifdef CONFIG_EFI_LOADER
715         efi_memory_init,
716 #endif
717         initr_binman,
718 #ifdef CONFIG_FSP_VERSION2
719         arch_fsp_init_r,
720 #endif
721         initr_dm_devices,
722         stdio_init_tables,
723         initr_serial,
724         initr_announce,
725 #if CONFIG_IS_ENABLED(WDT)
726         initr_watchdog,
727 #endif
728         INIT_FUNC_WATCHDOG_RESET
729 #ifdef CONFIG_NEEDS_MANUAL_RELOC
730         initr_manual_reloc_cmdtable,
731 #endif
732 #if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_MIPS)
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_POST
743         initr_post_backlog,
744 #endif
745         INIT_FUNC_WATCHDOG_RESET
746 #if defined(CONFIG_PCI) && defined(CONFIG_SYS_EARLY_PCI_INIT)
747         /*
748          * Do early PCI configuration _before_ the flash gets initialised,
749          * because PCU resources are crucial for flash access on some boards.
750          */
751         initr_pci,
752 #endif
753 #ifdef CONFIG_ARCH_EARLY_INIT_R
754         arch_early_init_r,
755 #endif
756         power_init_board,
757 #ifdef CONFIG_MTD_NOR_FLASH
758         initr_flash,
759 #endif
760         INIT_FUNC_WATCHDOG_RESET
761 #if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_X86)
762         /* initialize higher level parts of CPU like time base and timers */
763         cpu_init_r,
764 #endif
765 #ifdef CONFIG_CMD_NAND
766         initr_nand,
767 #endif
768 #ifdef CONFIG_CMD_ONENAND
769         initr_onenand,
770 #endif
771 #ifdef CONFIG_MMC
772         initr_mmc,
773 #endif
774         initr_env,
775 #ifdef CONFIG_SYS_BOOTPARAMS_LEN
776         initr_malloc_bootparams,
777 #endif
778         INIT_FUNC_WATCHDOG_RESET
779         initr_secondary_cpu,
780 #if defined(CONFIG_ID_EEPROM) || defined(CONFIG_SYS_I2C_MAC_OFFSET)
781         mac_read_from_eeprom,
782 #endif
783         INIT_FUNC_WATCHDOG_RESET
784 #if defined(CONFIG_PCI) && !defined(CONFIG_SYS_EARLY_PCI_INIT)
785         /*
786          * Do pci configuration
787          */
788         initr_pci,
789 #endif
790         stdio_add_devices,
791         initr_jumptable,
792 #ifdef CONFIG_API
793         initr_api,
794 #endif
795         console_init_r,         /* fully init console as a device */
796 #ifdef CONFIG_DISPLAY_BOARDINFO_LATE
797         console_announce_r,
798         show_board_info,
799 #endif
800 #ifdef CONFIG_ARCH_MISC_INIT
801         arch_misc_init,         /* miscellaneous arch-dependent init */
802 #endif
803 #ifdef CONFIG_MISC_INIT_R
804         misc_init_r,            /* miscellaneous platform-dependent init */
805 #endif
806         INIT_FUNC_WATCHDOG_RESET
807 #ifdef CONFIG_CMD_KGDB
808         initr_kgdb,
809 #endif
810         interrupt_init,
811 #ifdef CONFIG_ARM
812         initr_enable_interrupts,
813 #endif
814 #if defined(CONFIG_MICROBLAZE) || defined(CONFIG_M68K)
815         timer_init,             /* initialize timer */
816 #endif
817 #if defined(CONFIG_LED_STATUS)
818         initr_status_led,
819 #endif
820         /* PPC has a udelay(20) here dating from 2002. Why? */
821 #ifdef CONFIG_CMD_NET
822         initr_ethaddr,
823 #endif
824 #if defined(CONFIG_GPIO_HOG)
825         gpio_hog_probe_all,
826 #endif
827 #ifdef CONFIG_BOARD_LATE_INIT
828         board_late_init,
829 #endif
830 #if defined(CONFIG_SCSI) && !defined(CONFIG_DM_SCSI)
831         INIT_FUNC_WATCHDOG_RESET
832         initr_scsi,
833 #endif
834 #ifdef CONFIG_BITBANGMII
835         initr_bbmii,
836 #endif
837 #ifdef CONFIG_CMD_NET
838         INIT_FUNC_WATCHDOG_RESET
839         initr_net,
840 #endif
841 #ifdef CONFIG_POST
842         initr_post,
843 #endif
844 #if defined(CONFIG_IDE) && !defined(CONFIG_BLK)
845         initr_ide,
846 #endif
847 #ifdef CONFIG_LAST_STAGE_INIT
848         INIT_FUNC_WATCHDOG_RESET
849         /*
850          * Some parts can be only initialized if all others (like
851          * Interrupts) are up and running (i.e. the PC-style ISA
852          * keyboard).
853          */
854         last_stage_init,
855 #endif
856 #ifdef CONFIG_CMD_BEDBUG
857         INIT_FUNC_WATCHDOG_RESET
858         initr_bedbug,
859 #endif
860 #if defined(CONFIG_PRAM)
861         initr_mem,
862 #endif
863         run_main_loop,
864 };
865
866 void board_init_r(gd_t *new_gd, ulong dest_addr)
867 {
868         /*
869          * Set up the new global data pointer. So far only x86 does this
870          * here.
871          * TODO(sjg@chromium.org): Consider doing this for all archs, or
872          * dropping the new_gd parameter.
873          */
874 #if CONFIG_IS_ENABLED(X86_64)
875         arch_setup_gd(new_gd);
876 #endif
877
878 #ifdef CONFIG_NEEDS_MANUAL_RELOC
879         int i;
880 #endif
881
882 #if !defined(CONFIG_X86) && !defined(CONFIG_ARM) && !defined(CONFIG_ARM64)
883         gd = new_gd;
884 #endif
885         gd->flags &= ~GD_FLG_LOG_READY;
886
887 #ifdef CONFIG_NEEDS_MANUAL_RELOC
888         for (i = 0; i < ARRAY_SIZE(init_sequence_r); i++)
889                 init_sequence_r[i] += gd->reloc_off;
890 #endif
891
892         if (initcall_run_list(init_sequence_r))
893                 hang();
894
895         /* NOTREACHED - run_main_loop() does not return */
896         hang();
897 }