[u-boot.git] / arch / arm / mach-rockchip / rk3288-board-spl.c

/*
 * (C) Copyright 2015 Google, Inc
 *
 * SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <debug_uart.h>
#include <dm.h>
#include <fdtdec.h>
#include <i2c.h>
#include <led.h>
#include <malloc.h>
#include <ram.h>
#include <spl.h>
#include <asm/gpio.h>
#include <asm/io.h>
#include <asm/arch/bootrom.h>
#include <asm/arch/clock.h>
#include <asm/arch/hardware.h>
#include <asm/arch/periph.h>
#include <asm/arch/sdram.h>
#include <asm/arch/sys_proto.h>
#include <asm/arch/timer.h>
#include <dm/pinctrl.h>
#include <dm/root.h>
#include <dm/test.h>
#include <dm/util.h>
#include <power/regulator.h>
#include <power/rk8xx_pmic.h>

DECLARE_GLOBAL_DATA_PTR;

u32 spl_boot_device(void)
{
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	const void *blob = gd->fdt_blob;
	struct udevice *dev;
	const char *bootdev;
	int node;
	int ret;

	bootdev = fdtdec_get_config_string(blob, "u-boot,boot0");
	debug("Boot device %s\n", bootdev);
	if (!bootdev)
		goto fallback;

	node = fdt_path_offset(blob, bootdev);
	if (node < 0) {
		debug("node=%d\n", node);
		goto fallback;
	}
	ret = device_get_global_by_of_offset(node, &dev);
	if (ret) {
		debug("device at node %s/%d not found: %d\n", bootdev, node,
		      ret);
		goto fallback;
	}
	debug("Found device %s\n", dev->name);
	switch (device_get_uclass_id(dev)) {
	case UCLASS_SPI_FLASH:
		return BOOT_DEVICE_SPI;
	case UCLASS_MMC:
		return BOOT_DEVICE_MMC1;
	default:
		debug("Booting from device uclass '%s' not supported\n",
		      dev_get_uclass_name(dev));
	}

fallback:
#elif defined(CONFIG_TARGET_CHROMEBOOK_JERRY) || \
		defined(CONFIG_TARGET_CHROMEBIT_MICKEY) || \
		defined(CONFIG_TARGET_CHROMEBOOK_MINNIE)
	return BOOT_DEVICE_SPI;
#endif
	return BOOT_DEVICE_MMC1;
}

u32 spl_boot_mode(const u32 boot_device)
{
	return MMCSD_MODE_RAW;
}

#ifdef CONFIG_SPL_MMC_SUPPORT
static int configure_emmc(struct udevice *pinctrl)
{
#if defined(CONFIG_TARGET_CHROMEBOOK_JERRY)

	struct gpio_desc desc;
	int ret;

	pinctrl_request_noflags(pinctrl, PERIPH_ID_EMMC);

	/*
	 * TODO(sjg@chromium.org): Pick this up from device tree or perhaps
	 * use the EMMC_PWREN setting.
	 */
	ret = dm_gpio_lookup_name("D9", &desc);
	if (ret) {
		debug("gpio ret=%d\n", ret);
		return ret;
	}
	ret = dm_gpio_request(&desc, "emmc_pwren");
	if (ret) {
		debug("gpio_request ret=%d\n", ret);
		return ret;
	}
	ret = dm_gpio_set_dir_flags(&desc, GPIOD_IS_OUT);
	if (ret) {
		debug("gpio dir ret=%d\n", ret);
		return ret;
	}
	ret = dm_gpio_set_value(&desc, 1);
	if (ret) {
		debug("gpio value ret=%d\n", ret);
		return ret;
	}
#endif
	return 0;
}
#endif

