[deliverable/linux.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/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 <mach/mcspi.h>
#include <mach/mux.h>
#include <mach/board.h>
#include <mach/usb.h>
#include <mach/common.h>
#include <mach/dma.h>
#include <mach/gpmc.h>

#include <mach/control.h>
#include <mach/keypad.h>
#include <mach/gpmc-smc91x.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 sdp3430_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 twl4030_keypad_data sdp3430_kp_data = {
	.rows		= 5,
	.cols		= 6,
	.keymap		= sdp3430_keymap,
	.keymapsize	= ARRAY_SIZE(sdp3430_keymap),
	.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,
	},
};

static struct platform_device sdp3430_lcd_device = {
	.name		= "sdp2430_lcd",
	.id		= -1,
};

static struct regulator_consumer_supply sdp3430_vdac_supply = {
	.supply		= "vdac",
	.dev		= &sdp3430_lcd_device.dev,
};

static struct regulator_consumer_supply sdp3430_vdvi_supply = {
	.supply		= "vdvi",
	.dev		= &sdp3430_lcd_device.dev,
};

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

static void __init omap_3430sdp_init_irq(void)
{
	omap2_init_common_hw(NULL);
	omap_init_irq();
	omap_gpio_init();
}

static struct omap_uart_config sdp3430_uart_config __initdata = {
	.enabled_uarts	= ((1 << 0) | (1 << 1) | (1 << 2)),
};

static struct omap_lcd_config sdp3430_lcd_config __initdata = {
	.ctrl_name	= "internal",
};

static struct omap_board_config_kernel sdp3430_config[] __initdata = {
	{ OMAP_TAG_UART,	&sdp3430_uart_config },
	{ OMAP_TAG_LCD,		&sdp3430_lcd_config },
};

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_vdac_supply,
};

/* VPLL2 for digital video outputs */
static struct regulator_init_data sdp3430_vpll2 = {
	.constraints = {
		.name			= "VDVI",
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.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_vdvi_supply,
};

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,

