arch/arm/mach-omap2/board-overo.c - maze/linux - Git at Google

 /*
  * board-overo.c (Gumstix Overo)
  *
  * Initial code: Steve Sakoman <steve@sakoman.com>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA
  *
  */

 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/i2c/twl4030.h>

 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>

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

 #include <mach/board.h>
 #include <mach/common.h>
 #include <mach/gpio.h>
 #include <mach/gpmc.h>
 #include <mach/hardware.h>
 #include <mach/nand.h>
 #include <mach/usb.h>

 #include "mmc-twl4030.h"

 #define OVERO_GPIO_BT_XGATE	15
 #define OVERO_GPIO_W2W_NRESET	16
 #define OVERO_GPIO_BT_NRESET	164
 #define OVERO_GPIO_USBH_CPEN	168
 #define OVERO_GPIO_USBH_NRESET	183

 #define NAND_BLOCK_SIZE SZ_128K
 #define GPMC_CS0_BASE  0x60
 #define GPMC_CS_SIZE   0x30

 #if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
 	defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)

 #include <mach/mcspi.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>

 static struct omap2_mcspi_device_config ads7846_mcspi_config = {
 	.turbo_mode	= 0,
 	.single_channel	= 1,	/* 0: slave, 1: master */
 };

 static int ads7846_get_pendown_state(void)
 {
 	return !gpio_get_value(OVERO_GPIO_PENDOWN);
 }

 static struct ads7846_platform_data ads7846_config = {
 	.x_max			= 0x0fff,
 	.y_max			= 0x0fff,
 	.x_plate_ohms		= 180,
 	.pressure_max		= 255,
 	.debounce_max		= 10,
 	.debounce_tol		= 3,
 	.debounce_rep		= 1,
 	.get_pendown_state	= ads7846_get_pendown_state,
 	.keep_vref_on		= 1,
 };

 static struct spi_board_info overo_spi_board_info[] __initdata = {
 	{
 		.modalias		= "ads7846",
 		.bus_num		= 1,
 		.chip_select		= 0,
 		.max_speed_hz		= 1500000,
 		.controller_data	= &ads7846_mcspi_config,
 		.irq			= OMAP_GPIO_IRQ(OVERO_GPIO_PENDOWN),
 		.platform_data		= &ads7846_config,
 	}
 };

 static void __init overo_ads7846_init(void)
 {
 	if ((gpio_request(OVERO_GPIO_PENDOWN, "ADS7846_PENDOWN") == 0) &&
 	    (gpio_direction_input(OVERO_GPIO_PENDOWN) == 0)) {
 		gpio_export(OVERO_GPIO_PENDOWN, 0);
 	} else {
 		printk(KERN_ERR "could not obtain gpio for ADS7846_PENDOWN\n");
 		return;
 	}

 	spi_register_board_info(overo_spi_board_info,
 			ARRAY_SIZE(overo_spi_board_info));
 }

 #else
 static inline void __init overo_ads7846_init(void) { return; }
 #endif

 static struct mtd_partition overo_nand_partitions[] = {
 	{
 		.name           = "xloader",
 		.offset         = 0,			/* Offset = 0x00000 */
 		.size           = 4 * NAND_BLOCK_SIZE,
 		.mask_flags     = MTD_WRITEABLE
 	},
 	{
 		.name           = "uboot",
 		.offset         = MTDPART_OFS_APPEND,	/* Offset = 0x80000 */
 		.size           = 14 * NAND_BLOCK_SIZE,
 	},
 	{
 		.name           = "uboot environment",
 		.offset         = MTDPART_OFS_APPEND,	/* Offset = 0x240000 */
 		.size           = 2 * NAND_BLOCK_SIZE,
 	},
 	{
 		.name           = "linux",
 		.offset         = MTDPART_OFS_APPEND,	/* Offset = 0x280000 */
 		.size           = 32 * NAND_BLOCK_SIZE,
 	},
 	{
 		.name           = "rootfs",
 		.offset         = MTDPART_OFS_APPEND,	/* Offset = 0x680000 */
 		.size           = MTDPART_SIZ_FULL,
 	},
 };

 static struct omap_nand_platform_data overo_nand_data = {
 	.parts = overo_nand_partitions,
 	.nr_parts = ARRAY_SIZE(overo_nand_partitions),
 	.dma_channel = -1,	/* disable DMA in OMAP NAND driver */
 };

 static struct resource overo_nand_resource = {
 	.flags		= IORESOURCE_MEM,
 };

 static struct platform_device overo_nand_device = {
 	.name		= "omap2-nand",
 	.id		= -1,
 	.dev		= {
 		.platform_data	= &overo_nand_data,
 	},
 	.num_resources	= 1,
 	.resource	= &overo_nand_resource,
 };


 static void __init overo_flash_init(void)
 {
 	u8 cs = 0;
 	u8 nandcs = GPMC_CS_NUM + 1;

 	u32 gpmc_base_add = OMAP34XX_GPMC_VIRT;

 	/* find out the chip-select on which NAND exists */
 	while (cs < GPMC_CS_NUM) {
 		u32 ret = 0;
 		ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);

 		if ((ret & 0xC00) == 0x800) {
 			printk(KERN_INFO "Found NAND on CS%d\n", cs);
 			if (nandcs > GPMC_CS_NUM)
 				nandcs = cs;
 		}
 		cs++;
 	}

 	if (nandcs > GPMC_CS_NUM) {
 		printk(KERN_INFO "NAND: Unable to find configuration "
 				 "in GPMC\n ");
 		return;
 	}

 	if (nandcs < GPMC_CS_NUM) {
 		overo_nand_data.cs = nandcs;
 		overo_nand_data.gpmc_cs_baseaddr = (void *)
 			(gpmc_base_add + GPMC_CS0_BASE + nandcs * GPMC_CS_SIZE);
 		overo_nand_data.gpmc_baseaddr = (void *) (gpmc_base_add);

 		printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
 		if (platform_device_register(&overo_nand_device) < 0)
 			printk(KERN_ERR "Unable to register NAND device\n");
 	}
 }
 static struct omap_uart_config overo_uart_config __initdata = {
 	.enabled_uarts	= ((1 << 0) | (1 << 1) | (1 << 2)),
 };

 static struct twl4030_gpio_platform_data overo_gpio_data = {
 	.gpio_base	= OMAP_MAX_GPIO_LINES,
 	.irq_base	= TWL4030_GPIO_IRQ_BASE,
 	.irq_end	= TWL4030_GPIO_IRQ_END,
 };

 static struct twl4030_platform_data overo_twldata = {
 	.irq_base	= TWL4030_IRQ_BASE,
 	.irq_end	= TWL4030_IRQ_END,
 	.gpio		= &overo_gpio_data,
 };

 static struct i2c_board_info __initdata overo_i2c_boardinfo[] = {
 	{
 		I2C_BOARD_INFO("twl4030", 0x48),
 		.flags = I2C_CLIENT_WAKE,
 		.irq = INT_34XX_SYS_NIRQ,
 		.platform_data = &overo_twldata,
 	},
 };

 static int __init overo_i2c_init(void)
 {
 	omap_register_i2c_bus(1, 2600, overo_i2c_boardinfo,
 			ARRAY_SIZE(overo_i2c_boardinfo));
 	/* i2c2 pins are used for gpio */
 	omap_register_i2c_bus(3, 400, NULL, 0);
 	return 0;
 }

 static void __init overo_init_irq(void)
 {
 	omap2_init_common_hw(NULL);
 	omap_init_irq();
 	omap_gpio_init();
 }

 static struct platform_device overo_lcd_device = {
 	.name		= "overo_lcd",
 	.id		= -1,
 };

 static struct omap_lcd_config overo_lcd_config __initdata = {
 	.ctrl_name	= "internal",
 };

 static struct omap_board_config_kernel overo_config[] __initdata = {
 	{ OMAP_TAG_UART,	&overo_uart_config },
 	{ OMAP_TAG_LCD,		&overo_lcd_config },
 };

 static struct platform_device *overo_devices[] __initdata = {
 	&overo_lcd_device,
 };

 static struct twl4030_hsmmc_info mmc[] __initdata = {
 	{
 		.mmc		= 1,
 		.wires		= 4,
 		.gpio_cd	= -EINVAL,
 		.gpio_wp	= -EINVAL,
 	},
 	{
 		.mmc		= 2,
 		.wires		= 4,
 		.gpio_cd	= -EINVAL,
 		.gpio_wp	= -EINVAL,
 		.transceiver	= true,
 	},
 	{}	/* Terminator */
 };

 static void __init overo_init(void)
 {
 	overo_i2c_init();
 	platform_add_devices(overo_devices, ARRAY_SIZE(overo_devices));
 	omap_board_config = overo_config;
 	omap_board_config_size = ARRAY_SIZE(overo_config);
 	omap_serial_init();
 	twl4030_mmc_init(mmc);
 	overo_flash_init();
 	usb_musb_init();
 	overo_ads7846_init();

 	if ((gpio_request(OVERO_GPIO_W2W_NRESET,
 			  "OVERO_GPIO_W2W_NRESET") == 0) &&
 	    (gpio_direction_output(OVERO_GPIO_W2W_NRESET, 1) == 0)) {
 		gpio_export(OVERO_GPIO_W2W_NRESET, 0);
 		gpio_set_value(OVERO_GPIO_W2W_NRESET, 0);
 		udelay(10);
 		gpio_set_value(OVERO_GPIO_W2W_NRESET, 1);
 	} else {
 		printk(KERN_ERR "could not obtain gpio for "
 					"OVERO_GPIO_W2W_NRESET\n");
 	}

 	if ((gpio_request(OVERO_GPIO_BT_XGATE, "OVERO_GPIO_BT_XGATE") == 0) &&
 	    (gpio_direction_output(OVERO_GPIO_BT_XGATE, 0) == 0))
 		gpio_export(OVERO_GPIO_BT_XGATE, 0);
 	else
 		printk(KERN_ERR "could not obtain gpio for OVERO_GPIO_BT_XGATE\n");

 	if ((gpio_request(OVERO_GPIO_BT_NRESET, "OVERO_GPIO_BT_NRESET") == 0) &&
 	    (gpio_direction_output(OVERO_GPIO_BT_NRESET, 1) == 0)) {
 		gpio_export(OVERO_GPIO_BT_NRESET, 0);
 		gpio_set_value(OVERO_GPIO_BT_NRESET, 0);
 		mdelay(6);
 		gpio_set_value(OVERO_GPIO_BT_NRESET, 1);
 	} else {
 		printk(KERN_ERR "could not obtain gpio for "
 					"OVERO_GPIO_BT_NRESET\n");
 	}

 	if ((gpio_request(OVERO_GPIO_USBH_CPEN, "OVERO_GPIO_USBH_CPEN") == 0) &&
 	    (gpio_direction_output(OVERO_GPIO_USBH_CPEN, 1) == 0))
 		gpio_export(OVERO_GPIO_USBH_CPEN, 0);
 	else
 		printk(KERN_ERR "could not obtain gpio for "
 					"OVERO_GPIO_USBH_CPEN\n");

 	if ((gpio_request(OVERO_GPIO_USBH_NRESET,
 			  "OVERO_GPIO_USBH_NRESET") == 0) &&
 	    (gpio_direction_output(OVERO_GPIO_USBH_NRESET, 1) == 0))
 		gpio_export(OVERO_GPIO_USBH_NRESET, 0);
 	else
 		printk(KERN_ERR "could not obtain gpio for "
 					"OVERO_GPIO_USBH_NRESET\n");
 }

 static void __init overo_map_io(void)
 {
 	omap2_set_globals_343x();
 	omap2_map_common_io();
 }

 MACHINE_START(OVERO, "Gumstix Overo")
 	.phys_io	= 0x48000000,
 	.io_pg_offst	= ((0xd8000000) >> 18) & 0xfffc,
 	.boot_params	= 0x80000100,
 	.map_io		= overo_map_io,
 	.init_irq	= overo_init_irq,
 	.init_machine	= overo_init,
 	.timer		= &omap_timer,
 MACHINE_END
	/*
	* board-overo.c (Gumstix Overo)
	*
	* Initial code: Steve Sakoman <steve@sakoman.com>
	*
	* 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.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	* 02110-1301 USA
	*
	*/

	#include <linux/clk.h>
	#include <linux/delay.h>
	#include <linux/err.h>
	#include <linux/init.h>
	#include <linux/io.h>
	#include <linux/kernel.h>
	#include <linux/platform_device.h>
	#include <linux/i2c/twl4030.h>

	#include <linux/mtd/mtd.h>
	#include <linux/mtd/nand.h>
	#include <linux/mtd/partitions.h>

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

	#include <mach/board.h>
	#include <mach/common.h>
	#include <mach/gpio.h>
	#include <mach/gpmc.h>
	#include <mach/hardware.h>
	#include <mach/nand.h>
	#include <mach/usb.h>

	#include "mmc-twl4030.h"

	#define OVERO_GPIO_BT_XGATE 15
	#define OVERO_GPIO_W2W_NRESET 16
	#define OVERO_GPIO_BT_NRESET 164
	#define OVERO_GPIO_USBH_CPEN 168
	#define OVERO_GPIO_USBH_NRESET 183

	#define NAND_BLOCK_SIZE SZ_128K
	#define GPMC_CS0_BASE 0x60
	#define GPMC_CS_SIZE 0x30

	#if defined(CONFIG_TOUCHSCREEN_ADS7846) \|\| \
	defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)

	#include <mach/mcspi.h>
	#include <linux/spi/spi.h>
	#include <linux/spi/ads7846.h>

	static struct omap2_mcspi_device_config ads7846_mcspi_config = {
	.turbo_mode = 0,
	.single_channel = 1, /* 0: slave, 1: master */
	};

	static int ads7846_get_pendown_state(void)
	{
	return !gpio_get_value(OVERO_GPIO_PENDOWN);
	}

	static struct ads7846_platform_data ads7846_config = {
	.x_max = 0x0fff,
	.y_max = 0x0fff,
	.x_plate_ohms = 180,
	.pressure_max = 255,
	.debounce_max = 10,
	.debounce_tol = 3,
	.debounce_rep = 1,
	.get_pendown_state = ads7846_get_pendown_state,
	.keep_vref_on = 1,
	};

	static struct spi_board_info overo_spi_board_info[] __initdata = {
	{
	.modalias = "ads7846",
	.bus_num = 1,
	.chip_select = 0,
	.max_speed_hz = 1500000,
	.controller_data = &ads7846_mcspi_config,
	.irq = OMAP_GPIO_IRQ(OVERO_GPIO_PENDOWN),
	.platform_data = &ads7846_config,
	}
	};

	static void __init overo_ads7846_init(void)
	{
	if ((gpio_request(OVERO_GPIO_PENDOWN, "ADS7846_PENDOWN") == 0) &&
	(gpio_direction_input(OVERO_GPIO_PENDOWN) == 0)) {
	gpio_export(OVERO_GPIO_PENDOWN, 0);
	} else {
	printk(KERN_ERR "could not obtain gpio for ADS7846_PENDOWN\n");
	return;
	}

	spi_register_board_info(overo_spi_board_info,
	ARRAY_SIZE(overo_spi_board_info));
	}

	#else
	static inline void __init overo_ads7846_init(void) { return; }
	#endif

	static struct mtd_partition overo_nand_partitions[] = {
	{
	.name = "xloader",
	.offset = 0, /* Offset = 0x00000 */
	.size = 4 * NAND_BLOCK_SIZE,
	.mask_flags = MTD_WRITEABLE
	},
	{
	.name = "uboot",
	.offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */
	.size = 14 * NAND_BLOCK_SIZE,
	},
	{
	.name = "uboot environment",
	.offset = MTDPART_OFS_APPEND, /* Offset = 0x240000 */
	.size = 2 * NAND_BLOCK_SIZE,
	},
	{
	.name = "linux",
	.offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */
	.size = 32 * NAND_BLOCK_SIZE,
	},
	{
	.name = "rootfs",
	.offset = MTDPART_OFS_APPEND, /* Offset = 0x680000 */
	.size = MTDPART_SIZ_FULL,
	},
	};

	static struct omap_nand_platform_data overo_nand_data = {
	.parts = overo_nand_partitions,
	.nr_parts = ARRAY_SIZE(overo_nand_partitions),
	.dma_channel = -1, /* disable DMA in OMAP NAND driver */
	};

	static struct resource overo_nand_resource = {
	.flags = IORESOURCE_MEM,
	};

	static struct platform_device overo_nand_device = {
	.name = "omap2-nand",
	.id = -1,
	.dev = {
	.platform_data = &overo_nand_data,
	},
	.num_resources = 1,
	.resource = &overo_nand_resource,
	};


	static void __init overo_flash_init(void)
	{
	u8 cs = 0;
	u8 nandcs = GPMC_CS_NUM + 1;

	u32 gpmc_base_add = OMAP34XX_GPMC_VIRT;

	/* find out the chip-select on which NAND exists */
	while (cs < GPMC_CS_NUM) {
	u32 ret = 0;
	ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);

	if ((ret & 0xC00) == 0x800) {
	printk(KERN_INFO "Found NAND on CS%d\n", cs);
	if (nandcs > GPMC_CS_NUM)
	nandcs = cs;
	}
	cs++;
	}

	if (nandcs > GPMC_CS_NUM) {
	printk(KERN_INFO "NAND: Unable to find configuration "
	"in GPMC\n ");
	return;
	}

	if (nandcs < GPMC_CS_NUM) {
	overo_nand_data.cs = nandcs;
	overo_nand_data.gpmc_cs_baseaddr = (void *)
	(gpmc_base_add + GPMC_CS0_BASE + nandcs * GPMC_CS_SIZE);
	overo_nand_data.gpmc_baseaddr = (void *) (gpmc_base_add);

	printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
	if (platform_device_register(&overo_nand_device) < 0)
	printk(KERN_ERR "Unable to register NAND device\n");
	}
	}
	static struct omap_uart_config overo_uart_config __initdata = {
	.enabled_uarts = ((1 << 0) \| (1 << 1) \| (1 << 2)),
	};

	static struct twl4030_gpio_platform_data overo_gpio_data = {
	.gpio_base = OMAP_MAX_GPIO_LINES,
	.irq_base = TWL4030_GPIO_IRQ_BASE,
	.irq_end = TWL4030_GPIO_IRQ_END,
	};

	static struct twl4030_platform_data overo_twldata = {
	.irq_base = TWL4030_IRQ_BASE,
	.irq_end = TWL4030_IRQ_END,
	.gpio = &overo_gpio_data,
	};

	static struct i2c_board_info __initdata overo_i2c_boardinfo[] = {
	{
	I2C_BOARD_INFO("twl4030", 0x48),
	.flags = I2C_CLIENT_WAKE,
	.irq = INT_34XX_SYS_NIRQ,
	.platform_data = &overo_twldata,
	},
	};

	static int __init overo_i2c_init(void)
	{
	omap_register_i2c_bus(1, 2600, overo_i2c_boardinfo,
	ARRAY_SIZE(overo_i2c_boardinfo));
	/* i2c2 pins are used for gpio */
	omap_register_i2c_bus(3, 400, NULL, 0);
	return 0;
	}

	static void __init overo_init_irq(void)
	{
	omap2_init_common_hw(NULL);
	omap_init_irq();
	omap_gpio_init();
	}

	static struct platform_device overo_lcd_device = {
	.name = "overo_lcd",
	.id = -1,
	};

	static struct omap_lcd_config overo_lcd_config __initdata = {
	.ctrl_name = "internal",
	};

	static struct omap_board_config_kernel overo_config[] __initdata = {
	{ OMAP_TAG_UART, &overo_uart_config },
	{ OMAP_TAG_LCD, &overo_lcd_config },
	};

	static struct platform_device *overo_devices[] __initdata = {
	&overo_lcd_device,
	};

	static struct twl4030_hsmmc_info mmc[] __initdata = {
	{
	.mmc = 1,
	.wires = 4,
	.gpio_cd = -EINVAL,
	.gpio_wp = -EINVAL,
	},
	{
	.mmc = 2,
	.wires = 4,
	.gpio_cd = -EINVAL,
	.gpio_wp = -EINVAL,
	.transceiver = true,
	},
	{} /* Terminator */
	};

	static void __init overo_init(void)
	{
	overo_i2c_init();
	platform_add_devices(overo_devices, ARRAY_SIZE(overo_devices));
	omap_board_config = overo_config;
	omap_board_config_size = ARRAY_SIZE(overo_config);
	omap_serial_init();
	twl4030_mmc_init(mmc);
	overo_flash_init();
	usb_musb_init();
	overo_ads7846_init();

	if ((gpio_request(OVERO_GPIO_W2W_NRESET,
	"OVERO_GPIO_W2W_NRESET") == 0) &&
	(gpio_direction_output(OVERO_GPIO_W2W_NRESET, 1) == 0)) {
	gpio_export(OVERO_GPIO_W2W_NRESET, 0);
	gpio_set_value(OVERO_GPIO_W2W_NRESET, 0);
	udelay(10);
	gpio_set_value(OVERO_GPIO_W2W_NRESET, 1);
	} else {
	printk(KERN_ERR "could not obtain gpio for "
	"OVERO_GPIO_W2W_NRESET\n");
	}

	if ((gpio_request(OVERO_GPIO_BT_XGATE, "OVERO_GPIO_BT_XGATE") == 0) &&
	(gpio_direction_output(OVERO_GPIO_BT_XGATE, 0) == 0))
	gpio_export(OVERO_GPIO_BT_XGATE, 0);
	else
	printk(KERN_ERR "could not obtain gpio for OVERO_GPIO_BT_XGATE\n");

	if ((gpio_request(OVERO_GPIO_BT_NRESET, "OVERO_GPIO_BT_NRESET") == 0) &&
	(gpio_direction_output(OVERO_GPIO_BT_NRESET, 1) == 0)) {
	gpio_export(OVERO_GPIO_BT_NRESET, 0);
	gpio_set_value(OVERO_GPIO_BT_NRESET, 0);
	mdelay(6);
	gpio_set_value(OVERO_GPIO_BT_NRESET, 1);
	} else {
	printk(KERN_ERR "could not obtain gpio for "
	"OVERO_GPIO_BT_NRESET\n");
	}

	if ((gpio_request(OVERO_GPIO_USBH_CPEN, "OVERO_GPIO_USBH_CPEN") == 0) &&
	(gpio_direction_output(OVERO_GPIO_USBH_CPEN, 1) == 0))
	gpio_export(OVERO_GPIO_USBH_CPEN, 0);
	else
	printk(KERN_ERR "could not obtain gpio for "
	"OVERO_GPIO_USBH_CPEN\n");

	if ((gpio_request(OVERO_GPIO_USBH_NRESET,
	"OVERO_GPIO_USBH_NRESET") == 0) &&
	(gpio_direction_output(OVERO_GPIO_USBH_NRESET, 1) == 0))
	gpio_export(OVERO_GPIO_USBH_NRESET, 0);
	else
	printk(KERN_ERR "could not obtain gpio for "
	"OVERO_GPIO_USBH_NRESET\n");
	}

	static void __init overo_map_io(void)
	{
	omap2_set_globals_343x();
	omap2_map_common_io();
	}

	MACHINE_START(OVERO, "Gumstix Overo")
	.phys_io = 0x48000000,
	.io_pg_offst = ((0xd8000000) >> 18) & 0xfffc,
	.boot_params = 0x80000100,
	.map_io = overo_map_io,
	.init_irq = overo_init_irq,
	.init_machine = overo_init,
	.timer = &omap_timer,
	MACHINE_END