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