[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / arm / mach-davinci / board-tnetv107x-evm.c

/*
 * Texas Instruments TNETV107X EVM Board Support
 *
 * Copyright (C) 2010 Texas Instruments
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation version 2.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether express or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/console.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/ratelimit.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/input.h>
#include <linux/input/matrix_keypad.h>
#include <linux/spi/spi.h>

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

#include <mach/irqs.h>
#include <mach/edma.h>
#include <mach/mux.h>
#include <mach/cp_intc.h>
#include <mach/tnetv107x.h>

#define EVM_MMC_WP_GPIO		21
#define EVM_MMC_CD_GPIO		24
#define EVM_SPI_CS_GPIO		54

static int initialize_gpio(int gpio, char *desc)
{
	int ret;

	ret = gpio_request(gpio, desc);
	if (ret < 0) {
		pr_err_ratelimited("cannot open %s gpio\n", desc);
		return -ENOSYS;
	}
	gpio_direction_input(gpio);
	return gpio;
}

static int mmc_get_cd(int index)
{
	static int gpio;

	if (!gpio)
		gpio = initialize_gpio(EVM_MMC_CD_GPIO, "mmc card detect");

	if (gpio < 0)
		return gpio;

	return gpio_get_value(gpio) ? 0 : 1;
}

static int mmc_get_ro(int index)
{
	static int gpio;

	if (!gpio)
		gpio = initialize_gpio(EVM_MMC_WP_GPIO, "mmc write protect");

	if (gpio < 0)
		return gpio;

	return gpio_get_value(gpio) ? 1 : 0;
}

static struct davinci_mmc_config mmc_config = {
	.get_cd		= mmc_get_cd,
	.get_ro		= mmc_get_ro,
	.wires		= 4,
	.max_freq	= 50000000,
	.caps		= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED,
};

static const short sdio1_pins[] __initconst = {
	TNETV107X_SDIO1_CLK_1,		TNETV107X_SDIO1_CMD_1,
	TNETV107X_SDIO1_DATA0_1,	TNETV107X_SDIO1_DATA1_1,
	TNETV107X_SDIO1_DATA2_1,	TNETV107X_SDIO1_DATA3_1,
	TNETV107X_GPIO21,		TNETV107X_GPIO24,
	-1
};

static const short uart1_pins[] __initconst = {
	TNETV107X_UART1_RD,		TNETV107X_UART1_TD,
	-1
};

static const short ssp_pins[] __initconst = {
	TNETV107X_SSP0_0, TNETV107X_SSP0_1, TNETV107X_SSP0_2,
	TNETV107X_SSP1_0, TNETV107X_SSP1_1, TNETV107X_SSP1_2,
	TNETV107X_SSP1_3, -1
};

static struct mtd_partition nand_partitions[] = {
	/* bootloader (U-Boot, etc) in first 12 sectors */
	{
		.name		= "bootloader",
		.offset		= 0,
		.size		= (12*SZ_128K),
		.mask_flags	= MTD_WRITEABLE,	/* force read-only */
	},
	/* bootloader params in the next sector */
	{
		.name		= "params",
		.offset		= MTDPART_OFS_NXTBLK,
		.size		= SZ_128K,
		.mask_flags	= MTD_WRITEABLE,	/* force read-only */
	},
	/* kernel */
	{
		.name		= "kernel",
		.offset		= MTDPART_OFS_NXTBLK,
		.size		= SZ_4M,
		.mask_flags	= 0,
	},
	/* file system */
	{
		.name		= "filesystem",
		.offset		= MTDPART_OFS_NXTBLK,
		.size		= MTDPART_SIZ_FULL,
		.mask_flags	= 0,
	}
};

static struct davinci_nand_pdata nand_config = {
	.mask_cle	= 0x4000,
	.mask_ale	= 0x2000,
	.parts		= nand_partitions,
	.nr_parts	= ARRAY_SIZE(nand_partitions),
	.ecc_mode	= NAND_ECC_HW,
	.bbt_options	= NAND_BBT_USE_FLASH,
	.ecc_bits	= 1,
};

static struct davinci_uart_config serial_config __initconst = {
	.enabled_uarts	= BIT(1),
};

