2018-05-06 21:58:06 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2012-01-09 20:38:59 +00:00
|
|
|
/*
|
|
|
|
* boot-common.c
|
|
|
|
*
|
|
|
|
* Common bootmode functions for omap based boards
|
|
|
|
*
|
|
|
|
* Copyright (C) 2011, Texas Instruments, Incorporated - http://www.ti.com/
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <common.h>
|
2014-12-15 14:02:58 +00:00
|
|
|
#include <ahci.h>
|
2020-05-10 17:40:05 +00:00
|
|
|
#include <log.h>
|
2022-01-27 12:16:52 +00:00
|
|
|
#include <dm/uclass.h>
|
|
|
|
#include <fs_loader.h>
|
2012-08-13 19:03:19 +00:00
|
|
|
#include <spl.h>
|
2020-10-31 03:38:53 +00:00
|
|
|
#include <asm/global_data.h>
|
2012-01-09 20:38:59 +00:00
|
|
|
#include <asm/omap_common.h>
|
|
|
|
#include <asm/arch/omap.h>
|
2012-08-14 17:25:15 +00:00
|
|
|
#include <asm/arch/mmc_host_def.h>
|
2012-11-06 13:06:28 +00:00
|
|
|
#include <asm/arch/sys_proto.h>
|
2013-10-01 16:32:04 +00:00
|
|
|
#include <watchdog.h>
|
2014-12-15 14:02:58 +00:00
|
|
|
#include <scsi.h>
|
2015-07-15 14:02:19 +00:00
|
|
|
#include <i2c.h>
|
2022-01-27 12:16:52 +00:00
|
|
|
#include <remoteproc.h>
|
2012-01-09 20:38:59 +00:00
|
|
|
|
2013-04-24 00:41:24 +00:00
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
2012-01-09 20:38:59 +00:00
|
|
|
|
2022-01-27 12:16:52 +00:00
|
|
|
#define IPU1_LOAD_ADDR (0xa17ff000)
|
|
|
|
#define MAX_REMOTECORE_BIN_SIZE (8 * 0x100000)
|
|
|
|
#define IPU2_LOAD_ADDR (IPU1_LOAD_ADDR + MAX_REMOTECORE_BIN_SIZE)
|
|
|
|
|
2015-07-15 14:02:23 +00:00
|
|
|
__weak u32 omap_sys_boot_device(void)
|
|
|
|
{
|
|
|
|
return BOOT_DEVICE_NONE;
|
|
|
|
}
|
|
|
|
|
2013-05-31 16:31:59 +00:00
|
|
|
void save_omap_boot_params(void)
|
|
|
|
{
|
2015-07-15 14:02:19 +00:00
|
|
|
u32 boot_params = *((u32 *)OMAP_SRAM_SCRATCH_BOOT_PARAMS);
|
|
|
|
struct omap_boot_parameters *omap_boot_params;
|
2015-08-27 08:46:09 +00:00
|
|
|
int sys_boot_device = 0;
|
2015-07-15 14:02:19 +00:00
|
|
|
u32 boot_device;
|
|
|
|
u32 boot_mode;
|
2013-05-31 16:31:59 +00:00
|
|
|
|
2015-07-15 14:02:19 +00:00
|
|
|
if ((boot_params < NON_SECURE_SRAM_START) ||
|
|
|
|
(boot_params > NON_SECURE_SRAM_END))
|
2013-05-31 16:31:59 +00:00
|
|
|
return;
|
|
|
|
|
2015-07-15 14:02:19 +00:00
|
|
|
omap_boot_params = (struct omap_boot_parameters *)boot_params;
|
|
|
|
|
|
|
|
boot_device = omap_boot_params->boot_device;
|
2015-07-15 14:02:23 +00:00
|
|
|
boot_mode = MMCSD_MODE_UNDEFINED;
|
|
|
|
|
|
|
|
/* Boot device */
|
2015-07-15 14:02:19 +00:00
|
|
|
|
|
|
|
#ifdef BOOT_DEVICE_NAND_I2C
|
2014-11-12 10:57:33 +00:00
|
|
|
/*
|
|
|
|
* Re-map NAND&I2C boot-device to the "normal" NAND boot-device.
|
|
|
|
* Otherwise the SPL boot IF can't handle this device correctly.
|
|
|
|
* Somehow booting with Hynix 4GBit NAND H27U4G8 on Siemens
|
|
|
|
* Draco leads to this boot-device passed to SPL from the BootROM.
|
|
|
|
*/
|
|
|
|
if (boot_device == BOOT_DEVICE_NAND_I2C)
|
|
|
|
boot_device = BOOT_DEVICE_NAND;
|
|
|
|
#endif
|
2015-07-15 14:02:21 +00:00
|
|
|
#ifdef BOOT_DEVICE_QSPI_4
|
2014-04-03 11:52:56 +00:00
|
|
|
/*
|
|
|
|
* We get different values for QSPI_1 and QSPI_4 being used, but
|
|
|
|
* don't actually care about this difference. Rather than
|
|
|
|
* mangle the later code, if we're coming in as QSPI_4 just
|
|
|
|
* change to the QSPI_1 value.
|
|
|
|
*/
|
2015-07-15 14:02:21 +00:00
|
|
|
if (boot_device == BOOT_DEVICE_QSPI_4)
|
2015-07-15 14:02:19 +00:00
|
|
|
boot_device = BOOT_DEVICE_SPI;
|
2017-06-15 17:57:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_TI816X
|
|
|
|
/*
|
|
|
|
* On PG2.0 and later TI816x the values we get when booting are not the
|
|
|
|
* same as on PG1.0, which is what the defines are based on. Update
|
|
|
|
* them as needed.
|
|
|
|
*/
|
|
|
|
if (get_cpu_rev() != 1) {
|
|
|
|
if (boot_device == 0x05) {
|
|
|
|
omap_boot_params->boot_device = BOOT_DEVICE_NAND;
|
|
|
|
boot_device = BOOT_DEVICE_NAND;
|
|
|
|
}
|
|
|
|
if (boot_device == 0x08) {
|
|
|
|
omap_boot_params->boot_device = BOOT_DEVICE_MMC1;
|
|
|
|
boot_device = BOOT_DEVICE_MMC1;
|
|
|
|
}
|
|
|
|
}
|
2015-07-15 14:02:19 +00:00
|
|
|
#endif
|
2015-07-15 14:02:23 +00:00
|
|
|
/*
|
|
|
|
* When booting from peripheral booting, the boot device is not usable
|
|
|
|
* as-is (unless there is support for it), so the boot device is instead
|
|
|
|
* figured out using the SYS_BOOT pins.
|
|
|
|
*/
|
|
|
|
switch (boot_device) {
|
2015-08-27 08:46:09 +00:00
|
|
|
#if defined(BOOT_DEVICE_UART) && !defined(CONFIG_SPL_YMODEM_SUPPORT)
|
|
|
|
case BOOT_DEVICE_UART:
|
|
|
|
sys_boot_device = 1;
|
|
|
|
break;
|
2015-07-15 14:02:23 +00:00
|
|
|
#endif
|
2019-02-01 16:40:07 +00:00
|
|
|
#if defined(BOOT_DEVICE_USB) && !defined(CONFIG_SPL_USB_STORAGE)
|
2015-08-27 08:46:09 +00:00
|
|
|
case BOOT_DEVICE_USB:
|
|
|
|
sys_boot_device = 1;
|
|
|
|
break;
|
2015-07-15 14:02:23 +00:00
|
|
|
#endif
|
2018-02-16 15:47:44 +00:00
|
|
|
#if defined(BOOT_DEVICE_USBETH) && !defined(CONFIG_SPL_USB_ETHER)
|
2015-08-27 08:46:09 +00:00
|
|
|
case BOOT_DEVICE_USBETH:
|
|
|
|
sys_boot_device = 1;
|
|
|
|
break;
|
|
|
|
#endif
|
2021-07-11 03:14:26 +00:00
|
|
|
#if defined(BOOT_DEVICE_CPGMAC) && !defined(CONFIG_SPL_ETH)
|
2015-08-27 08:46:09 +00:00
|
|
|
case BOOT_DEVICE_CPGMAC:
|
|
|
|
sys_boot_device = 1;
|
|
|
|
break;
|
2016-07-28 12:09:17 +00:00
|
|
|
#endif
|
2019-01-17 19:43:02 +00:00
|
|
|
#if defined(BOOT_DEVICE_DFU) && !defined(CONFIG_SPL_DFU)
|
2016-07-28 12:09:17 +00:00
|
|
|
case BOOT_DEVICE_DFU:
|
|
|
|
sys_boot_device = 1;
|
|
|
|
break;
|
2015-08-27 08:46:09 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sys_boot_device) {
|
2015-07-15 14:02:23 +00:00
|
|
|
boot_device = omap_sys_boot_device();
|
|
|
|
|
|
|
|
/* MMC raw mode will fallback to FS mode. */
|
|
|
|
if ((boot_device >= MMC_BOOT_DEVICES_START) &&
|
|
|
|
(boot_device <= MMC_BOOT_DEVICES_END))
|
|
|
|
boot_mode = MMCSD_MODE_RAW;
|
|
|
|
}
|
2015-07-15 14:02:19 +00:00
|
|
|
|
|
|
|
gd->arch.omap_boot_device = boot_device;
|
|
|
|
|
|
|
|
/* Boot mode */
|
|
|
|
|
2015-07-15 14:02:23 +00:00
|
|
|
#ifdef CONFIG_OMAP34XX
|
2015-07-15 14:02:19 +00:00
|
|
|
if ((boot_device >= MMC_BOOT_DEVICES_START) &&
|
|
|
|
(boot_device <= MMC_BOOT_DEVICES_END)) {
|
|
|
|
switch (boot_device) {
|
|
|
|
case BOOT_DEVICE_MMC1:
|
2016-05-02 14:52:51 +00:00
|
|
|
boot_mode = MMCSD_MODE_FS;
|
|
|
|
break;
|
2015-07-15 14:02:19 +00:00
|
|
|
case BOOT_DEVICE_MMC2:
|
|
|
|
boot_mode = MMCSD_MODE_RAW;
|
|
|
|
break;
|
|
|
|
}
|
2015-07-15 14:02:23 +00:00
|
|
|
}
|
2015-07-15 14:02:19 +00:00
|
|
|
#else
|
2015-07-15 14:02:23 +00:00
|
|
|
/*
|
|
|
|
* If the boot device was dynamically changed and doesn't match what
|
|
|
|
* the bootrom initially booted, we cannot use the boot device
|
|
|
|
* descriptor to figure out the boot mode.
|
|
|
|
*/
|
|
|
|
if ((boot_device == omap_boot_params->boot_device) &&
|
|
|
|
(boot_device >= MMC_BOOT_DEVICES_START) &&
|
|
|
|
(boot_device <= MMC_BOOT_DEVICES_END)) {
|
2015-07-15 14:02:19 +00:00
|
|
|
boot_params = omap_boot_params->boot_device_descriptor;
|
|
|
|
if ((boot_params < NON_SECURE_SRAM_START) ||
|
|
|
|
(boot_params > NON_SECURE_SRAM_END))
|
|
|
|
return;
|
|
|
|
|
|
|
|
boot_params = *((u32 *)(boot_params + DEVICE_DATA_OFFSET));
|
|
|
|
if ((boot_params < NON_SECURE_SRAM_START) ||
|
|
|
|
(boot_params > NON_SECURE_SRAM_END))
|
|
|
|
return;
|
|
|
|
|
|
|
|
boot_mode = *((u32 *)(boot_params + BOOT_MODE_OFFSET));
|
|
|
|
|
|
|
|
if (boot_mode != MMCSD_MODE_FS &&
|
|
|
|
boot_mode != MMCSD_MODE_RAW)
|
|
|
|
#ifdef CONFIG_SUPPORT_EMMC_BOOT
|
2015-07-15 14:02:23 +00:00
|
|
|
boot_mode = MMCSD_MODE_EMMCBOOT;
|
2015-07-15 14:02:19 +00:00
|
|
|
#else
|
|
|
|
boot_mode = MMCSD_MODE_UNDEFINED;
|
|
|
|
#endif
|
|
|
|
}
|
2015-07-15 14:02:23 +00:00
|
|
|
#endif
|
2015-07-15 14:02:19 +00:00
|
|
|
|
|
|
|
gd->arch.omap_boot_mode = boot_mode;
|
|
|
|
|
|
|
|
#if !defined(CONFIG_TI814X) && !defined(CONFIG_TI816X) && \
|
|
|
|
!defined(CONFIG_AM33XX) && !defined(CONFIG_AM43XX)
|
|
|
|
|
|
|
|
/* CH flags */
|
|
|
|
|
|
|
|
gd->arch.omap_ch_flags = omap_boot_params->ch_flags;
|
2014-04-03 11:52:56 +00:00
|
|
|
#endif
|
2013-05-31 16:31:59 +00:00
|
|
|
}
|
|
|
|
|
2012-01-09 20:38:59 +00:00
|
|
|
#ifdef CONFIG_SPL_BUILD
|
2012-08-13 19:53:23 +00:00
|
|
|
u32 spl_boot_device(void)
|
2012-01-09 20:38:59 +00:00
|
|
|
{
|
2015-07-15 14:02:19 +00:00
|
|
|
return gd->arch.omap_boot_device;
|
2012-01-09 20:38:59 +00:00
|
|
|
}
|
|
|
|
|
2021-07-12 10:06:49 +00:00
|
|
|
u32 spl_mmc_boot_mode(struct mmc *mmc, const u32 boot_device)
|
2012-01-09 20:38:59 +00:00
|
|
|
{
|
2015-07-15 14:02:19 +00:00
|
|
|
return gd->arch.omap_boot_mode;
|
2012-01-09 20:38:59 +00:00
|
|
|
}
|
2012-08-14 17:25:15 +00:00
|
|
|
|
2022-01-27 12:16:52 +00:00
|
|
|
int load_firmware(char *name_fw, u32 *loadaddr)
|
|
|
|
{
|
|
|
|
struct udevice *fsdev;
|
|
|
|
int size = 0;
|
|
|
|
|
|
|
|
if (!IS_ENABLED(CONFIG_FS_LOADER))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!*loadaddr)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!uclass_get_device(UCLASS_FS_FIRMWARE_LOADER, 0, &fsdev)) {
|
|
|
|
size = request_firmware_into_buf(fsdev, name_fw,
|
|
|
|
(void *)*loadaddr, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
void spl_boot_ipu(void)
|
|
|
|
{
|
|
|
|
int ret, size;
|
|
|
|
u32 loadaddr = IPU1_LOAD_ADDR;
|
|
|
|
|
|
|
|
if (!IS_ENABLED(CONFIG_SPL_BUILD) ||
|
|
|
|
!IS_ENABLED(CONFIG_REMOTEPROC_TI_IPU))
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = load_firmware("dra7-ipu1-fw.xem4", &loadaddr);
|
|
|
|
if (size <= 0) {
|
|
|
|
pr_err("Firmware loading failed\n");
|
|
|
|
goto skip_ipu1;
|
|
|
|
}
|
|
|
|
|
|
|
|
enable_ipu1_clocks();
|
|
|
|
ret = rproc_dev_init(0);
|
|
|
|
if (ret) {
|
|
|
|
debug("%s: IPU1 failed to initialize on rproc (%d)\n",
|
|
|
|
__func__, ret);
|
|
|
|
goto skip_ipu1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rproc_load(0, IPU1_LOAD_ADDR, 0x2000000);
|
|
|
|
if (ret) {
|
|
|
|
debug("%s: IPU1 failed to load on rproc (%d)\n", __func__,
|
|
|
|
ret);
|
|
|
|
goto skip_ipu1;
|
|
|
|
}
|
|
|
|
|
|
|
|
debug("Starting IPU1...\n");
|
|
|
|
|
|
|
|
ret = rproc_start(0);
|
|
|
|
if (ret)
|
|
|
|
debug("%s: IPU1 failed to start (%d)\n", __func__, ret);
|
|
|
|
|
|
|
|
skip_ipu1:
|
|
|
|
loadaddr = IPU2_LOAD_ADDR;
|
|
|
|
size = load_firmware("dra7-ipu2-fw.xem4", &loadaddr);
|
|
|
|
if (size <= 0) {
|
|
|
|
pr_err("Firmware loading failed for ipu2\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
enable_ipu2_clocks();
|
|
|
|
ret = rproc_dev_init(1);
|
|
|
|
if (ret) {
|
|
|
|
debug("%s: IPU2 failed to initialize on rproc (%d)\n", __func__,
|
|
|
|
ret);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rproc_load(1, IPU2_LOAD_ADDR, 0x2000000);
|
|
|
|
if (ret) {
|
|
|
|
debug("%s: IPU2 failed to load on rproc (%d)\n", __func__,
|
|
|
|
ret);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
debug("Starting IPU2...\n");
|
|
|
|
|
|
|
|
ret = rproc_start(1);
|
|
|
|
if (ret)
|
|
|
|
debug("%s: IPU2 failed to start (%d)\n", __func__, ret);
|
|
|
|
}
|
|
|
|
|
2012-08-14 19:26:08 +00:00
|
|
|
void spl_board_init(void)
|
|
|
|
{
|
2014-12-19 21:53:24 +00:00
|
|
|
/* Prepare console output */
|
|
|
|
preloader_console_init();
|
2020-05-07 23:08:10 +00:00
|
|
|
|
2015-07-15 14:02:19 +00:00
|
|
|
#if defined(CONFIG_SPL_NAND_SUPPORT) || defined(CONFIG_SPL_ONENAND_SUPPORT)
|
2012-08-14 19:26:08 +00:00
|
|
|
gpmc_init();
|
|
|
|
#endif
|
2021-07-11 03:14:36 +00:00
|
|
|
#if defined(CONFIG_SPL_I2C) && !CONFIG_IS_ENABLED(DM_I2C)
|
2021-08-19 03:12:29 +00:00
|
|
|
i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
|
2015-07-15 14:02:19 +00:00
|
|
|
#endif
|
2021-07-11 03:14:27 +00:00
|
|
|
#if defined(CONFIG_AM33XX) && defined(CONFIG_SPL_MUSB_NEW)
|
2013-02-05 11:36:25 +00:00
|
|
|
arch_misc_init();
|
|
|
|
#endif
|
2019-07-31 16:24:07 +00:00
|
|
|
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
|
2013-10-01 16:32:04 +00:00
|
|
|
hw_watchdog_init();
|
|
|
|
#endif
|
2013-08-30 20:28:44 +00:00
|
|
|
#ifdef CONFIG_AM33XX
|
|
|
|
am33xx_spl_board_init();
|
|
|
|
#endif
|
2022-01-27 12:16:52 +00:00
|
|
|
if (IS_ENABLED(CONFIG_SPL_BUILD) &&
|
|
|
|
IS_ENABLED(CONFIG_REMOTEPROC_TI_IPU))
|
|
|
|
spl_boot_ipu();
|
2012-08-14 19:26:08 +00:00
|
|
|
}
|
|
|
|
|
2013-04-24 00:41:24 +00:00
|
|
|
void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
|
|
|
|
{
|
|
|
|
typedef void __noreturn (*image_entry_noargs_t)(u32 *);
|
|
|
|
image_entry_noargs_t image_entry =
|
|
|
|
(image_entry_noargs_t) spl_image->entry_point;
|
|
|
|
|
2015-07-15 14:02:19 +00:00
|
|
|
u32 boot_params = *((u32 *)OMAP_SRAM_SCRATCH_BOOT_PARAMS);
|
|
|
|
|
2017-01-02 11:48:31 +00:00
|
|
|
debug("image entry point: 0x%lX\n", spl_image->entry_point);
|
2013-04-24 00:41:24 +00:00
|
|
|
/* Pass the saved boot_params from rom code */
|
2015-07-15 14:02:19 +00:00
|
|
|
image_entry((u32 *)boot_params);
|
2013-04-24 00:41:24 +00:00
|
|
|
}
|
2012-01-09 20:38:59 +00:00
|
|
|
#endif
|
2014-12-15 14:02:58 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_SCSI_AHCI_PLAT
|
|
|
|
void arch_preboot_os(void)
|
|
|
|
{
|
2015-04-17 14:19:01 +00:00
|
|
|
ahci_reset((void __iomem *)DWC_AHSATA_BASE);
|
2014-12-15 14:02:58 +00:00
|
|
|
}
|
|
|
|
#endif
|