[linux-2.6-block.git] / arch / arm / mach-omap2 / board-3430sdp.c

/*
 * linux/arch/arm/mach-omap2/board-3430sdp.c
 *
 * Copyright (C) 2007 Texas Instruments
 *
 * Modified from mach-omap2/board-generic.c
 *
 * Initial code: 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/delay.h>
#include <linux/input.h>
#include <linux/input/matrix_keypad.h>
#include <linux/spi/spi.h>
#include <linux/spi/ads7846.h>
#include <linux/i2c/twl4030.h>
#include <linux/regulator/machine.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/mcspi.h>
#include <plat/mux.h>
#include <plat/board.h>
#include <plat/usb.h>
#include <plat/common.h>
#include <plat/dma.h>
#include <plat/gpmc.h>
#include <plat/display.h>

#include <plat/control.h>
#include <plat/gpmc-smc91x.h>

#include "mux.h"
#include "sdram-qimonda-hyb18m512160af-6.h"
#include "mmc-twl4030.h"

#define CONFIG_DISABLE_HFCLK 1

#define SDP3430_TS_GPIO_IRQ_SDPV1	3
#define SDP3430_TS_GPIO_IRQ_SDPV2	2

#define ENABLE_VAUX3_DEDICATED	0x03
#define ENABLE_VAUX3_DEV_GRP	0x20

#define TWL4030_MSECURE_GPIO 22

static int board_keymap[] = {
	KEY(0, 0, KEY_LEFT),
	KEY(0, 1, KEY_RIGHT),
	KEY(0, 2, KEY_A),
	KEY(0, 3, KEY_B),
	KEY(0, 4, KEY_C),
	KEY(1, 0, KEY_DOWN),
	KEY(1, 1, KEY_UP),
	KEY(1, 2, KEY_E),
	KEY(1, 3, KEY_F),
	KEY(1, 4, KEY_G),
	KEY(2, 0, KEY_ENTER),
	KEY(2, 1, KEY_I),
	KEY(2, 2, KEY_J),
	KEY(2, 3, KEY_K),
	KEY(2, 4, KEY_3),
	KEY(3, 0, KEY_M),
	KEY(3, 1, KEY_N),
	KEY(3, 2, KEY_O),
	KEY(3, 3, KEY_P),
	KEY(3, 4, KEY_Q),
	KEY(4, 0, KEY_R),
	KEY(4, 1, KEY_4),
	KEY(4, 2, KEY_T),
	KEY(4, 3, KEY_U),
	KEY(4, 4, KEY_D),
	KEY(5, 0, KEY_V),
	KEY(5, 1, KEY_W),
	KEY(5, 2, KEY_L),
	KEY(5, 3, KEY_S),
	KEY(5, 4, KEY_H),
	0
};

static struct matrix_keymap_data board_map_data = {
	.keymap			= board_keymap,
	.keymap_size		= ARRAY_SIZE(board_keymap),
};

static struct twl4030_keypad_data sdp3430_kp_data = {
	.keymap_data	= &board_map_data,
	.rows		= 5,
	.cols		= 6,
	.rep		= 1,
};

static int ts_gpio;	/* Needed for ads7846_get_pendown_state */

/**
 * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
 *
 * @return - void. If request gpio fails then Flag KERN_ERR.
 */
static void ads7846_dev_init(void)
{
	if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
		printk(KERN_ERR "can't get ads746 pen down GPIO\n");
		return;
	}

	gpio_direction_input(ts_gpio);

	omap_set_gpio_debounce(ts_gpio, 1);
	omap_set_gpio_debounce_time(ts_gpio, 0xa);
}

static int ads7846_get_pendown_state(void)
{
	return !gpio_get_value(ts_gpio);
}

static struct ads7846_platform_data tsc2046_config __initdata = {
	.get_pendown_state	= ads7846_get_pendown_state,
	.keep_vref_on		= 1,
};


static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
	.turbo_mode	= 0,
	.single_channel	= 1,	/* 0: slave, 1: master */
};

static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
	[0] = {
		/*
		 * TSC2046 operates at a max freqency of 2MHz, so
		 * operate slightly below at 1.5MHz
		 */
		.modalias		= "ads7846",
		.bus_num		= 1,
		.chip_select		= 0,
		.max_speed_hz		= 1500000,
		.controller_data	= &tsc2046_mcspi_config,
		.irq			= 0,
		.platform_data		= &tsc2046_config,
	},
};


#define SDP3430_LCD_PANEL_BACKLIGHT_GPIO	8
#define SDP3430_LCD_PANEL_ENABLE_GPIO		5

static unsigned backlight_gpio;
static unsigned enable_gpio;
static int lcd_enabled;
static int dvi_enabled;

static void __init sdp3430_display_init(void)
{
	int r;

	enable_gpio    = SDP3430_LCD_PANEL_ENABLE_GPIO;
	backlight_gpio = SDP3430_LCD_PANEL_BACKLIGHT_GPIO;

	r = gpio_request(enable_gpio, "LCD reset");
	if (r) {
		printk(KERN_ERR "failed to get LCD reset GPIO\n");
		goto err0;
	}

	r = gpio_request(backlight_gpio, "LCD Backlight");
	if (r) {
		printk(KERN_ERR "failed to get LCD backlight GPIO\n");
		goto err1;
	}

	gpio_direction_output(enable_gpio, 0);
	gpio_direction_output(backlight_gpio, 0);

	return;
err1:
	gpio_free(enable_gpio);
err0:
	return;
}

static int sdp3430_panel_enable_lcd(struct omap_dss_device *dssdev)
{
	if (dvi_enabled) {
		printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
		return -EINVAL;
	}

	gpio_direction_output(enable_gpio, 1);
	gpio_direction_output(backlight_gpio, 1);

	lcd_enabled = 1;

	return 0;
}

