[people/ms/u-boot.git] / arch / arm / mach-rockchip / rk3188-board-spl.c

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

#include <clk.h>
#include <common.h>
#include <debug_uart.h>
#include <dm.h>
#include <fdtdec.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/pmu_rk3188.h>
#include <asm/arch/sdram.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 <syscon.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:
#endif
	return BOOT_DEVICE_MMC1;
}

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

static int setup_arm_clock(void)
{
	struct udevice *dev;
	struct clk clk;
	int ret;

	ret = rockchip_get_clk(&dev);
	if (ret)
		return ret;

	clk.id = CLK_ARM;
	ret = clk_request(dev, &clk);
	if (ret < 0)
		return ret;

	ret = clk_set_rate(&clk, 600000000);

	clk_free(&clk);
	return ret;
}

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

	/* Example code showing how to enable the debug UART on RK3188 */
#ifdef EARLY_UART
#include <asm/arch/grf_rk3188.h>
	/* Enable early UART on the RK3188 */
#define GRF_BASE	0x20008000
	struct rk3188_grf * const grf = (void *)GRF_BASE;

	rk_clrsetreg(&grf->gpio1b_iomux,
		     GPIO1B1_MASK << GPIO1B1_SHIFT |
		     GPIO1B0_MASK << GPIO1B0_SHIFT,
		     GPIO1B1_UART2_SOUT << GPIO1B1_SHIFT |
		     GPIO1B0_UART2_SIN << GPIO1B0_SHIFT);
	/*
	 * Debug UART can be used from here if required:
	 *
	 * debug_uart_init();
	 * printch('a');
	 * printhex8(0x1234);
	 * printascii("string");
	 */
	debug_uart_init();
	printch('s');
	printch('p');
	printch('l');
	printch('\n');
#endif

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

	rockchip_timer_init();

	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;
	}

	ret = uclass_get_device(UCLASS_RAM, 0, &dev);
	if (ret) {
		debug("DRAM init failed: %d\n", ret);
		return;
	}

	setup_arm_clock();
#if CONFIG_IS_ENABLED(ROCKCHIP_BACK_TO_BROM) && !defined(CONFIG_SPL_BOARD_INIT)
	back_to_bootrom(BROM_BOOT_NEXTSTAGE);
#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;
	}
#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(BROM_BOOT_NEXTSTAGE);
#endif
	return;

err:
	printf("spl_board_init: Error %d\n", ret);

	/* No way to report error here */
	hang();
}
Commit	Line	Data
df9041ec HS	1	/*
	2	* (C) Copyright 2015 Google, Inc
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	*/
	6
f4f57c58	7	#include <clk.h>
df9041ec HS	8	#include <common.h>
	9	#include <debug_uart.h>
	10	#include <dm.h>
	11	#include <fdtdec.h>
	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>
	18	#include <asm/arch/bootrom.h>
	19	#include <asm/arch/clock.h>
	20	#include <asm/arch/hardware.h>
	21	#include <asm/arch/periph.h>
	22	#include <asm/arch/pmu_rk3188.h>
	23	#include <asm/arch/sdram.h>
	24	#include <asm/arch/timer.h>
	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>
	30	#include <syscon.h>
	31
	32	DECLARE_GLOBAL_DATA_PTR;
	33
	34	u32 spl_boot_device(void)
	35	{
	36	#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	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:
	71	#endif
72	return BOOT_DEVICE_MMC1;
73	}
74
75	u32 spl_boot_mode(const u32 boot_device)
76	{
77	return MMCSD_MODE_RAW;
78	}
79
f4f57c58 HS	80	static int setup_arm_clock(void)
	81	{
	82	struct udevice *dev;
	83	struct clk clk;
	84	int ret;
	85
	86	ret = rockchip_get_clk(&dev);
	87	if (ret)
	88	return ret;
	89
	90	clk.id = CLK_ARM;
	91	ret = clk_request(dev, &clk);
	92	if (ret < 0)
	93	return ret;
	94
	95	ret = clk_set_rate(&clk, 600000000);
	96
	97	clk_free(&clk);
	98	return ret;
	99	}
	100
