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