static void sdp3430_panel_disable_lcd(struct omap_dss_device *dssdev)
{
	lcd_enabled = 0;

	gpio_direction_output(enable_gpio, 0);
	gpio_direction_output(backlight_gpio, 0);
}

static int sdp3430_panel_enable_dvi(struct omap_dss_device *dssdev)
{
	if (lcd_enabled) {
		printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
		return -EINVAL;
	}

	dvi_enabled = 1;

	return 0;
}

static void sdp3430_panel_disable_dvi(struct omap_dss_device *dssdev)
{
	dvi_enabled = 0;
}

static int sdp3430_panel_enable_tv(struct omap_dss_device *dssdev)
{
	return 0;
}

static void sdp3430_panel_disable_tv(struct omap_dss_device *dssdev)
{
}


static struct omap_dss_device sdp3430_lcd_device = {
	.name			= "lcd",
	.driver_name		= "sharp_ls_panel",
	.type			= OMAP_DISPLAY_TYPE_DPI,
	.phy.dpi.data_lines	= 16,
	.platform_enable	= sdp3430_panel_enable_lcd,
	.platform_disable	= sdp3430_panel_disable_lcd,
};

static struct omap_dss_device sdp3430_dvi_device = {
	.name			= "dvi",
	.driver_name		= "generic_panel",
	.type			= OMAP_DISPLAY_TYPE_DPI,
	.phy.dpi.data_lines	= 24,
	.platform_enable	= sdp3430_panel_enable_dvi,
	.platform_disable	= sdp3430_panel_disable_dvi,
};

static struct omap_dss_device sdp3430_tv_device = {
	.name			= "tv",
	.driver_name		= "venc",
	.type			= OMAP_DISPLAY_TYPE_VENC,
	.phy.venc.type		= OMAP_DSS_VENC_TYPE_SVIDEO,
	.platform_enable	= sdp3430_panel_enable_tv,
	.platform_disable	= sdp3430_panel_disable_tv,
};


static struct omap_dss_device *sdp3430_dss_devices[] = {
	&sdp3430_lcd_device,
	&sdp3430_dvi_device,
	&sdp3430_tv_device,
};

static struct omap_dss_board_info sdp3430_dss_data = {
	.num_devices	= ARRAY_SIZE(sdp3430_dss_devices),
	.devices	= sdp3430_dss_devices,
	.default_device	= &sdp3430_lcd_device,
};

static struct platform_device sdp3430_dss_device = {
	.name		= "omapdss",
	.id		= -1,
	.dev		= {
		.platform_data = &sdp3430_dss_data,
	},
};

static struct regulator_consumer_supply sdp3430_vdda_dac_supply = {
	.supply		= "vdda_dac",
	.dev		= &sdp3430_dss_device.dev,
};

static struct platform_device *sdp3430_devices[] __initdata = {
	&sdp3430_dss_device,
};

static struct omap_board_config_kernel sdp3430_config[] __initdata = {
};

static void __init omap_3430sdp_init_irq(void)
{
	omap_board_config = sdp3430_config;
	omap_board_config_size = ARRAY_SIZE(sdp3430_config);
	omap2_init_common_hw(hyb18m512160af6_sdrc_params, NULL);
	omap_init_irq();
	omap_gpio_init();
}

static int sdp3430_batt_table[] = {
/* 0 C*/
30800, 29500, 28300, 27100,
26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
11600, 11200, 10800, 10400, 10000, 9630,   9280,   8950,   8620,   8310,
8020,   7730,   7460,   7200,   6950,   6710,   6470,   6250,   6040,   5830,
5640,   5450,   5260,   5090,   4920,   4760,   4600,   4450,   4310,   4170,
4040,   3910,   3790,   3670,   3550
};

static struct twl4030_bci_platform_data sdp3430_bci_data = {
	.battery_tmp_tbl	= sdp3430_batt_table,
	.tblsize		= ARRAY_SIZE(sdp3430_batt_table),
};

static struct twl4030_hsmmc_info mmc[] = {
	{
		.mmc		= 1,
		/* 8 bits (default) requires S6.3 == ON,
		 * so the SIM card isn't used; else 4 bits.
		 */
		.wires		= 8,
		.gpio_wp	= 4,
	},
	{
		.mmc		= 2,
		.wires		= 8,
		.gpio_wp	= 7,
	},
	{}	/* Terminator */
};

static struct regulator_consumer_supply sdp3430_vmmc1_supply = {
	.supply			= "vmmc",
};

static struct regulator_consumer_supply sdp3430_vsim_supply = {
	.supply			= "vmmc_aux",
};

static struct regulator_consumer_supply sdp3430_vmmc2_supply = {
	.supply			= "vmmc",
};

static int sdp3430_twl_gpio_setup(struct device *dev,
		unsigned gpio, unsigned ngpio)
{
	/* gpio + 0 is "mmc0_cd" (input/IRQ),
	 * gpio + 1 is "mmc1_cd" (input/IRQ)
	 */
	mmc[0].gpio_cd = gpio + 0;
	mmc[1].gpio_cd = gpio + 1;
	twl4030_mmc_init(mmc);

	/* link regulators to MMC adapters ... we "know" the
	 * regulators will be set up only *after* we return.
	 */
	sdp3430_vmmc1_supply.dev = mmc[0].dev;
	sdp3430_vsim_supply.dev = mmc[0].dev;
	sdp3430_vmmc2_supply.dev = mmc[1].dev;

	/* gpio + 7 is "sub_lcd_en_bkl" (output/PWM1) */
	gpio_request(gpio + 7, "sub_lcd_en_bkl");
	gpio_direction_output(gpio + 7, 0);

	/* gpio + 15 is "sub_lcd_nRST" (output) */
	gpio_request(gpio + 15, "sub_lcd_nRST");
	gpio_direction_output(gpio + 15, 0);

	return 0;
}

