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 <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
  22 DECLARE_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 */
  31 u32 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 */
 114 u32 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 QSPI_BOOT:
 176                 return BOOT_DEVICE_NOR;
 177         case USB_BOOT:
 178                 return BOOT_DEVICE_USB;
 179         default:
 180                 return BOOT_DEVICE_NONE;
 181         }
 182 }
 183 #endif /* CONFIG_MX7 || CONFIG_IMX8M || CONFIG_IMX8 */
 184
 185 #ifdef CONFIG_SPL_USB_GADGET
 186 int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name)
 187 {
 188         put_unaligned(CONFIG_USB_GADGET_PRODUCT_NUM + 0xfff, &dev->idProduct);
 189
 190         return 0;
 191 }
 192
 193 #define SDPV_BCD_DEVICE 0x500
 194 int g_dnl_get_board_bcd_device_number(int gcnum)
 195 {
 196         return SDPV_BCD_DEVICE;
 197 }
 198 #endif
 199
 200 #if defined(CONFIG_SPL_MMC_SUPPORT)
 201 /* called from spl_mmc to see type of boot mode for storage (RAW or FAT) */
 202 u32 spl_mmc_boot_mode(const u32 boot_device)
 203 {
 204 #if defined(CONFIG_MX7) || defined(CONFIG_IMX8M) || defined(CONFIG_IMX8)
 205         switch (get_boot_device()) {
 206         /* for MMC return either RAW or FAT mode */
 207         case SD1_BOOT:
 208         case SD2_BOOT:
 209         case SD3_BOOT:
 210                 if (IS_ENABLED(CONFIG_SPL_FS_FAT))
 211                         return MMCSD_MODE_FS;
 212                 else
 213                         return MMCSD_MODE_RAW;
 214         case MMC1_BOOT:
 215         case MMC2_BOOT:
 216         case MMC3_BOOT:
 217                 if (IS_ENABLED(CONFIG_SPL_FS_FAT))
 218                         return MMCSD_MODE_FS;
 219                 else if (IS_ENABLED(CONFIG_SUPPORT_EMMC_BOOT))
 220                         return MMCSD_MODE_EMMCBOOT;
 221                 else
 222                         return MMCSD_MODE_RAW;
 223         default:
 224                 puts("spl: ERROR:  unsupported device\n");
 225                 hang();
 226         }
 227 #else
 228         switch (boot_device) {
 229         /* for MMC return either RAW or FAT mode */
 230         case BOOT_DEVICE_MMC1:
 231         case BOOT_DEVICE_MMC2:
 232         case BOOT_DEVICE_MMC2_2:
 233                 if (IS_ENABLED(CONFIG_SPL_FS_FAT))
 234                         return MMCSD_MODE_FS;
 235                 else if (IS_ENABLED(CONFIG_SUPPORT_EMMC_BOOT))
 236                         return MMCSD_MODE_EMMCBOOT;
 237                 else
 238                         return MMCSD_MODE_RAW;
 239         default:
 240                 puts("spl: ERROR:  unsupported device\n");
 241                 hang();
 242         }
 243 #endif
 244 }
 245 #endif
 246
 247 #if defined(CONFIG_IMX_HAB)
 248
 249 /*
 250  * +------------+  0x0 (DDR_UIMAGE_START) -
 251  * |   Header   |                          |
 252  * +------------+  0x40                    |
 253  * |            |                          |
 254  * |            |                          |
 255  * |            |                          |
 256  * |            |                          |
 257  * | Image Data |                          |
 258  * .            |                          |
 259  * .            |                           > Stuff to be authenticated ----+
 260  * .            |                          |                                |
 261  * |            |                          |                                |
 262  * |            |                          |                                |
 263  * +------------+                          |                                |
 264  * |            |                          |                                |
 265  * | Fill Data  |                          |                                |
 266  * |            |                          |                                |
 267  * +------------+ Align to ALIGN_SIZE      |                                |
 268  * |    IVT     |                          |                                |
 269  * +------------+ + IVT_SIZE              -                                 |
 270  * |            |                                                           |
 271  * |  CSF DATA  | <---------------------------------------------------------+
 272  * |            |
 273  * +------------+
 274  * |            |
 275  * | Fill Data  |
 276  * |            |
 277  * +------------+ + CSF_PAD_SIZE
 278  */
 279
 280 __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
 281 {
 282         typedef void __noreturn (*image_entry_noargs_t)(void);
 283         uint32_t offset;
 284
 285         image_entry_noargs_t image_entry =
 286                 (image_entry_noargs_t)(unsigned long)spl_image->entry_point;
 287
 288         debug("image entry point: 0x%lX\n", spl_image->entry_point);
 289
 290         if (spl_image->flags & SPL_FIT_FOUND) {
 291                 image_entry();
 292         } else {
 293                 /*
 294                  * HAB looks for the CSF at the end of the authenticated
 295                  * data therefore, we need to subtract the size of the
 296                  * CSF from the actual filesize
 297                  */
 298                 offset = spl_image->size - CONFIG_CSF_SIZE;
 299                 if (!imx_hab_authenticate_image(spl_image->load_addr,
 300                                                 offset + IVT_SIZE +
 301                                                 CSF_PAD_SIZE, offset)) {
 302                         image_entry();
 303                 } else {
 304                         panic("spl: ERROR:  image authentication fail\n");
 305                 }
 306         }
 307 }
 308
 309 #if !defined(CONFIG_SPL_FIT_SIGNATURE)
 310 ulong board_spl_fit_size_align(ulong size)
 311 {
 312         /*
 313          * HAB authenticate_image requests the IVT offset is
 314          * aligned to 0x1000
 315          */
 316
 317         size = ALIGN(size, 0x1000);
 318         size += CONFIG_CSF_SIZE;
 319
 320         return size;
 321 }
 322
 323 void board_spl_fit_post_load(ulong load_addr, size_t length)
 324 {
 325         u32 offset = length - CONFIG_CSF_SIZE;
 326
 327         if (imx_hab_authenticate_image(load_addr,
 328                                        offset + IVT_SIZE + CSF_PAD_SIZE,
 329                                        offset)) {
 330                 panic("spl: ERROR:  image authentication unsuccessful\n");
 331         }
 332 }
 333 #endif
 334
 335 #endif
 336
 337 #if defined(CONFIG_MX6) && defined(CONFIG_SPL_OS_BOOT)
 338 int dram_init_banksize(void)
 339 {
 340         gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;
 341         gd->bd->bi_dram[0].size = imx_ddr_size();
 342
 343         return 0;
 344 }
 345 #endif