[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_one(IGEP2_GPIO_LED1_RED, GPIOF_IN, "GPIO_HW0_REV")) {
		pr_warning("IGEP2: Could not obtain gpio GPIO_HW0_REV\n");
		pr_err("IGEP2: Unknown Hardware Revision\n");
		return;
	}

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

	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 struct gpio igep2_gpio_leds[] __initdata = {
	{ IGEP2_GPIO_LED0_RED,	 GPIOF_OUT_INIT_LOW, "gpio-led:red:d0"   },
	{ IGEP2_GPIO_LED0_GREEN, GPIOF_OUT_INIT_LOW, "gpio-led:green:d0" },
	{ IGEP2_GPIO_LED1_RED,	 GPIOF_OUT_INIT_LOW, "gpio-led:red:d1"   },
};

static inline void igep2_leds_init(void)
{
	if (gpio_request_array(igep2_gpio_leds, ARRAY_SIZE(igep2_gpio_leds))) {
		pr_warning("IGEP v2: Could not obtain leds gpios\n");
		return;
	}

	gpio_export(IGEP2_GPIO_LED0_RED, 0);
	gpio_export(IGEP2_GPIO_LED0_GREEN, 0);
	gpio_export(IGEP2_GPIO_LED1_RED, 0);
}
#endif

static struct gpio igep2_twl_gpios[] = {
	{ -EINVAL, GPIOF_IN,		"GPIO_EHCI_NOC"  },
	{ -EINVAL, GPIOF_OUT_INIT_LOW,	"GPIO_USBH_CPEN" },
};

