[deliverable/linux.git] / arch / arm / mach-omap2 / board-zoom-peripherals.c

/*
 * Copyright (C) 2009 Texas Instruments Inc.
 *
 * Modified from mach-omap2/board-zoom2.c
 *
 * 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/input.h>
#include <linux/input/matrix_keypad.h>
#include <linux/gpio.h>
#include <linux/i2c/twl.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/fixed.h>
#include <linux/wl12xx.h>
#include <linux/mmc/host.h>

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

#include <plat/common.h>
#include <plat/usb.h>

#include <mach/board-zoom.h>

#include "mux.h"
#include "hsmmc.h"

#define OMAP_ZOOM_WLAN_PMENA_GPIO	(101)
#define OMAP_ZOOM_WLAN_IRQ_GPIO		(162)

#define LCD_PANEL_ENABLE_GPIO		(7 + OMAP_MAX_GPIO_LINES)

/* Zoom2 has Qwerty keyboard*/
static uint32_t board_keymap[] = {
	KEY(0, 0, KEY_E),
	KEY(0, 1, KEY_R),
	KEY(0, 2, KEY_T),
	KEY(0, 3, KEY_HOME),
	KEY(0, 6, KEY_I),
	KEY(0, 7, KEY_LEFTSHIFT),
	KEY(1, 0, KEY_D),
	KEY(1, 1, KEY_F),
	KEY(1, 2, KEY_G),
	KEY(1, 3, KEY_SEND),
	KEY(1, 6, KEY_K),
	KEY(1, 7, KEY_ENTER),
	KEY(2, 0, KEY_X),
	KEY(2, 1, KEY_C),
	KEY(2, 2, KEY_V),
	KEY(2, 3, KEY_END),
	KEY(2, 6, KEY_DOT),
	KEY(2, 7, KEY_CAPSLOCK),
	KEY(3, 0, KEY_Z),
	KEY(3, 1, KEY_KPPLUS),
	KEY(3, 2, KEY_B),
	KEY(3, 3, KEY_F1),
	KEY(3, 6, KEY_O),
	KEY(3, 7, KEY_SPACE),
	KEY(4, 0, KEY_W),
	KEY(4, 1, KEY_Y),
	KEY(4, 2, KEY_U),
	KEY(4, 3, KEY_F2),
	KEY(4, 4, KEY_VOLUMEUP),
	KEY(4, 6, KEY_L),
	KEY(4, 7, KEY_LEFT),
	KEY(5, 0, KEY_S),
	KEY(5, 1, KEY_H),
	KEY(5, 2, KEY_J),
	KEY(5, 3, KEY_F3),
	KEY(5, 4, KEY_UNKNOWN),
	KEY(5, 5, KEY_VOLUMEDOWN),
	KEY(5, 6, KEY_M),
	KEY(5, 7, KEY_RIGHT),
	KEY(6, 0, KEY_Q),
	KEY(6, 1, KEY_A),
	KEY(6, 2, KEY_N),
	KEY(6, 3, KEY_BACKSPACE),
	KEY(6, 6, KEY_P),
	KEY(6, 7, KEY_UP),
	KEY(7, 0, KEY_PROG1),	/*MACRO 1 <User defined> */
	KEY(7, 1, KEY_PROG2),	/*MACRO 2 <User defined> */
	KEY(7, 2, KEY_PROG3),	/*MACRO 3 <User defined> */
	KEY(7, 3, KEY_PROG4),	/*MACRO 4 <User defined> */
	KEY(7, 6, KEY_SELECT),
	KEY(7, 7, KEY_DOWN)
};

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

static struct twl4030_keypad_data zoom_kp_twl4030_data = {
	.keymap_data	= &board_map_data,
	.rows		= 8,
	.cols		= 8,
	.rep		= 1,
};

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

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

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

static struct regulator_consumer_supply zoom_vmmc3_supply = {
	.supply		= "vmmc",
	.dev_name	= "omap_hsmmc.2",
};

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

/* VMMC2 for MMC2 card */
static struct regulator_init_data zoom_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      = &zoom_vmmc2_supply,
};

/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
static struct regulator_init_data zoom_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      = &zoom_vsim_supply,
};

