[deliverable/linux.git] / arch / arm / mach-ux500 / board-mop500.c

/*
 * Copyright (C) 2008-2009 ST-Ericsson
 *
 * Author: Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2, as
 * published by the Free Software Foundation.
 *
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/amba/bus.h>
#include <linux/amba/pl022.h>
#include <linux/spi/spi.h>
#include <linux/mfd/ab8500.h>
#include <linux/mfd/tc3589x.h>
#include <linux/leds-lp5521.h>
#include <linux/input.h>
#include <linux/gpio_keys.h>

#include <asm/mach-types.h>
#include <asm/mach/arch.h>

#include <plat/pincfg.h>
#include <plat/i2c.h>

#include <mach/hardware.h>
#include <mach/setup.h>
#include <mach/devices.h>
#include <mach/irqs.h>

#include "devices-db8500.h"
#include "pins-db8500.h"
#include "board-mop500.h"
#include "board-mop500-regulators.h"

static pin_cfg_t mop500_pins[] = {
	/* SSP0 */
	GPIO143_SSP0_CLK,
	GPIO144_SSP0_FRM,
	GPIO145_SSP0_RXD,
	GPIO146_SSP0_TXD,

	/* I2C */
	GPIO147_I2C0_SCL,
	GPIO148_I2C0_SDA,
	GPIO16_I2C1_SCL,
	GPIO17_I2C1_SDA,
	GPIO10_I2C2_SDA,
	GPIO11_I2C2_SCL,
	GPIO229_I2C3_SDA,
	GPIO230_I2C3_SCL,

	/* SKE keypad */
	GPIO153_KP_I7,
	GPIO154_KP_I6,
	GPIO155_KP_I5,
	GPIO156_KP_I4,
	GPIO157_KP_O7,
	GPIO158_KP_O6,
	GPIO159_KP_O5,
	GPIO160_KP_O4,
	GPIO161_KP_I3,
	GPIO162_KP_I2,
	GPIO163_KP_I1,
	GPIO164_KP_I0,
	GPIO165_KP_O3,
	GPIO166_KP_O2,
	GPIO167_KP_O1,
	GPIO168_KP_O0,

	/* GPIO_EXP_INT */
	GPIO217_GPIO,

	/* STMPE1601 IRQ */
	GPIO218_GPIO    | PIN_INPUT_PULLUP,

	/* touch screen */
	GPIO84_GPIO	| PIN_INPUT_PULLUP,
};

static struct ab8500_platform_data ab8500_platdata = {
	.irq_base	= MOP500_AB8500_IRQ_BASE,
	.regulator	= ab8500_regulators,
	.num_regulator	= ARRAY_SIZE(ab8500_regulators),
};

static struct resource ab8500_resources[] = {
	[0] = {
		.start	= IRQ_DB8500_AB8500,
		.end	= IRQ_DB8500_AB8500,
		.flags	= IORESOURCE_IRQ
	}
};

struct platform_device ab8500_device = {
	.name = "ab8500-i2c",
	.id = 0,
	.dev = {
		.platform_data = &ab8500_platdata,
	},
	.num_resources = 1,
	.resource = ab8500_resources,
};

static struct pl022_ssp_controller ssp0_platform_data = {
	.bus_id = 0,
	/* pl022 not yet supports dma */
	.enable_dma = 0,
	/* on this platform, gpio 31,142,144,214 &
	 * 224 are connected as chip selects
	 */
	.num_chipselect = 5,
};

/*
 * TC35892
 */

static void mop500_tc35892_init(struct tc3589x *tc3589x, unsigned int base)
{
	mop500_sdi_tc35892_init();
}

static struct tc3589x_gpio_platform_data mop500_tc35892_gpio_data = {
	.gpio_base	= MOP500_EGPIO(0),
	.setup		= mop500_tc35892_init,
};

static struct tc3589x_platform_data mop500_tc35892_data = {
	.block		= TC3589x_BLOCK_GPIO,
	.gpio		= &mop500_tc35892_gpio_data,
	.irq_base	= MOP500_EGPIO_IRQ_BASE,
};