static int igep2_twl_gpio_setup(struct device *dev,
		unsigned gpio, unsigned ngpio)
{
	int ret;

	/* 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
	 */
	igep2_twl_gpios[0].gpio = gpio + 1;

	/* TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN (out, active low) */
	igep2_twl_gpios[1].gpio = gpio + TWL4030_GPIO_MAX;

	ret = gpio_request_array(igep2_twl_gpios, ARRAY_SIZE(igep2_twl_gpios));
	if (ret < 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)
	ret = gpio_request_one(gpio + TWL4030_GPIO_MAX + 1, GPIOF_OUT_INIT_HIGH,
			       "gpio-led:green:d1");
	if (ret == 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)
{
	int err = gpio_request_one(IGEP2_GPIO_DVI_PUP, GPIOF_OUT_INIT_HIGH,
				   "GPIO_DVI_PUP");
	if (err)
		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 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 struct gpio igep2_wlan_bt_gpios[] __initdata = {
	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NPD"	   },
	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NRESET" },
	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_BT_NRESET"   },
};

static void __init igep2_wlan_bt_init(void)
{
	int err;

	/* GPIO's for WLAN-BT combo depends on hardware revision */
	if (hwrev == IGEP2_BOARD_HWREV_B) {
		igep2_wlan_bt_gpios[0].gpio = IGEP2_RB_GPIO_WIFI_NPD;
		igep2_wlan_bt_gpios[1].gpio = IGEP2_RB_GPIO_WIFI_NRESET;
		igep2_wlan_bt_gpios[2].gpio = IGEP2_RB_GPIO_BT_NRESET;
	} else if (hwrev == IGEP2_BOARD_HWREV_C) {
		igep2_wlan_bt_gpios[0].gpio = IGEP2_RC_GPIO_WIFI_NPD;
		igep2_wlan_bt_gpios[1].gpio = IGEP2_RC_GPIO_WIFI_NRESET;
		igep2_wlan_bt_gpios[2].gpio = IGEP2_RC_GPIO_BT_NRESET;
	} else
		return;

	err = gpio_request_array(igep2_wlan_bt_gpios,
				 ARRAY_SIZE(igep2_wlan_bt_gpios));
	if (err) {
		pr_warning("IGEP2: Could not obtain WIFI/BT gpios\n");
		return;
	}

	gpio_export(igep2_wlan_bt_gpios[0].gpio, 0);
	gpio_export(igep2_wlan_bt_gpios[1].gpio, 0);
	gpio_export(igep2_wlan_bt_gpios[2].gpio, 0);

	gpio_set_value(igep2_wlan_bt_gpios[1].gpio, 0);
	udelay(10);
	gpio_set_value(igep2_wlan_bt_gpios[1].gpio, 1);

}
#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(NULL);
	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
bc593f5d	81	if (gpio_request_one(IGEP2_GPIO_LED1_RED, GPIOF_IN, "GPIO_HW0_REV")) {
3f8c48d9 EBS	82	pr_warning("IGEP2: Could not obtain gpio GPIO_HW0_REV\n");
3f8c48d9 EBS	83	pr_err("IGEP2: Unknown Hardware Revision\n");
bc593f5d IG	84	return;
	85	}
	86
	87	ret = gpio_get_value(IGEP2_GPIO_LED1_RED);
	88	if (ret == 0) {
	89	pr_info("IGEP2: Hardware Revision C (B-NON compatible)\n");
	90	hwrev = IGEP2_BOARD_HWREV_C;
	91	} else if (ret == 1) {
	92	pr_info("IGEP2: Hardware Revision B/C (B compatible)\n");
	93	hwrev = IGEP2_BOARD_HWREV_B;
	94	} else {
	95	pr_err("IGEP2: Unknown Hardware Revision\n");
	96	hwrev = -1;
3f8c48d9 EBS	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
bc593f5d IG	342	static struct gpio igep2_gpio_leds[] __initdata = {
	343	{ IGEP2_GPIO_LED0_RED, GPIOF_OUT_INIT_LOW, "gpio-led:red:d0" },
	344	{ IGEP2_GPIO_LED0_GREEN, GPIOF_OUT_INIT_LOW, "gpio-led:green:d0" },
	345	{ IGEP2_GPIO_LED1_RED, GPIOF_OUT_INIT_LOW, "gpio-led:red:d1" },
	346	};
	347
bee15390 EBS	348	static inline void igep2_leds_init(void)
bee15390 EBS	349	{
bc593f5d IG	350	if (gpio_request_array(igep2_gpio_leds, ARRAY_SIZE(igep2_gpio_leds))) {
	351	pr_warning("IGEP v2: Could not obtain leds gpios\n");
	352	return;
	353	}
bee15390	354
bc593f5d IG	355	gpio_export(IGEP2_GPIO_LED0_RED, 0);
	356	gpio_export(IGEP2_GPIO_LED0_GREEN, 0);
	357	gpio_export(IGEP2_GPIO_LED1_RED, 0);
bee15390 EBS	358	}
	359	#endif
	360
bc593f5d IG	361	static struct gpio igep2_twl_gpios[] = {
	362	{ -EINVAL, GPIOF_IN, "GPIO_EHCI_NOC" },
	363	{ -EINVAL, GPIOF_OUT_INIT_LOW, "GPIO_USBH_CPEN" },
	364	};
	365
58e11162 EBS	366	static int igep2_twl_gpio_setup(struct device *dev,
	367	unsigned gpio, unsigned ngpio)
	368	{
bc593f5d IG	369	int ret;
bc593f5d IG	370
58e11162 EBS	371	/* gpio + 0 is "mmc0_cd" (input/IRQ) */
58e11162 EBS	372	mmc[0].gpio_cd = gpio + 0;
68ff0423	373	omap2_hsmmc_init(mmc);
58e11162	374
61e118dd EBS	375	/*
	376	* REVISIT: need ehci-omap hooks for external VBUS
	377	* power switch and overcurrent detect
	378	*/
bc593f5d	379	igep2_twl_gpios[0].gpio = gpio + 1;
61e118dd	380
bc593f5d IG	381	/* TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN (out, active low) */
	382	igep2_twl_gpios[1].gpio = gpio + TWL4030_GPIO_MAX;
	383
	384	ret = gpio_request_array(igep2_twl_gpios, ARRAY_SIZE(igep2_twl_gpios));
	385	if (ret < 0)
61e118dd EBS	386	pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");
61e118dd EBS	387
bee15390 EBS	388	/* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
bee15390 EBS	389	#if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
bc593f5d IG	390	ret = gpio_request_one(gpio + TWL4030_GPIO_MAX + 1, GPIOF_OUT_INIT_HIGH,
	391	"gpio-led:green:d1");
	392	if (ret == 0)
bee15390	393	gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
62d8e9e2	394	else
bee15390 EBS	395	pr_warning("IGEP v2: Could not obtain gpio GPIO_LED1_GREEN\n");
	396	#else
	397	igep2_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
	398	#endif
58e11162 EBS	399
	400	return 0;
	401	};
	402
bee15390	403	static struct twl4030_gpio_platform_data igep2_twl4030_gpio_pdata = {
58e11162 EBS	404	.gpio_base = OMAP_MAX_GPIO_LINES,
	405	.irq_base = TWL4030_GPIO_IRQ_BASE,
	406	.irq_end = TWL4030_GPIO_IRQ_END,
bee15390	407	.use_leds = true,
58e11162 EBS	408	.setup = igep2_twl_gpio_setup,
	409	};
	410
	411	static struct twl4030_usb_data igep2_usb_data = {
	412	.usb_mode = T2_USB_MODE_ULPI,
	413	};
	414
691de27f EBS	415	static int igep2_enable_dvi(struct omap_dss_device *dssdev)
	416	{
	417	gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1);
	418
	419	return 0;
	420	}
	421
	422	static void igep2_disable_dvi(struct omap_dss_device *dssdev)
	423	{
	424	gpio_direction_output(IGEP2_GPIO_DVI_PUP, 0);
	425	}
	426
89747c91 BW	427	static struct panel_generic_dpi_data dvi_panel = {
	428	.name = "generic",
	429	.platform_enable = igep2_enable_dvi,
	430	.platform_disable = igep2_disable_dvi,
	431	};
	432
691de27f EBS	433	static struct omap_dss_device igep2_dvi_device = {
	434	.type = OMAP_DISPLAY_TYPE_DPI,
	435	.name = "dvi",
89747c91 BW	436	.driver_name = "generic_dpi_panel",
89747c91 BW	437	.data = &dvi_panel,
691de27f	438	.phy.dpi.data_lines = 24,
691de27f EBS	439	};
	440
	441	static struct omap_dss_device *igep2_dss_devices[] = {
	442	&igep2_dvi_device
	443	};
	444
	445	static struct omap_dss_board_info igep2_dss_data = {
	446	.num_devices = ARRAY_SIZE(igep2_dss_devices),
	447	.devices = igep2_dss_devices,
	448	.default_device = &igep2_dvi_device,
	449	};
	450
c8aac01b SG	451	static struct regulator_consumer_supply igep2_vpll2_supplies[] = {
	452	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
	453	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
	454	};
691de27f EBS	455
	456	static struct regulator_init_data igep2_vpll2 = {
	457	.constraints = {
	458	.name = "VDVI",
	459	.min_uV = 1800000,
	460	.max_uV = 1800000,
	461	.apply_uV = true,
	462	.valid_modes_mask = REGULATOR_MODE_NORMAL
	463	\| REGULATOR_MODE_STANDBY,
	464	.valid_ops_mask = REGULATOR_CHANGE_MODE
	465	\| REGULATOR_CHANGE_STATUS,
	466	},
c8aac01b SG	467	.num_consumer_supplies = ARRAY_SIZE(igep2_vpll2_supplies),
c8aac01b SG	468	.consumer_supplies = igep2_vpll2_supplies,
691de27f EBS	469	};
	470
	471	static void __init igep2_display_init(void)
	472	{
bc593f5d IG	473	int err = gpio_request_one(IGEP2_GPIO_DVI_PUP, GPIOF_OUT_INIT_HIGH,
	474	"GPIO_DVI_PUP");
	475	if (err)
691de27f EBS	476	pr_err("IGEP v2: Could not obtain gpio GPIO_DVI_PUP\n");
691de27f EBS	477	}
228893f9	478
691de27f	479	static struct platform_device *igep2_devices[] __initdata = {
da07c0cf	480	&igep2_vwlan_device,
691de27f EBS	481	};
691de27f EBS	482
3dc3bad6	483	static void __init igep2_init_early(void)
58e11162	484	{
4805734b PW	485	omap2_init_common_infrastructure();
	486	omap2_init_common_devices(m65kxxxxam_sdrc_params,
	487	m65kxxxxam_sdrc_params);
58e11162 EBS	488	}
58e11162 EBS	489
6a58baf8	490	static struct twl4030_codec_audio_data igep2_audio_data;
7f5f23da EBS	491
	492	static struct twl4030_codec_data igep2_codec_data = {
	493	.audio_mclk = 26000000,
	494	.audio = &igep2_audio_data,
	495	};
	496
18cbc7d9 EBS	497	static int igep2_keymap[] = {
	498	KEY(0, 0, KEY_LEFT),
	499	KEY(0, 1, KEY_RIGHT),
	500	KEY(0, 2, KEY_A),
	501	KEY(0, 3, KEY_B),
	502	KEY(1, 0, KEY_DOWN),
	503	KEY(1, 1, KEY_UP),
	504	KEY(1, 2, KEY_E),
	505	KEY(1, 3, KEY_F),
	506	KEY(2, 0, KEY_ENTER),
	507	KEY(2, 1, KEY_I),
	508	KEY(2, 2, KEY_J),
	509	KEY(2, 3, KEY_K),
	510	KEY(3, 0, KEY_M),
	511	KEY(3, 1, KEY_N),
	512	KEY(3, 2, KEY_O),
	513	KEY(3, 3, KEY_P)
	514	};
	515
	516	static struct matrix_keymap_data igep2_keymap_data = {
	517	.keymap = igep2_keymap,
	518	.keymap_size = ARRAY_SIZE(igep2_keymap),
	519	};
	520
	521	static struct twl4030_keypad_data igep2_keypad_pdata = {
	522	.keymap_data = &igep2_keymap_data,
	523	.rows = 4,
	524	.cols = 4,
	525	.rep = 1,
	526	};
	527
58e11162 EBS	528	static struct twl4030_platform_data igep2_twldata = {
	529	.irq_base = TWL4030_IRQ_BASE,
	530	.irq_end = TWL4030_IRQ_END,
	531
	532	/* platform_data for children goes here */
	533	.usb = &igep2_usb_data,
7f5f23da	534	.codec = &igep2_codec_data,
bee15390	535	.gpio = &igep2_twl4030_gpio_pdata,
18cbc7d9	536	.keypad = &igep2_keypad_pdata,
58e11162	537	.vmmc1 = &igep2_vmmc1,
691de27f	538	.vpll2 = &igep2_vpll2,
da07c0cf	539	.vio = &igep2_vio,
58e11162 EBS	540	};
58e11162 EBS	541
91d139cf EBS	542	static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
	543	{
	544	I2C_BOARD_INFO("eeprom", 0x50),
	545	},
	546	};
	547
	548	static void __init igep2_i2c_init(void)
58e11162	549	{
91d139cf EBS	550	int ret;
91d139cf EBS	551
fbd8071c	552	omap3_pmic_init("twl4030", &igep2_twldata);
91d139cf EBS	553
	554	/*
	555	* Bus 3 is attached to the DVI port where devices like the pico DLP
	556	* projector don't work reliably with 400kHz
	557	*/
	558	ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
	559	ARRAY_SIZE(igep2_i2c3_boardinfo));
	560	if (ret)
	561	pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
58e11162 EBS	562	}
58e11162 EBS	563
181b250c KM	564	static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
	565	.port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
	566	.port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
	567	.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
d0885486 EBS	568
d0885486 EBS	569	.phy_reset = true,
f6b74535 EBS	570	.reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
f6b74535 EBS	571	.reset_gpio_port[1] = -EINVAL,
d0885486 EBS	572	.reset_gpio_port[2] = -EINVAL,
	573	};
	574
