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