vbe: Support loading SPL images

VBE needs to load different images from a FIT depending on the xPL phase
in use. The IH_PHASE value is used to select the image to load.

Add the required logic to handle this. For compatibility with the
SPL-loader driver, fill out a struct spl_image_info with the details
needed to boot the next phase.

This is good enough for VBE-simple but ABrec will need the full set of
bootstd features. So add a USE_BOOTMETH define to control this.

Signed-off-by: Simon Glass <sjg@chromium.org>

diff --git a/boot/vbe_common.c b/boot/vbe_common.c
index 1926e85..2bc6c4d 100644 (file)
--- a/boot/vbe_common.c
+++ b/boot/vbe_common.c
@@ -16,6 +16,11 @@
 #include <u-boot/crc.h>
 #include "vbe_common.h"
 
+binman_sym_declare(ulong, u_boot_vpl_nodtb, size);
+binman_sym_declare(ulong, u_boot_vpl_bss_pad, size);
+binman_sym_declare(ulong, u_boot_spl_nodtb, size);
+binman_sym_declare(ulong, u_boot_spl_bss_pad, size);
+
 int vbe_get_blk(const char *storage, struct udevice **blkp)
 {
        struct blk_desc *desc;
@@ -105,17 +110,43 @@ int vbe_read_nvdata(struct udevice *blk, ulong offset, ulong size, u8 *buf)
        return 0;
 }
 
