Loading...
1// SPDX-License-Identifier: GPL-2.0
2//
3// Samsung Exynos Flattened Device Tree enabled machine
4//
5// Copyright (c) 2010-2014 Samsung Electronics Co., Ltd.
6// http://www.samsung.com
7
8#include <linux/init.h>
9#include <linux/io.h>
10#include <linux/of.h>
11#include <linux/of_address.h>
12#include <linux/of_fdt.h>
13#include <linux/platform_device.h>
14#include <linux/irqchip.h>
15#include <linux/soc/samsung/exynos-regs-pmu.h>
16
17#include <asm/cacheflush.h>
18#include <asm/hardware/cache-l2x0.h>
19#include <asm/mach/arch.h>
20#include <asm/mach/map.h>
21
22#include "common.h"
23
24#define S3C_ADDR_BASE 0xF6000000
25#define S3C_ADDR(x) ((void __iomem __force *)S3C_ADDR_BASE + (x))
26#define S5P_VA_CHIPID S3C_ADDR(0x02000000)
27
28static struct platform_device exynos_cpuidle = {
29 .name = "exynos_cpuidle",
30#ifdef CONFIG_ARM_EXYNOS_CPUIDLE
31 .dev.platform_data = exynos_enter_aftr,
32#endif
33 .id = -1,
34};
35
36void __iomem *sysram_base_addr __ro_after_init;
37phys_addr_t sysram_base_phys __ro_after_init;
38void __iomem *sysram_ns_base_addr __ro_after_init;
39
40unsigned long exynos_cpu_id;
41static unsigned int exynos_cpu_rev;
42
43unsigned int exynos_rev(void)
44{
45 return exynos_cpu_rev;
46}
47
48void __init exynos_sysram_init(void)
49{
50 struct device_node *node;
51
52 for_each_compatible_node(node, NULL, "samsung,exynos4210-sysram") {
53 struct resource res;
54 if (!of_device_is_available(node))
55 continue;
56
57 of_address_to_resource(node, 0, &res);
58 sysram_base_addr = ioremap(res.start, resource_size(&res));
59 sysram_base_phys = res.start;
60 of_node_put(node);
61 break;
62 }
63
64 for_each_compatible_node(node, NULL, "samsung,exynos4210-sysram-ns") {
65 if (!of_device_is_available(node))
66 continue;
67 sysram_ns_base_addr = of_iomap(node, 0);
68 of_node_put(node);
69 break;
70 }
71}
72
73static int __init exynos_fdt_map_chipid(unsigned long node, const char *uname,
74 int depth, void *data)
75{
76 struct map_desc iodesc;
77 const __be32 *reg;
78 int len;
79
80 if (!of_flat_dt_is_compatible(node, "samsung,exynos4210-chipid"))
81 return 0;
82
83 reg = of_get_flat_dt_prop(node, "reg", &len);
84 if (reg == NULL || len != (sizeof(unsigned long) * 2))
85 return 0;
86
87 iodesc.pfn = __phys_to_pfn(be32_to_cpu(reg[0]));
88 iodesc.length = be32_to_cpu(reg[1]) - 1;
89 iodesc.virtual = (unsigned long)S5P_VA_CHIPID;
90 iodesc.type = MT_DEVICE;
91 iotable_init(&iodesc, 1);
92 return 1;
93}
94
95static void __init exynos_init_io(void)
96{
97 debug_ll_io_init();
98
99 of_scan_flat_dt(exynos_fdt_map_chipid, NULL);
100
101 /* detect cpu id and rev. */
102 exynos_cpu_id = readl_relaxed(S5P_VA_CHIPID);
103 exynos_cpu_rev = exynos_cpu_id & 0xFF;
104
105 pr_info("Samsung CPU ID: 0x%08lx\n", exynos_cpu_id);
106
107}
108
109/*
110 * Set or clear the USE_DELAYED_RESET_ASSERTION option. Used by smp code
111 * and suspend.
112 *
113 * This is necessary only on Exynos4 SoCs. When system is running
114 * USE_DELAYED_RESET_ASSERTION should be set so the ARM CLK clock down
115 * feature could properly detect global idle state when secondary CPU is
116 * powered down.
117 *
118 * However this should not be set when such system is going into suspend.
119 */
120void exynos_set_delayed_reset_assertion(bool enable)
121{
122 if (of_machine_is_compatible("samsung,exynos4")) {
123 unsigned int tmp, core_id;
124
125 for (core_id = 0; core_id < num_possible_cpus(); core_id++) {
126 tmp = pmu_raw_readl(EXYNOS_ARM_CORE_OPTION(core_id));
127 if (enable)
128 tmp |= S5P_USE_DELAYED_RESET_ASSERTION;
129 else
130 tmp &= ~(S5P_USE_DELAYED_RESET_ASSERTION);
131 pmu_raw_writel(tmp, EXYNOS_ARM_CORE_OPTION(core_id));
132 }
133 }
134}
135
136/*
137 * Apparently, these SoCs are not able to wake-up from suspend using
138 * the PMU. Too bad. Should they suddenly become capable of such a
139 * feat, the matches below should be moved to suspend.c.
140 */
141static const struct of_device_id exynos_dt_pmu_match[] = {
142 { .compatible = "samsung,exynos5260-pmu" },
143 { .compatible = "samsung,exynos5410-pmu" },
144 { /*sentinel*/ },
145};
146
147static void exynos_map_pmu(void)
148{
149 struct device_node *np;
150
151 np = of_find_matching_node(NULL, exynos_dt_pmu_match);
152 if (np)
153 pmu_base_addr = of_iomap(np, 0);
154 of_node_put(np);
155}
156
157static void __init exynos_init_irq(void)
158{
159 irqchip_init();
160 /*
161 * Since platsmp.c needs pmu base address by the time
162 * DT is not unflatten so we can't use DT APIs before
163 * init_irq
164 */
165 exynos_map_pmu();
166}
167
168static void __init exynos_dt_machine_init(void)
169{
170 /*
171 * This is called from smp_prepare_cpus if we've built for SMP, but
172 * we still need to set it up for PM and firmware ops if not.
173 */
174 if (!IS_ENABLED(CONFIG_SMP))
175 exynos_sysram_init();
176
177#if defined(CONFIG_SMP) && defined(CONFIG_ARM_EXYNOS_CPUIDLE)
178 if (of_machine_is_compatible("samsung,exynos4210") ||
179 of_machine_is_compatible("samsung,exynos3250"))
180 exynos_cpuidle.dev.platform_data = &cpuidle_coupled_exynos_data;
181#endif
182 if (of_machine_is_compatible("samsung,exynos4210") ||
183 of_machine_is_compatible("samsung,exynos4212") ||
184 (of_machine_is_compatible("samsung,exynos4412") &&
185 (of_machine_is_compatible("samsung,trats2") ||
186 of_machine_is_compatible("samsung,midas") ||
187 of_machine_is_compatible("samsung,p4note"))) ||
188 of_machine_is_compatible("samsung,exynos3250") ||
189 of_machine_is_compatible("samsung,exynos5250"))
190 platform_device_register(&exynos_cpuidle);
191}
192
193static char const *const exynos_dt_compat[] __initconst = {
194 "samsung,exynos3",
195 "samsung,exynos3250",
196 "samsung,exynos4",
197 "samsung,exynos4210",
198 "samsung,exynos4212",
199 "samsung,exynos4412",
200 "samsung,exynos5",
201 "samsung,exynos5250",
202 "samsung,exynos5260",
203 "samsung,exynos5420",
204 NULL
205};
206
207static void __init exynos_dt_fixup(void)
208{
209 /*
210 * Some versions of uboot pass garbage entries in the memory node,
211 * use the old CONFIG_ARM_NR_BANKS
212 */
213 of_fdt_limit_memory(8);
214}
215
216DT_MACHINE_START(EXYNOS_DT, "Samsung Exynos (Flattened Device Tree)")
217 .l2c_aux_val = 0x08400000,
218 .l2c_aux_mask = 0xf60fffff,
219 .smp = smp_ops(exynos_smp_ops),
220 .map_io = exynos_init_io,
221 .init_early = exynos_firmware_init,
222 .init_irq = exynos_init_irq,
223 .init_machine = exynos_dt_machine_init,
224 .init_late = exynos_pm_init,
225 .dt_compat = exynos_dt_compat,
226 .dt_fixup = exynos_dt_fixup,
227MACHINE_END
1/*
2 * SAMSUNG EXYNOS Flattened Device Tree enabled machine
3 *
4 * Copyright (c) 2010-2014 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/init.h>
13#include <linux/io.h>
14#include <linux/kernel.h>
15#include <linux/serial_s3c.h>
16#include <linux/of.h>
17#include <linux/of_address.h>
18#include <linux/of_fdt.h>
19#include <linux/of_platform.h>
20#include <linux/platform_device.h>
21#include <linux/pm_domain.h>
22
23#include <asm/cacheflush.h>
24#include <asm/hardware/cache-l2x0.h>
25#include <asm/mach/arch.h>
26#include <asm/mach/map.h>
27#include <asm/memory.h>
28
29#include <plat/cpu.h>
30
31#include "common.h"
32#include "mfc.h"
33#include "regs-pmu.h"
34
35#define L2_AUX_VAL 0x7C470001
36#define L2_AUX_MASK 0xC200ffff
37
38static struct map_desc exynos4_iodesc[] __initdata = {
39 {
40 .virtual = (unsigned long)S3C_VA_SYS,
41 .pfn = __phys_to_pfn(EXYNOS4_PA_SYSCON),
42 .length = SZ_64K,
43 .type = MT_DEVICE,
44 }, {
45 .virtual = (unsigned long)S3C_VA_TIMER,
46 .pfn = __phys_to_pfn(EXYNOS4_PA_TIMER),
47 .length = SZ_16K,
48 .type = MT_DEVICE,
49 }, {
50 .virtual = (unsigned long)S3C_VA_WATCHDOG,
51 .pfn = __phys_to_pfn(EXYNOS4_PA_WATCHDOG),
52 .length = SZ_4K,
53 .type = MT_DEVICE,
54 }, {
55 .virtual = (unsigned long)S5P_VA_SROMC,
56 .pfn = __phys_to_pfn(EXYNOS4_PA_SROMC),
57 .length = SZ_4K,
58 .type = MT_DEVICE,
59 }, {
60 .virtual = (unsigned long)S5P_VA_SYSTIMER,
61 .pfn = __phys_to_pfn(EXYNOS4_PA_SYSTIMER),
62 .length = SZ_4K,
63 .type = MT_DEVICE,
64 }, {
65 .virtual = (unsigned long)S5P_VA_PMU,
66 .pfn = __phys_to_pfn(EXYNOS4_PA_PMU),
67 .length = SZ_64K,
68 .type = MT_DEVICE,
69 }, {
70 .virtual = (unsigned long)S5P_VA_COMBINER_BASE,
71 .pfn = __phys_to_pfn(EXYNOS4_PA_COMBINER),
72 .length = SZ_4K,
73 .type = MT_DEVICE,
74 }, {
75 .virtual = (unsigned long)S5P_VA_GIC_CPU,
76 .pfn = __phys_to_pfn(EXYNOS4_PA_GIC_CPU),
77 .length = SZ_64K,
78 .type = MT_DEVICE,
79 }, {
80 .virtual = (unsigned long)S5P_VA_GIC_DIST,
81 .pfn = __phys_to_pfn(EXYNOS4_PA_GIC_DIST),
82 .length = SZ_64K,
83 .type = MT_DEVICE,
84 }, {
85 .virtual = (unsigned long)S5P_VA_CMU,
86 .pfn = __phys_to_pfn(EXYNOS4_PA_CMU),
87 .length = SZ_128K,
88 .type = MT_DEVICE,
89 }, {
90 .virtual = (unsigned long)S5P_VA_COREPERI_BASE,
91 .pfn = __phys_to_pfn(EXYNOS4_PA_COREPERI),
92 .length = SZ_8K,
93 .type = MT_DEVICE,
94 }, {
95 .virtual = (unsigned long)S5P_VA_L2CC,
96 .pfn = __phys_to_pfn(EXYNOS4_PA_L2CC),
97 .length = SZ_4K,
98 .type = MT_DEVICE,
99 }, {
100 .virtual = (unsigned long)S5P_VA_DMC0,
101 .pfn = __phys_to_pfn(EXYNOS4_PA_DMC0),
102 .length = SZ_64K,
103 .type = MT_DEVICE,
104 }, {
105 .virtual = (unsigned long)S5P_VA_DMC1,
106 .pfn = __phys_to_pfn(EXYNOS4_PA_DMC1),
107 .length = SZ_64K,
108 .type = MT_DEVICE,
109 }, {
110 .virtual = (unsigned long)S3C_VA_USB_HSPHY,
111 .pfn = __phys_to_pfn(EXYNOS4_PA_HSPHY),
112 .length = SZ_4K,
113 .type = MT_DEVICE,
114 },
115};
116
117static struct map_desc exynos4_iodesc0[] __initdata = {
118 {
119 .virtual = (unsigned long)S5P_VA_SYSRAM,
120 .pfn = __phys_to_pfn(EXYNOS4_PA_SYSRAM0),
121 .length = SZ_4K,
122 .type = MT_DEVICE,
123 },
124};
125
126static struct map_desc exynos4_iodesc1[] __initdata = {
127 {
128 .virtual = (unsigned long)S5P_VA_SYSRAM,
129 .pfn = __phys_to_pfn(EXYNOS4_PA_SYSRAM1),
130 .length = SZ_4K,
131 .type = MT_DEVICE,
132 },
133};
134
135static struct map_desc exynos4210_iodesc[] __initdata = {
136 {
137 .virtual = (unsigned long)S5P_VA_SYSRAM_NS,
138 .pfn = __phys_to_pfn(EXYNOS4210_PA_SYSRAM_NS),
139 .length = SZ_4K,
140 .type = MT_DEVICE,
141 },
142};
143
144static struct map_desc exynos4x12_iodesc[] __initdata = {
145 {
146 .virtual = (unsigned long)S5P_VA_SYSRAM_NS,
147 .pfn = __phys_to_pfn(EXYNOS4x12_PA_SYSRAM_NS),
148 .length = SZ_4K,
149 .type = MT_DEVICE,
150 },
151};
152
153static struct map_desc exynos5250_iodesc[] __initdata = {
154 {
155 .virtual = (unsigned long)S5P_VA_SYSRAM_NS,
156 .pfn = __phys_to_pfn(EXYNOS5250_PA_SYSRAM_NS),
157 .length = SZ_4K,
158 .type = MT_DEVICE,
159 },
160};
161
162static struct map_desc exynos5_iodesc[] __initdata = {
163 {
164 .virtual = (unsigned long)S3C_VA_SYS,
165 .pfn = __phys_to_pfn(EXYNOS5_PA_SYSCON),
166 .length = SZ_64K,
167 .type = MT_DEVICE,
168 }, {
169 .virtual = (unsigned long)S3C_VA_TIMER,
170 .pfn = __phys_to_pfn(EXYNOS5_PA_TIMER),
171 .length = SZ_16K,
172 .type = MT_DEVICE,
173 }, {
174 .virtual = (unsigned long)S3C_VA_WATCHDOG,
175 .pfn = __phys_to_pfn(EXYNOS5_PA_WATCHDOG),
176 .length = SZ_4K,
177 .type = MT_DEVICE,
178 }, {
179 .virtual = (unsigned long)S5P_VA_SROMC,
180 .pfn = __phys_to_pfn(EXYNOS5_PA_SROMC),
181 .length = SZ_4K,
182 .type = MT_DEVICE,
183 }, {
184 .virtual = (unsigned long)S5P_VA_SYSRAM,
185 .pfn = __phys_to_pfn(EXYNOS5_PA_SYSRAM),
186 .length = SZ_4K,
187 .type = MT_DEVICE,
188 }, {
189 .virtual = (unsigned long)S5P_VA_CMU,
190 .pfn = __phys_to_pfn(EXYNOS5_PA_CMU),
191 .length = 144 * SZ_1K,
192 .type = MT_DEVICE,
193 }, {
194 .virtual = (unsigned long)S5P_VA_PMU,
195 .pfn = __phys_to_pfn(EXYNOS5_PA_PMU),
196 .length = SZ_64K,
197 .type = MT_DEVICE,
198 },
199};
200
201void exynos_restart(enum reboot_mode mode, const char *cmd)
202{
203 struct device_node *np;
204 u32 val = 0x1;
205 void __iomem *addr = EXYNOS_SWRESET;
206
207 if (of_machine_is_compatible("samsung,exynos5440")) {
208 u32 status;
209 np = of_find_compatible_node(NULL, NULL, "samsung,exynos5440-clock");
210
211 addr = of_iomap(np, 0) + 0xbc;
212 status = __raw_readl(addr);
213
214 addr = of_iomap(np, 0) + 0xcc;
215 val = __raw_readl(addr);
216
217 val = (val & 0xffff0000) | (status & 0xffff);
218 }
219
220 __raw_writel(val, addr);
221}
222
223static struct platform_device exynos_cpuidle = {
224 .name = "exynos_cpuidle",
225 .id = -1,
226};
227
228void __init exynos_cpuidle_init(void)
229{
230 platform_device_register(&exynos_cpuidle);
231}
232
233void __init exynos_cpufreq_init(void)
234{
235 platform_device_register_simple("exynos-cpufreq", -1, NULL, 0);
236}
237
238void __init exynos_init_late(void)
239{
240 if (of_machine_is_compatible("samsung,exynos5440"))
241 /* to be supported later */
242 return;
243
244 pm_genpd_poweroff_unused();
245 exynos_pm_init();
246}
247
248static int __init exynos_fdt_map_chipid(unsigned long node, const char *uname,
249 int depth, void *data)
250{
251 struct map_desc iodesc;
252 __be32 *reg;
253 unsigned long len;
254
255 if (!of_flat_dt_is_compatible(node, "samsung,exynos4210-chipid") &&
256 !of_flat_dt_is_compatible(node, "samsung,exynos5440-clock"))
257 return 0;
258
259 reg = of_get_flat_dt_prop(node, "reg", &len);
260 if (reg == NULL || len != (sizeof(unsigned long) * 2))
261 return 0;
262
263 iodesc.pfn = __phys_to_pfn(be32_to_cpu(reg[0]));
264 iodesc.length = be32_to_cpu(reg[1]) - 1;
265 iodesc.virtual = (unsigned long)S5P_VA_CHIPID;
266 iodesc.type = MT_DEVICE;
267 iotable_init(&iodesc, 1);
268 return 1;
269}
270
271/*
272 * exynos_map_io
273 *
274 * register the standard cpu IO areas
275 */
276static void __init exynos_map_io(void)
277{
278 if (soc_is_exynos4())
279 iotable_init(exynos4_iodesc, ARRAY_SIZE(exynos4_iodesc));
280
281 if (soc_is_exynos5())
282 iotable_init(exynos5_iodesc, ARRAY_SIZE(exynos5_iodesc));
283
284 if (soc_is_exynos4210()) {
285 if (samsung_rev() == EXYNOS4210_REV_0)
286 iotable_init(exynos4_iodesc0,
287 ARRAY_SIZE(exynos4_iodesc0));
288 else
289 iotable_init(exynos4_iodesc1,
290 ARRAY_SIZE(exynos4_iodesc1));
291 iotable_init(exynos4210_iodesc, ARRAY_SIZE(exynos4210_iodesc));
292 }
293 if (soc_is_exynos4212() || soc_is_exynos4412())
294 iotable_init(exynos4x12_iodesc, ARRAY_SIZE(exynos4x12_iodesc));
295 if (soc_is_exynos5250())
296 iotable_init(exynos5250_iodesc, ARRAY_SIZE(exynos5250_iodesc));
297}
298
299void __init exynos_init_io(void)
300{
301 debug_ll_io_init();
302
303 of_scan_flat_dt(exynos_fdt_map_chipid, NULL);
304
305 /* detect cpu id and rev. */
306 s5p_init_cpu(S5P_VA_CHIPID);
307
308 exynos_map_io();
309}
310
311struct bus_type exynos_subsys = {
312 .name = "exynos-core",
313 .dev_name = "exynos-core",
314};
315
316static int __init exynos_core_init(void)
317{
318 return subsys_system_register(&exynos_subsys, NULL);
319}
320core_initcall(exynos_core_init);
321
322static int __init exynos4_l2x0_cache_init(void)
323{
324 int ret;
325
326 ret = l2x0_of_init(L2_AUX_VAL, L2_AUX_MASK);
327 if (ret)
328 return ret;
329
330 if (IS_ENABLED(CONFIG_S5P_SLEEP)) {
331 l2x0_regs_phys = virt_to_phys(&l2x0_saved_regs);
332 clean_dcache_area(&l2x0_regs_phys, sizeof(unsigned long));
333 }
334 return 0;
335}
336early_initcall(exynos4_l2x0_cache_init);
337
338static void __init exynos_dt_machine_init(void)
339{
340 struct device_node *i2c_np;
341 const char *i2c_compat = "samsung,s3c2440-i2c";
342 unsigned int tmp;
343 int id;
344
345 /*
346 * Exynos5's legacy i2c controller and new high speed i2c
347 * controller have muxed interrupt sources. By default the
348 * interrupts for 4-channel HS-I2C controller are enabled.
349 * If node for first four channels of legacy i2c controller
350 * are available then re-configure the interrupts via the
351 * system register.
352 */
353 if (soc_is_exynos5()) {
354 for_each_compatible_node(i2c_np, NULL, i2c_compat) {
355 if (of_device_is_available(i2c_np)) {
356 id = of_alias_get_id(i2c_np, "i2c");
357 if (id < 4) {
358 tmp = readl(EXYNOS5_SYS_I2C_CFG);
359 writel(tmp & ~(0x1 << id),
360 EXYNOS5_SYS_I2C_CFG);
361 }
362 }
363 }
364 }
365
366 exynos_cpuidle_init();
367 exynos_cpufreq_init();
368
369 of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL);
370}
371
372static char const *exynos_dt_compat[] __initconst = {
373 "samsung,exynos4",
374 "samsung,exynos4210",
375 "samsung,exynos4212",
376 "samsung,exynos4412",
377 "samsung,exynos5",
378 "samsung,exynos5250",
379 "samsung,exynos5420",
380 "samsung,exynos5440",
381 NULL
382};
383
384static void __init exynos_reserve(void)
385{
386#ifdef CONFIG_S5P_DEV_MFC
387 int i;
388 char *mfc_mem[] = {
389 "samsung,mfc-v5",
390 "samsung,mfc-v6",
391 "samsung,mfc-v7",
392 };
393
394 for (i = 0; i < ARRAY_SIZE(mfc_mem); i++)
395 if (of_scan_flat_dt(s5p_fdt_alloc_mfc_mem, mfc_mem[i]))
396 break;
397#endif
398}
399
400DT_MACHINE_START(EXYNOS_DT, "SAMSUNG EXYNOS (Flattened Device Tree)")
401 /* Maintainer: Thomas Abraham <thomas.abraham@linaro.org> */
402 /* Maintainer: Kukjin Kim <kgene.kim@samsung.com> */
403 .smp = smp_ops(exynos_smp_ops),
404 .map_io = exynos_init_io,
405 .init_early = exynos_firmware_init,
406 .init_machine = exynos_dt_machine_init,
407 .init_late = exynos_init_late,
408 .dt_compat = exynos_dt_compat,
409 .restart = exynos_restart,
410 .reserve = exynos_reserve,
411MACHINE_END