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

/*
 * Copyright (C) 2009 Integration Software and Electronic Engineering.
 *
 * Modified from mach-omap2/board-generic.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/delay.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/input.h>

#include <linux/regulator/machine.h>
#include <linux/regulator/fixed.h>
#include <linux/i2c/twl.h>
#include <linux/mmc/host.h>

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

#include <plat/board.h>
#include <plat/common.h>
#include <plat/gpmc.h>
#include <plat/usb.h>
#include <plat/display.h>
#include <plat/panel-generic-dpi.h>
#include <plat/onenand.h>

#include "mux.h"
#include "hsmmc.h"
#include "sdram-numonyx-m65kxxxxam.h"
#include "common-board-devices.h"

#define IGEP2_SMSC911X_CS       5
#define IGEP2_SMSC911X_GPIO     176
#define IGEP2_GPIO_USBH_NRESET  24
#define IGEP2_GPIO_LED0_GREEN   26
#define IGEP2_GPIO_LED0_RED     27
#define IGEP2_GPIO_LED1_RED     28
#define IGEP2_GPIO_DVI_PUP      170

#define IGEP2_RB_GPIO_WIFI_NPD     94
#define IGEP2_RB_GPIO_WIFI_NRESET  95
#define IGEP2_RB_GPIO_BT_NRESET    137
#define IGEP2_RC_GPIO_WIFI_NPD     138
#define IGEP2_RC_GPIO_WIFI_NRESET  139
#define IGEP2_RC_GPIO_BT_NRESET    137

/*
 * IGEP2 Hardware Revision Table
 *
 *  --------------------------------------------------------------------------
 * | Id. | Hw Rev.            | HW0 (28) | WIFI_NPD | WIFI_NRESET | BT_NRESET |
 *  --------------------------------------------------------------------------
 * |  0  | B                  |   high   |  gpio94  |   gpio95    |     -     |
 * |  0  | B/C (B-compatible) |   high   |  gpio94  |   gpio95    |  gpio137  |
 * |  1  | C                  |   low    |  gpio138 |   gpio139   |  gpio137  |
 *  --------------------------------------------------------------------------
 */

#define IGEP2_BOARD_HWREV_B	0
#define IGEP2_BOARD_HWREV_C	1

static u8 hwrev;

static void __init igep2_get_revision(void)
{
	u8 ret;

	omap_mux_init_gpio(IGEP2_GPIO_LED1_RED, OMAP_PIN_INPUT);

	if ((gpio_request(IGEP2_GPIO_LED1_RED, "GPIO_HW0_REV") == 0) &&
	    (gpio_direction_input(IGEP2_GPIO_LED1_RED) == 0)) {
		ret = gpio_get_value(IGEP2_GPIO_LED1_RED);
		if (ret == 0) {
			pr_info("IGEP2: Hardware Revision C (B-NON compatible)\n");
			hwrev = IGEP2_BOARD_HWREV_C;
		} else if (ret ==  1) {
			pr_info("IGEP2: Hardware Revision B/C (B compatible)\n");
			hwrev = IGEP2_BOARD_HWREV_B;
		} else {
			pr_err("IGEP2: Unknown Hardware Revision\n");
			hwrev = -1;
		}
	} else {
		pr_warning("IGEP2: Could not obtain gpio GPIO_HW0_REV\n");
		pr_err("IGEP2: Unknown Hardware Revision\n");
	}

	gpio_free(IGEP2_GPIO_LED1_RED);
}

#if defined(CONFIG_MTD_ONENAND_OMAP2) || \
	defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)

#define ONENAND_MAP             0x20000000

/* NAND04GR4E1A ( x2 Flash built-in COMBO POP MEMORY )
 * Since the device is equipped with two DataRAMs, and two-plane NAND
 * Flash memory array, these two component enables simultaneous program
 * of 4KiB. Plane1 has only even blocks such as block0, block2, block4
 * while Plane2 has only odd blocks such as block1, block3, block5.
 * So MTD regards it as 4KiB page size and 256KiB block size 64*(2*2048)
 */

static struct mtd_partition igep2_onenand_partitions[] = {
	{
		.name           = "X-Loader",
		.offset         = 0,
		.size           = 2 * (64*(2*2048))
	},
	{
		.name           = "U-Boot",
		.offset         = MTDPART_OFS_APPEND,
		.size           = 6 * (64*(2*2048)),
	},
	{
		.name           = "Environment",
		.offset         = MTDPART_OFS_APPEND,
		.size           = 2 * (64*(2*2048)),
	},
	{
		.name           = "Kernel",
		.offset         = MTDPART_OFS_APPEND,
		.size           = 12 * (64*(2*2048)),
	},
	{
		.name           = "File System",
		.offset         = MTDPART_OFS_APPEND,
		.size           = MTDPART_SIZ_FULL,
	},
};

static struct omap_onenand_platform_data igep2_onenand_data = {
	.parts = igep2_onenand_partitions,
	.nr_parts = ARRAY_SIZE(igep2_onenand_partitions),
	.dma_channel	= -1,	/* disable DMA in OMAP OneNAND driver */
};

static struct platform_device igep2_onenand_device = {
	.name		= "omap2-onenand",
	.id		= -1,
	.dev = {
		.platform_data = &igep2_onenand_data,
	},
};

static void __init igep2_flash_init(void)
{
	u8 cs = 0;
	u8 onenandcs = GPMC_CS_NUM + 1;

	for (cs = 0; cs < GPMC_CS_NUM; cs++) {
		u32 ret;
		ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);

		/* Check if NAND/oneNAND is configured */
		if ((ret & 0xC00) == 0x800)
			/* NAND found */
			pr_err("IGEP2: Unsupported NAND found\n");
		else {
			ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
			if ((ret & 0x3F) == (ONENAND_MAP >> 24))
				/* ONENAND found */
				onenandcs = cs;
		}
	}

	if (onenandcs > GPMC_CS_NUM) {
		pr_err("IGEP2: Unable to find configuration in GPMC\n");
		return;
	}

	igep2_onenand_data.cs = onenandcs;

	if (platform_device_register(&igep2_onenand_device) < 0)
		pr_err("IGEP2: Unable to register OneNAND device\n");
}

