[people/ms/u-boot.git] / arch / arm / mach-imx / spl.c

/*
 * Copyright (C) 2014 Gateworks Corporation
 * Copyright (C) 2011-2012 Freescale Semiconductor, Inc.
 *
 * Author: Tim Harvey <tharvey@gateworks.com>
 *
 * SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <asm/io.h>
#include <asm/arch/imx-regs.h>
#include <asm/arch/sys_proto.h>
#include <asm/spl.h>
#include <spl.h>
#include <asm/mach-imx/hab.h>
#include <asm/mach-imx/boot_mode.h>
#include <g_dnl.h>

DECLARE_GLOBAL_DATA_PTR;

#if defined(CONFIG_MX6)
/* determine boot device from SRC_SBMR1 (BOOT_CFG[4:1]) or SRC_GPR9 register */
u32 spl_boot_device(void)
{
	unsigned int bmode = readl(&src_base->sbmr2);
	u32 reg = imx6_src_get_boot_mode();

	/*
	 * Check for BMODE if serial downloader is enabled
	 * BOOT_MODE - see IMX6DQRM Table 8-1
	 */
	if (((bmode >> 24) & 0x03) == 0x01) /* Serial Downloader */
		return BOOT_DEVICE_BOARD;

	/*
	 * The above method does not detect that the boot ROM used
	 * serial downloader in case the boot ROM decided to use the
	 * serial downloader as a fall back (primary boot source failed).
	 *
	 * Infer that the boot ROM used the USB serial downloader by
	 * checking whether the USB PHY is currently active... This
	 * assumes that SPL did not (yet) initialize the USB PHY...
	 */
	if (is_usbotg_phy_active())
		return BOOT_DEVICE_BOARD;

	/* BOOT_CFG1[7:4] - see IMX6DQRM Table 8-8 */
	switch ((reg & IMX6_BMODE_MASK) >> IMX6_BMODE_SHIFT) {
	 /* EIM: See 8.5.1, Table 8-9 */
	case IMX6_BMODE_EMI:
		/* BOOT_CFG1[3]: NOR/OneNAND Selection */
		switch ((reg & IMX6_BMODE_EMI_MASK) >> IMX6_BMODE_EMI_SHIFT) {
		case IMX6_BMODE_ONENAND:
			return BOOT_DEVICE_ONENAND;
		case IMX6_BMODE_NOR:
			return BOOT_DEVICE_NOR;
		break;
		}
	/* Reserved: Used to force Serial Downloader */
	case IMX6_BMODE_RESERVED:
		return BOOT_DEVICE_BOARD;
	/* SATA: See 8.5.4, Table 8-20 */
#if !defined(CONFIG_MX6UL) && !defined(CONFIG_MX6ULL)
	case IMX6_BMODE_SATA:
		return BOOT_DEVICE_SATA;
#endif
	/* Serial ROM: See 8.5.5.1, Table 8-22 */
	case IMX6_BMODE_SERIAL_ROM:
		/* BOOT_CFG4[2:0] */
		switch ((reg & IMX6_BMODE_SERIAL_ROM_MASK) >>
			IMX6_BMODE_SERIAL_ROM_SHIFT) {
		case IMX6_BMODE_ECSPI1:
		case IMX6_BMODE_ECSPI2:
		case IMX6_BMODE_ECSPI3:
		case IMX6_BMODE_ECSPI4:
		case IMX6_BMODE_ECSPI5:
			return BOOT_DEVICE_SPI;
		case IMX6_BMODE_I2C1:
		case IMX6_BMODE_I2C2:
		case IMX6_BMODE_I2C3:
			return BOOT_DEVICE_I2C;
		}
		break;
	/* SD/eSD: 8.5.3, Table 8-15  */
	case IMX6_BMODE_SD:
	case IMX6_BMODE_ESD:
		return BOOT_DEVICE_MMC1;
	/* MMC/eMMC: 8.5.3 */
	case IMX6_BMODE_MMC:
	case IMX6_BMODE_EMMC:
		return BOOT_DEVICE_MMC1;
	/* NAND Flash: 8.5.2, Table 8-10 */
	case IMX6_BMODE_NAND_MIN ... IMX6_BMODE_NAND_MAX:
		return BOOT_DEVICE_NAND;
	}
	return BOOT_DEVICE_NONE;
}

