[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/usb/phy.h>

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

#include <linux/mtd/nand.h>

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

#include <video/omapdss.h>
#include <video/omap-panel-tfp410.h>
#include <linux/platform_data/mtd-onenand-omap2.h>

#include "common.h"
#include "gpmc.h"
#include "mux.h"
#include "hsmmc.h"
#include "sdram-numonyx-m65kxxxxam.h"
#include "common-board-devices.h"
#include "board-flash.h"
#include "control.h"
#include "gpmc-onenand.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

#define IGEP3_GPIO_LED0_GREEN	54
#define IGEP3_GPIO_LED0_RED	53
#define IGEP3_GPIO_LED1_RED	16
#define IGEP3_GPIO_USBH_NRESET  183

#define IGEP_SYSBOOT_MASK           0x1f
#define IGEP_SYSBOOT_NAND           0x0f
#define IGEP_SYSBOOT_ONENAND        0x10

/*
 * 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
#define IGEP3_BOARD_HWREV	2

static u8 hwrev;

static void __init igep2_get_revision(void)
{
	u8 ret;

	if (machine_is_igep0030()) {
		hwrev = IGEP3_BOARD_HWREV;
		return;
	}

	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) ||	\
	defined(CONFIG_MTD_NAND_OMAP2) ||		\
	defined(CONFIG_MTD_NAND_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 igep_flash_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 inline u32 igep_get_sysboot_value(void)
{
	return omap_ctrl_readl(OMAP343X_CONTROL_STATUS) & IGEP_SYSBOOT_MASK;
}

static void __init igep_flash_init(void)
{
	u32 mux;
	mux = igep_get_sysboot_value();

	if (mux == IGEP_SYSBOOT_NAND) {
		pr_info("IGEP: initializing NAND memory device\n");
		board_nand_init(igep_flash_partitions,
				ARRAY_SIZE(igep_flash_partitions),
				0, NAND_BUSWIDTH_16, nand_default_timings);
	} else if (mux == IGEP_SYSBOOT_ONENAND) {
		pr_info("IGEP: initializing OneNAND memory device\n");
		board_onenand_init(igep_flash_partitions,
				   ARRAY_SIZE(igep_flash_partitions), 0);
	} else {
		pr_err("IGEP: Flash: unsupported sysboot sequence found\n");
	}
}

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

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

#include <linux/smsc911x.h>
#include "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 igep_vmmc1_supply[] = {
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
};

/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
static struct regulator_init_data igep_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  = ARRAY_SIZE(igep_vmmc1_supply),
	.consumer_supplies      = igep_vmmc1_supply,
};

static struct regulator_consumer_supply igep_vio_supply[] = {
	REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1"),
};

static struct regulator_init_data igep_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  = ARRAY_SIZE(igep_vio_supply),
	.consumer_supplies      = igep_vio_supply,
};

static struct regulator_consumer_supply igep_vmmc2_supply[] = {
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
};

static struct regulator_init_data igep_vmmc2 = {
	.constraints		= {
		.valid_modes_mask	= REGULATOR_MODE_NORMAL,
		.always_on		= 1,
	},
	.num_consumer_supplies	= ARRAY_SIZE(igep_vmmc2_supply),
	.consumer_supplies	= igep_vmmc2_supply,
};

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

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

static struct omap2_hsmmc_info mmc[] = {
	{
		.mmc		= 1,
		.caps		= MMC_CAP_4_BIT_DATA,
		.gpio_cd	= -EINVAL,
		.gpio_wp	= -EINVAL,
		.deferred	= true,
	},
#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 igep_gpio_leds[] = {
	[0] = {
		.name			= "omap3:red:user0",
		.default_state		= 0,
	},
	[1] = {
		.name			= "omap3:green:boot",
		.default_state		= 1,
	},
	[2] = {
		.name			= "omap3:red:user1",
		.default_state		= 0,
	},
	[3] = {
		.name			= "omap3:green:user1",
		.default_state		= 0,
		.gpio			= -EINVAL, /* gets replaced */
		.active_low		= 1,
	},
};

static struct gpio_led_platform_data igep_led_pdata = {
	.leds           = igep_gpio_leds,
	.num_leds       = ARRAY_SIZE(igep_gpio_leds),
};

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

static void __init igep_leds_init(void)
{
	if (machine_is_igep0020()) {
		igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
		igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
		igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
	} else {
		igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
		igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
		igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
	}

	platform_device_register(&igep_led_device);
}