static const uint32_t keymap[] = {
	KEY(0, 0, KEY_NUMERIC_1),
	KEY(0, 1, KEY_NUMERIC_2),
	KEY(0, 2, KEY_NUMERIC_3),
	KEY(0, 3, KEY_FN_F1),
	KEY(0, 4, KEY_MENU),

	KEY(1, 0, KEY_NUMERIC_4),
	KEY(1, 1, KEY_NUMERIC_5),
	KEY(1, 2, KEY_NUMERIC_6),
	KEY(1, 3, KEY_UP),
	KEY(1, 4, KEY_FN_F2),

	KEY(2, 0, KEY_NUMERIC_7),
	KEY(2, 1, KEY_NUMERIC_8),
	KEY(2, 2, KEY_NUMERIC_9),
	KEY(2, 3, KEY_LEFT),
	KEY(2, 4, KEY_ENTER),

	KEY(3, 0, KEY_NUMERIC_STAR),
	KEY(3, 1, KEY_NUMERIC_0),
	KEY(3, 2, KEY_NUMERIC_POUND),
	KEY(3, 3, KEY_DOWN),
	KEY(3, 4, KEY_RIGHT),

	KEY(4, 0, KEY_FN_F3),
	KEY(4, 1, KEY_FN_F4),
	KEY(4, 2, KEY_MUTE),
	KEY(4, 3, KEY_HOME),
	KEY(4, 4, KEY_BACK),

	KEY(5, 0, KEY_VOLUMEDOWN),
	KEY(5, 1, KEY_VOLUMEUP),
	KEY(5, 2, KEY_F1),
	KEY(5, 3, KEY_F2),
	KEY(5, 4, KEY_F3),
};

static const struct matrix_keymap_data keymap_data = {
	.keymap		= keymap,
	.keymap_size	= ARRAY_SIZE(keymap),
};

static struct matrix_keypad_platform_data keypad_config = {
	.keymap_data	= &keymap_data,
	.num_row_gpios	= 6,
	.num_col_gpios	= 5,
	.debounce_ms	= 0, /* minimum */
	.active_low	= 0, /* pull up realization */
	.no_autorepeat	= 0,
};

static void spi_select_device(int cs)
{
	static int gpio;

	if (!gpio) {
		int ret;
		ret = gpio_request(EVM_SPI_CS_GPIO, "spi chipsel");
		if (ret < 0) {
			pr_err("cannot open spi chipsel gpio\n");
			gpio = -ENOSYS;
			return;
		} else {
			gpio = EVM_SPI_CS_GPIO;
			gpio_direction_output(gpio, 0);
		}
	}

	if (gpio < 0)
		return;

	return gpio_set_value(gpio, cs ? 1 : 0);
}

static struct ti_ssp_spi_data spi_master_data = {
	.num_cs	= 2,
	.select	= spi_select_device,
	.iosel	= SSP_PIN_SEL(0, SSP_CLOCK)	| SSP_PIN_SEL(1, SSP_DATA) |
		  SSP_PIN_SEL(2, SSP_CHIPSEL)	| SSP_PIN_SEL(3, SSP_IN)   |
		  SSP_INPUT_SEL(3),
};

static struct ti_ssp_data ssp_config = {
	.out_clock	= 250 * 1000,
	.dev_data	= {
		[1] = {
			.dev_name = "ti-ssp-spi",
			.pdata = &spi_master_data,
			.pdata_size = sizeof(spi_master_data),
		},
	},
};

static struct tnetv107x_device_info evm_device_info __initconst = {
	.serial_config		= &serial_config,
	.mmc_config[1]		= &mmc_config,	/* controller 1 */
	.nand_config[0]		= &nand_config,	/* chip select 0 */
	.keypad_config		= &keypad_config,
	.ssp_config		= &ssp_config,
};

static struct spi_board_info spi_info[] __initconst = {
};

static __init void tnetv107x_evm_board_init(void)
{
	davinci_cfg_reg_list(sdio1_pins);
	davinci_cfg_reg_list(uart1_pins);
	davinci_cfg_reg_list(ssp_pins);

	tnetv107x_devices_init(&evm_device_info);

	spi_register_board_info(spi_info, ARRAY_SIZE(spi_info));
}

