[deliverable/linux.git] / arch / arm / mach-omap2 / board-am3517evm.c

/*
 * linux/arch/arm/mach-omap2/board-am3517evm.c
 *
 * Copyright (C) 2009 Texas Instruments Incorporated
 * Author: Ranjith Lohithakshan <ranjithl@ti.com>
 *
 * Based on mach-omap2/board-omap3evm.c
 *
 * 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/platform_device.h>
#include <linux/gpio.h>
#include <linux/i2c/pca953x.h>
#include <linux/can/platform/ti_hecc.h>
#include <linux/davinci_emac.h>

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

#include <plat/board.h>
#include <plat/common.h>
#include <plat/control.h>
#include <plat/usb.h>
#include <plat/display.h>

#include "mux.h"

#define AM35XX_EVM_PHY_MASK		(0xF)
#define AM35XX_EVM_MDIO_FREQUENCY	(1000000)

static struct emac_platform_data am3517_evm_emac_pdata = {
	.phy_mask	= AM35XX_EVM_PHY_MASK,
	.mdio_max_freq	= AM35XX_EVM_MDIO_FREQUENCY,
	.rmii_en	= 1,
};

static struct resource am3517_emac_resources[] = {
	{
		.start  = AM35XX_IPSS_EMAC_BASE,
		.end    = AM35XX_IPSS_EMAC_BASE + 0x3FFFF,
		.flags  = IORESOURCE_MEM,
	},
	{
		.start  = INT_35XX_EMAC_C0_RXTHRESH_IRQ,
		.end    = INT_35XX_EMAC_C0_RXTHRESH_IRQ,
		.flags  = IORESOURCE_IRQ,
	},
	{
		.start  = INT_35XX_EMAC_C0_RX_PULSE_IRQ,
		.end    = INT_35XX_EMAC_C0_RX_PULSE_IRQ,
		.flags  = IORESOURCE_IRQ,
	},
	{
		.start  = INT_35XX_EMAC_C0_TX_PULSE_IRQ,
		.end    = INT_35XX_EMAC_C0_TX_PULSE_IRQ,
		.flags  = IORESOURCE_IRQ,
	},
	{
		.start  = INT_35XX_EMAC_C0_MISC_PULSE_IRQ,
		.end    = INT_35XX_EMAC_C0_MISC_PULSE_IRQ,
		.flags  = IORESOURCE_IRQ,
	},
};

static struct platform_device am3517_emac_device = {
	.name		= "davinci_emac",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(am3517_emac_resources),
	.resource	= am3517_emac_resources,
};

static void am3517_enable_ethernet_int(void)
{
	u32 regval;

	regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
	regval = (regval | AM35XX_CPGMAC_C0_RX_PULSE_CLR |
		AM35XX_CPGMAC_C0_TX_PULSE_CLR |
		AM35XX_CPGMAC_C0_MISC_PULSE_CLR |
		AM35XX_CPGMAC_C0_RX_THRESH_CLR);
	omap_ctrl_writel(regval, AM35XX_CONTROL_LVL_INTR_CLEAR);
	regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
}

static void am3517_disable_ethernet_int(void)
{
	u32 regval;

	regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
	regval = (regval | AM35XX_CPGMAC_C0_RX_PULSE_CLR |
		AM35XX_CPGMAC_C0_TX_PULSE_CLR);
	omap_ctrl_writel(regval, AM35XX_CONTROL_LVL_INTR_CLEAR);
	regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
}

void am3517_evm_ethernet_init(struct emac_platform_data *pdata)
{
	unsigned int regval;

	pdata->ctrl_reg_offset		= AM35XX_EMAC_CNTRL_OFFSET;
	pdata->ctrl_mod_reg_offset	= AM35XX_EMAC_CNTRL_MOD_OFFSET;
	pdata->ctrl_ram_offset		= AM35XX_EMAC_CNTRL_RAM_OFFSET;
	pdata->mdio_reg_offset		= AM35XX_EMAC_MDIO_OFFSET;
	pdata->ctrl_ram_size		= AM35XX_EMAC_CNTRL_RAM_SIZE;
	pdata->version			= EMAC_VERSION_2;
	pdata->hw_ram_addr		= AM35XX_EMAC_HW_RAM_ADDR;
	pdata->interrupt_enable		= am3517_enable_ethernet_int;
	pdata->interrupt_disable	= am3517_disable_ethernet_int;
	am3517_emac_device.dev.platform_data	= pdata;
	platform_device_register(&am3517_emac_device);

	regval = omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET);
	regval = regval & (~(AM35XX_CPGMACSS_SW_RST));
	omap_ctrl_writel(regval, AM35XX_CONTROL_IP_SW_RESET);
	regval = omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET);

	return ;
}


#define LCD_PANEL_PWR		176
#define LCD_PANEL_BKLIGHT_PWR	182
#define LCD_PANEL_PWM		181

static struct i2c_board_info __initdata am3517evm_i2c1_boardinfo[] = {
	{
		I2C_BOARD_INFO("s35390a", 0x30),
		.type		= "s35390a",
	},
};

/*
 * RTC - S35390A
 */
