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>
11 #include <led.h>
12 #include <malloc.h>
13 #include <ram.h>
14 #include <spl.h>
15 #include <asm/gpio.h>
16 #include <asm/io.h>
17 #include <asm/arch/clock.h>
18 #include <asm/arch/hardware.h>
19 #include <asm/arch/periph.h>
20 #include <asm/arch/sdram.h>
21 #include <asm/arch/timer.h>
22 #include <dm/pinctrl.h>
23 #include <dm/root.h>
24 #include <dm/test.h>
25 #include <dm/util.h>
26 #include <power/regulator.h>
27 
28 DECLARE_GLOBAL_DATA_PTR;
29 
30 u32 spl_boot_device(void)
31 {
32 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
33 	const void *blob = gd->fdt_blob;
34 	struct udevice *dev;
35 	const char *bootdev;
36 	int node;
37 	int ret;
38 
39 	bootdev = fdtdec_get_config_string(blob, "u-boot,boot0");
40 	debug("Boot device %s\n", bootdev);
41 	if (!bootdev)
42 		goto fallback;
43 
44 	node = fdt_path_offset(blob, bootdev);
45 	if (node < 0) {
46 		debug("node=%d\n", node);
47 		goto fallback;
48 	}
49 	ret = device_get_global_by_of_offset(node, &dev);
50 	if (ret) {
51 		debug("device at node %s/%d not found: %d\n", bootdev, node,
52 		      ret);
53 		goto fallback;
54 	}
55 	debug("Found device %s\n", dev->name);
56 	switch (device_get_uclass_id(dev)) {
57 	case UCLASS_SPI_FLASH:
58 		return BOOT_DEVICE_SPI;
59 	case UCLASS_MMC:
60 		return BOOT_DEVICE_MMC1;
61 	default:
62 		debug("Booting from device uclass '%s' not supported\n",
63 		      dev_get_uclass_name(dev));
64 	}
65 
66 fallback:
67 #endif
68 	return BOOT_DEVICE_MMC1;
69 }
70 
71 u32 spl_boot_mode(const u32 boot_device)
72 {
73 	return MMCSD_MODE_RAW;
74 }
75 
76 /* read L2 control register (L2CTLR) */
77 static inline uint32_t read_l2ctlr(void)
78 {
79 	uint32_t val = 0;
80 
81 	asm volatile ("mrc p15, 1, %0, c9, c0, 2" : "=r" (val));
82 
83 	return val;
84 }
85 
86 /* write L2 control register (L2CTLR) */
87 static inline void write_l2ctlr(uint32_t val)
88 {
89 	/*
90 	 * Note: L2CTLR can only be written when the L2 memory system
91 	 * is idle, ie before the MMU is enabled.
92 	 */
93 	asm volatile("mcr p15, 1, %0, c9, c0, 2" : : "r" (val) : "memory");
94 	isb();
95 }
96 
97 static void configure_l2ctlr(void)
98 {
99 	uint32_t l2ctlr;
100 
101 	l2ctlr = read_l2ctlr();
102 	l2ctlr &= 0xfffc0000; /* clear bit0~bit17 */
103 
104 	/*
105 	* Data RAM write latency: 2 cycles
106 	* Data RAM read latency: 2 cycles
107 	* Data RAM setup latency: 1 cycle
108 	* Tag RAM write latency: 1 cycle
109 	* Tag RAM read latency: 1 cycle
110 	* Tag RAM setup latency: 1 cycle
111 	*/
112 	l2ctlr |= (1 << 3 | 1 << 0);
113 	write_l2ctlr(l2ctlr);
114 }
115 
116 #ifdef CONFIG_SPL_MMC_SUPPORT
117 static int configure_emmc(struct udevice *pinctrl)
118 {
119 	struct gpio_desc desc;
120 	int ret;
121 
122 	pinctrl_request_noflags(pinctrl, PERIPH_ID_EMMC);
123 
124 	/*
125 	 * TODO(sjg@chromium.org): Pick this up from device tree or perhaps
126 	 * use the EMMC_PWREN setting.
127 	 */
128 	ret = dm_gpio_lookup_name("D9", &desc);
129 	if (ret) {
130 		debug("gpio ret=%d\n", ret);
131 		return ret;
132 	}
133 	ret = dm_gpio_request(&desc, "emmc_pwren");
134 	if (ret) {
135 		debug("gpio_request ret=%d\n", ret);
136 		return ret;
137 	}
138 	ret = dm_gpio_set_dir_flags(&desc, GPIOD_IS_OUT);
139 	if (ret) {
140 		debug("gpio dir ret=%d\n", ret);
141 		return ret;
142 	}
143 	ret = dm_gpio_set_value(&desc, 1);
144 	if (ret) {
145 		debug("gpio value ret=%d\n", ret);
146 		return ret;
147 	}
148 
149 	return 0;
150 }
151 #endif
152 
153 void board_init_f(ulong dummy)
154 {
155 	struct udevice *pinctrl;
156 	struct udevice *dev;
157 	int ret;
158 
159 	/* Example code showing how to enable the debug UART on RK3288 */
160 #ifdef EARLY_UART
161 #include <asm/arch/grf_rk3288.h>
162 	/* Enable early UART on the RK3288 */
163 #define GRF_BASE	0xff770000
164 	struct rk3288_grf * const grf = (void *)GRF_BASE;
165 
166 	rk_clrsetreg(&grf->gpio7ch_iomux, GPIO7C7_MASK << GPIO7C7_SHIFT |
167 		     GPIO7C6_MASK << GPIO7C6_SHIFT,
168 		     GPIO7C7_UART2DBG_SOUT << GPIO7C7_SHIFT |
169 		     GPIO7C6_UART2DBG_SIN << GPIO7C6_SHIFT);
170 	/*
171 	 * Debug UART can be used from here if required:
172 	 *
173 	 * debug_uart_init();
174 	 * printch('a');
175 	 * printhex8(0x1234);
176 	 * printascii("string");
177 	 */
178 	debug_uart_init();
179 #endif
180 
181 	ret = spl_init();
182 	if (ret) {
183 		debug("spl_init() failed: %d\n", ret);
184 		hang();
185 	}
186 
187 	rockchip_timer_init();
188 	configure_l2ctlr();
189 
190 	ret = uclass_get_device(UCLASS_CLK, 0, &dev);
191 	if (ret) {
192 		debug("CLK init failed: %d\n", ret);
193 		return;
194 	}
195 
196 	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
197 	if (ret) {
198 		debug("Pinctrl init failed: %d\n", ret);
199 		return;
200 	}
201 
202 	ret = uclass_get_device(UCLASS_RAM, 0, &dev);
203 	if (ret) {
204 		debug("DRAM init failed: %d\n", ret);
205 		return;
206 	}
207 }
208 
209 static int setup_led(void)
210 {
211 #ifdef CONFIG_SPL_LED
212 	struct udevice *dev;
213 	char *led_name;
214 	int ret;
215 
216 	led_name = fdtdec_get_config_string(gd->fdt_blob, "u-boot,boot-led");
217 	if (!led_name)
218 		return 0;
219 	ret = led_get_by_label(led_name, &dev);
220 	if (ret) {
221 		debug("%s: get=%d\n", __func__, ret);
222 		return ret;
223 	}
224 	ret = led_set_on(dev, 1);
225 	if (ret)
226 		return ret;
227 #endif
228 
229 	return 0;
230 }
231 
232 void spl_board_init(void)
233 {
234 	struct udevice *pinctrl;
235 	int ret;
236 
237 	ret = setup_led();
238 
239 	if (ret) {
240 		debug("LED ret=%d\n", ret);
241 		hang();
242 	}
243 
244 	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
245 	if (ret) {
246 		debug("%s: Cannot find pinctrl device\n", __func__);
247 		goto err;
248 	}
249 #ifdef CONFIG_SPL_MMC_SUPPORT
250 	if (!IS_ENABLED(CONFIG_TARGET_ROCK2) &&
251 	    !IS_ENABLED(CONFIG_TARGET_FIREFLY_RK3288)) {
252 		ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_SDCARD);
253 		if (ret) {
254 			debug("%s: Failed to set up SD card\n", __func__);
255 			goto err;
256 		}
257 		ret = configure_emmc(pinctrl);
258 		if (ret) {
259 			debug("%s: Failed to set up eMMC\n", __func__);
260 			goto err;
261 		}
262 	}
263 #endif
264 
265 	/* Enable debug UART */
266 	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_UART_DBG);
267 	if (ret) {
268 		debug("%s: Failed to set up console UART\n", __func__);
269 		goto err;
270 	}
271 
272 	preloader_console_init();
273 	return;
274 err:
275 	printf("spl_board_init: Error %d\n", ret);
276 
277 	/* No way to report error here */
278 	hang();
279 }
280 
281 void lowlevel_init(void)
282 {
283 }
284