2018-05-07 07:27:01 +09:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
|
2018-03-12 18:46:18 +09:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2018, STMicroelectronics - All Rights Reserved
|
|
|
|
*/
|
2019-02-13 00:50:40 +09:00
|
|
|
#include <common.h>
|
|
|
|
#include <adc.h>
|
2019-06-21 22:26:40 +09:00
|
|
|
#include <bootm.h>
|
2018-08-11 00:12:14 +09:00
|
|
|
#include <clk.h>
|
2019-07-31 02:16:44 +09:00
|
|
|
#include <config.h>
|
2018-08-11 00:12:14 +09:00
|
|
|
#include <dm.h>
|
2019-08-02 00:46:42 +09:00
|
|
|
#include <env.h>
|
2019-08-03 00:44:25 +09:00
|
|
|
#include <env_internal.h>
|
2020-05-11 02:40:01 +09:00
|
|
|
#include <fdt_support.h>
|
2019-03-29 23:42:23 +09:00
|
|
|
#include <g_dnl.h>
|
2018-08-11 00:12:14 +09:00
|
|
|
#include <generic-phy.h>
|
2019-12-29 02:45:07 +09:00
|
|
|
#include <hang.h>
|
2019-03-29 23:42:24 +09:00
|
|
|
#include <i2c.h>
|
2019-11-15 04:57:46 +09:00
|
|
|
#include <init.h>
|
2019-02-12 19:44:41 +09:00
|
|
|
#include <led.h>
|
2020-05-11 02:40:05 +09:00
|
|
|
#include <log.h>
|
2020-02-03 23:36:16 +09:00
|
|
|
#include <malloc.h>
|
2019-02-12 19:44:41 +09:00
|
|
|
#include <misc.h>
|
2019-07-02 20:26:07 +09:00
|
|
|
#include <mtd_node.h>
|
2020-05-11 02:39:56 +09:00
|
|
|
#include <net.h>
|
2019-08-01 18:29:03 +09:00
|
|
|
#include <netdev.h>
|
2018-08-11 00:12:14 +09:00
|
|
|
#include <phy.h>
|
2019-08-02 22:07:20 +09:00
|
|
|
#include <remoteproc.h>
|
2018-08-11 00:12:14 +09:00
|
|
|
#include <reset.h>
|
2019-02-28 01:01:24 +09:00
|
|
|
#include <syscon.h>
|
2019-03-29 23:42:24 +09:00
|
|
|
#include <usb.h>
|
2019-07-31 02:16:39 +09:00
|
|
|
#include <watchdog.h>
|
2018-08-11 00:12:14 +09:00
|
|
|
#include <asm/io.h>
|
2019-02-28 01:01:18 +09:00
|
|
|
#include <asm/gpio.h>
|
2019-02-28 01:01:24 +09:00
|
|
|
#include <asm/arch/stm32.h>
|
2019-05-03 01:36:01 +09:00
|
|
|
#include <asm/arch/sys_proto.h>
|
2019-07-02 20:26:07 +09:00
|
|
|
#include <jffs2/load_kernel.h>
|
2020-05-11 02:40:13 +09:00
|
|
|
#include <linux/bitops.h>
|
2020-05-11 02:40:11 +09:00
|
|
|
#include <linux/delay.h>
|
2020-02-03 23:36:15 +09:00
|
|
|
#include <linux/err.h>
|
2020-04-22 21:29:16 +09:00
|
|
|
#include <linux/iopoll.h>
|
2018-08-11 00:12:14 +09:00
|
|
|
#include <power/regulator.h>
|
2019-03-29 23:42:24 +09:00
|
|
|
#include <usb/dwc2_udc.h>
|
2018-03-12 18:46:18 +09:00
|
|
|
|
2020-06-29 17:34:06 +09:00
|
|
|
#include "../../st/common/stusb160x.h"
|
|
|
|
|
2019-02-28 01:01:24 +09:00
|
|
|
/* SYSCFG registers */
|
|
|
|
#define SYSCFG_BOOTR 0x00
|
|
|
|
#define SYSCFG_PMCSETR 0x04
|
|
|
|
#define SYSCFG_IOCTRLSETR 0x18
|
|
|
|
#define SYSCFG_ICNR 0x1C
|
|
|
|
#define SYSCFG_CMPCR 0x20
|
|
|
|
#define SYSCFG_CMPENSETR 0x24
|
|
|
|
#define SYSCFG_PMCCLRR 0x44
|
|
|
|
|
|
|
|
#define SYSCFG_BOOTR_BOOT_MASK GENMASK(2, 0)
|
|
|
|
#define SYSCFG_BOOTR_BOOTPD_SHIFT 4
|
|
|
|
|
|
|
|
#define SYSCFG_IOCTRLSETR_HSLVEN_TRACE BIT(0)
|
|
|
|
#define SYSCFG_IOCTRLSETR_HSLVEN_QUADSPI BIT(1)
|
|
|
|
#define SYSCFG_IOCTRLSETR_HSLVEN_ETH BIT(2)
|
|
|
|
#define SYSCFG_IOCTRLSETR_HSLVEN_SDMMC BIT(3)
|
|
|
|
#define SYSCFG_IOCTRLSETR_HSLVEN_SPI BIT(4)
|
|
|
|
|
|
|
|
#define SYSCFG_CMPCR_SW_CTRL BIT(1)
|
|
|
|
#define SYSCFG_CMPCR_READY BIT(8)
|
|
|
|
|
|
|
|
#define SYSCFG_CMPENSETR_MPU_EN BIT(0)
|
|
|
|
|
|
|
|
#define SYSCFG_PMCSETR_ETH_CLK_SEL BIT(16)
|
|
|
|
#define SYSCFG_PMCSETR_ETH_REF_CLK_SEL BIT(17)
|
|
|
|
|
|
|
|
#define SYSCFG_PMCSETR_ETH_SELMII BIT(20)
|
|
|
|
|
|
|
|
#define SYSCFG_PMCSETR_ETH_SEL_MASK GENMASK(23, 21)
|
2019-05-17 22:08:43 +09:00
|
|
|
#define SYSCFG_PMCSETR_ETH_SEL_GMII_MII 0
|
|
|
|
#define SYSCFG_PMCSETR_ETH_SEL_RGMII BIT(21)
|
|
|
|
#define SYSCFG_PMCSETR_ETH_SEL_RMII BIT(23)
|
2019-02-28 01:01:24 +09:00
|
|
|
|
2018-03-12 18:46:18 +09:00
|
|
|
/*
|
|
|
|
* Get a global data pointer
|
|
|
|
*/
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
|
2019-05-01 01:09:38 +09:00
|
|
|
#define USB_LOW_THRESHOLD_UV 200000
|
2019-02-13 00:50:40 +09:00
|
|
|
#define USB_WARNING_LOW_THRESHOLD_UV 660000
|
|
|
|
#define USB_START_LOW_THRESHOLD_UV 1230000
|
2019-05-01 01:09:38 +09:00
|
|
|
#define USB_START_HIGH_THRESHOLD_UV 2150000
|
2019-02-13 00:50:40 +09:00
|
|
|
|
2020-05-25 19:19:46 +09:00
|
|
|
int board_early_init_f(void)
|
|
|
|
{
|
|
|
|
/* nothing to do, only used in SPL */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-02-12 19:44:41 +09:00
|
|
|
int checkboard(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char *mode;
|
|
|
|
u32 otp;
|
|
|
|
struct udevice *dev;
|
|
|
|
const char *fdt_compat;
|
|
|
|
int fdt_compat_len;
|
|
|
|
|
2020-03-18 17:22:49 +09:00
|
|
|
if (IS_ENABLED(CONFIG_TFABOOT))
|
2019-02-12 19:44:41 +09:00
|
|
|
mode = "trusted";
|
|
|
|
else
|
|
|
|
mode = "basic";
|
|
|
|
|
|
|
|
printf("Board: stm32mp1 in %s mode", mode);
|
|
|
|
fdt_compat = fdt_getprop(gd->fdt_blob, 0, "compatible",
|
|
|
|
&fdt_compat_len);
|
|
|
|
if (fdt_compat && fdt_compat_len)
|
|
|
|
printf(" (%s)", fdt_compat);
|
|
|
|
puts("\n");
|
|
|
|
|
2020-03-24 17:05:00 +09:00
|
|
|
/* display the STMicroelectronics board identification */
|
2020-02-13 03:37:42 +09:00
|
|
|
if (CONFIG_IS_ENABLED(CMD_STBOARD)) {
|
|
|
|
ret = uclass_get_device_by_driver(UCLASS_MISC,
|
2020-12-29 12:34:56 +09:00
|
|
|
DM_DRIVER_GET(stm32mp_bsec),
|
2020-02-13 03:37:42 +09:00
|
|
|
&dev);
|
|
|
|
if (!ret)
|
|
|
|
ret = misc_read(dev, STM32_BSEC_SHADOW(BSEC_OTP_BOARD),
|
|
|
|
&otp, sizeof(otp));
|
|
|
|
if (ret > 0 && otp)
|
|
|
|
printf("Board: MB%04x Var%d.%d Rev.%c-%02d\n",
|
|
|
|
otp >> 16,
|
|
|
|
(otp >> 12) & 0xF,
|
|
|
|
(otp >> 4) & 0xF,
|
|
|
|
((otp >> 8) & 0xF) - 1 + 'A',
|
|
|
|
otp & 0xF);
|
2019-02-12 19:44:41 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-02-28 01:01:20 +09:00
|
|
|
static void board_key_check(void)
|
|
|
|
{
|
|
|
|
ofnode node;
|
|
|
|
struct gpio_desc gpio;
|
|
|
|
enum forced_boot_mode boot_mode = BOOT_NORMAL;
|
|
|
|
|
2020-07-31 23:31:42 +09:00
|
|
|
if (!IS_ENABLED(CONFIG_FASTBOOT) && !IS_ENABLED(CONFIG_CMD_STM32PROG))
|
|
|
|
return;
|
|
|
|
|
2019-02-28 01:01:20 +09:00
|
|
|
node = ofnode_path("/config");
|
|
|
|
if (!ofnode_valid(node)) {
|
|
|
|
debug("%s: no /config node?\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
2020-07-31 23:31:42 +09:00
|
|
|
if (IS_ENABLED(CONFIG_FASTBOOT)) {
|
|
|
|
if (gpio_request_by_name_nodev(node, "st,fastboot-gpios", 0,
|
|
|
|
&gpio, GPIOD_IS_IN)) {
|
|
|
|
debug("%s: could not find a /config/st,fastboot-gpios\n",
|
|
|
|
__func__);
|
|
|
|
} else {
|
|
|
|
if (dm_gpio_get_value(&gpio)) {
|
|
|
|
puts("Fastboot key pressed, ");
|
|
|
|
boot_mode = BOOT_FASTBOOT;
|
|
|
|
}
|
|
|
|
|
|
|
|
dm_gpio_free(NULL, &gpio);
|
2019-02-28 01:01:20 +09:00
|
|
|
}
|
|
|
|
}
|
2020-07-31 23:31:42 +09:00
|
|
|
if (IS_ENABLED(CONFIG_CMD_STM32PROG)) {
|
|
|
|
if (gpio_request_by_name_nodev(node, "st,stm32prog-gpios", 0,
|
|
|
|
&gpio, GPIOD_IS_IN)) {
|
|
|
|
debug("%s: could not find a /config/st,stm32prog-gpios\n",
|
|
|
|
__func__);
|
|
|
|
} else {
|
|
|
|
if (dm_gpio_get_value(&gpio)) {
|
|
|
|
puts("STM32Programmer key pressed, ");
|
|
|
|
boot_mode = BOOT_STM32PROG;
|
|
|
|
}
|
|
|
|
dm_gpio_free(NULL, &gpio);
|
2019-02-28 01:01:20 +09:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (boot_mode != BOOT_NORMAL) {
|
|
|
|
puts("entering download mode...\n");
|
|
|
|
clrsetbits_le32(TAMP_BOOT_CONTEXT,
|
|
|
|
TAMP_BOOT_FORCED_MASK,
|
|
|
|
boot_mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-29 23:42:23 +09:00
|
|
|
int g_dnl_board_usb_cable_connected(void)
|
2018-08-11 00:12:14 +09:00
|
|
|
{
|
2019-03-29 23:42:23 +09:00
|
|
|
struct udevice *dwc2_udc_otg;
|
2018-08-11 00:12:14 +09:00
|
|
|
int ret;
|
|
|
|
|
2020-07-31 23:31:43 +09:00
|
|
|
if (!IS_ENABLED(CONFIG_USB_GADGET_DWC2_OTG))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2020-06-29 17:34:06 +09:00
|
|
|
/* if typec stusb160x is present, means DK1 or DK2 board */
|
|
|
|
ret = stusb160x_cable_connected();
|
|
|
|
if (ret >= 0)
|
|
|
|
return ret;
|
2019-03-29 23:42:24 +09:00
|
|
|
|
2019-03-29 23:42:23 +09:00
|
|
|
ret = uclass_get_device_by_driver(UCLASS_USB_GADGET_GENERIC,
|
2020-12-29 12:34:56 +09:00
|
|
|
DM_DRIVER_GET(dwc2_udc_otg),
|
2019-03-29 23:42:23 +09:00
|
|
|
&dwc2_udc_otg);
|
|
|
|
if (!ret)
|
|
|
|
debug("dwc2_udc_otg init failed\n");
|
2018-08-11 00:12:14 +09:00
|
|
|
|
2019-03-29 23:42:23 +09:00
|
|
|
return dwc2_udc_B_session_valid(dwc2_udc_otg);
|
2018-08-11 00:12:14 +09:00
|
|
|
}
|
2019-09-13 22:24:17 +09:00
|
|
|
|
2020-07-31 23:31:43 +09:00
|
|
|
#ifdef CONFIG_USB_GADGET_DOWNLOAD
|
2019-09-13 22:24:17 +09:00
|
|
|
#define STM32MP1_G_DNL_DFU_PRODUCT_NUM 0xdf11
|
|
|
|
#define STM32MP1_G_DNL_FASTBOOT_PRODUCT_NUM 0x0afb
|
|
|
|
|
|
|
|
int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name)
|
|
|
|
{
|
2020-07-31 23:31:43 +09:00
|
|
|
if (IS_ENABLED(CONFIG_DFU_OVER_USB) &&
|
|
|
|
!strcmp(name, "usb_dnl_dfu"))
|
2019-09-13 22:24:17 +09:00
|
|
|
put_unaligned(STM32MP1_G_DNL_DFU_PRODUCT_NUM, &dev->idProduct);
|
2020-07-31 23:31:43 +09:00
|
|
|
else if (IS_ENABLED(CONFIG_FASTBOOT) &&
|
|
|
|
!strcmp(name, "usb_dnl_fastboot"))
|
2019-09-13 22:24:17 +09:00
|
|
|
put_unaligned(STM32MP1_G_DNL_FASTBOOT_PRODUCT_NUM,
|
|
|
|
&dev->idProduct);
|
|
|
|
else
|
|
|
|
put_unaligned(CONFIG_USB_GADGET_PRODUCT_NUM, &dev->idProduct);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2020-07-31 23:31:43 +09:00
|
|
|
#endif /* CONFIG_USB_GADGET_DOWNLOAD */
|
2018-08-11 00:12:14 +09:00
|
|
|
|
2019-02-13 00:50:40 +09:00
|
|
|
static int get_led(struct udevice **dev, char *led_string)
|
|
|
|
{
|
|
|
|
char *led_name;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
led_name = fdtdec_get_config_string(gd->fdt_blob, led_string);
|
|
|
|
if (!led_name) {
|
|
|
|
pr_debug("%s: could not find %s config string\n",
|
|
|
|
__func__, led_string);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
ret = led_get_by_label(led_name, dev);
|
|
|
|
if (ret) {
|
|
|
|
debug("%s: get=%d\n", __func__, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int setup_led(enum led_state_t cmd)
|
|
|
|
{
|
|
|
|
struct udevice *dev;
|
|
|
|
int ret;
|
|
|
|
|
2020-04-22 21:29:12 +09:00
|
|
|
if (!CONFIG_IS_ENABLED(LED))
|
|
|
|
return 0;
|
|
|
|
|
2019-02-13 00:50:40 +09:00
|
|
|
ret = get_led(&dev, "u-boot,boot-led");
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = led_set_state(dev, cmd);
|
|
|
|
return ret;
|
|
|
|
}
|
2019-07-31 02:16:39 +09:00
|
|
|
|
|
|
|
static void __maybe_unused led_error_blink(u32 nb_blink)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct udevice *led;
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
if (!nb_blink)
|
|
|
|
return;
|
|
|
|
|
2020-04-22 21:29:12 +09:00
|
|
|
if (CONFIG_IS_ENABLED(LED)) {
|
|
|
|
ret = get_led(&led, "u-boot,error-led");
|
|
|
|
if (!ret) {
|
|
|
|
/* make u-boot,error-led blinking */
|
|
|
|
/* if U32_MAX and 125ms interval, for 17.02 years */
|
|
|
|
for (i = 0; i < 2 * nb_blink; i++) {
|
|
|
|
led_set_state(led, LEDST_TOGGLE);
|
|
|
|
mdelay(125);
|
|
|
|
WATCHDOG_RESET();
|
|
|
|
}
|
|
|
|
led_set_state(led, LEDST_ON);
|
2019-07-31 02:16:39 +09:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* infinite: the boot process must be stopped */
|
|
|
|
if (nb_blink == U32_MAX)
|
|
|
|
hang();
|
|
|
|
}
|
2019-02-13 00:50:40 +09:00
|
|
|
|
|
|
|
static int board_check_usb_power(void)
|
|
|
|
{
|
|
|
|
struct ofnode_phandle_args adc_args;
|
|
|
|
struct udevice *adc;
|
|
|
|
ofnode node;
|
|
|
|
unsigned int raw;
|
|
|
|
int max_uV = 0;
|
2019-05-01 01:09:38 +09:00
|
|
|
int min_uV = USB_START_HIGH_THRESHOLD_UV;
|
2019-02-13 00:50:40 +09:00
|
|
|
int ret, uV, adc_count;
|
2019-05-01 01:09:38 +09:00
|
|
|
u32 nb_blink;
|
|
|
|
u8 i;
|
2020-07-31 23:31:44 +09:00
|
|
|
|
|
|
|
if (!IS_ENABLED(CONFIG_ADC))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2019-02-13 00:50:40 +09:00
|
|
|
node = ofnode_path("/config");
|
|
|
|
if (!ofnode_valid(node)) {
|
|
|
|
debug("%s: no /config node?\n", __func__);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Retrieve the ADC channels devices and get measurement
|
|
|
|
* for each of them
|
|
|
|
*/
|
|
|
|
adc_count = ofnode_count_phandle_with_args(node, "st,adc_usb_pd",
|
2020-09-25 16:41:14 +09:00
|
|
|
"#io-channel-cells", 0);
|
2019-02-13 00:50:40 +09:00
|
|
|
if (adc_count < 0) {
|
|
|
|
if (adc_count == -ENOENT)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
pr_err("%s: can't find adc channel (%d)\n", __func__,
|
|
|
|
adc_count);
|
|
|
|
|
|
|
|
return adc_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < adc_count; i++) {
|
|
|
|
if (ofnode_parse_phandle_with_args(node, "st,adc_usb_pd",
|
|
|
|
"#io-channel-cells", 0, i,
|
|
|
|
&adc_args)) {
|
|
|
|
pr_debug("%s: can't find /config/st,adc_usb_pd\n",
|
|
|
|
__func__);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = uclass_get_device_by_ofnode(UCLASS_ADC, adc_args.node,
|
|
|
|
&adc);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
pr_err("%s: Can't get adc device(%d)\n", __func__,
|
|
|
|
ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = adc_channel_single_shot(adc->name, adc_args.args[0],
|
|
|
|
&raw);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("%s: single shot failed for %s[%d]!\n",
|
|
|
|
__func__, adc->name, adc_args.args[0]);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/* Convert to uV */
|
|
|
|
if (!adc_raw_to_uV(adc, raw, &uV)) {
|
|
|
|
if (uV > max_uV)
|
|
|
|
max_uV = uV;
|
2019-05-01 01:09:38 +09:00
|
|
|
if (uV < min_uV)
|
|
|
|
min_uV = uV;
|
2019-02-13 00:50:40 +09:00
|
|
|
pr_debug("%s: %s[%02d] = %u, %d uV\n", __func__,
|
|
|
|
adc->name, adc_args.args[0], raw, uV);
|
|
|
|
} else {
|
|
|
|
pr_err("%s: Can't get uV value for %s[%d]\n",
|
|
|
|
__func__, adc->name, adc_args.args[0]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If highest value is inside 1.23 Volts and 2.10 Volts, that means
|
|
|
|
* board is plugged on an USB-C 3A power supply and boot process can
|
|
|
|
* continue.
|
|
|
|
*/
|
|
|
|
if (max_uV > USB_START_LOW_THRESHOLD_UV &&
|
2019-05-01 01:09:38 +09:00
|
|
|
max_uV <= USB_START_HIGH_THRESHOLD_UV &&
|
|
|
|
min_uV <= USB_LOW_THRESHOLD_UV)
|
2019-02-13 00:50:40 +09:00
|
|
|
return 0;
|
|
|
|
|
2019-05-01 01:09:38 +09:00
|
|
|
pr_err("****************************************************\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If highest and lowest value are either both below
|
|
|
|
* USB_LOW_THRESHOLD_UV or both above USB_LOW_THRESHOLD_UV, that
|
|
|
|
* means USB TYPE-C is in unattached mode, this is an issue, make
|
|
|
|
* u-boot,error-led blinking and stop boot process.
|
|
|
|
*/
|
|
|
|
if ((max_uV > USB_LOW_THRESHOLD_UV &&
|
|
|
|
min_uV > USB_LOW_THRESHOLD_UV) ||
|
|
|
|
(max_uV <= USB_LOW_THRESHOLD_UV &&
|
|
|
|
min_uV <= USB_LOW_THRESHOLD_UV)) {
|
|
|
|
pr_err("* ERROR USB TYPE-C connection in unattached mode *\n");
|
|
|
|
pr_err("* Check that USB TYPE-C cable is correctly plugged *\n");
|
|
|
|
/* with 125ms interval, led will blink for 17.02 years ....*/
|
|
|
|
nb_blink = U32_MAX;
|
|
|
|
}
|
2019-02-13 00:50:40 +09:00
|
|
|
|
2019-05-01 01:09:38 +09:00
|
|
|
if (max_uV > USB_LOW_THRESHOLD_UV &&
|
|
|
|
max_uV <= USB_WARNING_LOW_THRESHOLD_UV &&
|
|
|
|
min_uV <= USB_LOW_THRESHOLD_UV) {
|
|
|
|
pr_err("* WARNING 500mA power supply detected *\n");
|
2019-02-13 00:50:40 +09:00
|
|
|
nb_blink = 2;
|
2019-05-01 01:09:38 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
if (max_uV > USB_WARNING_LOW_THRESHOLD_UV &&
|
|
|
|
max_uV <= USB_START_LOW_THRESHOLD_UV &&
|
|
|
|
min_uV <= USB_LOW_THRESHOLD_UV) {
|
2020-05-01 01:41:05 +09:00
|
|
|
pr_err("* WARNING 1.5A power supply detected *\n");
|
2019-02-13 00:50:40 +09:00
|
|
|
nb_blink = 3;
|
|
|
|
}
|
|
|
|
|
2019-05-01 01:09:38 +09:00
|
|
|
/*
|
|
|
|
* If highest value is above 2.15 Volts that means that the USB TypeC
|
|
|
|
* supplies more than 3 Amp, this is not compliant with TypeC specification
|
|
|
|
*/
|
|
|
|
if (max_uV > USB_START_HIGH_THRESHOLD_UV) {
|
|
|
|
pr_err("* USB TYPE-C charger not compliant with *\n");
|
|
|
|
pr_err("* specification *\n");
|
|
|
|
pr_err("****************************************************\n\n");
|
|
|
|
/* with 125ms interval, led will blink for 17.02 years ....*/
|
|
|
|
nb_blink = U32_MAX;
|
|
|
|
} else {
|
|
|
|
pr_err("* Current too low, use a 3A power supply! *\n");
|
|
|
|
pr_err("****************************************************\n\n");
|
|
|
|
}
|
2019-02-13 00:50:40 +09:00
|
|
|
|
2019-07-31 02:16:39 +09:00
|
|
|
led_error_blink(nb_blink);
|
2019-02-13 00:50:40 +09:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-02-28 01:01:24 +09:00
|
|
|
static void sysconf_init(void)
|
|
|
|
{
|
|
|
|
u8 *syscfg;
|
|
|
|
struct udevice *pwr_dev;
|
|
|
|
struct udevice *pwr_reg;
|
|
|
|
struct udevice *dev;
|
|
|
|
u32 otp = 0;
|
2020-04-22 21:29:16 +09:00
|
|
|
int ret;
|
|
|
|
u32 bootr, val;
|
2019-02-28 01:01:24 +09:00
|
|
|
|
|
|
|
syscfg = (u8 *)syscon_get_first_range(STM32MP_SYSCON_SYSCFG);
|
|
|
|
|
|
|
|
/* interconnect update : select master using the port 1 */
|
|
|
|
/* LTDC = AXI_M9 */
|
|
|
|
/* GPU = AXI_M8 */
|
|
|
|
/* today information is hardcoded in U-Boot */
|
|
|
|
writel(BIT(9), syscfg + SYSCFG_ICNR);
|
|
|
|
|
|
|
|
/* disable Pull-Down for boot pin connected to VDD */
|
|
|
|
bootr = readl(syscfg + SYSCFG_BOOTR);
|
|
|
|
bootr &= ~(SYSCFG_BOOTR_BOOT_MASK << SYSCFG_BOOTR_BOOTPD_SHIFT);
|
|
|
|
bootr |= (bootr & SYSCFG_BOOTR_BOOT_MASK) << SYSCFG_BOOTR_BOOTPD_SHIFT;
|
|
|
|
writel(bootr, syscfg + SYSCFG_BOOTR);
|
|
|
|
|
|
|
|
/* High Speed Low Voltage Pad mode Enable for SPI, SDMMC, ETH, QSPI
|
|
|
|
* and TRACE. Needed above ~50MHz and conditioned by AFMUX selection.
|
|
|
|
* The customer will have to disable this for low frequencies
|
|
|
|
* or if AFMUX is selected but the function not used, typically for
|
|
|
|
* TRACE. Otherwise, impact on power consumption.
|
|
|
|
*
|
|
|
|
* WARNING:
|
|
|
|
* enabling High Speed mode while VDD>2.7V
|
|
|
|
* with the OTP product_below_2v5 (OTP 18, BIT 13)
|
|
|
|
* erroneously set to 1 can damage the IC!
|
|
|
|
* => U-Boot set the register only if VDD < 2.7V (in DT)
|
|
|
|
* but this value need to be consistent with board design
|
|
|
|
*/
|
2019-07-31 02:16:42 +09:00
|
|
|
ret = uclass_get_device_by_driver(UCLASS_PMIC,
|
2020-12-29 12:34:56 +09:00
|
|
|
DM_DRIVER_GET(stm32mp_pwr_pmic),
|
2019-07-31 02:16:42 +09:00
|
|
|
&pwr_dev);
|
2020-07-31 23:31:45 +09:00
|
|
|
if (!ret && IS_ENABLED(CONFIG_DM_REGULATOR)) {
|
2019-02-28 01:01:24 +09:00
|
|
|
ret = uclass_get_device_by_driver(UCLASS_MISC,
|
2020-12-29 12:34:56 +09:00
|
|
|
DM_DRIVER_GET(stm32mp_bsec),
|
2019-02-28 01:01:24 +09:00
|
|
|
&dev);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("Can't find stm32mp_bsec driver\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = misc_read(dev, STM32_BSEC_SHADOW(18), &otp, 4);
|
2019-08-02 20:08:06 +09:00
|
|
|
if (ret > 0)
|
2019-02-28 01:01:24 +09:00
|
|
|
otp = otp & BIT(13);
|
|
|
|
|
2019-07-31 02:16:42 +09:00
|
|
|
/* get VDD = vdd-supply */
|
|
|
|
ret = device_get_supply_regulator(pwr_dev, "vdd-supply",
|
2019-02-28 01:01:24 +09:00
|
|
|
&pwr_reg);
|
|
|
|
|
|
|
|
/* check if VDD is Low Voltage */
|
|
|
|
if (!ret) {
|
|
|
|
if (regulator_get_value(pwr_reg) < 2700000) {
|
|
|
|
writel(SYSCFG_IOCTRLSETR_HSLVEN_TRACE |
|
|
|
|
SYSCFG_IOCTRLSETR_HSLVEN_QUADSPI |
|
|
|
|
SYSCFG_IOCTRLSETR_HSLVEN_ETH |
|
|
|
|
SYSCFG_IOCTRLSETR_HSLVEN_SDMMC |
|
|
|
|
SYSCFG_IOCTRLSETR_HSLVEN_SPI,
|
|
|
|
syscfg + SYSCFG_IOCTRLSETR);
|
|
|
|
|
|
|
|
if (!otp)
|
|
|
|
pr_err("product_below_2v5=0: HSLVEN protected by HW\n");
|
|
|
|
} else {
|
|
|
|
if (otp)
|
|
|
|
pr_err("product_below_2v5=1: HSLVEN update is destructive, no update as VDD>2.7V\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
debug("VDD unknown");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* activate automatic I/O compensation
|
|
|
|
* warning: need to ensure CSI enabled and ready in clock driver
|
|
|
|
*/
|
|
|
|
writel(SYSCFG_CMPENSETR_MPU_EN, syscfg + SYSCFG_CMPENSETR);
|
|
|
|
|
2020-04-22 21:29:16 +09:00
|
|
|
/* poll until ready (1s timeout) */
|
|
|
|
ret = readl_poll_timeout(syscfg + SYSCFG_CMPCR, val,
|
|
|
|
val & SYSCFG_CMPCR_READY,
|
|
|
|
1000000);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("SYSCFG: I/O compensation failed, timeout.\n");
|
|
|
|
led_error_blink(10);
|
|
|
|
}
|
|
|
|
|
2019-02-28 01:01:24 +09:00
|
|
|
clrbits_le32(syscfg + SYSCFG_CMPCR, SYSCFG_CMPCR_SW_CTRL);
|
|
|
|
}
|
|
|
|
|
2019-07-31 02:16:38 +09:00
|
|
|
/* Fix to make I2C1 usable on DK2 for touchscreen usage in kernel */
|
|
|
|
static int dk2_i2c1_fix(void)
|
|
|
|
{
|
|
|
|
ofnode node;
|
|
|
|
struct gpio_desc hdmi, audio;
|
|
|
|
int ret = 0;
|
|
|
|
|
2020-07-31 23:31:47 +09:00
|
|
|
if (!IS_ENABLED(CONFIG_DM_REGULATOR))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2019-07-31 02:16:38 +09:00
|
|
|
node = ofnode_path("/soc/i2c@40012000/hdmi-transmitter@39");
|
|
|
|
if (!ofnode_valid(node)) {
|
|
|
|
pr_debug("%s: no hdmi-transmitter@39 ?\n", __func__);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gpio_request_by_name_nodev(node, "reset-gpios", 0,
|
|
|
|
&hdmi, GPIOD_IS_OUT)) {
|
|
|
|
pr_debug("%s: could not find reset-gpios\n",
|
|
|
|
__func__);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = ofnode_path("/soc/i2c@40012000/cs42l51@4a");
|
|
|
|
if (!ofnode_valid(node)) {
|
|
|
|
pr_debug("%s: no cs42l51@4a ?\n", __func__);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gpio_request_by_name_nodev(node, "reset-gpios", 0,
|
|
|
|
&audio, GPIOD_IS_OUT)) {
|
|
|
|
pr_debug("%s: could not find reset-gpios\n",
|
|
|
|
__func__);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* before power up, insure that HDMI and AUDIO IC is under reset */
|
|
|
|
ret = dm_gpio_set_value(&hdmi, 1);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("%s: can't set_value for hdmi_nrst gpio", __func__);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
ret = dm_gpio_set_value(&audio, 1);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("%s: can't set_value for audio_nrst gpio", __func__);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* power-up audio IC */
|
|
|
|
regulator_autoset_by_name("v1v8_audio", NULL);
|
|
|
|
|
|
|
|
/* power-up HDMI IC */
|
|
|
|
regulator_autoset_by_name("v1v2_hdmi", NULL);
|
|
|
|
regulator_autoset_by_name("v3v3_hdmi", NULL);
|
|
|
|
|
|
|
|
error:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool board_is_dk2(void)
|
|
|
|
{
|
2020-01-13 23:17:42 +09:00
|
|
|
if (CONFIG_IS_ENABLED(TARGET_ST_STM32MP15x) &&
|
2019-07-31 02:16:38 +09:00
|
|
|
of_machine_is_compatible("st,stm32mp157c-dk2"))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-04-22 21:29:13 +09:00
|
|
|
static bool board_is_ev1(void)
|
|
|
|
{
|
|
|
|
if (CONFIG_IS_ENABLED(TARGET_ST_STM32MP15x) &&
|
|
|
|
(of_machine_is_compatible("st,stm32mp157a-ev1") ||
|
|
|
|
of_machine_is_compatible("st,stm32mp157c-ev1") ||
|
|
|
|
of_machine_is_compatible("st,stm32mp157d-ev1") ||
|
|
|
|
of_machine_is_compatible("st,stm32mp157f-ev1")))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* touchscreen driver: only used for pincontrol configuration */
|
|
|
|
static const struct udevice_id goodix_ids[] = {
|
|
|
|
{ .compatible = "goodix,gt9147", },
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
U_BOOT_DRIVER(goodix) = {
|
|
|
|
.name = "goodix",
|
|
|
|
.id = UCLASS_NOP,
|
|
|
|
.of_match = goodix_ids,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void board_ev1_init(void)
|
|
|
|
{
|
|
|
|
struct udevice *dev;
|
|
|
|
|
|
|
|
/* configure IRQ line on EV1 for touchscreen before LCD reset */
|
2020-12-29 12:34:56 +09:00
|
|
|
uclass_get_device_by_driver(UCLASS_NOP, DM_DRIVER_GET(goodix), &dev);
|
2020-04-22 21:29:13 +09:00
|
|
|
}
|
|
|
|
|
2018-03-12 18:46:18 +09:00
|
|
|
/* board dependent setup after realloc */
|
|
|
|
int board_init(void)
|
|
|
|
{
|
|
|
|
/* address of boot parameters */
|
|
|
|
gd->bd->bi_boot_params = STM32_DDR_BASE + 0x100;
|
|
|
|
|
2020-06-04 21:30:24 +09:00
|
|
|
if (CONFIG_IS_ENABLED(DM_GPIO_HOG))
|
|
|
|
gpio_hog_probe_all();
|
2019-03-11 19:13:17 +09:00
|
|
|
|
2019-02-28 01:01:20 +09:00
|
|
|
board_key_check();
|
|
|
|
|
2020-04-22 21:29:13 +09:00
|
|
|
if (board_is_ev1())
|
|
|
|
board_ev1_init();
|
|
|
|
|
2019-07-31 02:16:38 +09:00
|
|
|
if (board_is_dk2())
|
|
|
|
dk2_i2c1_fix();
|
|
|
|
|
2020-07-31 23:31:47 +09:00
|
|
|
if (IS_ENABLED(CONFIG_DM_REGULATOR))
|
|
|
|
regulators_enable_boot_on(_DEBUG);
|
2019-07-06 00:20:09 +09:00
|
|
|
|
2020-07-31 23:31:45 +09:00
|
|
|
if (!IS_ENABLED(CONFIG_TFABOOT))
|
|
|
|
sysconf_init();
|
2019-02-28 01:01:24 +09:00
|
|
|
|
2020-04-11 02:14:01 +09:00
|
|
|
if (CONFIG_IS_ENABLED(LED))
|
2018-07-27 23:37:08 +09:00
|
|
|
led_default_state();
|
|
|
|
|
2020-04-22 21:29:12 +09:00
|
|
|
setup_led(LEDST_ON);
|
|
|
|
|
2018-03-12 18:46:18 +09:00
|
|
|
return 0;
|
|
|
|
}
|
2019-02-28 01:01:11 +09:00
|
|
|
|
|
|
|
int board_late_init(void)
|
|
|
|
{
|
|
|
|
const void *fdt_compat;
|
|
|
|
int fdt_compat_len;
|
2019-07-31 02:16:37 +09:00
|
|
|
int ret;
|
|
|
|
u32 otp;
|
|
|
|
struct udevice *dev;
|
|
|
|
char buf[10];
|
2020-07-31 23:31:48 +09:00
|
|
|
char dtb_name[256];
|
|
|
|
int buf_len;
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG)) {
|
|
|
|
fdt_compat = fdt_getprop(gd->fdt_blob, 0, "compatible",
|
|
|
|
&fdt_compat_len);
|
|
|
|
if (fdt_compat && fdt_compat_len) {
|
|
|
|
if (strncmp(fdt_compat, "st,", 3) != 0) {
|
|
|
|
env_set("board_name", fdt_compat);
|
|
|
|
} else {
|
|
|
|
env_set("board_name", fdt_compat + 3);
|
2019-02-28 01:01:11 +09:00
|
|
|
|
2020-07-31 23:31:48 +09:00
|
|
|
buf_len = sizeof(dtb_name);
|
|
|
|
strncpy(dtb_name, fdt_compat + 3, buf_len);
|
|
|
|
buf_len -= strlen(fdt_compat + 3);
|
|
|
|
strncat(dtb_name, ".dtb", buf_len);
|
|
|
|
env_set("fdtfile", dtb_name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = uclass_get_device_by_driver(UCLASS_MISC,
|
2020-12-29 12:34:56 +09:00
|
|
|
DM_DRIVER_GET(stm32mp_bsec),
|
2020-07-31 23:31:48 +09:00
|
|
|
&dev);
|
2020-04-22 21:29:14 +09:00
|
|
|
|
2020-07-31 23:31:48 +09:00
|
|
|
if (!ret)
|
|
|
|
ret = misc_read(dev, STM32_BSEC_SHADOW(BSEC_OTP_BOARD),
|
|
|
|
&otp, sizeof(otp));
|
|
|
|
if (ret > 0 && otp) {
|
|
|
|
snprintf(buf, sizeof(buf), "0x%04x", otp >> 16);
|
|
|
|
env_set("board_id", buf);
|
2020-04-22 21:29:14 +09:00
|
|
|
|
2020-07-31 23:31:48 +09:00
|
|
|
snprintf(buf, sizeof(buf), "0x%04x",
|
|
|
|
((otp >> 8) & 0xF) - 1 + 0xA);
|
|
|
|
env_set("board_rev", buf);
|
2020-04-22 21:29:14 +09:00
|
|
|
}
|
2019-02-28 01:01:11 +09:00
|
|
|
}
|
|
|
|
|
2019-02-13 00:50:40 +09:00
|
|
|
/* for DK1/DK2 boards */
|
|
|
|
board_check_usb_power();
|
|
|
|
|
2019-02-28 01:01:11 +09:00
|
|
|
return 0;
|
|
|
|
}
|
2019-02-13 00:50:40 +09:00
|
|
|
|
|
|
|
void board_quiesce_devices(void)
|
|
|
|
{
|
|
|
|
setup_led(LEDST_OFF);
|
2019-05-17 22:08:43 +09:00
|
|
|
}
|
|
|
|
|
2019-08-01 18:29:03 +09:00
|
|
|
/* eth init function : weak called in eqos driver */
|
|
|
|
int board_interface_eth_init(struct udevice *dev,
|
|
|
|
phy_interface_t interface_type)
|
2019-05-17 22:08:43 +09:00
|
|
|
{
|
|
|
|
u8 *syscfg;
|
|
|
|
u32 value;
|
2019-08-01 18:29:03 +09:00
|
|
|
bool eth_clk_sel_reg = false;
|
|
|
|
bool eth_ref_clk_sel_reg = false;
|
|
|
|
|
|
|
|
/* Gigabit Ethernet 125MHz clock selection. */
|
|
|
|
eth_clk_sel_reg = dev_read_bool(dev, "st,eth_clk_sel");
|
|
|
|
|
|
|
|
/* Ethernet 50Mhz RMII clock selection */
|
|
|
|
eth_ref_clk_sel_reg =
|
|
|
|
dev_read_bool(dev, "st,eth_ref_clk_sel");
|
2019-05-17 22:08:43 +09:00
|
|
|
|
|
|
|
syscfg = (u8 *)syscon_get_first_range(STM32MP_SYSCON_SYSCFG);
|
|
|
|
|
|
|
|
if (!syscfg)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
switch (interface_type) {
|
|
|
|
case PHY_INTERFACE_MODE_MII:
|
|
|
|
value = SYSCFG_PMCSETR_ETH_SEL_GMII_MII |
|
|
|
|
SYSCFG_PMCSETR_ETH_REF_CLK_SEL;
|
|
|
|
debug("%s: PHY_INTERFACE_MODE_MII\n", __func__);
|
|
|
|
break;
|
|
|
|
case PHY_INTERFACE_MODE_GMII:
|
|
|
|
if (eth_clk_sel_reg)
|
|
|
|
value = SYSCFG_PMCSETR_ETH_SEL_GMII_MII |
|
|
|
|
SYSCFG_PMCSETR_ETH_CLK_SEL;
|
|
|
|
else
|
|
|
|
value = SYSCFG_PMCSETR_ETH_SEL_GMII_MII;
|
|
|
|
debug("%s: PHY_INTERFACE_MODE_GMII\n", __func__);
|
|
|
|
break;
|
|
|
|
case PHY_INTERFACE_MODE_RMII:
|
|
|
|
if (eth_ref_clk_sel_reg)
|
|
|
|
value = SYSCFG_PMCSETR_ETH_SEL_RMII |
|
|
|
|
SYSCFG_PMCSETR_ETH_REF_CLK_SEL;
|
|
|
|
else
|
|
|
|
value = SYSCFG_PMCSETR_ETH_SEL_RMII;
|
|
|
|
debug("%s: PHY_INTERFACE_MODE_RMII\n", __func__);
|
|
|
|
break;
|
|
|
|
case PHY_INTERFACE_MODE_RGMII:
|
|
|
|
case PHY_INTERFACE_MODE_RGMII_ID:
|
|
|
|
case PHY_INTERFACE_MODE_RGMII_RXID:
|
|
|
|
case PHY_INTERFACE_MODE_RGMII_TXID:
|
|
|
|
if (eth_clk_sel_reg)
|
|
|
|
value = SYSCFG_PMCSETR_ETH_SEL_RGMII |
|
|
|
|
SYSCFG_PMCSETR_ETH_CLK_SEL;
|
|
|
|
else
|
|
|
|
value = SYSCFG_PMCSETR_ETH_SEL_RGMII;
|
|
|
|
debug("%s: PHY_INTERFACE_MODE_RGMII\n", __func__);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
debug("%s: Do not manage %d interface\n",
|
|
|
|
__func__, interface_type);
|
|
|
|
/* Do not manage others interfaces */
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* clear and set ETH configuration bits */
|
|
|
|
writel(SYSCFG_PMCSETR_ETH_SEL_MASK | SYSCFG_PMCSETR_ETH_SELMII |
|
|
|
|
SYSCFG_PMCSETR_ETH_REF_CLK_SEL | SYSCFG_PMCSETR_ETH_CLK_SEL,
|
|
|
|
syscfg + SYSCFG_PMCCLRR);
|
|
|
|
writel(value, syscfg + SYSCFG_PMCSETR);
|
|
|
|
|
|
|
|
return 0;
|
2019-02-13 00:50:40 +09:00
|
|
|
}
|
2019-05-03 01:07:14 +09:00
|
|
|
|
2019-05-03 01:28:05 +09:00
|
|
|
enum env_location env_get_location(enum env_operation op, int prio)
|
|
|
|
{
|
|
|
|
u32 bootmode = get_bootmode();
|
|
|
|
|
|
|
|
if (prio)
|
|
|
|
return ENVL_UNKNOWN;
|
|
|
|
|
|
|
|
switch (bootmode & TAMP_BOOT_DEVICE_MASK) {
|
2020-06-15 18:18:22 +09:00
|
|
|
case BOOT_FLASH_SD:
|
|
|
|
case BOOT_FLASH_EMMC:
|
2020-07-31 23:31:49 +09:00
|
|
|
if (CONFIG_IS_ENABLED(ENV_IS_IN_MMC))
|
|
|
|
return ENVL_MMC;
|
|
|
|
else if (CONFIG_IS_ENABLED(ENV_IS_IN_EXT4))
|
|
|
|
return ENVL_EXT4;
|
|
|
|
else
|
|
|
|
return ENVL_NOWHERE;
|
|
|
|
|
2019-05-03 01:28:05 +09:00
|
|
|
case BOOT_FLASH_NAND:
|
2020-03-18 17:22:52 +09:00
|
|
|
case BOOT_FLASH_SPINAND:
|
2020-07-31 23:31:49 +09:00
|
|
|
if (CONFIG_IS_ENABLED(ENV_IS_IN_UBI))
|
|
|
|
return ENVL_UBI;
|
|
|
|
else
|
|
|
|
return ENVL_NOWHERE;
|
|
|
|
|
stm32mp1: Update env_get_location for NOR support
Update env_get_location() to be able to save environment into
NOR (SPI_FLASH).
Series-cc: pde, cke, pch, uboot-stm32
Cover-letter:
Add saveenv support for STM32MP1
This series adds saveenv support for STM32MP1 on several boot
devices. STM32MP1 is able to boot on eMMC, sdcard and NOR
(NAND support is not fully supported).
On eMMC and sdcard, environment is saved in EXT4 partition
On NOR, environment is saved in a dedicated partition
On NAND, environment is saved in a UBI volume.
This series:
- enables NAND and NOR support on ev1 board
- enables ENV_IS_IN_SPI_FLASH, ENV_IS_IN_UBI, ENV_IS_IN_EXT4
flags
- fixes get_mtdparts()
- allows to override interface, device and partition for ext4
environment
- updates rule to set ENV_IS_NOWHERE value
- introduce ENV_IS_IN_DEVICE
END
Signed-off-by: Patrice Chotard <patrice.chotard@st.com>
2019-05-09 21:25:36 +09:00
|
|
|
case BOOT_FLASH_NOR:
|
2020-07-31 23:31:49 +09:00
|
|
|
if (CONFIG_IS_ENABLED(ENV_IS_IN_SPI_FLASH))
|
|
|
|
return ENVL_SPI_FLASH;
|
|
|
|
else
|
|
|
|
return ENVL_NOWHERE;
|
|
|
|
|
2019-05-03 01:28:05 +09:00
|
|
|
default:
|
|
|
|
return ENVL_NOWHERE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-03 01:36:01 +09:00
|
|
|
const char *env_ext4_get_intf(void)
|
|
|
|
{
|
|
|
|
u32 bootmode = get_bootmode();
|
|
|
|
|
|
|
|
switch (bootmode & TAMP_BOOT_DEVICE_MASK) {
|
|
|
|
case BOOT_FLASH_SD:
|
|
|
|
case BOOT_FLASH_EMMC:
|
|
|
|
return "mmc";
|
|
|
|
default:
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *env_ext4_get_dev_part(void)
|
|
|
|
{
|
|
|
|
static char *const dev_part[] = {"0:auto", "1:auto", "2:auto"};
|
|
|
|
u32 bootmode = get_bootmode();
|
|
|
|
|
|
|
|
return dev_part[(bootmode & TAMP_BOOT_INSTANCE_MASK) - 1];
|
|
|
|
}
|
2020-06-15 18:18:22 +09:00
|
|
|
int mmc_get_env_dev(void)
|
|
|
|
{
|
|
|
|
u32 bootmode = get_bootmode();
|
|
|
|
|
|
|
|
return (bootmode & TAMP_BOOT_INSTANCE_MASK) - 1;
|
|
|
|
}
|
|
|
|
|
2019-07-02 20:26:07 +09:00
|
|
|
#if defined(CONFIG_OF_BOARD_SETUP)
|
2020-06-26 15:13:33 +09:00
|
|
|
int ft_board_setup(void *blob, struct bd_info *bd)
|
2019-07-02 20:26:07 +09:00
|
|
|
{
|
2020-07-29 20:24:52 +09:00
|
|
|
static const struct node_info nodes[] = {
|
2019-07-02 20:26:07 +09:00
|
|
|
{ "st,stm32f469-qspi", MTD_DEV_TYPE_NOR, },
|
2020-03-18 17:22:52 +09:00
|
|
|
{ "st,stm32f469-qspi", MTD_DEV_TYPE_SPINAND},
|
2019-07-02 20:26:07 +09:00
|
|
|
{ "st,stm32mp15-fmc2", MTD_DEV_TYPE_NAND, },
|
2020-07-31 16:53:42 +09:00
|
|
|
{ "st,stm32mp1-fmc2-nfc", MTD_DEV_TYPE_NAND, },
|
2019-07-02 20:26:07 +09:00
|
|
|
};
|
2020-10-15 21:52:30 +09:00
|
|
|
char *boot_device;
|
|
|
|
|
|
|
|
/* Check the boot-source and don't update MTD for serial or usb boot */
|
|
|
|
boot_device = env_get("boot_device");
|
|
|
|
if (!boot_device ||
|
|
|
|
(strcmp(boot_device, "serial") && strcmp(boot_device, "usb")))
|
|
|
|
if (IS_ENABLED(CONFIG_FDT_FIXUP_PARTITIONS))
|
|
|
|
fdt_fixup_mtdparts(blob, nodes, ARRAY_SIZE(nodes));
|
2019-07-02 20:26:07 +09:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2019-08-02 22:07:20 +09:00
|
|
|
|
|
|
|
static void board_copro_image_process(ulong fw_image, size_t fw_size)
|
|
|
|
{
|
|
|
|
int ret, id = 0; /* Copro id fixed to 0 as only one coproc on mp1 */
|
|
|
|
|
|
|
|
if (!rproc_is_initialized())
|
|
|
|
if (rproc_init()) {
|
|
|
|
printf("Remote Processor %d initialization failed\n",
|
|
|
|
id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rproc_load(id, fw_image, fw_size);
|
|
|
|
printf("Load Remote Processor %d with data@addr=0x%08lx %u bytes:%s\n",
|
|
|
|
id, fw_image, fw_size, ret ? " Failed!" : " Success!");
|
|
|
|
|
2019-10-30 22:38:32 +09:00
|
|
|
if (!ret)
|
2019-08-02 22:07:20 +09:00
|
|
|
rproc_start(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
U_BOOT_FIT_LOADABLE_HANDLER(IH_TYPE_COPRO, board_copro_image_process);
|