[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / arch / arm / mach-omap2 / board-zoom2.c

/*
 * Copyright (C) 2009 Texas Instruments Inc.
 * Mikkel Christensen <mlc@ti.com>
 *
 * Modified from mach-omap2/board-ldp.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/gpio.h>
#include <linux/i2c/twl4030.h>
#include <linux/regulator/machine.h>

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

#include <mach/common.h>
#include <mach/usb.h>
#include <mach/keypad.h>

#include "mmc-twl4030.h"

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

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

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

static struct omap_board_config_kernel zoom2_config[] __initdata = {
};

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

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

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

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

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

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

static struct twl4030_hsmmc_info mmc[] __initdata = {
	{
		.mmc		= 1,
		.wires		= 4,
		.gpio_wp	= -EINVAL,
	},
	{
		.mmc		= 2,
		.wires		= 4,
		.gpio_wp	= -EINVAL,
	},
	{}      /* Terminator */
};

static int zoom2_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.
	*/
	zoom2_vmmc1_supply.dev = mmc[0].dev;
	zoom2_vsim_supply.dev = mmc[0].dev;
	zoom2_vmmc2_supply.dev = mmc[1].dev;

	return 0;
}


static int zoom2_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 zoom2_bci_data = {
	.battery_tmp_tbl	= zoom2_batt_table,
	.tblsize		= ARRAY_SIZE(zoom2_batt_table),
};

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

static void __init omap_zoom2_init_irq(void)
{
	omap_board_config = zoom2_config;
	omap_board_config_size = ARRAY_SIZE(zoom2_config);
	omap2_init_common_hw(NULL, NULL);
	omap_init_irq();
	omap_gpio_init();
}

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

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

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

	/* platform_data for children goes here */
	.bci		= &zoom2_bci_data,
	.madc		= &zoom2_madc_data,
	.usb		= &zoom2_usb_data,
	.gpio		= &zoom2_gpio_data,
	.keypad		= &zoom2_kp_twl4030_data,
	.vmmc1          = &zoom2_vmmc1,
	.vmmc2          = &zoom2_vmmc2,
	.vsim           = &zoom2_vsim,

};

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

static int __init omap_i2c_init(void)
{
	omap_register_i2c_bus(1, 2600, zoom2_i2c_boardinfo,
			ARRAY_SIZE(zoom2_i2c_boardinfo));
	omap_register_i2c_bus(2, 400, NULL, 0);
	omap_register_i2c_bus(3, 400, NULL, 0);
	return 0;
}

extern int __init omap_zoom2_debugboard_init(void);

static void __init omap_zoom2_init(void)
{
	omap_i2c_init();
	omap_serial_init();
	omap_zoom2_debugboard_init();
	usb_musb_init();
}

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

MACHINE_START(OMAP_ZOOM2, "OMAP Zoom2 board")
	.phys_io	= 0x48000000,
	.io_pg_offst	= ((0xd8000000) >> 18) & 0xfffc,
	.boot_params	= 0x80000100,
	.map_io		= omap_zoom2_map_io,
	.init_irq	= omap_zoom2_init_irq,
	.init_machine	= omap_zoom2_init,
	.timer		= &omap_timer,