	.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 __init omap_3430sdp_init(void)
{
	omap3430_i2c_init();
	platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
	omap_board_config = sdp3430_config;
	omap_board_config_size = ARRAY_SIZE(sdp3430_config);
	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();
}

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	= ((0xd8000000) >> 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>
	20	#include <linux/spi/spi.h>
	21	#include <linux/spi/ads7846.h>
	22	#include <linux/i2c/twl4030.h>
	23	#include <linux/regulator/machine.h>
	24	#include <linux/io.h>
	25	#include <linux/gpio.h>
	26
	27	#include <mach/hardware.h>
	28	#include <asm/mach-types.h>
	29	#include <asm/mach/arch.h>
	30	#include <asm/mach/map.h>
	31
	32	#include <mach/mcspi.h>
	33	#include <mach/mux.h>
	34	#include <mach/board.h>
	35	#include <mach/usb.h>
	36	#include <mach/common.h>
	37	#include <mach/dma.h>
	38	#include <mach/gpmc.h>
	39
	40	#include <mach/control.h>
	41	#include <mach/keypad.h>
1a48e157	42	#include <mach/gpmc-smc91x.h>
6fdc29e2 SMK	43
	44	#include "mmc-twl4030.h"
	45
	46	#define CONFIG_DISABLE_HFCLK 1
	47
6fdc29e2 SMK	48	#define SDP3430_TS_GPIO_IRQ_SDPV1 3
	49	#define SDP3430_TS_GPIO_IRQ_SDPV2 2
	50
	51	#define ENABLE_VAUX3_DEDICATED 0x03
	52	#define ENABLE_VAUX3_DEV_GRP 0x20
	53
	54	#define TWL4030_MSECURE_GPIO 22
	55
6fdc29e2 SMK	56	static int sdp3430_keymap[] = {
	57	KEY(0, 0, KEY_LEFT),
	58	KEY(0, 1, KEY_RIGHT),
	59	KEY(0, 2, KEY_A),
	60	KEY(0, 3, KEY_B),
	61	KEY(0, 4, KEY_C),
	62	KEY(1, 0, KEY_DOWN),
	63	KEY(1, 1, KEY_UP),
	64	KEY(1, 2, KEY_E),
	65	KEY(1, 3, KEY_F),
	66	KEY(1, 4, KEY_G),
	67	KEY(2, 0, KEY_ENTER),
	68	KEY(2, 1, KEY_I),
	69	KEY(2, 2, KEY_J),
	70	KEY(2, 3, KEY_K),
	71	KEY(2, 4, KEY_3),
	72	KEY(3, 0, KEY_M),
	73	KEY(3, 1, KEY_N),
	74	KEY(3, 2, KEY_O),
	75	KEY(3, 3, KEY_P),
	76	KEY(3, 4, KEY_Q),
	77	KEY(4, 0, KEY_R),
	78	KEY(4, 1, KEY_4),
	79	KEY(4, 2, KEY_T),
	80	KEY(4, 3, KEY_U),
	81	KEY(4, 4, KEY_D),
	82	KEY(5, 0, KEY_V),
	83	KEY(5, 1, KEY_W),
	84	KEY(5, 2, KEY_L),
	85	KEY(5, 3, KEY_S),
	86	KEY(5, 4, KEY_H),
	87	0
	88	};
	89
	90	static struct twl4030_keypad_data sdp3430_kp_data = {
	91	.rows = 5,
	92	.cols = 6,
	93	.keymap = sdp3430_keymap,
	94	.keymapsize = ARRAY_SIZE(sdp3430_keymap),
	95	.rep = 1,
	96	};
	97
	98	static int ts_gpio; /* Needed for ads7846_get_pendown_state */
	99
	100	/**
	101	* @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
	102	*
	103	* @return - void. If request gpio fails then Flag KERN_ERR.
	104	*/
	105	static void ads7846_dev_init(void)
	106	{
	107	if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
	108	printk(KERN_ERR "can't get ads746 pen down GPIO\n");
	109	return;
	110	}
	111
	112	gpio_direction_input(ts_gpio);
	113
	114	omap_set_gpio_debounce(ts_gpio, 1);
	115	omap_set_gpio_debounce_time(ts_gpio, 0xa);
	116	}
	117
	118	static int ads7846_get_pendown_state(void)
	119	{
120	return !gpio_get_value(ts_gpio);
121	}
122
123	static struct ads7846_platform_data tsc2046_config __initdata = {
124	.get_pendown_state = ads7846_get_pendown_state,
125	.keep_vref_on = 1,
126	};
127
128
129	static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
130	.turbo_mode = 0,
131	.single_channel = 1, /* 0: slave, 1: master */
132	};
133
134	static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
135	[0] = {
136	/*
137	* TSC2046 operates at a max freqency of 2MHz, so
138	* operate slightly below at 1.5MHz
139	*/
140	.modalias = "ads7846",
141	.bus_num = 1,
142	.chip_select = 0,
143	.max_speed_hz = 1500000,
144	.controller_data = &tsc2046_mcspi_config,
145	.irq = 0,
146	.platform_data = &tsc2046_config,
147	},
148	};
149
150	static struct platform_device sdp3430_lcd_device = {
151	.name = "sdp2430_lcd",
152	.id = -1,
153	};
154
155	static struct regulator_consumer_supply sdp3430_vdac_supply = {
156	.supply = "vdac",
157	.dev = &sdp3430_lcd_device.dev,
158	};
159
160	static struct regulator_consumer_supply sdp3430_vdvi_supply = {
161	.supply = "vdvi",
162	.dev = &sdp3430_lcd_device.dev,
163	};
164
165	static struct platform_device *sdp3430_devices[] __initdata = {
6fdc29e2 SMK	166	&sdp3430_lcd_device,
	167	};
	168
