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