1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2010 4 * Texas Instruments, <www.ti.com> 5 * 6 * Aneesh V <aneesh (at) ti.com> 7 */ 8 9 #include <common.h> 10 #include <binman_sym.h> 11 #include <dm.h> 12 #include <spl.h> 13 #include <asm/u-boot.h> 14 #include <nand.h> 15 #include <fat.h> 16 #include <version.h> 17 #include <image.h> 18 #include <malloc.h> 19 #include <dm/root.h> 20 #include <linux/compiler.h> 21 #include <fdt_support.h> 22 #include <bootcount.h> 23 24 DECLARE_GLOBAL_DATA_PTR; 25 26 #ifndef CONFIG_SYS_UBOOT_START 27 #define CONFIG_SYS_UBOOT_START CONFIG_SYS_TEXT_BASE 28 #endif 29 #ifndef CONFIG_SYS_MONITOR_LEN 30 /* Unknown U-Boot size, let's assume it will not be more than 200 KB */ 31 #define CONFIG_SYS_MONITOR_LEN (200 * 1024) 32 #endif 33 34 u32 *boot_params_ptr = NULL; 35 36 /* See spl.h for information about this */ 37 binman_sym_declare(ulong, u_boot_any, pos); 38 39 /* Define board data structure */ 40 static bd_t bdata __attribute__ ((section(".data"))); 41 42 /* 43 * Board-specific Platform code can reimplement show_boot_progress () if needed 44 */ 45 __weak void show_boot_progress(int val) {} 46 47 /* 48 * Default function to determine if u-boot or the OS should 49 * be started. This implementation always returns 1. 50 * 51 * Please implement your own board specific funcion to do this. 52 * 53 * RETURN 54 * 0 to not start u-boot 55 * positive if u-boot should start 56 */ 57 #ifdef CONFIG_SPL_OS_BOOT 58 __weak int spl_start_uboot(void) 59 { 60 puts("SPL: Please implement spl_start_uboot() for your board\n"); 61 puts("SPL: Direct Linux boot not active!\n"); 62 return 1; 63 } 64 65 /* weak default platform specific function to initialize 66 * dram banks 67 */ 68 __weak int dram_init_banksize(void) 69 { 70 return 0; 71 } 72 73 /* 74 * Weak default function for arch specific zImage check. Return zero 75 * and fill start and end address if image is recognized. 76 */ 77 int __weak bootz_setup(ulong image, ulong *start, ulong *end) 78 { 79 return 1; 80 } 81 #endif 82 83 void spl_fixup_fdt(void) 84 { 85 #if defined(CONFIG_SPL_OF_LIBFDT) && defined(CONFIG_SYS_SPL_ARGS_ADDR) 86 void *fdt_blob = (void *)CONFIG_SYS_SPL_ARGS_ADDR; 87 int err; 88 89 err = fdt_check_header(fdt_blob); 90 if (err < 0) { 91 printf("fdt_root: %s\n", fdt_strerror(err)); 92 return; 93 } 94 95 /* fixup the memory dt node */ 96 err = fdt_shrink_to_minimum(fdt_blob, 0); 97 if (err == 0) { 98 printf("spl: fdt_shrink_to_minimum err - %d\n", err); 99 return; 100 } 101 102 err = arch_fixup_fdt(fdt_blob); 103 if (err) { 104 printf("spl: arch_fixup_fdt err - %d\n", err); 105 return; 106 } 107 #endif 108 } 109 110 /* 111 * Weak default function for board specific cleanup/preparation before 112 * Linux boot. Some boards/platforms might not need it, so just provide 113 * an empty stub here. 114 */ 115 __weak void spl_board_prepare_for_linux(void) 116 { 117 /* Nothing to do! */ 118 } 119 120 __weak void spl_board_prepare_for_boot(void) 121 { 122 /* Nothing to do! */ 123 } 124 125 void spl_set_header_raw_uboot(struct spl_image_info *spl_image) 126 { 127 ulong u_boot_pos = binman_sym(ulong, u_boot_any, pos); 128 129 spl_image->size = CONFIG_SYS_MONITOR_LEN; 130 131 /* 132 * Binman error cases: address of the end of the previous region or the 133 * start of the image's entry area (usually 0) if there is no previous 134 * region. 135 */ 136 if (u_boot_pos && u_boot_pos != BINMAN_SYM_MISSING) { 137 /* Binman does not support separated entry addresses */ 138 spl_image->entry_point = u_boot_pos; 139 spl_image->load_addr = u_boot_pos; 140 } else { 141 spl_image->entry_point = CONFIG_SYS_UBOOT_START; 142 spl_image->load_addr = CONFIG_SYS_TEXT_BASE; 143 } 144 spl_image->os = IH_OS_U_BOOT; 145 spl_image->name = "U-Boot"; 146 } 147 148 #ifdef CONFIG_SPL_LOAD_FIT_FULL 149 /* Parse and load full fitImage in SPL */ 150 static int spl_load_fit_image(struct spl_image_info *spl_image, 151 const struct image_header *header) 152 { 153 bootm_headers_t images; 154 const char *fit_uname_config = NULL; 155 const char *fit_uname_fdt = FIT_FDT_PROP; 156 const char *uname; 157 ulong fw_data = 0, dt_data = 0, img_data = 0; 158 ulong fw_len = 0, dt_len = 0, img_len = 0; 159 int idx, conf_noffset; 160 int ret; 161 162 #ifdef CONFIG_SPL_FIT_SIGNATURE 163 images.verify = 1; 164 #endif 165 ret = fit_image_load(&images, (ulong)header, 166 NULL, &fit_uname_config, 167 IH_ARCH_DEFAULT, IH_TYPE_STANDALONE, -1, 168 FIT_LOAD_REQUIRED, &fw_data, &fw_len); 169 if (ret < 0) 170 return ret; 171 172 spl_image->size = fw_len; 173 spl_image->entry_point = fw_data; 174 spl_image->load_addr = fw_data; 175 spl_image->os = IH_OS_U_BOOT; 176 spl_image->name = "U-Boot"; 177 178 debug("spl: payload image: %.*s load addr: 0x%lx size: %d\n", 179 (int)sizeof(spl_image->name), spl_image->name, 180 spl_image->load_addr, spl_image->size); 181 182 #ifdef CONFIG_SPL_FIT_SIGNATURE 183 images.verify = 1; 184 #endif 185 fit_image_load(&images, (ulong)header, 186 &fit_uname_fdt, &fit_uname_config, 187 IH_ARCH_DEFAULT, IH_TYPE_FLATDT, -1, 188 FIT_LOAD_OPTIONAL, &dt_data, &dt_len); 189 190 conf_noffset = fit_conf_get_node((const void *)header, 191 fit_uname_config); 192 if (conf_noffset <= 0) 193 return 0; 194 195 for (idx = 0; 196 uname = fdt_stringlist_get((const void *)header, conf_noffset, 197 FIT_LOADABLE_PROP, idx, 198 NULL), uname; 199 idx++) 200 { 201 #ifdef CONFIG_SPL_FIT_SIGNATURE 202 images.verify = 1; 203 #endif 204 ret = fit_image_load(&images, (ulong)header, 205 &uname, &fit_uname_config, 206 IH_ARCH_DEFAULT, IH_TYPE_LOADABLE, -1, 207 FIT_LOAD_OPTIONAL_NON_ZERO, 208 &img_data, &img_len); 209 if (ret < 0) 210 return ret; 211 } 212 213 return 0; 214 } 215 #endif 216 217 int spl_parse_image_header(struct spl_image_info *spl_image, 218 const struct image_header *header) 219 { 220 #ifdef CONFIG_SPL_LOAD_FIT_FULL 221 int ret = spl_load_fit_image(spl_image, header); 222 223 if (!ret) 224 return ret; 225 #endif 226 if (image_get_magic(header) == IH_MAGIC) { 227 #ifdef CONFIG_SPL_LEGACY_IMAGE_SUPPORT 228 u32 header_size = sizeof(struct image_header); 229 230 if (spl_image->flags & SPL_COPY_PAYLOAD_ONLY) { 231 /* 232 * On some system (e.g. powerpc), the load-address and 233 * entry-point is located at address 0. We can't load 234 * to 0-0x40. So skip header in this case. 235 */ 236 spl_image->load_addr = image_get_load(header); 237 spl_image->entry_point = image_get_ep(header); 238 spl_image->size = image_get_data_size(header); 239 } else { 240 spl_image->entry_point = image_get_load(header); 241 /* Load including the header */ 242 spl_image->load_addr = spl_image->entry_point - 243 header_size; 244 spl_image->size = image_get_data_size(header) + 245 header_size; 246 } 247 spl_image->os = image_get_os(header); 248 spl_image->name = image_get_name(header); 249 debug("spl: payload image: %.*s load addr: 0x%lx size: %d\n", 250 IH_NMLEN, spl_image->name, 251 spl_image->load_addr, spl_image->size); 252 #else 253 /* LEGACY image not supported */ 254 debug("Legacy boot image support not enabled, proceeding to other boot methods\n"); 255 return -EINVAL; 256 #endif 257 } else { 258 #ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE 259 /* 260 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the 261 * code which loads images in SPL cannot guarantee that 262 * absolutely all read errors will be reported. 263 * An example is the LPC32XX MLC NAND driver, which 264 * will consider that a completely unreadable NAND block 265 * is bad, and thus should be skipped silently. 266 */ 267 panic("** no mkimage signature but raw image not supported"); 268 #endif 269 270 #ifdef CONFIG_SPL_OS_BOOT 271 ulong start, end; 272 273 if (!bootz_setup((ulong)header, &start, &end)) { 274 spl_image->name = "Linux"; 275 spl_image->os = IH_OS_LINUX; 276 spl_image->load_addr = CONFIG_SYS_LOAD_ADDR; 277 spl_image->entry_point = CONFIG_SYS_LOAD_ADDR; 278 spl_image->size = end - start; 279 debug("spl: payload zImage, load addr: 0x%lx size: %d\n", 280 spl_image->load_addr, spl_image->size); 281 return 0; 282 } 283 #endif 284 285 #ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT 286 /* Signature not found - assume u-boot.bin */ 287 debug("mkimage signature not found - ih_magic = %x\n", 288 header->ih_magic); 289 spl_set_header_raw_uboot(spl_image); 290 #else 291 /* RAW image not supported, proceed to other boot methods. */ 292 debug("Raw boot image support not enabled, proceeding to other boot methods\n"); 293 return -EINVAL; 294 #endif 295 } 296 297 return 0; 298 } 299 300 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image) 301 { 302 typedef void __noreturn (*image_entry_noargs_t)(void); 303 304 image_entry_noargs_t image_entry = 305 (image_entry_noargs_t)spl_image->entry_point; 306 307 debug("image entry point: 0x%lX\n", spl_image->entry_point); 308 image_entry(); 309 } 310 311 static int spl_common_init(bool setup_malloc) 312 { 313 int ret; 314 315 debug("spl_early_init()\n"); 316 317 #if CONFIG_VAL(SYS_MALLOC_F_LEN) 318 if (setup_malloc) { 319 #ifdef CONFIG_MALLOC_F_ADDR 320 gd->malloc_base = CONFIG_MALLOC_F_ADDR; 321 #endif 322 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN); 323 gd->malloc_ptr = 0; 324 } 325 #endif 326 ret = bootstage_init(true); 327 if (ret) { 328 debug("%s: Failed to set up bootstage: ret=%d\n", __func__, 329 ret); 330 return ret; 331 } 332 bootstage_mark_name(BOOTSTAGE_ID_START_SPL, "spl"); 333 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) { 334 ret = fdtdec_setup(); 335 if (ret) { 336 debug("fdtdec_setup() returned error %d\n", ret); 337 return ret; 338 } 339 } 340 if (CONFIG_IS_ENABLED(DM)) { 341 bootstage_start(BOOTSTATE_ID_ACCUM_DM_SPL, "dm_spl"); 342 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */ 343 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA)); 344 bootstage_accum(BOOTSTATE_ID_ACCUM_DM_SPL); 345 if (ret) { 346 debug("dm_init_and_scan() returned error %d\n", ret); 347 return ret; 348 } 349 } 350 351 return 0; 352 } 353 354 void spl_set_bd(void) 355 { 356 if (!gd->bd) 357 gd->bd = &bdata; 358 } 359 360 int spl_early_init(void) 361 { 362 int ret; 363 364 ret = spl_common_init(true); 365 if (ret) 366 return ret; 367 gd->flags |= GD_FLG_SPL_EARLY_INIT; 368 369 return 0; 370 } 371 372 int spl_init(void) 373 { 374 int ret; 375 bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) && 376 IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE)); 377 378 if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) { 379 ret = spl_common_init(setup_malloc); 380 if (ret) 381 return ret; 382 } 383 gd->flags |= GD_FLG_SPL_INIT; 384 385 return 0; 386 } 387 388 #ifndef BOOT_DEVICE_NONE 389 #define BOOT_DEVICE_NONE 0xdeadbeef 390 #endif 391 392 __weak void board_boot_order(u32 *spl_boot_list) 393 { 394 spl_boot_list[0] = spl_boot_device(); 395 } 396 397 static struct spl_image_loader *spl_ll_find_loader(uint boot_device) 398 { 399 struct spl_image_loader *drv = 400 ll_entry_start(struct spl_image_loader, spl_image_loader); 401 const int n_ents = 402 ll_entry_count(struct spl_image_loader, spl_image_loader); 403 struct spl_image_loader *entry; 404 405 for (entry = drv; entry != drv + n_ents; entry++) { 406 if (boot_device == entry->boot_device) 407 return entry; 408 } 409 410 /* Not found */ 411 return NULL; 412 } 413 414 static int spl_load_image(struct spl_image_info *spl_image, 415 struct spl_image_loader *loader) 416 { 417 struct spl_boot_device bootdev; 418 419 bootdev.boot_device = loader->boot_device; 420 bootdev.boot_device_name = NULL; 421 422 return loader->load_image(spl_image, &bootdev); 423 } 424 425 /** 426 * boot_from_devices() - Try loading an booting U-Boot from a list of devices 427 * 428 * @spl_image: Place to put the image details if successful 429 * @spl_boot_list: List of boot devices to try 430 * @count: Number of elements in spl_boot_list 431 * @return 0 if OK, -ve on error 432 */ 433 static int boot_from_devices(struct spl_image_info *spl_image, 434 u32 spl_boot_list[], int count) 435 { 436 int i; 437 438 for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) { 439 struct spl_image_loader *loader; 440 441 loader = spl_ll_find_loader(spl_boot_list[i]); 442 #if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 443 if (loader) 444 printf("Trying to boot from %s\n", loader->name); 445 else 446 puts("SPL: Unsupported Boot Device!\n"); 447 #endif 448 if (loader && !spl_load_image(spl_image, loader)) 449 return 0; 450 } 451 452 return -ENODEV; 453 } 454 455 void board_init_r(gd_t *dummy1, ulong dummy2) 456 { 457 u32 spl_boot_list[] = { 458 BOOT_DEVICE_NONE, 459 BOOT_DEVICE_NONE, 460 BOOT_DEVICE_NONE, 461 BOOT_DEVICE_NONE, 462 BOOT_DEVICE_NONE, 463 }; 464 struct spl_image_info spl_image; 465 466 debug(">>spl:board_init_r()\n"); 467 468 spl_set_bd(); 469 470 #ifdef CONFIG_SPL_OS_BOOT 471 dram_init_banksize(); 472 #endif 473 474 #if defined(CONFIG_SYS_SPL_MALLOC_START) 475 mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START, 476 CONFIG_SYS_SPL_MALLOC_SIZE); 477 gd->flags |= GD_FLG_FULL_MALLOC_INIT; 478 #endif 479 if (!(gd->flags & GD_FLG_SPL_INIT)) { 480 if (spl_init()) 481 hang(); 482 } 483 #if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6) 484 /* 485 * timer_init() does not exist on PPC systems. The timer is initialized 486 * and enabled (decrementer) in interrupt_init() here. 487 */ 488 timer_init(); 489 #endif 490 491 #if CONFIG_IS_ENABLED(BOARD_INIT) 492 spl_board_init(); 493 #endif 494 495 bootcount_inc(); 496 497 memset(&spl_image, '\0', sizeof(spl_image)); 498 #ifdef CONFIG_SYS_SPL_ARGS_ADDR 499 spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR; 500 #endif 501 board_boot_order(spl_boot_list); 502 503 if (boot_from_devices(&spl_image, spl_boot_list, 504 ARRAY_SIZE(spl_boot_list))) { 505 puts("SPL: failed to boot from all boot devices\n"); 506 hang(); 507 } 508 509 #ifdef CONFIG_CPU_V7M 510 spl_image.entry_point |= 0x1; 511 #endif 512 switch (spl_image.os) { 513 case IH_OS_U_BOOT: 514 debug("Jumping to U-Boot\n"); 515 break; 516 #if CONFIG_IS_ENABLED(ATF) 517 case IH_OS_ARM_TRUSTED_FIRMWARE: 518 debug("Jumping to U-Boot via ARM Trusted Firmware\n"); 519 spl_invoke_atf(&spl_image); 520 break; 521 #endif 522 #ifdef CONFIG_SPL_OS_BOOT 523 case IH_OS_LINUX: 524 debug("Jumping to Linux\n"); 525 spl_fixup_fdt(); 526 spl_board_prepare_for_linux(); 527 jump_to_image_linux(&spl_image); 528 #endif 529 default: 530 debug("Unsupported OS image.. Jumping nevertheless..\n"); 531 } 532 #if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE) 533 debug("SPL malloc() used %#lx bytes (%ld KB)\n", gd->malloc_ptr, 534 gd->malloc_ptr / 1024); 535 #endif 536 #ifdef CONFIG_BOOTSTAGE_STASH 537 int ret; 538 539 bootstage_mark_name(BOOTSTAGE_ID_END_SPL, "end_spl"); 540 ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR, 541 CONFIG_BOOTSTAGE_STASH_SIZE); 542 if (ret) 543 debug("Failed to stash bootstage: err=%d\n", ret); 544 #endif 545 546 debug("loaded - jumping to U-Boot...\n"); 547 spl_board_prepare_for_boot(); 548 jump_to_image_no_args(&spl_image); 549 } 550 551 #ifdef CONFIG_SPL_SERIAL_SUPPORT 552 /* 553 * This requires UART clocks to be enabled. In order for this to work the 554 * caller must ensure that the gd pointer is valid. 555 */ 556 void preloader_console_init(void) 557 { 558 gd->baudrate = CONFIG_BAUDRATE; 559 560 serial_init(); /* serial communications setup */ 561 562 gd->have_console = 1; 563 564 #ifndef CONFIG_SPL_DISABLE_BANNER_PRINT 565 puts("\nU-Boot SPL " PLAIN_VERSION " (" U_BOOT_DATE " - " \ 566 U_BOOT_TIME " " U_BOOT_TZ ")\n"); 567 #endif 568 #ifdef CONFIG_SPL_DISPLAY_PRINT 569 spl_display_print(); 570 #endif 571 } 572 #endif 573 574 /** 575 * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution 576 * 577 * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM 578 * for the main board_init_r() execution. This is typically because we need 579 * more stack space for things like the MMC sub-system. 580 * 581 * This function calculates the stack position, copies the global_data into 582 * place, sets the new gd (except for ARM, for which setting GD within a C 583 * function may not always work) and returns the new stack position. The 584 * caller is responsible for setting up the sp register and, in the case 585 * of ARM, setting up gd. 586 * 587 * All of this is done using the same layout and alignments as done in 588 * board_init_f_init_reserve() / board_init_f_alloc_reserve(). 589 * 590 * @return new stack location, or 0 to use the same stack 591 */ 592 ulong spl_relocate_stack_gd(void) 593 { 594 #ifdef CONFIG_SPL_STACK_R 595 gd_t *new_gd; 596 ulong ptr = CONFIG_SPL_STACK_R_ADDR; 597 598 #if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN) 599 if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) { 600 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN; 601 gd->malloc_base = ptr; 602 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN; 603 gd->malloc_ptr = 0; 604 } 605 #endif 606 /* Get stack position: use 8-byte alignment for ABI compliance */ 607 ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16); 608 new_gd = (gd_t *)ptr; 609 memcpy(new_gd, (void *)gd, sizeof(gd_t)); 610 #if CONFIG_IS_ENABLED(DM) 611 dm_fixup_for_gd_move(new_gd); 612 #endif 613 #if !defined(CONFIG_ARM) 614 gd = new_gd; 615 #endif 616 return ptr; 617 #else 618 return 0; 619 #endif 620 } 621