#if !defined(CONFIG_SPL_OF_PLATDATA)
static int phycore_init(void)
{
	struct udevice *pmic;
	int ret;

	ret = uclass_first_device_err(UCLASS_PMIC, &pmic);
	if (ret)
		return ret;

#if defined(CONFIG_SPL_POWER_SUPPORT)
	/* Increase USB input current to 2A */
	ret = rk818_spl_configure_usb_input_current(pmic, 2000);
	if (ret)
		return ret;

	/* Close charger when USB lower then 3.26V */
	ret = rk818_spl_configure_usb_chrg_shutdown(pmic, 3260000);
	if (ret)
		return ret;
#endif

	return 0;
}
#endif

void board_init_f(ulong dummy)
{
	struct udevice *pinctrl;
	struct udevice *dev;
	int ret;

	/* Example code showing how to enable the debug UART on RK3288 */
#include <asm/arch/grf_rk3288.h>
	/* Enable early UART on the RK3288 */
#define GRF_BASE	0xff770000
	struct rk3288_grf * const grf = (void *)GRF_BASE;

	rk_clrsetreg(&grf->gpio7ch_iomux, GPIO7C7_MASK << GPIO7C7_SHIFT |
		     GPIO7C6_MASK << GPIO7C6_SHIFT,
		     GPIO7C7_UART2DBG_SOUT << GPIO7C7_SHIFT |
		     GPIO7C6_UART2DBG_SIN << GPIO7C6_SHIFT);
	/*
	 * Debug UART can be used from here if required:
	 *
	 * debug_uart_init();
	 * printch('a');
	 * printhex8(0x1234);
	 * printascii("string");
	 */
	debug_uart_init();
	debug("\nspl:debug uart enabled in %s\n", __func__);
	ret = spl_early_init();
	if (ret) {
		debug("spl_early_init() failed: %d\n", ret);
		hang();
	}

	rockchip_timer_init();
	configure_l2ctlr();

	ret = rockchip_get_clk(&dev);
	if (ret) {
		debug("CLK init failed: %d\n", ret);
		return;
	}

	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
	if (ret) {
		debug("Pinctrl init failed: %d\n", ret);
		return;
	}

#if !defined(CONFIG_SPL_OF_PLATDATA)
	if (of_machine_is_compatible("phytec,rk3288-phycore-som")) {
		ret = phycore_init();
		if (ret) {
			debug("Failed to set up phycore power settings: %d\n",
			      ret);
			return;
		}
	}
#endif

#if !defined(CONFIG_SUPPORT_TPL)
	debug("\nspl:init dram\n");
	ret = uclass_get_device(UCLASS_RAM, 0, &dev);
	if (ret) {
		debug("DRAM init failed: %d\n", ret);
		return;
	}
#endif

#if CONFIG_IS_ENABLED(ROCKCHIP_BACK_TO_BROM) && !defined(CONFIG_SPL_BOARD_INIT)
	back_to_bootrom();
#endif
}

static int setup_led(void)
{
#ifdef CONFIG_SPL_LED
	struct udevice *dev;
	char *led_name;
	int ret;

	led_name = fdtdec_get_config_string(gd->fdt_blob, "u-boot,boot-led");
	if (!led_name)
		return 0;
	ret = led_get_by_label(led_name, &dev);
	if (ret) {
		debug("%s: get=%d\n", __func__, ret);
		return ret;
	}
	ret = led_set_on(dev, 1);
	if (ret)
		return ret;
#endif

	return 0;
}

void spl_board_init(void)
{
	struct udevice *pinctrl;
	int ret;

	ret = setup_led();

	if (ret) {
		debug("LED ret=%d\n", ret);
		hang();
	}

	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
	if (ret) {
		debug("%s: Cannot find pinctrl device\n", __func__);
		goto err;
	}

#ifdef CONFIG_SPL_MMC_SUPPORT
	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_SDCARD);
	if (ret) {
		debug("%s: Failed to set up SD card\n", __func__);
		goto err;
	}
	ret = configure_emmc(pinctrl);
	if (ret) {
		debug("%s: Failed to set up eMMC\n", __func__);
		goto err;
	}