#else
static void __init igep2_flash_init(void) {}
#endif

#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)

#include <linux/smsc911x.h>
#include <plat/gpmc-smsc911x.h>

static struct omap_smsc911x_platform_data smsc911x_cfg = {
	.cs             = IGEP2_SMSC911X_CS,
	.gpio_irq       = IGEP2_SMSC911X_GPIO,
	.gpio_reset     = -EINVAL,
	.flags		= SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
};

static inline void __init igep2_init_smsc911x(void)
{
	gpmc_smsc911x_init(&smsc911x_cfg);
}

#else
static inline void __init igep2_init_smsc911x(void) { }
#endif

static struct regulator_consumer_supply igep2_vmmc1_supply =
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0");

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

static struct regulator_consumer_supply igep2_vio_supply =
	REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1");

static struct regulator_init_data igep2_vio = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.apply_uV		= 1,
		.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      = &igep2_vio_supply,
};

static struct regulator_consumer_supply igep2_vmmc2_supply =
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1");

static struct regulator_init_data igep2_vmmc2 = {
	.constraints		= {
		.valid_modes_mask	= REGULATOR_MODE_NORMAL,
		.always_on		= 1,
	},
	.num_consumer_supplies	= 1,
	.consumer_supplies	= &igep2_vmmc2_supply,
};

static struct fixed_voltage_config igep2_vwlan = {
	.supply_name		= "vwlan",
	.microvolts		= 3300000,
	.gpio			= -EINVAL,
	.enabled_at_boot	= 1,
	.init_data		= &igep2_vmmc2,
};

static struct platform_device igep2_vwlan_device = {
	.name		= "reg-fixed-voltage",
	.id		= 0,
	.dev = {
		.platform_data	= &igep2_vwlan,
	},
};

static struct omap2_hsmmc_info mmc[] = {
	{
		.mmc		= 1,
		.caps		= MMC_CAP_4_BIT_DATA,
		.gpio_cd	= -EINVAL,
		.gpio_wp	= -EINVAL,
	},
#if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
	{
		.mmc		= 2,
		.caps		= MMC_CAP_4_BIT_DATA,
		.gpio_cd	= -EINVAL,
		.gpio_wp	= -EINVAL,
	},
#endif
	{}      /* Terminator */
};

#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
#include <linux/leds.h>

static struct gpio_led igep2_gpio_leds[] = {
	[0] = {
		.name			= "gpio-led:red:d0",
		.gpio			= IGEP2_GPIO_LED0_RED,
		.default_trigger	= "default-off"
	},
	[1] = {
		.name			= "gpio-led:green:d0",
		.gpio			= IGEP2_GPIO_LED0_GREEN,
		.default_trigger	= "default-off",
	},
	[2] = {
		.name			= "gpio-led:red:d1",
		.gpio			= IGEP2_GPIO_LED1_RED,
		.default_trigger	= "default-off",
	},
	[3] = {
		.name			= "gpio-led:green:d1",
		.default_trigger	= "heartbeat",
		.gpio			= -EINVAL, /* gets replaced */
		.active_low		= 1,
	},
};

static struct gpio_led_platform_data igep2_led_pdata = {
	.leds           = igep2_gpio_leds,
	.num_leds       = ARRAY_SIZE(igep2_gpio_leds),
};

static struct platform_device igep2_led_device = {
	 .name   = "leds-gpio",
	 .id     = -1,
	 .dev    = {
		 .platform_data  =  &igep2_led_pdata,
	},
};

static void __init igep2_leds_init(void)
{
	platform_device_register(&igep2_led_device);
}

#else
static inline void igep2_leds_init(void)
{
	if ((gpio_request(IGEP2_GPIO_LED0_RED, "gpio-led:red:d0") == 0) &&
	    (gpio_direction_output(IGEP2_GPIO_LED0_RED, 0) == 0))
		gpio_export(IGEP2_GPIO_LED0_RED, 0);
	else
		pr_warning("IGEP v2: Could not obtain gpio GPIO_LED0_RED\n");

	if ((gpio_request(IGEP2_GPIO_LED0_GREEN, "gpio-led:green:d0") == 0) &&
	    (gpio_direction_output(IGEP2_GPIO_LED0_GREEN, 0) == 0))
		gpio_export(IGEP2_GPIO_LED0_GREEN, 0);
	else
		pr_warning("IGEP v2: Could not obtain gpio GPIO_LED0_GREEN\n");

	if ((gpio_request(IGEP2_GPIO_LED1_RED, "gpio-led:red:d1") == 0) &&
	    (gpio_direction_output(IGEP2_GPIO_LED1_RED, 0) == 0))
		gpio_export(IGEP2_GPIO_LED1_RED, 0);
	else
		pr_warning("IGEP v2: Could not obtain gpio GPIO_LED1_RED\n");

}
#endif