#define GPIO_RTCS35390A_IRQ	55

static void __init am3517_evm_rtc_init(void)
{
	int r;

	omap_mux_init_gpio(GPIO_RTCS35390A_IRQ, OMAP_PIN_INPUT_PULLUP);
	r = gpio_request(GPIO_RTCS35390A_IRQ, "rtcs35390a-irq");
	if (r < 0) {
		printk(KERN_WARNING "failed to request GPIO#%d\n",
				GPIO_RTCS35390A_IRQ);
		return;
	}
	r = gpio_direction_input(GPIO_RTCS35390A_IRQ);
	if (r < 0) {
		printk(KERN_WARNING "GPIO#%d cannot be configured as input\n",
				GPIO_RTCS35390A_IRQ);
		gpio_free(GPIO_RTCS35390A_IRQ);
		return;
	}
	am3517evm_i2c1_boardinfo[0].irq = gpio_to_irq(GPIO_RTCS35390A_IRQ);
}

/*
 * I2C GPIO Expander - TCA6416
 */

/* Mounted on Base-Board */
static struct pca953x_platform_data am3517evm_gpio_expander_info_0 = {
	.gpio_base	= OMAP_MAX_GPIO_LINES,
};
static struct i2c_board_info __initdata am3517evm_i2c2_boardinfo[] = {
	{
		I2C_BOARD_INFO("tca6416", 0x21),
		.platform_data = &am3517evm_gpio_expander_info_0,
	},
};

/* Mounted on UI Card */
static struct pca953x_platform_data am3517evm_ui_gpio_expander_info_1 = {
	.gpio_base	= OMAP_MAX_GPIO_LINES + 16,
};
static struct pca953x_platform_data am3517evm_ui_gpio_expander_info_2 = {
	.gpio_base	= OMAP_MAX_GPIO_LINES + 32,
};
static struct i2c_board_info __initdata am3517evm_i2c3_boardinfo[] = {
	{
		I2C_BOARD_INFO("tca6416", 0x20),
		.platform_data = &am3517evm_ui_gpio_expander_info_1,
	},
	{
		I2C_BOARD_INFO("tca6416", 0x21),
		.platform_data = &am3517evm_ui_gpio_expander_info_2,
	},
};

static int __init am3517_evm_i2c_init(void)
{
	omap_register_i2c_bus(1, 400, NULL, 0);
	omap_register_i2c_bus(2, 400, am3517evm_i2c2_boardinfo,
			ARRAY_SIZE(am3517evm_i2c2_boardinfo));
	omap_register_i2c_bus(3, 400, am3517evm_i2c3_boardinfo,
			ARRAY_SIZE(am3517evm_i2c3_boardinfo));

	return 0;
}

static int lcd_enabled;
static int dvi_enabled;

#if defined(CONFIG_PANEL_SHARP_LQ043T1DG01) || \
		defined(CONFIG_PANEL_SHARP_LQ043T1DG01_MODULE)