static struct twl4030_gpio_platform_data sdp3430_gpio_data = {
	.gpio_base	= OMAP_MAX_GPIO_LINES,
	.irq_base	= TWL4030_GPIO_IRQ_BASE,
	.irq_end	= TWL4030_GPIO_IRQ_END,
	.pulldowns	= BIT(2) | BIT(6) | BIT(8) | BIT(13)
				| BIT(16) | BIT(17),
	.setup		= sdp3430_twl_gpio_setup,
};

static struct twl4030_usb_data sdp3430_usb_data = {
	.usb_mode	= T2_USB_MODE_ULPI,
};

static struct twl4030_madc_platform_data sdp3430_madc_data = {
	.irq_line	= 1,
};

/*
 * Apply all the fixed voltages since most versions of U-Boot
 * don't bother with that initialization.
 */

/* VAUX1 for mainboard (irda and sub-lcd) */
static struct regulator_init_data sdp3430_vaux1 = {
	.constraints = {
		.min_uV			= 2800000,
		.max_uV			= 2800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

/* VAUX2 for camera module */
static struct regulator_init_data sdp3430_vaux2 = {
	.constraints = {
		.min_uV			= 2800000,
		.max_uV			= 2800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

/* VAUX3 for LCD board */
static struct regulator_init_data sdp3430_vaux3 = {
	.constraints = {
		.min_uV			= 2800000,
		.max_uV			= 2800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

/* VAUX4 for OMAP VDD_CSI2 (camera) */
static struct regulator_init_data sdp3430_vaux4 = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
static struct regulator_init_data sdp3430_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	= 1,
	.consumer_supplies	= &sdp3430_vmmc1_supply,
};

/* VMMC2 for MMC2 card */
static struct regulator_init_data sdp3430_vmmc2 = {
	.constraints = {
		.min_uV			= 1850000,
		.max_uV			= 1850000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= 1,
	.consumer_supplies	= &sdp3430_vmmc2_supply,
};

/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
static struct regulator_init_data sdp3430_vsim = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 3000000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= 1,
	.consumer_supplies	= &sdp3430_vsim_supply,
};

/* VDAC for DSS driving S-Video */
static struct regulator_init_data sdp3430_vdac = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= 1,
	.consumer_supplies	= &sdp3430_vdda_dac_supply,
};

/* VPLL2 for digital video outputs */
static struct regulator_consumer_supply sdp3430_vpll2_supplies[] = {
	{
		.supply		= "vdvi",
		.dev		= &sdp3430_lcd_device.dev,
	},
	{
		.supply		= "vdds_dsi",
		.dev		= &sdp3430_dss_device.dev,
	}
};

static struct regulator_init_data sdp3430_vpll2 = {
	.constraints = {
		.name			= "VDVI",
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= ARRAY_SIZE(sdp3430_vpll2_supplies),
	.consumer_supplies	= sdp3430_vpll2_supplies,
};

static struct twl4030_codec_audio_data sdp3430_audio = {
	.audio_mclk = 26000000,
};

static struct twl4030_codec_data sdp3430_codec = {
	.audio_mclk = 26000000,
	.audio = &sdp3430_audio,
};

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

	/* platform_data for children goes here */
	.bci		= &sdp3430_bci_data,
	.gpio		= &sdp3430_gpio_data,
	.madc		= &sdp3430_madc_data,
	.keypad		= &sdp3430_kp_data,
	.usb		= &sdp3430_usb_data,
	.codec		= &sdp3430_codec,

	.vaux1		= &sdp3430_vaux1,
	.vaux2		= &sdp3430_vaux2,
	.vaux3		= &sdp3430_vaux3,
	.vaux4		= &sdp3430_vaux4,
	.vmmc1		= &sdp3430_vmmc1,
	.vmmc2		= &sdp3430_vmmc2,
	.vsim		= &sdp3430_vsim,
	.vdac		= &sdp3430_vdac,
	.vpll2		= &sdp3430_vpll2,
};

static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
	{
		I2C_BOARD_INFO("twl4030", 0x48),
		.flags = I2C_CLIENT_WAKE,
		.irq = INT_34XX_SYS_NIRQ,
		.platform_data = &sdp3430_twldata,
	},
};

static int __init omap3430_i2c_init(void)
{
	/* i2c1 for PMIC only */
	omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
			ARRAY_SIZE(sdp3430_i2c_boardinfo));
	/* i2c2 on camera connector (for sensor control) and optional isp1301 */
	omap_register_i2c_bus(2, 400, NULL, 0);
	/* i2c3 on display connector (for DVI, tfp410) */
	omap_register_i2c_bus(3, 400, NULL, 0);
	return 0;
}

#if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE)

static struct omap_smc91x_platform_data board_smc91x_data = {
	.cs		= 3,
	.flags		= GPMC_MUX_ADD_DATA | GPMC_TIMINGS_SMC91C96 |
				IORESOURCE_IRQ_LOWLEVEL,
};

static void __init board_smc91x_init(void)
{
	if (omap_rev() > OMAP3430_REV_ES1_0)
		board_smc91x_data.gpio_irq = 6;
	else
		board_smc91x_data.gpio_irq = 29;

	gpmc_smc91x_init(&board_smc91x_data);
}

#else

static inline void board_smc91x_init(void)
{
}

#endif

static void enable_board_wakeup_source(void)
{
	omap_cfg_reg(AF26_34XX_SYS_NIRQ); /* T2 interrupt line (keypad) */
}

static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {

	.port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
	.port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
	.port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,

	.phy_reset  = true,
	.reset_gpio_port[0]  = 57,
	.reset_gpio_port[1]  = 61,
	.reset_gpio_port[2]  = -EINVAL
};

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

static void __init omap_3430sdp_init(void)
{
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
	omap3430_i2c_init();
	platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
	if (omap_rev() > OMAP3430_REV_ES1_0)
		ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV2;
	else
		ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV1;
	sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
	spi_register_board_info(sdp3430_spi_board_info,
				ARRAY_SIZE(sdp3430_spi_board_info));
	ads7846_dev_init();
	omap_serial_init();
	usb_musb_init();
	board_smc91x_init();
	sdp3430_display_init();
	enable_board_wakeup_source();
	usb_ehci_init(&ehci_pdata);
}

static void __init omap_3430sdp_map_io(void)
{
	omap2_set_globals_343x();
	omap2_map_common_io();
}

MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
	/* Maintainer: Syed Khasim - Texas Instruments Inc */
	.phys_io	= 0x48000000,
	.io_pg_offst	= ((0xfa000000) >> 18) & 0xfffc,
	.boot_params	= 0x80000100,
	.map_io		= omap_3430sdp_map_io,
	.init_irq	= omap_3430sdp_init_irq,
	.init_machine	= omap_3430sdp_init,
	.timer		= &omap_timer,
MACHINE_END
Commit	Line	Data
6fdc29e2 SMK	1	/*
	2	* linux/arch/arm/mach-omap2/board-3430sdp.c
	3	*
	4	* Copyright (C) 2007 Texas Instruments
	5	*
	6	* Modified from mach-omap2/board-generic.c
	7	*
	8	* Initial code: Syed Mohammed Khasim
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/delay.h>
	19	#include <linux/input.h>
6135434a	20	#include <linux/input/matrix_keypad.h>
6fdc29e2 SMK	21	#include <linux/spi/spi.h>
	22	#include <linux/spi/ads7846.h>
	23	#include <linux/i2c/twl4030.h>
	24	#include <linux/regulator/machine.h>
	25	#include <linux/io.h>
	26	#include <linux/gpio.h>
	27
	28	#include <mach/hardware.h>
	29	#include <asm/mach-types.h>
	30	#include <asm/mach/arch.h>
	31	#include <asm/mach/map.h>
	32
ce491cf8 TL	33	#include <plat/mcspi.h>
	34	#include <plat/mux.h>
	35	#include <plat/board.h>
	36	#include <plat/usb.h>
	37	#include <plat/common.h>
	38	#include <plat/dma.h>
	39	#include <plat/gpmc.h>
d9056ce2	40	#include <plat/display.h>
6fdc29e2	41
ce491cf8	42	#include <plat/control.h>
ce491cf8	43	#include <plat/gpmc-smc91x.h>
6fdc29e2	44
ca5742bd	45	#include "mux.h"
17a722ca	46	#include "sdram-qimonda-hyb18m512160af-6.h"
6fdc29e2 SMK	47	#include "mmc-twl4030.h"
	48
	49	#define CONFIG_DISABLE_HFCLK 1
	50
6fdc29e2 SMK	51	#define SDP3430_TS_GPIO_IRQ_SDPV1 3
	52	#define SDP3430_TS_GPIO_IRQ_SDPV2 2
	53
	54	#define ENABLE_VAUX3_DEDICATED 0x03
	55	#define ENABLE_VAUX3_DEV_GRP 0x20
	56
	57	#define TWL4030_MSECURE_GPIO 22
	58
4f543332	59	static int board_keymap[] = {
6fdc29e2 SMK	60	KEY(0, 0, KEY_LEFT),
	61	KEY(0, 1, KEY_RIGHT),
	62	KEY(0, 2, KEY_A),
	63	KEY(0, 3, KEY_B),
	64	KEY(0, 4, KEY_C),
	65	KEY(1, 0, KEY_DOWN),
	66	KEY(1, 1, KEY_UP),
	67	KEY(1, 2, KEY_E),
	68	KEY(1, 3, KEY_F),
	69	KEY(1, 4, KEY_G),
	70	KEY(2, 0, KEY_ENTER),
	71	KEY(2, 1, KEY_I),
	72	KEY(2, 2, KEY_J),
	73	KEY(2, 3, KEY_K),
	74	KEY(2, 4, KEY_3),
	75	KEY(3, 0, KEY_M),
	76	KEY(3, 1, KEY_N),
	77	KEY(3, 2, KEY_O),
	78	KEY(3, 3, KEY_P),
	79	KEY(3, 4, KEY_Q),
	80	KEY(4, 0, KEY_R),
	81	KEY(4, 1, KEY_4),
	82	KEY(4, 2, KEY_T),
	83	KEY(4, 3, KEY_U),
	84	KEY(4, 4, KEY_D),
	85	KEY(5, 0, KEY_V),
	86	KEY(5, 1, KEY_W),
	87	KEY(5, 2, KEY_L),
	88	KEY(5, 3, KEY_S),
	89	KEY(5, 4, KEY_H),
	90	0
	91	};
	92
4f543332 TL	93	static struct matrix_keymap_data board_map_data = {
	94	.keymap = board_keymap,
	95	.keymap_size = ARRAY_SIZE(board_keymap),
	96	};
	97
6fdc29e2	98	static struct twl4030_keypad_data sdp3430_kp_data = {
4f543332	99	.keymap_data = &board_map_data,
6fdc29e2 SMK	100	.rows = 5,
6fdc29e2 SMK	101	.cols = 6,
6fdc29e2 SMK	102	.rep = 1,
	103	};
	104
	105	static int ts_gpio; /* Needed for ads7846_get_pendown_state */
	106
	107	/**
	108	* @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
	109	*
	110	* @return - void. If request gpio fails then Flag KERN_ERR.
	111	*/
	112	static void ads7846_dev_init(void)
	113	{
	114	if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
	115	printk(KERN_ERR "can't get ads746 pen down GPIO\n");
	116	return;
	117	}
	118
	119	gpio_direction_input(ts_gpio);
	120
	121	omap_set_gpio_debounce(ts_gpio, 1);
	122	omap_set_gpio_debounce_time(ts_gpio, 0xa);
	123	}
	124
	125	static int ads7846_get_pendown_state(void)
	126	{
	127	return !gpio_get_value(ts_gpio);
	128	}
	129
	130	static struct ads7846_platform_data tsc2046_config __initdata = {
	131	.get_pendown_state = ads7846_get_pendown_state,
	132	.keep_vref_on = 1,
	133	};
	134
	135
	136	static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
	137	.turbo_mode = 0,
	138	.single_channel = 1, /* 0: slave, 1: master */
	139	};
	140
	141	static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
	142	[0] = {
	143	/*
	144	* TSC2046 operates at a max freqency of 2MHz, so
	145	* operate slightly below at 1.5MHz
	146	*/
	147	.modalias = "ads7846",
	148	.bus_num = 1,
	149	.chip_select = 0,
	150	.max_speed_hz = 1500000,
	151	.controller_data = &tsc2046_mcspi_config,
	152	.irq = 0,
	153	.platform_data = &tsc2046_config,
	154	},
	155	};
	156