static struct regulator_init_data zoom_vmmc3 = {
	.constraints = {
		.valid_ops_mask	= REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= 1,
	.consumer_supplies = &zoom_vmmc3_supply,
};

static struct fixed_voltage_config zoom_vwlan = {
	.supply_name		= "vwl1271",
	.microvolts		= 1800000, /* 1.8V */
	.gpio			= OMAP_ZOOM_WLAN_PMENA_GPIO,
	.startup_delay		= 70000, /* 70msec */
	.enable_high		= 1,
	.enabled_at_boot	= 0,
	.init_data		= &zoom_vmmc3,
};

static struct platform_device omap_vwlan_device = {
	.name		= "reg-fixed-voltage",
	.id		= 1,
	.dev = {
		.platform_data	= &zoom_vwlan,
	},
};

static struct wl12xx_platform_data omap_zoom_wlan_data __initdata = {
	.irq = OMAP_GPIO_IRQ(OMAP_ZOOM_WLAN_IRQ_GPIO),
	/* ZOOM ref clock is 26 MHz */
	.board_ref_clock = 1,
};

static struct omap2_hsmmc_info mmc[] = {
	{
		.name		= "external",
		.mmc		= 1,
		.caps		= MMC_CAP_4_BIT_DATA,
		.gpio_wp	= -EINVAL,
		.power_saving	= true,
	},
	{
		.name		= "internal",
		.mmc		= 2,
		.caps		= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
		.gpio_cd	= -EINVAL,
		.gpio_wp	= -EINVAL,
		.nonremovable	= true,
		.power_saving	= true,
	},
	{
		.name		= "wl1271",
		.mmc		= 3,
		.caps		= MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
		.gpio_wp	= -EINVAL,
		.gpio_cd	= -EINVAL,
		.nonremovable	= true,
	},
	{}      /* Terminator */
};

static struct regulator_consumer_supply zoom_vpll2_supplies[] = {
	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
};

static struct regulator_consumer_supply zoom_vdda_dac_supply =
	REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");

static struct regulator_init_data zoom_vpll2 = {
	.constraints = {
		.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		= ARRAY_SIZE(zoom_vpll2_supplies),
	.consumer_supplies		= zoom_vpll2_supplies,
};

static struct regulator_init_data zoom_vdac = {
	.constraints = {
		.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		= &zoom_vdda_dac_supply,
};

static int zoom_twl_gpio_setup(struct device *dev,
		unsigned gpio, unsigned ngpio)
{
	int ret;

	/* gpio + 0 is "mmc0_cd" (input/IRQ) */
	mmc[0].gpio_cd = gpio + 0;
	omap2_hsmmc_init(mmc);

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

	ret = gpio_request(LCD_PANEL_ENABLE_GPIO, "lcd enable");
	if (ret) {
		pr_err("Failed to get LCD_PANEL_ENABLE_GPIO (gpio%d).\n",
				LCD_PANEL_ENABLE_GPIO);
		return ret;
	}
	gpio_direction_output(LCD_PANEL_ENABLE_GPIO, 0);

	return ret;
}

/* EXTMUTE callback function */
static void zoom2_set_hs_extmute(int mute)
{
	gpio_set_value(ZOOM2_HEADSET_EXTMUTE_GPIO, mute);
}

static int zoom_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 zoom_bci_data = {
	.battery_tmp_tbl	= zoom_batt_table,
	.tblsize		= ARRAY_SIZE(zoom_batt_table),
};

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

static struct twl4030_gpio_platform_data zoom_gpio_data = {
	.gpio_base	= OMAP_MAX_GPIO_LINES,
	.irq_base	= TWL4030_GPIO_IRQ_BASE,
	.irq_end	= TWL4030_GPIO_IRQ_END,
	.setup		= zoom_twl_gpio_setup,
};

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

static struct twl4030_codec_audio_data zoom_audio_data;

static struct twl4030_codec_data zoom_codec_data = {
	.audio_mclk = 26000000,
	.audio = &zoom_audio_data,
};

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