static int igep2_twl_gpio_setup(struct device *dev,
		unsigned gpio, unsigned ngpio)
{
	/* gpio + 0 is "mmc0_cd" (input/IRQ) */
	mmc[0].gpio_cd = gpio + 0;
	omap2_hsmmc_init(mmc);

	/*
	 * REVISIT: need ehci-omap hooks for external VBUS
	 * power switch and overcurrent detect
	 */
	if ((gpio_request(gpio + 1, "GPIO_EHCI_NOC") < 0) ||
	    (gpio_direction_input(gpio + 1) < 0))
		pr_err("IGEP2: Could not obtain gpio for EHCI NOC");

	/*
	 * TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN
	 * (out, active low)
	 */
	if ((gpio_request(gpio + TWL4030_GPIO_MAX, "GPIO_USBH_CPEN") < 0) ||
	    (gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0) < 0))
		pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");

	/* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
#if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
	if ((gpio_request(gpio+TWL4030_GPIO_MAX+1, "gpio-led:green:d1") == 0)
	    && (gpio_direction_output(gpio + TWL4030_GPIO_MAX + 1, 1) == 0))
		gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
	else
		pr_warning("IGEP v2: Could not obtain gpio GPIO_LED1_GREEN\n");
#else
	igep2_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
#endif

	return 0;
};

static struct twl4030_gpio_platform_data igep2_twl4030_gpio_pdata = {
	.gpio_base	= OMAP_MAX_GPIO_LINES,
	.irq_base	= TWL4030_GPIO_IRQ_BASE,
	.irq_end	= TWL4030_GPIO_IRQ_END,
	.use_leds	= true,
	.setup		= igep2_twl_gpio_setup,
};

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

static int igep2_enable_dvi(struct omap_dss_device *dssdev)
{
	gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1);

	return 0;
}

static void igep2_disable_dvi(struct omap_dss_device *dssdev)
{
	gpio_direction_output(IGEP2_GPIO_DVI_PUP, 0);
}

static struct panel_generic_dpi_data dvi_panel = {
	.name			= "generic",
	.platform_enable	= igep2_enable_dvi,
	.platform_disable	= igep2_disable_dvi,
};

static struct omap_dss_device igep2_dvi_device = {
	.type			= OMAP_DISPLAY_TYPE_DPI,
	.name			= "dvi",
	.driver_name		= "generic_dpi_panel",
	.data			= &dvi_panel,
	.phy.dpi.data_lines	= 24,
};

static struct omap_dss_device *igep2_dss_devices[] = {
	&igep2_dvi_device
};

static struct omap_dss_board_info igep2_dss_data = {
	.num_devices	= ARRAY_SIZE(igep2_dss_devices),
	.devices	= igep2_dss_devices,
	.default_device	= &igep2_dvi_device,
};

static struct regulator_consumer_supply igep2_vpll2_supplies[] = {
	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
};

static struct regulator_init_data igep2_vpll2 = {
	.constraints = {
		.name			= "VDVI",
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= ARRAY_SIZE(igep2_vpll2_supplies),
	.consumer_supplies	= igep2_vpll2_supplies,
};

static void __init igep2_display_init(void)
{
	if (gpio_request(IGEP2_GPIO_DVI_PUP, "GPIO_DVI_PUP") &&
	    gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1))
		pr_err("IGEP v2: Could not obtain gpio GPIO_DVI_PUP\n");
}

static struct platform_device *igep2_devices[] __initdata = {
	&igep2_vwlan_device,
};

static void __init igep2_init_early(void)
{
	omap2_init_common_infrastructure();
	omap2_init_common_devices(m65kxxxxam_sdrc_params,
				  m65kxxxxam_sdrc_params);
}

static struct twl4030_codec_audio_data igep2_audio_data;

static struct twl4030_codec_data igep2_codec_data = {
	.audio_mclk = 26000000,
	.audio = &igep2_audio_data,
};

static int igep2_keymap[] = {
	KEY(0, 0, KEY_LEFT),
	KEY(0, 1, KEY_RIGHT),
	KEY(0, 2, KEY_A),
	KEY(0, 3, KEY_B),
	KEY(1, 0, KEY_DOWN),
	KEY(1, 1, KEY_UP),
	KEY(1, 2, KEY_E),
	KEY(1, 3, KEY_F),
	KEY(2, 0, KEY_ENTER),
	KEY(2, 1, KEY_I),
	KEY(2, 2, KEY_J),
	KEY(2, 3, KEY_K),
	KEY(3, 0, KEY_M),
	KEY(3, 1, KEY_N),
	KEY(3, 2, KEY_O),
	KEY(3, 3, KEY_P)
};

static struct matrix_keymap_data igep2_keymap_data = {
	.keymap			= igep2_keymap,
	.keymap_size		= ARRAY_SIZE(igep2_keymap),
};

static struct twl4030_keypad_data igep2_keypad_pdata = {
	.keymap_data	= &igep2_keymap_data,
	.rows		= 4,
	.cols		= 4,
	.rep		= 1,
};

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

	/* platform_data for children goes here */
	.usb		= &igep2_usb_data,
	.codec		= &igep2_codec_data,
	.gpio		= &igep2_twl4030_gpio_pdata,
	.keypad		= &igep2_keypad_pdata,
	.vmmc1          = &igep2_vmmc1,
	.vpll2		= &igep2_vpll2,
	.vio		= &igep2_vio,
};

static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
	{
		I2C_BOARD_INFO("eeprom", 0x50),
	},
};

static void __init igep2_i2c_init(void)
{
	int ret;

	omap3_pmic_init("twl4030", &igep2_twldata);

	/*
	 * Bus 3 is attached to the DVI port where devices like the pico DLP
	 * projector don't work reliably with 400kHz
	 */
	ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
		ARRAY_SIZE(igep2_i2c3_boardinfo));
	if (ret)
		pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
}

static struct omap_musb_board_data musb_board_data = {
	.interface_type		= MUSB_INTERFACE_ULPI,
	.mode			= MUSB_OTG,
	.power			= 100,
};

static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
	.port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
	.port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
	.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,

	.phy_reset = true,
	.reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
	.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 },
};
#endif

#if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)

static void __init igep2_wlan_bt_init(void)
{
	unsigned npd, wreset, btreset;

	/* GPIO's for WLAN-BT combo depends on hardware revision */
	if (hwrev == IGEP2_BOARD_HWREV_B) {
		npd = IGEP2_RB_GPIO_WIFI_NPD;
		wreset = IGEP2_RB_GPIO_WIFI_NRESET;
		btreset = IGEP2_RB_GPIO_BT_NRESET;
	} else if (hwrev == IGEP2_BOARD_HWREV_C) {
		npd = IGEP2_RC_GPIO_WIFI_NPD;
		wreset = IGEP2_RC_GPIO_WIFI_NRESET;
		btreset = IGEP2_RC_GPIO_BT_NRESET;
	} else
		return;

	/* Set GPIO's for  WLAN-BT combo module */
	if ((gpio_request(npd, "GPIO_WIFI_NPD") == 0) &&
	    (gpio_direction_output(npd, 1) == 0)) {
		gpio_export(npd, 0);
	} else
		pr_warning("IGEP2: Could not obtain gpio GPIO_WIFI_NPD\n");

	if ((gpio_request(wreset, "GPIO_WIFI_NRESET") == 0) &&
	    (gpio_direction_output(wreset, 1) == 0)) {
		gpio_export(wreset, 0);
		gpio_set_value(wreset, 0);
		udelay(10);
		gpio_set_value(wreset, 1);
	} else
		pr_warning("IGEP2: Could not obtain gpio GPIO_WIFI_NRESET\n");

	if ((gpio_request(btreset, "GPIO_BT_NRESET") == 0) &&
	    (gpio_direction_output(btreset, 1) == 0)) {
		gpio_export(btreset, 0);
	} else
		pr_warning("IGEP2: Could not obtain gpio GPIO_BT_NRESET\n");
}
#else
static inline void __init igep2_wlan_bt_init(void) { }
#endif

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

	/* Get IGEP2 hardware revision */
	igep2_get_revision();
	/* Register I2C busses and drivers */
	igep2_i2c_init();
	platform_add_devices(igep2_devices, ARRAY_SIZE(igep2_devices));
	omap_display_init(&igep2_dss_data);
	omap_serial_init();
	usb_musb_init(&musb_board_data);
	usbhs_init(&usbhs_bdata);

	igep2_flash_init();
	igep2_leds_init();
	igep2_display_init();
	igep2_init_smsc911x();

	/*
	 * WLAN-BT combo module from MuRata which has a Marvell WLAN
	 * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
	 */
	igep2_wlan_bt_init();

}