d9056ce2 TV	157
	158	#define SDP3430_LCD_PANEL_BACKLIGHT_GPIO 8
	159	#define SDP3430_LCD_PANEL_ENABLE_GPIO 5
	160
	161	static unsigned backlight_gpio;
	162	static unsigned enable_gpio;
	163	static int lcd_enabled;
	164	static int dvi_enabled;
	165
	166	static void __init sdp3430_display_init(void)
	167	{
	168	int r;
	169
	170	enable_gpio = SDP3430_LCD_PANEL_ENABLE_GPIO;
	171	backlight_gpio = SDP3430_LCD_PANEL_BACKLIGHT_GPIO;
	172
	173	r = gpio_request(enable_gpio, "LCD reset");
	174	if (r) {
	175	printk(KERN_ERR "failed to get LCD reset GPIO\n");
	176	goto err0;
	177	}
	178
	179	r = gpio_request(backlight_gpio, "LCD Backlight");
	180	if (r) {
	181	printk(KERN_ERR "failed to get LCD backlight GPIO\n");
	182	goto err1;
	183	}
	184
	185	gpio_direction_output(enable_gpio, 0);
	186	gpio_direction_output(backlight_gpio, 0);
	187
	188	return;
	189	err1:
	190	gpio_free(enable_gpio);
	191	err0:
	192	return;
	193	}
	194
	195	static int sdp3430_panel_enable_lcd(struct omap_dss_device *dssdev)
	196	{
	197	if (dvi_enabled) {
	198	printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
	199	return -EINVAL;
	200	}
	201
	202	gpio_direction_output(enable_gpio, 1);
	203	gpio_direction_output(backlight_gpio, 1);
	204
	205	lcd_enabled = 1;
	206
	207	return 0;
	208	}
	209
	210	static void sdp3430_panel_disable_lcd(struct omap_dss_device *dssdev)
	211	{
	212	lcd_enabled = 0;
	213
	214	gpio_direction_output(enable_gpio, 0);
	215	gpio_direction_output(backlight_gpio, 0);
	216	}
	217
	218	static int sdp3430_panel_enable_dvi(struct omap_dss_device *dssdev)
	219	{
	220	if (lcd_enabled) {
221	printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
222	return -EINVAL;
223	}
224
225	dvi_enabled = 1;
226
227	return 0;
228	}
229
230	static void sdp3430_panel_disable_dvi(struct omap_dss_device *dssdev)
231	{
232	dvi_enabled = 0;
233	}
234
235	static int sdp3430_panel_enable_tv(struct omap_dss_device *dssdev)
236	{
237	return 0;
238	}
239
240	static void sdp3430_panel_disable_tv(struct omap_dss_device *dssdev)
241	{
242	}
243
244
245	static struct omap_dss_device sdp3430_lcd_device = {
246	.name = "lcd",
247	.driver_name = "sharp_ls_panel",
248	.type = OMAP_DISPLAY_TYPE_DPI,
249	.phy.dpi.data_lines = 16,
250	.platform_enable = sdp3430_panel_enable_lcd,
251	.platform_disable = sdp3430_panel_disable_lcd,
6fdc29e2 SMK	252	};
6fdc29e2 SMK	253
d9056ce2 TV	254	static struct omap_dss_device sdp3430_dvi_device = {
	255	.name = "dvi",
	256	.driver_name = "generic_panel",
	257	.type = OMAP_DISPLAY_TYPE_DPI,
	258	.phy.dpi.data_lines = 24,
	259	.platform_enable = sdp3430_panel_enable_dvi,
	260	.platform_disable = sdp3430_panel_disable_dvi,
6fdc29e2 SMK	261	};
6fdc29e2 SMK	262
d9056ce2 TV	263	static struct omap_dss_device sdp3430_tv_device = {
	264	.name = "tv",
	265	.driver_name = "venc",
	266	.type = OMAP_DISPLAY_TYPE_VENC,
	267	.phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
	268	.platform_enable = sdp3430_panel_enable_tv,
	269	.platform_disable = sdp3430_panel_disable_tv,
6fdc29e2 SMK	270	};
6fdc29e2 SMK	271
d9056ce2 TV	272
d9056ce2 TV	273	static struct omap_dss_device *sdp3430_dss_devices[] = {
6fdc29e2	274	&sdp3430_lcd_device,
d9056ce2 TV	275	&sdp3430_dvi_device,
d9056ce2 TV	276	&sdp3430_tv_device,
6fdc29e2 SMK	277	};
6fdc29e2 SMK	278
d9056ce2 TV	279	static struct omap_dss_board_info sdp3430_dss_data = {
	280	.num_devices = ARRAY_SIZE(sdp3430_dss_devices),
	281	.devices = sdp3430_dss_devices,
	282	.default_device = &sdp3430_lcd_device,
	283	};
	284
	285	static struct platform_device sdp3430_dss_device = {
	286	.name = "omapdss",
	287	.id = -1,
	288	.dev = {
	289	.platform_data = &sdp3430_dss_data,
	290	},
	291	};
	292
	293	static struct regulator_consumer_supply sdp3430_vdda_dac_supply = {
	294	.supply = "vdda_dac",
	295	.dev = &sdp3430_dss_device.dev,
	296	};
	297
	298	static struct platform_device *sdp3430_devices[] __initdata = {
	299	&sdp3430_dss_device,
6fdc29e2 SMK	300	};
	301
	302	static struct omap_board_config_kernel sdp3430_config[] __initdata = {
6fdc29e2 SMK	303	};
6fdc29e2 SMK	304
b3c6df3a PW	305	static void __init omap_3430sdp_init_irq(void)
	306	{
	307	omap_board_config = sdp3430_config;
	308	omap_board_config_size = ARRAY_SIZE(sdp3430_config);
	309	omap2_init_common_hw(hyb18m512160af6_sdrc_params, NULL);
	310	omap_init_irq();
	311	omap_gpio_init();
	312	}
	313
