1 /* 2 * (C) Copyright 2010 3 * Texas Instruments, <www.ti.com> 4 * 5 * Aneesh V <aneesh@ti.com> 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #include <common.h> 11 #include <binman_sym.h> 12 #include <dm.h> 13 #include <spl.h> 14 #include <asm/u-boot.h> 15 #include <nand.h> 16 #include <fat.h> 17 #include <version.h> 18 #include <image.h> 19 #include <malloc.h> 20 #include <dm/root.h> 21 #include <linux/compiler.h> 22 #include <fdt_support.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 if (u_boot_pos != BINMAN_SYM_MISSING) { 131 /* biman does not support separate entry addresses at present */ 132 spl_image->entry_point = u_boot_pos; 133 spl_image->load_addr = u_boot_pos; 134 } else { 135 spl_image->entry_point = CONFIG_SYS_UBOOT_START; 136 spl_image->load_addr = CONFIG_SYS_TEXT_BASE; 137 } 138 spl_image->os = IH_OS_U_BOOT; 139 spl_image->name = "U-Boot"; 140 } 141 142 int spl_parse_image_header(struct spl_image_info *spl_image, 143 const struct image_header *header) 144 { 145 if (image_get_magic(header) == IH_MAGIC) { 146 #ifdef CONFIG_SPL_LEGACY_IMAGE_SUPPORT 147 u32 header_size = sizeof(struct image_header); 148 149 if (spl_image->flags & SPL_COPY_PAYLOAD_ONLY) { 150 /* 151 * On some system (e.g. powerpc), the load-address and 152 * entry-point is located at address 0. We can't load 153 * to 0-0x40. So skip header in this case. 154 */ 155 spl_image->load_addr = image_get_load(header); 156 spl_image->entry_point = image_get_ep(header); 157 spl_image->size = image_get_data_size(header); 158 } else { 159 spl_image->entry_point = image_get_load(header); 160 /* Load including the header */ 161 spl_image->load_addr = spl_image->entry_point - 162 header_size; 163 spl_image->size = image_get_data_size(header) + 164 header_size; 165 } 166 spl_image->os = image_get_os(header); 167 spl_image->name = image_get_name(header); 168 debug("spl: payload image: %.*s load addr: 0x%lx size: %d\n", 169 IH_NMLEN, spl_image->name, 170 spl_image->load_addr, spl_image->size); 171 #else 172 /* LEGACY image not supported */ 173 debug("Legacy boot image support not enabled, proceeding to other boot methods\n"); 174 return -EINVAL; 175 #endif 176 } else { 177 #ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE 178 /* 179 * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the 180 * code which loads images in SPL cannot guarantee that 181 * absolutely all read errors will be reported. 182 * An example is the LPC32XX MLC NAND driver, which 183 * will consider that a completely unreadable NAND block 184 * is bad, and thus should be skipped silently. 185 */ 186 panic("** no mkimage signature but raw image not supported"); 187 #endif 188 189 #ifdef CONFIG_SPL_OS_BOOT 190 ulong start, end; 191 192 if (!bootz_setup((ulong)header, &start, &end)) { 193 spl_image->name = "Linux"; 194 spl_image->os = IH_OS_LINUX; 195 spl_image->load_addr = CONFIG_SYS_LOAD_ADDR; 196 spl_image->entry_point = CONFIG_SYS_LOAD_ADDR; 197 spl_image->size = end - start; 198 debug("spl: payload zImage, load addr: 0x%lx size: %d\n", 199 spl_image->load_addr, spl_image->size); 200 return 0; 201 } 202 #endif 203 204 #ifdef CONFIG_SPL_RAW_IMAGE_SUPPORT 205 /* Signature not found - assume u-boot.bin */ 206 debug("mkimage signature not found - ih_magic = %x\n", 207 header->ih_magic); 208 spl_set_header_raw_uboot(spl_image); 209 #else 210 /* RAW image not supported, proceed to other boot methods. */ 211 debug("Raw boot image support not enabled, proceeding to other boot methods\n"); 212 return -EINVAL; 213 #endif 214 } 215 216 return 0; 217 } 218 219 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image) 220 { 221 typedef void __noreturn (*image_entry_noargs_t)(void); 222 223 image_entry_noargs_t image_entry = 224 (image_entry_noargs_t)spl_image->entry_point; 225 226 debug("image entry point: 0x%lX\n", spl_image->entry_point); 227 image_entry(); 228 } 229 230 static int spl_common_init(bool setup_malloc) 231 { 232 int ret; 233 234 debug("spl_early_init()\n"); 235 236 #if CONFIG_VAL(SYS_MALLOC_F_LEN) 237 if (setup_malloc) { 238 #ifdef CONFIG_MALLOC_F_ADDR 239 gd->malloc_base = CONFIG_MALLOC_F_ADDR; 240 #endif 241 gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN); 242 gd->malloc_ptr = 0; 243 } 244 #endif 245 ret = bootstage_init(true); 246 if (ret) { 247 debug("%s: Failed to set up bootstage: ret=%d\n", __func__, 248 ret); 249 return ret; 250 } 251 bootstage_mark_name(BOOTSTAGE_ID_START_SPL, "spl"); 252 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) { 253 ret = fdtdec_setup(); 254 if (ret) { 255 debug("fdtdec_setup() returned error %d\n", ret); 256 return ret; 257 } 258 } 259 if (CONFIG_IS_ENABLED(DM)) { 260 bootstage_start(BOOTSTATE_ID_ACCUM_DM_SPL, "dm_spl"); 261 /* With CONFIG_SPL_OF_PLATDATA, bring in all devices */ 262 ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA)); 263 bootstage_accum(BOOTSTATE_ID_ACCUM_DM_SPL); 264 if (ret) { 265 debug("dm_init_and_scan() returned error %d\n", ret); 266 return ret; 267 } 268 } 269 270 return 0; 271 } 272 273 void spl_set_bd(void) 274 { 275 if (!gd->bd) 276 gd->bd = &bdata; 277 } 278 279 int spl_early_init(void) 280 { 281 int ret; 282 283 ret = spl_common_init(true); 284 if (ret) 285 return ret; 286 gd->flags |= GD_FLG_SPL_EARLY_INIT; 287 288 return 0; 289 } 290 291 int spl_init(void) 292 { 293 int ret; 294 bool setup_malloc = !(IS_ENABLED(CONFIG_SPL_STACK_R) && 295 IS_ENABLED(CONFIG_SPL_SYS_MALLOC_SIMPLE)); 296 297 if (!(gd->flags & GD_FLG_SPL_EARLY_INIT)) { 298 ret = spl_common_init(setup_malloc); 299 if (ret) 300 return ret; 301 } 302 gd->flags |= GD_FLG_SPL_INIT; 303 304 return 0; 305 } 306 307 #ifndef BOOT_DEVICE_NONE 308 #define BOOT_DEVICE_NONE 0xdeadbeef 309 #endif 310 311 __weak void board_boot_order(u32 *spl_boot_list) 312 { 313 spl_boot_list[0] = spl_boot_device(); 314 } 315 316 static struct spl_image_loader *spl_ll_find_loader(uint boot_device) 317 { 318 struct spl_image_loader *drv = 319 ll_entry_start(struct spl_image_loader, spl_image_loader); 320 const int n_ents = 321 ll_entry_count(struct spl_image_loader, spl_image_loader); 322 struct spl_image_loader *entry; 323 324 for (entry = drv; entry != drv + n_ents; entry++) { 325 if (boot_device == entry->boot_device) 326 return entry; 327 } 328 329 /* Not found */ 330 return NULL; 331 } 332 333 static int spl_load_image(struct spl_image_info *spl_image, 334 struct spl_image_loader *loader) 335 { 336 struct spl_boot_device bootdev; 337 338 bootdev.boot_device = loader->boot_device; 339 bootdev.boot_device_name = NULL; 340 341 return loader->load_image(spl_image, &bootdev); 342 } 343 344 /** 345 * boot_from_devices() - Try loading an booting U-Boot from a list of devices 346 * 347 * @spl_image: Place to put the image details if successful 348 * @spl_boot_list: List of boot devices to try 349 * @count: Number of elements in spl_boot_list 350 * @return 0 if OK, -ve on error 351 */ 352 static int boot_from_devices(struct spl_image_info *spl_image, 353 u32 spl_boot_list[], int count) 354 { 355 int i; 356 357 for (i = 0; i < count && spl_boot_list[i] != BOOT_DEVICE_NONE; i++) { 358 struct spl_image_loader *loader; 359 360 loader = spl_ll_find_loader(spl_boot_list[i]); 361 #if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 362 if (loader) 363 printf("Trying to boot from %s\n", loader->name); 364 else 365 puts("SPL: Unsupported Boot Device!\n"); 366 #endif 367 if (loader && !spl_load_image(spl_image, loader)) 368 return 0; 369 } 370 371 return -ENODEV; 372 } 373 374 void board_init_r(gd_t *dummy1, ulong dummy2) 375 { 376 u32 spl_boot_list[] = { 377 BOOT_DEVICE_NONE, 378 BOOT_DEVICE_NONE, 379 BOOT_DEVICE_NONE, 380 BOOT_DEVICE_NONE, 381 BOOT_DEVICE_NONE, 382 }; 383 struct spl_image_info spl_image; 384 385 debug(">>spl:board_init_r()\n"); 386 387 spl_set_bd(); 388 389 #ifdef CONFIG_SPL_OS_BOOT 390 dram_init_banksize(); 391 #endif 392 393 #if defined(CONFIG_SYS_SPL_MALLOC_START) 394 mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START, 395 CONFIG_SYS_SPL_MALLOC_SIZE); 396 gd->flags |= GD_FLG_FULL_MALLOC_INIT; 397 #endif 398 if (!(gd->flags & GD_FLG_SPL_INIT)) { 399 if (spl_init()) 400 hang(); 401 } 402 #if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6) 403 /* 404 * timer_init() does not exist on PPC systems. The timer is initialized 405 * and enabled (decrementer) in interrupt_init() here. 406 */ 407 timer_init(); 408 #endif 409 410 #if CONFIG_IS_ENABLED(BOARD_INIT) 411 spl_board_init(); 412 #endif 413 414 memset(&spl_image, '\0', sizeof(spl_image)); 415 #ifdef CONFIG_SYS_SPL_ARGS_ADDR 416 spl_image.arg = (void *)CONFIG_SYS_SPL_ARGS_ADDR; 417 #endif 418 board_boot_order(spl_boot_list); 419 420 if (boot_from_devices(&spl_image, spl_boot_list, 421 ARRAY_SIZE(spl_boot_list))) { 422 puts("SPL: failed to boot from all boot devices\n"); 423 hang(); 424 } 425 426 #ifdef CONFIG_CPU_V7M 427 spl_image.entry_point |= 0x1; 428 #endif 429 switch (spl_image.os) { 430 case IH_OS_U_BOOT: 431 debug("Jumping to U-Boot\n"); 432 break; 433 #if CONFIG_IS_ENABLED(ATF) 434 case IH_OS_ARM_TRUSTED_FIRMWARE: 435 debug("Jumping to U-Boot via ARM Trusted Firmware\n"); 436 spl_invoke_atf(&spl_image); 437 break; 438 #endif 439 #ifdef CONFIG_SPL_OS_BOOT 440 case IH_OS_LINUX: 441 debug("Jumping to Linux\n"); 442 spl_fixup_fdt(); 443 spl_board_prepare_for_linux(); 444 jump_to_image_linux(&spl_image); 445 #endif 446 default: 447 debug("Unsupported OS image.. Jumping nevertheless..\n"); 448 } 449 #if CONFIG_VAL(SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE) 450 debug("SPL malloc() used %#lx bytes (%ld KB)\n", gd->malloc_ptr, 451 gd->malloc_ptr / 1024); 452 #endif 453 #ifdef CONFIG_BOOTSTAGE_STASH 454 int ret; 455 456 bootstage_mark_name(BOOTSTAGE_ID_END_SPL, "end_spl"); 457 ret = bootstage_stash((void *)CONFIG_BOOTSTAGE_STASH_ADDR, 458 CONFIG_BOOTSTAGE_STASH_SIZE); 459 if (ret) 460 debug("Failed to stash bootstage: err=%d\n", ret); 461 #endif 462 463 debug("loaded - jumping to U-Boot...\n"); 464 spl_board_prepare_for_boot(); 465 jump_to_image_no_args(&spl_image); 466 } 467 468 /* 469 * This requires UART clocks to be enabled. In order for this to work the 470 * caller must ensure that the gd pointer is valid. 471 */ 472 void preloader_console_init(void) 473 { 474 gd->baudrate = CONFIG_BAUDRATE; 475 476 serial_init(); /* serial communications setup */ 477 478 gd->have_console = 1; 479 480 puts("\nU-Boot SPL " PLAIN_VERSION " (" U_BOOT_DATE " - " \ 481 U_BOOT_TIME ")\n"); 482 #ifdef CONFIG_SPL_DISPLAY_PRINT 483 spl_display_print(); 484 #endif 485 } 486 487 /** 488 * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution 489 * 490 * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM 491 * for the main board_init_r() execution. This is typically because we need 492 * more stack space for things like the MMC sub-system. 493 * 494 * This function calculates the stack position, copies the global_data into 495 * place, sets the new gd (except for ARM, for which setting GD within a C 496 * function may not always work) and returns the new stack position. The 497 * caller is responsible for setting up the sp register and, in the case 498 * of ARM, setting up gd. 499 * 500 * All of this is done using the same layout and alignments as done in 501 * board_init_f_init_reserve() / board_init_f_alloc_reserve(). 502 * 503 * @return new stack location, or 0 to use the same stack 504 */ 505 ulong spl_relocate_stack_gd(void) 506 { 507 #ifdef CONFIG_SPL_STACK_R 508 gd_t *new_gd; 509 ulong ptr = CONFIG_SPL_STACK_R_ADDR; 510 511 #if defined(CONFIG_SPL_SYS_MALLOC_SIMPLE) && CONFIG_VAL(SYS_MALLOC_F_LEN) 512 if (CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN) { 513 ptr -= CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN; 514 gd->malloc_base = ptr; 515 gd->malloc_limit = CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN; 516 gd->malloc_ptr = 0; 517 } 518 #endif 519 /* Get stack position: use 8-byte alignment for ABI compliance */ 520 ptr = CONFIG_SPL_STACK_R_ADDR - roundup(sizeof(gd_t),16); 521 new_gd = (gd_t *)ptr; 522 memcpy(new_gd, (void *)gd, sizeof(gd_t)); 523 #if CONFIG_IS_ENABLED(DM) 524 dm_fixup_for_gd_move(new_gd); 525 #endif 526 #if !defined(CONFIG_ARM) 527 gd = new_gd; 528 #endif 529 return ptr; 530 #else 531 return 0; 532 #endif 533 } 534