MACHINE_START(IGEP0020, "IGEP v2 board")
	.boot_params	= 0x80000100,
	.reserve	= omap_reserve,
	.map_io		= omap3_map_io,
	.init_early	= igep2_init_early,
	.init_irq	= omap_init_irq,
	.init_machine	= igep2_init,
	.timer		= &omap_timer,
MACHINE_END
Commit	Line	Data
58e11162 EBS	1	/*
	2	* Copyright (C) 2009 Integration Software and Electronic Engineering.
	3	*
	4	* Modified from mach-omap2/board-generic.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/delay.h>
	15	#include <linux/err.h>
	16	#include <linux/clk.h>
	17	#include <linux/io.h>
	18	#include <linux/gpio.h>
	19	#include <linux/interrupt.h>
18cbc7d9	20	#include <linux/input.h>
58e11162 EBS	21
58e11162 EBS	22	#include <linux/regulator/machine.h>
da07c0cf	23	#include <linux/regulator/fixed.h>
ebeb53e1	24	#include <linux/i2c/twl.h>
3a63833e	25	#include <linux/mmc/host.h>
58e11162 EBS	26
	27	#include <asm/mach-types.h>
	28	#include <asm/mach/arch.h>
	29
	30	#include <plat/board.h>
	31	#include <plat/common.h>
	32	#include <plat/gpmc.h>
58e11162	33	#include <plat/usb.h>
691de27f	34	#include <plat/display.h>
89747c91	35	#include <plat/panel-generic-dpi.h>
cddb483a	36	#include <plat/onenand.h>
58e11162	37
ca5742bd	38	#include "mux.h"
d02a900b	39	#include "hsmmc.h"
22f1baac	40	#include "sdram-numonyx-m65kxxxxam.h"
fbd8071c	41	#include "common-board-devices.h"
58e11162 EBS	42
	43	#define IGEP2_SMSC911X_CS 5
	44	#define IGEP2_SMSC911X_GPIO 176
	45	#define IGEP2_GPIO_USBH_NRESET 24
5a9fcc99 EBS	46	#define IGEP2_GPIO_LED0_GREEN 26
	47	#define IGEP2_GPIO_LED0_RED 27
	48	#define IGEP2_GPIO_LED1_RED 28
	49	#define IGEP2_GPIO_DVI_PUP 170
	50
	51	#define IGEP2_RB_GPIO_WIFI_NPD 94
	52	#define IGEP2_RB_GPIO_WIFI_NRESET 95
	53	#define IGEP2_RB_GPIO_BT_NRESET 137
	54	#define IGEP2_RC_GPIO_WIFI_NPD 138
	55	#define IGEP2_RC_GPIO_WIFI_NRESET 139
	56	#define IGEP2_RC_GPIO_BT_NRESET 137
58e11162	57
3f8c48d9 EBS	58	/*
	59	* IGEP2 Hardware Revision Table
	60	*
5a9fcc99 EBS	61	* --------------------------------------------------------------------------
	62	* \| Id. \| Hw Rev. \| HW0 (28) \| WIFI_NPD \| WIFI_NRESET \| BT_NRESET \|
	63	* --------------------------------------------------------------------------
	64	* \| 0 \| B \| high \| gpio94 \| gpio95 \| - \|
	65	* \| 0 \| B/C (B-compatible) \| high \| gpio94 \| gpio95 \| gpio137 \|
	66	* \| 1 \| C \| low \| gpio138 \| gpio139 \| gpio137 \|
	67	* --------------------------------------------------------------------------
3f8c48d9 EBS	68	*/
	69
	70	#define IGEP2_BOARD_HWREV_B 0
	71	#define IGEP2_BOARD_HWREV_C 1
	72
	73	static u8 hwrev;
	74
	75	static void __init igep2_get_revision(void)
	76	{
	77	u8 ret;
	78
	79	omap_mux_init_gpio(IGEP2_GPIO_LED1_RED, OMAP_PIN_INPUT);
	80
	81	if ((gpio_request(IGEP2_GPIO_LED1_RED, "GPIO_HW0_REV") == 0) &&
	82	(gpio_direction_input(IGEP2_GPIO_LED1_RED) == 0)) {
	83	ret = gpio_get_value(IGEP2_GPIO_LED1_RED);
	84	if (ret == 0) {
	85	pr_info("IGEP2: Hardware Revision C (B-NON compatible)\n");
	86	hwrev = IGEP2_BOARD_HWREV_C;
	87	} else if (ret == 1) {
	88	pr_info("IGEP2: Hardware Revision B/C (B compatible)\n");
	89	hwrev = IGEP2_BOARD_HWREV_B;
	90	} else {
	91	pr_err("IGEP2: Unknown Hardware Revision\n");
	92	hwrev = -1;
	93	}
	94	} else {
	95	pr_warning("IGEP2: Could not obtain gpio GPIO_HW0_REV\n");
	96	pr_err("IGEP2: Unknown Hardware Revision\n");
	97	}
	98
	99	gpio_free(IGEP2_GPIO_LED1_RED);
	100	}
