1 /* 2 * Copyright (c) 2013, Google Inc. 3 * 4 * (C) Copyright 2008 Semihalf 5 * 6 * (C) Copyright 2000-2006 7 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 8 * 9 * SPDX-License-Identifier: GPL-2.0+ 10 */ 11 12 #include <common.h> 13 #include <fdt_support.h> 14 #include <errno.h> 15 #include <image.h> 16 #include <linux/libfdt.h> 17 #include <mapmem.h> 18 #include <asm/io.h> 19 20 #ifndef CONFIG_SYS_FDT_PAD 21 #define CONFIG_SYS_FDT_PAD 0x3000 22 #endif 23 24 DECLARE_GLOBAL_DATA_PTR; 25 26 static void fdt_error(const char *msg) 27 { 28 puts("ERROR: "); 29 puts(msg); 30 puts(" - must RESET the board to recover.\n"); 31 } 32 33 #if defined(CONFIG_IMAGE_FORMAT_LEGACY) 34 static const image_header_t *image_get_fdt(ulong fdt_addr) 35 { 36 const image_header_t *fdt_hdr = map_sysmem(fdt_addr, 0); 37 38 image_print_contents(fdt_hdr); 39 40 puts(" Verifying Checksum ... "); 41 if (!image_check_hcrc(fdt_hdr)) { 42 fdt_error("fdt header checksum invalid"); 43 return NULL; 44 } 45 46 if (!image_check_dcrc(fdt_hdr)) { 47 fdt_error("fdt checksum invalid"); 48 return NULL; 49 } 50 puts("OK\n"); 51 52 if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) { 53 fdt_error("uImage is not a fdt"); 54 return NULL; 55 } 56 if (image_get_comp(fdt_hdr) != IH_COMP_NONE) { 57 fdt_error("uImage is compressed"); 58 return NULL; 59 } 60 if (fdt_check_header((void *)image_get_data(fdt_hdr)) != 0) { 61 fdt_error("uImage data is not a fdt"); 62 return NULL; 63 } 64 return fdt_hdr; 65 } 66 #endif 67 68 /** 69 * boot_fdt_add_mem_rsv_regions - Mark the memreserve sections as unusable 70 * @lmb: pointer to lmb handle, will be used for memory mgmt 71 * @fdt_blob: pointer to fdt blob base address 72 * 73 * Adds the memreserve regions in the dtb to the lmb block. Adding the 74 * memreserve regions prevents u-boot from using them to store the initrd 75 * or the fdt blob. 76 */ 77 void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob) 78 { 79 uint64_t addr, size; 80 int i, total; 81 82 if (fdt_check_header(fdt_blob) != 0) 83 return; 84 85 total = fdt_num_mem_rsv(fdt_blob); 86 for (i = 0; i < total; i++) { 87 if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0) 88 continue; 89 printf(" reserving fdt memory region: addr=%llx size=%llx\n", 90 (unsigned long long)addr, (unsigned long long)size); 91 lmb_reserve(lmb, addr, size); 92 } 93 } 94 95 /** 96 * boot_relocate_fdt - relocate flat device tree 97 * @lmb: pointer to lmb handle, will be used for memory mgmt 98 * @of_flat_tree: pointer to a char* variable, will hold fdt start address 99 * @of_size: pointer to a ulong variable, will hold fdt length 100 * 101 * boot_relocate_fdt() allocates a region of memory within the bootmap and 102 * relocates the of_flat_tree into that region, even if the fdt is already in 103 * the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD 104 * bytes. 105 * 106 * of_flat_tree and of_size are set to final (after relocation) values 107 * 108 * returns: 109 * 0 - success 110 * 1 - failure 111 */ 112 int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size) 113 { 114 void *fdt_blob = *of_flat_tree; 115 void *of_start = NULL; 116 char *fdt_high; 117 ulong of_len = 0; 118 int err; 119 int disable_relocation = 0; 120 121 /* nothing to do */ 122 if (*of_size == 0) 123 return 0; 124 125 if (fdt_check_header(fdt_blob) != 0) { 126 fdt_error("image is not a fdt"); 127 goto error; 128 } 129 130 /* position on a 4K boundary before the alloc_current */ 131 /* Pad the FDT by a specified amount */ 132 of_len = *of_size + CONFIG_SYS_FDT_PAD; 133 134 /* If fdt_high is set use it to select the relocation address */ 135 fdt_high = env_get("fdt_high"); 136 if (fdt_high) { 137 void *desired_addr = (void *)simple_strtoul(fdt_high, NULL, 16); 138 139 if (((ulong) desired_addr) == ~0UL) { 140 /* All ones means use fdt in place */ 141 of_start = fdt_blob; 142 lmb_reserve(lmb, (ulong)of_start, of_len); 143 disable_relocation = 1; 144 } else if (desired_addr) { 145 of_start = 146 (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000, 147 (ulong)desired_addr); 148 if (of_start == NULL) { 149 puts("Failed using fdt_high value for Device Tree"); 150 goto error; 151 } 152 } else { 153 of_start = 154 (void *)(ulong) lmb_alloc(lmb, of_len, 0x1000); 155 } 156 } else { 157 of_start = 158 (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000, 159 env_get_bootm_mapsize() 160 + env_get_bootm_low()); 161 } 162 163 if (of_start == NULL) { 164 puts("device tree - allocation error\n"); 165 goto error; 166 } 167 168 if (disable_relocation) { 169 /* 170 * We assume there is space after the existing fdt to use 171 * for padding 172 */ 173 fdt_set_totalsize(of_start, of_len); 174 printf(" Using Device Tree in place at %p, end %p\n", 175 of_start, of_start + of_len - 1); 176 } else { 177 debug("## device tree at %p ... %p (len=%ld [0x%lX])\n", 178 fdt_blob, fdt_blob + *of_size - 1, of_len, of_len); 179 180 printf(" Loading Device Tree to %p, end %p ... ", 181 of_start, of_start + of_len - 1); 182 183 err = fdt_open_into(fdt_blob, of_start, of_len); 184 if (err != 0) { 185 fdt_error("fdt move failed"); 186 goto error; 187 } 188 puts("OK\n"); 189 } 190 191 *of_flat_tree = of_start; 192 *of_size = of_len; 193 194 set_working_fdt_addr((ulong)*of_flat_tree); 195 return 0; 196 197 error: 198 return 1; 199 } 200 201 /** 202 * boot_get_fdt - main fdt handling routine 203 * @argc: command argument count 204 * @argv: command argument list 205 * @arch: architecture (IH_ARCH_...) 206 * @images: pointer to the bootm images structure 207 * @of_flat_tree: pointer to a char* variable, will hold fdt start address 208 * @of_size: pointer to a ulong variable, will hold fdt length 209 * 210 * boot_get_fdt() is responsible for finding a valid flat device tree image. 211 * Curently supported are the following ramdisk sources: 212 * - multicomponent kernel/ramdisk image, 213 * - commandline provided address of decicated ramdisk image. 214 * 215 * returns: 216 * 0, if fdt image was found and valid, or skipped 217 * of_flat_tree and of_size are set to fdt start address and length if 218 * fdt image is found and valid 219 * 220 * 1, if fdt image is found but corrupted 221 * of_flat_tree and of_size are set to 0 if no fdt exists 222 */ 223 int boot_get_fdt(int flag, int argc, char * const argv[], uint8_t arch, 224 bootm_headers_t *images, char **of_flat_tree, ulong *of_size) 225 { 226 #if defined(CONFIG_IMAGE_FORMAT_LEGACY) 227 const image_header_t *fdt_hdr; 228 ulong load, load_end; 229 ulong image_start, image_data, image_end; 230 #endif 231 ulong fdt_addr; 232 char *fdt_blob = NULL; 233 void *buf; 234 #if CONFIG_IS_ENABLED(FIT) 235 const char *fit_uname_config = images->fit_uname_cfg; 236 const char *fit_uname_fdt = NULL; 237 ulong default_addr; 238 int fdt_noffset; 239 #endif 240 const char *select = NULL; 241 int ok_no_fdt = 0; 242 243 *of_flat_tree = NULL; 244 *of_size = 0; 245 246 if (argc > 2) 247 select = argv[2]; 248 if (select || genimg_has_config(images)) { 249 #if CONFIG_IS_ENABLED(FIT) 250 if (select) { 251 /* 252 * If the FDT blob comes from the FIT image and the 253 * FIT image address is omitted in the command line 254 * argument, try to use ramdisk or os FIT image 255 * address or default load address. 256 */ 257 if (images->fit_uname_rd) 258 default_addr = (ulong)images->fit_hdr_rd; 259 else if (images->fit_uname_os) 260 default_addr = (ulong)images->fit_hdr_os; 261 else 262 default_addr = load_addr; 263 264 if (fit_parse_conf(select, default_addr, 265 &fdt_addr, &fit_uname_config)) { 266 debug("* fdt: config '%s' from image at 0x%08lx\n", 267 fit_uname_config, fdt_addr); 268 } else if (fit_parse_subimage(select, default_addr, 269 &fdt_addr, &fit_uname_fdt)) { 270 debug("* fdt: subimage '%s' from image at 0x%08lx\n", 271 fit_uname_fdt, fdt_addr); 272 } else 273 #endif 274 { 275 fdt_addr = simple_strtoul(select, NULL, 16); 276 debug("* fdt: cmdline image address = 0x%08lx\n", 277 fdt_addr); 278 } 279 #if CONFIG_IS_ENABLED(FIT) 280 } else { 281 /* use FIT configuration provided in first bootm 282 * command argument 283 */ 284 fdt_addr = map_to_sysmem(images->fit_hdr_os); 285 fdt_noffset = fit_get_node_from_config(images, 286 FIT_FDT_PROP, 287 fdt_addr); 288 if (fdt_noffset == -ENOENT) 289 return 0; 290 else if (fdt_noffset < 0) 291 return 1; 292 } 293 #endif 294 debug("## Checking for 'FDT'/'FDT Image' at %08lx\n", 295 fdt_addr); 296 297 /* 298 * Check if there is an FDT image at the 299 * address provided in the second bootm argument 300 * check image type, for FIT images get a FIT node. 301 */ 302 buf = map_sysmem(fdt_addr, 0); 303 switch (genimg_get_format(buf)) { 304 #if defined(CONFIG_IMAGE_FORMAT_LEGACY) 305 case IMAGE_FORMAT_LEGACY: 306 /* verify fdt_addr points to a valid image header */ 307 printf("## Flattened Device Tree from Legacy Image at %08lx\n", 308 fdt_addr); 309 fdt_hdr = image_get_fdt(fdt_addr); 310 if (!fdt_hdr) 311 goto no_fdt; 312 313 /* 314 * move image data to the load address, 315 * make sure we don't overwrite initial image 316 */ 317 image_start = (ulong)fdt_hdr; 318 image_data = (ulong)image_get_data(fdt_hdr); 319 image_end = image_get_image_end(fdt_hdr); 320 321 load = image_get_load(fdt_hdr); 322 load_end = load + image_get_data_size(fdt_hdr); 323 324 if (load == image_start || 325 load == image_data) { 326 fdt_addr = load; 327 break; 328 } 329 330 if ((load < image_end) && (load_end > image_start)) { 331 fdt_error("fdt overwritten"); 332 goto error; 333 } 334 335 debug(" Loading FDT from 0x%08lx to 0x%08lx\n", 336 image_data, load); 337 338 memmove((void *)load, 339 (void *)image_data, 340 image_get_data_size(fdt_hdr)); 341 342 fdt_addr = load; 343 break; 344 #endif 345 case IMAGE_FORMAT_FIT: 346 /* 347 * This case will catch both: new uImage format 348 * (libfdt based) and raw FDT blob (also libfdt 349 * based). 350 */ 351 #if CONFIG_IS_ENABLED(FIT) 352 /* check FDT blob vs FIT blob */ 353 if (fit_check_format(buf)) { 354 ulong load, len; 355 356 fdt_noffset = boot_get_fdt_fit(images, 357 fdt_addr, &fit_uname_fdt, 358 &fit_uname_config, 359 arch, &load, &len); 360 361 images->fit_hdr_fdt = map_sysmem(fdt_addr, 0); 362 images->fit_uname_fdt = fit_uname_fdt; 363 images->fit_noffset_fdt = fdt_noffset; 364 fdt_addr = load; 365 366 break; 367 } else 368 #endif 369 { 370 /* 371 * FDT blob 372 */ 373 debug("* fdt: raw FDT blob\n"); 374 printf("## Flattened Device Tree blob at %08lx\n", 375 (long)fdt_addr); 376 } 377 break; 378 default: 379 puts("ERROR: Did not find a cmdline Flattened Device Tree\n"); 380 goto no_fdt; 381 } 382 383 printf(" Booting using the fdt blob at %#08lx\n", fdt_addr); 384 fdt_blob = map_sysmem(fdt_addr, 0); 385 } else if (images->legacy_hdr_valid && 386 image_check_type(&images->legacy_hdr_os_copy, 387 IH_TYPE_MULTI)) { 388 ulong fdt_data, fdt_len; 389 390 /* 391 * Now check if we have a legacy multi-component image, 392 * get second entry data start address and len. 393 */ 394 printf("## Flattened Device Tree from multi component Image at %08lX\n", 395 (ulong)images->legacy_hdr_os); 396 397 image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data, 398 &fdt_len); 399 if (fdt_len) { 400 fdt_blob = (char *)fdt_data; 401 printf(" Booting using the fdt at 0x%p\n", fdt_blob); 402 403 if (fdt_check_header(fdt_blob) != 0) { 404 fdt_error("image is not a fdt"); 405 goto error; 406 } 407 408 if (fdt_totalsize(fdt_blob) != fdt_len) { 409 fdt_error("fdt size != image size"); 410 goto error; 411 } 412 } else { 413 debug("## No Flattened Device Tree\n"); 414 goto no_fdt; 415 } 416 } else { 417 debug("## No Flattened Device Tree\n"); 418 goto no_fdt; 419 } 420 421 *of_flat_tree = fdt_blob; 422 *of_size = fdt_totalsize(fdt_blob); 423 debug(" of_flat_tree at 0x%08lx size 0x%08lx\n", 424 (ulong)*of_flat_tree, *of_size); 425 426 return 0; 427 428 no_fdt: 429 ok_no_fdt = 1; 430 error: 431 *of_flat_tree = NULL; 432 *of_size = 0; 433 if (!select && ok_no_fdt) { 434 debug("Continuing to boot without FDT\n"); 435 return 0; 436 } 437 return 1; 438 } 439 440 /* 441 * Verify the device tree. 442 * 443 * This function is called after all device tree fix-ups have been enacted, 444 * so that the final device tree can be verified. The definition of "verified" 445 * is up to the specific implementation. However, it generally means that the 446 * addresses of some of the devices in the device tree are compared with the 447 * actual addresses at which U-Boot has placed them. 448 * 449 * Returns 1 on success, 0 on failure. If 0 is returned, U-Boot will halt the 450 * boot process. 451 */ 452 __weak int ft_verify_fdt(void *fdt) 453 { 454 return 1; 455 } 456 457 __weak int arch_fixup_fdt(void *blob) 458 { 459 return 0; 460 } 461 462 int image_setup_libfdt(bootm_headers_t *images, void *blob, 463 int of_size, struct lmb *lmb) 464 { 465 ulong *initrd_start = &images->initrd_start; 466 ulong *initrd_end = &images->initrd_end; 467 int ret = -EPERM; 468 int fdt_ret; 469 470 if (fdt_root(blob) < 0) { 471 printf("ERROR: root node setup failed\n"); 472 goto err; 473 } 474 if (fdt_chosen(blob) < 0) { 475 printf("ERROR: /chosen node create failed\n"); 476 goto err; 477 } 478 if (arch_fixup_fdt(blob) < 0) { 479 printf("ERROR: arch-specific fdt fixup failed\n"); 480 goto err; 481 } 482 /* Update ethernet nodes */ 483 fdt_fixup_ethernet(blob); 484 if (IMAGE_OF_BOARD_SETUP) { 485 fdt_ret = ft_board_setup(blob, gd->bd); 486 if (fdt_ret) { 487 printf("ERROR: board-specific fdt fixup failed: %s\n", 488 fdt_strerror(fdt_ret)); 489 goto err; 490 } 491 } 492 if (IMAGE_OF_SYSTEM_SETUP) { 493 fdt_ret = ft_system_setup(blob, gd->bd); 494 if (fdt_ret) { 495 printf("ERROR: system-specific fdt fixup failed: %s\n", 496 fdt_strerror(fdt_ret)); 497 goto err; 498 } 499 } 500 501 /* Delete the old LMB reservation */ 502 if (lmb) 503 lmb_free(lmb, (phys_addr_t)(u32)(uintptr_t)blob, 504 (phys_size_t)fdt_totalsize(blob)); 505 506 ret = fdt_shrink_to_minimum(blob, 0); 507 if (ret < 0) 508 goto err; 509 of_size = ret; 510 511 if (*initrd_start && *initrd_end) { 512 of_size += FDT_RAMDISK_OVERHEAD; 513 fdt_set_totalsize(blob, of_size); 514 } 515 /* Create a new LMB reservation */ 516 if (lmb) 517 lmb_reserve(lmb, (ulong)blob, of_size); 518 519 fdt_initrd(blob, *initrd_start, *initrd_end); 520 if (!ft_verify_fdt(blob)) 521 goto err; 522 523 #if defined(CONFIG_SOC_KEYSTONE) 524 if (IMAGE_OF_BOARD_SETUP) 525 ft_board_setup_ex(blob, gd->bd); 526 #endif 527 528 return 0; 529 err: 530 printf(" - must RESET the board to recover.\n\n"); 531 532 return ret; 533 } 534