+/**
+ * h_vbe_load_read() - Handler for reading an SPL image from a FIT
+ *
+ * See spl_load_reader for the definition
+ */
+ulong h_vbe_load_read(struct spl_load_info *load, ulong off, ulong size,
+                     void *buf)
+{
+       struct blk_desc *desc = load->priv;
+       lbaint_t sector = off >> desc->log2blksz;
+       lbaint_t count = size >> desc->log2blksz;
+       int ret;
+
+       log_debug("vbe read log2blksz %x offset %lx sector %lx count %lx\n",
+                 desc->log2blksz, (ulong)off, (long)sector, (ulong)count);
+
+       ret = blk_dread(desc, sector, count, buf);
+       log_debug("ret=%x\n", ret);
+       if (ret < 0)
+               return ret;
+
+       return ret << desc->log2blksz;
+}
+
 int vbe_read_fit(struct udevice *blk, ulong area_offset, ulong area_size,
-                ulong *load_addrp, ulong *lenp, char **namep)
+                struct spl_image_info *image, ulong *load_addrp, ulong *lenp,
+                char **namep)
 {
        ALLOC_CACHE_ALIGN_BUFFER(u8, sbuf, MMC_MAX_BLOCK_LEN);
-       ulong size, blknum, addr, len, load_addr, num_blks;
+       ulong size, blknum, addr, len, load_addr, num_blks, spl_load_addr;
        ulong aligned_size, fdt_load_addr, fdt_size;
        const char *fit_uname, *fit_uname_config;
        struct bootm_headers images = {};
        enum image_phase_t phase;
        struct blk_desc *desc;
        int node, ret;
+       bool for_xpl;
        void *buf;
 
        desc = dev_get_uclass_plat(blk);
@@ -168,7 +199,8 @@ int vbe_read_fit(struct udevice *blk, ulong area_offset, ulong area_size,
                  gd->malloc_base + gd->malloc_limit);
 #endif
        /* figure out the phase to load */
-       phase = IS_ENABLED(CONFIG_VPL_BUILD) ? IH_PHASE_SPL : IH_PHASE_U_BOOT;
+       phase = IS_ENABLED(CONFIG_TPL_BUILD) ? IH_PHASE_NONE :
+               IS_ENABLED(CONFIG_VPL_BUILD) ? IH_PHASE_SPL : IH_PHASE_U_BOOT;
 
        /*
         * Load the image from the FIT. We ignore any load-address information
@@ -179,6 +211,20 @@ int vbe_read_fit(struct udevice *blk, ulong area_offset, ulong area_size,
        fit_uname = NULL;
        fit_uname_config = NULL;
        log_debug("loading FIT\n");
+
+       if (xpl_phase() == PHASE_SPL && !IS_ENABLED(CONFIG_SANDBOX)) {
+               struct spl_load_info info;
+
+               spl_load_init(&info, h_vbe_load_read, desc, desc->blksz);
+               xpl_set_phase(&info, IH_PHASE_U_BOOT);
+               log_debug("doing SPL from %s blksz %lx log2blksz %x area_offset %lx + fdt_size %lx\n",
+                         blk->name, desc->blksz, desc->log2blksz, area_offset, ALIGN(size, 4));
+               ret = spl_load_simple_fit(image, &info, area_offset, buf);
+               log_debug("spl_load_abrec_fit() ret=%d\n", ret);
+
+               return ret;
+       }
+
        ret = fit_image_load(&images, addr, &fit_uname, &fit_uname_config,
                             IH_ARCH_DEFAULT, image_ph(phase, IH_TYPE_FIRMWARE),
                             BOOTSTAGE_ID_FIT_SPL_START, FIT_LOAD_IGNORED,
@@ -197,6 +243,31 @@ int vbe_read_fit(struct udevice *blk, ulong area_offset, ulong area_size,
 
        fdt_load_addr = 0;
        fdt_size = 0;
+       if ((xpl_phase() == PHASE_TPL || xpl_phase() == PHASE_VPL) &&
+           !IS_ENABLED(CONFIG_SANDBOX)) {
+               /* allow use of a different image from the configuration node */
+               fit_uname = NULL;
+               ret = fit_image_load(&images, addr, &fit_uname,
+                                    &fit_uname_config, IH_ARCH_DEFAULT,
+                                    image_ph(phase, IH_TYPE_FLATDT),
+                                    BOOTSTAGE_ID_FIT_SPL_START,
+                                    FIT_LOAD_IGNORED, &fdt_load_addr,
+                                    &fdt_size);
+               fdt_size = ALIGN(fdt_size, desc->blksz);
+               log_debug("FDT noload to %lx size %lx\n", fdt_load_addr,
+                         fdt_size);
+       }
+
+       for_xpl = !USE_BOOTMETH && CONFIG_IS_ENABLED(RELOC_LOADER);
+       if (for_xpl) {
+               image->size = len;
+               image->fdt_size = fdt_size;
+               ret = spl_reloc_prepare(image, &spl_load_addr);
+               if (ret)
+                       return log_msg_ret("spl", ret);
+       }
+       if (!IS_ENABLED(CONFIG_SANDBOX))
+               image->os = IH_OS_U_BOOT;
 
        /* For FIT external data, read in the external data */
        log_debug("load_addr %lx len %lx addr %lx aligned_size %lx\n",
@@ -224,6 +295,8 @@ int vbe_read_fit(struct udevice *blk, ulong area_offset, ulong area_size,
                 * to load to, then load the blocks
                 */
                num_blks = DIV_ROUND_UP(full_size, desc->blksz);
+               if (for_xpl)
+                       base = spl_load_addr;
                base_buf = map_sysmem(base, full_size);
                ret = blk_read(blk, blknum, num_blks, base_buf);
                log_debug("read foffset %lx blknum %lx full_size %lx num_blks %lx to %lx / %p: ret=%d\n",
@@ -239,6 +312,12 @@ int vbe_read_fit(struct udevice *blk, ulong area_offset, ulong area_size,
                        memmove(base_buf, base_buf + extra, len);
                }
 
+               if ((xpl_phase() == PHASE_VPL || xpl_phase() == PHASE_TPL) &&
+                   !IS_ENABLED(CONFIG_SANDBOX)) {
+                       image->load_addr = spl_get_image_text_base();
+                       image->entry_point = image->load_addr;
+               }
+
                /* now the FDT */
                if (fdt_size) {
                        fdt_offset = area_offset + fdt_load_addr - addr;

diff --git a/boot/vbe_common.h b/boot/vbe_common.h
index bfa3390..8411781 100644 (file)
--- a/boot/vbe_common.h
+++ b/boot/vbe_common.h
@@ -11,8 +11,18 @@
 
 #include <linux/types.h>
 
+struct spl_image_info;
 struct udevice;
 
+/*
+ * Controls whether we use a full bootmeth driver with VBE in this phase, or
+ * just access the information directly.
+ *
+ * For now VBE-simple uses the full bootmeth, but VBE-abrec does not, to reduce
+ * code size
+ */
+#define USE_BOOTMETH   CONFIG_IS_ENABLED(BOOTMETH_VBE_SIMPLE)
+
 enum {
        MAX_VERSION_LEN         = 256,
 
@@ -109,6 +119,7 @@ int vbe_read_nvdata(struct udevice *blk, ulong offset, ulong size, u8 *buf);
  * @blk: Block device containing FIT
  * @area_offset: Byte offset of the VBE area in @blk containing the FIT
  * @area_size: Size of the VBE area
+ * @image: SPL image to fill in with details of the loaded image, or NULL
  * @load_addrp: If non-null, returns the address where the image was loaded
  * @lenp: If non-null, returns the size of the image loaded, in bytes
  * @namep: If non-null, returns the name of the FIT-image node that was loaded
@@ -120,6 +131,7 @@ int vbe_read_nvdata(struct udevice *blk, ulong offset, ulong size, u8 *buf);
  * FIT-parsing (see fit_image_load()).
  */
 int vbe_read_fit(struct udevice *blk, ulong area_offset, ulong area_size,
-                ulong *load_addrp, ulong *lenp, char **namep);
+                struct spl_image_info *image, ulong *load_addrp, ulong *lenp,
+                char **namep);
 
 #endif /* __VBE_ABREC_H */

diff --git a/boot/vbe_simple_fw.c b/boot/vbe_simple_fw.c
index 0bf25cc..9da3e49 100644 (file)
--- a/boot/vbe_simple_fw.c
+++ b/boot/vbe_simple_fw.c
@@ -52,7 +52,8 @@ int vbe_simple_read_bootflow_fw(struct udevice *dev, struct bootflow *bflow)
        log_debug("blk=%s\n", blk->name);
 
        ret = vbe_read_fit(blk, priv->area_start + priv->skip_offset,
-                          priv->area_size, &load_addr, &len, &bflow->name);
+                          priv->area_size, NULL, &load_addr, &len,
+                          &bflow->name);
 
        /* set up the bootflow with the info we obtained */
        bflow->blk = blk;