[deliverable/linux.git] / arch / arm / mach-omap2 / board-2430sdp.c

/*
 * linux/arch/arm/mach-omap2/board-2430sdp.c
 *
 * Copyright (C) 2006 Texas Instruments
 *
 * Modified from mach-omap2/board-generic.c
 *
 * Initial Code : Based on a patch from Komal Shah and Richard Woodruff
 * Updated the Code for 2430 SDP : Syed Mohammed Khasim
 *
 * 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/platform_device.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/mtd/physmap.h>
#include <linux/mmc/host.h>
#include <linux/delay.h>
#include <linux/i2c/twl.h>
#include <linux/regulator/machine.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/gpio.h>

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

#include <plat/board.h>
#include <plat/common.h>
#include <plat/gpmc.h>
#include <plat/usb.h>
#include <plat/gpmc-smc91x.h>

#include <video/omapdss.h>
#include <video/omap-panel-generic-dpi.h>

#include "mux.h"
#include "hsmmc.h"
#include "common-board-devices.h"

#define SDP2430_CS0_BASE	0x04000000
#define SECONDARY_LCD_GPIO		147

static struct mtd_partition sdp2430_partitions[] = {
	/* bootloader (U-Boot, etc) in first sector */
	{
		.name		= "bootloader",
		.offset		= 0,
		.size		= SZ_256K,
		.mask_flags	= MTD_WRITEABLE,	/* force read-only */
	 },
	/* bootloader params in the next sector */
	{
		.name		= "params",
		.offset		= MTDPART_OFS_APPEND,
		.size		= SZ_128K,
		.mask_flags	= 0,
	 },
	/* kernel */
	{
		.name		= "kernel",
		.offset		= MTDPART_OFS_APPEND,
		.size		= SZ_2M,
		.mask_flags	= 0
	},
	/* file system */
	{
		.name		= "filesystem",
		.offset		= MTDPART_OFS_APPEND,
		.size		= MTDPART_SIZ_FULL,
		.mask_flags	= 0
	}
};

static struct physmap_flash_data sdp2430_flash_data = {
	.width		= 2,
	.parts		= sdp2430_partitions,
	.nr_parts	= ARRAY_SIZE(sdp2430_partitions),
};

static struct resource sdp2430_flash_resource = {
	.start		= SDP2430_CS0_BASE,
	.end		= SDP2430_CS0_BASE + SZ_64M - 1,
	.flags		= IORESOURCE_MEM,
};

static struct platform_device sdp2430_flash_device = {
	.name		= "physmap-flash",
	.id		= 0,
	.dev = {
		.platform_data	= &sdp2430_flash_data,
	},
	.num_resources	= 1,
	.resource	= &sdp2430_flash_resource,
};

static struct platform_device *sdp2430_devices[] __initdata = {
	&sdp2430_flash_device,
};

/* LCD */
#define SDP2430_LCD_PANEL_BACKLIGHT_GPIO	91
#define SDP2430_LCD_PANEL_ENABLE_GPIO		154

static int sdp2430_panel_enable_lcd(struct omap_dss_device *dssdev)
{
	gpio_direction_output(SDP2430_LCD_PANEL_ENABLE_GPIO, 1);
	gpio_direction_output(SDP2430_LCD_PANEL_BACKLIGHT_GPIO, 1);

	return 0;
}

static void sdp2430_panel_disable_lcd(struct omap_dss_device *dssdev)
{
	gpio_direction_output(SDP2430_LCD_PANEL_ENABLE_GPIO, 0);
	gpio_direction_output(SDP2430_LCD_PANEL_BACKLIGHT_GPIO, 0);
}

static struct panel_generic_dpi_data sdp2430_panel_data = {
	.name			= "nec_nl2432dr22-11b",
	.platform_enable	= sdp2430_panel_enable_lcd,
	.platform_disable	= sdp2430_panel_disable_lcd,
};

static struct omap_dss_device sdp2430_lcd_device = {
	.name			= "lcd",
	.driver_name		= "generic_dpi_panel",
	.type			= OMAP_DISPLAY_TYPE_DPI,
	.phy.dpi.data_lines	= 16,
	.data			= &sdp2430_panel_data,
};