static void __init am3517_evm_display_init(void)
{
	int r;

	omap_mux_init_gpio(LCD_PANEL_PWR, OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_gpio(LCD_PANEL_BKLIGHT_PWR, OMAP_PIN_INPUT_PULLDOWN);
	omap_mux_init_gpio(LCD_PANEL_PWM, OMAP_PIN_INPUT_PULLDOWN);
	/*
	 * Enable GPIO 182 = LCD Backlight Power
	 */
	r = gpio_request(LCD_PANEL_BKLIGHT_PWR, "lcd_backlight_pwr");
	if (r) {
		printk(KERN_ERR "failed to get lcd_backlight_pwr\n");
		return;
	}
	gpio_direction_output(LCD_PANEL_BKLIGHT_PWR, 1);
	/*
	 * Enable GPIO 181 = LCD Panel PWM
	 */
	r = gpio_request(LCD_PANEL_PWM, "lcd_pwm");
	if (r) {
		printk(KERN_ERR "failed to get lcd_pwm\n");
		goto err_1;
	}
	gpio_direction_output(LCD_PANEL_PWM, 1);
	/*
	 * Enable GPIO 176 = LCD Panel Power enable pin
	 */
	r = gpio_request(LCD_PANEL_PWR, "lcd_panel_pwr");
	if (r) {
		printk(KERN_ERR "failed to get lcd_panel_pwr\n");
		goto err_2;
	}
	gpio_direction_output(LCD_PANEL_PWR, 1);

	printk(KERN_INFO "Display initialized successfully\n");
	return;

err_2:
	gpio_free(LCD_PANEL_PWM);
err_1:
	gpio_free(LCD_PANEL_BKLIGHT_PWR);
}
#else
static void __init am3517_evm_display_init(void) {}
#endif

static int am3517_evm_panel_enable_lcd(struct omap_dss_device *dssdev)
{
	if (dvi_enabled) {
		printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
		return -EINVAL;
	}
	gpio_set_value(LCD_PANEL_PWR, 1);
	lcd_enabled = 1;

	return 0;
}

static void am3517_evm_panel_disable_lcd(struct omap_dss_device *dssdev)
{
	gpio_set_value(LCD_PANEL_PWR, 0);
	lcd_enabled = 0;
}

static struct omap_dss_device am3517_evm_lcd_device = {
	.type			= OMAP_DISPLAY_TYPE_DPI,
	.name			= "lcd",
	.driver_name		= "sharp_lq_panel",
	.phy.dpi.data_lines 	= 16,
	.platform_enable	= am3517_evm_panel_enable_lcd,
	.platform_disable	= am3517_evm_panel_disable_lcd,
};

static int am3517_evm_panel_enable_tv(struct omap_dss_device *dssdev)
{
	return 0;
}

static void am3517_evm_panel_disable_tv(struct omap_dss_device *dssdev)
{
}

static struct omap_dss_device am3517_evm_tv_device = {
	.type 			= OMAP_DISPLAY_TYPE_VENC,
	.name 			= "tv",
	.driver_name		= "venc",
	.phy.venc.type		= OMAP_DSS_VENC_TYPE_SVIDEO,
	.platform_enable	= am3517_evm_panel_enable_tv,
	.platform_disable	= am3517_evm_panel_disable_tv,
};

static int am3517_evm_panel_enable_dvi(struct omap_dss_device *dssdev)
{
	if (lcd_enabled) {
		printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
		return -EINVAL;
	}
	dvi_enabled = 1;

	return 0;
}

static void am3517_evm_panel_disable_dvi(struct omap_dss_device *dssdev)
{
	dvi_enabled = 0;
}

static struct omap_dss_device am3517_evm_dvi_device = {
	.type			= OMAP_DISPLAY_TYPE_DPI,
	.name			= "dvi",
	.driver_name		= "generic_panel",
	.phy.dpi.data_lines	= 24,
	.platform_enable	= am3517_evm_panel_enable_dvi,
	.platform_disable	= am3517_evm_panel_disable_dvi,
};

static struct omap_dss_device *am3517_evm_dss_devices[] = {
	&am3517_evm_lcd_device,
	&am3517_evm_tv_device,
	&am3517_evm_dvi_device,
};

static struct omap_dss_board_info am3517_evm_dss_data = {
	.num_devices	= ARRAY_SIZE(am3517_evm_dss_devices),
	.devices	= am3517_evm_dss_devices,
	.default_device	= &am3517_evm_lcd_device,
};

struct platform_device am3517_evm_dss_device = {
	.name		= "omapdss",
	.id		= -1,
	.dev		= {
		.platform_data	= &am3517_evm_dss_data,
	},
};

/*
 * Board initialization
 */
static struct omap_board_config_kernel am3517_evm_config[] __initdata = {
};

static struct platform_device *am3517_evm_devices[] __initdata = {
	&am3517_evm_dss_device,
};

static void __init am3517_evm_init_irq(void)
{
	omap_board_config = am3517_evm_config;
	omap_board_config_size = ARRAY_SIZE(am3517_evm_config);

	omap2_init_common_hw(NULL, NULL);
	omap_init_irq();
	omap_gpio_init();
}

static const struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
	.port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
#if defined(CONFIG_PANEL_SHARP_LQ043T1DG01) || \
		defined(CONFIG_PANEL_SHARP_LQ043T1DG01_MODULE)
	.port_mode[1] = EHCI_HCD_OMAP_MODE_UNKNOWN,
#else
	.port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
#endif
	.port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,

	.phy_reset  = true,
	.reset_gpio_port[0]  = 57,
	.reset_gpio_port[1]  = -EINVAL,
	.reset_gpio_port[2]  = -EINVAL
};

#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux board_mux[] __initdata = {
	{ .reg_offset = OMAP_MUX_TERMINATOR },
};
#else
#define board_mux	NULL
#endif