#elif defined(CONFIG_MX7) || defined(CONFIG_MX8M)
/* Translate iMX7/MX8M boot device to the SPL boot device enumeration */
u32 spl_boot_device(void)
{
	enum boot_device boot_device_spl = get_boot_device();

	switch (boot_device_spl) {
	case SD1_BOOT:
	case MMC1_BOOT:
	case SD2_BOOT:
	case MMC2_BOOT:
	case SD3_BOOT:
	case MMC3_BOOT:
		return BOOT_DEVICE_MMC1;
	case NAND_BOOT:
		return BOOT_DEVICE_NAND;
	case SPI_NOR_BOOT:
		return BOOT_DEVICE_SPI;
	case USB_BOOT:
		return BOOT_DEVICE_USB;
	default:
		return BOOT_DEVICE_NONE;
	}
}
#endif /* CONFIG_MX6 || CONFIG_MX7 || CONFIG_MX8M */

#ifdef CONFIG_SPL_USB_GADGET_SUPPORT
int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name)
{
	put_unaligned(CONFIG_USB_GADGET_PRODUCT_NUM + 0xfff, &dev->idProduct);

	return 0;
}
#endif

#if defined(CONFIG_SPL_MMC_SUPPORT)
/* called from spl_mmc to see type of boot mode for storage (RAW or FAT) */
u32 spl_boot_mode(const u32 boot_device)
{
	switch (spl_boot_device()) {
	/* for MMC return either RAW or FAT mode */
	case BOOT_DEVICE_MMC1:
	case BOOT_DEVICE_MMC2:
#if defined(CONFIG_SPL_FAT_SUPPORT)
		return MMCSD_MODE_FS;
#elif defined(CONFIG_SUPPORT_EMMC_BOOT)
		return MMCSD_MODE_EMMCBOOT;
#else
		return MMCSD_MODE_RAW;
#endif
		break;
	default:
		puts("spl: ERROR:  unsupported device\n");
		hang();
	}
}
#endif

#if defined(CONFIG_SECURE_BOOT)

/*
 * +------------+  0x0 (DDR_UIMAGE_START) -
 * |   Header   |                          |
 * +------------+  0x40                    |
 * |            |                          |
 * |            |                          |
 * |            |                          |
 * |            |                          |
 * | Image Data |                          |
 * .            |                          |
 * .            |                           > Stuff to be authenticated ----+
 * .            |                          |                                |
 * |            |                          |                                |
 * |            |                          |                                |
 * +------------+                          |                                |
 * |            |                          |                                |
 * | Fill Data  |                          |                                |
 * |            |                          |                                |
 * +------------+ Align to ALIGN_SIZE      |                                |
 * |    IVT     |                          |                                |
 * +------------+ + IVT_SIZE              -                                 |
 * |            |                                                           |
 * |  CSF DATA  | <---------------------------------------------------------+
 * |            |
 * +------------+
 * |            |
 * | Fill Data  |
 * |            |
 * +------------+ + CSF_PAD_SIZE
 */

__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
{
	typedef void __noreturn (*image_entry_noargs_t)(void);
	uint32_t offset;

	image_entry_noargs_t image_entry =
		(image_entry_noargs_t)(unsigned long)spl_image->entry_point;

	debug("image entry point: 0x%lX\n", spl_image->entry_point);

	/* HAB looks for the CSF at the end of the authenticated data therefore,
	 * we need to subtract the size of the CSF from the actual filesize */
	offset = spl_image->size - CONFIG_CSF_SIZE;
	if (!imx_hab_authenticate_image(spl_image->load_addr,
					offset + IVT_SIZE + CSF_PAD_SIZE,
					offset)) {
		image_entry();
	} else {
		puts("spl: ERROR:  image authentication unsuccessful\n");
		hang();
	}
}