6fdc29e2 SMK	169	static void __init omap_3430sdp_init_irq(void)
6fdc29e2 SMK	170	{
2f3ec501	171	omap2_init_common_hw(NULL);
6fdc29e2 SMK	172	omap_init_irq();
6fdc29e2 SMK	173	omap_gpio_init();
6fdc29e2 SMK	174	}
	175
	176	static struct omap_uart_config sdp3430_uart_config __initdata = {
	177	.enabled_uarts = ((1 << 0) \| (1 << 1) \| (1 << 2)),
	178	};
	179
	180	static struct omap_lcd_config sdp3430_lcd_config __initdata = {
	181	.ctrl_name = "internal",
	182	};
	183
	184	static struct omap_board_config_kernel sdp3430_config[] __initdata = {
	185	{ OMAP_TAG_UART, &sdp3430_uart_config },
	186	{ OMAP_TAG_LCD, &sdp3430_lcd_config },
	187	};
	188
	189	static int sdp3430_batt_table[] = {
	190	/* 0 C*/
	191	30800, 29500, 28300, 27100,
	192	26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
	193	17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
	194	11600, 11200, 10800, 10400, 10000, 9630, 9280, 8950, 8620, 8310,
	195	8020, 7730, 7460, 7200, 6950, 6710, 6470, 6250, 6040, 5830,
	196	5640, 5450, 5260, 5090, 4920, 4760, 4600, 4450, 4310, 4170,
	197	4040, 3910, 3790, 3670, 3550
	198	};
	199
	200	static struct twl4030_bci_platform_data sdp3430_bci_data = {
	201	.battery_tmp_tbl = sdp3430_batt_table,
	202	.tblsize = ARRAY_SIZE(sdp3430_batt_table),
	203	};
	204
	205	static struct twl4030_hsmmc_info mmc[] = {
	206	{
	207	.mmc = 1,
	208	/* 8 bits (default) requires S6.3 == ON,
	209	* so the SIM card isn't used; else 4 bits.
	210	*/
	211	.wires = 8,
	212	.gpio_wp = 4,
	213	},
	214	{
	215	.mmc = 2,
	216	.wires = 8,
	217	.gpio_wp = 7,
	218	},
	219	{} /* Terminator */
	220	};
	221
	222	static struct regulator_consumer_supply sdp3430_vmmc1_supply = {
	223	.supply = "vmmc",
	224	};
	225
	226	static struct regulator_consumer_supply sdp3430_vsim_supply = {
	227	.supply = "vmmc_aux",
	228	};
	229
	230	static struct regulator_consumer_supply sdp3430_vmmc2_supply = {
	231	.supply = "vmmc",
	232	};
	233
	234	static int sdp3430_twl_gpio_setup(struct device *dev,
	235	unsigned gpio, unsigned ngpio)
	236	{
	237	/* gpio + 0 is "mmc0_cd" (input/IRQ),
238	* gpio + 1 is "mmc1_cd" (input/IRQ)
239	*/
240	mmc[0].gpio_cd = gpio + 0;
241	mmc[1].gpio_cd = gpio + 1;
242	twl4030_mmc_init(mmc);
243
244	/* link regulators to MMC adapters ... we "know" the
245	* regulators will be set up only after we return.
246	*/
247	sdp3430_vmmc1_supply.dev = mmc[0].dev;
248	sdp3430_vsim_supply.dev = mmc[0].dev;
249	sdp3430_vmmc2_supply.dev = mmc[1].dev;
250
251	/* gpio + 7 is "sub_lcd_en_bkl" (output/PWM1) */
252	gpio_request(gpio + 7, "sub_lcd_en_bkl");
253	gpio_direction_output(gpio + 7, 0);
254
255	/* gpio + 15 is "sub_lcd_nRST" (output) */
256	gpio_request(gpio + 15, "sub_lcd_nRST");
257	gpio_direction_output(gpio + 15, 0);
258
259	return 0;
260	}
261
262	static struct twl4030_gpio_platform_data sdp3430_gpio_data = {
263	.gpio_base = OMAP_MAX_GPIO_LINES,
264	.irq_base = TWL4030_GPIO_IRQ_BASE,
265	.irq_end = TWL4030_GPIO_IRQ_END,
266	.pulldowns = BIT(2) \| BIT(6) \| BIT(8) \| BIT(13)
267	\| BIT(16) \| BIT(17),
268	.setup = sdp3430_twl_gpio_setup,
269	};
270
271	static struct twl4030_usb_data sdp3430_usb_data = {
272	.usb_mode = T2_USB_MODE_ULPI,
273	};
274
275	static struct twl4030_madc_platform_data sdp3430_madc_data = {
276	.irq_line = 1,
277	};
278
279	/*
280	* Apply all the fixed voltages since most versions of U-Boot
281	* don't bother with that initialization.
282	*/
283
284	/* VAUX1 for mainboard (irda and sub-lcd) */
285	static struct regulator_init_data sdp3430_vaux1 = {
286	.constraints = {
287	.min_uV = 2800000,
288	.max_uV = 2800000,
289	.apply_uV = true,
290	.valid_modes_mask = REGULATOR_MODE_NORMAL
291	\| REGULATOR_MODE_STANDBY,
292	.valid_ops_mask = REGULATOR_CHANGE_MODE
293	\| REGULATOR_CHANGE_STATUS,
294	},
295	};
296
297	/* VAUX2 for camera module */
298	static struct regulator_init_data sdp3430_vaux2 = {
299	.constraints = {
300	.min_uV = 2800000,
301	.max_uV = 2800000,
302	.apply_uV = true,
303	.valid_modes_mask = REGULATOR_MODE_NORMAL
304	\| REGULATOR_MODE_STANDBY,
305	.valid_ops_mask = REGULATOR_CHANGE_MODE
306	\| REGULATOR_CHANGE_STATUS,
307	},
308	};
309
310	/* VAUX3 for LCD board */
311	static struct regulator_init_data sdp3430_vaux3 = {
312	.constraints = {
313	.min_uV = 2800000,
314	.max_uV = 2800000,
315	.apply_uV = true,
316	.valid_modes_mask = REGULATOR_MODE_NORMAL
317	\| REGULATOR_MODE_STANDBY,
318	.valid_ops_mask = REGULATOR_CHANGE_MODE
319	\| REGULATOR_CHANGE_STATUS,
320	},
321	};
322
323	/* VAUX4 for OMAP VDD_CSI2 (camera) */
324	static struct regulator_init_data sdp3430_vaux4 = {
325	.constraints = {
326	.min_uV = 1800000,
327	.max_uV = 1800000,
328	.apply_uV = true,
329	.valid_modes_mask = REGULATOR_MODE_NORMAL
330	\| REGULATOR_MODE_STANDBY,
331	.valid_ops_mask = REGULATOR_CHANGE_MODE
332	\| REGULATOR_CHANGE_STATUS,
333	},
334	};
335
336	/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
337	static struct regulator_init_data sdp3430_vmmc1 = {
338	.constraints = {
339	.min_uV = 1850000,
340	.max_uV = 3150000,
341	.valid_modes_mask = REGULATOR_MODE_NORMAL
342	\| REGULATOR_MODE_STANDBY,
343	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
344	\| REGULATOR_CHANGE_MODE
345	\| REGULATOR_CHANGE_STATUS,
346	},
347	.num_consumer_supplies = 1,
348	.consumer_supplies = &sdp3430_vmmc1_supply,
349	};
350
351	/* VMMC2 for MMC2 card */
352	static struct regulator_init_data sdp3430_vmmc2 = {
353	.constraints = {
354	.min_uV = 1850000,
355	.max_uV = 1850000,
356	.apply_uV = true,
357	.valid_modes_mask = REGULATOR_MODE_NORMAL
358	\| REGULATOR_MODE_STANDBY,
359	.valid_ops_mask = REGULATOR_CHANGE_MODE
360	\| REGULATOR_CHANGE_STATUS,
361	},
362	.num_consumer_supplies = 1,
363	.consumer_supplies = &sdp3430_vmmc2_supply,
364	};
365
366	/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
367	static struct regulator_init_data sdp3430_vsim = {
368	.constraints = {
369	.min_uV = 1800000,
370	.max_uV = 3000000,
371	.valid_modes_mask = REGULATOR_MODE_NORMAL
372	\| REGULATOR_MODE_STANDBY,
373	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
374	\| REGULATOR_CHANGE_MODE
375	\| REGULATOR_CHANGE_STATUS,
376	},
377	.num_consumer_supplies = 1,
378	.consumer_supplies = &sdp3430_vsim_supply,
379	};
380
381	/* VDAC for DSS driving S-Video */
382	static struct regulator_init_data sdp3430_vdac = {
383	.constraints = {
384	.min_uV = 1800000,
385	.max_uV = 1800000,
386	.apply_uV = true,
387	.valid_modes_mask = REGULATOR_MODE_NORMAL
388	\| REGULATOR_MODE_STANDBY,
389	.valid_ops_mask = REGULATOR_CHANGE_MODE
390	\| REGULATOR_CHANGE_STATUS,
391	},
392	.num_consumer_supplies = 1,
393	.consumer_supplies = &sdp3430_vdac_supply,
394	};
395
396	/* VPLL2 for digital video outputs */
397	static struct regulator_init_data sdp3430_vpll2 = {
398	.constraints = {
399	.name = "VDVI",
400	.min_uV = 1800000,
401	.max_uV = 1800000,
402	.valid_modes_mask = REGULATOR_MODE_NORMAL
403	\| REGULATOR_MODE_STANDBY,
404	.valid_ops_mask = REGULATOR_CHANGE_MODE
405	\| REGULATOR_CHANGE_STATUS,
406	},
407	.num_consumer_supplies = 1,
408	.consumer_supplies = &sdp3430_vdvi_supply,
409	};
410
411	static struct twl4030_platform_data sdp3430_twldata = {
412	.irq_base = TWL4030_IRQ_BASE,
413	.irq_end = TWL4030_IRQ_END,
414
415	/* platform_data for children goes here */
416	.bci = &sdp3430_bci_data,
417	.gpio = &sdp3430_gpio_data,
418	.madc = &sdp3430_madc_data,
419	.keypad = &sdp3430_kp_data,
420	.usb = &sdp3430_usb_data,
421
422	.vaux1 = &sdp3430_vaux1,
423	.vaux2 = &sdp3430_vaux2,
424	.vaux3 = &sdp3430_vaux3,
425	.vaux4 = &sdp3430_vaux4,
426	.vmmc1 = &sdp3430_vmmc1,
427	.vmmc2 = &sdp3430_vmmc2,
428	.vsim = &sdp3430_vsim,
429	.vdac = &sdp3430_vdac,
430	.vpll2 = &sdp3430_vpll2,
431	};
432
433	static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
434	{
435	I2C_BOARD_INFO("twl4030", 0x48),
436	.flags = I2C_CLIENT_WAKE,
437	.irq = INT_34XX_SYS_NIRQ,
438	.platform_data = &sdp3430_twldata,
439	},
440	};
441
442	static int __init omap3430_i2c_init(void)
443	{
444	/* i2c1 for PMIC only */
445	omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
446	ARRAY_SIZE(sdp3430_i2c_boardinfo));
447	/* i2c2 on camera connector (for sensor control) and optional isp1301 */
448	omap_register_i2c_bus(2, 400, NULL, 0);
449	/* i2c3 on display connector (for DVI, tfp410) */
450	omap_register_i2c_bus(3, 400, NULL, 0);
451	return 0;
452	}
453
1a48e157 TL	454	#if defined(CONFIG_SMC91X) \|\| defined(CONFIG_SMC91X_MODULE)
	455
	456	static struct omap_smc91x_platform_data board_smc91x_data = {
	457	.cs = 3,
	458	.flags = GPMC_MUX_ADD_DATA \| GPMC_TIMINGS_SMC91C96 \|
	459	IORESOURCE_IRQ_LOWLEVEL,
	460	};
	461
	462	static void __init board_smc91x_init(void)
	463	{
	464	if (omap_rev() > OMAP3430_REV_ES1_0)
	465	board_smc91x_data.gpio_irq = 6;
	466	else
	467	board_smc91x_data.gpio_irq = 29;
	468
	469	gpmc_smc91x_init(&board_smc91x_data);
	470	}
	471
	472	#else
	473
	474	static inline void board_smc91x_init(void)
	475	{
	476	}
	477
	478	#endif
	479