58e11162	101
cddb483a EBS	102	#if defined(CONFIG_MTD_ONENAND_OMAP2) \|\| \
	103	defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
	104
	105	#define ONENAND_MAP 0x20000000
	106
	107	/* NAND04GR4E1A ( x2 Flash built-in COMBO POP MEMORY )
	108	* Since the device is equipped with two DataRAMs, and two-plane NAND
	109	* Flash memory array, these two component enables simultaneous program
	110	* of 4KiB. Plane1 has only even blocks such as block0, block2, block4
	111	* while Plane2 has only odd blocks such as block1, block3, block5.
	112	* So MTD regards it as 4KiB page size and 256KiB block size 64(22048)
	113	*/
	114
	115	static struct mtd_partition igep2_onenand_partitions[] = {
	116	{
	117	.name = "X-Loader",
	118	.offset = 0,
	119	.size = 2 * (64(22048))
	120	},
	121	{
	122	.name = "U-Boot",
	123	.offset = MTDPART_OFS_APPEND,
	124	.size = 6 * (64(22048)),
	125	},
	126	{
	127	.name = "Environment",
	128	.offset = MTDPART_OFS_APPEND,
	129	.size = 2 * (64(22048)),
	130	},
	131	{
	132	.name = "Kernel",
	133	.offset = MTDPART_OFS_APPEND,
	134	.size = 12 * (64(22048)),
	135	},
	136	{
	137	.name = "File System",
	138	.offset = MTDPART_OFS_APPEND,
	139	.size = MTDPART_SIZ_FULL,
	140	},
	141	};
	142
cddb483a EBS	143	static struct omap_onenand_platform_data igep2_onenand_data = {
	144	.parts = igep2_onenand_partitions,
	145	.nr_parts = ARRAY_SIZE(igep2_onenand_partitions),
cddb483a EBS	146	.dma_channel = -1, /* disable DMA in OMAP OneNAND driver */
	147	};
	148
	149	static struct platform_device igep2_onenand_device = {
	150	.name = "omap2-onenand",
	151	.id = -1,
	152	.dev = {
	153	.platform_data = &igep2_onenand_data,
	154	},
	155	};
	156
04aeae77	157	static void __init igep2_flash_init(void)
cddb483a	158	{
235228ba EBS	159	u8 cs = 0;
235228ba EBS	160	u8 onenandcs = GPMC_CS_NUM + 1;
cddb483a	161
235228ba EBS	162	for (cs = 0; cs < GPMC_CS_NUM; cs++) {
235228ba EBS	163	u32 ret;
cddb483a EBS	164	ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
	165
	166	/* Check if NAND/oneNAND is configured */
	167	if ((ret & 0xC00) == 0x800)
	168	/* NAND found */
235228ba	169	pr_err("IGEP2: Unsupported NAND found\n");
cddb483a EBS	170	else {
	171	ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
	172	if ((ret & 0x3F) == (ONENAND_MAP >> 24))
	173	/* ONENAND found */
	174	onenandcs = cs;
	175	}
cddb483a	176	}
235228ba	177
cddb483a	178	if (onenandcs > GPMC_CS_NUM) {
235228ba	179	pr_err("IGEP2: Unable to find configuration in GPMC\n");
cddb483a EBS	180	return;
	181	}
	182
235228ba EBS	183	igep2_onenand_data.cs = onenandcs;
	184
	185	if (platform_device_register(&igep2_onenand_device) < 0)
	186	pr_err("IGEP2: Unable to register OneNAND device\n");
cddb483a EBS	187	}
	188
	189	#else
04aeae77	190	static void __init igep2_flash_init(void) {}
cddb483a EBS	191	#endif
cddb483a EBS	192
58e11162 EBS	193	#if defined(CONFIG_SMSC911X) \|\| defined(CONFIG_SMSC911X_MODULE)
	194
	195	#include <linux/smsc911x.h>
21b42731	196	#include <plat/gpmc-smsc911x.h>
58e11162	197
21b42731 MR	198	static struct omap_smsc911x_platform_data smsc911x_cfg = {
	199	.cs = IGEP2_SMSC911X_CS,
	200	.gpio_irq = IGEP2_SMSC911X_GPIO,
	201	.gpio_reset = -EINVAL,
	202	.flags = SMSC911X_USE_32BIT \| SMSC911X_SAVE_MAC_ADDRESS,
58e11162 EBS	203	};
	204
	205	static inline void __init igep2_init_smsc911x(void)
	206	{
21b42731	207	gpmc_smsc911x_init(&smsc911x_cfg);
58e11162 EBS	208	}
	209
	210	#else
	211	static inline void __init igep2_init_smsc911x(void) { }
	212	#endif
	213
da07c0cf	214	static struct regulator_consumer_supply igep2_vmmc1_supply =
0005ae73	215	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0");
58e11162 EBS	216
	217	/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
	218	static struct regulator_init_data igep2_vmmc1 = {
	219	.constraints = {
	220	.min_uV = 1850000,
	221	.max_uV = 3150000,
	222	.valid_modes_mask = REGULATOR_MODE_NORMAL
	223	\| REGULATOR_MODE_STANDBY,
	224	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	225	\| REGULATOR_CHANGE_MODE
	226	\| REGULATOR_CHANGE_STATUS,
	227	},
	228	.num_consumer_supplies = 1,
	229	.consumer_supplies = &igep2_vmmc1_supply,
	230	};
	231
da07c0cf	232	static struct regulator_consumer_supply igep2_vio_supply =
0005ae73	233	REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1");
da07c0cf MZ	234
	235	static struct regulator_init_data igep2_vio = {
	236	.constraints = {
	237	.min_uV = 1800000,
	238	.max_uV = 1800000,
	239	.apply_uV = 1,
	240	.valid_modes_mask = REGULATOR_MODE_NORMAL
	241	\| REGULATOR_MODE_STANDBY,
	242	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	243	\| REGULATOR_CHANGE_MODE
	244	\| REGULATOR_CHANGE_STATUS,
	245	},
	246	.num_consumer_supplies = 1,
	247	.consumer_supplies = &igep2_vio_supply,
	248	};
	249
	250	static struct regulator_consumer_supply igep2_vmmc2_supply =