#endif

#if defined(CONFIG_MX6) && defined(CONFIG_SPL_OS_BOOT)
int dram_init_banksize(void)
{
	gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;
	gd->bd->bi_dram[0].size = imx_ddr_size();

	return 0;
}
#endif
Commit	Line	Data
887717db TH	1	/*
	2	* Copyright (C) 2014 Gateworks Corporation
	3	* Copyright (C) 2011-2012 Freescale Semiconductor, Inc.
	4	*
	5	* Author: Tim Harvey <tharvey@gateworks.com>
	6	*
	7	* SPDX-License-Identifier: GPL-2.0+
	8	*/
	9
	10	#include <common.h>
	11	#include <asm/io.h>
	12	#include <asm/arch/imx-regs.h>
cba586b4	13	#include <asm/arch/sys_proto.h>
887717db TH	14	#include <asm/spl.h>
887717db TH	15	#include <spl.h>
552a848e	16	#include <asm/mach-imx/hab.h>
c5c6f37a	17	#include <asm/mach-imx/boot_mode.h>
511db3bf	18	#include <g_dnl.h>
887717db	19
46668df5 JT	20	DECLARE_GLOBAL_DATA_PTR;
46668df5 JT	21
887717db	22	#if defined(CONFIG_MX6)
f2863ff3	23	/* determine boot device from SRC_SBMR1 (BOOT_CFG[4:1]) or SRC_GPR9 register */
887717db TH	24	u32 spl_boot_device(void)
887717db TH	25	{
7b54f5a8	26	unsigned int bmode = readl(&src_base->sbmr2);
cba586b4	27	u32 reg = imx6_src_get_boot_mode();
887717db	28
40f4839c SB	29	/*
	30	* Check for BMODE if serial downloader is enabled
	31	* BOOT_MODE - see IMX6DQRM Table 8-1
	32	*/
ac0a93fd	33	if (((bmode >> 24) & 0x03) == 0x01) /* Serial Downloader */
962c78b1	34	return BOOT_DEVICE_BOARD;
96aac843	35
e203dcf2 SA	36	/*
	37	* The above method does not detect that the boot ROM used
	38	* serial downloader in case the boot ROM decided to use the
	39	* serial downloader as a fall back (primary boot source failed).
	40	*
	41	* Infer that the boot ROM used the USB serial downloader by
	42	* checking whether the USB PHY is currently active... This
	43	* assumes that SPL did not (yet) initialize the USB PHY...
	44	*/
	45	if (is_usbotg_phy_active())
	46	return BOOT_DEVICE_BOARD;
	47
887717db	48	/* BOOT_CFG1[7:4] - see IMX6DQRM Table 8-8 */
96aac843	49	switch ((reg & IMX6_BMODE_MASK) >> IMX6_BMODE_SHIFT) {
887717db	50	/* EIM: See 8.5.1, Table 8-9 */
96aac843	51	case IMX6_BMODE_EMI:
887717db	52	/* BOOT_CFG1[3]: NOR/OneNAND Selection */
96aac843 JT	53	switch ((reg & IMX6_BMODE_EMI_MASK) >> IMX6_BMODE_EMI_SHIFT) {
96aac843 JT	54	case IMX6_BMODE_ONENAND:
887717db	55	return BOOT_DEVICE_ONENAND;
96aac843	56	case IMX6_BMODE_NOR:
887717db TH	57	return BOOT_DEVICE_NOR;
887717db TH	58	break;
96aac843	59	}
ac0a93fd	60	/* Reserved: Used to force Serial Downloader */
3bd1642d	61	case IMX6_BMODE_RESERVED:
962c78b1	62	return BOOT_DEVICE_BOARD;
887717db	63	/* SATA: See 8.5.4, Table 8-20 */
624da53c	64	#if !defined(CONFIG_MX6UL) && !defined(CONFIG_MX6ULL)
96aac843	65	case IMX6_BMODE_SATA:
887717db	66	return BOOT_DEVICE_SATA;
624da53c	67	#endif
887717db	68	/* Serial ROM: See 8.5.5.1, Table 8-22 */
96aac843	69	case IMX6_BMODE_SERIAL_ROM:
887717db	70	/* BOOT_CFG4[2:0] */
96aac843 JT	71	switch ((reg & IMX6_BMODE_SERIAL_ROM_MASK) >>
	72	IMX6_BMODE_SERIAL_ROM_SHIFT) {
	73	case IMX6_BMODE_ECSPI1:
	74	case IMX6_BMODE_ECSPI2:
	75	case IMX6_BMODE_ECSPI3:
	76	case IMX6_BMODE_ECSPI4:
	77	case IMX6_BMODE_ECSPI5:
887717db	78	return BOOT_DEVICE_SPI;
96aac843 JT	79	case IMX6_BMODE_I2C1:
	80	case IMX6_BMODE_I2C2:
	81	case IMX6_BMODE_I2C3:
887717db TH	82	return BOOT_DEVICE_I2C;
	83	}
	84	break;
	85	/* SD/eSD: 8.5.3, Table 8-15 */
96aac843 JT	86	case IMX6_BMODE_SD:
96aac843 JT	87	case IMX6_BMODE_ESD:
51efabac	88	return BOOT_DEVICE_MMC1;
887717db	89	/* MMC/eMMC: 8.5.3 */
96aac843 JT	90	case IMX6_BMODE_MMC:
96aac843 JT	91	case IMX6_BMODE_EMMC:
887717db	92	return BOOT_DEVICE_MMC1;
20f14714	93	/* NAND Flash: 8.5.2, Table 8-10 */
af104ae5	94	case IMX6_BMODE_NAND_MIN ... IMX6_BMODE_NAND_MAX:
887717db TH	95	return BOOT_DEVICE_NAND;
	96	}
	97	return BOOT_DEVICE_NONE;
	98	}