6fdc29e2 SMK	314	static int sdp3430_batt_table[] = {
	315	/* 0 C*/
	316	30800, 29500, 28300, 27100,
	317	26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
	318	17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
	319	11600, 11200, 10800, 10400, 10000, 9630, 9280, 8950, 8620, 8310,
	320	8020, 7730, 7460, 7200, 6950, 6710, 6470, 6250, 6040, 5830,
	321	5640, 5450, 5260, 5090, 4920, 4760, 4600, 4450, 4310, 4170,
	322	4040, 3910, 3790, 3670, 3550
	323	};
	324
	325	static struct twl4030_bci_platform_data sdp3430_bci_data = {
	326	.battery_tmp_tbl = sdp3430_batt_table,
	327	.tblsize = ARRAY_SIZE(sdp3430_batt_table),
	328	};
	329
	330	static struct twl4030_hsmmc_info mmc[] = {
	331	{
	332	.mmc = 1,
	333	/* 8 bits (default) requires S6.3 == ON,
	334	* so the SIM card isn't used; else 4 bits.
	335	*/
	336	.wires = 8,
	337	.gpio_wp = 4,
	338	},
	339	{
	340	.mmc = 2,
	341	.wires = 8,
	342	.gpio_wp = 7,
	343	},
	344	{} /* Terminator */
	345	};
	346
	347	static struct regulator_consumer_supply sdp3430_vmmc1_supply = {
	348	.supply = "vmmc",
	349	};
	350
	351	static struct regulator_consumer_supply sdp3430_vsim_supply = {
	352	.supply = "vmmc_aux",
	353	};
	354
	355	static struct regulator_consumer_supply sdp3430_vmmc2_supply = {
	356	.supply = "vmmc",
	357	};
	358
	359	static int sdp3430_twl_gpio_setup(struct device *dev,
	360	unsigned gpio, unsigned ngpio)
	361	{
	362	/* gpio + 0 is "mmc0_cd" (input/IRQ),
	363	* gpio + 1 is "mmc1_cd" (input/IRQ)
	364	*/
	365	mmc[0].gpio_cd = gpio + 0;
	366	mmc[1].gpio_cd = gpio + 1;
	367	twl4030_mmc_init(mmc);
	368
	369	/* link regulators to MMC adapters ... we "know" the
	370	* regulators will be set up only after we return.
	371	*/
	372	sdp3430_vmmc1_supply.dev = mmc[0].dev;
	373	sdp3430_vsim_supply.dev = mmc[0].dev;
	374	sdp3430_vmmc2_supply.dev = mmc[1].dev;
	375
	376	/* gpio + 7 is "sub_lcd_en_bkl" (output/PWM1) */
	377	gpio_request(gpio + 7, "sub_lcd_en_bkl");
378	gpio_direction_output(gpio + 7, 0);
379
380	/* gpio + 15 is "sub_lcd_nRST" (output) */
381	gpio_request(gpio + 15, "sub_lcd_nRST");
382	gpio_direction_output(gpio + 15, 0);
383
384	return 0;
385	}
386
387	static struct twl4030_gpio_platform_data sdp3430_gpio_data = {
388	.gpio_base = OMAP_MAX_GPIO_LINES,
389	.irq_base = TWL4030_GPIO_IRQ_BASE,
390	.irq_end = TWL4030_GPIO_IRQ_END,
391	.pulldowns = BIT(2) \| BIT(6) \| BIT(8) \| BIT(13)
392	\| BIT(16) \| BIT(17),
393	.setup = sdp3430_twl_gpio_setup,
394	};
395
396	static struct twl4030_usb_data sdp3430_usb_data = {
397	.usb_mode = T2_USB_MODE_ULPI,
398	};
399
400	static struct twl4030_madc_platform_data sdp3430_madc_data = {
401	.irq_line = 1,
402	};
403
404	/*
405	* Apply all the fixed voltages since most versions of U-Boot
406	* don't bother with that initialization.
407	*/
408
409	/* VAUX1 for mainboard (irda and sub-lcd) */
410	static struct regulator_init_data sdp3430_vaux1 = {
411	.constraints = {
412	.min_uV = 2800000,
413	.max_uV = 2800000,
414	.apply_uV = true,
415	.valid_modes_mask = REGULATOR_MODE_NORMAL
416	\| REGULATOR_MODE_STANDBY,
417	.valid_ops_mask = REGULATOR_CHANGE_MODE
418	\| REGULATOR_CHANGE_STATUS,
419	},
420	};
421
422	/* VAUX2 for camera module */
423	static struct regulator_init_data sdp3430_vaux2 = {
424	.constraints = {
425	.min_uV = 2800000,
426	.max_uV = 2800000,
427	.apply_uV = true,
428	.valid_modes_mask = REGULATOR_MODE_NORMAL
429	\| REGULATOR_MODE_STANDBY,
430	.valid_ops_mask = REGULATOR_CHANGE_MODE
431	\| REGULATOR_CHANGE_STATUS,
432	},
433	};
434
435	/* VAUX3 for LCD board */
436	static struct regulator_init_data sdp3430_vaux3 = {
437	.constraints = {
438	.min_uV = 2800000,
439	.max_uV = 2800000,
440	.apply_uV = true,
441	.valid_modes_mask = REGULATOR_MODE_NORMAL
442	\| REGULATOR_MODE_STANDBY,
443	.valid_ops_mask = REGULATOR_CHANGE_MODE
444	\| REGULATOR_CHANGE_STATUS,
445	},
446	};
447
448	/* VAUX4 for OMAP VDD_CSI2 (camera) */
449	static struct regulator_init_data sdp3430_vaux4 = {
450	.constraints = {
451	.min_uV = 1800000,
452	.max_uV = 1800000,
453	.apply_uV = true,
454	.valid_modes_mask = REGULATOR_MODE_NORMAL
455	\| REGULATOR_MODE_STANDBY,
456	.valid_ops_mask = REGULATOR_CHANGE_MODE
457	\| REGULATOR_CHANGE_STATUS,
458	},
459	};
460
461	/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
462	static struct regulator_init_data sdp3430_vmmc1 = {
463	.constraints = {
464	.min_uV = 1850000,
465	.max_uV = 3150000,
466	.valid_modes_mask = REGULATOR_MODE_NORMAL
467	\| REGULATOR_MODE_STANDBY,
468	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
469	\| REGULATOR_CHANGE_MODE
470	\| REGULATOR_CHANGE_STATUS,
471	},
472	.num_consumer_supplies = 1,
473	.consumer_supplies = &sdp3430_vmmc1_supply,
474	};
475
476	/* VMMC2 for MMC2 card */
477	static struct regulator_init_data sdp3430_vmmc2 = {
478	.constraints = {
479	.min_uV = 1850000,
480	.max_uV = 1850000,
481	.apply_uV = true,
482	.valid_modes_mask = REGULATOR_MODE_NORMAL
483	\| REGULATOR_MODE_STANDBY,
484	.valid_ops_mask = REGULATOR_CHANGE_MODE
485	\| REGULATOR_CHANGE_STATUS,
486	},
487	.num_consumer_supplies = 1,
488	.consumer_supplies = &sdp3430_vmmc2_supply,
489	};
490
491	/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
492	static struct regulator_init_data sdp3430_vsim = {
493	.constraints = {
494	.min_uV = 1800000,
495	.max_uV = 3000000,
496	.valid_modes_mask = REGULATOR_MODE_NORMAL
497	\| REGULATOR_MODE_STANDBY,
498	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
499	\| REGULATOR_CHANGE_MODE
500	\| REGULATOR_CHANGE_STATUS,
501	},
502	.num_consumer_supplies = 1,
503	.consumer_supplies = &sdp3430_vsim_supply,
504	};
505
506	/* VDAC for DSS driving S-Video */
507	static struct regulator_init_data sdp3430_vdac = {
508	.constraints = {
509	.min_uV = 1800000,
510	.max_uV = 1800000,
511	.apply_uV = true,
512	.valid_modes_mask = REGULATOR_MODE_NORMAL
513	\| REGULATOR_MODE_STANDBY,
514	.valid_ops_mask = REGULATOR_CHANGE_MODE
515	\| REGULATOR_CHANGE_STATUS,
516	},
517	.num_consumer_supplies = 1,
d9056ce2	518	.consumer_supplies = &sdp3430_vdda_dac_supply,
6fdc29e2 SMK	519	};
	520
	521	/* VPLL2 for digital video outputs */