static struct lp5521_led_config lp5521_pri_led[] = {
       [0] = {
	       .chan_nr = 0,
	       .led_current = 0x2f,
	       .max_current = 0x5f,
       },
       [1] = {
	       .chan_nr = 1,
	       .led_current = 0x2f,
	       .max_current = 0x5f,
       },
       [2] = {
	       .chan_nr = 2,
	       .led_current = 0x2f,
	       .max_current = 0x5f,
       },
};

static struct lp5521_platform_data __initdata lp5521_pri_data = {
       .label = "lp5521_pri",
       .led_config     = &lp5521_pri_led[0],
       .num_channels   = 3,
       .clock_mode     = LP5521_CLOCK_EXT,
};

static struct lp5521_led_config lp5521_sec_led[] = {
       [0] = {
	       .chan_nr = 0,
	       .led_current = 0x2f,
	       .max_current = 0x5f,
       },
       [1] = {
	       .chan_nr = 1,
	       .led_current = 0x2f,
	       .max_current = 0x5f,
       },
       [2] = {
	       .chan_nr = 2,
	       .led_current = 0x2f,
	       .max_current = 0x5f,
       },
};

static struct lp5521_platform_data __initdata lp5521_sec_data = {
       .label = "lp5521_sec",
       .led_config     = &lp5521_sec_led[0],
       .num_channels   = 3,
       .clock_mode     = LP5521_CLOCK_EXT,
};

static struct i2c_board_info mop500_i2c0_devices[] = {
	{
		I2C_BOARD_INFO("tc3589x", 0x42),
		.irq		= NOMADIK_GPIO_TO_IRQ(217),
		.platform_data  = &mop500_tc35892_data,
	},
};

static struct i2c_board_info __initdata mop500_i2c2_devices[] = {
	{
		/* lp5521 LED driver, 1st device */
		I2C_BOARD_INFO("lp5521", 0x33),
		.platform_data = &lp5521_pri_data,
	},
	{
		/* lp5521 LED driver, 2st device */
		I2C_BOARD_INFO("lp5521", 0x34),
		.platform_data = &lp5521_sec_data,
	},
};

#define U8500_I2C_CONTROLLER(id, _slsu, _tft, _rft, clk, _sm) \
static struct nmk_i2c_controller u8500_i2c##id##_data = { \
	/*				\
	 * slave data setup time, which is	\
	 * 250 ns,100ns,10ns which is 14,6,2	\
	 * respectively for a 48 Mhz	\
	 * i2c clock			\
	 */				\
	.slsu		= _slsu,	\
	/* Tx FIFO threshold */		\
	.tft		= _tft,		\
	/* Rx FIFO threshold */		\
	.rft		= _rft,		\
	/* std. mode operation */	\
	.clk_freq	= clk,		\
	.sm		= _sm,		\
}

/*
 * The board uses 4 i2c controllers, initialize all of
 * them with slave data setup time of 250 ns,
 * Tx & Rx FIFO threshold values as 1 and standard
 * mode of operation
 */
U8500_I2C_CONTROLLER(0, 0xe, 1, 1, 100000, I2C_FREQ_MODE_STANDARD);
U8500_I2C_CONTROLLER(1, 0xe, 1, 1, 100000, I2C_FREQ_MODE_STANDARD);
U8500_I2C_CONTROLLER(2,	0xe, 1, 1, 100000, I2C_FREQ_MODE_STANDARD);
U8500_I2C_CONTROLLER(3,	0xe, 1, 1, 100000, I2C_FREQ_MODE_STANDARD);

static void __init mop500_i2c_init(void)
{
	db8500_add_i2c0(&u8500_i2c0_data);
	db8500_add_i2c1(&u8500_i2c1_data);
	db8500_add_i2c2(&u8500_i2c2_data);
	db8500_add_i2c3(&u8500_i2c3_data);
}

static struct gpio_keys_button mop500_gpio_keys[] = {
	{
		.desc			= "SFH7741 Proximity Sensor",
		.type			= EV_SW,
		.code			= SW_FRONT_PROXIMITY,
		.gpio			= GPIO_PROX_SENSOR,
		.active_low		= 0,
		.can_disable		= 1,
	}
};

static struct regulator *prox_regulator;
static int mop500_prox_activate(struct device *dev);
static void mop500_prox_deactivate(struct device *dev);