511db3bf	99
d7cb10a0 PF	100	#elif defined(CONFIG_MX7) \|\| defined(CONFIG_MX8M)
d7cb10a0 PF	101	/* Translate iMX7/MX8M boot device to the SPL boot device enumeration */
c5c6f37a UM	102	u32 spl_boot_device(void)
	103	{
	104	enum boot_device boot_device_spl = get_boot_device();
	105
	106	switch (boot_device_spl) {
	107	case SD1_BOOT:
	108	case MMC1_BOOT:
c5c6f37a UM	109	case SD2_BOOT:
c5c6f37a UM	110	case MMC2_BOOT:
e7528a3d EM	111	case SD3_BOOT:
e7528a3d EM	112	case MMC3_BOOT:
cd9f3ff6	113	return BOOT_DEVICE_MMC1;
e7528a3d EM	114	case NAND_BOOT:
e7528a3d EM	115	return BOOT_DEVICE_NAND;
c5c6f37a UM	116	case SPI_NOR_BOOT:
c5c6f37a UM	117	return BOOT_DEVICE_SPI;
d7cb10a0 PF	118	case USB_BOOT:
d7cb10a0 PF	119	return BOOT_DEVICE_USB;
c5c6f37a UM	120	default:
	121	return BOOT_DEVICE_NONE;
	122	}
	123	}
