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