d9056ce2 TV	522	static struct regulator_consumer_supply sdp3430_vpll2_supplies[] = {
	523	{
	524	.supply = "vdvi",
	525	.dev = &sdp3430_lcd_device.dev,
	526	},
	527	{
	528	.supply = "vdds_dsi",
	529	.dev = &sdp3430_dss_device.dev,
	530	}
	531	};
	532
6fdc29e2 SMK	533	static struct regulator_init_data sdp3430_vpll2 = {
	534	.constraints = {
	535	.name = "VDVI",
	536	.min_uV = 1800000,
	537	.max_uV = 1800000,
d9056ce2	538	.apply_uV = true,
6fdc29e2 SMK	539	.valid_modes_mask = REGULATOR_MODE_NORMAL
	540	\| REGULATOR_MODE_STANDBY,
	541	.valid_ops_mask = REGULATOR_CHANGE_MODE
	542	\| REGULATOR_CHANGE_STATUS,
	543	},
d9056ce2 TV	544	.num_consumer_supplies = ARRAY_SIZE(sdp3430_vpll2_supplies),
d9056ce2 TV	545	.consumer_supplies = sdp3430_vpll2_supplies,
6fdc29e2 SMK	546	};
6fdc29e2 SMK	547
e86fa0b4 PU	548	static struct twl4030_codec_audio_data sdp3430_audio = {
	549	.audio_mclk = 26000000,
	550	};
	551
	552	static struct twl4030_codec_data sdp3430_codec = {
6df74efb	553	.audio_mclk = 26000000,
e86fa0b4 PU	554	.audio = &sdp3430_audio,
	555	};
	556
