arch/arm/mach-imx/spl.c

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