xref: /linux/arch/arm/mach-ux500/cpu-db8500.c (revision 04eeb606a8383b306f4bc6991da8231b5f3924b0)
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 
36 static struct ab8500_platform_data ab8500_platdata = {
37 	.regulator	= &ab8500_regulator_plat_data,
38 };
39 
40 static struct 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 */
47 static 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 */
52 static 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 */
73 static 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 */
80 static 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 
85 static void __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  */
106 static 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 
122 static struct arm_pmu_platdata db8500_pmu_platdata = {
123 	.handle_irq		= db8500_pmu_handler,
124 };
125 
126 static 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 
138 static 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 
145 static 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("stericsson,ux500-msp-i2s", 0x80123000,
150 		       "ux500-msp-i2s.0", &msp0_platform_data),
151 	OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80124000,
152 		       "ux500-msp-i2s.1", &msp1_platform_data),
153 	OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80117000,
154 		       "ux500-msp-i2s.2", &msp2_platform_data),
155 	OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80125000,
156 		       "ux500-msp-i2s.3", &msp3_platform_data),
157 	/* Requires non-DT:able platform data. */
158 	OF_DEV_AUXDATA("stericsson,db8500-prcmu", 0x80157000, "db8500-prcmu",
159 			&db8500_prcmu_pdata),
160 	OF_DEV_AUXDATA("stericsson,ux500-cryp", 0xa03cb000, "cryp1", NULL),
161 	OF_DEV_AUXDATA("stericsson,ux500-hash", 0xa03c2000, "hash1", NULL),
162 	OF_DEV_AUXDATA("stericsson,snd-soc-mop500", 0, "snd-soc-mop500.0",
163 			NULL),
164 	{},
165 };
166 
167 static struct of_dev_auxdata u8540_auxdata_lookup[] __initdata = {
168 	OF_DEV_AUXDATA("stericsson,db8500-prcmu", 0x80157000, "db8500-prcmu",
169 			&db8500_prcmu_pdata),
170 	{},
171 };
172 
173 static const struct of_device_id u8500_local_bus_nodes[] = {
174 	/* only create devices below soc node */
175 	{ .compatible = "stericsson,db8500", },
176 	{ .compatible = "stericsson,db8500-prcmu", },
177 	{ .compatible = "simple-bus"},
178 	{ },
179 };
180 
181 static void __init u8500_init_machine(void)
182 {
183 	struct device *parent = db8500_soc_device_init();
184 
185 	/* automatically probe child nodes of dbx5x0 devices */
186 	if (of_machine_is_compatible("st-ericsson,u8540"))
187 		of_platform_populate(NULL, u8500_local_bus_nodes,
188 				     u8540_auxdata_lookup, parent);
189 	else
190 		of_platform_populate(NULL, u8500_local_bus_nodes,
191 				     u8500_auxdata_lookup, parent);
192 }
193 
194 static const char * stericsson_dt_platform_compat[] = {
195 	"st-ericsson,u8500",
196 	"st-ericsson,u8540",
197 	"st-ericsson,u9500",
198 	"st-ericsson,u9540",
199 	NULL,
200 };
201 
202 DT_MACHINE_START(U8500_DT, "ST-Ericsson Ux5x0 platform (Device Tree Support)")
203 	.smp            = smp_ops(ux500_smp_ops),
204 	.map_io		= u8500_map_io,
205 	.init_irq	= ux500_init_irq,
206 	/* we re-use nomadik timer here */
207 	.init_time	= ux500_timer_init,
208 	.init_machine	= u8500_init_machine,
209 	.init_late	= NULL,
210 	.dt_compat      = stericsson_dt_platform_compat,
211 	.restart        = ux500_restart,
212 MACHINE_END
213