common/board_r.c

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