	/* platform_data for children goes here */
	.bci		= &zoom_bci_data,
	.madc		= &zoom_madc_data,
	.usb		= &zoom_usb_data,
	.gpio		= &zoom_gpio_data,
	.keypad		= &zoom_kp_twl4030_data,
	.codec		= &zoom_codec_data,
	.vmmc1          = &zoom_vmmc1,
	.vmmc2          = &zoom_vmmc2,
	.vsim           = &zoom_vsim,
	.vpll2		= &zoom_vpll2,
	.vdac		= &zoom_vdac,
};

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

static int __init omap_i2c_init(void)
{
	if (machine_is_omap_zoom2()) {
		zoom_audio_data.ramp_delay_value = 3;	/* 161 ms */
		zoom_audio_data.hs_extmute = 1;
		zoom_audio_data.set_hs_extmute = zoom2_set_hs_extmute;
	}
	omap_register_i2c_bus(1, 2400, zoom_i2c_boardinfo,
			ARRAY_SIZE(zoom_i2c_boardinfo));
	omap_register_i2c_bus(2, 400, NULL, 0);
	omap_register_i2c_bus(3, 400, NULL, 0);
	return 0;
}

static struct omap_musb_board_data musb_board_data = {
	.interface_type		= MUSB_INTERFACE_ULPI,
	.mode			= MUSB_OTG,
	.power			= 100,
};

static void enable_board_wakeup_source(void)
{
	/* T2 interrupt line (keypad) */
	omap_mux_init_signal("sys_nirq",
		OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
}

void __init zoom_peripherals_init(void)
{
	if (wl12xx_set_platform_data(&omap_zoom_wlan_data))
		pr_err("error setting wl12xx data\n");

	omap_i2c_init();
	platform_device_register(&omap_vwlan_device);
	usb_musb_init(&musb_board_data);
	enable_board_wakeup_source();
	omap_serial_init();
}
Commit	Line	Data
479f12c9	1	/*
	2	* Copyright (C) 2009 Texas Instruments Inc.
	3	*
	4	* Modified from mach-omap2/board-zoom2.c
	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/platform_device.h>
	14	#include <linux/input.h>
	15	#include <linux/input/matrix_keypad.h>
	16	#include <linux/gpio.h>
ebeb53e1	17	#include <linux/i2c/twl.h>
479f12c9	18	#include <linux/regulator/machine.h>
b642fde7	19	#include <linux/regulator/fixed.h>
80b517f3	20	#include <linux/wl12xx.h>
3a63833e	21	#include <linux/mmc/host.h>
479f12c9	22
	23	#include <asm/mach-types.h>
	24	#include <asm/mach/arch.h>
	25	#include <asm/mach/map.h>
	26
	27	#include <plat/common.h>
	28	#include <plat/usb.h>
	29
4b285c3f JN	30	#include <mach/board-zoom.h>
4b285c3f JN	31
a1e63642	32	#include "mux.h"
d02a900b	33	#include "hsmmc.h"
479f12c9	34
b642fde7	35	#define OMAP_ZOOM_WLAN_PMENA_GPIO (101)
80b517f3	36	#define OMAP_ZOOM_WLAN_IRQ_GPIO (162)
b642fde7	37
a6490335 K	38	#define LCD_PANEL_ENABLE_GPIO (7 + OMAP_MAX_GPIO_LINES)
a6490335 K	39
479f12c9	40	/* Zoom2 has Qwerty keyboard*/
bead4375	41	static uint32_t board_keymap[] = {
479f12c9	42	KEY(0, 0, KEY_E),
	43	KEY(0, 1, KEY_R),
	44	KEY(0, 2, KEY_T),
	45	KEY(0, 3, KEY_HOME),
	46	KEY(0, 6, KEY_I),
	47	KEY(0, 7, KEY_LEFTSHIFT),
	48	KEY(1, 0, KEY_D),
	49	KEY(1, 1, KEY_F),
	50	KEY(1, 2, KEY_G),
	51	KEY(1, 3, KEY_SEND),
	52	KEY(1, 6, KEY_K),
	53	KEY(1, 7, KEY_ENTER),
	54	KEY(2, 0, KEY_X),
	55	KEY(2, 1, KEY_C),
	56	KEY(2, 2, KEY_V),
	57	KEY(2, 3, KEY_END),
	58	KEY(2, 6, KEY_DOT),
	59	KEY(2, 7, KEY_CAPSLOCK),
	60	KEY(3, 0, KEY_Z),
	61	KEY(3, 1, KEY_KPPLUS),
	62	KEY(3, 2, KEY_B),
	63	KEY(3, 3, KEY_F1),
	64	KEY(3, 6, KEY_O),
	65	KEY(3, 7, KEY_SPACE),
	66	KEY(4, 0, KEY_W),
	67	KEY(4, 1, KEY_Y),
	68	KEY(4, 2, KEY_U),
	69	KEY(4, 3, KEY_F2),
	70	KEY(4, 4, KEY_VOLUMEUP),
	71	KEY(4, 6, KEY_L),
	72	KEY(4, 7, KEY_LEFT),
	73	KEY(5, 0, KEY_S),
	74	KEY(5, 1, KEY_H),
	75	KEY(5, 2, KEY_J),
	76	KEY(5, 3, KEY_F3),
6b06ebdf	77	KEY(5, 4, KEY_UNKNOWN),
479f12c9	78	KEY(5, 5, KEY_VOLUMEDOWN),
479f12c9	79	KEY(5, 6, KEY_M),
6b06ebdf	80	KEY(5, 7, KEY_RIGHT),
479f12c9	81	KEY(6, 0, KEY_Q),
	82	KEY(6, 1, KEY_A),
	83	KEY(6, 2, KEY_N),
	84	KEY(6, 3, KEY_BACKSPACE),
	85	KEY(6, 6, KEY_P),
6b06ebdf	86	KEY(6, 7, KEY_UP),
479f12c9	87	KEY(7, 0, KEY_PROG1), /MACRO 1 <User defined> /
	88	KEY(7, 1, KEY_PROG2), /MACRO 2 <User defined> /
	89	KEY(7, 2, KEY_PROG3), /MACRO 3 <User defined> /
	90	KEY(7, 3, KEY_PROG4), /MACRO 4 <User defined> /
6b06ebdf	91	KEY(7, 6, KEY_SELECT),
479f12c9	92	KEY(7, 7, KEY_DOWN)
	93	};
	94
	95	static struct matrix_keymap_data board_map_data = {
	96	.keymap = board_keymap,
	97	.keymap_size = ARRAY_SIZE(board_keymap),
	98	};
	99
62d0b336	100	static struct twl4030_keypad_data zoom_kp_twl4030_data = {
479f12c9	101	.keymap_data = &board_map_data,
	102	.rows = 8,
	103	.cols = 8,
	104	.rep = 1,
	105	};
	106
62d0b336	107	static struct regulator_consumer_supply zoom_vmmc1_supply = {
479f12c9	108	.supply = "vmmc",
	109	};
	110
62d0b336	111	static struct regulator_consumer_supply zoom_vsim_supply = {
479f12c9	112	.supply = "vmmc_aux",
	113	};
	114
62d0b336	115	static struct regulator_consumer_supply zoom_vmmc2_supply = {
479f12c9	116	.supply = "vmmc",
	117	};
	118
b642fde7 OBC	119	static struct regulator_consumer_supply zoom_vmmc3_supply = {
b642fde7 OBC	120	.supply = "vmmc",
0005ae73	121	.dev_name = "omap_hsmmc.2",
b642fde7 OBC	122	};
b642fde7 OBC	123
479f12c9	124	/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
62d0b336	125	static struct regulator_init_data zoom_vmmc1 = {
479f12c9	126	.constraints = {
	127	.min_uV = 1850000,
	128	.max_uV = 3150000,
	129	.valid_modes_mask = REGULATOR_MODE_NORMAL
	130	\| REGULATOR_MODE_STANDBY,
	131	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	132	\| REGULATOR_CHANGE_MODE
	133	\| REGULATOR_CHANGE_STATUS,
	134	},
	135	.num_consumer_supplies = 1,
62d0b336	136	.consumer_supplies = &zoom_vmmc1_supply,
479f12c9	137	};
	138
	139	/* VMMC2 for MMC2 card */
62d0b336	140	static struct regulator_init_data zoom_vmmc2 = {
479f12c9	141	.constraints = {
	142	.min_uV = 1850000,
	143	.max_uV = 1850000,
	144	.apply_uV = true,
	145	.valid_modes_mask = REGULATOR_MODE_NORMAL
	146	\| REGULATOR_MODE_STANDBY,
	147	.valid_ops_mask = REGULATOR_CHANGE_MODE
	148	\| REGULATOR_CHANGE_STATUS,
	149	},
	150	.num_consumer_supplies = 1,
62d0b336	151	.consumer_supplies = &zoom_vmmc2_supply,
479f12c9	152	};
	153
	154	/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
62d0b336	155	static struct regulator_init_data zoom_vsim = {
479f12c9	156	.constraints = {
	157	.min_uV = 1800000,
	158	.max_uV = 3000000,
	159	.valid_modes_mask = REGULATOR_MODE_NORMAL
	160	\| REGULATOR_MODE_STANDBY,
	161	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	162	\| REGULATOR_CHANGE_MODE
	163	\| REGULATOR_CHANGE_STATUS,
	164	},
	165	.num_consumer_supplies = 1,
62d0b336	166	.consumer_supplies = &zoom_vsim_supply,
479f12c9	167	};
479f12c9	168
b642fde7 OBC	169	static struct regulator_init_data zoom_vmmc3 = {
	170	.constraints = {
	171	.valid_ops_mask = REGULATOR_CHANGE_STATUS,
	172	},
	173	.num_consumer_supplies = 1,
	174	.consumer_supplies = &zoom_vmmc3_supply,
	175	};
	176
	177	static struct fixed_voltage_config zoom_vwlan = {
	178	.supply_name = "vwl1271",
	179	.microvolts = 1800000, /* 1.8V */
	180	.gpio = OMAP_ZOOM_WLAN_PMENA_GPIO,
	181	.startup_delay = 70000, /* 70msec */
	182	.enable_high = 1,
	183	.enabled_at_boot = 0,
	184	.init_data = &zoom_vmmc3,
	185	};
	186
	187	static struct platform_device omap_vwlan_device = {
	188	.name = "reg-fixed-voltage",
	189	.id = 1,
	190	.dev = {
	191	.platform_data = &zoom_vwlan,
	192	},
	193	};
	194
0ce3bb72	195	static struct wl12xx_platform_data omap_zoom_wlan_data __initdata = {
80b517f3 OBC	196	.irq = OMAP_GPIO_IRQ(OMAP_ZOOM_WLAN_IRQ_GPIO),
	197	/* ZOOM ref clock is 26 MHz */
	198	.board_ref_clock = 1,
	199	};
	200
1a6b5923	201	static struct omap2_hsmmc_info mmc[] = {
479f12c9	202	{
ed32350d	203	.name = "external",
479f12c9	204	.mmc = 1,
3a63833e	205	.caps = MMC_CAP_4_BIT_DATA,
479f12c9	206	.gpio_wp = -EINVAL,
ed32350d	207	.power_saving = true,
479f12c9	208	},
479f12c9	209	{
ed32350d	210	.name = "internal",
479f12c9	211	.mmc = 2,
3a63833e	212	.caps = MMC_CAP_4_BIT_DATA \| MMC_CAP_8_BIT_DATA,
ed32350d	213	.gpio_cd = -EINVAL,
479f12c9	214	.gpio_wp = -EINVAL,
ed32350d MC	215	.nonremovable = true,
ed32350d MC	216	.power_saving = true,
479f12c9	217	},
80b517f3 OBC	218	{
	219	.name = "wl1271",
	220	.mmc = 3,
f8110364	221	.caps = MMC_CAP_4_BIT_DATA \| MMC_CAP_POWER_OFF_CARD,
80b517f3 OBC	222	.gpio_wp = -EINVAL,
	223	.gpio_cd = -EINVAL,
	224	.nonremovable = true,
	225	},
479f12c9	226	{} /* Terminator */
	227	};
	228
c8aac01b SG	229	static struct regulator_consumer_supply zoom_vpll2_supplies[] = {
	230	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
	231	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
	232	};
a6490335 K	233
a6490335 K	234	static struct regulator_consumer_supply zoom_vdda_dac_supply =
30ea50c9	235	REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");
a6490335 K	236
	237	static struct regulator_init_data zoom_vpll2 = {
	238	.constraints = {
	239	.min_uV = 1800000,
	240	.max_uV = 1800000,
	241	.valid_modes_mask = REGULATOR_MODE_NORMAL
	242	\| REGULATOR_MODE_STANDBY,
	243	.valid_ops_mask = REGULATOR_CHANGE_MODE
	244	\| REGULATOR_CHANGE_STATUS,
	245	},
c8aac01b SG	246	.num_consumer_supplies = ARRAY_SIZE(zoom_vpll2_supplies),
c8aac01b SG	247	.consumer_supplies = zoom_vpll2_supplies,
a6490335 K	248	};
	249
	250	static struct regulator_init_data zoom_vdac = {
	251	.constraints = {
	252	.min_uV = 1800000,
	253	.max_uV = 1800000,
	254	.valid_modes_mask = REGULATOR_MODE_NORMAL
	255	\| REGULATOR_MODE_STANDBY,
	256	.valid_ops_mask = REGULATOR_CHANGE_MODE
	257	\| REGULATOR_CHANGE_STATUS,
	258	},
	259	.num_consumer_supplies = 1,
	260	.consumer_supplies = &zoom_vdda_dac_supply,
	261	};
	262
62d0b336	263	static int zoom_twl_gpio_setup(struct device *dev,
479f12c9	264	unsigned gpio, unsigned ngpio)
479f12c9	265	{
a6490335 K	266	int ret;
a6490335 K	267
ed32350d	268	/* gpio + 0 is "mmc0_cd" (input/IRQ) */
479f12c9	269	mmc[0].gpio_cd = gpio + 0;
68ff0423	270	omap2_hsmmc_init(mmc);
479f12c9	271
	272	/* link regulators to MMC adapters ... we "know" the
	273	* regulators will be set up only after we return.
	274	*/
62d0b336	275	zoom_vmmc1_supply.dev = mmc[0].dev;
	276	zoom_vsim_supply.dev = mmc[0].dev;
	277	zoom_vmmc2_supply.dev = mmc[1].dev;
479f12c9	278
a6490335 K	279	ret = gpio_request(LCD_PANEL_ENABLE_GPIO, "lcd enable");
	280	if (ret) {
	281	pr_err("Failed to get LCD_PANEL_ENABLE_GPIO (gpio%d).\n",
	282	LCD_PANEL_ENABLE_GPIO);
	283	return ret;
	284	}
	285	gpio_direction_output(LCD_PANEL_ENABLE_GPIO, 0);
	286
	287	return ret;
479f12c9	288	}
479f12c9	289
4b285c3f	290	/* EXTMUTE callback function */
0ce3bb72	291	static void zoom2_set_hs_extmute(int mute)
4b285c3f JN	292	{
	293	gpio_set_value(ZOOM2_HEADSET_EXTMUTE_GPIO, mute);
	294	}
479f12c9	295
62d0b336	296	static int zoom_batt_table[] = {
479f12c9	297	/* 0 C*/
	298	30800, 29500, 28300, 27100,
	299	26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
	300	17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
	301	11600, 11200, 10800, 10400, 10000, 9630, 9280, 8950, 8620, 8310,
	302	8020, 7730, 7460, 7200, 6950, 6710, 6470, 6250, 6040, 5830,
	303	5640, 5450, 5260, 5090, 4920, 4760, 4600, 4450, 4310, 4170,
	304	4040, 3910, 3790, 3670, 3550
	305	};
	306
62d0b336	307	static struct twl4030_bci_platform_data zoom_bci_data = {
	308	.battery_tmp_tbl = zoom_batt_table,
	309	.tblsize = ARRAY_SIZE(zoom_batt_table),
479f12c9	310	};
479f12c9	311
62d0b336	312	static struct twl4030_usb_data zoom_usb_data = {
479f12c9	313	.usb_mode = T2_USB_MODE_ULPI,
	314	};
	315
62d0b336	316	static struct twl4030_gpio_platform_data zoom_gpio_data = {
479f12c9	317	.gpio_base = OMAP_MAX_GPIO_LINES,
	318	.irq_base = TWL4030_GPIO_IRQ_BASE,
	319	.irq_end = TWL4030_GPIO_IRQ_END,
62d0b336	320	.setup = zoom_twl_gpio_setup,
479f12c9	321	};
479f12c9	322
62d0b336	323	static struct twl4030_madc_platform_data zoom_madc_data = {
479f12c9	324	.irq_line = 1,
	325	};
	326
6a58baf8	327	static struct twl4030_codec_audio_data zoom_audio_data;
479f12c9	328
62d0b336	329	static struct twl4030_codec_data zoom_codec_data = {
479f12c9	330	.audio_mclk = 26000000,
62d0b336	331	.audio = &zoom_audio_data,
479f12c9	332	};
479f12c9	333
62d0b336	334	static struct twl4030_platform_data zoom_twldata = {
479f12c9	335	.irq_base = TWL4030_IRQ_BASE,
	336	.irq_end = TWL4030_IRQ_END,
	337
	338	/* platform_data for children goes here */
62d0b336	339	.bci = &zoom_bci_data,
	340	.madc = &zoom_madc_data,
	341	.usb = &zoom_usb_data,
	342	.gpio = &zoom_gpio_data,
	343	.keypad = &zoom_kp_twl4030_data,
	344	.codec = &zoom_codec_data,
aed79bce	345	.vmmc1 = &zoom_vmmc1,
62d0b336	346	.vmmc2 = &zoom_vmmc2,
62d0b336	347	.vsim = &zoom_vsim,
a6490335 K	348	.vpll2 = &zoom_vpll2,
a6490335 K	349	.vdac = &zoom_vdac,
479f12c9	350	};
479f12c9	351
62d0b336	352	static struct i2c_board_info __initdata zoom_i2c_boardinfo[] = {
479f12c9	353	{
6b61a83b	354	I2C_BOARD_INFO("twl5030", 0x48),
479f12c9	355	.flags = I2C_CLIENT_WAKE,
479f12c9	356	.irq = INT_34XX_SYS_NIRQ,
62d0b336	357	.platform_data = &zoom_twldata,
479f12c9	358	},
	359	};
	360
	361	static int __init omap_i2c_init(void)
	362	{
4b285c3f JN	363	if (machine_is_omap_zoom2()) {
	364	zoom_audio_data.ramp_delay_value = 3; /* 161 ms */
	365	zoom_audio_data.hs_extmute = 1;
	366	zoom_audio_data.set_hs_extmute = zoom2_set_hs_extmute;
	367	}
6b61a83b	368	omap_register_i2c_bus(1, 2400, zoom_i2c_boardinfo,
62d0b336	369	ARRAY_SIZE(zoom_i2c_boardinfo));
479f12c9	370	omap_register_i2c_bus(2, 400, NULL, 0);
	371	omap_register_i2c_bus(3, 400, NULL, 0);
	372	return 0;
	373	}
	374
884b8369 MM	375	static struct omap_musb_board_data musb_board_data = {
	376	.interface_type = MUSB_INTERFACE_ULPI,
	377	.mode = MUSB_OTG,
	378	.power = 100,
	379	};
	380
a1e63642 L	381	static void enable_board_wakeup_source(void)
	382	{
	383	/* T2 interrupt line (keypad) */
	384	omap_mux_init_signal("sys_nirq",
	385	OMAP_WAKEUP_EN \| OMAP_PIN_INPUT_PULLUP);
	386	}
	387
479f12c9	388	void __init zoom_peripherals_init(void)
479f12c9	389	{
80b517f3 OBC	390	if (wl12xx_set_platform_data(&omap_zoom_wlan_data))
	391	pr_err("error setting wl12xx data\n");
	392
479f12c9	393	omap_i2c_init();
b642fde7	394	platform_device_register(&omap_vwlan_device);
884b8369	395	usb_musb_init(&musb_board_data);
a1e63642	396	enable_board_wakeup_source();
257f23d8	397	omap_serial_init();
479f12c9	398	}