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