#ifdef CONFIG_SERIAL_8250_CONSOLE
static int __init tnetv107x_evm_console_init(void)
{
	return add_preferred_console("ttyS", 0, "115200");
}
console_initcall(tnetv107x_evm_console_init);
#endif

MACHINE_START(TNETV107X, "TNETV107X EVM")
	.atag_offset	= 0x100,
	.map_io		= tnetv107x_init,
	.init_irq	= cp_intc_init,
	.init_time	= davinci_timer_init,
	.init_machine	= tnetv107x_evm_board_init,
	.init_late	= davinci_init_late,
	.dma_zone_size	= SZ_128M,
	.restart	= tnetv107x_restart,
MACHINE_END
Commit	Line	Data
57a58a2e CC	1	/*
	2	* Texas Instruments TNETV107X EVM Board Support
	3	*
	4	* Copyright (C) 2010 Texas Instruments
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation version 2.
	9	*
	10	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	11	* kind, whether express or implied; without even the implied warranty
	12	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*/
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/console.h>
	18	#include <linux/dma-mapping.h>
	19	#include <linux/interrupt.h>
	20	#include <linux/gpio.h>
	21	#include <linux/delay.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/ratelimit.h>
	24	#include <linux/mtd/mtd.h>
	25	#include <linux/mtd/partitions.h>
a1b44403 CC	26	#include <linux/input.h>
a1b44403 CC	27	#include <linux/input/matrix_keypad.h>
f6e5306e	28	#include <linux/spi/spi.h>
a1b44403	29
57a58a2e CC	30	#include <asm/mach/arch.h>
	31	#include <asm/mach-types.h>
	32
	33	#include <mach/irqs.h>
	34	#include <mach/edma.h>
	35	#include <mach/mux.h>
	36	#include <mach/cp_intc.h>
	37	#include <mach/tnetv107x.h>
	38
	39	#define EVM_MMC_WP_GPIO 21
	40	#define EVM_MMC_CD_GPIO 24
f6e5306e	41	#define EVM_SPI_CS_GPIO 54
57a58a2e CC	42
	43	static int initialize_gpio(int gpio, char *desc)
	44	{
	45	int ret;
	46
	47	ret = gpio_request(gpio, desc);
	48	if (ret < 0) {
	49	pr_err_ratelimited("cannot open %s gpio\n", desc);
	50	return -ENOSYS;
	51	}
	52	gpio_direction_input(gpio);
	53	return gpio;
	54	}
	55
	56	static int mmc_get_cd(int index)
	57	{
	58	static int gpio;
	59
	60	if (!gpio)
	61	gpio = initialize_gpio(EVM_MMC_CD_GPIO, "mmc card detect");
	62
	63	if (gpio < 0)
	64	return gpio;
	65
	66	return gpio_get_value(gpio) ? 0 : 1;
	67	}
	68
	69	static int mmc_get_ro(int index)
	70	{
	71	static int gpio;
	72
	73	if (!gpio)
	74	gpio = initialize_gpio(EVM_MMC_WP_GPIO, "mmc write protect");
	75
	76	if (gpio < 0)
	77	return gpio;
	78
	79	return gpio_get_value(gpio) ? 1 : 0;
	80	}
	81
	82	static struct davinci_mmc_config mmc_config = {
	83	.get_cd = mmc_get_cd,
	84	.get_ro = mmc_get_ro,
	85	.wires = 4,
	86	.max_freq = 50000000,
	87	.caps = MMC_CAP_MMC_HIGHSPEED \| MMC_CAP_SD_HIGHSPEED,
57a58a2e CC	88	};
57a58a2e CC	89
bcad6dc3	90	static const short sdio1_pins[] __initconst = {
57a58a2e CC	91	TNETV107X_SDIO1_CLK_1, TNETV107X_SDIO1_CMD_1,
	92	TNETV107X_SDIO1_DATA0_1, TNETV107X_SDIO1_DATA1_1,
	93	TNETV107X_SDIO1_DATA2_1, TNETV107X_SDIO1_DATA3_1,
	94	TNETV107X_GPIO21, TNETV107X_GPIO24,
	95	-1
	96	};
	97
