1 /*
2  * Copyright 2014-2015 Freescale Semiconductor, Inc.
3  *
4  * SPDX-License-Identifier:	GPL-2.0+
5  */
6 
7 #include <common.h>
8 #include <asm/io.h>
9 #include <linux/errno.h>
10 #include <asm/system.h>
11 #include <asm/armv8/mmu.h>
12 #include <asm/io.h>
13 #include <asm/arch/fsl_serdes.h>
14 #include <asm/arch/soc.h>
15 #include <asm/arch/cpu.h>
16 #include <asm/arch/speed.h>
17 #ifdef CONFIG_MP
18 #include <asm/arch/mp.h>
19 #endif
20 #include <efi_loader.h>
21 #include <fm_eth.h>
22 #include <fsl-mc/fsl_mc.h>
23 #ifdef CONFIG_FSL_ESDHC
24 #include <fsl_esdhc.h>
25 #endif
26 #ifdef CONFIG_ARMV8_SEC_FIRMWARE_SUPPORT
27 #include <asm/armv8/sec_firmware.h>
28 #endif
29 #ifdef CONFIG_SYS_FSL_DDR
30 #include <fsl_ddr.h>
31 #endif
32 
33 DECLARE_GLOBAL_DATA_PTR;
34 
35 struct mm_region *mem_map = early_map;
36 
37 void cpu_name(char *name)
38 {
39 	struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
40 	unsigned int i, svr, ver;
41 
42 	svr = gur_in32(&gur->svr);
43 	ver = SVR_SOC_VER(svr);
44 
45 	for (i = 0; i < ARRAY_SIZE(cpu_type_list); i++)
46 		if ((cpu_type_list[i].soc_ver & SVR_WO_E) == ver) {
47 			strcpy(name, cpu_type_list[i].name);
48 
49 			if (IS_E_PROCESSOR(svr))
50 				strcat(name, "E");
51 
52 			sprintf(name + strlen(name), " Rev%d.%d",
53 				SVR_MAJ(svr), SVR_MIN(svr));
54 			break;
55 		}
56 
57 	if (i == ARRAY_SIZE(cpu_type_list))
58 		strcpy(name, "unknown");
59 }
60 
61 #ifndef CONFIG_SYS_DCACHE_OFF
62 /*
63  * To start MMU before DDR is available, we create MMU table in SRAM.
64  * The base address of SRAM is CONFIG_SYS_FSL_OCRAM_BASE. We use three
65  * levels of translation tables here to cover 40-bit address space.
66  * We use 4KB granule size, with 40 bits physical address, T0SZ=24
67  * Address above EARLY_PGTABLE_SIZE (0x5000) is free for other purpose.
68  * Note, the debug print in cache_v8.c is not usable for debugging
69  * these early MMU tables because UART is not yet available.
70  */
71 static inline void early_mmu_setup(void)
72 {
73 	unsigned int el = current_el();
74 
75 	/* global data is already setup, no allocation yet */
76 	gd->arch.tlb_addr = CONFIG_SYS_FSL_OCRAM_BASE;
77 	gd->arch.tlb_fillptr = gd->arch.tlb_addr;
78 	gd->arch.tlb_size = EARLY_PGTABLE_SIZE;
79 
80 	/* Create early page tables */
81 	setup_pgtables();
82 
83 	/* point TTBR to the new table */
84 	set_ttbr_tcr_mair(el, gd->arch.tlb_addr,
85 			  get_tcr(el, NULL, NULL) &
86 			  ~(TCR_ORGN_MASK | TCR_IRGN_MASK),
87 			  MEMORY_ATTRIBUTES);
88 
89 	set_sctlr(get_sctlr() | CR_M);
90 }
91 
92 /*
93  * The final tables look similar to early tables, but different in detail.
94  * These tables are in DRAM. Sub tables are added to enable cache for
95  * QBMan and OCRAM.
96  *
97  * Put the MMU table in secure memory if gd->arch.secure_ram is valid.
98  * OCRAM will be not used for this purpose so gd->arch.secure_ram can't be 0.
99  */
100 static inline void final_mmu_setup(void)
101 {
102 	u64 tlb_addr_save = gd->arch.tlb_addr;
103 	unsigned int el = current_el();
104 #ifdef CONFIG_SYS_MEM_RESERVE_SECURE
105 	int index;
106 #endif
107 
108 	mem_map = final_map;
109 
110 #ifdef CONFIG_SYS_MEM_RESERVE_SECURE
111 	if (gd->arch.secure_ram & MEM_RESERVE_SECURE_MAINTAINED) {
112 		if (el == 3) {
113 			/*
114 			 * Only use gd->arch.secure_ram if the address is
115 			 * recalculated. Align to 4KB for MMU table.
116 			 */
117 			/* put page tables in secure ram */
118 			index = ARRAY_SIZE(final_map) - 2;
119 			gd->arch.tlb_addr = gd->arch.secure_ram & ~0xfff;
120 			final_map[index].virt = gd->arch.secure_ram & ~0x3;
121 			final_map[index].phys = final_map[index].virt;
122 			final_map[index].size = CONFIG_SYS_MEM_RESERVE_SECURE;
123 			final_map[index].attrs = PTE_BLOCK_OUTER_SHARE;
124 			gd->arch.secure_ram |= MEM_RESERVE_SECURE_SECURED;
125 			tlb_addr_save = gd->arch.tlb_addr;
126 		} else {
127 			/* Use allocated (board_f.c) memory for TLB */
128 			tlb_addr_save = gd->arch.tlb_allocated;
129 			gd->arch.tlb_addr = tlb_addr_save;
130 		}
131 	}
132 #endif
133 
134 	/* Reset the fill ptr */
135 	gd->arch.tlb_fillptr = tlb_addr_save;
136 
137 	/* Create normal system page tables */
138 	setup_pgtables();
139 
140 	/* Create emergency page tables */
141 	gd->arch.tlb_addr = gd->arch.tlb_fillptr;
142 	gd->arch.tlb_emerg = gd->arch.tlb_addr;
143 	setup_pgtables();
144 	gd->arch.tlb_addr = tlb_addr_save;
145 
146 	/* flush new MMU table */
147 	flush_dcache_range(gd->arch.tlb_addr,
148 			   gd->arch.tlb_addr + gd->arch.tlb_size);
149 
150 	/* point TTBR to the new table */
151 	set_ttbr_tcr_mair(el, gd->arch.tlb_addr, get_tcr(el, NULL, NULL),
152 			  MEMORY_ATTRIBUTES);
153 	/*
154 	 * EL3 MMU is already enabled, just need to invalidate TLB to load the
155 	 * new table. The new table is compatible with the current table, if
156 	 * MMU somehow walks through the new table before invalidation TLB,
157 	 * it still works. So we don't need to turn off MMU here.
158 	 * When EL2 MMU table is created by calling this function, MMU needs
159 	 * to be enabled.
160 	 */
161 	set_sctlr(get_sctlr() | CR_M);
162 }
163 
164 u64 get_page_table_size(void)
165 {
166 	return 0x10000;
167 }
168 
169 int arch_cpu_init(void)
170 {
171 	icache_enable();
172 	__asm_invalidate_dcache_all();
173 	__asm_invalidate_tlb_all();
174 	early_mmu_setup();
175 	set_sctlr(get_sctlr() | CR_C);
176 	return 0;
177 }
178 
179 void mmu_setup(void)
180 {
181 	final_mmu_setup();
182 }
183 
184 /*
185  * This function is called from common/board_r.c.
186  * It recreates MMU table in main memory.
187  */
188 void enable_caches(void)
189 {
190 	mmu_setup();
191 	__asm_invalidate_tlb_all();
192 	icache_enable();
193 	dcache_enable();
194 }
195 #endif
196 
197 u32 initiator_type(u32 cluster, int init_id)
198 {
199 	struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
200 	u32 idx = (cluster >> (init_id * 8)) & TP_CLUSTER_INIT_MASK;
201 	u32 type = 0;
202 
203 	type = gur_in32(&gur->tp_ityp[idx]);
204 	if (type & TP_ITYP_AV)
205 		return type;
206 
207 	return 0;
208 }
209 
210 u32 cpu_pos_mask(void)
211 {
212 	struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
213 	int i = 0;
214 	u32 cluster, type, mask = 0;
215 
216 	do {
217 		int j;
218 
219 		cluster = gur_in32(&gur->tp_cluster[i].lower);
220 		for (j = 0; j < TP_INIT_PER_CLUSTER; j++) {
221 			type = initiator_type(cluster, j);
222 			if (type && (TP_ITYP_TYPE(type) == TP_ITYP_TYPE_ARM))
223 				mask |= 1 << (i * TP_INIT_PER_CLUSTER + j);
224 		}
225 		i++;
226 	} while ((cluster & TP_CLUSTER_EOC) == 0x0);
227 
228 	return mask;
229 }
230 
231 u32 cpu_mask(void)
232 {
233 	struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
234 	int i = 0, count = 0;
235 	u32 cluster, type, mask = 0;
236 
237 	do {
238 		int j;
239 
240 		cluster = gur_in32(&gur->tp_cluster[i].lower);
241 		for (j = 0; j < TP_INIT_PER_CLUSTER; j++) {
242 			type = initiator_type(cluster, j);
243 			if (type) {
244 				if (TP_ITYP_TYPE(type) == TP_ITYP_TYPE_ARM)
245 					mask |= 1 << count;
246 				count++;
247 			}
248 		}
249 		i++;
250 	} while ((cluster & TP_CLUSTER_EOC) == 0x0);
251 
252 	return mask;
253 }
254 
255 /*
256  * Return the number of cores on this SOC.
257  */
258 int cpu_numcores(void)
259 {
260 	return hweight32(cpu_mask());
261 }
262 
263 int fsl_qoriq_core_to_cluster(unsigned int core)
264 {
265 	struct ccsr_gur __iomem *gur =
266 		(void __iomem *)(CONFIG_SYS_FSL_GUTS_ADDR);
267 	int i = 0, count = 0;
268 	u32 cluster;
269 
270 	do {
271 		int j;
272 
273 		cluster = gur_in32(&gur->tp_cluster[i].lower);
274 		for (j = 0; j < TP_INIT_PER_CLUSTER; j++) {
275 			if (initiator_type(cluster, j)) {
276 				if (count == core)
277 					return i;
278 				count++;
279 			}
280 		}
281 		i++;
282 	} while ((cluster & TP_CLUSTER_EOC) == 0x0);
283 
284 	return -1;      /* cannot identify the cluster */
285 }
286 
287 u32 fsl_qoriq_core_to_type(unsigned int core)
288 {
289 	struct ccsr_gur __iomem *gur =
290 		(void __iomem *)(CONFIG_SYS_FSL_GUTS_ADDR);
291 	int i = 0, count = 0;
292 	u32 cluster, type;
293 
294 	do {
295 		int j;
296 
297 		cluster = gur_in32(&gur->tp_cluster[i].lower);
298 		for (j = 0; j < TP_INIT_PER_CLUSTER; j++) {
299 			type = initiator_type(cluster, j);
300 			if (type) {
301 				if (count == core)
302 					return type;
303 				count++;
304 			}
305 		}
306 		i++;
307 	} while ((cluster & TP_CLUSTER_EOC) == 0x0);
308 
309 	return -1;      /* cannot identify the cluster */
310 }
311 
312 #ifndef CONFIG_FSL_LSCH3
313 uint get_svr(void)
314 {
315 	struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
316 
317 	return gur_in32(&gur->svr);
318 }
319 #endif
320 
321 #ifdef CONFIG_DISPLAY_CPUINFO
322 int print_cpuinfo(void)
323 {
324 	struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
325 	struct sys_info sysinfo;
326 	char buf[32];
327 	unsigned int i, core;
328 	u32 type, rcw, svr = gur_in32(&gur->svr);
329 
330 	puts("SoC: ");
331 
332 	cpu_name(buf);
333 	printf(" %s (0x%x)\n", buf, svr);
334 	memset((u8 *)buf, 0x00, ARRAY_SIZE(buf));
335 	get_sys_info(&sysinfo);
336 	puts("Clock Configuration:");
337 	for_each_cpu(i, core, cpu_numcores(), cpu_mask()) {
338 		if (!(i % 3))
339 			puts("\n       ");
340 		type = TP_ITYP_VER(fsl_qoriq_core_to_type(core));
341 		printf("CPU%d(%s):%-4s MHz  ", core,
342 		       type == TY_ITYP_VER_A7 ? "A7 " :
343 		       (type == TY_ITYP_VER_A53 ? "A53" :
344 		       (type == TY_ITYP_VER_A57 ? "A57" :
345 		       (type == TY_ITYP_VER_A72 ? "A72" : "   "))),
346 		       strmhz(buf, sysinfo.freq_processor[core]));
347 	}
348 	/* Display platform clock as Bus frequency. */
349 	printf("\n       Bus:      %-4s MHz  ",
350 	       strmhz(buf, sysinfo.freq_systembus / CONFIG_SYS_FSL_PCLK_DIV));
351 	printf("DDR:      %-4s MT/s", strmhz(buf, sysinfo.freq_ddrbus));
352 #ifdef CONFIG_SYS_DPAA_FMAN
353 	printf("  FMAN:     %-4s MHz", strmhz(buf, sysinfo.freq_fman[0]));
354 #endif
355 #ifdef CONFIG_SYS_FSL_HAS_DP_DDR
356 	if (soc_has_dp_ddr()) {
357 		printf("     DP-DDR:   %-4s MT/s",
358 		       strmhz(buf, sysinfo.freq_ddrbus2));
359 	}
360 #endif
361 	puts("\n");
362 
363 	/*
364 	 * Display the RCW, so that no one gets confused as to what RCW
365 	 * we're actually using for this boot.
366 	 */
367 	puts("Reset Configuration Word (RCW):");
368 	for (i = 0; i < ARRAY_SIZE(gur->rcwsr); i++) {
369 		rcw = gur_in32(&gur->rcwsr[i]);
370 		if ((i % 4) == 0)
371 			printf("\n       %08x:", i * 4);
372 		printf(" %08x", rcw);
373 	}
374 	puts("\n");
375 
376 	return 0;
377 }
378 #endif
379 
380 #ifdef CONFIG_FSL_ESDHC
381 int cpu_mmc_init(bd_t *bis)
382 {
383 	return fsl_esdhc_mmc_init(bis);
384 }
385 #endif
386 
387 int cpu_eth_init(bd_t *bis)
388 {
389 	int error = 0;
390 
391 #ifdef CONFIG_FSL_MC_ENET
392 	error = fsl_mc_ldpaa_init(bis);
393 #endif
394 #ifdef CONFIG_FMAN_ENET
395 	fm_standard_init(bis);
396 #endif
397 	return error;
398 }
399 
400 int arch_early_init_r(void)
401 {
402 #ifdef CONFIG_MP
403 	int rv = 1;
404 	u32 psci_ver = 0xffffffff;
405 #endif
406 
407 #ifdef CONFIG_SYS_FSL_ERRATUM_A009635
408 	erratum_a009635();
409 #endif
410 #if defined(CONFIG_SYS_FSL_ERRATUM_A009942) && defined(CONFIG_SYS_FSL_DDR)
411 	erratum_a009942_check_cpo();
412 #endif
413 #ifdef CONFIG_MP
414 #if defined(CONFIG_ARMV8_SEC_FIRMWARE_SUPPORT) && \
415 	defined(CONFIG_SEC_FIRMWARE_ARMV8_PSCI)
416 	/* Check the psci version to determine if the psci is supported */
417 	psci_ver = sec_firmware_support_psci_version();
418 #endif
419 	if (psci_ver == 0xffffffff) {
420 		rv = fsl_layerscape_wake_seconday_cores();
421 		if (rv)
422 			printf("Did not wake secondary cores\n");
423 	}
424 #endif
425 
426 #ifdef CONFIG_SYS_HAS_SERDES
427 	fsl_serdes_init();
428 #endif
429 #ifdef CONFIG_FMAN_ENET
430 	fman_enet_init();
431 #endif
432 	return 0;
433 }
434 
435 int timer_init(void)
436 {
437 	u32 __iomem *cntcr = (u32 *)CONFIG_SYS_FSL_TIMER_ADDR;
438 #ifdef CONFIG_FSL_LSCH3
439 	u32 __iomem *cltbenr = (u32 *)CONFIG_SYS_FSL_PMU_CLTBENR;
440 #endif
441 #ifdef CONFIG_LS2080A
442 	u32 __iomem *pctbenr = (u32 *)FSL_PMU_PCTBENR_OFFSET;
443 	u32 svr_dev_id;
444 #endif
445 #ifdef COUNTER_FREQUENCY_REAL
446 	unsigned long cntfrq = COUNTER_FREQUENCY_REAL;
447 
448 	/* Update with accurate clock frequency */
449 	asm volatile("msr cntfrq_el0, %0" : : "r" (cntfrq) : "memory");
450 #endif
451 
452 #ifdef CONFIG_FSL_LSCH3
453 	/* Enable timebase for all clusters.
454 	 * It is safe to do so even some clusters are not enabled.
455 	 */
456 	out_le32(cltbenr, 0xf);
457 #endif
458 
459 #ifdef CONFIG_LS2080A
460 	/*
461 	 * In certain Layerscape SoCs, the clock for each core's
462 	 * has an enable bit in the PMU Physical Core Time Base Enable
463 	 * Register (PCTBENR), which allows the watchdog to operate.
464 	 */
465 	setbits_le32(pctbenr, 0xff);
466 	/*
467 	 * For LS2080A SoC and its personalities, timer controller
468 	 * offset is different
469 	 */
470 	svr_dev_id = get_svr() >> 16;
471 	if (svr_dev_id == SVR_DEV_LS2080A)
472 		cntcr = (u32 *)SYS_FSL_LS2080A_LS2085A_TIMER_ADDR;
473 
474 #endif
475 
476 	/* Enable clock for timer
477 	 * This is a global setting.
478 	 */
479 	out_le32(cntcr, 0x1);
480 
481 	return 0;
482 }
483 
484 __efi_runtime_data u32 __iomem *rstcr = (u32 *)CONFIG_SYS_FSL_RST_ADDR;
485 
486 void __efi_runtime reset_cpu(ulong addr)
487 {
488 	u32 val;
489 
490 	/* Raise RESET_REQ_B */
491 	val = scfg_in32(rstcr);
492 	val |= 0x02;
493 	scfg_out32(rstcr, val);
494 }
495 
496 #ifdef CONFIG_EFI_LOADER
497 
498 void __efi_runtime EFIAPI efi_reset_system(
499 		       enum efi_reset_type reset_type,
500 		       efi_status_t reset_status,
501 		       unsigned long data_size, void *reset_data)
502 {
503 	switch (reset_type) {
504 	case EFI_RESET_COLD:
505 	case EFI_RESET_WARM:
506 		reset_cpu(0);
507 		break;
508 	case EFI_RESET_SHUTDOWN:
509 		/* Nothing we can do */
510 		break;
511 	}
512 
513 	while (1) { }
514 }
515 
516 void efi_reset_system_init(void)
517 {
518        efi_add_runtime_mmio(&rstcr, sizeof(*rstcr));
519 }
520 
521 #endif
522 
523 phys_size_t board_reserve_ram_top(phys_size_t ram_size)
524 {
525 	phys_size_t ram_top = ram_size;
526 
527 #ifdef CONFIG_SYS_MEM_TOP_HIDE
528 #error CONFIG_SYS_MEM_TOP_HIDE not to be used together with this function
529 #endif
530 
531 /* Carve the MC private DRAM block from the end of DRAM */
532 #ifdef CONFIG_FSL_MC_ENET
533 	ram_top -= mc_get_dram_block_size();
534 	ram_top &= ~(CONFIG_SYS_MC_RSV_MEM_ALIGN - 1);
535 #endif
536 
537 	return ram_top;
538 }
539