MACHINE_END
Commit	Line	Data
577145f4 VP	1	/*
	2	* Copyright (C) 2009 Texas Instruments Inc.
	3	* Mikkel Christensen <mlc@ti.com>
	4	*
	5	* Modified from mach-omap2/board-ldp.c
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/init.h>
	14	#include <linux/platform_device.h>
70ac51ab	15	#include <linux/input.h>
577145f4 VP	16	#include <linux/gpio.h>
577145f4 VP	17	#include <linux/i2c/twl4030.h>
70ac51ab	18	#include <linux/regulator/machine.h>
577145f4 VP	19
	20	#include <asm/mach-types.h>
	21	#include <asm/mach/arch.h>
	22
	23	#include <mach/common.h>
	24	#include <mach/usb.h>
70ac51ab	25	#include <mach/keypad.h>
577145f4 VP	26
	27	#include "mmc-twl4030.h"
	28
70ac51ab	29	/* Zoom2 has Qwerty keyboard*/
4f543332	30	static int board_keymap[] = {
70ac51ab VP	31	KEY(0, 0, KEY_E),
	32	KEY(1, 0, KEY_R),
	33	KEY(2, 0, KEY_T),
	34	KEY(3, 0, KEY_HOME),
	35	KEY(6, 0, KEY_I),
	36	KEY(7, 0, KEY_LEFTSHIFT),
	37	KEY(0, 1, KEY_D),
	38	KEY(1, 1, KEY_F),
	39	KEY(2, 1, KEY_G),
	40	KEY(3, 1, KEY_SEND),
	41	KEY(6, 1, KEY_K),
	42	KEY(7, 1, KEY_ENTER),
	43	KEY(0, 2, KEY_X),
	44	KEY(1, 2, KEY_C),
	45	KEY(2, 2, KEY_V),
	46	KEY(3, 2, KEY_END),
	47	KEY(6, 2, KEY_DOT),
	48	KEY(7, 2, KEY_CAPSLOCK),
	49	KEY(0, 3, KEY_Z),
	50	KEY(1, 3, KEY_KPPLUS),
	51	KEY(2, 3, KEY_B),
	52	KEY(3, 3, KEY_F1),
	53	KEY(6, 3, KEY_O),
	54	KEY(7, 3, KEY_SPACE),
	55	KEY(0, 4, KEY_W),
	56	KEY(1, 4, KEY_Y),
	57	KEY(2, 4, KEY_U),
	58	KEY(3, 4, KEY_F2),
	59	KEY(4, 4, KEY_VOLUMEUP),
	60	KEY(6, 4, KEY_L),
	61	KEY(7, 4, KEY_LEFT),
	62	KEY(0, 5, KEY_S),
	63	KEY(1, 5, KEY_H),
	64	KEY(2, 5, KEY_J),
	65	KEY(3, 5, KEY_F3),
	66	KEY(5, 5, KEY_VOLUMEDOWN),
	67	KEY(6, 5, KEY_M),
	68	KEY(4, 5, KEY_ENTER),
	69	KEY(7, 5, KEY_RIGHT),
	70	KEY(0, 6, KEY_Q),
	71	KEY(1, 6, KEY_A),
	72	KEY(2, 6, KEY_N),
	73	KEY(3, 6, KEY_BACKSPACE),
	74	KEY(6, 6, KEY_P),
	75	KEY(7, 6, KEY_UP),
	76	KEY(6, 7, KEY_SELECT),
	77	KEY(7, 7, KEY_DOWN),
	78	KEY(0, 7, KEY_PROG1), /MACRO 1 <User defined> /
	79	KEY(1, 7, KEY_PROG2), /MACRO 2 <User defined> /
	80	KEY(2, 7, KEY_PROG3), /MACRO 3 <User defined> /
	81	KEY(3, 7, KEY_PROG4), /MACRO 4 <User defined> /
	82	0
	83	};
	84
4f543332 TL	85	static struct matrix_keymap_data board_map_data = {
	86	.keymap = board_keymap,
	87	.keymap_size = ARRAY_SIZE(board_keymap),
	88	};
	89
70ac51ab	90	static struct twl4030_keypad_data zoom2_kp_twl4030_data = {
4f543332	91	.keymap_data = &board_map_data,
70ac51ab VP	92	.rows = 8,
70ac51ab VP	93	.cols = 8,
70ac51ab VP	94	.rep = 1,
	95	};
	96