0005ae73	251	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1");
da07c0cf MZ	252
	253	static struct regulator_init_data igep2_vmmc2 = {
	254	.constraints = {
	255	.valid_modes_mask = REGULATOR_MODE_NORMAL,
	256	.always_on = 1,
	257	},
	258	.num_consumer_supplies = 1,
	259	.consumer_supplies = &igep2_vmmc2_supply,
	260	};
	261
	262	static struct fixed_voltage_config igep2_vwlan = {
	263	.supply_name = "vwlan",
	264	.microvolts = 3300000,
	265	.gpio = -EINVAL,
	266	.enabled_at_boot = 1,
	267	.init_data = &igep2_vmmc2,
	268	};
	269
	270	static struct platform_device igep2_vwlan_device = {
	271	.name = "reg-fixed-voltage",
	272	.id = 0,
	273	.dev = {
	274	.platform_data = &igep2_vwlan,
	275	},
	276	};
	277
68ff0423	278	static struct omap2_hsmmc_info mmc[] = {
58e11162 EBS	279	{
58e11162 EBS	280	.mmc = 1,
3a63833e	281	.caps = MMC_CAP_4_BIT_DATA,
58e11162 EBS	282	.gpio_cd = -EINVAL,
	283	.gpio_wp = -EINVAL,
	284	},
5a9fcc99	285	#if defined(CONFIG_LIBERTAS_SDIO) \|\| defined(CONFIG_LIBERTAS_SDIO_MODULE)
58e11162 EBS	286	{
58e11162 EBS	287	.mmc = 2,
3a63833e	288	.caps = MMC_CAP_4_BIT_DATA,
58e11162 EBS	289	.gpio_cd = -EINVAL,
	290	.gpio_wp = -EINVAL,
	291	},
5a9fcc99	292	#endif
58e11162 EBS	293	{} /* Terminator */
	294	};
	295
bee15390 EBS	296	#if defined(CONFIG_LEDS_GPIO) \|\| defined(CONFIG_LEDS_GPIO_MODULE)
	297	#include <linux/leds.h>
	298
	299	static struct gpio_led igep2_gpio_leds[] = {
	300	[0] = {
	301	.name = "gpio-led:red:d0",
	302	.gpio = IGEP2_GPIO_LED0_RED,
	303	.default_trigger = "default-off"
	304	},
	305	[1] = {
	306	.name = "gpio-led:green:d0",
	307	.gpio = IGEP2_GPIO_LED0_GREEN,
	308	.default_trigger = "default-off",
	309	},
	310	[2] = {
	311	.name = "gpio-led:red:d1",
	312	.gpio = IGEP2_GPIO_LED1_RED,
	313	.default_trigger = "default-off",
	314	},
	315	[3] = {
	316	.name = "gpio-led:green:d1",
	317	.default_trigger = "heartbeat",
	318	.gpio = -EINVAL, /* gets replaced */
70e77760	319	.active_low = 1,
bee15390 EBS	320	},
	321	};
	322
	323	static struct gpio_led_platform_data igep2_led_pdata = {
	324	.leds = igep2_gpio_leds,
	325	.num_leds = ARRAY_SIZE(igep2_gpio_leds),
	326	};
	327
	328	static struct platform_device igep2_led_device = {
	329	.name = "leds-gpio",
	330	.id = -1,
	331	.dev = {
	332	.platform_data = &igep2_led_pdata,
	333	},
	334	};
	335
	336	static void __init igep2_leds_init(void)
	337	{
	338	platform_device_register(&igep2_led_device);
	339	}
	340
	341	#else
	342	static inline void igep2_leds_init(void)
	343	{
	344	if ((gpio_request(IGEP2_GPIO_LED0_RED, "gpio-led:red:d0") == 0) &&
62d8e9e2	345	(gpio_direction_output(IGEP2_GPIO_LED0_RED, 0) == 0))
bee15390	346	gpio_export(IGEP2_GPIO_LED0_RED, 0);
62d8e9e2	347	else
bee15390 EBS	348	pr_warning("IGEP v2: Could not obtain gpio GPIO_LED0_RED\n");
	349
	350	if ((gpio_request(IGEP2_GPIO_LED0_GREEN, "gpio-led:green:d0") == 0) &&
62d8e9e2	351	(gpio_direction_output(IGEP2_GPIO_LED0_GREEN, 0) == 0))
bee15390	352	gpio_export(IGEP2_GPIO_LED0_GREEN, 0);
62d8e9e2	353	else
bee15390 EBS	354	pr_warning("IGEP v2: Could not obtain gpio GPIO_LED0_GREEN\n");
	355
	356	if ((gpio_request(IGEP2_GPIO_LED1_RED, "gpio-led:red:d1") == 0) &&
62d8e9e2	357	(gpio_direction_output(IGEP2_GPIO_LED1_RED, 0) == 0))
bee15390	358	gpio_export(IGEP2_GPIO_LED1_RED, 0);
62d8e9e2	359	else
bee15390 EBS	360	pr_warning("IGEP v2: Could not obtain gpio GPIO_LED1_RED\n");
	361
	362	}
	363	#endif
	364
58e11162 EBS	365	static int igep2_twl_gpio_setup(struct device *dev,
	366	unsigned gpio, unsigned ngpio)
	367	{
	368	/* gpio + 0 is "mmc0_cd" (input/IRQ) */
	369	mmc[0].gpio_cd = gpio + 0;
68ff0423	370	omap2_hsmmc_init(mmc);
58e11162	371
61e118dd EBS	372	/*
	373	* REVISIT: need ehci-omap hooks for external VBUS
	374	* power switch and overcurrent detect
	375	*/
	376	if ((gpio_request(gpio + 1, "GPIO_EHCI_NOC") < 0) \|\|
	377	(gpio_direction_input(gpio + 1) < 0))
	378	pr_err("IGEP2: Could not obtain gpio for EHCI NOC");
	379
	380	/*
	381	* TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN
	382	* (out, active low)
	383	*/
	384	if ((gpio_request(gpio + TWL4030_GPIO_MAX, "GPIO_USBH_CPEN") < 0) \|\|
	385	(gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0) < 0))
	386	pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");
	387