#endif

	/* Enable debug UART */
	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_UART_DBG);
	if (ret) {
		debug("%s: Failed to set up console UART\n", __func__);
		goto err;
	}

	preloader_console_init();
#if CONFIG_IS_ENABLED(ROCKCHIP_BACK_TO_BROM)
	back_to_bootrom();
#endif
	return;
err:
	printf("spl_board_init: Error %d\n", ret);

	/* No way to report error here */
	hang();
}
Commit	Line	Data
2444dae5 SG	1	/*
	2	* (C) Copyright 2015 Google, Inc
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	*/
	6
	7	#include <common.h>
	8	#include <debug_uart.h>
	9	#include <dm.h>
	10	#include <fdtdec.h>
bafcf2db	11	#include <i2c.h>
2444dae5 SG	12	#include <led.h>
	13	#include <malloc.h>
	14	#include <ram.h>
	15	#include <spl.h>
	16	#include <asm/gpio.h>
	17	#include <asm/io.h>
aade077e	18	#include <asm/arch/bootrom.h>
2444dae5 SG	19	#include <asm/arch/clock.h>
	20	#include <asm/arch/hardware.h>
	21	#include <asm/arch/periph.h>
	22	#include <asm/arch/sdram.h>
a982d515	23	#include <asm/arch/sys_proto.h>
cc2244b8	24	#include <asm/arch/timer.h>
2444dae5 SG	25	#include <dm/pinctrl.h>
	26	#include <dm/root.h>
	27	#include <dm/test.h>
	28	#include <dm/util.h>
	29	#include <power/regulator.h>
bafcf2db	30	#include <power/rk8xx_pmic.h>
2444dae5 SG	31
	32	DECLARE_GLOBAL_DATA_PTR;
	33
	34	u32 spl_boot_device(void)
	35	{
6afc4661	36	#if !CONFIG_IS_ENABLED(OF_PLATDATA)
2444dae5 SG	37	const void *blob = gd->fdt_blob;
	38	struct udevice *dev;
	39	const char *bootdev;
	40	int node;
	41	int ret;
	42
	43	bootdev = fdtdec_get_config_string(blob, "u-boot,boot0");
	44	debug("Boot device %s\n", bootdev);
	45	if (!bootdev)
	46	goto fallback;
	47
	48	node = fdt_path_offset(blob, bootdev);
	49	if (node < 0) {
	50	debug("node=%d\n", node);
	51	goto fallback;
	52	}
	53	ret = device_get_global_by_of_offset(node, &dev);
	54	if (ret) {
	55	debug("device at node %s/%d not found: %d\n", bootdev, node,
	56	ret);
	57	goto fallback;
	58	}
	59	debug("Found device %s\n", dev->name);
	60	switch (device_get_uclass_id(dev)) {
	61	case UCLASS_SPI_FLASH:
	62	return BOOT_DEVICE_SPI;
	63	case UCLASS_MMC:
	64	return BOOT_DEVICE_MMC1;
	65	default:
	66	debug("Booting from device uclass '%s' not supported\n",
	67	dev_get_uclass_name(dev));
	68	}
	69
	70	fallback:
e70408c0	71	#elif defined(CONFIG_TARGET_CHROMEBOOK_JERRY) \|\| \
c420ef67 SG	72	defined(CONFIG_TARGET_CHROMEBIT_MICKEY) \|\| \
c420ef67 SG	73	defined(CONFIG_TARGET_CHROMEBOOK_MINNIE)
c8816d14	74	return BOOT_DEVICE_SPI;
6afc4661	75	#endif
2444dae5 SG	76	return BOOT_DEVICE_MMC1;
	77	}
	78
2b1cdafa	79	u32 spl_boot_mode(const u32 boot_device)
2444dae5 SG	80	{
	81	return MMCSD_MODE_RAW;
	82	}
	83