static struct gpio_keys_platform_data mop500_gpio_keys_data = {
	.buttons	= mop500_gpio_keys,
	.nbuttons	= ARRAY_SIZE(mop500_gpio_keys),
	.enable		= mop500_prox_activate,
	.disable	= mop500_prox_deactivate,
};

static struct platform_device mop500_gpio_keys_device = {
	.name	= "gpio-keys",
	.id	= 0,
	.dev	= {
		.platform_data	= &mop500_gpio_keys_data,
	},
};

static int mop500_prox_activate(struct device *dev)
{
	prox_regulator = regulator_get(&mop500_gpio_keys_device.dev,
						"vcc");
	if (IS_ERR(prox_regulator)) {
		dev_err(&mop500_gpio_keys_device.dev,
			"no regulator\n");
		return PTR_ERR(prox_regulator);
	}
	regulator_enable(prox_regulator);
	return 0;
}

static void mop500_prox_deactivate(struct device *dev)
{
	regulator_disable(prox_regulator);
	regulator_put(prox_regulator);
}

/* add any platform devices here - TODO */
static struct platform_device *platform_devs[] __initdata = {
	&mop500_gpio_keys_device,
};

static void __init mop500_spi_init(void)
{
	db8500_add_ssp0(&ssp0_platform_data);
}

static void __init mop500_uart_init(void)
{
	db8500_add_uart0();
	db8500_add_uart1();
	db8500_add_uart2();
}

static void __init u8500_init_machine(void)
{
	u8500_init_devices();

	nmk_config_pins(mop500_pins, ARRAY_SIZE(mop500_pins));

	platform_add_devices(platform_devs, ARRAY_SIZE(platform_devs));

	mop500_i2c_init();
	mop500_sdi_init();
	mop500_spi_init();
	mop500_uart_init();

	platform_device_register(&ab8500_device);

	i2c_register_board_info(0, mop500_i2c0_devices,
				ARRAY_SIZE(mop500_i2c0_devices));
	i2c_register_board_info(2, mop500_i2c2_devices,
				ARRAY_SIZE(mop500_i2c2_devices));
}

MACHINE_START(U8500, "ST-Ericsson MOP500 platform")
	/* Maintainer: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com> */
	.boot_params	= 0x100,
	.map_io		= u8500_map_io,
	.init_irq	= ux500_init_irq,
	/* we re-use nomadik timer here */
	.timer		= &ux500_timer,
	.init_machine	= u8500_init_machine,
MACHINE_END
Commit	Line	Data
aa44ef4d SK	1	/*
	2	* Copyright (C) 2008-2009 ST-Ericsson
	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/kernel.h>
	12	#include <linux/init.h>
	13	#include <linux/interrupt.h>
	14	#include <linux/platform_device.h>
	15	#include <linux/io.h>
b8410a15	16	#include <linux/i2c.h>
ea05a57f	17	#include <linux/gpio.h>
aa44ef4d SK	18	#include <linux/amba/bus.h>
	19	#include <linux/amba/pl022.h>
	20	#include <linux/spi/spi.h>
39ae702c	21	#include <linux/mfd/ab8500.h>
20406ebf	22	#include <linux/mfd/tc3589x.h>
dd7b2a05	23	#include <linux/leds-lp5521.h>
a71b819b PL	24	#include <linux/input.h>
a71b819b PL	25	#include <linux/gpio_keys.h>
aa44ef4d	26
aa44ef4d SK	27	#include <asm/mach-types.h>
	28	#include <asm/mach/arch.h>
	29
ea05a57f	30	#include <plat/pincfg.h>
d48a41c1	31	#include <plat/i2c.h>
aa44ef4d SK	32
	33	#include <mach/hardware.h>
	34	#include <mach/setup.h>
9e4e7fe1	35	#include <mach/devices.h>
29aeb3cf	36	#include <mach/irqs.h>
aa44ef4d	37
fbf1eadf	38	#include "devices-db8500.h"
ea05a57f	39	#include "pins-db8500.h"
008f8a2f	40	#include "board-mop500.h"
a1e516e3	41	#include "board-mop500-regulators.h"
ea05a57f RV	42
	43	static pin_cfg_t mop500_pins[] = {
	44	/* SSP0 */
	45	GPIO143_SSP0_CLK,
	46	GPIO144_SSP0_FRM,
	47	GPIO145_SSP0_RXD,
	48	GPIO146_SSP0_TXD,
	49
	50	/* I2C */
	51	GPIO147_I2C0_SCL,
	52	GPIO148_I2C0_SDA,
	53	GPIO16_I2C1_SCL,
	54	GPIO17_I2C1_SDA,
	55	GPIO10_I2C2_SDA,
	56	GPIO11_I2C2_SCL,
	57	GPIO229_I2C3_SDA,
	58	GPIO230_I2C3_SCL,
