LXR uboot/common/board

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