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