#else
static struct gpio igep_gpio_leds[] __initdata = {
	{ -EINVAL,	GPIOF_OUT_INIT_LOW, "gpio-led:red:d0"   },
	{ -EINVAL,	GPIOF_OUT_INIT_LOW, "gpio-led:green:d0" },
	{ -EINVAL,	GPIOF_OUT_INIT_LOW, "gpio-led:red:d1"   },
};

static inline void igep_leds_init(void)
{
	int i;

	if (machine_is_igep0020()) {
		igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
		igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
		igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
	} else {
		igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
		igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
		igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
	}

	if (gpio_request_array(igep_gpio_leds, ARRAY_SIZE(igep_gpio_leds))) {
		pr_warning("IGEP v2: Could not obtain leds gpios\n");
		return;
	}

	for (i = 0; i < ARRAY_SIZE(igep_gpio_leds); i++)
		gpio_export(igep_gpio_leds[i].gpio, 0);
}
#endif

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

static int igep_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;
	omap_hsmmc_late_init(mmc);

	/* 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: Could not obtain gpio GPIO_LED1_GREEN\n");
#else
	igep_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
#endif

	if (machine_is_igep0030())
		return 0;

	/*
	 * 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");

	return 0;
};

static struct twl4030_gpio_platform_data igep_twl4030_gpio_pdata = {
	.use_leds	= true,
	.setup		= igep_twl_gpio_setup,
};

static struct tfp410_platform_data dvi_panel = {
	.i2c_bus_num		= 3,
	.power_down_gpio	= IGEP2_GPIO_DVI_PUP,
};

static struct omap_dss_device igep2_dvi_device = {
	.type			= OMAP_DISPLAY_TYPE_DPI,
	.name			= "dvi",
	.driver_name		= "tfp410",
	.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 platform_device *igep_devices[] __initdata = {
	&igep_vwlan_device,
};

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 igep_twldata = {
	/* platform_data for children goes here */
	.gpio		= &igep_twl4030_gpio_pdata,
	.vmmc1          = &igep_vmmc1,
	.vio		= &igep_vio,
};

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

static void __init igep_i2c_init(void)
{
	int ret;

	omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_USB,
			      TWL_COMMON_REGULATOR_VPLL2);
	igep_twldata.vpll2->constraints.apply_uV = true;
	igep_twldata.vpll2->constraints.name = "VDVI";

	if (machine_is_igep0020()) {
		/*
		 * 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);

		igep_twldata.keypad	= &igep2_keypad_pdata;
		/* Get common pmic data */
		omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_AUDIO, 0);
	}

	omap3_pmic_init("twl4030", &igep_twldata);
}

static struct usbhs_omap_platform_data igep2_usbhs_bdata __initdata = {
	.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,
};

static struct usbhs_omap_platform_data igep3_usbhs_bdata __initdata = {
	.port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
	.port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
	.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,

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

#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux board_mux[] __initdata = {
	/* SMSC9221 LAN Controller ETH IRQ (GPIO_176) */
	OMAP3_MUX(MCSPI1_CS2, OMAP_MUX_MODE4 | OMAP_PIN_INPUT),
	{ .reg_offset = OMAP_MUX_TERMINATOR },
};
#endif

#if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
static struct gpio igep_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 igep_wlan_bt_init(void)
{
	int err;

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

