[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/twl4030.h>
#include <linux/regulator/machine.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 "mmc-twl4030.h"

/* Zoom2 has Qwerty keyboard*/
static int 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, 5, KEY_VOLUMEDOWN),
	KEY(5, 6, KEY_M),
	KEY(5, 7, KEY_ENTER),
	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_SELECT),
	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, 5, KEY_RIGHT),
	KEY(7, 6, KEY_UP),
	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",
};

/* 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 twl4030_hsmmc_info mmc[] __initdata = {
	{
		.mmc		= 1,
		.wires		= 4,
		.gpio_wp	= -EINVAL,
	},
	{
		.mmc		= 2,
		.wires		= 4,
		.gpio_wp	= -EINVAL,
	},
	{}      /* Terminator */
};

static int zoom_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.
	*/
	zoom_vmmc1_supply.dev = mmc[0].dev;
	zoom_vsim_supply.dev = mmc[0].dev;
	zoom_vmmc2_supply.dev = mmc[1].dev;

	return 0;
}


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 = {
	.audio_mclk = 26000000,
};

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,
	.vmmc2          = &zoom_vmmc2,
	.vsim           = &zoom_vsim,

};

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)
{
	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;
}

void __init zoom_peripherals_init(void)
{
	omap_i2c_init();
	omap_serial_init();
	usb_musb_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>
	17	#include <linux/i2c/twl4030.h>
	18	#include <linux/regulator/machine.h>
	19
	20	#include <asm/mach-types.h>
	21	#include <asm/mach/arch.h>
	22	#include <asm/mach/map.h>
	23
	24	#include <plat/common.h>
	25	#include <plat/usb.h>
	26
	27	#include "mmc-twl4030.h"
	28
	29	/* Zoom2 has Qwerty keyboard*/
	30	static int board_keymap[] = {
	31	KEY(0, 0, KEY_E),
	32	KEY(0, 1, KEY_R),
	33	KEY(0, 2, KEY_T),
	34	KEY(0, 3, KEY_HOME),
	35	KEY(0, 6, KEY_I),
	36	KEY(0, 7, KEY_LEFTSHIFT),
	37	KEY(1, 0, KEY_D),
	38	KEY(1, 1, KEY_F),
	39	KEY(1, 2, KEY_G),
	40	KEY(1, 3, KEY_SEND),
	41	KEY(1, 6, KEY_K),
	42	KEY(1, 7, KEY_ENTER),
	43	KEY(2, 0, KEY_X),
	44	KEY(2, 1, KEY_C),
	45	KEY(2, 2, KEY_V),
	46	KEY(2, 3, KEY_END),
	47	KEY(2, 6, KEY_DOT),
	48	KEY(2, 7, KEY_CAPSLOCK),
	49	KEY(3, 0, KEY_Z),
	50	KEY(3, 1, KEY_KPPLUS),
	51	KEY(3, 2, KEY_B),
	52	KEY(3, 3, KEY_F1),
	53	KEY(3, 6, KEY_O),
	54	KEY(3, 7, KEY_SPACE),
	55	KEY(4, 0, KEY_W),
	56	KEY(4, 1, KEY_Y),
	57	KEY(4, 2, KEY_U),
	58	KEY(4, 3, KEY_F2),
	59	KEY(4, 4, KEY_VOLUMEUP),
	60	KEY(4, 6, KEY_L),
	61	KEY(4, 7, KEY_LEFT),
	62	KEY(5, 0, KEY_S),
	63	KEY(5, 1, KEY_H),
	64	KEY(5, 2, KEY_J),
65	KEY(5, 3, KEY_F3),
66	KEY(5, 5, KEY_VOLUMEDOWN),
67	KEY(5, 6, KEY_M),
68	KEY(5, 7, KEY_ENTER),
69	KEY(6, 0, KEY_Q),
70	KEY(6, 1, KEY_A),
71	KEY(6, 2, KEY_N),
72	KEY(6, 3, KEY_BACKSPACE),
73	KEY(6, 6, KEY_P),
74	KEY(6, 7, KEY_SELECT),
75	KEY(7, 0, KEY_PROG1), /MACRO 1 <User defined> /
76	KEY(7, 1, KEY_PROG2), /MACRO 2 <User defined> /
77	KEY(7, 2, KEY_PROG3), /MACRO 3 <User defined> /
78	KEY(7, 3, KEY_PROG4), /MACRO 4 <User defined> /
79	KEY(7, 5, KEY_RIGHT),
80	KEY(7, 6, KEY_UP),
81	KEY(7, 7, KEY_DOWN)
82	};
83
84	static struct matrix_keymap_data board_map_data = {
85	.keymap = board_keymap,
86	.keymap_size = ARRAY_SIZE(board_keymap),
87	};
88
62d0b336	89	static struct twl4030_keypad_data zoom_kp_twl4030_data = {
479f12c9	90	.keymap_data = &board_map_data,
	91	.rows = 8,
	92	.cols = 8,
	93	.rep = 1,
	94	};
	95
62d0b336	96	static struct regulator_consumer_supply zoom_vmmc1_supply = {
479f12c9	97	.supply = "vmmc",
	98	};
	99
62d0b336	100	static struct regulator_consumer_supply zoom_vsim_supply = {
479f12c9	101	.supply = "vmmc_aux",
	102	};
	103
62d0b336	104	static struct regulator_consumer_supply zoom_vmmc2_supply = {
479f12c9	105	.supply = "vmmc",
	106	};
	107
	108	/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
62d0b336	109	static struct regulator_init_data zoom_vmmc1 = {
479f12c9	110	.constraints = {
	111	.min_uV = 1850000,
	112	.max_uV = 3150000,
	113	.valid_modes_mask = REGULATOR_MODE_NORMAL
	114	\| REGULATOR_MODE_STANDBY,
	115	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	116	\| REGULATOR_CHANGE_MODE
	117	\| REGULATOR_CHANGE_STATUS,
	118	},
	119	.num_consumer_supplies = 1,
62d0b336	120	.consumer_supplies = &zoom_vmmc1_supply,
479f12c9	121	};
	122
	123	/* VMMC2 for MMC2 card */
62d0b336	124	static struct regulator_init_data zoom_vmmc2 = {
479f12c9	125	.constraints = {
	126	.min_uV = 1850000,
	127	.max_uV = 1850000,
	128	.apply_uV = true,
	129	.valid_modes_mask = REGULATOR_MODE_NORMAL
	130	\| REGULATOR_MODE_STANDBY,
	131	.valid_ops_mask = REGULATOR_CHANGE_MODE
	132	\| REGULATOR_CHANGE_STATUS,
	133	},
	134	.num_consumer_supplies = 1,
62d0b336	135	.consumer_supplies = &zoom_vmmc2_supply,
479f12c9	136	};
	137
	138	/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
62d0b336	139	static struct regulator_init_data zoom_vsim = {
479f12c9	140	.constraints = {
	141	.min_uV = 1800000,
	142	.max_uV = 3000000,
	143	.valid_modes_mask = REGULATOR_MODE_NORMAL
	144	\| REGULATOR_MODE_STANDBY,
	145	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	146	\| REGULATOR_CHANGE_MODE
	147	\| REGULATOR_CHANGE_STATUS,
	148	},
	149	.num_consumer_supplies = 1,
62d0b336	150	.consumer_supplies = &zoom_vsim_supply,
479f12c9	151	};
	152
	153	static struct twl4030_hsmmc_info mmc[] __initdata = {
	154	{
	155	.mmc = 1,
	156	.wires = 4,
	157	.gpio_wp = -EINVAL,
	158	},
	159	{
	160	.mmc = 2,
	161	.wires = 4,
	162	.gpio_wp = -EINVAL,
	163	},
	164	{} /* Terminator */
	165	};
	166
62d0b336	167	static int zoom_twl_gpio_setup(struct device *dev,
479f12c9	168	unsigned gpio, unsigned ngpio)
	169	{
	170	/* gpio + 0 is "mmc0_cd" (input/IRQ),
	171	* gpio + 1 is "mmc1_cd" (input/IRQ)
	172	*/
	173	mmc[0].gpio_cd = gpio + 0;
	174	mmc[1].gpio_cd = gpio + 1;
	175	twl4030_mmc_init(mmc);
	176
	177	/* link regulators to MMC adapters ... we "know" the
	178	* regulators will be set up only after we return.
	179	*/
62d0b336	180	zoom_vmmc1_supply.dev = mmc[0].dev;
	181	zoom_vsim_supply.dev = mmc[0].dev;
	182	zoom_vmmc2_supply.dev = mmc[1].dev;
479f12c9	183
	184	return 0;
	185	}
	186
	187
62d0b336	188	static int zoom_batt_table[] = {
479f12c9	189	/* 0 C*/
	190	30800, 29500, 28300, 27100,
	191	26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
	192	17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
	193	11600, 11200, 10800, 10400, 10000, 9630, 9280, 8950, 8620, 8310,
	194	8020, 7730, 7460, 7200, 6950, 6710, 6470, 6250, 6040, 5830,
	195	5640, 5450, 5260, 5090, 4920, 4760, 4600, 4450, 4310, 4170,
	196	4040, 3910, 3790, 3670, 3550
	197	};
	198
62d0b336	199	static struct twl4030_bci_platform_data zoom_bci_data = {
	200	.battery_tmp_tbl = zoom_batt_table,
	201	.tblsize = ARRAY_SIZE(zoom_batt_table),
479f12c9	202	};
479f12c9	203
62d0b336	204	static struct twl4030_usb_data zoom_usb_data = {
479f12c9	205	.usb_mode = T2_USB_MODE_ULPI,
	206	};
	207
62d0b336	208	static struct twl4030_gpio_platform_data zoom_gpio_data = {
479f12c9	209	.gpio_base = OMAP_MAX_GPIO_LINES,
	210	.irq_base = TWL4030_GPIO_IRQ_BASE,
	211	.irq_end = TWL4030_GPIO_IRQ_END,
62d0b336	212	.setup = zoom_twl_gpio_setup,
479f12c9	213	};
479f12c9	214
62d0b336	215	static struct twl4030_madc_platform_data zoom_madc_data = {
479f12c9	216	.irq_line = 1,
	217	};
	218
62d0b336	219	static struct twl4030_codec_audio_data zoom_audio_data = {
479f12c9	220	.audio_mclk = 26000000,
	221	};
	222
62d0b336	223	static struct twl4030_codec_data zoom_codec_data = {
479f12c9	224	.audio_mclk = 26000000,
62d0b336	225	.audio = &zoom_audio_data,
479f12c9	226	};
479f12c9	227
62d0b336	228	static struct twl4030_platform_data zoom_twldata = {
479f12c9	229	.irq_base = TWL4030_IRQ_BASE,
	230	.irq_end = TWL4030_IRQ_END,
	231
	232	/* platform_data for children goes here */
62d0b336	233	.bci = &zoom_bci_data,
	234	.madc = &zoom_madc_data,
	235	.usb = &zoom_usb_data,
	236	.gpio = &zoom_gpio_data,
	237	.keypad = &zoom_kp_twl4030_data,
	238	.codec = &zoom_codec_data,
	239	.vmmc2 = &zoom_vmmc2,
	240	.vsim = &zoom_vsim,
479f12c9	241
	242	};
	243
62d0b336	244	static struct i2c_board_info __initdata zoom_i2c_boardinfo[] = {
479f12c9	245	{
6b61a83b	246	I2C_BOARD_INFO("twl5030", 0x48),
479f12c9	247	.flags = I2C_CLIENT_WAKE,
479f12c9	248	.irq = INT_34XX_SYS_NIRQ,
62d0b336	249	.platform_data = &zoom_twldata,
479f12c9	250	},
	251	};
	252
	253	static int __init omap_i2c_init(void)
	254	{
6b61a83b	255	omap_register_i2c_bus(1, 2400, zoom_i2c_boardinfo,
62d0b336	256	ARRAY_SIZE(zoom_i2c_boardinfo));
479f12c9	257	omap_register_i2c_bus(2, 400, NULL, 0);
	258	omap_register_i2c_bus(3, 400, NULL, 0);
	259	return 0;
	260	}
	261
	262	void __init zoom_peripherals_init(void)
	263	{
	264	omap_i2c_init();
	265	omap_serial_init();
	266	usb_musb_init();
	267	}