bee15390 EBS	388	/* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
	389	#if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
	390	if ((gpio_request(gpio+TWL4030_GPIO_MAX+1, "gpio-led:green:d1") == 0)
70e77760	391	&& (gpio_direction_output(gpio + TWL4030_GPIO_MAX + 1, 1) == 0))
bee15390	392	gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
62d8e9e2	393	else
bee15390 EBS	394	pr_warning("IGEP v2: Could not obtain gpio GPIO_LED1_GREEN\n");
	395	#else
	396	igep2_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
	397	#endif
58e11162 EBS	398
	399	return 0;
	400	};
	401
bee15390	402	static struct twl4030_gpio_platform_data igep2_twl4030_gpio_pdata = {
58e11162 EBS	403	.gpio_base = OMAP_MAX_GPIO_LINES,
	404	.irq_base = TWL4030_GPIO_IRQ_BASE,
	405	.irq_end = TWL4030_GPIO_IRQ_END,
bee15390	406	.use_leds = true,
58e11162 EBS	407	.setup = igep2_twl_gpio_setup,
	408	};
	409
	410	static struct twl4030_usb_data igep2_usb_data = {
	411	.usb_mode = T2_USB_MODE_ULPI,
	412	};
	413
691de27f EBS	414	static int igep2_enable_dvi(struct omap_dss_device *dssdev)
	415	{
	416	gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1);
	417
	418	return 0;
	419	}
	420
	421	static void igep2_disable_dvi(struct omap_dss_device *dssdev)
	422	{
	423	gpio_direction_output(IGEP2_GPIO_DVI_PUP, 0);
	424	}
	425
89747c91 BW	426	static struct panel_generic_dpi_data dvi_panel = {
	427	.name = "generic",
	428	.platform_enable = igep2_enable_dvi,
	429	.platform_disable = igep2_disable_dvi,
	430	};
	431
691de27f EBS	432	static struct omap_dss_device igep2_dvi_device = {
	433	.type = OMAP_DISPLAY_TYPE_DPI,
	434	.name = "dvi",
89747c91 BW	435	.driver_name = "generic_dpi_panel",
89747c91 BW	436	.data = &dvi_panel,
691de27f	437	.phy.dpi.data_lines = 24,
691de27f EBS	438	};
	439
	440	static struct omap_dss_device *igep2_dss_devices[] = {
	441	&igep2_dvi_device
	442	};
	443
	444	static struct omap_dss_board_info igep2_dss_data = {
	445	.num_devices = ARRAY_SIZE(igep2_dss_devices),
	446	.devices = igep2_dss_devices,
	447	.default_device = &igep2_dvi_device,
	448	};
	449
c8aac01b SG	450	static struct regulator_consumer_supply igep2_vpll2_supplies[] = {
	451	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
	452	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
	453	};
691de27f EBS	454
	455	static struct regulator_init_data igep2_vpll2 = {
	456	.constraints = {
	457	.name = "VDVI",
	458	.min_uV = 1800000,
	459	.max_uV = 1800000,
	460	.apply_uV = true,
	461	.valid_modes_mask = REGULATOR_MODE_NORMAL
	462	\| REGULATOR_MODE_STANDBY,
	463	.valid_ops_mask = REGULATOR_CHANGE_MODE
	464	\| REGULATOR_CHANGE_STATUS,
	465	},
c8aac01b SG	466	.num_consumer_supplies = ARRAY_SIZE(igep2_vpll2_supplies),
c8aac01b SG	467	.consumer_supplies = igep2_vpll2_supplies,
691de27f EBS	468	};
	469
	470	static void __init igep2_display_init(void)
	471	{
	472	if (gpio_request(IGEP2_GPIO_DVI_PUP, "GPIO_DVI_PUP") &&
	473	gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1))
	474	pr_err("IGEP v2: Could not obtain gpio GPIO_DVI_PUP\n");
	475	}
228893f9	476
691de27f	477	static struct platform_device *igep2_devices[] __initdata = {
da07c0cf	478	&igep2_vwlan_device,
691de27f EBS	479	};
691de27f EBS	480
3dc3bad6	481	static void __init igep2_init_early(void)
58e11162	482	{
4805734b PW	483	omap2_init_common_infrastructure();
	484	omap2_init_common_devices(m65kxxxxam_sdrc_params,
	485	m65kxxxxam_sdrc_params);
58e11162 EBS	486	}
58e11162 EBS	487
6a58baf8	488	static struct twl4030_codec_audio_data igep2_audio_data;
7f5f23da EBS	489
	490	static struct twl4030_codec_data igep2_codec_data = {
	491	.audio_mclk = 26000000,
	492	.audio = &igep2_audio_data,
	493	};
	494
18cbc7d9 EBS	495	static int igep2_keymap[] = {
	496	KEY(0, 0, KEY_LEFT),
	497	KEY(0, 1, KEY_RIGHT),
	498	KEY(0, 2, KEY_A),
	499	KEY(0, 3, KEY_B),
	500	KEY(1, 0, KEY_DOWN),
	501	KEY(1, 1, KEY_UP),
	502	KEY(1, 2, KEY_E),
	503	KEY(1, 3, KEY_F),
	504	KEY(2, 0, KEY_ENTER),
	505	KEY(2, 1, KEY_I),
	506	KEY(2, 2, KEY_J),
	507	KEY(2, 3, KEY_K),
	508	KEY(3, 0, KEY_M),
	509	KEY(3, 1, KEY_N),
	510	KEY(3, 2, KEY_O),
	511	KEY(3, 3, KEY_P)
	512	};
	513
	514	static struct matrix_keymap_data igep2_keymap_data = {
	515	.keymap = igep2_keymap,
	516	.keymap_size = ARRAY_SIZE(igep2_keymap),
	517	};
	518
	519	static struct twl4030_keypad_data igep2_keypad_pdata = {
	520	.keymap_data = &igep2_keymap_data,
	521	.rows = 4,
	522	.cols = 4,
	523	.rep = 1,
	524	};
	525
58e11162 EBS	526	static struct twl4030_platform_data igep2_twldata = {
	527	.irq_base = TWL4030_IRQ_BASE,
	528	.irq_end = TWL4030_IRQ_END,
	529
	530	/* platform_data for children goes here */
	531	.usb = &igep2_usb_data,