static struct omap_dss_device *sdp2430_dss_devices[] = {
	&sdp2430_lcd_device,
};

static struct omap_dss_board_info sdp2430_dss_data = {
	.num_devices	= ARRAY_SIZE(sdp2430_dss_devices),
	.devices	= sdp2430_dss_devices,
	.default_device	= &sdp2430_lcd_device,
};

static void __init sdp2430_display_init(void)
{
	int r;

	static struct gpio gpios[] __initdata = {
		{ SDP2430_LCD_PANEL_ENABLE_GPIO, GPIOF_OUT_INIT_LOW,
			"LCD reset" },
		{ SDP2430_LCD_PANEL_BACKLIGHT_GPIO, GPIOF_OUT_INIT_LOW,
			"LCD Backlight" },
	};

	r = gpio_request_array(gpios, ARRAY_SIZE(gpios));
	if (r) {
		pr_err("Cannot request LCD GPIOs, error %d\n", r);
		return;
	}

	omap_display_init(&sdp2430_dss_data);
}

#if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91x_MODULE)

static struct omap_smc91x_platform_data board_smc91x_data = {
	.cs		= 5,
	.gpio_irq	= 149,
	.flags		= GPMC_MUX_ADD_DATA | GPMC_TIMINGS_SMC91C96 |
				IORESOURCE_IRQ_LOWLEVEL,

};

static void __init board_smc91x_init(void)
{
	omap_mux_init_gpio(149, OMAP_PIN_INPUT);
	gpmc_smc91x_init(&board_smc91x_data);
}

#else

static inline void board_smc91x_init(void)
{
}

#endif

static void __init omap_2430sdp_init_early(void)
{
	omap2_init_common_infrastructure();
	omap2_init_common_devices(NULL, NULL);
}

static struct regulator_consumer_supply sdp2430_vmmc1_supplies[] = {
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
};

/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
static struct regulator_init_data sdp2430_vmmc1 = {
	.constraints = {
		.min_uV			= 1850000,
		.max_uV			= 3150000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= ARRAY_SIZE(sdp2430_vmmc1_supplies),
	.consumer_supplies	= &sdp2430_vmmc1_supplies[0],
};

static struct twl4030_gpio_platform_data sdp2430_gpio_data = {
	.gpio_base	= OMAP_MAX_GPIO_LINES,
	.irq_base	= TWL4030_GPIO_IRQ_BASE,
	.irq_end	= TWL4030_GPIO_IRQ_END,
};

static struct twl4030_platform_data sdp2430_twldata = {
	.irq_base	= TWL4030_IRQ_BASE,
	.irq_end	= TWL4030_IRQ_END,

	/* platform_data for children goes here */
	.gpio		= &sdp2430_gpio_data,
	.vmmc1		= &sdp2430_vmmc1,
};

static struct i2c_board_info __initdata sdp2430_i2c1_boardinfo[] = {
	{
		I2C_BOARD_INFO("isp1301_omap", 0x2D),
		.flags = I2C_CLIENT_WAKE,
		.irq = OMAP_GPIO_IRQ(78),
	},
};

static int __init omap2430_i2c_init(void)
{
	omap_register_i2c_bus(1, 100, sdp2430_i2c1_boardinfo,
			ARRAY_SIZE(sdp2430_i2c1_boardinfo));
	omap2_pmic_init("twl4030", &sdp2430_twldata);
	return 0;
}

static struct omap2_hsmmc_info mmc[] __initdata = {
	{
		.mmc		= 1,
		.caps		= MMC_CAP_4_BIT_DATA,
		.gpio_cd	= -EINVAL,
		.gpio_wp	= -EINVAL,
		.ext_clock	= 1,
	},
	{}	/* Terminator */
};

static struct omap_usb_config sdp2430_usb_config __initdata = {
	.otg		= 1,
#ifdef  CONFIG_USB_GADGET_OMAP
	.hmc_mode	= 0x0,
#elif   defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
	.hmc_mode	= 0x1,
#endif
	.pins[0]	= 3,
};

#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux board_mux[] __initdata = {
	{ .reg_offset = OMAP_MUX_TERMINATOR },
};
#endif