6fdc29e2 SMK	480	static void __init omap_3430sdp_init(void)
	481	{
	482	omap3430_i2c_init();
	483	platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
	484	omap_board_config = sdp3430_config;
	485	omap_board_config_size = ARRAY_SIZE(sdp3430_config);
	486	if (omap_rev() > OMAP3430_REV_ES1_0)
	487	ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV2;
	488	else
	489	ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV1;
	490	sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
	491	spi_register_board_info(sdp3430_spi_board_info,
	492	ARRAY_SIZE(sdp3430_spi_board_info));
	493	ads7846_dev_init();
	494	omap_serial_init();
	495	usb_musb_init();
1a48e157	496	board_smc91x_init();
6fdc29e2 SMK	497	}
	498
	499	static void __init omap_3430sdp_map_io(void)
	500	{
	501	omap2_set_globals_343x();
	502	omap2_map_common_io();
	503	}
	504
	505	MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
	506	/* Maintainer: Syed Khasim - Texas Instruments Inc */
	507	.phys_io = 0x48000000,
	508	.io_pg_offst = ((0xd8000000) >> 18) & 0xfffc,
	509	.boot_params = 0x80000100,
	510	.map_io = omap_3430sdp_map_io,
	511	.init_irq = omap_3430sdp_init_irq,
	512	.init_machine = omap_3430sdp_init,
	513	.timer = &omap_timer,
	514	MACHINE_END