[net-next-2.6.git] / arch / arm / mach-mx3 / mach-cpuimx35.c

/*
 * Copyright (C) 2010 Eric Benard - eric@eukrea.com
 * Copyright (C) 2009 Sascha Hauer, Pengutronix
 *
 * 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; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/types.h>
#include <linux/init.h>

#include <linux/platform_device.h>
#include <linux/mtd/physmap.h>
#include <linux/memory.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/i2c/tsc2007.h>
#include <linux/usb/otg.h>
#include <linux/usb/ulpi.h>
#include <linux/fsl_devices.h>

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

#include <mach/eukrea-baseboards.h>
#include <mach/hardware.h>
#include <mach/common.h>
#include <mach/iomux-mx35.h>
#include <mach/mxc_nand.h>
#include <mach/mxc_ehci.h>
#include <mach/ulpi.h>

#include "devices-imx35.h"
#include "devices.h"

static const struct imxuart_platform_data uart_pdata __initconst = {
	.flags = IMXUART_HAVE_RTSCTS,
};

static const struct imxi2c_platform_data
eukrea_cpuimx35_i2c0_data __initconst = {
	.bitrate = 50000,
};

#define TSC2007_IRQGPIO		(2 * 32 + 2)
static int ts_get_pendown_state(void)
{
	int val = 0;
	gpio_free(TSC2007_IRQGPIO);
	gpio_request(TSC2007_IRQGPIO, NULL);
	gpio_direction_input(TSC2007_IRQGPIO);

	val = gpio_get_value(TSC2007_IRQGPIO);

	gpio_free(TSC2007_IRQGPIO);
	gpio_request(TSC2007_IRQGPIO, NULL);

	return val ? 0 : 1;
}

static int ts_init(void)
{
	gpio_request(TSC2007_IRQGPIO, NULL);
	return 0;
}

static struct tsc2007_platform_data tsc2007_info = {
	.model			= 2007,
	.x_plate_ohms		= 180,
	.get_pendown_state	= ts_get_pendown_state,
	.init_platform_hw	= ts_init,
};

static struct i2c_board_info eukrea_cpuimx35_i2c_devices[] = {
	{
		I2C_BOARD_INFO("pcf8563", 0x51),
	}, {
		I2C_BOARD_INFO("tsc2007", 0x48),
		.type		= "tsc2007",
		.platform_data	= &tsc2007_info,
		.irq		= gpio_to_irq(TSC2007_IRQGPIO),
	},
};

static struct platform_device *devices[] __initdata = {
	&mxc_fec_device,
	&imx_wdt_device0,
};

static struct pad_desc eukrea_cpuimx35_pads[] = {
	/* UART1 */
	MX35_PAD_CTS1__UART1_CTS,
	MX35_PAD_RTS1__UART1_RTS,
	MX35_PAD_TXD1__UART1_TXD_MUX,
	MX35_PAD_RXD1__UART1_RXD_MUX,
	/* FEC */
	MX35_PAD_FEC_TX_CLK__FEC_TX_CLK,
	MX35_PAD_FEC_RX_CLK__FEC_RX_CLK,
	MX35_PAD_FEC_RX_DV__FEC_RX_DV,
	MX35_PAD_FEC_COL__FEC_COL,
	MX35_PAD_FEC_RDATA0__FEC_RDATA_0,
	MX35_PAD_FEC_TDATA0__FEC_TDATA_0,
	MX35_PAD_FEC_TX_EN__FEC_TX_EN,
	MX35_PAD_FEC_MDC__FEC_MDC,
	MX35_PAD_FEC_MDIO__FEC_MDIO,
	MX35_PAD_FEC_TX_ERR__FEC_TX_ERR,
	MX35_PAD_FEC_RX_ERR__FEC_RX_ERR,
	MX35_PAD_FEC_CRS__FEC_CRS,
	MX35_PAD_FEC_RDATA1__FEC_RDATA_1,
	MX35_PAD_FEC_TDATA1__FEC_TDATA_1,
	MX35_PAD_FEC_RDATA2__FEC_RDATA_2,
	MX35_PAD_FEC_TDATA2__FEC_TDATA_2,
	MX35_PAD_FEC_RDATA3__FEC_RDATA_3,
	MX35_PAD_FEC_TDATA3__FEC_TDATA_3,
	/* I2C1 */
	MX35_PAD_I2C1_CLK__I2C1_SCL,
	MX35_PAD_I2C1_DAT__I2C1_SDA,
	/* TSC2007 IRQ */
	MX35_PAD_ATA_DA2__GPIO3_2,
};

