common/spl/spl_fit.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2016 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #include <common.h>
   8 #include <errno.h>
   9 #include <fpga.h>
  10 #include <gzip.h>
  11 #include <image.h>
  12 #include <log.h>
  13 #include <memalign.h>
  14 #include <mapmem.h>
  15 #include <spl.h>
  16 #include <sysinfo.h>
  17 #include <asm/cache.h>
  18 #include <asm/global_data.h>
  19 #include <linux/libfdt.h>
  20
  21 DECLARE_GLOBAL_DATA_PTR;
  22
  23 struct spl_fit_info {
  24         const void *fit;        /* Pointer to a valid FIT blob */
  25         size_t ext_data_offset; /* Offset to FIT external data (end of FIT) */
  26         int images_node;        /* FDT offset to "/images" node */
  27         int conf_node;          /* FDT offset to selected configuration node */
  28 };
  29
  30 __weak ulong board_spl_fit_size_align(ulong size)
  31 {
  32         return size;
  33 }
  34
  35 static int find_node_from_desc(const void *fit, int node, const char *str)
  36 {
  37         int child;
  38
  39         if (node < 0)
  40                 return -EINVAL;
  41
  42         /* iterate the FIT nodes and find a matching description */
  43         for (child = fdt_first_subnode(fit, node); child >= 0;
  44              child = fdt_next_subnode(fit, child)) {
  45                 int len;
  46                 const char *desc = fdt_getprop(fit, child, "description", &len);
  47
  48                 if (!desc)
  49                         continue;
  50
  51                 if (!strcmp(desc, str))
  52                         return child;
  53         }
  54
  55         return -ENOENT;
  56 }
  57
  58 /**
  59  * spl_fit_get_image_name(): By using the matching configuration subnode,
  60  * retrieve the name of an image, specified by a property name and an index
  61  * into that.
  62  * @fit:        Pointer to the FDT blob.
  63  * @images:     Offset of the /images subnode.
  64  * @type:       Name of the property within the configuration subnode.
  65  * @index:      Index into the list of strings in this property.
  66  * @outname:    Name of the image
  67  *
  68  * Return:      0 on success, or a negative error number
  69  */
  70 static int spl_fit_get_image_name(const struct spl_fit_info *ctx,
  71                                   const char *type, int index,
  72                                   const char **outname)
  73 {
  74         struct udevice *sysinfo;
  75         const char *name, *str;
  76         __maybe_unused int node;
  77         int len, i;
  78         bool found = true;
  79
  80         name = fdt_getprop(ctx->fit, ctx->conf_node, type, &len);
  81         if (!name) {
  82                 debug("cannot find property '%s': %d\n", type, len);
  83                 return -EINVAL;
  84         }
  85
  86         str = name;
  87         for (i = 0; i < index; i++) {
  88                 str = strchr(str, '\0') + 1;
  89                 if (!str || (str - name >= len)) {
  90                         found = false;
  91                         break;
  92                 }
  93         }
  94
  95         if (!found && CONFIG_IS_ENABLED(SYSINFO) && !sysinfo_get(&sysinfo)) {
  96                 int rc;
  97                 /*
  98                  * no string in the property for this index. Check if the
  99                  * sysinfo-level code can supply one.
 100                  */
 101                 rc = sysinfo_detect(sysinfo);
 102                 if (rc)
 103                         return rc;
 104
 105                 rc = sysinfo_get_fit_loadable(sysinfo, index - i - 1, type,
 106                                               &str);
 107                 if (rc && rc != -ENOENT)
 108                         return rc;
 109
 110                 if (!rc) {
 111                         /*
 112                          * The sysinfo provided a name for a loadable.
 113                          * Try to match it against the description properties
 114                          * first. If no matching node is found, use it as a
 115                          * node name.
 116                          */
 117                         int node;
 118                         int images = fdt_path_offset(ctx->fit, FIT_IMAGES_PATH);
 119
 120                         node = find_node_from_desc(ctx->fit, images, str);
 121                         if (node > 0)
 122                                 str = fdt_get_name(ctx->fit, node, NULL);
 123
 124                         found = true;
 125                 }
 126         }
 127
 128         if (!found) {
 129                 debug("no string for index %d\n", index);
 130                 return -E2BIG;
 131         }
 132
 133         *outname = str;
 134         return 0;
 135 }
 136
 137 /**
 138  * spl_fit_get_image_node(): By using the matching configuration subnode,
 139  * retrieve the name of an image, specified by a property name and an index
 140  * into that.
 141  * @fit:        Pointer to the FDT blob.
 142  * @images:     Offset of the /images subnode.
 143  * @type:       Name of the property within the configuration subnode.
 144  * @index:      Index into the list of strings in this property.
 145  *
 146  * Return:      the node offset of the respective image node or a negative
 147  *              error number.
 148  */
 149 static int spl_fit_get_image_node(const struct spl_fit_info *ctx,
 150                                   const char *type, int index)
 151 {
 152         const char *str;
 153         int err;
 154         int node;
 155
 156         err = spl_fit_get_image_name(ctx, type, index, &str);
 157         if (err)
 158                 return err;
 159
 160         debug("%s: '%s'\n", type, str);
 161
 162         node = fdt_subnode_offset(ctx->fit, ctx->images_node, str);
 163         if (node < 0) {
 164                 pr_err("cannot find image node '%s': %d\n", str, node);
 165                 return -EINVAL;
 166         }
 167
 168         return node;
 169 }
 170
 171 static int get_aligned_image_offset(struct spl_load_info *info, int offset)
 172 {
 173         /*
 174          * If it is a FS read, get the first address before offset which is
 175          * aligned to ARCH_DMA_MINALIGN. If it is raw read return the
 176          * block number to which offset belongs.
 177          */
 178         if (info->filename)
 179                 return offset & ~(ARCH_DMA_MINALIGN - 1);
 180
 181         return offset / info->bl_len;
 182 }
 183
 184 static int get_aligned_image_overhead(struct spl_load_info *info, int offset)
 185 {
 186         /*
 187          * If it is a FS read, get the difference between the offset and
 188          * the first address before offset which is aligned to
 189          * ARCH_DMA_MINALIGN. If it is raw read return the offset within the
 190          * block.
 191          */
 192         if (info->filename)
 193                 return offset & (ARCH_DMA_MINALIGN - 1);
 194
 195         return offset % info->bl_len;
 196 }
 197
 198 static int get_aligned_image_size(struct spl_load_info *info, int data_size,
 199                                   int offset)
 200 {
 201         data_size = data_size + get_aligned_image_overhead(info, offset);
 202
 203         if (info->filename)
 204                 return data_size;
 205
 206         return (data_size + info->bl_len - 1) / info->bl_len;
 207 }
 208
 209 /**
 210  * spl_load_fit_image(): load the image described in a certain FIT node
 211  * @info:       points to information about the device to load data from
 212  * @sector:     the start sector of the FIT image on the device
 213  * @ctx:        points to the FIT context structure
 214  * @node:       offset of the DT node describing the image to load (relative
 215  *              to @fit)
 216  * @image_info: will be filled with information about the loaded image
 217  *              If the FIT node does not contain a "load" (address) property,
 218  *              the image gets loaded to the address pointed to by the
 219  *              load_addr member in this struct, if load_addr is not 0
 220  *
 221  * Return:      0 on success or a negative error number.
 222  */
 223 static int spl_load_fit_image(struct spl_load_info *info, ulong sector,
 224                               const struct spl_fit_info *ctx, int node,
 225                               struct spl_image_info *image_info)
 226 {
 227         int offset;
 228         size_t length;
 229         int len;
 230         ulong size;
 231         ulong load_addr;
 232         void *load_ptr;
 233         void *src;
 234         ulong overhead;
 235         int nr_sectors;
 236         uint8_t image_comp = -1, type = -1;
 237         const void *data;
 238         const void *fit = ctx->fit;
 239         bool external_data = false;
 240
 241         if (IS_ENABLED(CONFIG_SPL_FPGA) ||
 242             (IS_ENABLED(CONFIG_SPL_OS_BOOT) && IS_ENABLED(CONFIG_SPL_GZIP))) {
 243                 if (fit_image_get_type(fit, node, &type))
 244                         puts("Cannot get image type.\n");
 245                 else
 246                         debug("%s ", genimg_get_type_name(type));
 247         }
 248
 249         if (IS_ENABLED(CONFIG_SPL_GZIP)) {
 250                 fit_image_get_comp(fit, node, &image_comp);
 251                 debug("%s ", genimg_get_comp_name(image_comp));
 252         }
 253
 254         if (fit_image_get_load(fit, node, &load_addr)) {
 255                 if (!image_info->load_addr) {
 256                         printf("Can't load %s: No load address and no buffer\n",
 257                                fit_get_name(fit, node, NULL));
 258                         return -ENOBUFS;
 259                 }
 260                 load_addr = image_info->load_addr;
 261         }
 262
 263         if (!fit_image_get_data_position(fit, node, &offset)) {
 264                 external_data = true;
 265         } else if (!fit_image_get_data_offset(fit, node, &offset)) {
 266                 offset += ctx->ext_data_offset;
 267                 external_data = true;
 268         }
 269
 270         if (external_data) {
 271                 void *src_ptr;
 272
 273                 /* External data */
 274                 if (fit_image_get_data_size(fit, node, &len))
 275                         return -ENOENT;
 276
 277                 /* Dont bother to copy 0 byte data, but warn, though */
 278                 if (!len) {
 279                         log_warning("%s: Skip load '%s': image size is 0!\n",
 280                                     __func__, fit_get_name(fit, node, NULL));
 281                         return 0;
 282                 }
 283
 284                 src_ptr = map_sysmem(ALIGN(load_addr, ARCH_DMA_MINALIGN), len);
 285                 length = len;
 286
 287                 overhead = get_aligned_image_overhead(info, offset);
 288                 nr_sectors = get_aligned_image_size(info, length, offset);
 289
 290                 if (info->read(info,
 291                                sector + get_aligned_image_offset(info, offset),
 292                                nr_sectors, src_ptr) != nr_sectors)
 293                         return -EIO;
 294
 295                 debug("External data: dst=%p, offset=%x, size=%lx\n",
 296                       src_ptr, offset, (unsigned long)length);
 297                 src = src_ptr + overhead;
 298         } else {
 299                 /* Embedded data */
 300                 if (fit_image_get_data(fit, node, &data, &length)) {
 301                         puts("Cannot get image data/size\n");
 302                         return -ENOENT;
 303                 }
 304                 debug("Embedded data: dst=%lx, size=%lx\n", load_addr,
 305                       (unsigned long)length);
 306                 src = (void *)data;     /* cast away const */
 307         }
 308
 309         if (CONFIG_IS_ENABLED(FIT_SIGNATURE)) {
 310                 printf("## Checking hash(es) for Image %s ... ",
 311                        fit_get_name(fit, node, NULL));
 312                 if (!fit_image_verify_with_data(fit, node, gd_fdt_blob(), src,
 313                                                 length))
 314                         return -EPERM;
 315                 puts("OK\n");
 316         }
 317
 318         if (CONFIG_IS_ENABLED(FIT_IMAGE_POST_PROCESS))
 319                 board_fit_image_post_process(fit, node, &src, &length);
 320
 321         load_ptr = map_sysmem(load_addr, length);
 322         if (IS_ENABLED(CONFIG_SPL_GZIP) && image_comp == IH_COMP_GZIP) {
 323                 size = length;
 324                 if (gunzip(load_ptr, CONFIG_SYS_BOOTM_LEN, src, &size)) {
 325                         puts("Uncompressing error\n");
 326                         return -EIO;
 327                 }
 328                 length = size;
 329         } else {
 330                 memcpy(load_ptr, src, length);
 331         }
 332
 333         if (image_info) {
 334                 ulong entry_point;
 335
 336                 image_info->load_addr = load_addr;
 337                 image_info->size = length;
 338
 339                 if (!fit_image_get_entry(fit, node, &entry_point))
 340                         image_info->entry_point = entry_point;
 341                 else
 342                         image_info->entry_point = FDT_ERROR;
 343         }
 344
 345         return 0;
 346 }
 347
 348 static bool os_takes_devicetree(uint8_t os)
 349 {
 350         switch (os) {
 351         case IH_OS_U_BOOT:
 352                 return true;
 353         case IH_OS_LINUX:
 354                 return IS_ENABLED(CONFIG_SPL_OS_BOOT);
 355         default:
 356                 return false;
 357         }
 358 }
 359
 360 static int spl_fit_append_fdt(struct spl_image_info *spl_image,
 361                               struct spl_load_info *info, ulong sector,
 362                               const struct spl_fit_info *ctx)
 363 {
 364         struct spl_image_info image_info;
 365         int node, ret = 0, index = 0;
 366
 367         /*
 368          * Use the address following the image as target address for the
 369          * device tree.
 370          */
 371         image_info.load_addr = spl_image->load_addr + spl_image->size;
 372
 373         /* Figure out which device tree the board wants to use */
 374         node = spl_fit_get_image_node(ctx, FIT_FDT_PROP, index++);
 375         if (node < 0) {
 376                 debug("%s: cannot find FDT node\n", __func__);
 377
 378                 /*
 379                  * U-Boot did not find a device tree inside the FIT image. Use
 380                  * the U-Boot device tree instead.
 381                  */
 382                 if (gd->fdt_blob)
 383                         memcpy((void *)image_info.load_addr, gd->fdt_blob,
 384                                fdt_totalsize(gd->fdt_blob));
 385                 else
 386                         return node;
 387         } else {
 388                 ret = spl_load_fit_image(info, sector, ctx, node,
 389                                          &image_info);
 390                 if (ret < 0)
 391                         return ret;
 392         }
 393
 394         /* Make the load-address of the FDT available for the SPL framework */
 395         spl_image->fdt_addr = map_sysmem(image_info.load_addr, 0);
 396         if (CONFIG_IS_ENABLED(FIT_IMAGE_TINY))
 397                 return 0;
 398
 399 #if CONFIG_IS_ENABLED(LOAD_FIT_APPLY_OVERLAY)
 400                 void *tmpbuffer = NULL;
 401
 402                 for (; ; index++) {
 403                         node = spl_fit_get_image_node(ctx, FIT_FDT_PROP, index);
 404                         if (node == -E2BIG) {
 405                                 debug("%s: No additional FDT node\n", __func__);
 406                                 break;
 407                         } else if (node < 0) {
 408                                 debug("%s: unable to find FDT node %d\n",
 409                                       __func__, index);
 410                                 continue;
 411                         }
 412
 413                         if (!tmpbuffer) {
 414                                 /*
 415                                  * allocate memory to store the DT overlay
 416                                  * before it is applied. It may not be used
 417                                  * depending on how the overlay is stored, so
 418                                  * don't fail yet if the allocation failed.
 419                                  */
 420                                 size_t size = CONFIG_SPL_LOAD_FIT_APPLY_OVERLAY_BUF_SZ;
 421
 422                                 tmpbuffer = malloc_cache_aligned(size);
 423                                 if (!tmpbuffer)
 424                                         debug("%s: unable to allocate space for overlays\n",
 425                                               __func__);
 426                         }
 427                         image_info.load_addr = (ulong)tmpbuffer;
 428                         ret = spl_load_fit_image(info, sector, ctx,
 429                                                  node, &image_info);
 430                         if (ret < 0)
 431                                 break;
 432
 433                         /* Make room in FDT for changes from the overlay */
 434                         ret = fdt_increase_size(spl_image->fdt_addr,
 435                                                 image_info.size);
 436                         if (ret < 0)
 437                                 break;
 438
 439                         ret = fdt_overlay_apply_verbose(spl_image->fdt_addr,
 440                                                         (void *)image_info.load_addr);
 441                         if (ret) {
 442                                 pr_err("failed to apply DT overlay %s\n",
 443                                        fit_get_name(ctx->fit, node, NULL));
 444                                 break;
 445                         }
 446
 447                         debug("%s: DT overlay %s applied\n", __func__,
 448                               fit_get_name(ctx->fit, node, NULL));
 449                 }
 450                 free(tmpbuffer);
 451                 if (ret)
 452                         return ret;
 453 #endif
 454         /* Try to make space, so we can inject details on the loadables */
 455         ret = fdt_shrink_to_minimum(spl_image->fdt_addr, 8192);
 456         if (ret < 0)
 457                 return ret;
 458
 459         return ret;
 460 }
 461
 462 static int spl_fit_record_loadable(const struct spl_fit_info *ctx, int index,
 463                                    void *blob, struct spl_image_info *image)
 464 {
 465         int ret = 0;
 466         const char *name;
 467         int node;
 468
 469         if (CONFIG_IS_ENABLED(FIT_IMAGE_TINY))
 470                 return 0;
 471
 472         ret = spl_fit_get_image_name(ctx, "loadables", index, &name);
 473         if (ret < 0)
 474                 return ret;
 475
 476         node = spl_fit_get_image_node(ctx, "loadables", index);
 477
 478         ret = fdt_record_loadable(blob, index, name, image->load_addr,
 479                                   image->size, image->entry_point,
 480                                   fdt_getprop(ctx->fit, node, "type", NULL),
 481                                   fdt_getprop(ctx->fit, node, "os", NULL),
 482                                   fdt_getprop(ctx->fit, node, "arch", NULL));
 483         return ret;
 484 }
 485
 486 static int spl_fit_image_is_fpga(const void *fit, int node)
 487 {
 488         const char *type;
 489
 490         if (!IS_ENABLED(CONFIG_SPL_FPGA))
 491                 return 0;
 492
 493         type = fdt_getprop(fit, node, FIT_TYPE_PROP, NULL);
 494         if (!type)
 495                 return 0;
 496
 497         return !strcmp(type, "fpga");
 498 }
 499
 500 static int spl_fit_image_get_os(const void *fit, int noffset, uint8_t *os)
 501 {
 502         if (!CONFIG_IS_ENABLED(FIT_IMAGE_TINY) || CONFIG_IS_ENABLED(OS_BOOT))
 503                 return fit_image_get_os(fit, noffset, os);
 504
 505         const char *name = fdt_getprop(fit, noffset, FIT_OS_PROP, NULL);
 506         if (!name)
 507                 return -ENOENT;
 508
 509         /*
 510          * We don't care what the type of the image actually is,
 511          * only whether or not it is U-Boot. This saves some
 512          * space by omitting the large table of OS types.
 513          */
 514         if (!strcmp(name, "u-boot"))
 515                 *os = IH_OS_U_BOOT;
 516         else
 517                 *os = IH_OS_INVALID;
 518
 519         return 0;
 520 }
 521
 522 /*
 523  * The purpose of the FIT load buffer is to provide a memory location that is
 524  * independent of the load address of any FIT component.
 525  */
 526 static void *spl_get_fit_load_buffer(size_t size)
 527 {
 528         void *buf;
 529
 530         buf = malloc_cache_aligned(size);
 531         if (!buf) {
 532                 pr_err("Could not get FIT buffer of %lu bytes\n", (ulong)size);
 533                 pr_err("\tcheck CONFIG_SYS_SPL_MALLOC_SIZE\n");
 534                 buf = spl_get_load_buffer(0, size);
 535         }
 536         return buf;
 537 }
 538
 539 __weak void *board_spl_fit_buffer_addr(ulong fit_size, int sectors, int bl_len)
 540 {
 541         return spl_get_fit_load_buffer(sectors * bl_len);
 542 }
 543
 544 /*
 545  * Weak default function to allow customizing SPL fit loading for load-only
 546  * use cases by allowing to skip the parsing/processing of the FIT contents
 547  * (so that this can be done separately in a more customized fashion)
 548  */
 549 __weak bool spl_load_simple_fit_skip_processing(void)
 550 {
 551         return false;
 552 }
 553
 554 /*
 555  * Weak default function to allow fixes after fit header
 556  * is loaded.
 557  */
 558 __weak void *spl_load_simple_fit_fix_load(const void *fit)
 559 {
 560         return (void *)fit;
 561 }
 562
 563 static void warn_deprecated(const char *msg)
 564 {
 565         printf("DEPRECATED: %s\n", msg);
 566         printf("\tSee doc/uImage.FIT/source_file_format.txt\n");
 567 }
 568
 569 static int spl_fit_upload_fpga(struct spl_fit_info *ctx, int node,
 570                                struct spl_image_info *fpga_image)
 571 {
 572         const char *compatible;
 573         int ret;
 574         int devnum = 0;
 575         int flags = 0;
 576
 577         debug("FPGA bitstream at: %x, size: %x\n",
 578               (u32)fpga_image->load_addr, fpga_image->size);
 579
 580         compatible = fdt_getprop(ctx->fit, node, "compatible", NULL);
 581         if (!compatible) {
 582                 warn_deprecated("'fpga' image without 'compatible' property");
 583         } else {
 584                 if (CONFIG_IS_ENABLED(FPGA_LOAD_SECURE))
 585                         flags = fpga_compatible2flag(devnum, compatible);
 586                 if (strcmp(compatible, "u-boot,fpga-legacy"))
 587                         debug("Ignoring compatible = %s property\n",
 588                               compatible);
 589         }
 590
 591         ret = fpga_load(devnum, (void *)fpga_image->load_addr,
 592                         fpga_image->size, BIT_FULL, flags);
 593         if (ret) {
 594                 printf("%s: Cannot load the image to the FPGA\n", __func__);
 595                 return ret;
 596         }
 597
 598         puts("FPGA image loaded from FIT\n");
 599
 600         return 0;
 601 }
 602
 603 static int spl_fit_load_fpga(struct spl_fit_info *ctx,
 604                              struct spl_load_info *info, ulong sector)
 605 {
 606         int node, ret;
 607
 608         struct spl_image_info fpga_image = {
 609                 .load_addr = 0,
 610         };
 611
 612         node = spl_fit_get_image_node(ctx, "fpga", 0);
 613         if (node < 0)
 614                 return node;
 615
 616         warn_deprecated("'fpga' property in config node. Use 'loadables'");
 617
 618         /* Load the image and set up the fpga_image structure */
 619         ret = spl_load_fit_image(info, sector, ctx, node, &fpga_image);
 620         if (ret) {
 621                 printf("%s: Cannot load the FPGA: %i\n", __func__, ret);
 622                 return ret;
 623         }
 624
 625         return spl_fit_upload_fpga(ctx, node, &fpga_image);
 626 }
 627
 628 static int spl_simple_fit_read(struct spl_fit_info *ctx,
 629                                struct spl_load_info *info, ulong sector,
 630                                const void *fit_header)
 631 {
 632         unsigned long count, size;
 633         int sectors;
 634         void *buf;
 635
 636         /*
 637          * For FIT with external data, figure out where the external images
 638          * start. This is the base for the data-offset properties in each
 639          * image.
 640          */
 641         size = ALIGN(fdt_totalsize(fit_header), 4);
 642         size = board_spl_fit_size_align(size);
 643         ctx->ext_data_offset = ALIGN(size, 4);
 644
 645         /*
 646          * So far we only have one block of data from the FIT. Read the entire
 647          * thing, including that first block.
 648          *
 649          * For FIT with data embedded, data is loaded as part of FIT image.
 650          * For FIT with external data, data is not loaded in this step.
 651          */
 652         sectors = get_aligned_image_size(info, size, 0);
 653         buf = board_spl_fit_buffer_addr(size, sectors, info->bl_len);
 654
 655         count = info->read(info, sector, sectors, buf);
 656         ctx->fit = buf;
 657         debug("fit read sector %lx, sectors=%d, dst=%p, count=%lu, size=0x%lx\n",
 658               sector, sectors, buf, count, size);
 659
 660         return (count == 0) ? -EIO : 0;
 661 }
 662
 663 static int spl_simple_fit_parse(struct spl_fit_info *ctx)
 664 {
 665         /* Find the correct subnode under "/configurations" */
 666         ctx->conf_node = fit_find_config_node(ctx->fit);
 667         if (ctx->conf_node < 0)
 668                 return -EINVAL;
 669
 670         if (IS_ENABLED(CONFIG_SPL_FIT_SIGNATURE)) {
 671                 printf("## Checking hash(es) for config %s ... ",
 672                        fit_get_name(ctx->fit, ctx->conf_node, NULL));
 673                 if (fit_config_verify(ctx->fit, ctx->conf_node))
 674                         return -EPERM;
 675                 puts("OK\n");
 676         }
 677
 678         /* find the node holding the images information */
 679         ctx->images_node = fdt_path_offset(ctx->fit, FIT_IMAGES_PATH);
 680         if (ctx->images_node < 0) {
 681                 debug("%s: Cannot find /images node: %d\n", __func__,
 682                       ctx->images_node);
 683                 return -EINVAL;
 684         }
 685
 686         return 0;
 687 }
 688
 689 int spl_load_simple_fit(struct spl_image_info *spl_image,
 690                         struct spl_load_info *info, ulong sector, void *fit)
 691 {
 692         struct spl_image_info image_info;
 693         struct spl_fit_info ctx;
 694         int node = -1;
 695         int ret;
 696         int index = 0;
 697         int firmware_node;
 698
 699         ret = spl_simple_fit_read(&ctx, info, sector, fit);
 700         if (ret < 0)
 701                 return ret;
 702
 703         /* skip further processing if requested to enable load-only use cases */
 704         if (spl_load_simple_fit_skip_processing())
 705                 return 0;
 706
 707         ctx.fit = spl_load_simple_fit_fix_load(ctx.fit);
 708
 709         ret = spl_simple_fit_parse(&ctx);
 710         if (ret < 0)
 711                 return ret;
 712
 713         if (IS_ENABLED(CONFIG_SPL_FPGA))
 714                 spl_fit_load_fpga(&ctx, info, sector);
 715
 716         /*
 717          * Find the U-Boot image using the following search order:
 718          *   - start at 'firmware' (e.g. an ARM Trusted Firmware)
 719          *   - fall back 'kernel' (e.g. a Falcon-mode OS boot
 720          *   - fall back to using the first 'loadables' entry
 721          */
 722         if (node < 0)
 723                 node = spl_fit_get_image_node(&ctx, FIT_FIRMWARE_PROP, 0);
 724
 725         if (node < 0 && IS_ENABLED(CONFIG_SPL_OS_BOOT))
 726                 node = spl_fit_get_image_node(&ctx, FIT_KERNEL_PROP, 0);
 727
 728         if (node < 0) {
 729                 debug("could not find firmware image, trying loadables...\n");
 730                 node = spl_fit_get_image_node(&ctx, "loadables", 0);
 731                 /*
 732                  * If we pick the U-Boot image from "loadables", start at
 733                  * the second image when later loading additional images.
 734                  */
 735                 index = 1;
 736         }
 737         if (node < 0) {
 738                 debug("%s: Cannot find u-boot image node: %d\n",
 739                       __func__, node);
 740                 return -1;
 741         }
 742
 743         /* Load the image and set up the spl_image structure */
 744         ret = spl_load_fit_image(info, sector, &ctx, node, spl_image);
 745         if (ret)
 746                 return ret;
 747
 748         /*
 749          * For backward compatibility, we treat the first node that is
 750          * as a U-Boot image, if no OS-type has been declared.
 751          */
 752         if (!spl_fit_image_get_os(ctx.fit, node, &spl_image->os))
 753                 debug("Image OS is %s\n", genimg_get_os_name(spl_image->os));
 754         else if (!IS_ENABLED(CONFIG_SPL_OS_BOOT))
 755                 spl_image->os = IH_OS_U_BOOT;
 756
 757         /*
 758          * Booting a next-stage U-Boot may require us to append the FDT.
 759          * We allow this to fail, as the U-Boot image might embed its FDT.
 760          */
 761         if (os_takes_devicetree(spl_image->os)) {
 762                 ret = spl_fit_append_fdt(spl_image, info, sector, &ctx);
 763                 if (ret < 0 && spl_image->os != IH_OS_U_BOOT)
 764                         return ret;
 765         }
 766
 767         firmware_node = node;
 768         /* Now check if there are more images for us to load */
 769         for (; ; index++) {
 770                 uint8_t os_type = IH_OS_INVALID;
 771
 772                 node = spl_fit_get_image_node(&ctx, "loadables", index);
 773                 if (node < 0)
 774                         break;
 775
 776                 /*
 777                  * if the firmware is also a loadable, skip it because
 778                  * it already has been loaded. This is typically the case with
 779                  * u-boot.img generated by mkimage.
 780                  */
 781                 if (firmware_node == node)
 782                         continue;
 783
 784                 image_info.load_addr = 0;
 785                 ret = spl_load_fit_image(info, sector, &ctx, node, &image_info);
 786                 if (ret < 0) {
 787                         printf("%s: can't load image loadables index %d (ret = %d)\n",
 788                                __func__, index, ret);
 789                         return ret;
 790                 }
 791
 792                 if (spl_fit_image_is_fpga(ctx.fit, node))
 793                         spl_fit_upload_fpga(&ctx, node, &image_info);
 794
 795                 if (!spl_fit_image_get_os(ctx.fit, node, &os_type))
 796                         debug("Loadable is %s\n", genimg_get_os_name(os_type));
 797
 798                 if (os_takes_devicetree(os_type)) {
 799                         spl_fit_append_fdt(&image_info, info, sector, &ctx);
 800                         spl_image->fdt_addr = image_info.fdt_addr;
 801                 }
 802
 803                 /*
 804                  * If the "firmware" image did not provide an entry point,
 805                  * use the first valid entry point from the loadables.
 806                  */
 807                 if (spl_image->entry_point == FDT_ERROR &&
 808                     image_info.entry_point != FDT_ERROR)
 809                         spl_image->entry_point = image_info.entry_point;
 810
 811                 /* Record our loadables into the FDT */
 812                 if (spl_image->fdt_addr)
 813                         spl_fit_record_loadable(&ctx, index,
 814                                                 spl_image->fdt_addr,
 815                                                 &image_info);
 816         }
 817
 818         /*
 819          * If a platform does not provide CFG_SYS_UBOOT_START, U-Boot's
 820          * Makefile will set it to 0 and it will end up as the entry point
 821          * here. What it actually means is: use the load address.
 822          */
 823         if (spl_image->entry_point == FDT_ERROR || spl_image->entry_point == 0)
 824                 spl_image->entry_point = spl_image->load_addr;
 825
 826         spl_image->flags |= SPL_FIT_FOUND;
 827
 828         return 0;
 829 }