[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"
#include "common-board-devices.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_one(LCD_PANEL_ENABLE_GPIO, GPIOF_OUT_INIT_LOW,
			       "lcd enable");
	if (ret)
		pr_err("Failed to get LCD_PANEL_ENABLE_GPIO (gpio%d).\n",
				LCD_PANEL_ENABLE_GPIO);

	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 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_pmic_init(1, 2400, "twl5030", INT_34XX_SYS_NIRQ, &zoom_twldata);
	omap_register_i2c_bus(2, 400, NULL, 0);
	omap_register_i2c_bus(3, 400, NULL, 0);
	return 0;
}

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