static const struct mxc_nand_platform_data
eukrea_cpuimx35_nand_board_info __initconst = {
	.width		= 1,
	.hw_ecc		= 1,
	.flash_bbt	= 1,
};

static struct mxc_usbh_platform_data otg_pdata = {
	.portsc	= MXC_EHCI_MODE_UTMI,
	.flags	= MXC_EHCI_INTERFACE_DIFF_UNI,
};

static struct mxc_usbh_platform_data usbh1_pdata = {
	.portsc	= MXC_EHCI_MODE_SERIAL,
	.flags	= MXC_EHCI_INTERFACE_SINGLE_UNI | MXC_EHCI_INTERNAL_PHY |
		  MXC_EHCI_IPPUE_DOWN,
};

static struct fsl_usb2_platform_data otg_device_pdata = {
	.operating_mode	= FSL_USB2_DR_DEVICE,
	.phy_mode	= FSL_USB2_PHY_UTMI,
};

static int otg_mode_host;

static int __init eukrea_cpuimx35_otg_mode(char *options)
{
	if (!strcmp(options, "host"))
		otg_mode_host = 1;
	else if (!strcmp(options, "device"))
		otg_mode_host = 0;
	else
		pr_info("otg_mode neither \"host\" nor \"device\". "
			"Defaulting to device\n");
	return 0;
}
__setup("otg_mode=", eukrea_cpuimx35_otg_mode);

/*
 * Board specific initialization.
 */
static void __init mxc_board_init(void)
{
	mxc_iomux_v3_setup_multiple_pads(eukrea_cpuimx35_pads,
			ARRAY_SIZE(eukrea_cpuimx35_pads));

	platform_add_devices(devices, ARRAY_SIZE(devices));

	imx35_add_imx_uart0(&uart_pdata);
	imx35_add_mxc_nand(&eukrea_cpuimx35_nand_board_info);

	i2c_register_board_info(0, eukrea_cpuimx35_i2c_devices,
			ARRAY_SIZE(eukrea_cpuimx35_i2c_devices));
	imx35_add_imx_i2c0(&eukrea_cpuimx35_i2c0_data);

#if defined(CONFIG_USB_ULPI)
	if (otg_mode_host) {
		otg_pdata.otg = otg_ulpi_create(&mxc_ulpi_access_ops,
				ULPI_OTG_DRVVBUS | ULPI_OTG_DRVVBUS_EXT);

		mxc_register_device(&mxc_otg_host, &otg_pdata);
	}
	mxc_register_device(&mxc_usbh1, &usbh1_pdata);
#endif
	if (!otg_mode_host)
		mxc_register_device(&mxc_otg_udc_device, &otg_device_pdata);

#ifdef CONFIG_MACH_EUKREA_MBIMXSD_BASEBOARD
	eukrea_mbimxsd_baseboard_init();
#endif
}

static void __init eukrea_cpuimx35_timer_init(void)
{
	mx35_clocks_init();
}

struct sys_timer eukrea_cpuimx35_timer = {
	.init	= eukrea_cpuimx35_timer_init,
};

MACHINE_START(EUKREA_CPUIMX35, "Eukrea CPUIMX35")
	/* Maintainer: Eukrea Electromatique */
	.phys_io	= MX35_AIPS1_BASE_ADDR,
	.io_pg_offst	= ((MX35_AIPS1_BASE_ADDR_VIRT) >> 18) & 0xfffc,
	.boot_params    = MX3x_PHYS_OFFSET + 0x100,
	.map_io         = mx35_map_io,
	.init_irq       = mx35_init_irq,
	.init_machine   = mxc_board_init,
	.timer          = &eukrea_cpuimx35_timer,
