1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Copyright (C) 2014 Gateworks Corporation 4 * Copyright (C) 2011-2012 Freescale Semiconductor, Inc. 5 * 6 * Author: Tim Harvey <tharvey@gateworks.com> 7 */ 8 9#include <common.h> 10#include <hang.h> 11#include <init.h> 12#include <log.h> 13#include <asm/io.h> 14#include <asm/arch/imx-regs.h> 15#include <asm/arch/sys_proto.h> 16#include <asm/spl.h> 17#include <spl.h> 18#include <asm/mach-imx/hab.h> 19#include <asm/mach-imx/boot_mode.h> 20#include <g_dnl.h> 21 22DECLARE_GLOBAL_DATA_PTR; 23 24__weak int spl_board_boot_device(enum boot_device boot_dev_spl) 25{ 26 return 0; 27} 28 29#if defined(CONFIG_MX6) 30/* determine boot device from SRC_SBMR1 (BOOT_CFG[4:1]) or SRC_GPR9 register */ 31u32 spl_boot_device(void) 32{ 33 unsigned int bmode = readl(&src_base->sbmr2); 34 u32 reg = imx6_src_get_boot_mode(); 35 36 /* 37 * Check for BMODE if serial downloader is enabled 38 * BOOT_MODE - see IMX6DQRM Table 8-1 39 */ 40 if (((bmode >> 24) & 0x03) == 0x01) /* Serial Downloader */ 41 return BOOT_DEVICE_BOARD; 42 43 /* 44 * The above method does not detect that the boot ROM used 45 * serial downloader in case the boot ROM decided to use the 46 * serial downloader as a fall back (primary boot source failed). 47 * 48 * Infer that the boot ROM used the USB serial downloader by 49 * checking whether the USB PHY is currently active... This 50 * assumes that SPL did not (yet) initialize the USB PHY... 51 */ 52 if (is_usbotg_phy_active()) 53 return BOOT_DEVICE_BOARD; 54 55 /* BOOT_CFG1[7:4] - see IMX6DQRM Table 8-8 */ 56 switch ((reg & IMX6_BMODE_MASK) >> IMX6_BMODE_SHIFT) { 57 /* EIM: See 8.5.1, Table 8-9 */ 58 case IMX6_BMODE_EMI: 59 /* BOOT_CFG1[3]: NOR/OneNAND Selection */ 60 switch ((reg & IMX6_BMODE_EMI_MASK) >> IMX6_BMODE_EMI_SHIFT) { 61 case IMX6_BMODE_ONENAND: 62 return BOOT_DEVICE_ONENAND; 63 case IMX6_BMODE_NOR: 64 return BOOT_DEVICE_NOR; 65 break; 66 } 67 /* Reserved: Used to force Serial Downloader */ 68 case IMX6_BMODE_RESERVED: 69 return BOOT_DEVICE_BOARD; 70 /* SATA: See 8.5.4, Table 8-20 */ 71#if !defined(CONFIG_MX6UL) && !defined(CONFIG_MX6ULL) 72 case IMX6_BMODE_SATA: 73 return BOOT_DEVICE_SATA; 74#endif 75 /* Serial ROM: See 8.5.5.1, Table 8-22 */ 76 case IMX6_BMODE_SERIAL_ROM: 77 /* BOOT_CFG4[2:0] */ 78 switch ((reg & IMX6_BMODE_SERIAL_ROM_MASK) >> 79 IMX6_BMODE_SERIAL_ROM_SHIFT) { 80 case IMX6_BMODE_ECSPI1: 81 case IMX6_BMODE_ECSPI2: 82 case IMX6_BMODE_ECSPI3: 83 case IMX6_BMODE_ECSPI4: 84 case IMX6_BMODE_ECSPI5: 85 return BOOT_DEVICE_SPI; 86 case IMX6_BMODE_I2C1: 87 case IMX6_BMODE_I2C2: 88 case IMX6_BMODE_I2C3: 89 return BOOT_DEVICE_I2C; 90 } 91 break; 92 /* SD/eSD: 8.5.3, Table 8-15 */ 93 case IMX6_BMODE_SD: 94 case IMX6_BMODE_ESD: 95 return BOOT_DEVICE_MMC1; 96 /* MMC/eMMC: 8.5.3 */ 97 case IMX6_BMODE_MMC: 98 case IMX6_BMODE_EMMC: 99 return BOOT_DEVICE_MMC1; 100 /* NAND Flash: 8.5.2, Table 8-10 */ 101 case IMX6_BMODE_NAND_MIN ... IMX6_BMODE_NAND_MAX: 102 return BOOT_DEVICE_NAND; 103#if defined(CONFIG_MX6UL) || defined(CONFIG_MX6ULL) 104 /* QSPI boot */ 105 case IMX6_BMODE_QSPI: 106 return BOOT_DEVICE_SPI; 107#endif 108 } 109 return BOOT_DEVICE_NONE; 110} 111 112#elif defined(CONFIG_MX7) || defined(CONFIG_IMX8M) || defined(CONFIG_IMX8) 113/* Translate iMX7/i.MX8M boot device to the SPL boot device enumeration */ 114u32 spl_boot_device(void) 115{ 116#if defined(CONFIG_MX7) 117 unsigned int bmode = readl(&src_base->sbmr2); 118 119 /* 120 * Check for BMODE if serial downloader is enabled 121 * BOOT_MODE - see IMX7DRM Table 6-24 122 */ 123 if (((bmode >> 24) & 0x03) == 0x01) /* Serial Downloader */ 124 return BOOT_DEVICE_BOARD; 125 126 /* 127 * The above method does not detect that the boot ROM used 128 * serial downloader in case the boot ROM decided to use the 129 * serial downloader as a fall back (primary boot source failed). 130 * 131 * Infer that the boot ROM used the USB serial downloader by 132 * checking whether the USB PHY is currently active... This 133 * assumes that SPL did not (yet) initialize the USB PHY... 134 */ 135 if (is_boot_from_usb()) 136 return BOOT_DEVICE_BOARD; 137#endif 138 139 enum boot_device boot_device_spl = get_boot_device(); 140 141 if (IS_ENABLED(CONFIG_IMX8MM) || IS_ENABLED(CONFIG_IMX8MN) || 142 IS_ENABLED(CONFIG_IMX8MP)) 143 return spl_board_boot_device(boot_device_spl); 144 145 switch (boot_device_spl) { 146#if defined(CONFIG_MX7) 147 case SD1_BOOT: 148 case MMC1_BOOT: 149 case SD2_BOOT: 150 case MMC2_BOOT: 151 case SD3_BOOT: 152 case MMC3_BOOT: 153 return BOOT_DEVICE_MMC1; 154#elif defined(CONFIG_IMX8) 155 case MMC1_BOOT: 156 return BOOT_DEVICE_MMC1; 157 case SD2_BOOT: 158 return BOOT_DEVICE_MMC2_2; 159 case SD3_BOOT: 160 return BOOT_DEVICE_MMC1; 161 case FLEXSPI_BOOT: 162 return BOOT_DEVICE_SPI; 163#elif defined(CONFIG_IMX8M) 164 case SD1_BOOT: 165 case MMC1_BOOT: 166 return BOOT_DEVICE_MMC1; 167 case SD2_BOOT: 168 case MMC2_BOOT: 169 return BOOT_DEVICE_MMC2; 170#endif 171 case NAND_BOOT: 172 return BOOT_DEVICE_NAND; 173 case SPI_NOR_BOOT: 174 return BOOT_DEVICE_SPI; 175 case USB_BOOT: 176 return BOOT_DEVICE_USB; 177 default: 178 return BOOT_DEVICE_NONE; 179 } 180} 181#endif /* CONFIG_MX7 || CONFIG_IMX8M || CONFIG_IMX8 */ 182 183#ifdef CONFIG_SPL_USB_GADGET 184int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name) 185{ 186 put_unaligned(CONFIG_USB_GADGET_PRODUCT_NUM + 0xfff, &dev->idProduct); 187 188 return 0; 189} 190 191#define SDPV_BCD_DEVICE 0x500 192int g_dnl_get_board_bcd_device_number(int gcnum) 193{ 194 return SDPV_BCD_DEVICE; 195} 196#endif 197 198#if defined(CONFIG_SPL_MMC_SUPPORT) 199/* called from spl_mmc to see type of boot mode for storage (RAW or FAT) */ 200u32 spl_mmc_boot_mode(const u32 boot_device) 201{ 202#if defined(CONFIG_MX7) || defined(CONFIG_IMX8M) || defined(CONFIG_IMX8) 203 switch (get_boot_device()) { 204 /* for MMC return either RAW or FAT mode */ 205 case SD1_BOOT: 206 case SD2_BOOT: 207 case SD3_BOOT: 208 if (IS_ENABLED(CONFIG_SPL_FS_FAT)) 209 return MMCSD_MODE_FS; 210 else 211 return MMCSD_MODE_RAW; 212 case MMC1_BOOT: 213 case MMC2_BOOT: 214 case MMC3_BOOT: 215 if (IS_ENABLED(CONFIG_SPL_FS_FAT)) 216 return MMCSD_MODE_FS; 217 else if (IS_ENABLED(CONFIG_SUPPORT_EMMC_BOOT)) 218 return MMCSD_MODE_EMMCBOOT; 219 else 220 return MMCSD_MODE_RAW; 221 default: 222 puts("spl: ERROR: unsupported device\n"); 223 hang(); 224 } 225#else 226 switch (boot_device) { 227 /* for MMC return either RAW or FAT mode */ 228 case BOOT_DEVICE_MMC1: 229 case BOOT_DEVICE_MMC2: 230 case BOOT_DEVICE_MMC2_2: 231 if (IS_ENABLED(CONFIG_SPL_FS_FAT)) 232 return MMCSD_MODE_FS; 233 else if (IS_ENABLED(CONFIG_SUPPORT_EMMC_BOOT)) 234 return MMCSD_MODE_EMMCBOOT; 235 else 236 return MMCSD_MODE_RAW; 237 default: 238 puts("spl: ERROR: unsupported device\n"); 239 hang(); 240 } 241#endif 242} 243#endif 244 245#if defined(CONFIG_IMX_HAB) 246 247/* 248 * +------------+ 0x0 (DDR_UIMAGE_START) - 249 * | Header | | 250 * +------------+ 0x40 | 251 * | | | 252 * | | | 253 * | | | 254 * | | | 255 * | Image Data | | 256 * . | | 257 * . | > Stuff to be authenticated ----+ 258 * . | | | 259 * | | | | 260 * | | | | 261 * +------------+ | | 262 * | | | | 263 * | Fill Data | | | 264 * | | | | 265 * +------------+ Align to ALIGN_SIZE | | 266 * | IVT | | | 267 * +------------+ + IVT_SIZE - | 268 * | | | 269 * | CSF DATA | <---------------------------------------------------------+ 270 * | | 271 * +------------+ 272 * | | 273 * | Fill Data | 274 * | | 275 * +------------+ + CSF_PAD_SIZE 276 */ 277 278__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image) 279{ 280 typedef void __noreturn (*image_entry_noargs_t)(void); 281 uint32_t offset; 282 283 image_entry_noargs_t image_entry = 284 (image_entry_noargs_t)(unsigned long)spl_image->entry_point; 285 286 debug("image entry point: 0x%lX\n", spl_image->entry_point); 287 288 if (spl_image->flags & SPL_FIT_FOUND) { 289 image_entry(); 290 } else { 291 /* 292 * HAB looks for the CSF at the end of the authenticated 293 * data therefore, we need to subtract the size of the 294 * CSF from the actual filesize 295 */ 296 offset = spl_image->size - CONFIG_CSF_SIZE; 297 if (!imx_hab_authenticate_image(spl_image->load_addr, 298 offset + IVT_SIZE + 299 CSF_PAD_SIZE, offset)) { 300 image_entry(); 301 } else { 302 panic("spl: ERROR: image authentication fail\n"); 303 } 304 } 305} 306 307#if !defined(CONFIG_SPL_FIT_SIGNATURE) 308ulong board_spl_fit_size_align(ulong size) 309{ 310 /* 311 * HAB authenticate_image requests the IVT offset is 312 * aligned to 0x1000 313 */ 314 315 size = ALIGN(size, 0x1000); 316 size += CONFIG_CSF_SIZE; 317 318 return size; 319} 320 321void board_spl_fit_post_load(ulong load_addr, size_t length) 322{ 323 u32 offset = length - CONFIG_CSF_SIZE; 324 325 if (imx_hab_authenticate_image(load_addr, 326 offset + IVT_SIZE + CSF_PAD_SIZE, 327 offset)) { 328 panic("spl: ERROR: image authentication unsuccessful\n"); 329 } 330} 331#endif 332 333#endif 334 335#if defined(CONFIG_MX6) && defined(CONFIG_SPL_OS_BOOT) 336int dram_init_banksize(void) 337{ 338 gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE; 339 gd->bd->bi_dram[0].size = imx_ddr_size(); 340 341 return 0; 342} 343#endif 344