	/* Make sure that the GPIO pins are muxed correctly */
	omap_mux_init_gpio(igep_wlan_bt_gpios[0].gpio, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(igep_wlan_bt_gpios[1].gpio, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(igep_wlan_bt_gpios[2].gpio, OMAP_PIN_OUTPUT);

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

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

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

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

static struct regulator_consumer_supply dummy_supplies[] = {
	REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
	REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
};

static void __init igep_init(void)
{
	regulator_register_fixed(1, dummy_supplies, ARRAY_SIZE(dummy_supplies));
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);

	/* Get IGEP2 hardware revision */
	igep2_get_revision();

	omap_hsmmc_init(mmc);

	/* Register I2C busses and drivers */
	igep_i2c_init();
	platform_add_devices(igep_devices, ARRAY_SIZE(igep_devices));
	omap_serial_init();
	omap_sdrc_init(m65kxxxxam_sdrc_params,
				  m65kxxxxam_sdrc_params);
	usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
	usb_musb_init(NULL);

	igep_flash_init();
	igep_leds_init();
	omap_twl4030_audio_init("igep2", NULL);

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

	if (machine_is_igep0020()) {
		omap_display_init(&igep2_dss_data);
		igep2_init_smsc911x();
		usbhs_init(&igep2_usbhs_bdata);
	} else {
		usbhs_init(&igep3_usbhs_bdata);
	}
}

MACHINE_START(IGEP0020, "IGEP v2 board")
	.atag_offset	= 0x100,
	.reserve	= omap_reserve,
	.map_io		= omap3_map_io,
	.init_early	= omap35xx_init_early,
	.init_irq	= omap3_init_irq,
	.handle_irq	= omap3_intc_handle_irq,
	.init_machine	= igep_init,
	.init_late	= omap35xx_init_late,
	.init_time	= omap3_sync32k_timer_init,
	.restart	= omap3xxx_restart,
MACHINE_END

MACHINE_START(IGEP0030, "IGEP OMAP3 module")
	.atag_offset	= 0x100,
	.reserve	= omap_reserve,
	.map_io		= omap3_map_io,
	.init_early	= omap35xx_init_early,
	.init_irq	= omap3_init_irq,
	.handle_irq	= omap3_intc_handle_irq,
	.init_machine	= igep_init,
	.init_late	= omap35xx_init_late,
	.init_time	= omap3_sync32k_timer_init,
	.restart	= omap3xxx_restart,
MACHINE_END
Commit	Line	Data
	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>
	20	#include <linux/input.h>
	21	#include <linux/usb/phy.h>
	22
	23	#include <linux/regulator/machine.h>
	24	#include <linux/regulator/fixed.h>
	25	#include <linux/i2c/twl.h>
	26	#include <linux/mmc/host.h>
	27
	28	#include <linux/mtd/nand.h>
	29
	30	#include <asm/mach-types.h>
	31	#include <asm/mach/arch.h>
	32
	33	#include <video/omapdss.h>
	34	#include <video/omap-panel-tfp410.h>
	35	#include <linux/platform_data/mtd-onenand-omap2.h>
	36
	37	#include "common.h"
	38	#include "gpmc.h"
	39	#include "mux.h"
	40	#include "hsmmc.h"
	41	#include "sdram-numonyx-m65kxxxxam.h"
	42	#include "common-board-devices.h"
	43	#include "board-flash.h"
	44	#include "control.h"
	45	#include "gpmc-onenand.h"
	46
	47	#define IGEP2_SMSC911X_CS 5
	48	#define IGEP2_SMSC911X_GPIO 176
	49	#define IGEP2_GPIO_USBH_NRESET 24
	50	#define IGEP2_GPIO_LED0_GREEN 26
	51	#define IGEP2_GPIO_LED0_RED 27
	52	#define IGEP2_GPIO_LED1_RED 28
	53	#define IGEP2_GPIO_DVI_PUP 170
	54
	55	#define IGEP2_RB_GPIO_WIFI_NPD 94
	56	#define IGEP2_RB_GPIO_WIFI_NRESET 95
	57	#define IGEP2_RB_GPIO_BT_NRESET 137
	58	#define IGEP2_RC_GPIO_WIFI_NPD 138
	59	#define IGEP2_RC_GPIO_WIFI_NRESET 139
	60	#define IGEP2_RC_GPIO_BT_NRESET 137
	61
	62	#define IGEP3_GPIO_LED0_GREEN 54
	63	#define IGEP3_GPIO_LED0_RED 53
	64	#define IGEP3_GPIO_LED1_RED 16
	65	#define IGEP3_GPIO_USBH_NRESET 183
	66
	67	#define IGEP_SYSBOOT_MASK 0x1f
	68	#define IGEP_SYSBOOT_NAND 0x0f
	69	#define IGEP_SYSBOOT_ONENAND 0x10
	70
	71	/*
	72	* IGEP2 Hardware Revision Table
	73	*
	74	* --------------------------------------------------------------------------
	75	* \| Id. \| Hw Rev. \| HW0 (28) \| WIFI_NPD \| WIFI_NRESET \| BT_NRESET \|
	76	* --------------------------------------------------------------------------
	77	* \| 0 \| B \| high \| gpio94 \| gpio95 \| - \|
	78	* \| 0 \| B/C (B-compatible) \| high \| gpio94 \| gpio95 \| gpio137 \|
	79	* \| 1 \| C \| low \| gpio138 \| gpio139 \| gpio137 \|
	80	* --------------------------------------------------------------------------
	81	*/
	82
	83	#define IGEP2_BOARD_HWREV_B 0
	84	#define IGEP2_BOARD_HWREV_C 1
	85	#define IGEP3_BOARD_HWREV 2
	86
	87	static u8 hwrev;
	88
	89	static void __init igep2_get_revision(void)
	90	{
	91	u8 ret;
	92
	93	if (machine_is_igep0030()) {
	94	hwrev = IGEP3_BOARD_HWREV;
	95	return;
	96	}
	97
	98	omap_mux_init_gpio(IGEP2_GPIO_LED1_RED, OMAP_PIN_INPUT);
	99
	100	if (gpio_request_one(IGEP2_GPIO_LED1_RED, GPIOF_IN, "GPIO_HW0_REV")) {
	101	pr_warning("IGEP2: Could not obtain gpio GPIO_HW0_REV\n");
	102	pr_err("IGEP2: Unknown Hardware Revision\n");
	103	return;
	104	}
	105
	106	ret = gpio_get_value(IGEP2_GPIO_LED1_RED);
	107	if (ret == 0) {
	108	pr_info("IGEP2: Hardware Revision C (B-NON compatible)\n");
	109	hwrev = IGEP2_BOARD_HWREV_C;
	110	} else if (ret == 1) {
	111	pr_info("IGEP2: Hardware Revision B/C (B compatible)\n");
	112	hwrev = IGEP2_BOARD_HWREV_B;
	113	} else {
	114	pr_err("IGEP2: Unknown Hardware Revision\n");
	115	hwrev = -1;
	116	}
	117
	118	gpio_free(IGEP2_GPIO_LED1_RED);
	119	}
	120
	121	#if defined(CONFIG_MTD_ONENAND_OMAP2) \|\| \
	122	defined(CONFIG_MTD_ONENAND_OMAP2_MODULE) \|\| \
	123	defined(CONFIG_MTD_NAND_OMAP2) \|\| \
	124	defined(CONFIG_MTD_NAND_OMAP2_MODULE)
	125
	126	#define ONENAND_MAP 0x20000000
	127
	128	/* NAND04GR4E1A ( x2 Flash built-in COMBO POP MEMORY )
	129	* Since the device is equipped with two DataRAMs, and two-plane NAND
	130	* Flash memory array, these two component enables simultaneous program
	131	* of 4KiB. Plane1 has only even blocks such as block0, block2, block4
	132	* while Plane2 has only odd blocks such as block1, block3, block5.
	133	* So MTD regards it as 4KiB page size and 256KiB block size 64(22048)
	134	*/
	135
	136	static struct mtd_partition igep_flash_partitions[] = {
	137	{
	138	.name = "X-Loader",
	139	.offset = 0,
	140	.size = 2 * (64(22048))
	141	},
	142	{
	143	.name = "U-Boot",
	144	.offset = MTDPART_OFS_APPEND,
	145	.size = 6 * (64(22048)),
	146	},
	147	{
	148	.name = "Environment",
	149	.offset = MTDPART_OFS_APPEND,
	150	.size = 2 * (64(22048)),
	151	},
	152	{
	153	.name = "Kernel",
	154	.offset = MTDPART_OFS_APPEND,
	155	.size = 12 * (64(22048)),
	156	},
	157	{
	158	.name = "File System",
	159	.offset = MTDPART_OFS_APPEND,
	160	.size = MTDPART_SIZ_FULL,
	161	},
	162	};
	163
	164	static inline u32 igep_get_sysboot_value(void)
	165	{
	166	return omap_ctrl_readl(OMAP343X_CONTROL_STATUS) & IGEP_SYSBOOT_MASK;
	167	}
	168
	169	static void __init igep_flash_init(void)
	170	{
	171	u32 mux;
	172	mux = igep_get_sysboot_value();
	173
	174	if (mux == IGEP_SYSBOOT_NAND) {
	175	pr_info("IGEP: initializing NAND memory device\n");
	176	board_nand_init(igep_flash_partitions,
	177	ARRAY_SIZE(igep_flash_partitions),
	178	0, NAND_BUSWIDTH_16, nand_default_timings);
	179	} else if (mux == IGEP_SYSBOOT_ONENAND) {
	180	pr_info("IGEP: initializing OneNAND memory device\n");
	181	board_onenand_init(igep_flash_partitions,
	182	ARRAY_SIZE(igep_flash_partitions), 0);
	183	} else {
	184	pr_err("IGEP: Flash: unsupported sysboot sequence found\n");
	185	}
	186	}
	187
	188	#else
	189	static void __init igep_flash_init(void) {}
	190	#endif
	191
	192	#if defined(CONFIG_SMSC911X) \|\| defined(CONFIG_SMSC911X_MODULE)
	193
	194	#include <linux/smsc911x.h>
	195	#include "gpmc-smsc911x.h"
	196
	197	static struct omap_smsc911x_platform_data smsc911x_cfg = {
	198	.cs = IGEP2_SMSC911X_CS,
	199	.gpio_irq = IGEP2_SMSC911X_GPIO,
	200	.gpio_reset = -EINVAL,
	201	.flags = SMSC911X_USE_32BIT \| SMSC911X_SAVE_MAC_ADDRESS,
	202	};
	203
	204	static inline void __init igep2_init_smsc911x(void)
	205	{
	206	gpmc_smsc911x_init(&smsc911x_cfg);
	207	}
	208
	209	#else
	210	static inline void __init igep2_init_smsc911x(void) { }
	211	#endif
	212
	213	static struct regulator_consumer_supply igep_vmmc1_supply[] = {
	214	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
	215	};
	216
	217	/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
	218	static struct regulator_init_data igep_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 = ARRAY_SIZE(igep_vmmc1_supply),
	229	.consumer_supplies = igep_vmmc1_supply,
	230	};
	231
	232	static struct regulator_consumer_supply igep_vio_supply[] = {
	233	REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1"),
	234	};
	235
	236	static struct regulator_init_data igep_vio = {
	237	.constraints = {
	238	.min_uV = 1800000,
	239	.max_uV = 1800000,
	240	.apply_uV = 1,
	241	.valid_modes_mask = REGULATOR_MODE_NORMAL
	242	\| REGULATOR_MODE_STANDBY,
	243	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	244	\| REGULATOR_CHANGE_MODE
	245	\| REGULATOR_CHANGE_STATUS,
	246	},
	247	.num_consumer_supplies = ARRAY_SIZE(igep_vio_supply),
	248	.consumer_supplies = igep_vio_supply,
	249	};
	250
	251	static struct regulator_consumer_supply igep_vmmc2_supply[] = {
	252	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
	253	};
	254
	255	static struct regulator_init_data igep_vmmc2 = {
	256	.constraints = {
	257	.valid_modes_mask = REGULATOR_MODE_NORMAL,
	258	.always_on = 1,
	259	},
	260	.num_consumer_supplies = ARRAY_SIZE(igep_vmmc2_supply),
	261	.consumer_supplies = igep_vmmc2_supply,
	262	};
	263
	264	static struct fixed_voltage_config igep_vwlan = {
	265	.supply_name = "vwlan",
	266	.microvolts = 3300000,
	267	.gpio = -EINVAL,
	268	.enabled_at_boot = 1,
	269	.init_data = &igep_vmmc2,
	270	};
	271
	272	static struct platform_device igep_vwlan_device = {
	273	.name = "reg-fixed-voltage",
	274	.id = 0,
	275	.dev = {
	276	.platform_data = &igep_vwlan,
	277	},
	278	};
	279
	280	static struct omap2_hsmmc_info mmc[] = {
	281	{
	282	.mmc = 1,
	283	.caps = MMC_CAP_4_BIT_DATA,
	284	.gpio_cd = -EINVAL,
	285	.gpio_wp = -EINVAL,
	286	.deferred = true,
	287	},
	288	#if defined(CONFIG_LIBERTAS_SDIO) \|\| defined(CONFIG_LIBERTAS_SDIO_MODULE)
	289	{
	290	.mmc = 2,
	291	.caps = MMC_CAP_4_BIT_DATA,
	292	.gpio_cd = -EINVAL,
	293	.gpio_wp = -EINVAL,
	294	},
	295	#endif
	296	{} /* Terminator */
	297	};
	298
	299	#if defined(CONFIG_LEDS_GPIO) \|\| defined(CONFIG_LEDS_GPIO_MODULE)
	300	#include <linux/leds.h>
	301
	302	static struct gpio_led igep_gpio_leds[] = {
	303	[0] = {
	304	.name = "omap3:red:user0",
	305	.default_state = 0,
	306	},
	307	[1] = {
	308	.name = "omap3:green:boot",
	309	.default_state = 1,
	310	},
	311	[2] = {
	312	.name = "omap3:red:user1",
	313	.default_state = 0,
	314	},
	315	[3] = {
	316	.name = "omap3:green:user1",
	317	.default_state = 0,
	318	.gpio = -EINVAL, /* gets replaced */
	319	.active_low = 1,
	320	},
	321	};
	322
	323	static struct gpio_led_platform_data igep_led_pdata = {
	324	.leds = igep_gpio_leds,
	325	.num_leds = ARRAY_SIZE(igep_gpio_leds),
	326	};
	327
	328	static struct platform_device igep_led_device = {
	329	.name = "leds-gpio",
	330	.id = -1,
	331	.dev = {
	332	.platform_data = &igep_led_pdata,
	333	},
	334	};
	335
	336	static void __init igep_leds_init(void)
	337	{
	338	if (machine_is_igep0020()) {
	339	igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
	340	igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
	341	igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
	342	} else {
	343	igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
	344	igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
	345	igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
	346	}
	347
	348	platform_device_register(&igep_led_device);
	349	}
	350
	351	#else
	352	static struct gpio igep_gpio_leds[] __initdata = {
	353	{ -EINVAL, GPIOF_OUT_INIT_LOW, "gpio-led:red:d0" },
	354	{ -EINVAL, GPIOF_OUT_INIT_LOW, "gpio-led:green:d0" },
	355	{ -EINVAL, GPIOF_OUT_INIT_LOW, "gpio-led:red:d1" },
	356	};
	357
	358	static inline void igep_leds_init(void)
	359	{
	360	int i;
	361
	362	if (machine_is_igep0020()) {
	363	igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
	364	igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
	365	igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
	366	} else {
	367	igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
	368	igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
	369	igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
	370	}
	371
	372	if (gpio_request_array(igep_gpio_leds, ARRAY_SIZE(igep_gpio_leds))) {
	373	pr_warning("IGEP v2: Could not obtain leds gpios\n");
	374	return;
	375	}
	376
	377	for (i = 0; i < ARRAY_SIZE(igep_gpio_leds); i++)
	378	gpio_export(igep_gpio_leds[i].gpio, 0);
	379	}
	380	#endif
	381
	382	static struct gpio igep2_twl_gpios[] = {
	383	{ -EINVAL, GPIOF_IN, "GPIO_EHCI_NOC" },
	384	{ -EINVAL, GPIOF_OUT_INIT_LOW, "GPIO_USBH_CPEN" },
	385	};
	386
	387	static int igep_twl_gpio_setup(struct device *dev,
	388	unsigned gpio, unsigned ngpio)
	389	{
	390	int ret;
	391
	392	/* gpio + 0 is "mmc0_cd" (input/IRQ) */
	393	mmc[0].gpio_cd = gpio + 0;
	394	omap_hsmmc_late_init(mmc);
	395
	396	/* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
	397	#if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
	398	ret = gpio_request_one(gpio + TWL4030_GPIO_MAX + 1, GPIOF_OUT_INIT_HIGH,
	399	"gpio-led:green:d1");
	400	if (ret == 0)
	401	gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
	402	else
	403	pr_warning("IGEP: Could not obtain gpio GPIO_LED1_GREEN\n");
	404	#else
	405	igep_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
	406	#endif
	407
	408	if (machine_is_igep0030())
	409	return 0;
	410
	411	/*
	412	* REVISIT: need ehci-omap hooks for external VBUS
	413	* power switch and overcurrent detect
	414	*/
	415	igep2_twl_gpios[0].gpio = gpio + 1;
	416
	417	/* TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN (out, active low) */
	418	igep2_twl_gpios[1].gpio = gpio + TWL4030_GPIO_MAX;
	419
	420	ret = gpio_request_array(igep2_twl_gpios, ARRAY_SIZE(igep2_twl_gpios));
	421	if (ret < 0)
	422	pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");
	423
	424	return 0;
	425	};
	426
	427	static struct twl4030_gpio_platform_data igep_twl4030_gpio_pdata = {
	428	.use_leds = true,
	429	.setup = igep_twl_gpio_setup,
	430	};
	431
	432	static struct tfp410_platform_data dvi_panel = {
	433	.i2c_bus_num = 3,
	434	.power_down_gpio = IGEP2_GPIO_DVI_PUP,
	435	};
	436
	437	static struct omap_dss_device igep2_dvi_device = {
	438	.type = OMAP_DISPLAY_TYPE_DPI,
	439	.name = "dvi",
	440	.driver_name = "tfp410",
	441	.data = &dvi_panel,
	442	.phy.dpi.data_lines = 24,
	443	};
	444
	445	static struct omap_dss_device *igep2_dss_devices[] = {
	446	&igep2_dvi_device
	447	};
	448
	449	static struct omap_dss_board_info igep2_dss_data = {
	450	.num_devices = ARRAY_SIZE(igep2_dss_devices),
	451	.devices = igep2_dss_devices,
	452	.default_device = &igep2_dvi_device,
	453	};
	454
	455	static struct platform_device *igep_devices[] __initdata = {
	456	&igep_vwlan_device,
	457	};
	458
	459	static int igep2_keymap[] = {
	460	KEY(0, 0, KEY_LEFT),
	461	KEY(0, 1, KEY_RIGHT),
	462	KEY(0, 2, KEY_A),
	463	KEY(0, 3, KEY_B),
	464	KEY(1, 0, KEY_DOWN),
	465	KEY(1, 1, KEY_UP),
	466	KEY(1, 2, KEY_E),
	467	KEY(1, 3, KEY_F),
	468	KEY(2, 0, KEY_ENTER),
	469	KEY(2, 1, KEY_I),
	470	KEY(2, 2, KEY_J),
	471	KEY(2, 3, KEY_K),
	472	KEY(3, 0, KEY_M),
	473	KEY(3, 1, KEY_N),
	474	KEY(3, 2, KEY_O),
	475	KEY(3, 3, KEY_P)
	476	};
	477
	478	static struct matrix_keymap_data igep2_keymap_data = {
	479	.keymap = igep2_keymap,
	480	.keymap_size = ARRAY_SIZE(igep2_keymap),
	481	};
	482
	483	static struct twl4030_keypad_data igep2_keypad_pdata = {
	484	.keymap_data = &igep2_keymap_data,
	485	.rows = 4,
	486	.cols = 4,
	487	.rep = 1,
	488	};
	489
	490	static struct twl4030_platform_data igep_twldata = {
	491	/* platform_data for children goes here */
	492	.gpio = &igep_twl4030_gpio_pdata,
	493	.vmmc1 = &igep_vmmc1,
	494	.vio = &igep_vio,
	495	};
	496
	497	static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
	498	{
	499	I2C_BOARD_INFO("eeprom", 0x50),
	500	},
	501	};
	502
	503	static void __init igep_i2c_init(void)
	504	{
	505	int ret;
	506
	507	omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_USB,
	508	TWL_COMMON_REGULATOR_VPLL2);
	509	igep_twldata.vpll2->constraints.apply_uV = true;
	510	igep_twldata.vpll2->constraints.name = "VDVI";
	511
	512	if (machine_is_igep0020()) {
	513	/*
	514	* Bus 3 is attached to the DVI port where devices like the
	515	* pico DLP projector don't work reliably with 400kHz
	516	*/
	517	ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
	518	ARRAY_SIZE(igep2_i2c3_boardinfo));
	519	if (ret)
	520	pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
	521
	522	igep_twldata.keypad = &igep2_keypad_pdata;
	523	/* Get common pmic data */
	524	omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_AUDIO, 0);
	525	}
	526
	527	omap3_pmic_init("twl4030", &igep_twldata);
	528	}
	529
	530	static struct usbhs_omap_platform_data igep2_usbhs_bdata __initdata = {
	531	.port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
	532	.port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
	533	.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
	534
	535	.phy_reset = true,
	536	.reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
	537	.reset_gpio_port[1] = -EINVAL,
	538	.reset_gpio_port[2] = -EINVAL,
	539	};
	540
	541	static struct usbhs_omap_platform_data igep3_usbhs_bdata __initdata = {
	542	.port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
	543	.port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
	544	.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
	545
	546	.phy_reset = true,
	547	.reset_gpio_port[0] = -EINVAL,
	548	.reset_gpio_port[1] = IGEP3_GPIO_USBH_NRESET,
	549	.reset_gpio_port[2] = -EINVAL,
	550	};
	551
	552	#ifdef CONFIG_OMAP_MUX
	553	static struct omap_board_mux board_mux[] __initdata = {
	554	/* SMSC9221 LAN Controller ETH IRQ (GPIO_176) */
	555	OMAP3_MUX(MCSPI1_CS2, OMAP_MUX_MODE4 \| OMAP_PIN_INPUT),
	556	{ .reg_offset = OMAP_MUX_TERMINATOR },
	557	};
	558	#endif
	559
	560	#if defined(CONFIG_LIBERTAS_SDIO) \|\| defined(CONFIG_LIBERTAS_SDIO_MODULE)
	561	static struct gpio igep_wlan_bt_gpios[] __initdata = {
	562	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NPD" },
	563	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NRESET" },
	564	{ -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_BT_NRESET" },
	565	};
	566
	567	static void __init igep_wlan_bt_init(void)
	568	{
	569	int err;
	570
	571	/* GPIO's for WLAN-BT combo depends on hardware revision */
	572	if (hwrev == IGEP2_BOARD_HWREV_B) {
	573	igep_wlan_bt_gpios[0].gpio = IGEP2_RB_GPIO_WIFI_NPD;
	574	igep_wlan_bt_gpios[1].gpio = IGEP2_RB_GPIO_WIFI_NRESET;
	575	igep_wlan_bt_gpios[2].gpio = IGEP2_RB_GPIO_BT_NRESET;
	576	} else if (hwrev == IGEP2_BOARD_HWREV_C \|\| machine_is_igep0030()) {
	577	igep_wlan_bt_gpios[0].gpio = IGEP2_RC_GPIO_WIFI_NPD;
	578	igep_wlan_bt_gpios[1].gpio = IGEP2_RC_GPIO_WIFI_NRESET;
	579	igep_wlan_bt_gpios[2].gpio = IGEP2_RC_GPIO_BT_NRESET;
	580	} else
	581	return;
	582
	583	/* Make sure that the GPIO pins are muxed correctly */
	584	omap_mux_init_gpio(igep_wlan_bt_gpios[0].gpio, OMAP_PIN_OUTPUT);
	585	omap_mux_init_gpio(igep_wlan_bt_gpios[1].gpio, OMAP_PIN_OUTPUT);
	586	omap_mux_init_gpio(igep_wlan_bt_gpios[2].gpio, OMAP_PIN_OUTPUT);
	587
	588	err = gpio_request_array(igep_wlan_bt_gpios,
	589	ARRAY_SIZE(igep_wlan_bt_gpios));
	590	if (err) {
	591	pr_warning("IGEP2: Could not obtain WIFI/BT gpios\n");
	592	return;
	593	}
	594
	595	gpio_export(igep_wlan_bt_gpios[0].gpio, 0);
	596	gpio_export(igep_wlan_bt_gpios[1].gpio, 0);
	597	gpio_export(igep_wlan_bt_gpios[2].gpio, 0);
	598
	599	gpio_set_value(igep_wlan_bt_gpios[1].gpio, 0);
	600	udelay(10);
	601	gpio_set_value(igep_wlan_bt_gpios[1].gpio, 1);
	602
	603	}
	604	#else
	605	static inline void __init igep_wlan_bt_init(void) { }
	606	#endif
	607
	608	static struct regulator_consumer_supply dummy_supplies[] = {
	609	REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
	610	REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
	611	};
	612
	613	static void __init igep_init(void)
	614	{
	615	regulator_register_fixed(1, dummy_supplies, ARRAY_SIZE(dummy_supplies));
	616	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
	617
	618	/* Get IGEP2 hardware revision */
	619	igep2_get_revision();
	620
	621	omap_hsmmc_init(mmc);
	622
	623	/* Register I2C busses and drivers */
	624	igep_i2c_init();
	625	platform_add_devices(igep_devices, ARRAY_SIZE(igep_devices));
	626	omap_serial_init();
	627	omap_sdrc_init(m65kxxxxam_sdrc_params,
	628	m65kxxxxam_sdrc_params);
	629	usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
	630	usb_musb_init(NULL);
	631
	632	igep_flash_init();
	633	igep_leds_init();
	634	omap_twl4030_audio_init("igep2", NULL);
	635
	636	/*
	637	* WLAN-BT combo module from MuRata which has a Marvell WLAN
	638	* (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
	639	*/
	640	igep_wlan_bt_init();
	641
	642	if (machine_is_igep0020()) {
	643	omap_display_init(&igep2_dss_data);
	644	igep2_init_smsc911x();
	645	usbhs_init(&igep2_usbhs_bdata);
	646	} else {
	647	usbhs_init(&igep3_usbhs_bdata);
	648	}
	649	}
	650
	651	MACHINE_START(IGEP0020, "IGEP v2 board")
	652	.atag_offset = 0x100,
	653	.reserve = omap_reserve,
	654	.map_io = omap3_map_io,
	655	.init_early = omap35xx_init_early,
	656	.init_irq = omap3_init_irq,
	657	.handle_irq = omap3_intc_handle_irq,
	658	.init_machine = igep_init,
	659	.init_late = omap35xx_init_late,
	660	.init_time = omap3_sync32k_timer_init,
	661	.restart = omap3xxx_restart,
	662	MACHINE_END
	663
	664	MACHINE_START(IGEP0030, "IGEP OMAP3 module")
	665	.atag_offset = 0x100,
	666	.reserve = omap_reserve,
	667	.map_io = omap3_map_io,
	668	.init_early = omap35xx_init_early,
	669	.init_irq = omap3_init_irq,
	670	.handle_irq = omap3_intc_handle_irq,
	671	.init_machine = igep_init,
	672	.init_late = omap35xx_init_late,
	673	.init_time = omap3_sync32k_timer_init,
	674	.restart = omap3xxx_restart,
	675	MACHINE_END