From a3e67a96452983ae3b35a78cb2910f14fda9dd86 Mon Sep 17 00:00:00 2001 From: Anshul Dalal Date: Sat, 18 Oct 2025 01:03:06 +0530 Subject: spl: Kconfig: add SPL_OS_BOOT_SECURE config symbol This patch adds the new SPL_OS_BOOT_SECURE symbol that enables secure boot flow in falcon mode. This symbol can be used to disable certain inherently insecure options during falcon boot. Reviewed-by: Tom Rini Signed-off-by: Anshul Dalal --- common/spl/Kconfig | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/common/spl/Kconfig b/common/spl/Kconfig index 4ece5d168f9..ba94d6fe05a 100644 --- a/common/spl/Kconfig +++ b/common/spl/Kconfig @@ -1207,6 +1207,14 @@ config SPL_OS_BOOT Enable booting directly to an OS from SPL. for more info read doc/README.falcon +config SPL_OS_BOOT_SECURE + bool "Allow Falcon Mode on secure devices" + depends on SPL_OS_BOOT + help + This allows for secure devices with signature verification capabilities + to use falcon mode by disabling certain inherently non-securable options + in the SPL boot flow. + config SPL_PAYLOAD_ARGS_ADDR hex "Address in memory to load 'args' file for Falcon Mode to" depends on SPL_OS_BOOT || SPL_LOAD_FIT_OPENSBI_OS_BOOT -- cgit v1.3.1 From 2909b3bff076746938389b2ef320eea68c2b93db Mon Sep 17 00:00:00 2001 From: Anshul Dalal Date: Sat, 18 Oct 2025 01:03:07 +0530 Subject: spl: mmc: split spl_mmc_do_fs_boot into regular/os_boot Currently the logic to handle falcon mode as well as the regular boot is inside spl_mmc_do_fs_boot, this prevents us from cleanly extending falcon mode functionality like toggleable fallback to U-Boot proper. Therefore this patch splits the logic into spl_mmc_fs_load and spl_mmc_fs_load_os to handle the regular boot and falcon mode use case. Signed-off-by: Anshul Dalal --- common/spl/spl_mmc.c | 80 ++++++++++++++++++++++++++++++++-------------------- 1 file changed, 50 insertions(+), 30 deletions(-) diff --git a/common/spl/spl_mmc.c b/common/spl/spl_mmc.c index cd56cf71055..bfcdea2d05f 100644 --- a/common/spl/spl_mmc.c +++ b/common/spl/spl_mmc.c @@ -194,6 +194,46 @@ int spl_start_uboot(void) #endif #ifdef CONFIG_SYS_MMCSD_FS_BOOT +static int spl_mmc_fs_load_os(struct spl_image_info *spl_image, + struct spl_boot_device *bootdev, + struct blk_desc *blk_dev, int part) +{ + int err = -ENOSYS; + + if (CONFIG_IS_ENABLED(FS_FAT)) { + err = spl_load_image_fat_os(spl_image, bootdev, blk_dev, part); + if (!err) + return 0; + } + if (CONFIG_IS_ENABLED(FS_EXT4)) { + err = spl_load_image_ext_os(spl_image, bootdev, blk_dev, part); + if (!err) + return 0; + } + + return err; +} + +static int __maybe_unused spl_mmc_fs_load(struct spl_image_info *spl_image, + struct spl_boot_device *bootdev, + struct blk_desc *blk_dev, int part, const char *file) +{ + int err = -ENOENT; + + if (CONFIG_IS_ENABLED(FS_FAT)) { + err = spl_load_image_fat(spl_image, bootdev, blk_dev, part, file); + if (!err) + return 0; + } + if (CONFIG_IS_ENABLED(FS_EXT4)) { + err = spl_load_image_ext(spl_image, bootdev, blk_dev, part, file); + if (!err) + return 0; + } + + return err; +} + static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct spl_boot_device *bootdev, struct mmc *mmc, @@ -225,42 +265,22 @@ static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, } #endif -#ifdef CONFIG_SPL_FS_FAT if (!spl_start_uboot()) { - ret = spl_load_image_fat_os(spl_image, bootdev, mmc_get_blk_desc(mmc), - partition); + ret = spl_mmc_fs_load_os(spl_image, bootdev, + mmc_get_blk_desc(mmc), partition); if (!ret) return 0; + printf("%s, Failed to load falcon payload: %d\n", __func__, + ret); + printf("Fallback to U-Boot\n"); } -#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME - ret = spl_load_image_fat(spl_image, bootdev, mmc_get_blk_desc(mmc), - partition, - filename); - if (!ret) - return ret; -#endif -#endif -#ifdef CONFIG_SPL_FS_EXT4 - if (!spl_start_uboot()) { - ret = spl_load_image_ext_os(spl_image, bootdev, mmc_get_blk_desc(mmc), - partition); - if (!ret) - return 0; - } -#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME - ret = spl_load_image_ext(spl_image, bootdev, mmc_get_blk_desc(mmc), - partition, - filename); - if (!ret) - return 0; -#endif -#endif - -#if defined(CONFIG_SPL_FS_FAT) || defined(CONFIG_SPL_FS_EXT4) - ret = -ENOENT; -#endif +#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME + return spl_mmc_fs_load(spl_image, bootdev, mmc_get_blk_desc(mmc), + partition, filename); +#else return ret; +#endif } #endif -- cgit v1.3.1 From 81951cfffdc85e07ddeb2fa33a1a0fbbac6806f0 Mon Sep 17 00:00:00 2001 From: Anshul Dalal Date: Sat, 18 Oct 2025 01:03:08 +0530 Subject: spl: ubi: refactor spl_ubi_load_image for falcon mode This patch moves the falcon mode handling logic out of spl_ubi_load_image to spl_ubi_load_image_os, this allows for cleaner handling for fallback to U-Boot in case falcon mode fails. Signed-off-by: Anshul Dalal --- common/spl/spl_ubi.c | 44 ++++++++++++++++++++++++++++++++------------ 1 file changed, 32 insertions(+), 12 deletions(-) diff --git a/common/spl/spl_ubi.c b/common/spl/spl_ubi.c index a8d3f43b452..4aecad3470c 100644 --- a/common/spl/spl_ubi.c +++ b/common/spl/spl_ubi.c @@ -11,6 +11,32 @@ #include #include +#if IS_ENABLED(CONFIG_SPL_OS_BOOT) +int spl_ubi_load_image_os(struct spl_image_info *spl_image, + struct spl_boot_device *bootdev, + struct ubispl_info *info) +{ + struct legacy_img_hdr *header; + struct ubispl_load volumes[2]; + int err; + + volumes[0].vol_id = CONFIG_SPL_UBI_LOAD_KERNEL_ID; + volumes[0].load_addr = (void *)CONFIG_SYS_LOAD_ADDR; + volumes[1].vol_id = CONFIG_SPL_UBI_LOAD_ARGS_ID; + volumes[1].load_addr = (void *)CONFIG_SPL_PAYLOAD_ARGS_ADDR; + + err = ubispl_load_volumes(info, volumes, 2); + if (err) + return err; + + header = (struct legacy_img_hdr *)volumes[0].load_addr; + spl_parse_image_header(spl_image, bootdev, header); + puts("Linux loaded.\n"); + + return 0; +} +#endif + int spl_ubi_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { @@ -46,21 +72,15 @@ int spl_ubi_load_image(struct spl_image_info *spl_image, #if CONFIG_IS_ENABLED(OS_BOOT) if (!spl_start_uboot()) { - volumes[0].vol_id = CONFIG_SPL_UBI_LOAD_KERNEL_ID; - volumes[0].load_addr = (void *)CONFIG_SYS_LOAD_ADDR; - volumes[1].vol_id = CONFIG_SPL_UBI_LOAD_ARGS_ID; - volumes[1].load_addr = (void *)CONFIG_SPL_PAYLOAD_ARGS_ADDR; + ret = spl_ubi_load_image_os(spl_image, bootdev, &info); + if (!ret) + return 0; - ret = ubispl_load_volumes(&info, volumes, 2); - if (!ret) { - header = (struct legacy_img_hdr *)volumes[0].load_addr; - spl_parse_image_header(spl_image, bootdev, header); - puts("Linux loaded.\n"); - goto out; - } - puts("Loading Linux failed, falling back to U-Boot.\n"); + printf("%s: Failed in falcon boot: %d", __func__, ret); + printf("Fallback to U-Boot\n"); } #endif + header = spl_get_load_buffer(-sizeof(*header), sizeof(header)); #ifdef CONFIG_SPL_UBI_LOAD_BY_VOLNAME volumes[0].vol_id = -1; -- cgit v1.3.1 From a6a801fcd6cf5c484f8df6341573e364ddc948c7 Mon Sep 17 00:00:00 2001 From: Anshul Dalal Date: Sat, 18 Oct 2025 01:03:09 +0530 Subject: spl: spi: refactor spl_spi_load_image for falcon mode This patch moves the falcon mode handling logic out of spl_spi_load_image to spl_spi_load_image_os, this allows for cleaner handling for fallback to U-Boot in case falcon mode fails. Signed-off-by: Anshul Dalal --- common/spl/spl_spi.c | 31 ++++++++++++++++++++++++------- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/common/spl/spl_spi.c b/common/spl/spl_spi.c index c2b188371c2..45718824cbf 100644 --- a/common/spl/spl_spi.c +++ b/common/spl/spl_spi.c @@ -49,6 +49,25 @@ u32 __weak spl_spi_boot_cs(void) return CONFIG_SF_DEFAULT_CS; } +#if IS_ENABLED(CONFIG_SPL_OS_BOOT) +static int spl_spi_load_image_os(struct spl_image_info *spl_image, + struct spl_boot_device *bootdev, + struct spi_flash *flash, + struct spl_load_info *load) +{ + int err = spl_load(spl_image, bootdev, load, 0, + CONFIG_SYS_SPI_KERNEL_OFFS); + + if (err) + return err; + + /* Read device tree. */ + return spi_flash_read(flash, CONFIG_SYS_SPI_ARGS_OFFS, + CONFIG_SYS_SPI_ARGS_SIZE, + (void *)CONFIG_SPL_PAYLOAD_ARGS_ADDR); +} +#endif + /* * The main entry for SPI booting. It's necessary that SDRAM is already * configured and available since this code loads the main U-Boot image @@ -81,15 +100,13 @@ static int spl_spi_load_image(struct spl_image_info *spl_image, #if CONFIG_IS_ENABLED(OS_BOOT) if (!spl_start_uboot()) { - int err = spl_load(spl_image, bootdev, &load, 0, - CONFIG_SYS_SPI_KERNEL_OFFS); + err = spl_spi_load_image_os(spl_image, bootdev, flash, &load); if (!err) - /* Read device tree. */ - return spi_flash_read( - flash, CONFIG_SYS_SPI_ARGS_OFFS, - CONFIG_SYS_SPI_ARGS_SIZE, - (void *)CONFIG_SPL_PAYLOAD_ARGS_ADDR); + return 0; + + printf("%s: Failed in falcon boot: %d, fallback to U-Boot", + __func__, err); } #endif -- cgit v1.3.1 From b5446fd4787432ce3aaa9b974760276d9b0b01b5 Mon Sep 17 00:00:00 2001 From: Anshul Dalal Date: Sat, 18 Oct 2025 01:03:10 +0530 Subject: spl: nor: refactor spl_nor_load_image for falcon mode This patch moves the falcon mode handling logic out of spl_nor_load_image to spl_nor_load_image_os, this allows for cleaner handling for fallback to U-Boot in case falcon mode fails. Signed-off-by: Anshul Dalal --- common/spl/spl_nor.c | 103 +++++++++++++++++++++++++++++---------------------- 1 file changed, 58 insertions(+), 45 deletions(-) diff --git a/common/spl/spl_nor.c b/common/spl/spl_nor.c index 1021d933999..c349a4c7bc3 100644 --- a/common/spl/spl_nor.c +++ b/common/spl/spl_nor.c @@ -25,66 +25,79 @@ unsigned long __weak spl_nor_get_uboot_base(void) return CFG_SYS_UBOOT_BASE; } -static int spl_nor_load_image(struct spl_image_info *spl_image, - struct spl_boot_device *bootdev) +#if IS_ENABLED(CONFIG_SPL_OS_BOOT) +static int spl_nor_load_image_os(struct spl_image_info *spl_image, + struct spl_boot_device *bootdev) { - struct spl_load_info load; - /* - * Loading of the payload to SDRAM is done with skipping of - * the mkimage header in this SPL NOR driver + * Load Linux from its location in NOR flash to its defined + * location in SDRAM */ - spl_image->flags |= SPL_COPY_PAYLOAD_ONLY; + const struct legacy_img_hdr *header = + (const struct legacy_img_hdr *)CONFIG_SYS_OS_BASE; + struct spl_load_info load; -#if CONFIG_IS_ENABLED(OS_BOOT) - if (!spl_start_uboot()) { - /* - * Load Linux from its location in NOR flash to its defined - * location in SDRAM - */ - const struct legacy_img_hdr *header = - (const struct legacy_img_hdr *)CONFIG_SYS_OS_BASE; #ifdef CONFIG_SPL_LOAD_FIT - if (image_get_magic(header) == FDT_MAGIC) { - int ret; + if (image_get_magic(header) == FDT_MAGIC) { + int ret; - debug("Found FIT\n"); - spl_load_init(&load, spl_nor_load_read, NULL, 1); + debug("Found FIT\n"); + spl_load_init(&load, spl_nor_load_read, NULL, 1); - ret = spl_load_simple_fit(spl_image, &load, - CONFIG_SYS_OS_BASE, - (void *)header); + ret = spl_load_simple_fit(spl_image, &load, CONFIG_SYS_OS_BASE, + (void *)header); #if defined CONFIG_SPL_PAYLOAD_ARGS_ADDR && defined CONFIG_CMD_SPL_NOR_OFS - memcpy((void *)CONFIG_SPL_PAYLOAD_ARGS_ADDR, - (void *)CONFIG_CMD_SPL_NOR_OFS, - CONFIG_CMD_SPL_WRITE_SIZE); + memcpy((void *)CONFIG_SPL_PAYLOAD_ARGS_ADDR, + (void *)CONFIG_CMD_SPL_NOR_OFS, + CONFIG_CMD_SPL_WRITE_SIZE); #endif - return ret; - } + return ret; + } #endif - if (image_get_os(header) == IH_OS_LINUX) { - /* happy - was a Linux */ - int ret; - - ret = spl_parse_image_header(spl_image, bootdev, header); - if (ret) - return ret; - - memcpy((void *)spl_image->load_addr, - (void *)(CONFIG_SYS_OS_BASE + - sizeof(struct legacy_img_hdr)), - spl_image->size); + if (image_get_os(header) != IH_OS_LINUX) + return -EINVAL; + + /* happy - was a Linux */ + int ret; + + ret = spl_parse_image_header(spl_image, bootdev, header); + if (ret) + return ret; + + memcpy((void *)spl_image->load_addr, + (void *)(CONFIG_SYS_OS_BASE + sizeof(struct legacy_img_hdr)), + spl_image->size); + #ifdef CONFIG_SPL_PAYLOAD_ARGS_ADDR - spl_image->arg = (void *)CONFIG_SPL_PAYLOAD_ARGS_ADDR; + spl_image->arg = (void *)CONFIG_SPL_PAYLOAD_ARGS_ADDR; #endif + return 0; +} +#endif + +static int spl_nor_load_image(struct spl_image_info *spl_image, + struct spl_boot_device *bootdev) +{ + struct spl_load_info load; + + /* + * Loading of the payload to SDRAM is done with skipping of + * the mkimage header in this SPL NOR driver + */ + spl_image->flags |= SPL_COPY_PAYLOAD_ONLY; + +#if IS_ENABLED(CONFIG_SPL_OS_BOOT) + int err; + + if (!spl_start_uboot()) { + err = spl_nor_load_image_os(spl_image, bootdev); + if (!err) return 0; - } else { - puts("The Expected Linux image was not found.\n" - "Please check your NOR configuration.\n" - "Trying to start u-boot now...\n"); - } + + printf("%s: Failed in falcon boot: %d, fallback to U-Boot", + __func__, err); } #endif -- cgit v1.3.1 From d9a50f8f14a5e052c0731492d8223dd3b8332a8b Mon Sep 17 00:00:00 2001 From: Anshul Dalal Date: Sat, 18 Oct 2025 01:03:11 +0530 Subject: spl: nand: refactor spl_nand_load_image for falcon mode This patch moves the falcon mode handling logic out of spl_ubi_load_image to spl_ubi_load_image_os, this allows for cleaner handling for fallback to U-Boot in case falcon mode fails. Signed-off-by: Anshul Dalal --- common/spl/spl_nand.c | 95 ++++++++++++++++++++++++++++----------------------- 1 file changed, 52 insertions(+), 43 deletions(-) diff --git a/common/spl/spl_nand.c b/common/spl/spl_nand.c index 22883f4e8b9..c9f5d039768 100644 --- a/common/spl/spl_nand.c +++ b/common/spl/spl_nand.c @@ -75,6 +75,52 @@ static int spl_nand_load_element(struct spl_image_info *spl_image, return spl_load(spl_image, bootdev, &load, 0, offset); } +#if IS_ENABLED(CONFIG_SPL_OS_BOOT) +static int spl_nand_load_image_os(struct spl_image_info *spl_image, + struct spl_boot_device *bootdev) +{ + int *src, *dst, err; + struct legacy_img_hdr *header = spl_get_load_buffer(0, sizeof(*header)); + + /* load linux */ + nand_spl_load_image(CONFIG_SYS_NAND_SPL_KERNEL_OFFS, sizeof(*header), + (void *)header); + err = spl_parse_image_header(spl_image, bootdev, header); + if (err) + return err; + + if (header->ih_os != IH_OS_LINUX) + return -EINVAL; + + /* happy - was a linux */ + err = nand_spl_load_image(CONFIG_SYS_NAND_SPL_KERNEL_OFFS, + spl_image->size, + (void *)spl_image->load_addr); + nand_deselect(); + + if (err) + return err; + + /* + * load parameter image load to temp position since nand_spl_load_image + * reads a whole block which is typically larger than + * CONFIG_CMD_SPL_WRITE_SIZE therefore may overwrite following sections + * like BSS + */ + nand_spl_load_image(CONFIG_CMD_SPL_NAND_OFS, CONFIG_CMD_SPL_WRITE_SIZE, + (void *)CONFIG_TEXT_BASE); + /* copy to destintion */ + for (dst = (int *)CONFIG_SPL_PAYLOAD_ARGS_ADDR, + src = (int *)CONFIG_TEXT_BASE; + src < (int *)(CONFIG_TEXT_BASE + CONFIG_CMD_SPL_WRITE_SIZE); + src++, dst++) { + writel(readl(src), dst); + } + + return 0; +} +#endif + static int spl_nand_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { @@ -89,51 +135,14 @@ static int spl_nand_load_image(struct spl_image_info *spl_image, #if CONFIG_IS_ENABLED(OS_BOOT) if (!spl_start_uboot()) { - int *src, *dst; - struct legacy_img_hdr *header = - spl_get_load_buffer(0, sizeof(*header)); - - /* - * load parameter image - * load to temp position since nand_spl_load_image reads - * a whole block which is typically larger than - * CONFIG_CMD_SPL_WRITE_SIZE therefore may overwrite - * following sections like BSS - */ - nand_spl_load_image(CONFIG_CMD_SPL_NAND_OFS, - CONFIG_CMD_SPL_WRITE_SIZE, - (void *)CONFIG_TEXT_BASE); - /* copy to destintion */ - for (dst = (int *)CONFIG_SPL_PAYLOAD_ARGS_ADDR, - src = (int *)CONFIG_TEXT_BASE; - src < (int *)(CONFIG_TEXT_BASE + - CONFIG_CMD_SPL_WRITE_SIZE); - src++, dst++) { - writel(readl(src), dst); - } - - /* load linux */ - nand_spl_load_image(CONFIG_SYS_NAND_SPL_KERNEL_OFFS, - sizeof(*header), (void *)header); - err = spl_parse_image_header(spl_image, bootdev, header); - if (err) - return err; - if (header->ih_os == IH_OS_LINUX) { - /* happy - was a linux */ - err = nand_spl_load_image( - CONFIG_SYS_NAND_SPL_KERNEL_OFFS, - spl_image->size, - (void *)spl_image->load_addr); - nand_deselect(); - return err; - } else { - puts("The Expected Linux image was not " - "found. Please check your NAND " - "configuration.\n"); - puts("Trying to start u-boot now...\n"); - } + err = spl_nand_load_image_os(spl_image, bootdev); + if (!err) + return 0; + printf("%s: Failed in falcon boot: %d, fallback to U-Boot", + __func__, err); } #endif + #ifdef CONFIG_NAND_ENV_DST spl_nand_load_element(spl_image, bootdev, CONFIG_ENV_OFFSET); #ifdef CONFIG_ENV_OFFSET_REDUND -- cgit v1.3.1 From d3ac0d60da066bf4ddb5a60174be8108fdc16862 Mon Sep 17 00:00:00 2001 From: Anshul Dalal Date: Sat, 18 Oct 2025 01:03:12 +0530 Subject: spl: falcon: disable fallback to U-Boot on failure Instead of falling back to the standard U-Boot boot flow, we should just halt boot if the expected boot flow in falcon mode fails. This prevents a malicious actor from accessing U-Boot proper if they can cause a boot failure on falcon mode. Signed-off-by: Anshul Dalal --- common/spl/spl_mmc.c | 4 ++++ common/spl/spl_nand.c | 6 ++++-- common/spl/spl_nor.c | 6 ++++-- common/spl/spl_spi.c | 6 ++++-- common/spl/spl_ubi.c | 2 ++ 5 files changed, 18 insertions(+), 6 deletions(-) diff --git a/common/spl/spl_mmc.c b/common/spl/spl_mmc.c index bfcdea2d05f..0a00d295575 100644 --- a/common/spl/spl_mmc.c +++ b/common/spl/spl_mmc.c @@ -272,6 +272,8 @@ static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, return 0; printf("%s, Failed to load falcon payload: %d\n", __func__, ret); + if (IS_ENABLED(CONFIG_SPL_OS_BOOT_SECURE)) + return ret; printf("Fallback to U-Boot\n"); } @@ -412,6 +414,8 @@ int spl_mmc_load(struct spl_image_info *spl_image, ret = mmc_load_image_raw_os(spl_image, bootdev, mmc); if (!ret) return 0; + if (IS_ENABLED(CONFIG_SPL_OS_BOOT_SECURE)) + return ret; } raw_sect = spl_mmc_get_uboot_raw_sector(mmc, raw_sect); diff --git a/common/spl/spl_nand.c b/common/spl/spl_nand.c index c9f5d039768..3da292f1437 100644 --- a/common/spl/spl_nand.c +++ b/common/spl/spl_nand.c @@ -138,8 +138,10 @@ static int spl_nand_load_image(struct spl_image_info *spl_image, err = spl_nand_load_image_os(spl_image, bootdev); if (!err) return 0; - printf("%s: Failed in falcon boot: %d, fallback to U-Boot", - __func__, err); + printf("%s: Failed in falcon boot: %d", __func__, err); + if (IS_ENABLED(CONFIG_SPL_OS_BOOT_SECURE)) + return err; + printf("Fallback to U-Boot\n"); } #endif diff --git a/common/spl/spl_nor.c b/common/spl/spl_nor.c index c349a4c7bc3..bb91f4ab8f8 100644 --- a/common/spl/spl_nor.c +++ b/common/spl/spl_nor.c @@ -96,8 +96,10 @@ static int spl_nor_load_image(struct spl_image_info *spl_image, if (!err) return 0; - printf("%s: Failed in falcon boot: %d, fallback to U-Boot", - __func__, err); + printf("%s: Failed in falcon boot: %d", __func__, err); + if (IS_ENABLED(CONFIG_SPL_OS_BOOT_SECURE)) + return err; + printf("Fallback to U-Boot\n"); } #endif diff --git a/common/spl/spl_spi.c b/common/spl/spl_spi.c index 45718824cbf..4d61214bceb 100644 --- a/common/spl/spl_spi.c +++ b/common/spl/spl_spi.c @@ -105,8 +105,10 @@ static int spl_spi_load_image(struct spl_image_info *spl_image, if (!err) return 0; - printf("%s: Failed in falcon boot: %d, fallback to U-Boot", - __func__, err); + printf("%s: Failed in falcon boot: %d", __func__, err); + if (IS_ENABLED(CONFIG_SPL_OS_BOOT_SECURE)) + return err; + printf("Fallback to U-Boot\n"); } #endif diff --git a/common/spl/spl_ubi.c b/common/spl/spl_ubi.c index 4aecad3470c..25e7599703c 100644 --- a/common/spl/spl_ubi.c +++ b/common/spl/spl_ubi.c @@ -77,6 +77,8 @@ int spl_ubi_load_image(struct spl_image_info *spl_image, return 0; printf("%s: Failed in falcon boot: %d", __func__, ret); + if (IS_ENABLED(CONFIG_SPL_OS_BOOT_SECURE)) + return ret; printf("Fallback to U-Boot\n"); } #endif -- cgit v1.3.1