df9041ec HS	101	void board_init_f(ulong dummy)
	102	{
	103	struct udevice pinctrl, dev;
df9041ec HS	104	int ret;
	105
	106	/* Example code showing how to enable the debug UART on RK3188 */
	107	#ifdef EARLY_UART
	108	#include <asm/arch/grf_rk3188.h>
	109	/* Enable early UART on the RK3188 */
	110	#define GRF_BASE 0x20008000
	111	struct rk3188_grf * const grf = (void *)GRF_BASE;
	112
	113	rk_clrsetreg(&grf->gpio1b_iomux,
	114	GPIO1B1_MASK << GPIO1B1_SHIFT \|
	115	GPIO1B0_MASK << GPIO1B0_SHIFT,
	116	GPIO1B1_UART2_SOUT << GPIO1B1_SHIFT \|
	117	GPIO1B0_UART2_SIN << GPIO1B0_SHIFT);
	118	/*
	119	* Debug UART can be used from here if required:
	120	*
	121	* debug_uart_init();
	122	* printch('a');
	123	* printhex8(0x1234);
	124	* printascii("string");
	125	*/
	126	debug_uart_init();
	127	printch('s');
	128	printch('p');
	129	printch('l');
	130	printch('\n');
	131	#endif
	132
232cf962	133	ret = spl_early_init();
df9041ec	134	if (ret) {
232cf962	135	debug("spl_early_init() failed: %d\n", ret);
df9041ec HS	136	hang();
	137	}
	138
	139	rockchip_timer_init();
	140
	141	ret = rockchip_get_clk(&dev);
	142	if (ret) {
	143	debug("CLK init failed: %d\n", ret);
	144	return;
	145	}
	146
df9041ec HS	147	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
	148	if (ret) {
	149	debug("Pinctrl init failed: %d\n", ret);
	150	return;
	151	}
	152
	153	ret = uclass_get_device(UCLASS_RAM, 0, &dev);
	154	if (ret) {
	155	debug("DRAM init failed: %d\n", ret);
	156	return;
	157	}
	158
f4f57c58	159	setup_arm_clock();
ee14d29d	160	#if CONFIG_IS_ENABLED(ROCKCHIP_BACK_TO_BROM) && !defined(CONFIG_SPL_BOARD_INIT)
b82bd1f8	161	back_to_bootrom(BROM_BOOT_NEXTSTAGE);
df9041ec HS	162	#endif
	163	}
	164
	165	static int setup_led(void)
	166	{
	167	#ifdef CONFIG_SPL_LED
	168	struct udevice *dev;
	169	char *led_name;
	170	int ret;
	171
	172	led_name = fdtdec_get_config_string(gd->fdt_blob, "u-boot,boot-led");
	173	if (!led_name)
	174	return 0;
	175	ret = led_get_by_label(led_name, &dev);
	176	if (ret) {
	177	debug("%s: get=%d\n", __func__, ret);
	178	return ret;
	179	}
	180	ret = led_set_on(dev, 1);
	181	if (ret)
	182	return ret;
	183	#endif
	184
	185	return 0;
	186	}
	187
	188	void spl_board_init(void)
	189	{
	190	struct udevice *pinctrl;
	191	int ret;
	192
	193	ret = setup_led();
	194	if (ret) {
	195	debug("LED ret=%d\n", ret);
	196	hang();
	197	}
	198
	199	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
	200	if (ret) {
	201	debug("%s: Cannot find pinctrl device\n", __func__);
	202	goto err;
	203	}
	204
	205	#ifdef CONFIG_SPL_MMC_SUPPORT
	206	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_SDCARD);
	207	if (ret) {
	208	debug("%s: Failed to set up SD card\n", __func__);
	209	goto err;
	210	}
	211	#endif
	212
	213	/* Enable debug UART */
	214	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_UART_DBG);
	215	if (ret) {
	216	debug("%s: Failed to set up console UART\n", __func__);
	217	goto err;
	218	}
	219
	220	preloader_console_init();
ee14d29d	221	#if CONFIG_IS_ENABLED(ROCKCHIP_BACK_TO_BROM)
b82bd1f8	222	back_to_bootrom(BROM_BOOT_NEXTSTAGE);
df9041ec HS	223	#endif
	224	return;
	225
	226	err:
	227	printf("spl_board_init: Error %d\n", ret);
	228
	229	/* No way to report error here */
	230	hang();
	231	}