static void __init omap_2430sdp_init(void)
{
	omap2430_mux_init(board_mux, OMAP_PACKAGE_ZAC);

	omap2430_i2c_init();

	platform_add_devices(sdp2430_devices, ARRAY_SIZE(sdp2430_devices));
	omap_serial_init();
	omap2_hsmmc_init(mmc);
	omap2_usbfs_init(&sdp2430_usb_config);

	omap_mux_init_signal("usb0hs_stp", OMAP_PULL_ENA | OMAP_PULL_UP);
	usb_musb_init(NULL);

	board_smc91x_init();

	/* Turn off secondary LCD backlight */
	gpio_request_one(SECONDARY_LCD_GPIO, GPIOF_OUT_INIT_LOW,
			 "Secondary LCD backlight");

	sdp2430_display_init();
}

static void __init omap_2430sdp_map_io(void)
{
	omap2_set_globals_243x();
	omap243x_map_common_io();
}

MACHINE_START(OMAP_2430SDP, "OMAP2430 sdp2430 board")
	/* Maintainer: Syed Khasim - Texas Instruments Inc */
	.boot_params	= 0x80000100,
	.reserve	= omap_reserve,
	.map_io		= omap_2430sdp_map_io,
	.init_early	= omap_2430sdp_init_early,
	.init_irq	= omap2_init_irq,
	.init_machine	= omap_2430sdp_init,
	.timer		= &omap2_timer,
MACHINE_END
Commit	Line	Data
72d0f1c3 SMK	1	/*
	2	* linux/arch/arm/mach-omap2/board-2430sdp.c
	3	*
	4	* Copyright (C) 2006 Texas Instruments
	5	*
	6	* Modified from mach-omap2/board-generic.c
	7	*
	8	* Initial Code : Based on a patch from Komal Shah and Richard Woodruff
	9	* Updated the Code for 2430 SDP : Syed Mohammed Khasim
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License version 2 as
	13	* published by the Free Software Foundation.
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/init.h>
	18	#include <linux/platform_device.h>
	19	#include <linux/mtd/mtd.h>
	20	#include <linux/mtd/partitions.h>
561b036a	21	#include <linux/mtd/physmap.h>
3a63833e	22	#include <linux/mmc/host.h>
72d0f1c3	23	#include <linux/delay.h>
b07682b6	24	#include <linux/i2c/twl.h>
d3f02fc3	25	#include <linux/regulator/machine.h>
72d0f1c3 SMK	26	#include <linux/err.h>
72d0f1c3 SMK	27	#include <linux/clk.h>
fced80c7	28	#include <linux/io.h>
f9fa1bb9	29	#include <linux/gpio.h>
72d0f1c3	30
a09e64fb	31	#include <mach/hardware.h>
72d0f1c3 SMK	32	#include <asm/mach-types.h>
	33	#include <asm/mach/arch.h>
	34	#include <asm/mach/map.h>
72d0f1c3	35
ce491cf8 TL	36	#include <plat/board.h>
	37	#include <plat/common.h>
	38	#include <plat/gpmc.h>
	39	#include <plat/usb.h>
	40	#include <plat/gpmc-smc91x.h>
72d0f1c3	41
6e896ff9 TV	42	#include <video/omapdss.h>
	43	#include <video/omap-panel-generic-dpi.h>
	44
369ed78f	45	#include "mux.h"
d02a900b	46	#include "hsmmc.h"
fbd8071c	47	#include "common-board-devices.h"
72d0f1c3	48
a362fdbd	49	#define SDP2430_CS0_BASE 0x04000000
7d8e967f	50	#define SECONDARY_LCD_GPIO 147
a362fdbd	51
72d0f1c3 SMK	52	static struct mtd_partition sdp2430_partitions[] = {
	53	/* bootloader (U-Boot, etc) in first sector */
	54	{
	55	.name = "bootloader",
	56	.offset = 0,
	57	.size = SZ_256K,
	58	.mask_flags = MTD_WRITEABLE, /* force read-only */
	59	},
	60	/* bootloader params in the next sector */
	61	{
	62	.name = "params",
	63	.offset = MTDPART_OFS_APPEND,
	64	.size = SZ_128K,
	65	.mask_flags = 0,
	66	},
	67	/* kernel */
	68	{
	69	.name = "kernel",
	70	.offset = MTDPART_OFS_APPEND,
	71	.size = SZ_2M,
	72	.mask_flags = 0
	73	},
	74	/* file system */
	75	{
	76	.name = "filesystem",
	77	.offset = MTDPART_OFS_APPEND,
	78	.size = MTDPART_SIZ_FULL,
	79	.mask_flags = 0
	80	}
	81	};
	82
