Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2014 Gateworks Corporation |
| 4 | * Copyright (C) 2011-2012 Freescale Semiconductor, Inc. |
| 5 | * |
| 6 | * Author: Tim Harvey <tharvey@gateworks.com> |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | #include <common.h> |
Simon Glass | f11478f | 2019-12-28 10:45:07 -0700 | [diff] [blame] | 10 | #include <hang.h> |
Simon Glass | 9758973 | 2020-05-10 11:40:02 -0600 | [diff] [blame] | 11 | #include <init.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 12 | #include <log.h> |
Simon Glass | 3ba929a | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 13 | #include <asm/global_data.h> |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 14 | #include <asm/io.h> |
| 15 | #include <asm/arch/imx-regs.h> |
Jagan Teki | e5f970b | 2017-02-24 15:45:12 +0530 | [diff] [blame] | 16 | #include <asm/arch/sys_proto.h> |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 17 | #include <asm/spl.h> |
| 18 | #include <spl.h> |
Stefano Babic | 33731bc | 2017-06-29 10:16:06 +0200 | [diff] [blame] | 19 | #include <asm/mach-imx/hab.h> |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 20 | #include <asm/mach-imx/boot_mode.h> |
Fabio Estevam | a0e462b | 2017-09-05 20:46:39 -0300 | [diff] [blame] | 21 | #include <g_dnl.h> |
Alexandru Gagniuc | 44af2a5 | 2021-01-20 10:46:49 -0600 | [diff] [blame] | 22 | #include <linux/libfdt.h> |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 23 | |
Jagan Teki | 7bb61bb | 2017-08-28 16:45:47 +0530 | [diff] [blame] | 24 | DECLARE_GLOBAL_DATA_PTR; |
| 25 | |
Peng Fan | cffe732 | 2019-08-27 06:25:07 +0000 | [diff] [blame] | 26 | __weak int spl_board_boot_device(enum boot_device boot_dev_spl) |
| 27 | { |
| 28 | return 0; |
| 29 | } |
| 30 | |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 31 | #if defined(CONFIG_MX6) |
Nikita Kiryanov | 9fba842 | 2014-10-29 19:28:33 +0200 | [diff] [blame] | 32 | /* determine boot device from SRC_SBMR1 (BOOT_CFG[4:1]) or SRC_GPR9 register */ |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 33 | u32 spl_boot_device(void) |
| 34 | { |
Jagan Teki | c981a94 | 2017-02-24 15:45:15 +0530 | [diff] [blame] | 35 | unsigned int bmode = readl(&src_base->sbmr2); |
Jagan Teki | e5f970b | 2017-02-24 15:45:12 +0530 | [diff] [blame] | 36 | u32 reg = imx6_src_get_boot_mode(); |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 37 | |
Stefano Babic | 587e72e | 2015-12-11 17:30:42 +0100 | [diff] [blame] | 38 | /* |
| 39 | * Check for BMODE if serial downloader is enabled |
| 40 | * BOOT_MODE - see IMX6DQRM Table 8-1 |
| 41 | */ |
Stefan Agner | 1539096 | 2016-12-27 17:01:42 +0100 | [diff] [blame] | 42 | if (((bmode >> 24) & 0x03) == 0x01) /* Serial Downloader */ |
Stefan Agner | a0a50ce | 2017-08-15 17:49:43 -0700 | [diff] [blame] | 43 | return BOOT_DEVICE_BOARD; |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 44 | |
Stefan Agner | 47f547e | 2017-09-13 14:29:45 -0700 | [diff] [blame] | 45 | /* |
| 46 | * The above method does not detect that the boot ROM used |
| 47 | * serial downloader in case the boot ROM decided to use the |
| 48 | * serial downloader as a fall back (primary boot source failed). |
| 49 | * |
| 50 | * Infer that the boot ROM used the USB serial downloader by |
| 51 | * checking whether the USB PHY is currently active... This |
| 52 | * assumes that SPL did not (yet) initialize the USB PHY... |
| 53 | */ |
| 54 | if (is_usbotg_phy_active()) |
| 55 | return BOOT_DEVICE_BOARD; |
| 56 | |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 57 | /* BOOT_CFG1[7:4] - see IMX6DQRM Table 8-8 */ |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 58 | switch ((reg & IMX6_BMODE_MASK) >> IMX6_BMODE_SHIFT) { |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 59 | /* EIM: See 8.5.1, Table 8-9 */ |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 60 | case IMX6_BMODE_EMI: |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 61 | /* BOOT_CFG1[3]: NOR/OneNAND Selection */ |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 62 | switch ((reg & IMX6_BMODE_EMI_MASK) >> IMX6_BMODE_EMI_SHIFT) { |
| 63 | case IMX6_BMODE_ONENAND: |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 64 | return BOOT_DEVICE_ONENAND; |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 65 | case IMX6_BMODE_NOR: |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 66 | return BOOT_DEVICE_NOR; |
| 67 | break; |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 68 | } |
Stefan Agner | 1539096 | 2016-12-27 17:01:42 +0100 | [diff] [blame] | 69 | /* Reserved: Used to force Serial Downloader */ |
Stefan Agner | 53456f5 | 2017-08-15 17:49:42 -0700 | [diff] [blame] | 70 | case IMX6_BMODE_RESERVED: |
Stefan Agner | a0a50ce | 2017-08-15 17:49:43 -0700 | [diff] [blame] | 71 | return BOOT_DEVICE_BOARD; |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 72 | /* SATA: See 8.5.4, Table 8-20 */ |
Stefan Agner | 34da473 | 2017-08-29 09:10:11 -0700 | [diff] [blame] | 73 | #if !defined(CONFIG_MX6UL) && !defined(CONFIG_MX6ULL) |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 74 | case IMX6_BMODE_SATA: |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 75 | return BOOT_DEVICE_SATA; |
Stefan Agner | 34da473 | 2017-08-29 09:10:11 -0700 | [diff] [blame] | 76 | #endif |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 77 | /* Serial ROM: See 8.5.5.1, Table 8-22 */ |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 78 | case IMX6_BMODE_SERIAL_ROM: |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 79 | /* BOOT_CFG4[2:0] */ |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 80 | switch ((reg & IMX6_BMODE_SERIAL_ROM_MASK) >> |
| 81 | IMX6_BMODE_SERIAL_ROM_SHIFT) { |
| 82 | case IMX6_BMODE_ECSPI1: |
| 83 | case IMX6_BMODE_ECSPI2: |
| 84 | case IMX6_BMODE_ECSPI3: |
| 85 | case IMX6_BMODE_ECSPI4: |
| 86 | case IMX6_BMODE_ECSPI5: |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 87 | return BOOT_DEVICE_SPI; |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 88 | case IMX6_BMODE_I2C1: |
| 89 | case IMX6_BMODE_I2C2: |
| 90 | case IMX6_BMODE_I2C3: |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 91 | return BOOT_DEVICE_I2C; |
| 92 | } |
| 93 | break; |
| 94 | /* SD/eSD: 8.5.3, Table 8-15 */ |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 95 | case IMX6_BMODE_SD: |
| 96 | case IMX6_BMODE_ESD: |
Adam Ford | a2a91e2 | 2019-10-08 07:56:44 -0500 | [diff] [blame] | 97 | return BOOT_DEVICE_MMC1; |
| 98 | /* MMC/eMMC: 8.5.3 */ |
Jagan Teki | 32a7114 | 2017-02-24 15:45:14 +0530 | [diff] [blame] | 99 | case IMX6_BMODE_MMC: |
| 100 | case IMX6_BMODE_EMMC: |
Adam Ford | a2a91e2 | 2019-10-08 07:56:44 -0500 | [diff] [blame] | 101 | return BOOT_DEVICE_MMC1; |
Jagan Teki | 4191b22 | 2017-02-24 15:45:13 +0530 | [diff] [blame] | 102 | /* NAND Flash: 8.5.2, Table 8-10 */ |
Eran Matityahu | 5fa7ca6 | 2017-12-14 20:20:02 +0200 | [diff] [blame] | 103 | case IMX6_BMODE_NAND_MIN ... IMX6_BMODE_NAND_MAX: |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 104 | return BOOT_DEVICE_NAND; |
Stefan Roese | fe41e32 | 2019-09-20 18:09:08 +0200 | [diff] [blame] | 105 | #if defined(CONFIG_MX6UL) || defined(CONFIG_MX6ULL) |
| 106 | /* QSPI boot */ |
| 107 | case IMX6_BMODE_QSPI: |
| 108 | return BOOT_DEVICE_SPI; |
| 109 | #endif |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 110 | } |
| 111 | return BOOT_DEVICE_NONE; |
| 112 | } |
Fabio Estevam | a0e462b | 2017-09-05 20:46:39 -0300 | [diff] [blame] | 113 | |
Peng Fan | 9d5bc07 | 2018-12-21 06:21:23 +0000 | [diff] [blame] | 114 | #elif defined(CONFIG_MX7) || defined(CONFIG_IMX8M) || defined(CONFIG_IMX8) |
Peng Fan | 39945c1 | 2018-11-20 10:19:25 +0000 | [diff] [blame] | 115 | /* Translate iMX7/i.MX8M boot device to the SPL boot device enumeration */ |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 116 | u32 spl_boot_device(void) |
| 117 | { |
Eran Matityahu | 52fef1c | 2018-03-06 16:38:00 +0200 | [diff] [blame] | 118 | #if defined(CONFIG_MX7) |
| 119 | unsigned int bmode = readl(&src_base->sbmr2); |
| 120 | |
| 121 | /* |
| 122 | * Check for BMODE if serial downloader is enabled |
| 123 | * BOOT_MODE - see IMX7DRM Table 6-24 |
| 124 | */ |
| 125 | if (((bmode >> 24) & 0x03) == 0x01) /* Serial Downloader */ |
| 126 | return BOOT_DEVICE_BOARD; |
| 127 | |
| 128 | /* |
| 129 | * The above method does not detect that the boot ROM used |
| 130 | * serial downloader in case the boot ROM decided to use the |
| 131 | * serial downloader as a fall back (primary boot source failed). |
| 132 | * |
| 133 | * Infer that the boot ROM used the USB serial downloader by |
| 134 | * checking whether the USB PHY is currently active... This |
| 135 | * assumes that SPL did not (yet) initialize the USB PHY... |
| 136 | */ |
| 137 | if (is_boot_from_usb()) |
| 138 | return BOOT_DEVICE_BOARD; |
| 139 | #endif |
| 140 | |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 141 | enum boot_device boot_device_spl = get_boot_device(); |
| 142 | |
Peng Fan | e7997ef | 2019-12-27 10:27:49 +0800 | [diff] [blame] | 143 | if (IS_ENABLED(CONFIG_IMX8MM) || IS_ENABLED(CONFIG_IMX8MN) || |
| 144 | IS_ENABLED(CONFIG_IMX8MP)) |
Peng Fan | cffe732 | 2019-08-27 06:25:07 +0000 | [diff] [blame] | 145 | return spl_board_boot_device(boot_device_spl); |
| 146 | |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 147 | switch (boot_device_spl) { |
Peng Fan | 30f17ec | 2018-11-20 10:19:29 +0000 | [diff] [blame] | 148 | #if defined(CONFIG_MX7) |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 149 | case SD1_BOOT: |
| 150 | case MMC1_BOOT: |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 151 | case SD2_BOOT: |
| 152 | case MMC2_BOOT: |
Eran Matityahu | 3d7aa68 | 2018-01-03 12:56:24 +0200 | [diff] [blame] | 153 | case SD3_BOOT: |
| 154 | case MMC3_BOOT: |
Eran Matityahu | 7359655 | 2018-01-03 12:53:08 +0200 | [diff] [blame] | 155 | return BOOT_DEVICE_MMC1; |
Peng Fan | 9d5bc07 | 2018-12-21 06:21:23 +0000 | [diff] [blame] | 156 | #elif defined(CONFIG_IMX8) |
| 157 | case MMC1_BOOT: |
| 158 | return BOOT_DEVICE_MMC1; |
| 159 | case SD2_BOOT: |
| 160 | return BOOT_DEVICE_MMC2_2; |
| 161 | case SD3_BOOT: |
| 162 | return BOOT_DEVICE_MMC1; |
| 163 | case FLEXSPI_BOOT: |
| 164 | return BOOT_DEVICE_SPI; |
Peng Fan | 30f17ec | 2018-11-20 10:19:29 +0000 | [diff] [blame] | 165 | #elif defined(CONFIG_IMX8M) |
| 166 | case SD1_BOOT: |
| 167 | case MMC1_BOOT: |
| 168 | return BOOT_DEVICE_MMC1; |
| 169 | case SD2_BOOT: |
| 170 | case MMC2_BOOT: |
| 171 | return BOOT_DEVICE_MMC2; |
| 172 | #endif |
Eran Matityahu | 3d7aa68 | 2018-01-03 12:56:24 +0200 | [diff] [blame] | 173 | case NAND_BOOT: |
| 174 | return BOOT_DEVICE_NAND; |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 175 | case SPI_NOR_BOOT: |
| 176 | return BOOT_DEVICE_SPI; |
Peng Fan | 037f91c | 2018-05-17 15:15:59 +0800 | [diff] [blame] | 177 | case QSPI_BOOT: |
| 178 | return BOOT_DEVICE_NOR; |
Peng Fan | 58f19b4 | 2018-01-10 13:20:26 +0800 | [diff] [blame] | 179 | case USB_BOOT: |
| 180 | return BOOT_DEVICE_USB; |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 181 | default: |
| 182 | return BOOT_DEVICE_NONE; |
| 183 | } |
| 184 | } |
Peng Fan | 9d5bc07 | 2018-12-21 06:21:23 +0000 | [diff] [blame] | 185 | #endif /* CONFIG_MX7 || CONFIG_IMX8M || CONFIG_IMX8 */ |
Uri Mashiach | 5dd4689 | 2017-09-24 09:00:24 +0300 | [diff] [blame] | 186 | |
Jean-Jacques Hiblot | 6a22852 | 2019-01-10 15:44:13 +0100 | [diff] [blame] | 187 | #ifdef CONFIG_SPL_USB_GADGET |
Fabio Estevam | a0e462b | 2017-09-05 20:46:39 -0300 | [diff] [blame] | 188 | int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name) |
| 189 | { |
Maxime Ripard | 7f78b9d | 2017-09-07 08:58:08 +0200 | [diff] [blame] | 190 | put_unaligned(CONFIG_USB_GADGET_PRODUCT_NUM + 0xfff, &dev->idProduct); |
Fabio Estevam | a0e462b | 2017-09-05 20:46:39 -0300 | [diff] [blame] | 191 | |
| 192 | return 0; |
| 193 | } |
Peng Fan | 8f97c26 | 2020-08-18 18:16:47 +0800 | [diff] [blame] | 194 | |
| 195 | #define SDPV_BCD_DEVICE 0x500 |
| 196 | int g_dnl_get_board_bcd_device_number(int gcnum) |
| 197 | { |
| 198 | return SDPV_BCD_DEVICE; |
| 199 | } |
Fabio Estevam | a0e462b | 2017-09-05 20:46:39 -0300 | [diff] [blame] | 200 | #endif |
Tim Harvey | 354a7e3 | 2014-06-02 16:13:20 -0700 | [diff] [blame] | 201 | |
Simon Glass | b58bfe0 | 2021-08-08 12:20:09 -0600 | [diff] [blame] | 202 | #if defined(CONFIG_SPL_MMC) |
Fabio Estevam | 550b52e | 2018-02-15 12:41:40 -0200 | [diff] [blame] | 203 | /* called from spl_mmc to see type of boot mode for storage (RAW or FAT) */ |
Harald Seiler | 0bf7ab1 | 2020-04-15 11:33:30 +0200 | [diff] [blame] | 204 | u32 spl_mmc_boot_mode(const u32 boot_device) |
Fabio Estevam | 550b52e | 2018-02-15 12:41:40 -0200 | [diff] [blame] | 205 | { |
Peng Fan | 1dd4cc3 | 2019-10-16 10:24:25 +0000 | [diff] [blame] | 206 | #if defined(CONFIG_MX7) || defined(CONFIG_IMX8M) || defined(CONFIG_IMX8) |
| 207 | switch (get_boot_device()) { |
| 208 | /* for MMC return either RAW or FAT mode */ |
| 209 | case SD1_BOOT: |
| 210 | case SD2_BOOT: |
| 211 | case SD3_BOOT: |
Harald Seiler | fbbb318 | 2020-04-23 13:07:53 +0200 | [diff] [blame] | 212 | if (IS_ENABLED(CONFIG_SPL_FS_FAT)) |
Harald Seiler | 5152681 | 2020-04-23 13:07:52 +0200 | [diff] [blame] | 213 | return MMCSD_MODE_FS; |
| 214 | else |
| 215 | return MMCSD_MODE_RAW; |
Peng Fan | 1dd4cc3 | 2019-10-16 10:24:25 +0000 | [diff] [blame] | 216 | case MMC1_BOOT: |
| 217 | case MMC2_BOOT: |
| 218 | case MMC3_BOOT: |
Harald Seiler | fbbb318 | 2020-04-23 13:07:53 +0200 | [diff] [blame] | 219 | if (IS_ENABLED(CONFIG_SPL_FS_FAT)) |
Harald Seiler | 5152681 | 2020-04-23 13:07:52 +0200 | [diff] [blame] | 220 | return MMCSD_MODE_FS; |
| 221 | else if (IS_ENABLED(CONFIG_SUPPORT_EMMC_BOOT)) |
| 222 | return MMCSD_MODE_EMMCBOOT; |
| 223 | else |
| 224 | return MMCSD_MODE_RAW; |
Peng Fan | 1dd4cc3 | 2019-10-16 10:24:25 +0000 | [diff] [blame] | 225 | default: |
| 226 | puts("spl: ERROR: unsupported device\n"); |
| 227 | hang(); |
| 228 | } |
| 229 | #else |
Anatolij Gustschin | 62499ff | 2020-04-23 13:07:49 +0200 | [diff] [blame] | 230 | switch (boot_device) { |
Fabio Estevam | 550b52e | 2018-02-15 12:41:40 -0200 | [diff] [blame] | 231 | /* for MMC return either RAW or FAT mode */ |
| 232 | case BOOT_DEVICE_MMC1: |
| 233 | case BOOT_DEVICE_MMC2: |
Peng Fan | 9d5bc07 | 2018-12-21 06:21:23 +0000 | [diff] [blame] | 234 | case BOOT_DEVICE_MMC2_2: |
Harald Seiler | 5152681 | 2020-04-23 13:07:52 +0200 | [diff] [blame] | 235 | if (IS_ENABLED(CONFIG_SPL_FS_FAT)) |
| 236 | return MMCSD_MODE_FS; |
| 237 | else if (IS_ENABLED(CONFIG_SUPPORT_EMMC_BOOT)) |
| 238 | return MMCSD_MODE_EMMCBOOT; |
| 239 | else |
| 240 | return MMCSD_MODE_RAW; |
Fabio Estevam | 550b52e | 2018-02-15 12:41:40 -0200 | [diff] [blame] | 241 | default: |
| 242 | puts("spl: ERROR: unsupported device\n"); |
| 243 | hang(); |
| 244 | } |
Peng Fan | 1dd4cc3 | 2019-10-16 10:24:25 +0000 | [diff] [blame] | 245 | #endif |
Fabio Estevam | 550b52e | 2018-02-15 12:41:40 -0200 | [diff] [blame] | 246 | } |
| 247 | #endif |
| 248 | |
Stefano Babic | f8b509b | 2019-09-20 08:47:53 +0200 | [diff] [blame] | 249 | #if defined(CONFIG_IMX_HAB) |
Sven Ebenfeld | eba5e33 | 2016-11-06 16:37:55 +0100 | [diff] [blame] | 250 | |
Bryan O'Donoghue | 8891996 | 2018-01-12 12:40:01 +0000 | [diff] [blame] | 251 | /* |
| 252 | * +------------+ 0x0 (DDR_UIMAGE_START) - |
| 253 | * | Header | | |
| 254 | * +------------+ 0x40 | |
| 255 | * | | | |
| 256 | * | | | |
| 257 | * | | | |
| 258 | * | | | |
| 259 | * | Image Data | | |
| 260 | * . | | |
| 261 | * . | > Stuff to be authenticated ----+ |
| 262 | * . | | | |
| 263 | * | | | | |
| 264 | * | | | | |
| 265 | * +------------+ | | |
| 266 | * | | | | |
| 267 | * | Fill Data | | | |
| 268 | * | | | | |
| 269 | * +------------+ Align to ALIGN_SIZE | | |
| 270 | * | IVT | | | |
| 271 | * +------------+ + IVT_SIZE - | |
| 272 | * | | | |
| 273 | * | CSF DATA | <---------------------------------------------------------+ |
| 274 | * | | |
| 275 | * +------------+ |
| 276 | * | | |
| 277 | * | Fill Data | |
| 278 | * | | |
| 279 | * +------------+ + CSF_PAD_SIZE |
| 280 | */ |
| 281 | |
Sven Ebenfeld | eba5e33 | 2016-11-06 16:37:55 +0100 | [diff] [blame] | 282 | __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image) |
| 283 | { |
| 284 | typedef void __noreturn (*image_entry_noargs_t)(void); |
Bryan O'Donoghue | 8891996 | 2018-01-12 12:40:01 +0000 | [diff] [blame] | 285 | uint32_t offset; |
Sven Ebenfeld | eba5e33 | 2016-11-06 16:37:55 +0100 | [diff] [blame] | 286 | |
| 287 | image_entry_noargs_t image_entry = |
| 288 | (image_entry_noargs_t)(unsigned long)spl_image->entry_point; |
| 289 | |
Tom Rini | f1c2fc0 | 2017-01-11 10:45:48 -0500 | [diff] [blame] | 290 | debug("image entry point: 0x%lX\n", spl_image->entry_point); |
Sven Ebenfeld | eba5e33 | 2016-11-06 16:37:55 +0100 | [diff] [blame] | 291 | |
Ye Li | 9d5b0f4 | 2018-11-17 09:10:25 +0000 | [diff] [blame] | 292 | if (spl_image->flags & SPL_FIT_FOUND) { |
Sven Ebenfeld | eba5e33 | 2016-11-06 16:37:55 +0100 | [diff] [blame] | 293 | image_entry(); |
| 294 | } else { |
Ye Li | 9d5b0f4 | 2018-11-17 09:10:25 +0000 | [diff] [blame] | 295 | /* |
| 296 | * HAB looks for the CSF at the end of the authenticated |
| 297 | * data therefore, we need to subtract the size of the |
| 298 | * CSF from the actual filesize |
| 299 | */ |
| 300 | offset = spl_image->size - CONFIG_CSF_SIZE; |
| 301 | if (!imx_hab_authenticate_image(spl_image->load_addr, |
| 302 | offset + IVT_SIZE + |
| 303 | CSF_PAD_SIZE, offset)) { |
| 304 | image_entry(); |
| 305 | } else { |
Marek Vasut | 579fd51 | 2020-05-30 20:29:00 +0200 | [diff] [blame] | 306 | panic("spl: ERROR: image authentication fail\n"); |
Ye Li | 9d5b0f4 | 2018-11-17 09:10:25 +0000 | [diff] [blame] | 307 | } |
| 308 | } |
| 309 | } |
| 310 | |
Ricardo Salveti | d7d649c | 2019-09-02 18:18:52 -0300 | [diff] [blame] | 311 | #if !defined(CONFIG_SPL_FIT_SIGNATURE) |
Ye Li | 9d5b0f4 | 2018-11-17 09:10:25 +0000 | [diff] [blame] | 312 | ulong board_spl_fit_size_align(ulong size) |
| 313 | { |
| 314 | /* |
| 315 | * HAB authenticate_image requests the IVT offset is |
| 316 | * aligned to 0x1000 |
| 317 | */ |
| 318 | |
| 319 | size = ALIGN(size, 0x1000); |
| 320 | size += CONFIG_CSF_SIZE; |
| 321 | |
| 322 | return size; |
| 323 | } |
| 324 | |
Alexandru Gagniuc | 44af2a5 | 2021-01-20 10:46:49 -0600 | [diff] [blame] | 325 | void board_spl_fit_post_load(const void *fit) |
Ye Li | 9d5b0f4 | 2018-11-17 09:10:25 +0000 | [diff] [blame] | 326 | { |
Alexandru Gagniuc | 44af2a5 | 2021-01-20 10:46:49 -0600 | [diff] [blame] | 327 | u32 offset = ALIGN(fdt_totalsize(fit), 0x1000); |
Ye Li | 9d5b0f4 | 2018-11-17 09:10:25 +0000 | [diff] [blame] | 328 | |
Alexandru Gagniuc | 44af2a5 | 2021-01-20 10:46:49 -0600 | [diff] [blame] | 329 | if (imx_hab_authenticate_image((uintptr_t)fit, |
Ye Li | 9d5b0f4 | 2018-11-17 09:10:25 +0000 | [diff] [blame] | 330 | offset + IVT_SIZE + CSF_PAD_SIZE, |
| 331 | offset)) { |
Marek Vasut | 579fd51 | 2020-05-30 20:29:00 +0200 | [diff] [blame] | 332 | panic("spl: ERROR: image authentication unsuccessful\n"); |
Sven Ebenfeld | eba5e33 | 2016-11-06 16:37:55 +0100 | [diff] [blame] | 333 | } |
| 334 | } |
Ricardo Salveti | d7d649c | 2019-09-02 18:18:52 -0300 | [diff] [blame] | 335 | #endif |
Sven Ebenfeld | eba5e33 | 2016-11-06 16:37:55 +0100 | [diff] [blame] | 336 | |
Jagan Teki | 7bb61bb | 2017-08-28 16:45:47 +0530 | [diff] [blame] | 337 | #endif |
| 338 | |
| 339 | #if defined(CONFIG_MX6) && defined(CONFIG_SPL_OS_BOOT) |
| 340 | int dram_init_banksize(void) |
| 341 | { |
| 342 | gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE; |
| 343 | gd->bd->bi_dram[0].size = imx_ddr_size(); |
| 344 | |
| 345 | return 0; |
| 346 | } |
Sven Ebenfeld | eba5e33 | 2016-11-06 16:37:55 +0100 | [diff] [blame] | 347 | #endif |
Heiko Schocher | f3c450b | 2021-08-06 06:44:27 +0200 | [diff] [blame^] | 348 | |
| 349 | /* |
| 350 | * read the address where the IVT header must sit |
| 351 | * from IVT image header, loaded from SPL into |
| 352 | * an malloced buffer and copy the IVT header |
| 353 | * to this address |
| 354 | */ |
| 355 | void *spl_load_simple_fit_fix_load(const void *fit) |
| 356 | { |
| 357 | struct ivt *ivt; |
| 358 | unsigned long new; |
| 359 | unsigned long offset; |
| 360 | unsigned long size; |
| 361 | u8 *tmp = (u8 *)fit; |
| 362 | |
| 363 | offset = ALIGN(fdt_totalsize(fit), 0x1000); |
| 364 | size = ALIGN(fdt_totalsize(fit), 4); |
| 365 | size = board_spl_fit_size_align(size); |
| 366 | tmp += offset; |
| 367 | ivt = (struct ivt *)tmp; |
| 368 | if (ivt->hdr.magic != IVT_HEADER_MAGIC) { |
| 369 | debug("no IVT header found\n"); |
| 370 | return (void *)fit; |
| 371 | } |
| 372 | debug("%s: ivt: %p offset: %lx size: %lx\n", __func__, ivt, offset, size); |
| 373 | debug("%s: ivt self: %x\n", __func__, ivt->self); |
| 374 | new = ivt->self; |
| 375 | new -= offset; |
| 376 | debug("%s: new %lx\n", __func__, new); |
| 377 | memcpy((void *)new, fit, size); |
| 378 | |
| 379 | return (void *)new; |
| 380 | } |