6fdc29e2 SMK	557	static struct twl4030_platform_data sdp3430_twldata = {
	558	.irq_base = TWL4030_IRQ_BASE,
	559	.irq_end = TWL4030_IRQ_END,
	560
	561	/* platform_data for children goes here */
	562	.bci = &sdp3430_bci_data,
	563	.gpio = &sdp3430_gpio_data,
	564	.madc = &sdp3430_madc_data,
	565	.keypad = &sdp3430_kp_data,
	566	.usb = &sdp3430_usb_data,
e86fa0b4	567	.codec = &sdp3430_codec,
6fdc29e2 SMK	568
	569	.vaux1 = &sdp3430_vaux1,
	570	.vaux2 = &sdp3430_vaux2,
	571	.vaux3 = &sdp3430_vaux3,
	572	.vaux4 = &sdp3430_vaux4,
	573	.vmmc1 = &sdp3430_vmmc1,
	574	.vmmc2 = &sdp3430_vmmc2,
	575	.vsim = &sdp3430_vsim,
	576	.vdac = &sdp3430_vdac,
	577	.vpll2 = &sdp3430_vpll2,
	578	};
	579
	580	static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
	581	{
	582	I2C_BOARD_INFO("twl4030", 0x48),
	583	.flags = I2C_CLIENT_WAKE,
	584	.irq = INT_34XX_SYS_NIRQ,
	585	.platform_data = &sdp3430_twldata,
	586	},
	587	};
	588
	589	static int __init omap3430_i2c_init(void)
	590	{
	591	/* i2c1 for PMIC only */
	592	omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
	593	ARRAY_SIZE(sdp3430_i2c_boardinfo));
	594	/* i2c2 on camera connector (for sensor control) and optional isp1301 */
	595	omap_register_i2c_bus(2, 400, NULL, 0);
	596	/* i2c3 on display connector (for DVI, tfp410) */
	597	omap_register_i2c_bus(3, 400, NULL, 0);
	598	return 0;
	599	}
	600