561b036a	83	static struct physmap_flash_data sdp2430_flash_data = {
72d0f1c3 SMK	84	.width = 2,
	85	.parts = sdp2430_partitions,
	86	.nr_parts = ARRAY_SIZE(sdp2430_partitions),
	87	};
	88
	89	static struct resource sdp2430_flash_resource = {
	90	.start = SDP2430_CS0_BASE,
	91	.end = SDP2430_CS0_BASE + SZ_64M - 1,
	92	.flags = IORESOURCE_MEM,
	93	};
	94
	95	static struct platform_device sdp2430_flash_device = {
561b036a	96	.name = "physmap-flash",
72d0f1c3 SMK	97	.id = 0,
	98	.dev = {
	99	.platform_data = &sdp2430_flash_data,
	100	},
	101	.num_resources = 1,
	102	.resource = &sdp2430_flash_resource,
	103	};
	104
72d0f1c3	105	static struct platform_device *sdp2430_devices[] __initdata = {
72d0f1c3	106	&sdp2430_flash_device,
6e896ff9 TV	107	};
	108
	109	/* LCD */
	110	#define SDP2430_LCD_PANEL_BACKLIGHT_GPIO 91
	111	#define SDP2430_LCD_PANEL_ENABLE_GPIO 154
	112
	113	static int sdp2430_panel_enable_lcd(struct omap_dss_device *dssdev)
	114	{
	115	gpio_direction_output(SDP2430_LCD_PANEL_ENABLE_GPIO, 1);
	116	gpio_direction_output(SDP2430_LCD_PANEL_BACKLIGHT_GPIO, 1);
	117
	118	return 0;
	119	}
	120
	121	static void sdp2430_panel_disable_lcd(struct omap_dss_device *dssdev)
	122	{
	123	gpio_direction_output(SDP2430_LCD_PANEL_ENABLE_GPIO, 0);
	124	gpio_direction_output(SDP2430_LCD_PANEL_BACKLIGHT_GPIO, 0);
	125	}
	126
	127	static struct panel_generic_dpi_data sdp2430_panel_data = {
	128	.name = "nec_nl2432dr22-11b",
	129	.platform_enable = sdp2430_panel_enable_lcd,
	130	.platform_disable = sdp2430_panel_disable_lcd,
	131	};
	132
	133	static struct omap_dss_device sdp2430_lcd_device = {
	134	.name = "lcd",
	135	.driver_name = "generic_dpi_panel",
	136	.type = OMAP_DISPLAY_TYPE_DPI,
	137	.phy.dpi.data_lines = 16,
	138	.data = &sdp2430_panel_data,
	139	};
	140
	141	static struct omap_dss_device *sdp2430_dss_devices[] = {
7d8e967f ID	142	&sdp2430_lcd_device,
	143	};
	144