bcad6dc3	98	static const short uart1_pins[] __initconst = {
57a58a2e CC	99	TNETV107X_UART1_RD, TNETV107X_UART1_TD,
	100	-1
	101	};
	102
bcad6dc3	103	static const short ssp_pins[] __initconst = {
08e0e1d5 CC	104	TNETV107X_SSP0_0, TNETV107X_SSP0_1, TNETV107X_SSP0_2,
	105	TNETV107X_SSP1_0, TNETV107X_SSP1_1, TNETV107X_SSP1_2,
	106	TNETV107X_SSP1_3, -1
	107	};
	108
57a58a2e CC	109	static struct mtd_partition nand_partitions[] = {
	110	/* bootloader (U-Boot, etc) in first 12 sectors */
	111	{
	112	.name = "bootloader",
	113	.offset = 0,
	114	.size = (12*SZ_128K),
	115	.mask_flags = MTD_WRITEABLE, /* force read-only */
	116	},
	117	/* bootloader params in the next sector */
	118	{
	119	.name = "params",
	120	.offset = MTDPART_OFS_NXTBLK,
	121	.size = SZ_128K,
	122	.mask_flags = MTD_WRITEABLE, /* force read-only */
	123	},
	124	/* kernel */
	125	{
	126	.name = "kernel",
	127	.offset = MTDPART_OFS_NXTBLK,
	128	.size = SZ_4M,
	129	.mask_flags = 0,
	130	},
	131	/* file system */
	132	{
	133	.name = "filesystem",
	134	.offset = MTDPART_OFS_NXTBLK,
	135	.size = MTDPART_SIZ_FULL,
	136	.mask_flags = 0,
	137	}
	138	};
	139
	140	static struct davinci_nand_pdata nand_config = {
	141	.mask_cle = 0x4000,
	142	.mask_ale = 0x2000,
	143	.parts = nand_partitions,
	144	.nr_parts = ARRAY_SIZE(nand_partitions),
	145	.ecc_mode = NAND_ECC_HW,
bb9ebd4e	146	.bbt_options = NAND_BBT_USE_FLASH,
57a58a2e CC	147	.ecc_bits = 1,
	148	};
	149
	150	static struct davinci_uart_config serial_config __initconst = {
	151	.enabled_uarts = BIT(1),
	152	};
	153
a1b44403 CC	154	static const uint32_t keymap[] = {
	155	KEY(0, 0, KEY_NUMERIC_1),
	156	KEY(0, 1, KEY_NUMERIC_2),
	157	KEY(0, 2, KEY_NUMERIC_3),
	158	KEY(0, 3, KEY_FN_F1),
	159	KEY(0, 4, KEY_MENU),
	160
	161	KEY(1, 0, KEY_NUMERIC_4),
	162	KEY(1, 1, KEY_NUMERIC_5),
	163	KEY(1, 2, KEY_NUMERIC_6),
	164	KEY(1, 3, KEY_UP),
	165	KEY(1, 4, KEY_FN_F2),
	166
	167	KEY(2, 0, KEY_NUMERIC_7),
	168	KEY(2, 1, KEY_NUMERIC_8),
	169	KEY(2, 2, KEY_NUMERIC_9),
	170	KEY(2, 3, KEY_LEFT),
	171	KEY(2, 4, KEY_ENTER),
	172
	173	KEY(3, 0, KEY_NUMERIC_STAR),
	174	KEY(3, 1, KEY_NUMERIC_0),
	175	KEY(3, 2, KEY_NUMERIC_POUND),
	176	KEY(3, 3, KEY_DOWN),
	177	KEY(3, 4, KEY_RIGHT),
	178
	179	KEY(4, 0, KEY_FN_F3),
	180	KEY(4, 1, KEY_FN_F4),
	181	KEY(4, 2, KEY_MUTE),
	182	KEY(4, 3, KEY_HOME),
	183	KEY(4, 4, KEY_BACK),
	184
	185	KEY(5, 0, KEY_VOLUMEDOWN),
	186	KEY(5, 1, KEY_VOLUMEUP),
	187	KEY(5, 2, KEY_F1),
	188	KEY(5, 3, KEY_F2),
	189	KEY(5, 4, KEY_F3),
	190	};
	191
	192	static const struct matrix_keymap_data keymap_data = {
	193	.keymap = keymap,
	194	.keymap_size = ARRAY_SIZE(keymap),
	195	};
	196
	197	static struct matrix_keypad_platform_data keypad_config = {
	198	.keymap_data = &keymap_data,
	199	.num_row_gpios = 6,
	200	.num_col_gpios = 5,
	201	.debounce_ms = 0, /* minimum */
	202	.active_low = 0, /* pull up realization */
	203	.no_autorepeat = 0,
	204	};
	205