4c61c845 SI	59
	60	/* SKE keypad */
	61	GPIO153_KP_I7,
	62	GPIO154_KP_I6,
	63	GPIO155_KP_I5,
	64	GPIO156_KP_I4,
	65	GPIO157_KP_O7,
	66	GPIO158_KP_O6,
	67	GPIO159_KP_O5,
	68	GPIO160_KP_O4,
	69	GPIO161_KP_I3,
	70	GPIO162_KP_I2,
	71	GPIO163_KP_I1,
	72	GPIO164_KP_I0,
	73	GPIO165_KP_O3,
	74	GPIO166_KP_O2,
	75	GPIO167_KP_O1,
	76	GPIO168_KP_O0,
b8410a15	77
556fb038 SI	78	/* GPIO_EXP_INT */
	79	GPIO217_GPIO,
	80
	81	/* STMPE1601 IRQ */
	82	GPIO218_GPIO \| PIN_INPUT_PULLUP,
71f933f4 SI	83
	84	/* touch screen */
	85	GPIO84_GPIO \| PIN_INPUT_PULLUP,
ea05a57f RV	86	};
ea05a57f RV	87
39ae702c RV	88	static struct ab8500_platform_data ab8500_platdata = {
39ae702c RV	89	.irq_base = MOP500_AB8500_IRQ_BASE,
a1e516e3 BJ	90	.regulator = ab8500_regulators,
a1e516e3 BJ	91	.num_regulator = ARRAY_SIZE(ab8500_regulators),
39ae702c RV	92	};
39ae702c RV	93
29aeb3cf LW	94	static struct resource ab8500_resources[] = {
29aeb3cf LW	95	[0] = {
22039b7c RV	96	.start = IRQ_DB8500_AB8500,
	97	.end = IRQ_DB8500_AB8500,
	98	.flags = IORESOURCE_IRQ
29aeb3cf LW	99	}
	100	};
	101
	102	struct platform_device ab8500_device = {
	103	.name = "ab8500-i2c",
	104	.id = 0,
	105	.dev = {
	106	.platform_data = &ab8500_platdata,
	107	},
	108	.num_resources = 1,
	109	.resource = ab8500_resources,
	110	};
	111
aa44ef4d SK	112	static struct pl022_ssp_controller ssp0_platform_data = {
	113	.bus_id = 0,
	114	/* pl022 not yet supports dma */
	115	.enable_dma = 0,
	116	/* on this platform, gpio 31,142,144,214 &
	117	* 224 are connected as chip selects
	118	*/
	119	.num_chipselect = 5,
	120	};
	121
b8410a15 RV	122	/*
	123	* TC35892
	124	*/
	125
20406ebf	126	static void mop500_tc35892_init(struct tc3589x *tc3589x, unsigned int base)
b8410a15 RV	127	{
	128	mop500_sdi_tc35892_init();
	129	}
	130
20406ebf	131	static struct tc3589x_gpio_platform_data mop500_tc35892_gpio_data = {
b8410a15 RV	132	.gpio_base = MOP500_EGPIO(0),
	133	.setup = mop500_tc35892_init,
	134	};
	135
20406ebf	136	static struct tc3589x_platform_data mop500_tc35892_data = {
611b7590	137	.block = TC3589x_BLOCK_GPIO,
b8410a15 RV	138	.gpio = &mop500_tc35892_gpio_data,
	139	.irq_base = MOP500_EGPIO_IRQ_BASE,
	140	};
	141
