1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * K3: Common Architecture initialization
4 *
5 * Copyright (C) 2018 Texas Instruments Incorporated - https://www.ti.com/
6 *	Lokesh Vutla <lokeshvutla@ti.com>
7 */
8
9#include <config.h>
10#include <cpu_func.h>
11#include <image.h>
12#include <init.h>
13#include <log.h>
14#include <spl.h>
15#include <asm/global_data.h>
16#include <linux/printk.h>
17#include "common.h"
18#include <dm.h>
19#include <remoteproc.h>
20#include <asm/cache.h>
21#include <linux/soc/ti/ti_sci_protocol.h>
22#include <fdt_support.h>
23#include <asm/hardware.h>
24#include <asm/io.h>
25#include <fs_loader.h>
26#include <fs.h>
27#include <efi_loader.h>
28#include <env.h>
29#include <elf.h>
30#include <soc.h>
31
32#include <asm/arch/k3-qos.h>
33
34struct ti_sci_handle *get_ti_sci_handle(void)
35{
36	struct udevice *dev;
37	int ret;
38
39	ret = uclass_get_device_by_driver(UCLASS_FIRMWARE,
40					  DM_DRIVER_GET(ti_sci), &dev);
41	if (ret)
42		panic("Failed to get SYSFW (%d)\n", ret);
43
44	return (struct ti_sci_handle *)ti_sci_get_handle_from_sysfw(dev);
45}
46
47void k3_sysfw_print_ver(void)
48{
49	struct ti_sci_handle *ti_sci = get_ti_sci_handle();
50	char fw_desc[sizeof(ti_sci->version.firmware_description) + 1];
51
52	/*
53	 * Output System Firmware version info. Note that since the
54	 * 'firmware_description' field is not guaranteed to be zero-
55	 * terminated we manually add a \0 terminator if needed. Further
56	 * note that we intentionally no longer rely on the extended
57	 * printf() formatter '%.*s' to not having to require a more
58	 * full-featured printf() implementation.
59	 */
60	strncpy(fw_desc, ti_sci->version.firmware_description,
61		sizeof(ti_sci->version.firmware_description));
62	fw_desc[sizeof(fw_desc) - 1] = '\0';
63
64	printf("SYSFW ABI: %d.%d (firmware rev 0x%04x '%s')\n",
65	       ti_sci->version.abi_major, ti_sci->version.abi_minor,
66	       ti_sci->version.firmware_revision, fw_desc);
67}
68
69void mmr_unlock(uintptr_t base, u32 partition)
70{
71	/* Translate the base address */
72	uintptr_t part_base = base + partition * CTRL_MMR0_PARTITION_SIZE;
73
74	/* Unlock the requested partition if locked using two-step sequence */
75	writel(CTRLMMR_LOCK_KICK0_UNLOCK_VAL, part_base + CTRLMMR_LOCK_KICK0);
76	writel(CTRLMMR_LOCK_KICK1_UNLOCK_VAL, part_base + CTRLMMR_LOCK_KICK1);
77}
78
79bool is_rom_loaded_sysfw(struct rom_extended_boot_data *data)
80{
81	if (strncmp(data->header, K3_ROM_BOOT_HEADER_MAGIC, 7))
82		return false;
83
84	return data->num_components > 1;
85}
86
87DECLARE_GLOBAL_DATA_PTR;
88
89#ifdef CONFIG_K3_EARLY_CONS
90int early_console_init(void)
91{
92	struct udevice *dev;
93	int ret;
94
95	gd->baudrate = CONFIG_BAUDRATE;
96
97	ret = uclass_get_device_by_seq(UCLASS_SERIAL, CONFIG_K3_EARLY_CONS_IDX,
98				       &dev);
99	if (ret) {
100		printf("Error getting serial dev for early console! (%d)\n",
101		       ret);
102		return ret;
103	}
104
105	gd->cur_serial_dev = dev;
106	gd->flags |= GD_FLG_SERIAL_READY;
107	gd->have_console = 1;
108
109	return 0;
110}
111#endif
112
113#if CONFIG_IS_ENABLED(FIT_IMAGE_POST_PROCESS) && !IS_ENABLED(CONFIG_SYS_K3_SPL_ATF)
114void board_fit_image_post_process(const void *fit, int node, void **p_image,
115				  size_t *p_size)
116{
117	ti_secure_image_check_binary(p_image, p_size);
118	ti_secure_image_post_process(p_image, p_size);
119}
120#endif
121
122#ifndef CONFIG_SYSRESET
123void reset_cpu(void)
124{
125}
126#endif
127
128enum k3_device_type get_device_type(void)
129{
130	u32 sys_status = readl(K3_SEC_MGR_SYS_STATUS);
131
132	u32 sys_dev_type = (sys_status & SYS_STATUS_DEV_TYPE_MASK) >>
133			SYS_STATUS_DEV_TYPE_SHIFT;
134
135	u32 sys_sub_type = (sys_status & SYS_STATUS_SUB_TYPE_MASK) >>
136			SYS_STATUS_SUB_TYPE_SHIFT;
137
138	switch (sys_dev_type) {
139	case SYS_STATUS_DEV_TYPE_GP:
140		return K3_DEVICE_TYPE_GP;
141	case SYS_STATUS_DEV_TYPE_TEST:
142		return K3_DEVICE_TYPE_TEST;
143	case SYS_STATUS_DEV_TYPE_EMU:
144		return K3_DEVICE_TYPE_EMU;
145	case SYS_STATUS_DEV_TYPE_HS:
146		if (sys_sub_type == SYS_STATUS_SUB_TYPE_VAL_FS)
147			return K3_DEVICE_TYPE_HS_FS;
148		else
149			return K3_DEVICE_TYPE_HS_SE;
150	default:
151		return K3_DEVICE_TYPE_BAD;
152	}
153}
154
155#if defined(CONFIG_DISPLAY_CPUINFO)
156static const char *get_device_type_name(void)
157{
158	enum k3_device_type type = get_device_type();
159
160	switch (type) {
161	case K3_DEVICE_TYPE_GP:
162		return "GP";
163	case K3_DEVICE_TYPE_TEST:
164		return "TEST";
165	case K3_DEVICE_TYPE_EMU:
166		return "EMU";
167	case K3_DEVICE_TYPE_HS_FS:
168		return "HS-FS";
169	case K3_DEVICE_TYPE_HS_SE:
170		return "HS-SE";
171	default:
172		return "BAD";
173	}
174}
175
176int print_cpuinfo(void)
177{
178	struct udevice *soc;
179	char name[64];
180	int ret;
181
182	printf("SoC:   ");
183
184	ret = soc_get(&soc);
185	if (ret) {
186		printf("UNKNOWN\n");
187		return 0;
188	}
189
190	ret = soc_get_family(soc, name, 64);
191	if (!ret) {
192		printf("%s ", name);
193	}
194
195	ret = soc_get_revision(soc, name, 64);
196	if (!ret) {
197		printf("%s ", name);
198	}
199
200	printf("%s\n", get_device_type_name());
201
202	return 0;
203}
204#endif
205
206#ifdef CONFIG_ARM64
207void board_prep_linux(struct bootm_headers *images)
208{
209	debug("Linux kernel Image start = 0x%lx end = 0x%lx\n",
210	      images->os.start, images->os.end);
211	__asm_flush_dcache_range(images->os.start,
212				 ROUND(images->os.end,
213				       CONFIG_SYS_CACHELINE_SIZE));
214}
215#endif
216
217void spl_enable_cache(void)
218{
219#if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF))
220	gd->ram_top = CFG_SYS_SDRAM_BASE;
221	int ret = 0;
222
223	dram_init();
224
225	/* reserve TLB table */
226	gd->arch.tlb_size = PGTABLE_SIZE;
227
228	gd->ram_top += get_effective_memsize();
229	/* keep ram_top in the 32-bit address space */
230	if (gd->ram_top >= 0x100000000)
231		gd->ram_top = (phys_addr_t)0x100000000;
232
233	gd->relocaddr = gd->ram_top;
234
235	ret = spl_reserve_video_from_ram_top();
236	if (ret)
237		panic("Failed to reserve framebuffer memory (%d)\n", ret);
238
239	gd->arch.tlb_addr = gd->relocaddr - gd->arch.tlb_size;
240	gd->arch.tlb_addr &= ~(0x10000 - 1);
241	debug("TLB table from %08lx to %08lx\n", gd->arch.tlb_addr,
242	      gd->arch.tlb_addr + gd->arch.tlb_size);
243	gd->relocaddr = gd->arch.tlb_addr;
244
245	enable_caches();
246#endif
247}
248
249#if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF))
250void spl_board_prepare_for_boot(void)
251{
252	dcache_disable();
253}
254
255void spl_board_prepare_for_linux(void)
256{
257	dcache_disable();
258}
259#endif
260
261int misc_init_r(void)
262{
263	if (IS_ENABLED(CONFIG_TI_AM65_CPSW_NUSS)) {
264		struct udevice *dev;
265		int ret;
266
267		ret = uclass_get_device_by_driver(UCLASS_MISC,
268						  DM_DRIVER_GET(am65_cpsw_nuss),
269						  &dev);
270		if (ret)
271			printf("Failed to probe am65_cpsw_nuss driver\n");
272	}
273
274	if (IS_ENABLED(CONFIG_TI_ICSSG_PRUETH)) {
275		struct udevice *dev;
276		int ret;
277
278		ret = uclass_get_device_by_driver(UCLASS_MISC,
279						  DM_DRIVER_GET(prueth),
280						  &dev);
281		if (ret)
282			printf("Failed to probe prueth driver\n");
283	}
284
285	/* Default FIT boot on HS-SE devices */
286	if (get_device_type() == K3_DEVICE_TYPE_HS_SE)
287		env_set("boot_fit", "1");
288
289	return 0;
290}
291
292/**
293 * do_board_detect() - Detect board description
294 *
295 * Function to detect board description. This is expected to be
296 * overridden in the SoC family board file where desired.
297 */
298void __weak do_board_detect(void)
299{
300}
301
302#if (IS_ENABLED(CONFIG_K3_QOS))
303void setup_qos(void)
304{
305	u32 i;
306
307	for (i = 0; i < qos_count; i++)
308		writel(qos_data[i].val, (uintptr_t)qos_data[i].reg);
309}
310#endif
311
312void efi_add_known_memory(void)
313{
314	if (IS_ENABLED(CONFIG_EFI_LOADER))
315		/*
316		 * Memory over ram_top can be used by various firmware
317		 * Declare to EFI only memory area below ram_top
318		 */
319		efi_add_memory_map(gd->ram_base, gd->ram_top - gd->ram_base,
320				   EFI_CONVENTIONAL_MEMORY);
321}
322