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 <mach/map.h>
23#include <plat/cpu.h>
24
25#include "common.h"
26
27static struct map_desc exynos4_iodesc[] __initdata = {
28 {
29 .virtual = (unsigned long)S5P_VA_COREPERI_BASE,
30 .pfn = __phys_to_pfn(EXYNOS4_PA_COREPERI),
31 .length = SZ_8K,
32 .type = MT_DEVICE,
33 },
34};
35
36static struct platform_device exynos_cpuidle = {
37 .name = "exynos_cpuidle",
38#ifdef CONFIG_ARM_EXYNOS_CPUIDLE
39 .dev.platform_data = exynos_enter_aftr,
40#endif
41 .id = -1,
42};
43
44void __iomem *sysram_base_addr __ro_after_init;
45void __iomem *sysram_ns_base_addr __ro_after_init;
46
47void __init exynos_sysram_init(void)
48{
49 struct device_node *node;
50
51 for_each_compatible_node(node, NULL, "samsung,exynos4210-sysram") {
52 if (!of_device_is_available(node))
53 continue;
54 sysram_base_addr = of_iomap(node, 0);
55 break;
56 }
57
58 for_each_compatible_node(node, NULL, "samsung,exynos4210-sysram-ns") {
59 if (!of_device_is_available(node))
60 continue;
61 sysram_ns_base_addr = of_iomap(node, 0);
62 break;
63 }
64}
65
66static void __init exynos_init_late(void)
67{
68 if (of_machine_is_compatible("samsung,exynos5440"))
69 /* to be supported later */
70 return;
71
72 exynos_pm_init();
73}
74
75static int __init exynos_fdt_map_chipid(unsigned long node, const char *uname,
76 int depth, void *data)
77{
78 struct map_desc iodesc;
79 const __be32 *reg;
80 int len;
81
82 if (!of_flat_dt_is_compatible(node, "samsung,exynos4210-chipid") &&
83 !of_flat_dt_is_compatible(node, "samsung,exynos5440-clock"))
84 return 0;
85
86 reg = of_get_flat_dt_prop(node, "reg", &len);
87 if (reg == NULL || len != (sizeof(unsigned long) * 2))
88 return 0;
89
90 iodesc.pfn = __phys_to_pfn(be32_to_cpu(reg[0]));
91 iodesc.length = be32_to_cpu(reg[1]) - 1;
92 iodesc.virtual = (unsigned long)S5P_VA_CHIPID;
93 iodesc.type = MT_DEVICE;
94 iotable_init(&iodesc, 1);
95 return 1;
96}
97
98/*
99 * exynos_map_io
100 *
101 * register the standard cpu IO areas
102 */
103static void __init exynos_map_io(void)
104{
105 if (soc_is_exynos4())
106 iotable_init(exynos4_iodesc, ARRAY_SIZE(exynos4_iodesc));
107}
108
109static void __init exynos_init_io(void)
110{
111 debug_ll_io_init();
112
113 of_scan_flat_dt(exynos_fdt_map_chipid, NULL);
114
115 /* detect cpu id and rev. */
116 s5p_init_cpu(S5P_VA_CHIPID);
117
118 exynos_map_io();
119}
120
121/*
122 * Set or clear the USE_DELAYED_RESET_ASSERTION option. Used by smp code
123 * and suspend.
124 *
125 * This is necessary only on Exynos4 SoCs. When system is running
126 * USE_DELAYED_RESET_ASSERTION should be set so the ARM CLK clock down
127 * feature could properly detect global idle state when secondary CPU is
128 * powered down.
129 *
130 * However this should not be set when such system is going into suspend.
131 */
132void exynos_set_delayed_reset_assertion(bool enable)
133{
134 if (of_machine_is_compatible("samsung,exynos4")) {
135 unsigned int tmp, core_id;
136
137 for (core_id = 0; core_id < num_possible_cpus(); core_id++) {
138 tmp = pmu_raw_readl(EXYNOS_ARM_CORE_OPTION(core_id));
139 if (enable)
140 tmp |= S5P_USE_DELAYED_RESET_ASSERTION;
141 else
142 tmp &= ~(S5P_USE_DELAYED_RESET_ASSERTION);
143 pmu_raw_writel(tmp, EXYNOS_ARM_CORE_OPTION(core_id));
144 }
145 }
146}
147
148/*
149 * Apparently, these SoCs are not able to wake-up from suspend using
150 * the PMU. Too bad. Should they suddenly become capable of such a
151 * feat, the matches below should be moved to suspend.c.
152 */
153static const struct of_device_id exynos_dt_pmu_match[] = {
154 { .compatible = "samsung,exynos5260-pmu" },
155 { .compatible = "samsung,exynos5410-pmu" },
156 { /*sentinel*/ },
157};
158
159static void exynos_map_pmu(void)
160{
161 struct device_node *np;
162
163 np = of_find_matching_node(NULL, exynos_dt_pmu_match);
164 if (np)
165 pmu_base_addr = of_iomap(np, 0);
166}
167
168static void __init exynos_init_irq(void)
169{
170 irqchip_init();
171 /*
172 * Since platsmp.c needs pmu base address by the time
173 * DT is not unflatten so we can't use DT APIs before
174 * init_irq
175 */
176 exynos_map_pmu();
177}
178
179static void __init exynos_dt_machine_init(void)
180{
181 /*
182 * This is called from smp_prepare_cpus if we've built for SMP, but
183 * we still need to set it up for PM and firmware ops if not.
184 */
185 if (!IS_ENABLED(CONFIG_SMP))
186 exynos_sysram_init();
187
188#if defined(CONFIG_SMP) && defined(CONFIG_ARM_EXYNOS_CPUIDLE)
189 if (of_machine_is_compatible("samsung,exynos4210") ||
190 of_machine_is_compatible("samsung,exynos3250"))
191 exynos_cpuidle.dev.platform_data = &cpuidle_coupled_exynos_data;
192#endif
193 if (of_machine_is_compatible("samsung,exynos4210") ||
194 (of_machine_is_compatible("samsung,exynos4412") &&
195 (of_machine_is_compatible("samsung,trats2") ||
196 of_machine_is_compatible("samsung,midas"))) ||
197 of_machine_is_compatible("samsung,exynos3250") ||
198 of_machine_is_compatible("samsung,exynos5250"))
199 platform_device_register(&exynos_cpuidle);
200}
201
202static char const *const exynos_dt_compat[] __initconst = {
203 "samsung,exynos3",
204 "samsung,exynos3250",
205 "samsung,exynos4",
206 "samsung,exynos4210",
207 "samsung,exynos4412",
208 "samsung,exynos5",
209 "samsung,exynos5250",
210 "samsung,exynos5260",
211 "samsung,exynos5420",
212 "samsung,exynos5440",
213 NULL
214};
215
216static void __init exynos_dt_fixup(void)
217{
218 /*
219 * Some versions of uboot pass garbage entries in the memory node,
220 * use the old CONFIG_ARM_NR_BANKS
221 */
222 of_fdt_limit_memory(8);
223}
224
225DT_MACHINE_START(EXYNOS_DT, "SAMSUNG EXYNOS (Flattened Device Tree)")
226 /* Maintainer: Thomas Abraham <thomas.abraham@linaro.org> */
227 /* Maintainer: Kukjin Kim <kgene.kim@samsung.com> */
228 .l2c_aux_val = 0x3c400001,
229 .l2c_aux_mask = 0xc20fffff,
230 .smp = smp_ops(exynos_smp_ops),
231 .map_io = exynos_init_io,
232 .init_early = exynos_firmware_init,
233 .init_irq = exynos_init_irq,
234 .init_machine = exynos_dt_machine_init,
235 .init_late = exynos_init_late,
236 .dt_compat = exynos_dt_compat,
237 .dt_fixup = exynos_dt_fixup,
238MACHINE_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