MACHINE_END
Commit	Line	Data
21744f19 EB	1	/*
	2	* Copyright (C) 2010 Eric Benard - eric@eukrea.com
	3	* Copyright (C) 2009 Sascha Hauer, Pengutronix
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
	20	#include <linux/types.h>
	21	#include <linux/init.h>
	22
	23	#include <linux/platform_device.h>
	24	#include <linux/mtd/physmap.h>
	25	#include <linux/memory.h>
	26	#include <linux/gpio.h>
	27	#include <linux/interrupt.h>
	28	#include <linux/delay.h>
	29	#include <linux/i2c.h>
	30	#include <linux/i2c/tsc2007.h>
	31	#include <linux/usb/otg.h>
	32	#include <linux/usb/ulpi.h>
	33	#include <linux/fsl_devices.h>
	34
	35	#include <asm/mach-types.h>
	36	#include <asm/mach/arch.h>
	37	#include <asm/mach/time.h>
	38	#include <asm/mach/map.h>
	39
95afd090	40	#include <mach/eukrea-baseboards.h>
21744f19 EB	41	#include <mach/hardware.h>
21744f19 EB	42	#include <mach/common.h>
21744f19 EB	43	#include <mach/iomux-mx35.h>
	44	#include <mach/mxc_nand.h>
	45	#include <mach/mxc_ehci.h>
	46	#include <mach/ulpi.h>
	47
2dcf78c0	48	#include "devices-imx35.h"
21744f19 EB	49	#include "devices.h"
21744f19 EB	50
2dcf78c0	51	static const struct imxuart_platform_data uart_pdata __initconst = {
21744f19 EB	52	.flags = IMXUART_HAVE_RTSCTS,
	53	};
	54
2dcf78c0 UKK	55	static const struct imxi2c_platform_data
2dcf78c0 UKK	56	eukrea_cpuimx35_i2c0_data __initconst = {
21744f19 EB	57	.bitrate = 50000,
	58	};
	59
	60	#define TSC2007_IRQGPIO (2 * 32 + 2)
	61	static int ts_get_pendown_state(void)
	62	{
	63	int val = 0;
	64	gpio_free(TSC2007_IRQGPIO);
	65	gpio_request(TSC2007_IRQGPIO, NULL);
	66	gpio_direction_input(TSC2007_IRQGPIO);
	67
	68	val = gpio_get_value(TSC2007_IRQGPIO);
	69
	70	gpio_free(TSC2007_IRQGPIO);
	71	gpio_request(TSC2007_IRQGPIO, NULL);
	72
	73	return val ? 0 : 1;
	74	}
	75
	76	static int ts_init(void)
	77	{
	78	gpio_request(TSC2007_IRQGPIO, NULL);
	79	return 0;
	80	}
	81
	82	static struct tsc2007_platform_data tsc2007_info = {
	83	.model = 2007,
	84	.x_plate_ohms = 180,
	85	.get_pendown_state = ts_get_pendown_state,
	86	.init_platform_hw = ts_init,
	87	};
	88
	89	static struct i2c_board_info eukrea_cpuimx35_i2c_devices[] = {
	90	{
	91	I2C_BOARD_INFO("pcf8563", 0x51),
	92	}, {
	93	I2C_BOARD_INFO("tsc2007", 0x48),
	94	.type = "tsc2007",
	95	.platform_data = &tsc2007_info,
	96	.irq = gpio_to_irq(TSC2007_IRQGPIO),
	97	},
	98	};
	99
	100	static struct platform_device *devices[] __initdata = {
	101	&mxc_fec_device,
	102	&imx_wdt_device0,
	103	};
	104
	105	static struct pad_desc eukrea_cpuimx35_pads[] = {
	106	/* UART1 */
	107	MX35_PAD_CTS1__UART1_CTS,
	108	MX35_PAD_RTS1__UART1_RTS,
	109	MX35_PAD_TXD1__UART1_TXD_MUX,
	110	MX35_PAD_RXD1__UART1_RXD_MUX,
	111	/* FEC */
	112	MX35_PAD_FEC_TX_CLK__FEC_TX_CLK,
	113	MX35_PAD_FEC_RX_CLK__FEC_RX_CLK,
	114	MX35_PAD_FEC_RX_DV__FEC_RX_DV,
	115	MX35_PAD_FEC_COL__FEC_COL,
	116	MX35_PAD_FEC_RDATA0__FEC_RDATA_0,
	117	MX35_PAD_FEC_TDATA0__FEC_TDATA_0,
	118	MX35_PAD_FEC_TX_EN__FEC_TX_EN,
	119	MX35_PAD_FEC_MDC__FEC_MDC,
	120	MX35_PAD_FEC_MDIO__FEC_MDIO,