6e896ff9 TV	145	static struct omap_dss_board_info sdp2430_dss_data = {
	146	.num_devices = ARRAY_SIZE(sdp2430_dss_devices),
	147	.devices = sdp2430_dss_devices,
	148	.default_device = &sdp2430_lcd_device,
72d0f1c3 SMK	149	};
72d0f1c3 SMK	150
6e896ff9 TV	151	static void __init sdp2430_display_init(void)
	152	{
	153	int r;
	154
	155	static struct gpio gpios[] __initdata = {
	156	{ SDP2430_LCD_PANEL_ENABLE_GPIO, GPIOF_OUT_INIT_LOW,
	157	"LCD reset" },
	158	{ SDP2430_LCD_PANEL_BACKLIGHT_GPIO, GPIOF_OUT_INIT_LOW,
	159	"LCD Backlight" },
	160	};
	161
	162	r = gpio_request_array(gpios, ARRAY_SIZE(gpios));
	163	if (r) {
	164	pr_err("Cannot request LCD GPIOs, error %d\n", r);
	165	return;
	166	}
	167
	168	omap_display_init(&sdp2430_dss_data);
	169	}
	170
1a48e157	171	#if defined(CONFIG_SMC91X) \|\| defined(CONFIG_SMC91x_MODULE)
72d0f1c3	172
1a48e157 TL	173	static struct omap_smc91x_platform_data board_smc91x_data = {
	174	.cs = 5,
	175	.gpio_irq = 149,
	176	.flags = GPMC_MUX_ADD_DATA \| GPMC_TIMINGS_SMC91C96 \|
	177	IORESOURCE_IRQ_LOWLEVEL,
44595982	178
1a48e157	179	};
72d0f1c3	180
1a48e157 TL	181	static void __init board_smc91x_init(void)
1a48e157 TL	182	{
25d6f630	183	omap_mux_init_gpio(149, OMAP_PIN_INPUT);
1a48e157 TL	184	gpmc_smc91x_init(&board_smc91x_data);
1a48e157 TL	185	}
72d0f1c3	186
1a48e157	187	#else
72d0f1c3	188
1a48e157 TL	189	static inline void board_smc91x_init(void)
1a48e157 TL	190	{
72d0f1c3 SMK	191	}
72d0f1c3 SMK	192
1a48e157 TL	193	#endif
1a48e157 TL	194
3dc3bad6	195	static void __init omap_2430sdp_init_early(void)
72d0f1c3	196	{
4805734b PW	197	omap2_init_common_infrastructure();
4805734b PW	198	omap2_init_common_devices(NULL, NULL);
72d0f1c3 SMK	199	}
72d0f1c3 SMK	200
d3f02fc3	201	static struct regulator_consumer_supply sdp2430_vmmc1_supplies[] = {
0005ae73	202	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
d3f02fc3 B	203	};
	204
	205	/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
	206	static struct regulator_init_data sdp2430_vmmc1 = {
	207	.constraints = {
	208	.min_uV = 1850000,
	209	.max_uV = 3150000,
	210	.valid_modes_mask = REGULATOR_MODE_NORMAL
	211	\| REGULATOR_MODE_STANDBY,
	212	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	213	\| REGULATOR_CHANGE_MODE
	214	\| REGULATOR_CHANGE_STATUS,
	215	},
	216	.num_consumer_supplies = ARRAY_SIZE(sdp2430_vmmc1_supplies),
	217	.consumer_supplies = &sdp2430_vmmc1_supplies[0],
	218	};
	219
90c62bf0 TL	220	static struct twl4030_gpio_platform_data sdp2430_gpio_data = {
	221	.gpio_base = OMAP_MAX_GPIO_LINES,
	222	.irq_base = TWL4030_GPIO_IRQ_BASE,
	223	.irq_end = TWL4030_GPIO_IRQ_END,
	224	};
	225
	226	static struct twl4030_platform_data sdp2430_twldata = {
	227	.irq_base = TWL4030_IRQ_BASE,
	228	.irq_end = TWL4030_IRQ_END,
	229
	230	/* platform_data for children goes here */
	231	.gpio = &sdp2430_gpio_data,
d3f02fc3	232	.vmmc1 = &sdp2430_vmmc1,
90c62bf0 TL	233	};
90c62bf0 TL	234
39ecc703 VM	235	static struct i2c_board_info __initdata sdp2430_i2c1_boardinfo[] = {
	236	{
	237	I2C_BOARD_INFO("isp1301_omap", 0x2D),
	238	.flags = I2C_CLIENT_WAKE,
	239	.irq = OMAP_GPIO_IRQ(78),
	240	},
	241	};
	242