ca5742bd TL	575	#ifdef CONFIG_OMAP_MUX
	576	static struct omap_board_mux board_mux[] __initdata = {
	577	{ .reg_offset = OMAP_MUX_TERMINATOR },
	578	};
ca5742bd TL	579	#endif
ca5742bd TL	580
5a9fcc99	581	#if defined(CONFIG_LIBERTAS_SDIO) \|\| defined(CONFIG_LIBERTAS_SDIO_MODULE)
bc593f5d IG	582	static struct gpio igep2_wlan_bt_gpios[] __initdata = {
	583	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NPD" },
	584	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NRESET" },
	585	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_BT_NRESET" },
	586	};
5a9fcc99 EBS	587
	588	static void __init igep2_wlan_bt_init(void)
	589	{
bc593f5d	590	int err;
5a9fcc99 EBS	591
	592	/* GPIO's for WLAN-BT combo depends on hardware revision */
	593	if (hwrev == IGEP2_BOARD_HWREV_B) {
bc593f5d IG	594	igep2_wlan_bt_gpios[0].gpio = IGEP2_RB_GPIO_WIFI_NPD;
	595	igep2_wlan_bt_gpios[1].gpio = IGEP2_RB_GPIO_WIFI_NRESET;
	596	igep2_wlan_bt_gpios[2].gpio = IGEP2_RB_GPIO_BT_NRESET;
5a9fcc99	597	} else if (hwrev == IGEP2_BOARD_HWREV_C) {
bc593f5d IG	598	igep2_wlan_bt_gpios[0].gpio = IGEP2_RC_GPIO_WIFI_NPD;
	599	igep2_wlan_bt_gpios[1].gpio = IGEP2_RC_GPIO_WIFI_NRESET;
	600	igep2_wlan_bt_gpios[2].gpio = IGEP2_RC_GPIO_BT_NRESET;
5a9fcc99 EBS	601	} else
	602	return;
	603
bc593f5d IG	604	err = gpio_request_array(igep2_wlan_bt_gpios,
	605	ARRAY_SIZE(igep2_wlan_bt_gpios));
	606	if (err) {
	607	pr_warning("IGEP2: Could not obtain WIFI/BT gpios\n");
	608	return;
	609	}
	610
	611	gpio_export(igep2_wlan_bt_gpios[0].gpio, 0);
	612	gpio_export(igep2_wlan_bt_gpios[1].gpio, 0);
	613	gpio_export(igep2_wlan_bt_gpios[2].gpio, 0);
	614
	615	gpio_set_value(igep2_wlan_bt_gpios[1].gpio, 0);
	616	udelay(10);
	617	gpio_set_value(igep2_wlan_bt_gpios[1].gpio, 1);
5a9fcc99	618
5a9fcc99 EBS	619	}
	620	#else
	621	static inline void __init igep2_wlan_bt_init(void) { }
	622	#endif
	623