7f5f23da	532	.codec = &igep2_codec_data,
bee15390	533	.gpio = &igep2_twl4030_gpio_pdata,
18cbc7d9	534	.keypad = &igep2_keypad_pdata,
58e11162	535	.vmmc1 = &igep2_vmmc1,
691de27f	536	.vpll2 = &igep2_vpll2,
da07c0cf	537	.vio = &igep2_vio,
58e11162 EBS	538	};
58e11162 EBS	539
91d139cf EBS	540	static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
	541	{
	542	I2C_BOARD_INFO("eeprom", 0x50),
	543	},
	544	};
	545
	546	static void __init igep2_i2c_init(void)
58e11162	547	{
91d139cf EBS	548	int ret;
91d139cf EBS	549
fbd8071c	550	omap3_pmic_init("twl4030", &igep2_twldata);
91d139cf EBS	551
	552	/*
	553	* Bus 3 is attached to the DVI port where devices like the pico DLP
	554	* projector don't work reliably with 400kHz
	555	*/
	556	ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
	557	ARRAY_SIZE(igep2_i2c3_boardinfo));
	558	if (ret)
	559	pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
58e11162 EBS	560	}
58e11162 EBS	561
884b8369 MM	562	static struct omap_musb_board_data musb_board_data = {
	563	.interface_type = MUSB_INTERFACE_ULPI,
	564	.mode = MUSB_OTG,
	565	.power = 100,
	566	};
	567
181b250c KM	568	static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
	569	.port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
	570	.port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
	571	.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
d0885486 EBS	572
d0885486 EBS	573	.phy_reset = true,
f6b74535 EBS	574	.reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
f6b74535 EBS	575	.reset_gpio_port[1] = -EINVAL,
d0885486 EBS	576	.reset_gpio_port[2] = -EINVAL,
	577	};
	578
ca5742bd TL	579	#ifdef CONFIG_OMAP_MUX
	580	static struct omap_board_mux board_mux[] __initdata = {
	581	{ .reg_offset = OMAP_MUX_TERMINATOR },
	582	};
ca5742bd TL	583	#endif
ca5742bd TL	584
5a9fcc99 EBS	585	#if defined(CONFIG_LIBERTAS_SDIO) \|\| defined(CONFIG_LIBERTAS_SDIO_MODULE)
	586
	587	static void __init igep2_wlan_bt_init(void)
	588	{
	589	unsigned npd, wreset, btreset;
	590
	591	/* GPIO's for WLAN-BT combo depends on hardware revision */
	592	if (hwrev == IGEP2_BOARD_HWREV_B) {
	593	npd = IGEP2_RB_GPIO_WIFI_NPD;
	594	wreset = IGEP2_RB_GPIO_WIFI_NRESET;
	595	btreset = IGEP2_RB_GPIO_BT_NRESET;
	596	} else if (hwrev == IGEP2_BOARD_HWREV_C) {
	597	npd = IGEP2_RC_GPIO_WIFI_NPD;
	598	wreset = IGEP2_RC_GPIO_WIFI_NRESET;
	599	btreset = IGEP2_RC_GPIO_BT_NRESET;
	600	} else
	601	return;
	602
	603	/* Set GPIO's for WLAN-BT combo module */
	604	if ((gpio_request(npd, "GPIO_WIFI_NPD") == 0) &&
	605	(gpio_direction_output(npd, 1) == 0)) {
	606	gpio_export(npd, 0);
	607	} else
	608	pr_warning("IGEP2: Could not obtain gpio GPIO_WIFI_NPD\n");
	609
	610	if ((gpio_request(wreset, "GPIO_WIFI_NRESET") == 0) &&
	611	(gpio_direction_output(wreset, 1) == 0)) {
	612	gpio_export(wreset, 0);
	613	gpio_set_value(wreset, 0);
	614	udelay(10);
	615	gpio_set_value(wreset, 1);
	616	} else
	617	pr_warning("IGEP2: Could not obtain gpio GPIO_WIFI_NRESET\n");
	618
	619	if ((gpio_request(btreset, "GPIO_BT_NRESET") == 0) &&
	620	(gpio_direction_output(btreset, 1) == 0)) {
	621	gpio_export(btreset, 0);
	622	} else
	623	pr_warning("IGEP2: Could not obtain gpio GPIO_BT_NRESET\n");
	624	}
	625	#else
	626	static inline void __init igep2_wlan_bt_init(void) { }
	627	#endif
	628
58e11162 EBS	629	static void __init igep2_init(void)
58e11162 EBS	630	{
ca5742bd	631	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
3f8c48d9 EBS	632
	633	/* Get IGEP2 hardware revision */
	634	igep2_get_revision();
91d139cf	635	/* Register I2C busses and drivers */
58e11162	636	igep2_i2c_init();
691de27f	637	platform_add_devices(igep2_devices, ARRAY_SIZE(igep2_devices));
d5e13227	638	omap_display_init(&igep2_dss_data);
58e11162	639	omap_serial_init();
884b8369	640	usb_musb_init(&musb_board_data);
9e64bb1e	641	usbhs_init(&usbhs_bdata);
58e11162	642
cddb483a	643	igep2_flash_init();
bee15390	644	igep2_leds_init();
691de27f	645	igep2_display_init();
58e11162 EBS	646	igep2_init_smsc911x();
58e11162 EBS	647
5a9fcc99	648	/*
25985edc	649	* WLAN-BT combo module from MuRata which has a Marvell WLAN
5a9fcc99 EBS	650	* (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
	651	*/
	652	igep2_wlan_bt_init();
c67b0d98	653
58e11162 EBS	654	}
58e11162 EBS	655
58e11162	656	MACHINE_START(IGEP0020, "IGEP v2 board")
58e11162	657	.boot_params = 0x80000100,
71ee7dad	658	.reserve = omap_reserve,
3dc3bad6 RKAL	659	.map_io = omap3_map_io,
	660	.init_early = igep2_init_early,
	661	.init_irq = omap_init_irq,
58e11162 EBS	662	.init_machine = igep2_init,
	663	.timer = &omap_timer,
	664	MACHINE_END