static struct resource am3517_hecc_resources[] = {
	{
		.start	= AM35XX_IPSS_HECC_BASE,
		.end	= AM35XX_IPSS_HECC_BASE + 0x3FFF,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= INT_35XX_HECC0_IRQ,
		.end	= INT_35XX_HECC0_IRQ,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device am3517_hecc_device = {
	.name		= "ti_hecc",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(am3517_hecc_resources),
	.resource	= am3517_hecc_resources,
};

static struct ti_hecc_platform_data am3517_evm_hecc_pdata = {
	.scc_hecc_offset	= AM35XX_HECC_SCC_HECC_OFFSET,
	.scc_ram_offset		= AM35XX_HECC_SCC_RAM_OFFSET,
	.hecc_ram_offset	= AM35XX_HECC_RAM_OFFSET,
	.mbx_offset		= AM35XX_HECC_MBOX_OFFSET,
	.int_line		= AM35XX_HECC_INT_LINE,
	.version		= AM35XX_HECC_VERSION,
};

static void am3517_evm_hecc_init(struct ti_hecc_platform_data *pdata)
{
	am3517_hecc_device.dev.platform_data = pdata;
	platform_device_register(&am3517_hecc_device);
}

static void __init am3517_evm_init(void)
{
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);

	am3517_evm_i2c_init();
	platform_add_devices(am3517_evm_devices,
				ARRAY_SIZE(am3517_evm_devices));

	omap_serial_init();

	/* Configure GPIO for EHCI port */
	omap_mux_init_gpio(57, OMAP_PIN_OUTPUT);
	usb_ehci_init(&ehci_pdata);
	am3517_evm_hecc_init(&am3517_evm_hecc_pdata);
	/* DSS */
	am3517_evm_display_init();

	/* RTC - S35390A */
	am3517_evm_rtc_init();