f23cf909	84	#ifdef CONFIG_SPL_MMC_SUPPORT
2444dae5 SG	85	static int configure_emmc(struct udevice *pinctrl)
2444dae5 SG	86	{
d7ca67b7	87	#if defined(CONFIG_TARGET_CHROMEBOOK_JERRY)
5051a77b	88
2444dae5 SG	89	struct gpio_desc desc;
	90	int ret;
	91
	92	pinctrl_request_noflags(pinctrl, PERIPH_ID_EMMC);
	93
	94	/*
	95	* TODO(sjg@chromium.org): Pick this up from device tree or perhaps
	96	* use the EMMC_PWREN setting.
	97	*/
	98	ret = dm_gpio_lookup_name("D9", &desc);
	99	if (ret) {
	100	debug("gpio ret=%d\n", ret);
	101	return ret;
	102	}
	103	ret = dm_gpio_request(&desc, "emmc_pwren");
	104	if (ret) {
	105	debug("gpio_request ret=%d\n", ret);
	106	return ret;
	107	}
	108	ret = dm_gpio_set_dir_flags(&desc, GPIOD_IS_OUT);
	109	if (ret) {
	110	debug("gpio dir ret=%d\n", ret);
	111	return ret;
	112	}
	113	ret = dm_gpio_set_value(&desc, 1);
	114	if (ret) {
	115	debug("gpio value ret=%d\n", ret);
	116	return ret;
	117	}
5051a77b	118	#endif
2444dae5 SG	119	return 0;
2444dae5 SG	120	}
f23cf909	121	#endif
aade077e	122
bafcf2db WE	123	#if !defined(CONFIG_SPL_OF_PLATDATA)
	124	static int phycore_init(void)
	125	{
	126	struct udevice *pmic;
	127	int ret;
	128
	129	ret = uclass_first_device_err(UCLASS_PMIC, &pmic);
	130	if (ret)
	131	return ret;
	132
	133	#if defined(CONFIG_SPL_POWER_SUPPORT)
	134	/* Increase USB input current to 2A */
	135	ret = rk818_spl_configure_usb_input_current(pmic, 2000);
	136	if (ret)
	137	return ret;
	138
	139	/* Close charger when USB lower then 3.26V */
	140	ret = rk818_spl_configure_usb_chrg_shutdown(pmic, 3260000);
	141	if (ret)
	142	return ret;
	143	#endif
	144
	145	return 0;
	146	}
	147	#endif
	148