90c62bf0 TL	243	static int __init omap2430_i2c_init(void)
90c62bf0 TL	244	{
39ecc703 VM	245	omap_register_i2c_bus(1, 100, sdp2430_i2c1_boardinfo,
39ecc703 VM	246	ARRAY_SIZE(sdp2430_i2c1_boardinfo));
fbd8071c	247	omap2_pmic_init("twl4030", &sdp2430_twldata);
90c62bf0 TL	248	return 0;
	249	}
	250
68ff0423	251	static struct omap2_hsmmc_info mmc[] __initdata = {
90c62bf0 TL	252	{
90c62bf0 TL	253	.mmc = 1,
3a63833e	254	.caps = MMC_CAP_4_BIT_DATA,
90c62bf0 TL	255	.gpio_cd = -EINVAL,
	256	.gpio_wp = -EINVAL,
	257	.ext_clock = 1,
	258	},
	259	{} /* Terminator */
	260	};
	261
9c68eb81 VM	262	static struct omap_usb_config sdp2430_usb_config __initdata = {
	263	.otg = 1,
	264	#ifdef CONFIG_USB_GADGET_OMAP
	265	.hmc_mode = 0x0,
	266	#elif defined(CONFIG_USB_OHCI_HCD) \|\| defined(CONFIG_USB_OHCI_HCD_MODULE)
	267	.hmc_mode = 0x1,
	268	#endif
	269	.pins[0] = 3,
	270	};
884b8369	271
369ed78f TL	272	#ifdef CONFIG_OMAP_MUX
	273	static struct omap_board_mux board_mux[] __initdata = {
	274	{ .reg_offset = OMAP_MUX_TERMINATOR },
	275	};
369ed78f TL	276	#endif
369ed78f TL	277
72d0f1c3 SMK	278	static void __init omap_2430sdp_init(void)
72d0f1c3 SMK	279	{
369ed78f TL	280	omap2430_mux_init(board_mux, OMAP_PACKAGE_ZAC);
369ed78f TL	281
90c62bf0 TL	282	omap2430_i2c_init();
90c62bf0 TL	283
72d0f1c3	284	platform_add_devices(sdp2430_devices, ARRAY_SIZE(sdp2430_devices));
72d0f1c3	285	omap_serial_init();
68ff0423	286	omap2_hsmmc_init(mmc);
b5e8905b	287	omap2_usbfs_init(&sdp2430_usb_config);
58310acd TL	288
58310acd TL	289	omap_mux_init_signal("usb0hs_stp", OMAP_PULL_ENA \| OMAP_PULL_UP);
9e18630b	290	usb_musb_init(NULL);
58310acd	291
1a48e157	292	board_smc91x_init();
7d8e967f ID	293
7d8e967f ID	294	/* Turn off secondary LCD backlight */
bc593f5d IG	295	gpio_request_one(SECONDARY_LCD_GPIO, GPIOF_OUT_INIT_LOW,
bc593f5d IG	296	"Secondary LCD backlight");
6e896ff9 TV	297
6e896ff9 TV	298	sdp2430_display_init();
72d0f1c3 SMK	299	}
	300
	301	static void __init omap_2430sdp_map_io(void)
	302	{
c8d2eb8e	303	omap2_set_globals_243x();
6fbd55d0	304	omap243x_map_common_io();
72d0f1c3 SMK	305	}
	306
	307	MACHINE_START(OMAP_2430SDP, "OMAP2430 sdp2430 board")
	308	/* Maintainer: Syed Khasim - Texas Instruments Inc */
72d0f1c3	309	.boot_params = 0x80000100,
71ee7dad	310	.reserve = omap_reserve,
3dc3bad6 RKAL	311	.map_io = omap_2430sdp_map_io,
3dc3bad6 RKAL	312	.init_early = omap_2430sdp_init_early,
741e3a89	313	.init_irq = omap2_init_irq,
72d0f1c3	314	.init_machine = omap_2430sdp_init,
e74984e4	315	.timer = &omap2_timer,
72d0f1c3	316	MACHINE_END