	i2c_register_board_info(1, am3517evm_i2c1_boardinfo,
				ARRAY_SIZE(am3517evm_i2c1_boardinfo));
	/*Ethernet*/
	am3517_evm_ethernet_init(&am3517_evm_emac_pdata);
}

MACHINE_START(OMAP3517EVM, "OMAP3517/AM3517 EVM")
	.phys_io	= 0x48000000,
	.io_pg_offst	= ((0xd8000000) >> 18) & 0xfffc,
	.boot_params	= 0x80000100,
	.map_io		= omap3_map_io,
	.reserve	= omap_reserve,
	.init_irq	= am3517_evm_init_irq,
	.init_machine	= am3517_evm_init,
	.timer		= &omap_timer,
MACHINE_END
Commit	Line	Data
c625327e RL	1	/*
	2	* linux/arch/arm/mach-omap2/board-am3517evm.c
	3	*
	4	* Copyright (C) 2009 Texas Instruments Incorporated
	5	* Author: Ranjith Lohithakshan <ranjithl@ti.com>
	6	*
	7	* Based on mach-omap2/board-omap3evm.c
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation version 2.
	12	*
	13	* This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
	14	* whether express or implied; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/init.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/gpio.h>
5d4292a5	23	#include <linux/i2c/pca953x.h>
91733631	24	#include <linux/can/platform/ti_hecc.h>
56881d28	25	#include <linux/davinci_emac.h>
c625327e RL	26
c625327e RL	27	#include <mach/hardware.h>
e3d4d0a2	28	#include <mach/am35xx.h>
c625327e RL	29	#include <asm/mach-types.h>
	30	#include <asm/mach/arch.h>
	31	#include <asm/mach/map.h>
	32
	33	#include <plat/board.h>
	34	#include <plat/common.h>
56881d28	35	#include <plat/control.h>
c625327e	36	#include <plat/usb.h>
c3d33329	37	#include <plat/display.h>
c625327e	38
ca5742bd TL	39	#include "mux.h"
ca5742bd TL	40
56881d28 S	41	#define AM35XX_EVM_PHY_MASK (0xF)
	42	#define AM35XX_EVM_MDIO_FREQUENCY (1000000)
	43
	44	static struct emac_platform_data am3517_evm_emac_pdata = {
	45	.phy_mask = AM35XX_EVM_PHY_MASK,
	46	.mdio_max_freq = AM35XX_EVM_MDIO_FREQUENCY,
	47	.rmii_en = 1,
	48	};
	49
	50	static struct resource am3517_emac_resources[] = {
	51	{
	52	.start = AM35XX_IPSS_EMAC_BASE,
	53	.end = AM35XX_IPSS_EMAC_BASE + 0x3FFFF,
	54	.flags = IORESOURCE_MEM,
	55	},
	56	{
	57	.start = INT_35XX_EMAC_C0_RXTHRESH_IRQ,
	58	.end = INT_35XX_EMAC_C0_RXTHRESH_IRQ,
	59	.flags = IORESOURCE_IRQ,
	60	},
	61	{
	62	.start = INT_35XX_EMAC_C0_RX_PULSE_IRQ,
	63	.end = INT_35XX_EMAC_C0_RX_PULSE_IRQ,
	64	.flags = IORESOURCE_IRQ,
	65	},
	66	{
	67	.start = INT_35XX_EMAC_C0_TX_PULSE_IRQ,
	68	.end = INT_35XX_EMAC_C0_TX_PULSE_IRQ,
	69	.flags = IORESOURCE_IRQ,
	70	},
	71	{
	72	.start = INT_35XX_EMAC_C0_MISC_PULSE_IRQ,
	73	.end = INT_35XX_EMAC_C0_MISC_PULSE_IRQ,
	74	.flags = IORESOURCE_IRQ,
	75	},
	76	};
	77
	78	static struct platform_device am3517_emac_device = {
	79	.name = "davinci_emac",
	80	.id = -1,
	81	.num_resources = ARRAY_SIZE(am3517_emac_resources),
	82	.resource = am3517_emac_resources,
	83	};
	84
	85	static void am3517_enable_ethernet_int(void)
	86	{
	87	u32 regval;
	88
	89	regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
	90	regval = (regval \| AM35XX_CPGMAC_C0_RX_PULSE_CLR \|
	91	AM35XX_CPGMAC_C0_TX_PULSE_CLR \|
	92	AM35XX_CPGMAC_C0_MISC_PULSE_CLR \|
	93	AM35XX_CPGMAC_C0_RX_THRESH_CLR);
	94	omap_ctrl_writel(regval, AM35XX_CONTROL_LVL_INTR_CLEAR);
	95	regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
	96	}
	97
	98	static void am3517_disable_ethernet_int(void)
	99	{
	100	u32 regval;
	101
	102	regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
	103	regval = (regval \| AM35XX_CPGMAC_C0_RX_PULSE_CLR \|
	104	AM35XX_CPGMAC_C0_TX_PULSE_CLR);
105	omap_ctrl_writel(regval, AM35XX_CONTROL_LVL_INTR_CLEAR);
106	regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
107	}
108
109	void am3517_evm_ethernet_init(struct emac_platform_data *pdata)
110	{
111	unsigned int regval;
112
113	pdata->ctrl_reg_offset = AM35XX_EMAC_CNTRL_OFFSET;
114	pdata->ctrl_mod_reg_offset = AM35XX_EMAC_CNTRL_MOD_OFFSET;
115	pdata->ctrl_ram_offset = AM35XX_EMAC_CNTRL_RAM_OFFSET;
116	pdata->mdio_reg_offset = AM35XX_EMAC_MDIO_OFFSET;
117	pdata->ctrl_ram_size = AM35XX_EMAC_CNTRL_RAM_SIZE;
118	pdata->version = EMAC_VERSION_2;
119	pdata->hw_ram_addr = AM35XX_EMAC_HW_RAM_ADDR;
120	pdata->interrupt_enable = am3517_enable_ethernet_int;
121	pdata->interrupt_disable = am3517_disable_ethernet_int;
122	am3517_emac_device.dev.platform_data = pdata;
123	platform_device_register(&am3517_emac_device);
124
125	regval = omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET);
126	regval = regval & (~(AM35XX_CPGMACSS_SW_RST));
127	omap_ctrl_writel(regval, AM35XX_CONTROL_IP_SW_RESET);
128	regval = omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET);
129
130	return ;
131	}
132
133
134
c3d33329 VH	135	#define LCD_PANEL_PWR 176
	136	#define LCD_PANEL_BKLIGHT_PWR 182
	137	#define LCD_PANEL_PWM 181
	138
b91da669	139	static struct i2c_board_info __initdata am3517evm_i2c1_boardinfo[] = {
f2afbbb8 VH	140	{
	141	I2C_BOARD_INFO("s35390a", 0x30),
	142	.type = "s35390a",
	143	},
	144	};
	145
	146	/*
	147	* RTC - S35390A
	148	*/
	149	#define GPIO_RTCS35390A_IRQ 55
	150
	151	static void __init am3517_evm_rtc_init(void)
	152	{
	153	int r;
	154
	155	omap_mux_init_gpio(GPIO_RTCS35390A_IRQ, OMAP_PIN_INPUT_PULLUP);
	156	r = gpio_request(GPIO_RTCS35390A_IRQ, "rtcs35390a-irq");
	157	if (r < 0) {
	158	printk(KERN_WARNING "failed to request GPIO#%d\n",
	159	GPIO_RTCS35390A_IRQ);
	160	return;
	161	}
	162	r = gpio_direction_input(GPIO_RTCS35390A_IRQ);
	163	if (r < 0) {
	164	printk(KERN_WARNING "GPIO#%d cannot be configured as input\n",
	165	GPIO_RTCS35390A_IRQ);
	166	gpio_free(GPIO_RTCS35390A_IRQ);
	167	return;
	168	}
b91da669	169	am3517evm_i2c1_boardinfo[0].irq = gpio_to_irq(GPIO_RTCS35390A_IRQ);
f2afbbb8 VH	170	}
f2afbbb8 VH	171
5d4292a5 VH	172	/*
	173	* I2C GPIO Expander - TCA6416
	174	*/
	175
	176	/* Mounted on Base-Board */
	177	static struct pca953x_platform_data am3517evm_gpio_expander_info_0 = {
	178	.gpio_base = OMAP_MAX_GPIO_LINES,
	179	};
b91da669	180	static struct i2c_board_info __initdata am3517evm_i2c2_boardinfo[] = {
5d4292a5 VH	181	{
	182	I2C_BOARD_INFO("tca6416", 0x21),
	183	.platform_data = &am3517evm_gpio_expander_info_0,
	184	},
	185	};
	186
	187	/* Mounted on UI Card */
	188	static struct pca953x_platform_data am3517evm_ui_gpio_expander_info_1 = {
	189	.gpio_base = OMAP_MAX_GPIO_LINES + 16,
	190	};
	191	static struct pca953x_platform_data am3517evm_ui_gpio_expander_info_2 = {
	192	.gpio_base = OMAP_MAX_GPIO_LINES + 32,
	193	};
b91da669	194	static struct i2c_board_info __initdata am3517evm_i2c3_boardinfo[] = {
5d4292a5 VH	195	{
	196	I2C_BOARD_INFO("tca6416", 0x20),
	197	.platform_data = &am3517evm_ui_gpio_expander_info_1,
	198	},
	199	{
	200	I2C_BOARD_INFO("tca6416", 0x21),
	201	.platform_data = &am3517evm_ui_gpio_expander_info_2,
	202	},
	203	};
	204
1f738dc3 VH	205	static int __init am3517_evm_i2c_init(void)
	206	{
	207	omap_register_i2c_bus(1, 400, NULL, 0);
b91da669	208	omap_register_i2c_bus(2, 400, am3517evm_i2c2_boardinfo,
	209	ARRAY_SIZE(am3517evm_i2c2_boardinfo));
	210	omap_register_i2c_bus(3, 400, am3517evm_i2c3_boardinfo,
	211	ARRAY_SIZE(am3517evm_i2c3_boardinfo));
1f738dc3 VH	212
	213	return 0;
	214	}
	215
c3d33329 VH	216	static int lcd_enabled;
	217	static int dvi_enabled;
	218
de997718 AKG	219	#if defined(CONFIG_PANEL_SHARP_LQ043T1DG01) \|\| \
de997718 AKG	220	defined(CONFIG_PANEL_SHARP_LQ043T1DG01_MODULE)
c3d33329 VH	221	static void __init am3517_evm_display_init(void)
	222	{
	223	int r;
	224
	225	omap_mux_init_gpio(LCD_PANEL_PWR, OMAP_PIN_INPUT_PULLUP);
	226	omap_mux_init_gpio(LCD_PANEL_BKLIGHT_PWR, OMAP_PIN_INPUT_PULLDOWN);
	227	omap_mux_init_gpio(LCD_PANEL_PWM, OMAP_PIN_INPUT_PULLDOWN);
	228	/*
	229	* Enable GPIO 182 = LCD Backlight Power
	230	*/
	231	r = gpio_request(LCD_PANEL_BKLIGHT_PWR, "lcd_backlight_pwr");
	232	if (r) {
	233	printk(KERN_ERR "failed to get lcd_backlight_pwr\n");
	234	return;
	235	}
	236	gpio_direction_output(LCD_PANEL_BKLIGHT_PWR, 1);
	237	/*
	238	* Enable GPIO 181 = LCD Panel PWM
	239	*/
	240	r = gpio_request(LCD_PANEL_PWM, "lcd_pwm");
	241	if (r) {
	242	printk(KERN_ERR "failed to get lcd_pwm\n");
	243	goto err_1;
	244	}
	245	gpio_direction_output(LCD_PANEL_PWM, 1);
	246	/*
	247	* Enable GPIO 176 = LCD Panel Power enable pin
	248	*/
	249	r = gpio_request(LCD_PANEL_PWR, "lcd_panel_pwr");
	250	if (r) {
	251	printk(KERN_ERR "failed to get lcd_panel_pwr\n");
	252	goto err_2;
	253	}
	254	gpio_direction_output(LCD_PANEL_PWR, 1);
	255
	256	printk(KERN_INFO "Display initialized successfully\n");
	257	return;
	258
	259	err_2:
	260	gpio_free(LCD_PANEL_PWM);
	261	err_1:
	262	gpio_free(LCD_PANEL_BKLIGHT_PWR);
	263	}
de997718 AKG	264	#else
	265	static void __init am3517_evm_display_init(void) {}
	266	#endif
c3d33329 VH	267
	268	static int am3517_evm_panel_enable_lcd(struct omap_dss_device *dssdev)
	269	{
	270	if (dvi_enabled) {
	271	printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
	272	return -EINVAL;
	273	}
	274	gpio_set_value(LCD_PANEL_PWR, 1);
	275	lcd_enabled = 1;
	276
	277	return 0;
	278	}
	279
	280	static void am3517_evm_panel_disable_lcd(struct omap_dss_device *dssdev)
	281	{
	282	gpio_set_value(LCD_PANEL_PWR, 0);
	283	lcd_enabled = 0;
	284	}
	285
	286	static struct omap_dss_device am3517_evm_lcd_device = {
	287	.type = OMAP_DISPLAY_TYPE_DPI,
	288	.name = "lcd",
	289	.driver_name = "sharp_lq_panel",
	290	.phy.dpi.data_lines = 16,
	291	.platform_enable = am3517_evm_panel_enable_lcd,
	292	.platform_disable = am3517_evm_panel_disable_lcd,
	293	};
	294
	295	static int am3517_evm_panel_enable_tv(struct omap_dss_device *dssdev)
	296	{
	297	return 0;
	298	}
	299
	300	static void am3517_evm_panel_disable_tv(struct omap_dss_device *dssdev)
	301	{
	302	}
	303
	304	static struct omap_dss_device am3517_evm_tv_device = {
	305	.type = OMAP_DISPLAY_TYPE_VENC,
	306	.name = "tv",
	307	.driver_name = "venc",
	308	.phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
	309	.platform_enable = am3517_evm_panel_enable_tv,
	310	.platform_disable = am3517_evm_panel_disable_tv,
	311	};
	312
	313	static int am3517_evm_panel_enable_dvi(struct omap_dss_device *dssdev)
	314	{
	315	if (lcd_enabled) {
	316	printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
	317	return -EINVAL;
	318	}
	319	dvi_enabled = 1;
	320
	321	return 0;
	322	}
	323
	324	static void am3517_evm_panel_disable_dvi(struct omap_dss_device *dssdev)
	325	{
	326	dvi_enabled = 0;
	327	}
	328
	329	static struct omap_dss_device am3517_evm_dvi_device = {
	330	.type = OMAP_DISPLAY_TYPE_DPI,
331	.name = "dvi",
332	.driver_name = "generic_panel",
333	.phy.dpi.data_lines = 24,
334	.platform_enable = am3517_evm_panel_enable_dvi,
335	.platform_disable = am3517_evm_panel_disable_dvi,
336	};
337
338	static struct omap_dss_device *am3517_evm_dss_devices[] = {
339	&am3517_evm_lcd_device,
340	&am3517_evm_tv_device,
341	&am3517_evm_dvi_device,
342	};
343
344	static struct omap_dss_board_info am3517_evm_dss_data = {
345	.num_devices = ARRAY_SIZE(am3517_evm_dss_devices),
346	.devices = am3517_evm_dss_devices,
347	.default_device = &am3517_evm_lcd_device,
348	};
349
350	struct platform_device am3517_evm_dss_device = {
351	.name = "omapdss",
352	.id = -1,
353	.dev = {
354	.platform_data = &am3517_evm_dss_data,
355	},
356	};
357
c625327e RL	358	/*
	359	* Board initialization
	360	*/
	361	static struct omap_board_config_kernel am3517_evm_config[] __initdata = {
	362	};
	363
	364	static struct platform_device *am3517_evm_devices[] __initdata = {
c3d33329	365	&am3517_evm_dss_device,
c625327e RL	366	};
	367
	368	static void __init am3517_evm_init_irq(void)
	369	{
	370	omap_board_config = am3517_evm_config;
	371	omap_board_config_size = ARRAY_SIZE(am3517_evm_config);
	372
	373	omap2_init_common_hw(NULL, NULL);
	374	omap_init_irq();
	375	omap_gpio_init();
	376	}
	377
6f69a181	378	static const struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
c625327e	379	.port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
de997718 AKG	380	#if defined(CONFIG_PANEL_SHARP_LQ043T1DG01) \|\| \
	381	defined(CONFIG_PANEL_SHARP_LQ043T1DG01_MODULE)
	382	.port_mode[1] = EHCI_HCD_OMAP_MODE_UNKNOWN,
	383	#else
c625327e	384	.port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
de997718	385	#endif
c625327e RL	386	.port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
	387
	388	.phy_reset = true,
	389	.reset_gpio_port[0] = 57,
	390	.reset_gpio_port[1] = -EINVAL,
	391	.reset_gpio_port[2] = -EINVAL
	392	};
	393