2444dae5 SG	149	void board_init_f(ulong dummy)
	150	{
	151	struct udevice *pinctrl;
	152	struct udevice *dev;
	153	int ret;
	154
	155	/* Example code showing how to enable the debug UART on RK3288 */
2444dae5 SG	156	#include <asm/arch/grf_rk3288.h>
	157	/* Enable early UART on the RK3288 */
	158	#define GRF_BASE 0xff770000
	159	struct rk3288_grf * const grf = (void *)GRF_BASE;
	160
	161	rk_clrsetreg(&grf->gpio7ch_iomux, GPIO7C7_MASK << GPIO7C7_SHIFT \|
	162	GPIO7C6_MASK << GPIO7C6_SHIFT,
	163	GPIO7C7_UART2DBG_SOUT << GPIO7C7_SHIFT \|
	164	GPIO7C6_UART2DBG_SIN << GPIO7C6_SHIFT);
	165	/*
	166	* Debug UART can be used from here if required:
	167	*
	168	* debug_uart_init();
	169	* printch('a');
	170	* printhex8(0x1234);
	171	* printascii("string");
	172	*/
	173	debug_uart_init();
7474bbe8	174	debug("\nspl:debug uart enabled in %s\n", __func__);
73976056	175	ret = spl_early_init();
2444dae5	176	if (ret) {
73976056	177	debug("spl_early_init() failed: %d\n", ret);
2444dae5 SG	178	hang();
	179	}
	180
cc2244b8	181	rockchip_timer_init();
2444dae5 SG	182	configure_l2ctlr();
2444dae5 SG	183
c3aad6f6	184	ret = rockchip_get_clk(&dev);
2444dae5 SG	185	if (ret) {
	186	debug("CLK init failed: %d\n", ret);
	187	return;
	188	}
	189
	190	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
	191	if (ret) {
	192	debug("Pinctrl init failed: %d\n", ret);
	193	return;
	194	}
bafcf2db WE	195
	196	#if !defined(CONFIG_SPL_OF_PLATDATA)
	197	if (of_machine_is_compatible("phytec,rk3288-phycore-som")) {
	198	ret = phycore_init();
	199	if (ret) {
	200	debug("Failed to set up phycore power settings: %d\n",
	201	ret);
	202	return;
	203	}
	204	}
	205	#endif
	206
532cb7f5	207	#if !defined(CONFIG_SUPPORT_TPL)
7474bbe8	208	debug("\nspl:init dram\n");
2444dae5 SG	209	ret = uclass_get_device(UCLASS_RAM, 0, &dev);
	210	if (ret) {
	211	debug("DRAM init failed: %d\n", ret);
	212	return;
	213	}
532cb7f5 JT	214	#endif
532cb7f5 JT	215
ee14d29d	216	#if CONFIG_IS_ENABLED(ROCKCHIP_BACK_TO_BROM) && !defined(CONFIG_SPL_BOARD_INIT)
b47ea792 XZ	217	back_to_bootrom();
b47ea792 XZ	218	#endif
2444dae5 SG	219	}
	220
	221	static int setup_led(void)
	222	{
	223	#ifdef CONFIG_SPL_LED
	224	struct udevice *dev;
	225	char *led_name;
	226	int ret;
	227
	228	led_name = fdtdec_get_config_string(gd->fdt_blob, "u-boot,boot-led");
	229	if (!led_name)
	230	return 0;
	231	ret = led_get_by_label(led_name, &dev);
	232	if (ret) {
	233	debug("%s: get=%d\n", __func__, ret);
	234	return ret;
	235	}
	236	ret = led_set_on(dev, 1);
	237	if (ret)
	238	return ret;
	239	#endif
	240
	241	return 0;
	242	}
	243
	244	void spl_board_init(void)
	245	{
	246	struct udevice *pinctrl;
	247	int ret;
	248
	249	ret = setup_led();
	250
	251	if (ret) {
	252	debug("LED ret=%d\n", ret);
	253	hang();
	254	}
	255
	256	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
	257	if (ret) {
	258	debug("%s: Cannot find pinctrl device\n", __func__);
	259	goto err;
	260	}
5051a77b	261
f23cf909	262	#ifdef CONFIG_SPL_MMC_SUPPORT
5051a77b	263	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_SDCARD);
	264	if (ret) {
	265	debug("%s: Failed to set up SD card\n", __func__);
	266	goto err;
	267	}
	268	ret = configure_emmc(pinctrl);
	269	if (ret) {
	270	debug("%s: Failed to set up eMMC\n", __func__);
	271	goto err;
2444dae5	272	}
f23cf909	273	#endif
2444dae5 SG	274
	275	/* Enable debug UART */
	276	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_UART_DBG);
	277	if (ret) {
	278	debug("%s: Failed to set up console UART\n", __func__);
	279	goto err;
	280	}
	281
	282	preloader_console_init();
ee14d29d	283	#if CONFIG_IS_ENABLED(ROCKCHIP_BACK_TO_BROM)
427351dc SP	284	back_to_bootrom();
427351dc SP	285	#endif
2444dae5 SG	286	return;
	287	err:
	288	printf("spl_board_init: Error %d\n", ret);
	289
	290	/* No way to report error here */
	291	hang();
	292	}