577145f4	97	static struct omap_board_config_kernel zoom2_config[] __initdata = {
577145f4 VP	98	};
577145f4 VP	99
70ac51ab VP	100	static struct regulator_consumer_supply zoom2_vmmc1_supply = {
	101	.supply = "vmmc",
	102	};
	103
	104	static struct regulator_consumer_supply zoom2_vsim_supply = {
	105	.supply = "vmmc_aux",
	106	};
	107
	108	static struct regulator_consumer_supply zoom2_vmmc2_supply = {
	109	.supply = "vmmc",
	110	};
	111
	112	/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
	113	static struct regulator_init_data zoom2_vmmc1 = {
	114	.constraints = {
	115	.min_uV = 1850000,
	116	.max_uV = 3150000,
	117	.valid_modes_mask = REGULATOR_MODE_NORMAL
	118	\| REGULATOR_MODE_STANDBY,
	119	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	120	\| REGULATOR_CHANGE_MODE
	121	\| REGULATOR_CHANGE_STATUS,
	122	},
	123	.num_consumer_supplies = 1,
	124	.consumer_supplies = &zoom2_vmmc1_supply,
	125	};
	126
	127	/* VMMC2 for MMC2 card */
	128	static struct regulator_init_data zoom2_vmmc2 = {
	129	.constraints = {
	130	.min_uV = 1850000,
	131	.max_uV = 1850000,
	132	.apply_uV = true,
	133	.valid_modes_mask = REGULATOR_MODE_NORMAL
	134	\| REGULATOR_MODE_STANDBY,
	135	.valid_ops_mask = REGULATOR_CHANGE_MODE
	136	\| REGULATOR_CHANGE_STATUS,
	137	},
	138	.num_consumer_supplies = 1,
	139	.consumer_supplies = &zoom2_vmmc2_supply,
	140	};
	141
	142	/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
	143	static struct regulator_init_data zoom2_vsim = {
	144	.constraints = {
	145	.min_uV = 1800000,
	146	.max_uV = 3000000,
	147	.valid_modes_mask = REGULATOR_MODE_NORMAL
	148	\| REGULATOR_MODE_STANDBY,
	149	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	150	\| REGULATOR_CHANGE_MODE
	151	\| REGULATOR_CHANGE_STATUS,
	152	},
	153	.num_consumer_supplies = 1,
	154	.consumer_supplies = &zoom2_vsim_supply,
	155	};
	156
	157	static struct twl4030_hsmmc_info mmc[] __initdata = {
	158	{
	159	.mmc = 1,
	160	.wires = 4,
	161	.gpio_wp = -EINVAL,
	162	},
	163	{
164	.mmc = 2,
165	.wires = 4,
166	.gpio_wp = -EINVAL,
167	},
168	{} /* Terminator */
169	};
170
171	static int zoom2_twl_gpio_setup(struct device *dev,
172	unsigned gpio, unsigned ngpio)
173	{
174	/* gpio + 0 is "mmc0_cd" (input/IRQ),
175	* gpio + 1 is "mmc1_cd" (input/IRQ)
176	*/
177	mmc[0].gpio_cd = gpio + 0;
178	mmc[1].gpio_cd = gpio + 1;
179	twl4030_mmc_init(mmc);
180
181	/* link regulators to MMC adapters ... we "know" the
182	* regulators will be set up only after we return.
183	*/
184	zoom2_vmmc1_supply.dev = mmc[0].dev;
185	zoom2_vsim_supply.dev = mmc[0].dev;
186	zoom2_vmmc2_supply.dev = mmc[1].dev;
187
188	return 0;
189	}
190
191
192	static int zoom2_batt_table[] = {
193	/* 0 C*/
194	30800, 29500, 28300, 27100,
195	26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
196	17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
197	11600, 11200, 10800, 10400, 10000, 9630, 9280, 8950, 8620, 8310,
198	8020, 7730, 7460, 7200, 6950, 6710, 6470, 6250, 6040, 5830,
199	5640, 5450, 5260, 5090, 4920, 4760, 4600, 4450, 4310, 4170,
200	4040, 3910, 3790, 3670, 3550
201	};
202
203	static struct twl4030_bci_platform_data zoom2_bci_data = {
204	.battery_tmp_tbl = zoom2_batt_table,
205	.tblsize = ARRAY_SIZE(zoom2_batt_table),
206	};
207
208	static struct twl4030_usb_data zoom2_usb_data = {
209	.usb_mode = T2_USB_MODE_ULPI,
210	};
211
b3c6df3a PW	212	static void __init omap_zoom2_init_irq(void)
	213	{
	214	omap_board_config = zoom2_config;
	215	omap_board_config_size = ARRAY_SIZE(zoom2_config);
	216	omap2_init_common_hw(NULL, NULL);
	217	omap_init_irq();
	218	omap_gpio_init();
	219	}
	220