d7cb10a0	124	#endif /* CONFIG_MX6 \|\| CONFIG_MX7 \|\| CONFIG_MX8M */
c5c6f37a	125
511db3bf FE	126	#ifdef CONFIG_SPL_USB_GADGET_SUPPORT
	127	int g_dnl_bind_fixup(struct usb_device_descriptor dev, const char name)
	128	{
a95aee6a	129	put_unaligned(CONFIG_USB_GADGET_PRODUCT_NUM + 0xfff, &dev->idProduct);
511db3bf FE	130
	131	return 0;
	132	}
	133	#endif
887717db	134
0339086b FE	135	#if defined(CONFIG_SPL_MMC_SUPPORT)
	136	/* called from spl_mmc to see type of boot mode for storage (RAW or FAT) */
	137	u32 spl_boot_mode(const u32 boot_device)
	138	{
	139	switch (spl_boot_device()) {
	140	/* for MMC return either RAW or FAT mode */
	141	case BOOT_DEVICE_MMC1:
	142	case BOOT_DEVICE_MMC2:
	143	#if defined(CONFIG_SPL_FAT_SUPPORT)
	144	return MMCSD_MODE_FS;
	145	#elif defined(CONFIG_SUPPORT_EMMC_BOOT)
	146	return MMCSD_MODE_EMMCBOOT;
	147	#else
	148	return MMCSD_MODE_RAW;
	149	#endif
	150	break;
	151	default:
	152	puts("spl: ERROR: unsupported device\n");
	153	hang();
	154	}
	155	}
	156	#endif
	157
15b505b0 SE	158	#if defined(CONFIG_SECURE_BOOT)
15b505b0 SE	159
c5800b25 BD	160	/*
	161	* +------------+ 0x0 (DDR_UIMAGE_START) -
	162	* \| Header \| \|
	163	* +------------+ 0x40 \|
	164	* \| \| \|
	165	* \| \| \|
	166	* \| \| \|
	167	* \| \| \|
	168	* \| Image Data \| \|
	169	* . \| \|
	170	* . \| > Stuff to be authenticated ----+
	171	* . \| \| \|
	172	* \| \| \| \|
	173	* \| \| \| \|
	174	* +------------+ \| \|
	175	* \| \| \| \|
	176	* \| Fill Data \| \| \|
	177	* \| \| \| \|
	178	* +------------+ Align to ALIGN_SIZE \| \|
	179	* \| IVT \| \| \|
	180	* +------------+ + IVT_SIZE - \|
	181	* \| \| \|
	182	* \| CSF DATA \| <---------------------------------------------------------+
	183	* \| \|
	184	* +------------+
	185	* \| \|
	186	* \| Fill Data \|
	187	* \| \|
	188	* +------------+ + CSF_PAD_SIZE
	189	*/
	190
15b505b0 SE	191	__weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
	192	{
	193	typedef void __noreturn (*image_entry_noargs_t)(void);
c5800b25	194	uint32_t offset;
15b505b0 SE	195
	196	image_entry_noargs_t image_entry =
	197	(image_entry_noargs_t)(unsigned long)spl_image->entry_point;
	198
4386feb7	199	debug("image entry point: 0x%lX\n", spl_image->entry_point);
15b505b0 SE	200
	201	/* HAB looks for the CSF at the end of the authenticated data therefore,
	202	* we need to subtract the size of the CSF from the actual filesize */
c5800b25	203	offset = spl_image->size - CONFIG_CSF_SIZE;
57f65486 BD	204	if (!imx_hab_authenticate_image(spl_image->load_addr,
	205	offset + IVT_SIZE + CSF_PAD_SIZE,
	206	offset)) {
15b505b0 SE	207	image_entry();
	208	} else {
	209	puts("spl: ERROR: image authentication unsuccessful\n");
	210	hang();
	211	}
	212	}
	213
	214	#endif
46668df5 JT	215
	216	#if defined(CONFIG_MX6) && defined(CONFIG_SPL_OS_BOOT)
	217	int dram_init_banksize(void)
	218	{
	219	gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;
	220	gd->bd->bi_dram[0].size = imx_ddr_size();
	221
	222	return 0;
	223	}
	224	#endif