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