[deliverable/linux.git] / arch / arm / mach-shmobile / setup-emev2.c

/*
 * Emma Mobile EV2 processor support
 *
 * Copyright (C) 2012  Magnus Damm
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/irqchip.h>
#include <linux/platform_device.h>
#include <linux/platform_data/gpio-em.h>
#include <linux/of_platform.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/io.h>
#include <linux/irqchip/arm-gic.h>
#include <mach/hardware.h>
#include <mach/common.h>
#include <mach/emev2.h>
#include <mach/irqs.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/time.h>

static struct map_desc emev2_io_desc[] __initdata = {
#ifdef CONFIG_SMP
	/* 128K entity map for 0xe0100000 (SMU) */
	{
		.virtual	= 0xe0100000,
		.pfn		= __phys_to_pfn(0xe0100000),
		.length		= SZ_128K,
		.type		= MT_DEVICE
	},
	/* 2M mapping for SCU + L2 controller */
	{
		.virtual	= 0xf0000000,
		.pfn		= __phys_to_pfn(0x1e000000),
		.length		= SZ_2M,
		.type		= MT_DEVICE
	},
#endif
};

void __init emev2_map_io(void)
{
	iotable_init(emev2_io_desc, ARRAY_SIZE(emev2_io_desc));
}

/* UART */
static struct resource uart0_resources[] = {
	[0]	= {
		.start	= 0xe1020000,
		.end	= 0xe1020037,
		.flags	= IORESOURCE_MEM,
	},
	[1]	= {
		.start	= 40,
		.flags	= IORESOURCE_IRQ,
	}
};

static struct platform_device uart0_device = {
	.name		= "serial8250-em",
	.id		= 0,
	.num_resources	= ARRAY_SIZE(uart0_resources),
	.resource	= uart0_resources,
};

static struct resource uart1_resources[] = {
	[0]	= {
		.start	= 0xe1030000,
		.end	= 0xe1030037,
		.flags	= IORESOURCE_MEM,
	},
	[1]	= {
		.start	= 41,
		.flags	= IORESOURCE_IRQ,
	}
};

static struct platform_device uart1_device = {
	.name		= "serial8250-em",
	.id		= 1,
	.num_resources	= ARRAY_SIZE(uart1_resources),
	.resource	= uart1_resources,
};

static struct resource uart2_resources[] = {
	[0]	= {
		.start	= 0xe1040000,
		.end	= 0xe1040037,
		.flags	= IORESOURCE_MEM,
	},
	[1]	= {
		.start	= 42,
		.flags	= IORESOURCE_IRQ,
	}
};

static struct platform_device uart2_device = {
	.name		= "serial8250-em",
	.id		= 2,
	.num_resources	= ARRAY_SIZE(uart2_resources),
	.resource	= uart2_resources,
};

static struct resource uart3_resources[] = {
	[0]	= {
		.start	= 0xe1050000,
		.end	= 0xe1050037,
		.flags	= IORESOURCE_MEM,
	},
	[1]	= {
		.start	= 43,
		.flags	= IORESOURCE_IRQ,
	}
};

static struct platform_device uart3_device = {
	.name		= "serial8250-em",
	.id		= 3,
	.num_resources	= ARRAY_SIZE(uart3_resources),
	.resource	= uart3_resources,
};

