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