ca5742bd TL	394	#ifdef CONFIG_OMAP_MUX
	395	static struct omap_board_mux board_mux[] __initdata = {
	396	{ .reg_offset = OMAP_MUX_TERMINATOR },
	397	};
	398	#else
	399	#define board_mux NULL
	400	#endif
	401
91733631 S	402
	403	static struct resource am3517_hecc_resources[] = {
	404	{
	405	.start = AM35XX_IPSS_HECC_BASE,
	406	.end = AM35XX_IPSS_HECC_BASE + 0x3FFF,
	407	.flags = IORESOURCE_MEM,
	408	},
	409	{
	410	.start = INT_35XX_HECC0_IRQ,
	411	.end = INT_35XX_HECC0_IRQ,
	412	.flags = IORESOURCE_IRQ,
	413	},
	414	};
	415
	416	static struct platform_device am3517_hecc_device = {
	417	.name = "ti_hecc",
	418	.id = -1,
	419	.num_resources = ARRAY_SIZE(am3517_hecc_resources),
	420	.resource = am3517_hecc_resources,
	421	};
	422
	423	static struct ti_hecc_platform_data am3517_evm_hecc_pdata = {
	424	.scc_hecc_offset = AM35XX_HECC_SCC_HECC_OFFSET,
	425	.scc_ram_offset = AM35XX_HECC_SCC_RAM_OFFSET,
	426	.hecc_ram_offset = AM35XX_HECC_RAM_OFFSET,
	427	.mbx_offset = AM35XX_HECC_MBOX_OFFSET,
	428	.int_line = AM35XX_HECC_INT_LINE,
	429	.version = AM35XX_HECC_VERSION,
	430	};
	431
	432	static void am3517_evm_hecc_init(struct ti_hecc_platform_data *pdata)
	433	{
	434	am3517_hecc_device.dev.platform_data = pdata;
	435	platform_device_register(&am3517_hecc_device);
	436	}
	437