/* STI */
static struct resource sti_resources[] = {
	[0] = {
		.name	= "STI",
		.start	= 0xe0180000,
		.end	= 0xe0180053,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= 157,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device sti_device = {
	.name		= "em_sti",
	.id		= 0,
	.resource	= sti_resources,
	.num_resources	= ARRAY_SIZE(sti_resources),
};


/* GIO */
static struct gpio_em_config gio0_config = {
	.gpio_base = 0,
	.irq_base = EMEV2_GPIO_IRQ(0),
	.number_of_pins = 32,
};

static struct resource gio0_resources[] = {
	[0] = {
		.name	= "GIO_000",
		.start	= 0xe0050000,
		.end	= 0xe005002b,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.name	= "GIO_000",
		.start	= 0xe0050040,
		.end	= 0xe005005f,
		.flags	= IORESOURCE_MEM,
	},
	[2] = {
		.start	= 99,
		.flags	= IORESOURCE_IRQ,
	},
	[3] = {
		.start	= 100,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device gio0_device = {
	.name		= "em_gio",
	.id		= 0,
	.resource	= gio0_resources,
	.num_resources	= ARRAY_SIZE(gio0_resources),
	.dev		= {
		.platform_data	= &gio0_config,
	},
};

static struct gpio_em_config gio1_config = {
	.gpio_base = 32,
	.irq_base = EMEV2_GPIO_IRQ(32),
	.number_of_pins = 32,
};

static struct resource gio1_resources[] = {
	[0] = {
		.name	= "GIO_032",
		.start	= 0xe0050080,
		.end	= 0xe00500ab,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.name	= "GIO_032",
		.start	= 0xe00500c0,
		.end	= 0xe00500df,
		.flags	= IORESOURCE_MEM,
	},
	[2] = {
		.start	= 101,
		.flags	= IORESOURCE_IRQ,
	},
	[3] = {
		.start	= 102,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device gio1_device = {
	.name		= "em_gio",
	.id		= 1,
	.resource	= gio1_resources,
	.num_resources	= ARRAY_SIZE(gio1_resources),
	.dev		= {
		.platform_data	= &gio1_config,
	},
};

static struct gpio_em_config gio2_config = {
	.gpio_base = 64,
	.irq_base = EMEV2_GPIO_IRQ(64),
	.number_of_pins = 32,
};

static struct resource gio2_resources[] = {
	[0] = {
		.name	= "GIO_064",
		.start	= 0xe0050100,
		.end	= 0xe005012b,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.name	= "GIO_064",
		.start	= 0xe0050140,
		.end	= 0xe005015f,
		.flags	= IORESOURCE_MEM,
	},
	[2] = {
		.start	= 103,
		.flags	= IORESOURCE_IRQ,
	},
	[3] = {
		.start	= 104,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device gio2_device = {
	.name		= "em_gio",
	.id		= 2,
	.resource	= gio2_resources,
	.num_resources	= ARRAY_SIZE(gio2_resources),
	.dev		= {
		.platform_data	= &gio2_config,
	},
};

static struct gpio_em_config gio3_config = {
	.gpio_base = 96,
	.irq_base = EMEV2_GPIO_IRQ(96),
	.number_of_pins = 32,
};

static struct resource gio3_resources[] = {
	[0] = {
		.name	= "GIO_096",
		.start	= 0xe0050100,
		.end	= 0xe005012b,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.name	= "GIO_096",
		.start	= 0xe0050140,
		.end	= 0xe005015f,
		.flags	= IORESOURCE_MEM,
	},
	[2] = {
		.start	= 105,
		.flags	= IORESOURCE_IRQ,
	},
	[3] = {
		.start	= 106,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device gio3_device = {
	.name		= "em_gio",
	.id		= 3,
	.resource	= gio3_resources,
	.num_resources	= ARRAY_SIZE(gio3_resources),
	.dev		= {
		.platform_data	= &gio3_config,
	},
};

static struct gpio_em_config gio4_config = {
	.gpio_base = 128,
	.irq_base = EMEV2_GPIO_IRQ(128),
	.number_of_pins = 31,
};

static struct resource gio4_resources[] = {
	[0] = {
		.name	= "GIO_128",
		.start	= 0xe0050200,
		.end	= 0xe005022b,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.name	= "GIO_128",
		.start	= 0xe0050240,
		.end	= 0xe005025f,
		.flags	= IORESOURCE_MEM,
	},
	[2] = {
		.start	= 107,
		.flags	= IORESOURCE_IRQ,
	},
	[3] = {
		.start	= 108,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device gio4_device = {
	.name		= "em_gio",
	.id		= 4,
	.resource	= gio4_resources,
	.num_resources	= ARRAY_SIZE(gio4_resources),
	.dev		= {
		.platform_data	= &gio4_config,
	},
};

static struct resource pmu_resources[] = {
	[0] = {
		.start	= 152,
		.end	= 152,
		.flags	= IORESOURCE_IRQ,
	},
	[1] = {
		.start	= 153,
		.end	= 153,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device pmu_device = {
	.name		= "arm-pmu",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(pmu_resources),
	.resource	= pmu_resources,
};

static struct platform_device *emev2_early_devices[] __initdata = {
	&uart0_device,
	&uart1_device,
	&uart2_device,
	&uart3_device,
};

static struct platform_device *emev2_late_devices[] __initdata = {
	&sti_device,
	&gio0_device,
	&gio1_device,
	&gio2_device,
	&gio3_device,
	&gio4_device,
	&pmu_device,
};

void __init emev2_add_standard_devices(void)
{
	emev2_clock_init();

	platform_add_devices(emev2_early_devices,
			     ARRAY_SIZE(emev2_early_devices));

	platform_add_devices(emev2_late_devices,
			     ARRAY_SIZE(emev2_late_devices));
}

static void __init emev2_init_delay(void)
{
	shmobile_setup_delay(533, 1, 3); /* Cortex-A9 @ 533MHz */
}

void __init emev2_add_early_devices(void)
{
	emev2_init_delay();

	early_platform_add_devices(emev2_early_devices,
				   ARRAY_SIZE(emev2_early_devices));

	/* setup early console here as well */
	shmobile_setup_console();
}

void __init emev2_init_irq(void)
{
	void __iomem *gic_dist_base;
	void __iomem *gic_cpu_base;

	/* Static mappings, never released */
	gic_dist_base = ioremap(0xe0028000, PAGE_SIZE);
	gic_cpu_base = ioremap(0xe0020000, PAGE_SIZE);
	BUG_ON(!gic_dist_base || !gic_cpu_base);

	/* Use GIC to handle interrupts */
	gic_init(0, 29, gic_dist_base, gic_cpu_base);
}

#ifdef CONFIG_USE_OF
static const struct of_dev_auxdata emev2_auxdata_lookup[] __initconst = {
	{ }
};

static void __init emev2_add_standard_devices_dt(void)
{
	of_platform_populate(NULL, of_default_bus_match_table,
			     emev2_auxdata_lookup, NULL);
}

static const char *emev2_boards_compat_dt[] __initdata = {
	"renesas,emev2",
	NULL,
};

DT_MACHINE_START(EMEV2_DT, "Generic Emma Mobile EV2 (Flattened Device Tree)")
	.smp		= smp_ops(emev2_smp_ops),
	.init_early	= emev2_init_delay,
	.nr_irqs	= NR_IRQS_LEGACY,
	.init_irq	= irqchip_init,
	.init_machine	= emev2_add_standard_devices_dt,
	.init_time	= shmobile_timer_init,
	.dt_compat	= emev2_boards_compat_dt,
MACHINE_END

#endif /* CONFIG_USE_OF */
Commit	Line	Data
7f627f03 MD	1	/*
	2	* Emma Mobile EV2 processor support
	3	*
	4	* Copyright (C) 2012 Magnus Damm
	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 as published by
	8	* the Free Software Foundation; version 2 of the License.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
	19	#include <linux/kernel.h>
	20	#include <linux/init.h>
	21	#include <linux/interrupt.h>
	22	#include <linux/irq.h>
0529e315	23	#include <linux/irqchip.h>
7f627f03	24	#include <linux/platform_device.h>
088efd92	25	#include <linux/platform_data/gpio-em.h>
3d5de271	26	#include <linux/of_platform.h>
7f627f03 MD	27	#include <linux/delay.h>
	28	#include <linux/input.h>
	29	#include <linux/io.h>
520f7bd7	30	#include <linux/irqchip/arm-gic.h>
7f627f03 MD	31	#include <mach/hardware.h>
	32	#include <mach/common.h>
	33	#include <mach/emev2.h>
	34	#include <mach/irqs.h>
	35	#include <asm/mach-types.h>
	36	#include <asm/mach/arch.h>
	37	#include <asm/mach/map.h>
	38	#include <asm/mach/time.h>
7f627f03	39
bd5a875d MD	40	static struct map_desc emev2_io_desc[] __initdata = {
	41	#ifdef CONFIG_SMP
	42	/* 128K entity map for 0xe0100000 (SMU) */
	43	{
	44	.virtual = 0xe0100000,
	45	.pfn = __phys_to_pfn(0xe0100000),
	46	.length = SZ_128K,
	47	.type = MT_DEVICE
	48	},
	49	/* 2M mapping for SCU + L2 controller */
	50	{
	51	.virtual = 0xf0000000,
	52	.pfn = __phys_to_pfn(0x1e000000),
	53	.length = SZ_2M,
	54	.type = MT_DEVICE
	55	},
	56	#endif
	57	};
	58
	59	void __init emev2_map_io(void)
	60	{
	61	iotable_init(emev2_io_desc, ARRAY_SIZE(emev2_io_desc));
	62	}
	63
7f627f03 MD	64	/* UART */
	65	static struct resource uart0_resources[] = {
	66	[0] = {
	67	.start = 0xe1020000,
	68	.end = 0xe1020037,
	69	.flags = IORESOURCE_MEM,
	70	},
	71	[1] = {
	72	.start = 40,
	73	.flags = IORESOURCE_IRQ,
	74	}
	75	};
	76
	77	static struct platform_device uart0_device = {
	78	.name = "serial8250-em",
	79	.id = 0,
	80	.num_resources = ARRAY_SIZE(uart0_resources),
	81	.resource = uart0_resources,
	82	};
	83
	84	static struct resource uart1_resources[] = {
	85	[0] = {
	86	.start = 0xe1030000,
	87	.end = 0xe1030037,
	88	.flags = IORESOURCE_MEM,
	89	},
	90	[1] = {
	91	.start = 41,
	92	.flags = IORESOURCE_IRQ,
	93	}
	94	};
	95
	96	static struct platform_device uart1_device = {
	97	.name = "serial8250-em",
	98	.id = 1,
	99	.num_resources = ARRAY_SIZE(uart1_resources),
	100	.resource = uart1_resources,
	101	};
	102
	103	static struct resource uart2_resources[] = {
	104	[0] = {
	105	.start = 0xe1040000,
	106	.end = 0xe1040037,
	107	.flags = IORESOURCE_MEM,
	108	},
	109	[1] = {
	110	.start = 42,
	111	.flags = IORESOURCE_IRQ,
	112	}
	113	};
	114
	115	static struct platform_device uart2_device = {
	116	.name = "serial8250-em",
	117	.id = 2,
	118	.num_resources = ARRAY_SIZE(uart2_resources),
	119	.resource = uart2_resources,
	120	};
	121
	122	static struct resource uart3_resources[] = {
	123	[0] = {
	124	.start = 0xe1050000,
	125	.end = 0xe1050037,
	126	.flags = IORESOURCE_MEM,
	127	},
128	[1] = {
129	.start = 43,
130	.flags = IORESOURCE_IRQ,
131	}
132	};
133
134	static struct platform_device uart3_device = {
135	.name = "serial8250-em",
136	.id = 3,
137	.num_resources = ARRAY_SIZE(uart3_resources),
138	.resource = uart3_resources,
139	};
140
141	/* STI */
142	static struct resource sti_resources[] = {
143	[0] = {
144	.name = "STI",
145	.start = 0xe0180000,
146	.end = 0xe0180053,
147	.flags = IORESOURCE_MEM,
148	},
149	[1] = {
150	.start = 157,
151	.flags = IORESOURCE_IRQ,
152	},
153	};
154
155	static struct platform_device sti_device = {
156	.name = "em_sti",
157	.id = 0,
158	.resource = sti_resources,
159	.num_resources = ARRAY_SIZE(sti_resources),
160	};
161
088efd92 MD	162
	163	/* GIO */
	164	static struct gpio_em_config gio0_config = {
	165	.gpio_base = 0,
	166	.irq_base = EMEV2_GPIO_IRQ(0),
	167	.number_of_pins = 32,
	168	};
	169
	170	static struct resource gio0_resources[] = {
	171	[0] = {
	172	.name = "GIO_000",
	173	.start = 0xe0050000,
	174	.end = 0xe005002b,
	175	.flags = IORESOURCE_MEM,
	176	},
	177	[1] = {
	178	.name = "GIO_000",
	179	.start = 0xe0050040,
	180	.end = 0xe005005f,
	181	.flags = IORESOURCE_MEM,
	182	},
	183	[2] = {
	184	.start = 99,
	185	.flags = IORESOURCE_IRQ,
	186	},
	187	[3] = {
	188	.start = 100,
	189	.flags = IORESOURCE_IRQ,
	190	},
	191	};
	192
	193	static struct platform_device gio0_device = {
	194	.name = "em_gio",
	195	.id = 0,
	196	.resource = gio0_resources,
	197	.num_resources = ARRAY_SIZE(gio0_resources),
	198	.dev = {
	199	.platform_data = &gio0_config,
	200	},
	201	};
	202
	203	static struct gpio_em_config gio1_config = {
	204	.gpio_base = 32,
	205	.irq_base = EMEV2_GPIO_IRQ(32),
	206	.number_of_pins = 32,
	207	};
	208
	209	static struct resource gio1_resources[] = {
	210	[0] = {
	211	.name = "GIO_032",
	212	.start = 0xe0050080,
	213	.end = 0xe00500ab,
	214	.flags = IORESOURCE_MEM,
	215	},
	216	[1] = {
	217	.name = "GIO_032",
	218	.start = 0xe00500c0,
	219	.end = 0xe00500df,
	220	.flags = IORESOURCE_MEM,
	221	},
	222	[2] = {
	223	.start = 101,
	224	.flags = IORESOURCE_IRQ,
	225	},
226	[3] = {
227	.start = 102,
228	.flags = IORESOURCE_IRQ,
229	},
230	};
231
232	static struct platform_device gio1_device = {
233	.name = "em_gio",
234	.id = 1,
235	.resource = gio1_resources,
236	.num_resources = ARRAY_SIZE(gio1_resources),
237	.dev = {
238	.platform_data = &gio1_config,
239	},
240	};
241
242	static struct gpio_em_config gio2_config = {
243	.gpio_base = 64,
244	.irq_base = EMEV2_GPIO_IRQ(64),
245	.number_of_pins = 32,
246	};
247
248	static struct resource gio2_resources[] = {
249	[0] = {
250	.name = "GIO_064",
251	.start = 0xe0050100,
252	.end = 0xe005012b,
253	.flags = IORESOURCE_MEM,
254	},
255	[1] = {
256	.name = "GIO_064",
257	.start = 0xe0050140,
258	.end = 0xe005015f,
259	.flags = IORESOURCE_MEM,
260	},
261	[2] = {
262	.start = 103,
263	.flags = IORESOURCE_IRQ,
264	},
265	[3] = {
266	.start = 104,
267	.flags = IORESOURCE_IRQ,
268	},
269	};
270
271	static struct platform_device gio2_device = {
272	.name = "em_gio",
273	.id = 2,
274	.resource = gio2_resources,
275	.num_resources = ARRAY_SIZE(gio2_resources),
276	.dev = {
277	.platform_data = &gio2_config,
278	},
279	};
280
281	static struct gpio_em_config gio3_config = {
282	.gpio_base = 96,
283	.irq_base = EMEV2_GPIO_IRQ(96),
284	.number_of_pins = 32,
285	};
286
287	static struct resource gio3_resources[] = {
288	[0] = {
289	.name = "GIO_096",
290	.start = 0xe0050100,
291	.end = 0xe005012b,
292	.flags = IORESOURCE_MEM,
293	},
294	[1] = {
295	.name = "GIO_096",
296	.start = 0xe0050140,
297	.end = 0xe005015f,
298	.flags = IORESOURCE_MEM,
299	},
300	[2] = {
301	.start = 105,
302	.flags = IORESOURCE_IRQ,
303	},
304	[3] = {
305	.start = 106,
306	.flags = IORESOURCE_IRQ,
307	},
308	};
309
310	static struct platform_device gio3_device = {
311	.name = "em_gio",
312	.id = 3,
313	.resource = gio3_resources,
314	.num_resources = ARRAY_SIZE(gio3_resources),
315	.dev = {
316	.platform_data = &gio3_config,
317	},
318	};
319
320	static struct gpio_em_config gio4_config = {
321	.gpio_base = 128,
322	.irq_base = EMEV2_GPIO_IRQ(128),
323	.number_of_pins = 31,
324	};
325
326	static struct resource gio4_resources[] = {
327	[0] = {
328	.name = "GIO_128",
329	.start = 0xe0050200,
330	.end = 0xe005022b,
331	.flags = IORESOURCE_MEM,
332	},
333	[1] = {
334	.name = "GIO_128",
335	.start = 0xe0050240,
336	.end = 0xe005025f,
337	.flags = IORESOURCE_MEM,
338	},
339	[2] = {
340	.start = 107,
341	.flags = IORESOURCE_IRQ,
342	},
343	[3] = {
344	.start = 108,
345	.flags = IORESOURCE_IRQ,
346	},
347	};
348
349	static struct platform_device gio4_device = {
350	.name = "em_gio",
351	.id = 4,
352	.resource = gio4_resources,
353	.num_resources = ARRAY_SIZE(gio4_resources),
354	.dev = {
355	.platform_data = &gio4_config,
356	},
357	};
358
e433d444 TK	359	static struct resource pmu_resources[] = {
	360	[0] = {
	361	.start = 152,
	362	.end = 152,
	363	.flags = IORESOURCE_IRQ,
	364	},
	365	[1] = {
	366	.start = 153,
	367	.end = 153,
	368	.flags = IORESOURCE_IRQ,
	369	},
	370	};
	371
	372	static struct platform_device pmu_device = {
	373	.name = "arm-pmu",
	374	.id = -1,
	375	.num_resources = ARRAY_SIZE(pmu_resources),
	376	.resource = pmu_resources,
	377	};
	378
7f627f03 MD	379	static struct platform_device *emev2_early_devices[] __initdata = {
	380	&uart0_device,
	381	&uart1_device,
	382	&uart2_device,
	383	&uart3_device,
	384	};
	385
	386	static struct platform_device *emev2_late_devices[] __initdata = {
	387	&sti_device,
088efd92 MD	388	&gio0_device,
	389	&gio1_device,
	390	&gio2_device,
	391	&gio3_device,
	392	&gio4_device,
e433d444	393	&pmu_device,
7f627f03 MD	394	};
	395
	396	void __init emev2_add_standard_devices(void)
	397	{
	398	emev2_clock_init();
	399
	400	platform_add_devices(emev2_early_devices,
	401	ARRAY_SIZE(emev2_early_devices));
	402
	403	platform_add_devices(emev2_late_devices,
	404	ARRAY_SIZE(emev2_late_devices));
	405	}
	406
342ab874	407	static void __init emev2_init_delay(void)
7f627f03 MD	408	{
7f627f03 MD	409	shmobile_setup_delay(533, 1, 3); /* Cortex-A9 @ 533MHz */
3d5de271 MD	410	}
	411
	412	void __init emev2_add_early_devices(void)
	413	{
	414	emev2_init_delay();
7f627f03 MD	415
	416	early_platform_add_devices(emev2_early_devices,
	417	ARRAY_SIZE(emev2_early_devices));
	418
	419	/* setup early console here as well */
	420	shmobile_setup_console();
	421	}
	422
	423	void __init emev2_init_irq(void)
	424	{
	425	void __iomem *gic_dist_base;
	426	void __iomem *gic_cpu_base;
	427
	428	/* Static mappings, never released */
	429	gic_dist_base = ioremap(0xe0028000, PAGE_SIZE);
	430	gic_cpu_base = ioremap(0xe0020000, PAGE_SIZE);
	431	BUG_ON(!gic_dist_base \|\| !gic_cpu_base);
	432
	433	/* Use GIC to handle interrupts */
	434	gic_init(0, 29, gic_dist_base, gic_cpu_base);
	435	}
3d5de271 MD	436
	437	#ifdef CONFIG_USE_OF
	438	static const struct of_dev_auxdata emev2_auxdata_lookup[] __initconst = {
	439	{ }
	440	};
	441
342ab874	442	static void __init emev2_add_standard_devices_dt(void)
3d5de271 MD	443	{
	444	of_platform_populate(NULL, of_default_bus_match_table,
	445	emev2_auxdata_lookup, NULL);
	446	}
	447
3d5de271 MD	448	static const char *emev2_boards_compat_dt[] __initdata = {
	449	"renesas,emev2",
	450	NULL,
	451	};
	452
3d5de271	453	DT_MACHINE_START(EMEV2_DT, "Generic Emma Mobile EV2 (Flattened Device Tree)")
a62580e5	454	.smp = smp_ops(emev2_smp_ops),
3d5de271 MD	455	.init_early = emev2_init_delay,
3d5de271 MD	456	.nr_irqs = NR_IRQS_LEGACY,
0529e315	457	.init_irq = irqchip_init,
3d5de271	458	.init_machine = emev2_add_standard_devices_dt,
6bb27d73	459	.init_time = shmobile_timer_init,
3d5de271 MD	460	.dt_compat = emev2_boards_compat_dt,
	461	MACHINE_END
	462
	463	#endif /* CONFIG_USE_OF */