58e11162 EBS	624	static void __init igep2_init(void)
58e11162 EBS	625	{
ca5742bd	626	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
3f8c48d9 EBS	627
	628	/* Get IGEP2 hardware revision */
	629	igep2_get_revision();
91d139cf	630	/* Register I2C busses and drivers */
58e11162	631	igep2_i2c_init();
691de27f	632	platform_add_devices(igep2_devices, ARRAY_SIZE(igep2_devices));
d5e13227	633	omap_display_init(&igep2_dss_data);
58e11162	634	omap_serial_init();
9e18630b	635	usb_musb_init(NULL);
9e64bb1e	636	usbhs_init(&usbhs_bdata);
58e11162	637
cddb483a	638	igep2_flash_init();
bee15390	639	igep2_leds_init();
691de27f	640	igep2_display_init();
58e11162 EBS	641	igep2_init_smsc911x();
58e11162 EBS	642
5a9fcc99	643	/*
25985edc	644	* WLAN-BT combo module from MuRata which has a Marvell WLAN
5a9fcc99 EBS	645	* (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
	646	*/
	647	igep2_wlan_bt_init();
c67b0d98	648
58e11162 EBS	649	}
58e11162 EBS	650
58e11162	651	MACHINE_START(IGEP0020, "IGEP v2 board")
58e11162	652	.boot_params = 0x80000100,
71ee7dad	653	.reserve = omap_reserve,
3dc3bad6 RKAL	654	.map_io = omap3_map_io,
	655	.init_early = igep2_init_early,
	656	.init_irq = omap_init_irq,
58e11162 EBS	657	.init_machine = igep2_init,
	658	.timer = &omap_timer,
	659	MACHINE_END