Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2008-2009 ST-Ericsson SA
4 *
5 * Author: Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com>
6 */
7#include <linux/types.h>
8#include <linux/init.h>
9#include <linux/device.h>
10#include <linux/amba/bus.h>
11#include <linux/interrupt.h>
12#include <linux/irq.h>
13#include <linux/irqchip.h>
14#include <linux/irqchip/arm-gic.h>
15#include <linux/mfd/dbx500-prcmu.h>
16#include <linux/platform_data/arm-ux500-pm.h>
17#include <linux/platform_device.h>
18#include <linux/io.h>
19#include <linux/of.h>
20#include <linux/of_address.h>
21#include <linux/of_platform.h>
22#include <linux/regulator/machine.h>
23
24#include <asm/outercache.h>
25#include <asm/hardware/cache-l2x0.h>
26#include <asm/mach/map.h>
27#include <asm/mach/arch.h>
28
29static int __init ux500_l2x0_unlock(void)
30{
31 int i;
32 struct device_node *np;
33 void __iomem *l2x0_base;
34
35 np = of_find_compatible_node(NULL, NULL, "arm,pl310-cache");
36 l2x0_base = of_iomap(np, 0);
37 of_node_put(np);
38 if (!l2x0_base)
39 return -ENODEV;
40
41 /*
42 * Unlock Data and Instruction Lock if locked. Ux500 U-Boot versions
43 * apparently locks both caches before jumping to the kernel. The
44 * l2x0 core will not touch the unlock registers if the l2x0 is
45 * already enabled, so we do it right here instead. The PL310 has
46 * 8 sets of registers, one per possible CPU.
47 */
48 for (i = 0; i < 8; i++) {
49 writel_relaxed(0x0, l2x0_base + L2X0_LOCKDOWN_WAY_D_BASE +
50 i * L2X0_LOCKDOWN_STRIDE);
51 writel_relaxed(0x0, l2x0_base + L2X0_LOCKDOWN_WAY_I_BASE +
52 i * L2X0_LOCKDOWN_STRIDE);
53 }
54 iounmap(l2x0_base);
55 return 0;
56}
57
58static void ux500_l2c310_write_sec(unsigned long val, unsigned reg)
59{
60 /*
61 * We can't write to secure registers as we are in non-secure
62 * mode, until we have some SMI service available.
63 */
64}
65
66/*
67 * FIXME: Should we set up the GPIO domain here?
68 *
69 * The problem is that we cannot put the interrupt resources into the platform
70 * device until the irqdomain has been added. Right now, we set the GIC interrupt
71 * domain from init_irq(), then load the gpio driver from
72 * core_initcall(nmk_gpio_init) and add the platform devices from
73 * arch_initcall(customize_machine).
74 *
75 * This feels fragile because it depends on the gpio device getting probed
76 * _before_ any device uses the gpio interrupts.
77*/
78static void __init ux500_init_irq(void)
79{
80 struct device_node *np;
81 struct resource r;
82
83 irqchip_init();
84 prcmu_early_init();
85 np = of_find_compatible_node(NULL, NULL, "stericsson,db8500-prcmu");
86 of_address_to_resource(np, 0, &r);
87 of_node_put(np);
88 if (!r.start) {
89 pr_err("could not find PRCMU base resource\n");
90 return;
91 }
92 ux500_pm_init(r.start, r.end-r.start);
93
94 /* Unlock before init */
95 ux500_l2x0_unlock();
96 outer_cache.write_sec = ux500_l2c310_write_sec;
97}
98
99static void ux500_restart(enum reboot_mode mode, const char *cmd)
100{
101 local_irq_disable();
102 local_fiq_disable();
103
104 prcmu_system_reset(0);
105}
106
107static const struct of_device_id u8500_local_bus_nodes[] = {
108 /* only create devices below soc node */
109 { .compatible = "stericsson,db8500", },
110 { .compatible = "simple-bus"},
111 { },
112};
113
114static void __init u8500_init_machine(void)
115{
116 of_platform_populate(NULL, u8500_local_bus_nodes,
117 NULL, NULL);
118}
119
120static const char * stericsson_dt_platform_compat[] = {
121 "st-ericsson,u8500",
122 "st-ericsson,u9500",
123 NULL,
124};
125
126DT_MACHINE_START(U8500_DT, "ST-Ericsson Ux5x0 platform (Device Tree Support)")
127 .l2c_aux_val = 0,
128 .l2c_aux_mask = ~0,
129 .init_irq = ux500_init_irq,
130 .init_machine = u8500_init_machine,
131 .dt_compat = stericsson_dt_platform_compat,
132 .restart = ux500_restart,
133MACHINE_END
1/*
2 * Copyright (C) 2008-2009 ST-Ericsson SA
3 *
4 * Author: Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2, as
8 * published by the Free Software Foundation.
9 *
10 */
11#include <linux/types.h>
12#include <linux/init.h>
13#include <linux/device.h>
14#include <linux/amba/bus.h>
15#include <linux/interrupt.h>
16#include <linux/irq.h>
17#include <linux/platform_device.h>
18#include <linux/io.h>
19#include <linux/mfd/abx500/ab8500.h>
20#include <linux/mfd/dbx500-prcmu.h>
21#include <linux/of.h>
22#include <linux/of_platform.h>
23#include <linux/regulator/machine.h>
24#include <linux/random.h>
25
26#include <asm/pmu.h>
27#include <asm/mach/map.h>
28
29#include "setup.h"
30
31#include "board-mop500-regulators.h"
32#include "board-mop500.h"
33#include "db8500-regs.h"
34#include "id.h"
35
36struct ab8500_platform_data ab8500_platdata = {
37 .regulator = &ab8500_regulator_plat_data,
38};
39
40struct prcmu_pdata db8500_prcmu_pdata = {
41 .ab_platdata = &ab8500_platdata,
42 .version_offset = DB8500_PRCMU_FW_VERSION_OFFSET,
43 .legacy_offset = DB8500_PRCMU_LEGACY_OFFSET,
44};
45
46/* minimum static i/o mapping required to boot U8500 platforms */
47static struct map_desc u8500_uart_io_desc[] __initdata = {
48 __IO_DEV_DESC(U8500_UART0_BASE, SZ_4K),
49 __IO_DEV_DESC(U8500_UART2_BASE, SZ_4K),
50};
51/* U8500 and U9540 common io_desc */
52static struct map_desc u8500_common_io_desc[] __initdata = {
53 /* SCU base also covers GIC CPU BASE and TWD with its 4K page */
54 __IO_DEV_DESC(U8500_SCU_BASE, SZ_4K),
55 __IO_DEV_DESC(U8500_GIC_DIST_BASE, SZ_4K),
56 __IO_DEV_DESC(U8500_L2CC_BASE, SZ_4K),
57 __IO_DEV_DESC(U8500_MTU0_BASE, SZ_4K),
58 __IO_DEV_DESC(U8500_BACKUPRAM0_BASE, SZ_8K),
59
60 __IO_DEV_DESC(U8500_CLKRST1_BASE, SZ_4K),
61 __IO_DEV_DESC(U8500_CLKRST2_BASE, SZ_4K),
62 __IO_DEV_DESC(U8500_CLKRST3_BASE, SZ_4K),
63 __IO_DEV_DESC(U8500_CLKRST5_BASE, SZ_4K),
64 __IO_DEV_DESC(U8500_CLKRST6_BASE, SZ_4K),
65
66 __IO_DEV_DESC(U8500_GPIO0_BASE, SZ_4K),
67 __IO_DEV_DESC(U8500_GPIO1_BASE, SZ_4K),
68 __IO_DEV_DESC(U8500_GPIO2_BASE, SZ_4K),
69 __IO_DEV_DESC(U8500_GPIO3_BASE, SZ_4K),
70};
71
72/* U8500 IO map specific description */
73static struct map_desc u8500_io_desc[] __initdata = {
74 __IO_DEV_DESC(U8500_PRCMU_BASE, SZ_4K),
75 __IO_DEV_DESC(U8500_PRCMU_TCDM_BASE, SZ_4K),
76
77};
78
79/* U9540 IO map specific description */
80static struct map_desc u9540_io_desc[] __initdata = {
81 __IO_DEV_DESC(U8500_PRCMU_BASE, SZ_4K + SZ_8K),
82 __IO_DEV_DESC(U8500_PRCMU_TCDM_BASE, SZ_4K + SZ_8K),
83};
84
85void __init u8500_map_io(void)
86{
87 /*
88 * Map the UARTs early so that the DEBUG_LL stuff continues to work.
89 */
90 iotable_init(u8500_uart_io_desc, ARRAY_SIZE(u8500_uart_io_desc));
91
92 ux500_map_io();
93
94 iotable_init(u8500_common_io_desc, ARRAY_SIZE(u8500_common_io_desc));
95
96 if (cpu_is_ux540_family())
97 iotable_init(u9540_io_desc, ARRAY_SIZE(u9540_io_desc));
98 else
99 iotable_init(u8500_io_desc, ARRAY_SIZE(u8500_io_desc));
100}
101
102/*
103 * The PMU IRQ lines of two cores are wired together into a single interrupt.
104 * Bounce the interrupt to the other core if it's not ours.
105 */
106static irqreturn_t db8500_pmu_handler(int irq, void *dev, irq_handler_t handler)
107{
108 irqreturn_t ret = handler(irq, dev);
109 int other = !smp_processor_id();
110
111 if (ret == IRQ_NONE && cpu_online(other))
112 irq_set_affinity(irq, cpumask_of(other));
113
114 /*
115 * We should be able to get away with the amount of IRQ_NONEs we give,
116 * while still having the spurious IRQ detection code kick in if the
117 * interrupt really starts hitting spuriously.
118 */
119 return ret;
120}
121
122struct arm_pmu_platdata db8500_pmu_platdata = {
123 .handle_irq = db8500_pmu_handler,
124};
125
126static const char *db8500_read_soc_id(void)
127{
128 void __iomem *uid = __io_address(U8500_BB_UID_BASE);
129
130 /* Throw these device-specific numbers into the entropy pool */
131 add_device_randomness(uid, 0x14);
132 return kasprintf(GFP_KERNEL, "%08x%08x%08x%08x%08x",
133 readl((u32 *)uid+0),
134 readl((u32 *)uid+1), readl((u32 *)uid+2),
135 readl((u32 *)uid+3), readl((u32 *)uid+4));
136}
137
138static struct device * __init db8500_soc_device_init(void)
139{
140 const char *soc_id = db8500_read_soc_id();
141
142 return ux500_soc_device_init(soc_id);
143}
144
145static struct of_dev_auxdata u8500_auxdata_lookup[] __initdata = {
146 /* Requires call-back bindings. */
147 OF_DEV_AUXDATA("arm,cortex-a9-pmu", 0, "arm-pmu", &db8500_pmu_platdata),
148 /* Requires DMA bindings. */
149 OF_DEV_AUXDATA("arm,pl18x", 0x80126000, "sdi0", &mop500_sdi0_data),
150 OF_DEV_AUXDATA("arm,pl18x", 0x80118000, "sdi1", &mop500_sdi1_data),
151 OF_DEV_AUXDATA("arm,pl18x", 0x80005000, "sdi2", &mop500_sdi2_data),
152 OF_DEV_AUXDATA("arm,pl18x", 0x80114000, "sdi4", &mop500_sdi4_data),
153 OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80123000,
154 "ux500-msp-i2s.0", &msp0_platform_data),
155 OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80124000,
156 "ux500-msp-i2s.1", &msp1_platform_data),
157 OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80117000,
158 "ux500-msp-i2s.2", &msp2_platform_data),
159 OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80125000,
160 "ux500-msp-i2s.3", &msp3_platform_data),
161 /* Requires non-DT:able platform data. */
162 OF_DEV_AUXDATA("stericsson,db8500-prcmu", 0x80157000, "db8500-prcmu",
163 &db8500_prcmu_pdata),
164 OF_DEV_AUXDATA("stericsson,ux500-cryp", 0xa03cb000, "cryp1", NULL),
165 OF_DEV_AUXDATA("stericsson,ux500-hash", 0xa03c2000, "hash1", NULL),
166 OF_DEV_AUXDATA("stericsson,snd-soc-mop500", 0, "snd-soc-mop500.0",
167 NULL),
168 {},
169};
170
171static struct of_dev_auxdata u8540_auxdata_lookup[] __initdata = {
172 OF_DEV_AUXDATA("stericsson,db8500-prcmu", 0x80157000, "db8500-prcmu",
173 &db8500_prcmu_pdata),
174 {},
175};
176
177static const struct of_device_id u8500_local_bus_nodes[] = {
178 /* only create devices below soc node */
179 { .compatible = "stericsson,db8500", },
180 { .compatible = "stericsson,db8500-prcmu", },
181 { .compatible = "simple-bus"},
182 { },
183};
184
185static void __init u8500_init_machine(void)
186{
187 struct device *parent = db8500_soc_device_init();
188
189 /* automatically probe child nodes of dbx5x0 devices */
190 if (of_machine_is_compatible("st-ericsson,u8540"))
191 of_platform_populate(NULL, u8500_local_bus_nodes,
192 u8540_auxdata_lookup, parent);
193 else
194 of_platform_populate(NULL, u8500_local_bus_nodes,
195 u8500_auxdata_lookup, parent);
196}
197
198static const char * stericsson_dt_platform_compat[] = {
199 "st-ericsson,u8500",
200 "st-ericsson,u8540",
201 "st-ericsson,u9500",
202 "st-ericsson,u9540",
203 NULL,
204};
205
206DT_MACHINE_START(U8500_DT, "ST-Ericsson Ux5x0 platform (Device Tree Support)")
207 .smp = smp_ops(ux500_smp_ops),
208 .map_io = u8500_map_io,
209 .init_irq = ux500_init_irq,
210 /* we re-use nomadik timer here */
211 .init_time = ux500_timer_init,
212 .init_machine = u8500_init_machine,
213 .init_late = NULL,
214 .dt_compat = stericsson_dt_platform_compat,
215 .restart = ux500_restart,
216MACHINE_END