1a48e157 TL	601	#if defined(CONFIG_SMC91X) \|\| defined(CONFIG_SMC91X_MODULE)
	602
	603	static struct omap_smc91x_platform_data board_smc91x_data = {
	604	.cs = 3,
	605	.flags = GPMC_MUX_ADD_DATA \| GPMC_TIMINGS_SMC91C96 \|
	606	IORESOURCE_IRQ_LOWLEVEL,
	607	};
	608
	609	static void __init board_smc91x_init(void)
	610	{
	611	if (omap_rev() > OMAP3430_REV_ES1_0)
	612	board_smc91x_data.gpio_irq = 6;
	613	else
	614	board_smc91x_data.gpio_irq = 29;
	615
	616	gpmc_smc91x_init(&board_smc91x_data);
	617	}
	618
	619	#else
	620
	621	static inline void board_smc91x_init(void)
	622	{
	623	}
	624
	625	#endif
	626
5110b298 RT	627	static void enable_board_wakeup_source(void)
	628	{
	629	omap_cfg_reg(AF26_34XX_SYS_NIRQ); /* T2 interrupt line (keypad) */
	630	}
	631
58a5491c FB	632	static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
	633
	634	.port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
	635	.port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
	636	.port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
	637
	638	.phy_reset = true,
	639	.reset_gpio_port[0] = 57,
	640	.reset_gpio_port[1] = 61,
	641	.reset_gpio_port[2] = -EINVAL
	642	};
	643
ca5742bd TL	644	#ifdef CONFIG_OMAP_MUX
	645	static struct omap_board_mux board_mux[] __initdata = {
	646	{ .reg_offset = OMAP_MUX_TERMINATOR },
	647	};
	648	#else
	649	#define board_mux NULL
	650	#endif
	651
6fdc29e2 SMK	652	static void __init omap_3430sdp_init(void)
6fdc29e2 SMK	653	{
ca5742bd	654	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
6fdc29e2 SMK	655	omap3430_i2c_init();
6fdc29e2 SMK	656	platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
6fdc29e2 SMK	657	if (omap_rev() > OMAP3430_REV_ES1_0)
	658	ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV2;
	659	else
	660	ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV1;
	661	sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
	662	spi_register_board_info(sdp3430_spi_board_info,
	663	ARRAY_SIZE(sdp3430_spi_board_info));
	664	ads7846_dev_init();
	665	omap_serial_init();
	666	usb_musb_init();
1a48e157	667	board_smc91x_init();
d9056ce2	668	sdp3430_display_init();
5110b298	669	enable_board_wakeup_source();
58a5491c	670	usb_ehci_init(&ehci_pdata);
6fdc29e2 SMK	671	}
	672
	673	static void __init omap_3430sdp_map_io(void)
	674	{
	675	omap2_set_globals_343x();
	676	omap2_map_common_io();
	677	}
	678
	679	MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
	680	/* Maintainer: Syed Khasim - Texas Instruments Inc */
	681	.phys_io = 0x48000000,
b4224b23	682	.io_pg_offst = ((0xfa000000) >> 18) & 0xfffc,
6fdc29e2 SMK	683	.boot_params = 0x80000100,
	684	.map_io = omap_3430sdp_map_io,
	685	.init_irq = omap_3430sdp_init_irq,
	686	.init_machine = omap_3430sdp_init,
	687	.timer = &omap_timer,
	688	MACHINE_END