[mirror_ubuntu-jammy-kernel.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/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/of_irq.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>
#include <asm/hardware/gic.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 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,
};

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));
}

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 = {
	{ }
};

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

static const struct of_device_id emev2_dt_irq_match[] = {
	{ .compatible = "arm,cortex-a9-gic", .data = gic_of_init, },
	{},
};

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

void __init emev2_init_irq_dt(void)
{
	of_irq_init(emev2_dt_irq_match);
}

DT_MACHINE_START(EMEV2_DT, "Generic Emma Mobile EV2 (Flattened Device Tree)")
	.init_early	= emev2_init_delay,
	.nr_irqs	= NR_IRQS_LEGACY,
	.init_irq	= emev2_init_irq_dt,
	.handle_irq	= gic_handle_irq,
	.init_machine	= emev2_add_standard_devices_dt,
	.timer		= &shmobile_timer,
	.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>
	23	#include <linux/platform_device.h>
088efd92	24	#include <linux/platform_data/gpio-em.h>
3d5de271	25	#include <linux/of_platform.h>
7f627f03 MD	26	#include <linux/delay.h>
	27	#include <linux/input.h>
	28	#include <linux/io.h>
3d5de271	29	#include <linux/of_irq.h>
7f627f03 MD	30	#include <mach/hardware.h>
	31	#include <mach/common.h>
	32	#include <mach/emev2.h>
	33	#include <mach/irqs.h>
	34	#include <asm/mach-types.h>
	35	#include <asm/mach/arch.h>
	36	#include <asm/mach/map.h>
	37	#include <asm/mach/time.h>
	38	#include <asm/hardware/gic.h>
	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
7f627f03 MD	359	static struct platform_device *emev2_early_devices[] __initdata = {
	360	&uart0_device,
	361	&uart1_device,
	362	&uart2_device,
	363	&uart3_device,
	364	};
	365
	366	static struct platform_device *emev2_late_devices[] __initdata = {
	367	&sti_device,
088efd92 MD	368	&gio0_device,
	369	&gio1_device,
	370	&gio2_device,
	371	&gio3_device,
	372	&gio4_device,
7f627f03 MD	373	};
	374
	375	void __init emev2_add_standard_devices(void)
	376	{
	377	emev2_clock_init();
	378
	379	platform_add_devices(emev2_early_devices,
	380	ARRAY_SIZE(emev2_early_devices));
	381
	382	platform_add_devices(emev2_late_devices,
	383	ARRAY_SIZE(emev2_late_devices));
	384	}
	385
3d5de271	386	void __init emev2_init_delay(void)
7f627f03 MD	387	{
7f627f03 MD	388	shmobile_setup_delay(533, 1, 3); /* Cortex-A9 @ 533MHz */
3d5de271 MD	389	}
	390
	391	void __init emev2_add_early_devices(void)
	392	{
	393	emev2_init_delay();
7f627f03 MD	394
	395	early_platform_add_devices(emev2_early_devices,
	396	ARRAY_SIZE(emev2_early_devices));
	397
	398	/* setup early console here as well */
	399	shmobile_setup_console();
	400	}
	401
	402	void __init emev2_init_irq(void)
	403	{
	404	void __iomem *gic_dist_base;
	405	void __iomem *gic_cpu_base;
	406
	407	/* Static mappings, never released */
	408	gic_dist_base = ioremap(0xe0028000, PAGE_SIZE);
	409	gic_cpu_base = ioremap(0xe0020000, PAGE_SIZE);
	410	BUG_ON(!gic_dist_base \|\| !gic_cpu_base);
	411
	412	/* Use GIC to handle interrupts */
	413	gic_init(0, 29, gic_dist_base, gic_cpu_base);
	414	}
3d5de271 MD	415
	416	#ifdef CONFIG_USE_OF
	417	static const struct of_dev_auxdata emev2_auxdata_lookup[] __initconst = {
	418	{ }
	419	};
	420
	421	void __init emev2_add_standard_devices_dt(void)
	422	{
	423	of_platform_populate(NULL, of_default_bus_match_table,
	424	emev2_auxdata_lookup, NULL);
	425	}
	426
	427	static const struct of_device_id emev2_dt_irq_match[] = {
	428	{ .compatible = "arm,cortex-a9-gic", .data = gic_of_init, },
	429	{},
	430	};
	431
	432	static const char *emev2_boards_compat_dt[] __initdata = {
	433	"renesas,emev2",
	434	NULL,
	435	};
	436
	437	void __init emev2_init_irq_dt(void)
	438	{
	439	of_irq_init(emev2_dt_irq_match);
	440	}
	441
	442	DT_MACHINE_START(EMEV2_DT, "Generic Emma Mobile EV2 (Flattened Device Tree)")
	443	.init_early = emev2_init_delay,
	444	.nr_irqs = NR_IRQS_LEGACY,
	445	.init_irq = emev2_init_irq_dt,
	446	.handle_irq = gic_handle_irq,
	447	.init_machine = emev2_add_standard_devices_dt,
	448	.timer = &shmobile_timer,
	449	.dt_compat = emev2_boards_compat_dt,
	450	MACHINE_END
	451
	452	#endif /* CONFIG_USE_OF */