dd7b2a05 PL	142	static struct lp5521_led_config lp5521_pri_led[] = {
	143	[0] = {
	144	.chan_nr = 0,
	145	.led_current = 0x2f,
	146	.max_current = 0x5f,
	147	},
	148	[1] = {
	149	.chan_nr = 1,
	150	.led_current = 0x2f,
	151	.max_current = 0x5f,
	152	},
	153	[2] = {
	154	.chan_nr = 2,
	155	.led_current = 0x2f,
	156	.max_current = 0x5f,
	157	},
	158	};
	159
	160	static struct lp5521_platform_data __initdata lp5521_pri_data = {
	161	.label = "lp5521_pri",
	162	.led_config = &lp5521_pri_led[0],
	163	.num_channels = 3,
	164	.clock_mode = LP5521_CLOCK_EXT,
	165	};
	166
	167	static struct lp5521_led_config lp5521_sec_led[] = {
	168	[0] = {
	169	.chan_nr = 0,
	170	.led_current = 0x2f,
	171	.max_current = 0x5f,
	172	},
	173	[1] = {
	174	.chan_nr = 1,
	175	.led_current = 0x2f,
	176	.max_current = 0x5f,
	177	},
	178	[2] = {
	179	.chan_nr = 2,
	180	.led_current = 0x2f,
	181	.max_current = 0x5f,
	182	},
	183	};
	184
	185	static struct lp5521_platform_data __initdata lp5521_sec_data = {
	186	.label = "lp5521_sec",
	187	.led_config = &lp5521_sec_led[0],
	188	.num_channels = 3,
	189	.clock_mode = LP5521_CLOCK_EXT,
	190	};
	191
b8410a15 RV	192	static struct i2c_board_info mop500_i2c0_devices[] = {
b8410a15 RV	193	{
20406ebf	194	I2C_BOARD_INFO("tc3589x", 0x42),
dd7b2a05	195	.irq = NOMADIK_GPIO_TO_IRQ(217),
b8410a15 RV	196	.platform_data = &mop500_tc35892_data,
	197	},
	198	};
	199
dd7b2a05 PL	200	static struct i2c_board_info __initdata mop500_i2c2_devices[] = {
	201	{
	202	/* lp5521 LED driver, 1st device */
	203	I2C_BOARD_INFO("lp5521", 0x33),
	204	.platform_data = &lp5521_pri_data,
	205	},
	206	{
	207	/* lp5521 LED driver, 2st device */
	208	I2C_BOARD_INFO("lp5521", 0x34),
	209	.platform_data = &lp5521_sec_data,
	210	},
	211	};
	212
d48a41c1	213	#define U8500_I2C_CONTROLLER(id, _slsu, _tft, _rft, clk, _sm) \
f9faf237	214	static struct nmk_i2c_controller u8500_i2c##id##_data = { \
d48a41c1 SK	215	/* \
	216	* slave data setup time, which is \
	217	* 250 ns,100ns,10ns which is 14,6,2 \
	218	* respectively for a 48 Mhz \
	219	* i2c clock \
	220	*/ \
	221	.slsu = _slsu, \
	222	/* Tx FIFO threshold */ \
	223	.tft = _tft, \
	224	/* Rx FIFO threshold */ \
	225	.rft = _rft, \
	226	/* std. mode operation */ \
	227	.clk_freq = clk, \
	228	.sm = _sm, \
	229	}
	230
	231	/*
	232	* The board uses 4 i2c controllers, initialize all of
	233	* them with slave data setup time of 250 ns,
	234	* Tx & Rx FIFO threshold values as 1 and standard
	235	* mode of operation
	236	*/
	237	U8500_I2C_CONTROLLER(0, 0xe, 1, 1, 100000, I2C_FREQ_MODE_STANDARD);
	238	U8500_I2C_CONTROLLER(1, 0xe, 1, 1, 100000, I2C_FREQ_MODE_STANDARD);
	239	U8500_I2C_CONTROLLER(2, 0xe, 1, 1, 100000, I2C_FREQ_MODE_STANDARD);
	240	U8500_I2C_CONTROLLER(3, 0xe, 1, 1, 100000, I2C_FREQ_MODE_STANDARD);
	241
fbf1eadf RV	242	static void __init mop500_i2c_init(void)
	243	{
	244	db8500_add_i2c0(&u8500_i2c0_data);
	245	db8500_add_i2c1(&u8500_i2c1_data);
	246	db8500_add_i2c2(&u8500_i2c2_data);
	247	db8500_add_i2c3(&u8500_i2c3_data);
	248	}