c625327e RL	438	static void __init am3517_evm_init(void)
c625327e RL	439	{
ca5742bd	440	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
5241b6b3	441
5241b6b3	442	am3517_evm_i2c_init();
c625327e RL	443	platform_add_devices(am3517_evm_devices,
	444	ARRAY_SIZE(am3517_evm_devices));
	445
	446	omap_serial_init();
fec3eebd AKG	447
	448	/* Configure GPIO for EHCI port */
	449	omap_mux_init_gpio(57, OMAP_PIN_OUTPUT);
c625327e	450	usb_ehci_init(&ehci_pdata);
91733631	451	am3517_evm_hecc_init(&am3517_evm_hecc_pdata);
c3d33329 VH	452	/* DSS */
c3d33329 VH	453	am3517_evm_display_init();
f2afbbb8 VH	454
	455	/* RTC - S35390A */
	456	am3517_evm_rtc_init();
	457
b91da669	458	i2c_register_board_info(1, am3517evm_i2c1_boardinfo,
b91da669	459	ARRAY_SIZE(am3517evm_i2c1_boardinfo));
56881d28 S	460	/Ethernet/
56881d28 S	461	am3517_evm_ethernet_init(&am3517_evm_emac_pdata);
c625327e RL	462	}
c625327e RL	463
c625327e RL	464	MACHINE_START(OMAP3517EVM, "OMAP3517/AM3517 EVM")
	465	.phys_io = 0x48000000,
	466	.io_pg_offst = ((0xd8000000) >> 18) & 0xfffc,
	467	.boot_params = 0x80000100,
869fef41	468	.map_io = omap3_map_io,
71ee7dad	469	.reserve = omap_reserve,
c625327e RL	470	.init_irq = am3517_evm_init_irq,
	471	.init_machine = am3517_evm_init,
	472	.timer = &omap_timer,
	473	MACHINE_END