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