aa44ef4d	249
a71b819b PL	250	static struct gpio_keys_button mop500_gpio_keys[] = {
	251	{
	252	.desc = "SFH7741 Proximity Sensor",
	253	.type = EV_SW,
	254	.code = SW_FRONT_PROXIMITY,
	255	.gpio = GPIO_PROX_SENSOR,
	256	.active_low = 0,
	257	.can_disable = 1,
	258	}
	259	};
	260
	261	static struct regulator *prox_regulator;
	262	static int mop500_prox_activate(struct device *dev);
	263	static void mop500_prox_deactivate(struct device *dev);
	264
	265	static struct gpio_keys_platform_data mop500_gpio_keys_data = {
	266	.buttons = mop500_gpio_keys,
	267	.nbuttons = ARRAY_SIZE(mop500_gpio_keys),
	268	.enable = mop500_prox_activate,
	269	.disable = mop500_prox_deactivate,
	270	};
	271
	272	static struct platform_device mop500_gpio_keys_device = {
	273	.name = "gpio-keys",
	274	.id = 0,
	275	.dev = {
	276	.platform_data = &mop500_gpio_keys_data,
	277	},
	278	};
	279
	280	static int mop500_prox_activate(struct device *dev)
	281	{
	282	prox_regulator = regulator_get(&mop500_gpio_keys_device.dev,
	283	"vcc");
	284	if (IS_ERR(prox_regulator)) {
	285	dev_err(&mop500_gpio_keys_device.dev,
	286	"no regulator\n");
	287	return PTR_ERR(prox_regulator);
	288	}
	289	regulator_enable(prox_regulator);
	290	return 0;
	291	}
	292
	293	static void mop500_prox_deactivate(struct device *dev)
	294	{
	295	regulator_disable(prox_regulator);
	296	regulator_put(prox_regulator);
	297	}
	298
d48a41c1 SK	299	/* add any platform devices here - TODO */
d48a41c1 SK	300	static struct platform_device *platform_devs[] __initdata = {
a71b819b	301	&mop500_gpio_keys_device,
d48a41c1 SK	302	};
d48a41c1 SK	303
fbf1eadf	304	static void __init mop500_spi_init(void)
aa44ef4d	305	{
fbf1eadf RV	306	db8500_add_ssp0(&ssp0_platform_data);
fbf1eadf RV	307	}
aa44ef4d	308
fbf1eadf RV	309	static void __init mop500_uart_init(void)
	310	{
	311	db8500_add_uart0();
	312	db8500_add_uart1();
	313	db8500_add_uart2();
	314	}
	315
	316	static void __init u8500_init_machine(void)
	317	{
ea05a57f RV	318	u8500_init_devices();
	319
	320	nmk_config_pins(mop500_pins, ARRAY_SIZE(mop500_pins));
	321
d48a41c1 SK	322	platform_add_devices(platform_devs, ARRAY_SIZE(platform_devs));
d48a41c1 SK	323
fbf1eadf	324	mop500_i2c_init();
008f8a2f	325	mop500_sdi_init();
fbf1eadf RV	326	mop500_spi_init();
fbf1eadf RV	327	mop500_uart_init();
008f8a2f	328
d5d22815	329	platform_device_register(&ab8500_device);
b8410a15 RV	330
	331	i2c_register_board_info(0, mop500_i2c0_devices,
	332	ARRAY_SIZE(mop500_i2c0_devices));
dd7b2a05 PL	333	i2c_register_board_info(2, mop500_i2c2_devices,
dd7b2a05 PL	334	ARRAY_SIZE(mop500_i2c2_devices));
aa44ef4d SK	335	}
	336
	337	MACHINE_START(U8500, "ST-Ericsson MOP500 platform")
	338	/* Maintainer: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com> */
aa44ef4d SK	339	.boot_params = 0x100,
aa44ef4d SK	340	.map_io = u8500_map_io,
178980f9	341	.init_irq = ux500_init_irq,
aa44ef4d	342	/* we re-use nomadik timer here */
41ac329f	343	.timer = &ux500_timer,
aa44ef4d SK	344	.init_machine = u8500_init_machine,
aa44ef4d SK	345	MACHINE_END