f6e5306e CC	206	static void spi_select_device(int cs)
	207	{
	208	static int gpio;
	209
	210	if (!gpio) {
	211	int ret;
	212	ret = gpio_request(EVM_SPI_CS_GPIO, "spi chipsel");
	213	if (ret < 0) {
	214	pr_err("cannot open spi chipsel gpio\n");
	215	gpio = -ENOSYS;
	216	return;
	217	} else {
	218	gpio = EVM_SPI_CS_GPIO;
	219	gpio_direction_output(gpio, 0);
	220	}
	221	}
	222
	223	if (gpio < 0)
	224	return;
	225
	226	return gpio_set_value(gpio, cs ? 1 : 0);
	227	}
	228
	229	static struct ti_ssp_spi_data spi_master_data = {
	230	.num_cs = 2,
	231	.select = spi_select_device,
	232	.iosel = SSP_PIN_SEL(0, SSP_CLOCK) \| SSP_PIN_SEL(1, SSP_DATA) \|
	233	SSP_PIN_SEL(2, SSP_CHIPSEL) \| SSP_PIN_SEL(3, SSP_IN) \|
	234	SSP_INPUT_SEL(3),
	235	};
	236
08e0e1d5 CC	237	static struct ti_ssp_data ssp_config = {
	238	.out_clock = 250 * 1000,
	239	.dev_data = {
f6e5306e CC	240	[1] = {
	241	.dev_name = "ti-ssp-spi",
	242	.pdata = &spi_master_data,
	243	.pdata_size = sizeof(spi_master_data),
	244	},
08e0e1d5 CC	245	},
	246	};
	247
57a58a2e CC	248	static struct tnetv107x_device_info evm_device_info __initconst = {
	249	.serial_config = &serial_config,
	250	.mmc_config[1] = &mmc_config, /* controller 1 */
	251	.nand_config[0] = &nand_config, /* chip select 0 */
a1b44403	252	.keypad_config = &keypad_config,
08e0e1d5	253	.ssp_config = &ssp_config,
57a58a2e CC	254	};
57a58a2e CC	255
f6e5306e CC	256	static struct spi_board_info spi_info[] __initconst = {
	257	};
	258
57a58a2e CC	259	static __init void tnetv107x_evm_board_init(void)
	260	{
	261	davinci_cfg_reg_list(sdio1_pins);
	262	davinci_cfg_reg_list(uart1_pins);
08e0e1d5	263	davinci_cfg_reg_list(ssp_pins);
57a58a2e CC	264
57a58a2e CC	265	tnetv107x_devices_init(&evm_device_info);
f6e5306e CC	266
f6e5306e CC	267	spi_register_board_info(spi_info, ARRAY_SIZE(spi_info));
57a58a2e CC	268	}
	269
	270	#ifdef CONFIG_SERIAL_8250_CONSOLE
	271	static int __init tnetv107x_evm_console_init(void)
	272	{
	273	return add_preferred_console("ttyS", 0, "115200");
	274	}
	275	console_initcall(tnetv107x_evm_console_init);
	276	#endif
	277
	278	MACHINE_START(TNETV107X, "TNETV107X EVM")
e7e56014	279	.atag_offset = 0x100,
57a58a2e CC	280	.map_io = tnetv107x_init,
57a58a2e CC	281	.init_irq = cp_intc_init,
6bb27d73	282	.init_time = davinci_timer_init,
57a58a2e	283	.init_machine = tnetv107x_evm_board_init,
3aa3e840	284	.init_late = davinci_init_late,
f68deabf	285	.dma_zone_size = SZ_128M,
c6121ddd	286	.restart = tnetv107x_restart,
57a58a2e	287	MACHINE_END