577145f4 VP	221	static struct twl4030_gpio_platform_data zoom2_gpio_data = {
	222	.gpio_base = OMAP_MAX_GPIO_LINES,
	223	.irq_base = TWL4030_GPIO_IRQ_BASE,
	224	.irq_end = TWL4030_GPIO_IRQ_END,
70ac51ab VP	225	.setup = zoom2_twl_gpio_setup,
	226	};
	227
	228	static struct twl4030_madc_platform_data zoom2_madc_data = {
	229	.irq_line = 1,
577145f4 VP	230	};
	231
	232	static struct twl4030_platform_data zoom2_twldata = {
	233	.irq_base = TWL4030_IRQ_BASE,
	234	.irq_end = TWL4030_IRQ_END,
	235
	236	/* platform_data for children goes here */
70ac51ab VP	237	.bci = &zoom2_bci_data,
	238	.madc = &zoom2_madc_data,
	239	.usb = &zoom2_usb_data,
577145f4	240	.gpio = &zoom2_gpio_data,
70ac51ab VP	241	.keypad = &zoom2_kp_twl4030_data,
	242	.vmmc1 = &zoom2_vmmc1,
	243	.vmmc2 = &zoom2_vmmc2,
	244	.vsim = &zoom2_vsim,
	245
577145f4 VP	246	};
	247
	248	static struct i2c_board_info __initdata zoom2_i2c_boardinfo[] = {
	249	{
	250	I2C_BOARD_INFO("twl4030", 0x48),
	251	.flags = I2C_CLIENT_WAKE,
	252	.irq = INT_34XX_SYS_NIRQ,
	253	.platform_data = &zoom2_twldata,
	254	},
	255	};
	256
	257	static int __init omap_i2c_init(void)
	258	{
	259	omap_register_i2c_bus(1, 2600, zoom2_i2c_boardinfo,
	260	ARRAY_SIZE(zoom2_i2c_boardinfo));
	261	omap_register_i2c_bus(2, 400, NULL, 0);
	262	omap_register_i2c_bus(3, 400, NULL, 0);
	263	return 0;
	264	}
	265
577145f4 VP	266	extern int __init omap_zoom2_debugboard_init(void);
	267
	268	static void __init omap_zoom2_init(void)
	269	{
	270	omap_i2c_init();
577145f4 VP	271	omap_serial_init();
577145f4 VP	272	omap_zoom2_debugboard_init();
577145f4 VP	273	usb_musb_init();
	274	}
	275
	276	static void __init omap_zoom2_map_io(void)
	277	{
	278	omap2_set_globals_343x();
	279	omap2_map_common_io();
	280	}
	281
	282	MACHINE_START(OMAP_ZOOM2, "OMAP Zoom2 board")
	283	.phys_io = 0x48000000,
	284	.io_pg_offst = ((0xd8000000) >> 18) & 0xfffc,
	285	.boot_params = 0x80000100,
	286	.map_io = omap_zoom2_map_io,
	287	.init_irq = omap_zoom2_init_irq,
	288	.init_machine = omap_zoom2_init,
	289	.timer = &omap_timer,
	290	MACHINE_END