121	MX35_PAD_FEC_TX_ERR__FEC_TX_ERR,
122	MX35_PAD_FEC_RX_ERR__FEC_RX_ERR,
123	MX35_PAD_FEC_CRS__FEC_CRS,
124	MX35_PAD_FEC_RDATA1__FEC_RDATA_1,
125	MX35_PAD_FEC_TDATA1__FEC_TDATA_1,
126	MX35_PAD_FEC_RDATA2__FEC_RDATA_2,
127	MX35_PAD_FEC_TDATA2__FEC_TDATA_2,
128	MX35_PAD_FEC_RDATA3__FEC_RDATA_3,
129	MX35_PAD_FEC_TDATA3__FEC_TDATA_3,
130	/* I2C1 */
131	MX35_PAD_I2C1_CLK__I2C1_SCL,
132	MX35_PAD_I2C1_DAT__I2C1_SDA,
133	/* TSC2007 IRQ */
134	MX35_PAD_ATA_DA2__GPIO3_2,
135	};
136
2dcf78c0 UKK	137	static const struct mxc_nand_platform_data
2dcf78c0 UKK	138	eukrea_cpuimx35_nand_board_info __initconst = {
21744f19 EB	139	.width = 1,
	140	.hw_ecc = 1,
	141	.flash_bbt = 1,
	142	};
	143
	144	static struct mxc_usbh_platform_data otg_pdata = {
	145	.portsc = MXC_EHCI_MODE_UTMI,
	146	.flags = MXC_EHCI_INTERFACE_DIFF_UNI,
	147	};
	148
	149	static struct mxc_usbh_platform_data usbh1_pdata = {
	150	.portsc = MXC_EHCI_MODE_SERIAL,
	151	.flags = MXC_EHCI_INTERFACE_SINGLE_UNI \| MXC_EHCI_INTERNAL_PHY \|
	152	MXC_EHCI_IPPUE_DOWN,
	153	};
	154
	155	static struct fsl_usb2_platform_data otg_device_pdata = {
	156	.operating_mode = FSL_USB2_DR_DEVICE,
	157	.phy_mode = FSL_USB2_PHY_UTMI,
	158	};
	159
	160	static int otg_mode_host;
	161
	162	static int __init eukrea_cpuimx35_otg_mode(char *options)
	163	{
	164	if (!strcmp(options, "host"))
	165	otg_mode_host = 1;
	166	else if (!strcmp(options, "device"))
	167	otg_mode_host = 0;
	168	else
	169	pr_info("otg_mode neither \"host\" nor \"device\". "
	170	"Defaulting to device\n");
	171	return 0;
	172	}
	173	__setup("otg_mode=", eukrea_cpuimx35_otg_mode);
	174
	175	/*
	176	* Board specific initialization.
	177	*/
	178	static void __init mxc_board_init(void)
	179	{
	180	mxc_iomux_v3_setup_multiple_pads(eukrea_cpuimx35_pads,
	181	ARRAY_SIZE(eukrea_cpuimx35_pads));
	182
	183	platform_add_devices(devices, ARRAY_SIZE(devices));
	184
2dcf78c0 UKK	185	imx35_add_imx_uart0(&uart_pdata);
2dcf78c0 UKK	186	imx35_add_mxc_nand(&eukrea_cpuimx35_nand_board_info);
21744f19 EB	187
	188	i2c_register_board_info(0, eukrea_cpuimx35_i2c_devices,
	189	ARRAY_SIZE(eukrea_cpuimx35_i2c_devices));
2dcf78c0	190	imx35_add_imx_i2c0(&eukrea_cpuimx35_i2c0_data);
21744f19 EB	191
	192	#if defined(CONFIG_USB_ULPI)
	193	if (otg_mode_host) {
	194	otg_pdata.otg = otg_ulpi_create(&mxc_ulpi_access_ops,
70ddd47f	195	ULPI_OTG_DRVVBUS \| ULPI_OTG_DRVVBUS_EXT);
21744f19 EB	196
	197	mxc_register_device(&mxc_otg_host, &otg_pdata);
	198	}
	199	mxc_register_device(&mxc_usbh1, &usbh1_pdata);
	200	#endif
	201	if (!otg_mode_host)
	202	mxc_register_device(&mxc_otg_udc_device, &otg_device_pdata);
	203
	204	#ifdef CONFIG_MACH_EUKREA_MBIMXSD_BASEBOARD
	205	eukrea_mbimxsd_baseboard_init();
	206	#endif
	207	}
	208
	209	static void __init eukrea_cpuimx35_timer_init(void)
	210	{
	211	mx35_clocks_init();
	212	}
	213
	214	struct sys_timer eukrea_cpuimx35_timer = {
	215	.init = eukrea_cpuimx35_timer_init,
	216	};
	217
	218	MACHINE_START(EUKREA_CPUIMX35, "Eukrea CPUIMX35")
	219	/* Maintainer: Eukrea Electromatique */
	220	.phys_io = MX35_AIPS1_BASE_ADDR,
	221	.io_pg_offst = ((MX35_AIPS1_BASE_ADDR_VIRT) >> 18) & 0xfffc,
	222	.boot_params = MX3x_PHYS_OFFSET + 0x100,
	223	.map_io = mx35_map_io,
	224	.init_irq = mx35_init_irq,
	225	.init_machine = mxc_board_init,
	226	.timer = &eukrea_cpuimx35_timer,
	227	MACHINE_END