boot/image-fdt.c

   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 <env.h>
  15 #include <errno.h>
  16 #include <image.h>
  17 #include <lmb.h>
  18 #include <log.h>
  19 #include <malloc.h>
  20 #include <asm/global_data.h>
  21 #include <linux/libfdt.h>
  22 #include <mapmem.h>
  23 #include <asm/io.h>
  24 #include <dm/ofnode.h>
  25 #include <tee/optee.h>
  26
  27 #ifndef CONFIG_SYS_FDT_PAD
  28 #define CONFIG_SYS_FDT_PAD 0x3000
  29 #endif
  30
  31 /* adding a ramdisk needs 0x44 bytes in version 2008.10 */
  32 #define FDT_RAMDISK_OVERHEAD    0x80
  33
  34 DECLARE_GLOBAL_DATA_PTR;
  35
  36 static void fdt_error(const char *msg)
  37 {
  38         puts("ERROR: ");
  39         puts(msg);
  40         puts(" - must RESET the board to recover.\n");
  41 }
  42
  43 #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
  44 static const image_header_t *image_get_fdt(ulong fdt_addr)
  45 {
  46         const image_header_t *fdt_hdr = map_sysmem(fdt_addr, 0);
  47
  48         image_print_contents(fdt_hdr);
  49
  50         puts("   Verifying Checksum ... ");
  51         if (!image_check_hcrc(fdt_hdr)) {
  52                 fdt_error("fdt header checksum invalid");
  53                 return NULL;
  54         }
  55
  56         if (!image_check_dcrc(fdt_hdr)) {
  57                 fdt_error("fdt checksum invalid");
  58                 return NULL;
  59         }
  60         puts("OK\n");
  61
  62         if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
  63                 fdt_error("uImage is not a fdt");
  64                 return NULL;
  65         }
  66         if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
  67                 fdt_error("uImage is compressed");
  68                 return NULL;
  69         }
  70         if (fdt_check_header((void *)image_get_data(fdt_hdr)) != 0) {
  71                 fdt_error("uImage data is not a fdt");
  72                 return NULL;
  73         }
  74         return fdt_hdr;
  75 }
  76 #endif
  77
  78 static void boot_fdt_reserve_region(struct lmb *lmb, uint64_t addr,
  79                                     uint64_t size, enum lmb_flags flags)
  80 {
  81         long ret;
  82
  83         ret = lmb_reserve_flags(lmb, addr, size, flags);
  84         if (ret >= 0) {
  85                 debug("   reserving fdt memory region: addr=%llx size=%llx flags=%x\n",
  86                       (unsigned long long)addr,
  87                       (unsigned long long)size, flags);
  88         } else {
  89                 puts("ERROR: reserving fdt memory region failed ");
  90                 printf("(addr=%llx size=%llx flags=%x)\n",
  91                        (unsigned long long)addr,
  92                        (unsigned long long)size, flags);
  93         }
  94 }
  95
  96 /**
  97  * boot_fdt_add_mem_rsv_regions - Mark the memreserve and reserved-memory
  98  * sections as unusable
  99  * @lmb: pointer to lmb handle, will be used for memory mgmt
 100  * @fdt_blob: pointer to fdt blob base address
 101  *
 102  * Adds the and reserved-memorymemreserve regions in the dtb to the lmb block.
 103  * Adding the memreserve regions prevents u-boot from using them to store the
 104  * initrd or the fdt blob.
 105  */
 106 void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob)
 107 {
 108         uint64_t addr, size;
 109         int i, total, ret;
 110         int nodeoffset, subnode;
 111         struct fdt_resource res;
 112         enum lmb_flags flags;
 113
 114         if (fdt_check_header(fdt_blob) != 0)
 115                 return;
 116
 117         /* process memreserve sections */
 118         total = fdt_num_mem_rsv(fdt_blob);
 119         for (i = 0; i < total; i++) {
 120                 if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
 121                         continue;
 122                 boot_fdt_reserve_region(lmb, addr, size, LMB_NONE);
 123         }
 124
 125         /* process reserved-memory */
 126         nodeoffset = fdt_subnode_offset(fdt_blob, 0, "reserved-memory");
 127         if (nodeoffset >= 0) {
 128                 subnode = fdt_first_subnode(fdt_blob, nodeoffset);
 129                 while (subnode >= 0) {
 130                         /* check if this subnode has a reg property */
 131                         ret = fdt_get_resource(fdt_blob, subnode, "reg", 0,
 132                                                &res);
 133                         if (!ret && fdtdec_get_is_enabled(fdt_blob, subnode)) {
 134                                 flags = LMB_NONE;
 135                                 if (fdtdec_get_bool(fdt_blob, subnode,
 136                                                     "no-map"))
 137                                         flags = LMB_NOMAP;
 138                                 addr = res.start;
 139                                 size = res.end - res.start + 1;
 140                                 boot_fdt_reserve_region(lmb, addr, size, flags);
 141                         }
 142
 143                         subnode = fdt_next_subnode(fdt_blob, subnode);
 144                 }
 145         }
 146 }
 147
 148 /**
 149  * boot_relocate_fdt - relocate flat device tree
 150  * @lmb: pointer to lmb handle, will be used for memory mgmt
 151  * @of_flat_tree: pointer to a char* variable, will hold fdt start address
 152  * @of_size: pointer to a ulong variable, will hold fdt length
 153  *
 154  * boot_relocate_fdt() allocates a region of memory within the bootmap and
 155  * relocates the of_flat_tree into that region, even if the fdt is already in
 156  * the bootmap.  It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
 157  * bytes.
 158  *
 159  * of_flat_tree and of_size are set to final (after relocation) values
 160  *
 161  * returns:
 162  *      0 - success
 163  *      1 - failure
 164  */
 165 int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
 166 {
 167         void    *fdt_blob = *of_flat_tree;
 168         void    *of_start = NULL;
 169         u64     start, size, usable;
 170         char    *fdt_high;
 171         ulong   mapsize, low;
 172         ulong   of_len = 0;
 173         int     bank;
 174         int     err;
 175         int     disable_relocation = 0;
 176
 177         /* nothing to do */
 178         if (*of_size == 0)
 179                 return 0;
 180
 181         if (fdt_check_header(fdt_blob) != 0) {
 182                 fdt_error("image is not a fdt");
 183                 goto error;
 184         }
 185
 186         /* position on a 4K boundary before the alloc_current */
 187         /* Pad the FDT by a specified amount */
 188         of_len = *of_size + CONFIG_SYS_FDT_PAD;
 189
 190         /* If fdt_high is set use it to select the relocation address */
 191         fdt_high = env_get("fdt_high");
 192         if (fdt_high) {
 193                 void *desired_addr = (void *)hextoul(fdt_high, NULL);
 194
 195                 if (((ulong) desired_addr) == ~0UL) {
 196                         /* All ones means use fdt in place */
 197                         of_start = fdt_blob;
 198                         lmb_reserve(lmb, (ulong)of_start, of_len);
 199                         disable_relocation = 1;
 200                 } else if (desired_addr) {
 201                         of_start =
 202                             (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
 203                                                            (ulong)desired_addr);
 204                         if (of_start == NULL) {
 205                                 puts("Failed using fdt_high value for Device Tree");
 206                                 goto error;
 207                         }
 208                 } else {
 209                         of_start =
 210                             (void *)(ulong) lmb_alloc(lmb, of_len, 0x1000);
 211                 }
 212         } else {
 213                 mapsize = env_get_bootm_mapsize();
 214                 low = env_get_bootm_low();
 215                 of_start = NULL;
 216
 217                 for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
 218                         start = gd->bd->bi_dram[bank].start;
 219                         size = gd->bd->bi_dram[bank].size;
 220
 221                         /* DRAM bank addresses are too low, skip it. */
 222                         if (start + size < low)
 223                                 continue;
 224
 225                         usable = min(size, (u64)mapsize);
 226
 227                         /*
 228                          * At least part of this DRAM bank is usable, try
 229                          * using it for LMB allocation.
 230                          */
 231                         of_start =
 232                             (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
 233                                                            start + usable);
 234                         /* Allocation succeeded, use this block. */
 235                         if (of_start != NULL)
 236                                 break;
 237
 238                         /*
 239                          * Reduce the mapping size in the next bank
 240                          * by the size of attempt in current bank.
 241                          */
 242                         mapsize -= usable - max(start, (u64)low);
 243                         if (!mapsize)
 244                                 break;
 245                 }
 246         }
 247
 248         if (of_start == NULL) {
 249                 puts("device tree - allocation error\n");
 250                 goto error;
 251         }
 252
 253         if (disable_relocation) {
 254                 /*
 255                  * We assume there is space after the existing fdt to use
 256                  * for padding
 257                  */
 258                 fdt_set_totalsize(of_start, of_len);
 259                 printf("   Using Device Tree in place at %p, end %p\n",
 260                        of_start, of_start + of_len - 1);
 261         } else {
 262                 debug("## device tree at %p ... %p (len=%ld [0x%lX])\n",
 263                       fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
 264
 265                 printf("   Loading Device Tree to %p, end %p ... ",
 266                        of_start, of_start + of_len - 1);
 267
 268                 err = fdt_open_into(fdt_blob, of_start, of_len);
 269                 if (err != 0) {
 270                         fdt_error("fdt move failed");
 271                         goto error;
 272                 }
 273                 puts("OK\n");
 274         }
 275
 276         *of_flat_tree = of_start;
 277         *of_size = of_len;
 278
 279         if (CONFIG_IS_ENABLED(CMD_FDT))
 280                 set_working_fdt_addr(map_to_sysmem(*of_flat_tree));
 281         return 0;
 282
 283 error:
 284         return 1;
 285 }
 286
 287 /**
 288  * select_fdt() - Select and locate the FDT to use
 289  *
 290  * @images: pointer to the bootm images structure
 291  * @select: name of FDT to select, or NULL for any
 292  * @arch: expected FDT architecture
 293  * @fdt_addrp: pointer to a ulong variable, will hold FDT pointer
 294  * Return: 0 if OK, -ENOPKG if no FDT (but an error should not be reported),
 295  *      other -ve value on other error
 296  */
 297
 298 static int select_fdt(bootm_headers_t *images, const char *select, u8 arch,
 299                       ulong *fdt_addrp)
 300 {
 301         const char *buf;
 302         ulong fdt_addr;
 303
 304 #if CONFIG_IS_ENABLED(FIT)
 305         const char *fit_uname_config = images->fit_uname_cfg;
 306         const char *fit_uname_fdt = NULL;
 307         ulong default_addr;
 308         int fdt_noffset;
 309
 310         if (select) {
 311                         /*
 312                          * If the FDT blob comes from the FIT image and the
 313                          * FIT image address is omitted in the command line
 314                          * argument, try to use ramdisk or os FIT image
 315                          * address or default load address.
 316                          */
 317                         if (images->fit_uname_rd)
 318                                 default_addr = (ulong)images->fit_hdr_rd;
 319                         else if (images->fit_uname_os)
 320                                 default_addr = (ulong)images->fit_hdr_os;
 321                         else
 322                                 default_addr = image_load_addr;
 323
 324                         if (fit_parse_conf(select, default_addr, &fdt_addr,
 325                                            &fit_uname_config)) {
 326                                 debug("*  fdt: config '%s' from image at 0x%08lx\n",
 327                                       fit_uname_config, fdt_addr);
 328                         } else if (fit_parse_subimage(select, default_addr, &fdt_addr,
 329                                    &fit_uname_fdt)) {
 330                                 debug("*  fdt: subimage '%s' from image at 0x%08lx\n",
 331                                       fit_uname_fdt, fdt_addr);
 332                         } else
 333 #endif
 334                 {
 335                         fdt_addr = hextoul(select, NULL);
 336                         debug("*  fdt: cmdline image address = 0x%08lx\n",
 337                               fdt_addr);
 338                 }
 339 #if CONFIG_IS_ENABLED(FIT)
 340         } else {
 341                 /* use FIT configuration provided in first bootm
 342                  * command argument
 343                  */
 344                 fdt_addr = map_to_sysmem(images->fit_hdr_os);
 345                 fdt_noffset = fit_get_node_from_config(images, FIT_FDT_PROP,
 346                                                        fdt_addr);
 347                 if (fdt_noffset == -ENOENT)
 348                         return -ENOPKG;
 349                 else if (fdt_noffset < 0)
 350                         return fdt_noffset;
 351         }
 352 #endif
 353         debug("## Checking for 'FDT'/'FDT Image' at %08lx\n",
 354               fdt_addr);
 355
 356         /*
 357          * Check if there is an FDT image at the
 358          * address provided in the second bootm argument
 359          * check image type, for FIT images get a FIT node.
 360          */
 361         buf = map_sysmem(fdt_addr, 0);
 362         switch (genimg_get_format(buf)) {
 363 #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
 364         case IMAGE_FORMAT_LEGACY: {
 365                         const image_header_t *fdt_hdr;
 366                         ulong load, load_end;
 367                         ulong image_start, image_data, image_end;
 368
 369                         /* verify fdt_addr points to a valid image header */
 370                         printf("## Flattened Device Tree from Legacy Image at %08lx\n",
 371                                fdt_addr);
 372                         fdt_hdr = image_get_fdt(fdt_addr);
 373                         if (!fdt_hdr)
 374                                 return -ENOPKG;
 375
 376                         /*
 377                          * move image data to the load address,
 378                          * make sure we don't overwrite initial image
 379                          */
 380                         image_start = (ulong)fdt_hdr;
 381                         image_data = (ulong)image_get_data(fdt_hdr);
 382                         image_end = image_get_image_end(fdt_hdr);
 383
 384                         load = image_get_load(fdt_hdr);
 385                         load_end = load + image_get_data_size(fdt_hdr);
 386
 387                         if (load == image_start ||
 388                             load == image_data) {
 389                                 fdt_addr = load;
 390                                 break;
 391                         }
 392
 393                         if ((load < image_end) && (load_end > image_start)) {
 394                                 fdt_error("fdt overwritten");
 395                                 return -EFAULT;
 396                         }
 397
 398                         debug("   Loading FDT from 0x%08lx to 0x%08lx\n",
 399                               image_data, load);
 400
 401                         memmove((void *)load,
 402                                 (void *)image_data,
 403                                 image_get_data_size(fdt_hdr));
 404
 405                         fdt_addr = load;
 406                         break;
 407                 }
 408 #endif
 409         case IMAGE_FORMAT_FIT:
 410                 /*
 411                  * This case will catch both: new uImage format
 412                  * (libfdt based) and raw FDT blob (also libfdt
 413                  * based).
 414                  */
 415 #if CONFIG_IS_ENABLED(FIT)
 416                         /* check FDT blob vs FIT blob */
 417                         if (!fit_check_format(buf, IMAGE_SIZE_INVAL)) {
 418                                 ulong load, len;
 419
 420                                 fdt_noffset = boot_get_fdt_fit(images, fdt_addr,
 421                                                                &fit_uname_fdt,
 422                                                                &fit_uname_config,
 423                                                                arch, &load, &len);
 424
 425                                 if (fdt_noffset < 0)
 426                                         return -ENOENT;
 427
 428                                 images->fit_hdr_fdt = map_sysmem(fdt_addr, 0);
 429                                 images->fit_uname_fdt = fit_uname_fdt;
 430                                 images->fit_noffset_fdt = fdt_noffset;
 431                                 fdt_addr = load;
 432
 433                                 break;
 434                 } else
 435 #endif
 436                 {
 437                         /*
 438                          * FDT blob
 439                          */
 440                         debug("*  fdt: raw FDT blob\n");
 441                         printf("## Flattened Device Tree blob at %08lx\n",
 442                                (long)fdt_addr);
 443                 }
 444                 break;
 445         default:
 446                 puts("ERROR: Did not find a cmdline Flattened Device Tree\n");
 447                 return -ENOENT;
 448         }
 449         *fdt_addrp = fdt_addr;
 450
 451         return 0;
 452 }
 453
 454 /**
 455  * boot_get_fdt - main fdt handling routine
 456  * @argc: command argument count
 457  * @argv: command argument list
 458  * @arch: architecture (IH_ARCH_...)
 459  * @images: pointer to the bootm images structure
 460  * @of_flat_tree: pointer to a char* variable, will hold fdt start address
 461  * @of_size: pointer to a ulong variable, will hold fdt length
 462  *
 463  * boot_get_fdt() is responsible for finding a valid flat device tree image.
 464  * Currently supported are the following ramdisk sources:
 465  *      - multicomponent kernel/ramdisk image,
 466  *      - commandline provided address of decicated ramdisk image.
 467  *
 468  * returns:
 469  *     0, if fdt image was found and valid, or skipped
 470  *     of_flat_tree and of_size are set to fdt start address and length if
 471  *     fdt image is found and valid
 472  *
 473  *     1, if fdt image is found but corrupted
 474  *     of_flat_tree and of_size are set to 0 if no fdt exists
 475  */
 476 int boot_get_fdt(int flag, int argc, char *const argv[], uint8_t arch,
 477                  bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
 478 {
 479         ulong           img_addr;
 480         ulong           fdt_addr;
 481         char            *fdt_blob = NULL;
 482         void            *buf;
 483         const char *select = NULL;
 484
 485         *of_flat_tree = NULL;
 486         *of_size = 0;
 487
 488         img_addr = (argc == 0) ? image_load_addr : hextoul(argv[0], NULL);
 489         buf = map_sysmem(img_addr, 0);
 490
 491         if (argc > 2)
 492                 select = argv[2];
 493         if (select || genimg_has_config(images)) {
 494                 int ret;
 495
 496                 ret = select_fdt(images, select, arch, &fdt_addr);
 497                 if (ret == -ENOPKG)
 498                         goto no_fdt;
 499                 else if (ret)
 500                         return 1;
 501                 printf("   Booting using the fdt blob at %#08lx\n", fdt_addr);
 502                 fdt_blob = map_sysmem(fdt_addr, 0);
 503         } else if (images->legacy_hdr_valid &&
 504                         image_check_type(&images->legacy_hdr_os_copy,
 505                                          IH_TYPE_MULTI)) {
 506                 ulong fdt_data, fdt_len;
 507
 508                 /*
 509                  * Now check if we have a legacy multi-component image,
 510                  * get second entry data start address and len.
 511                  */
 512                 printf("## Flattened Device Tree from multi component Image at %08lX\n",
 513                        (ulong)images->legacy_hdr_os);
 514
 515                 image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
 516                                    &fdt_len);
 517                 if (fdt_len) {
 518                         fdt_blob = (char *)fdt_data;
 519                         printf("   Booting using the fdt at 0x%p\n", fdt_blob);
 520
 521                         if (fdt_check_header(fdt_blob) != 0) {
 522                                 fdt_error("image is not a fdt");
 523                                 goto error;
 524                         }
 525
 526                         if (fdt_totalsize(fdt_blob) != fdt_len) {
 527                                 fdt_error("fdt size != image size");
 528                                 goto error;
 529                         }
 530                 } else {
 531                         debug("## No Flattened Device Tree\n");
 532                         goto no_fdt;
 533                 }
 534 #ifdef CONFIG_ANDROID_BOOT_IMAGE
 535         } else if (genimg_get_format(buf) == IMAGE_FORMAT_ANDROID) {
 536                 struct andr_img_hdr *hdr = buf;
 537                 ulong           fdt_data, fdt_len;
 538                 u32                     fdt_size, dtb_idx;
 539                 /*
 540                  * Firstly check if this android boot image has dtb field.
 541                  */
 542                 dtb_idx = (u32)env_get_ulong("adtb_idx", 10, 0);
 543                 if (android_image_get_dtb_by_index((ulong)hdr, dtb_idx, &fdt_addr, &fdt_size)) {
 544                         fdt_blob = (char *)map_sysmem(fdt_addr, 0);
 545                         if (fdt_check_header(fdt_blob))
 546                                 goto no_fdt;
 547
 548                         debug("## Using FDT in Android image dtb area with idx %u\n", dtb_idx);
 549                 } else if (!android_image_get_second(hdr, &fdt_data, &fdt_len) &&
 550                         !fdt_check_header((char *)fdt_data)) {
 551                         fdt_blob = (char *)fdt_data;
 552                         if (fdt_totalsize(fdt_blob) != fdt_len)
 553                                 goto error;
 554
 555                         debug("## Using FDT in Android image second area\n");
 556                 } else {
 557                         fdt_addr = env_get_hex("fdtaddr", 0);
 558                         if (!fdt_addr)
 559                                 goto no_fdt;
 560
 561                         fdt_blob = map_sysmem(fdt_addr, 0);
 562                         if (fdt_check_header(fdt_blob))
 563                                 goto no_fdt;
 564
 565                         debug("## Using FDT at ${fdtaddr}=Ox%lx\n", fdt_addr);
 566                 }
 567 #endif
 568         } else {
 569                 debug("## No Flattened Device Tree\n");
 570                 goto no_fdt;
 571         }
 572
 573         *of_flat_tree = fdt_blob;
 574         *of_size = fdt_totalsize(fdt_blob);
 575         debug("   of_flat_tree at 0x%08lx size 0x%08lx\n",
 576               (ulong)*of_flat_tree, *of_size);
 577
 578         return 0;
 579
 580 no_fdt:
 581         debug("Continuing to boot without FDT\n");
 582         return 0;
 583 error:
 584         return 1;
 585 }
 586
 587 /*
 588  * Verify the device tree.
 589  *
 590  * This function is called after all device tree fix-ups have been enacted,
 591  * so that the final device tree can be verified.  The definition of "verified"
 592  * is up to the specific implementation.  However, it generally means that the
 593  * addresses of some of the devices in the device tree are compared with the
 594  * actual addresses at which U-Boot has placed them.
 595  *
 596  * Returns 1 on success, 0 on failure.  If 0 is returned, U-Boot will halt the
 597  * boot process.
 598  */
 599 __weak int ft_verify_fdt(void *fdt)
 600 {
 601         return 1;
 602 }
 603
 604 __weak int arch_fixup_fdt(void *blob)
 605 {
 606         return 0;
 607 }
 608
 609 int image_setup_libfdt(bootm_headers_t *images, void *blob,
 610                        int of_size, struct lmb *lmb)
 611 {
 612         ulong *initrd_start = &images->initrd_start;
 613         ulong *initrd_end = &images->initrd_end;
 614         int ret = -EPERM;
 615         int fdt_ret;
 616
 617         if (fdt_root(blob) < 0) {
 618                 printf("ERROR: root node setup failed\n");
 619                 goto err;
 620         }
 621         if (fdt_chosen(blob) < 0) {
 622                 printf("ERROR: /chosen node create failed\n");
 623                 goto err;
 624         }
 625         if (arch_fixup_fdt(blob) < 0) {
 626                 printf("ERROR: arch-specific fdt fixup failed\n");
 627                 goto err;
 628         }
 629
 630         fdt_ret = optee_copy_fdt_nodes(blob);
 631         if (fdt_ret) {
 632                 printf("ERROR: transfer of optee nodes to new fdt failed: %s\n",
 633                        fdt_strerror(fdt_ret));
 634                 goto err;
 635         }
 636
 637         /* Store name of configuration node as u-boot,bootconf in /chosen node */
 638         if (images->fit_uname_cfg)
 639                 fdt_find_and_setprop(blob, "/chosen", "u-boot,bootconf",
 640                                         images->fit_uname_cfg,
 641                                         strlen(images->fit_uname_cfg) + 1, 1);
 642
 643         /* Update ethernet nodes */
 644         fdt_fixup_ethernet(blob);
 645 #if CONFIG_IS_ENABLED(CMD_PSTORE)
 646         /* Append PStore configuration */
 647         fdt_fixup_pstore(blob);
 648 #endif
 649         if (IS_ENABLED(CONFIG_OF_BOARD_SETUP)) {
 650                 const char *skip_board_fixup;
 651
 652                 skip_board_fixup = env_get("skip_board_fixup");
 653                 if (skip_board_fixup && ((int)simple_strtol(skip_board_fixup, NULL, 10) == 1)) {
 654                         printf("skip board fdt fixup\n");
 655                 } else {
 656                         fdt_ret = ft_board_setup(blob, gd->bd);
 657                         if (fdt_ret) {
 658                                 printf("ERROR: board-specific fdt fixup failed: %s\n",
 659                                        fdt_strerror(fdt_ret));
 660                                 goto err;
 661                         }
 662                 }
 663         }
 664         if (IS_ENABLED(CONFIG_OF_SYSTEM_SETUP)) {
 665                 fdt_ret = ft_system_setup(blob, gd->bd);
 666                 if (fdt_ret) {
 667                         printf("ERROR: system-specific fdt fixup failed: %s\n",
 668                                fdt_strerror(fdt_ret));
 669                         goto err;
 670                 }
 671         }
 672         if (CONFIG_IS_ENABLED(EVENT)) {
 673                 struct event_ft_fixup fixup;
 674
 675                 fixup.tree = oftree_default();
 676                 ret = event_notify(EVT_FT_FIXUP, &fixup, sizeof(fixup));
 677                 if (ret) {
 678                         printf("ERROR: fdt fixup event failed: %d\n", ret);
 679                         goto err;
 680                 }
 681         }
 682
 683         /* Delete the old LMB reservation */
 684         if (lmb)
 685                 lmb_free(lmb, (phys_addr_t)(u32)(uintptr_t)blob,
 686                          (phys_size_t)fdt_totalsize(blob));
 687
 688         ret = fdt_shrink_to_minimum(blob, 0);
 689         if (ret < 0)
 690                 goto err;
 691         of_size = ret;
 692
 693         if (*initrd_start && *initrd_end) {
 694                 of_size += FDT_RAMDISK_OVERHEAD;
 695                 fdt_set_totalsize(blob, of_size);
 696         }
 697         /* Create a new LMB reservation */
 698         if (lmb)
 699                 lmb_reserve(lmb, (ulong)blob, of_size);
 700
 701         fdt_initrd(blob, *initrd_start, *initrd_end);
 702         if (!ft_verify_fdt(blob))
 703                 goto err;
 704
 705 #if defined(CONFIG_ARCH_KEYSTONE)
 706         if (IS_ENABLED(CONFIG_OF_BOARD_SETUP))
 707                 ft_board_setup_ex(blob, gd->bd);
 708 #endif
 709
 710         return 0;
 711 err:
 712         printf(" - must RESET the board to recover.\n\n");
 713
 714         return ret;
 715 }