2008-10-09 08:51:43 -06:00
|
|
|
/*
|
|
|
|
* 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>
|
2011-05-31 06:55:44 -06:00
|
|
|
#include <linux/gpio.h>
|
2008-10-09 08:51:43 -06:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/platform_device.h>
|
2009-12-13 12:05:51 -07:00
|
|
|
#include <linux/i2c/twl.h>
|
2009-05-28 15:04:03 -06:00
|
|
|
#include <linux/regulator/machine.h>
|
2011-03-05 09:12:26 -07:00
|
|
|
#include <linux/regulator/fixed.h>
|
2011-03-05 06:58:39 -07:00
|
|
|
#include <linux/spi/spi.h>
|
2008-10-09 08:51:43 -06:00
|
|
|
|
|
|
|
#include <linux/mtd/mtd.h>
|
|
|
|
#include <linux/mtd/nand.h>
|
|
|
|
#include <linux/mtd/partitions.h>
|
2010-09-15 08:49:23 -06:00
|
|
|
#include <linux/mmc/host.h>
|
2008-10-09 08:51:43 -06:00
|
|
|
|
|
|
|
#include <asm/mach-types.h>
|
|
|
|
#include <asm/mach/arch.h>
|
|
|
|
#include <asm/mach/flash.h>
|
|
|
|
#include <asm/mach/map.h>
|
|
|
|
|
2009-10-20 10:40:47 -06:00
|
|
|
#include <plat/board.h>
|
|
|
|
#include <plat/common.h>
|
2011-05-11 05:05:07 -06:00
|
|
|
#include <video/omapdss.h>
|
2011-05-10 10:48:10 -06:00
|
|
|
#include <video/omap-panel-generic-dpi.h>
|
2009-10-20 10:40:47 -06:00
|
|
|
#include <plat/gpmc.h>
|
2008-10-09 08:51:43 -06:00
|
|
|
#include <mach/hardware.h>
|
2009-10-20 10:40:47 -06:00
|
|
|
#include <plat/nand.h>
|
2011-03-05 06:58:39 -07:00
|
|
|
#include <plat/mcspi.h>
|
|
|
|
#include <plat/mux.h>
|
2009-10-20 10:40:47 -06:00
|
|
|
#include <plat/usb.h>
|
2008-10-09 08:51:43 -06:00
|
|
|
|
2009-12-11 17:16:32 -07:00
|
|
|
#include "mux.h"
|
2009-05-28 15:03:59 -06:00
|
|
|
#include "sdram-micron-mt46h32m32lf-6.h"
|
2010-02-15 11:03:34 -07:00
|
|
|
#include "hsmmc.h"
|
2011-04-24 16:09:05 -06:00
|
|
|
#include "common-board-devices.h"
|
2008-12-10 18:37:17 -07:00
|
|
|
|
2009-03-23 19:07:38 -06:00
|
|
|
#define OVERO_GPIO_BT_XGATE 15
|
|
|
|
#define OVERO_GPIO_W2W_NRESET 16
|
2009-07-20 10:09:23 -06:00
|
|
|
#define OVERO_GPIO_PENDOWN 114
|
2009-03-23 19:07:38 -06:00
|
|
|
#define OVERO_GPIO_BT_NRESET 164
|
|
|
|
#define OVERO_GPIO_USBH_CPEN 168
|
|
|
|
#define OVERO_GPIO_USBH_NRESET 183
|
|
|
|
|
2009-02-01 23:27:49 -07:00
|
|
|
#define OVERO_SMSC911X_CS 5
|
|
|
|
#define OVERO_SMSC911X_GPIO 176
|
2010-05-10 15:29:18 -06:00
|
|
|
#define OVERO_SMSC911X2_CS 4
|
|
|
|
#define OVERO_SMSC911X2_GPIO 65
|
2009-02-01 23:27:49 -07:00
|
|
|
|
2009-03-23 19:38:16 -06:00
|
|
|
#if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
|
|
|
|
defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
|
|
|
|
|
2011-03-05 09:12:26 -07:00
|
|
|
/* fixed regulator for ads7846 */
|
|
|
|
static struct regulator_consumer_supply ads7846_supply =
|
|
|
|
REGULATOR_SUPPLY("vcc", "spi1.0");
|
|
|
|
|
|
|
|
static struct regulator_init_data vads7846_regulator = {
|
|
|
|
.constraints = {
|
|
|
|
.valid_ops_mask = REGULATOR_CHANGE_STATUS,
|
|
|
|
},
|
|
|
|
.num_consumer_supplies = 1,
|
|
|
|
.consumer_supplies = &ads7846_supply,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct fixed_voltage_config vads7846 = {
|
|
|
|
.supply_name = "vads7846",
|
|
|
|
.microvolts = 3300000, /* 3.3V */
|
|
|
|
.gpio = -EINVAL,
|
|
|
|
.startup_delay = 0,
|
|
|
|
.init_data = &vads7846_regulator,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device vads7846_device = {
|
|
|
|
.name = "reg-fixed-voltage",
|
|
|
|
.id = 1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &vads7846,
|
|
|
|
},
|
2009-03-23 19:38:16 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static void __init overo_ads7846_init(void)
|
|
|
|
{
|
2011-04-24 16:09:05 -06:00
|
|
|
omap_ads7846_init(1, OVERO_GPIO_PENDOWN, 0, NULL);
|
2011-03-05 09:12:26 -07:00
|
|
|
platform_device_register(&vads7846_device);
|
2009-03-23 19:38:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
static inline void __init overo_ads7846_init(void) { return; }
|
|
|
|
#endif
|
|
|
|
|
2009-02-01 23:27:49 -07:00
|
|
|
#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
|
|
|
|
|
|
|
|
#include <linux/smsc911x.h>
|
2011-04-16 16:29:30 -06:00
|
|
|
#include <plat/gpmc-smsc911x.h>
|
2009-02-01 23:27:49 -07:00
|
|
|
|
2011-04-16 16:29:30 -06:00
|
|
|
static struct omap_smsc911x_platform_data smsc911x_cfg = {
|
2010-05-10 15:29:18 -06:00
|
|
|
.id = 0,
|
2011-04-16 16:29:30 -06:00
|
|
|
.cs = OVERO_SMSC911X_CS,
|
|
|
|
.gpio_irq = OVERO_SMSC911X_GPIO,
|
|
|
|
.gpio_reset = -EINVAL,
|
|
|
|
.flags = SMSC911X_USE_32BIT,
|
2009-02-01 23:27:49 -07:00
|
|
|
};
|
|
|
|
|
2011-04-16 16:29:30 -06:00
|
|
|
static struct omap_smsc911x_platform_data smsc911x2_cfg = {
|
2010-08-02 05:21:39 -06:00
|
|
|
.id = 1,
|
2011-04-16 16:29:30 -06:00
|
|
|
.cs = OVERO_SMSC911X2_CS,
|
|
|
|
.gpio_irq = OVERO_SMSC911X2_GPIO,
|
|
|
|
.gpio_reset = -EINVAL,
|
|
|
|
.flags = SMSC911X_USE_32BIT,
|
2010-08-02 05:21:39 -06:00
|
|
|
};
|
|
|
|
|
2011-04-16 16:29:30 -06:00
|
|
|
static void __init overo_init_smsc911x(void)
|
2009-02-01 23:27:49 -07:00
|
|
|
{
|
2011-04-16 16:29:30 -06:00
|
|
|
gpmc_smsc911x_init(&smsc911x_cfg);
|
|
|
|
gpmc_smsc911x_init(&smsc911x2_cfg);
|
2009-02-01 23:27:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
static inline void __init overo_init_smsc911x(void) { return; }
|
|
|
|
#endif
|
|
|
|
|
2011-03-05 06:58:39 -07:00
|
|
|
/* DSS */
|
|
|
|
static int lcd_enabled;
|
|
|
|
static int dvi_enabled;
|
|
|
|
|
|
|
|
#define OVERO_GPIO_LCD_EN 144
|
|
|
|
#define OVERO_GPIO_LCD_BL 145
|
|
|
|
|
2011-05-03 09:22:09 -06:00
|
|
|
static struct gpio overo_dss_gpios[] __initdata = {
|
|
|
|
{ OVERO_GPIO_LCD_EN, GPIOF_OUT_INIT_HIGH, "OVERO_GPIO_LCD_EN" },
|
|
|
|
{ OVERO_GPIO_LCD_BL, GPIOF_OUT_INIT_HIGH, "OVERO_GPIO_LCD_BL" },
|
|
|
|
};
|
|
|
|
|
2011-03-05 06:58:39 -07:00
|
|
|
static void __init overo_display_init(void)
|
|
|
|
{
|
2011-05-03 09:22:09 -06:00
|
|
|
if (gpio_request_array(overo_dss_gpios, ARRAY_SIZE(overo_dss_gpios))) {
|
|
|
|
printk(KERN_ERR "could not obtain DSS control GPIOs\n");
|
|
|
|
return;
|
|
|
|
}
|
2011-03-05 06:58:39 -07:00
|
|
|
|
2011-05-03 09:22:09 -06:00
|
|
|
gpio_export(OVERO_GPIO_LCD_EN, 0);
|
|
|
|
gpio_export(OVERO_GPIO_LCD_BL, 0);
|
2011-03-05 06:58:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int overo_panel_enable_dvi(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
if (lcd_enabled) {
|
|
|
|
printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
dvi_enabled = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void overo_panel_disable_dvi(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
dvi_enabled = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct panel_generic_dpi_data dvi_panel = {
|
|
|
|
.name = "generic",
|
|
|
|
.platform_enable = overo_panel_enable_dvi,
|
|
|
|
.platform_disable = overo_panel_disable_dvi,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_device overo_dvi_device = {
|
|
|
|
.name = "dvi",
|
|
|
|
.type = OMAP_DISPLAY_TYPE_DPI,
|
|
|
|
.driver_name = "generic_dpi_panel",
|
|
|
|
.data = &dvi_panel,
|
|
|
|
.phy.dpi.data_lines = 24,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_device overo_tv_device = {
|
|
|
|
.name = "tv",
|
|
|
|
.driver_name = "venc",
|
|
|
|
.type = OMAP_DISPLAY_TYPE_VENC,
|
|
|
|
.phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int overo_panel_enable_lcd(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
if (dvi_enabled) {
|
|
|
|
printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
gpio_set_value(OVERO_GPIO_LCD_EN, 1);
|
|
|
|
gpio_set_value(OVERO_GPIO_LCD_BL, 1);
|
|
|
|
lcd_enabled = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void overo_panel_disable_lcd(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
gpio_set_value(OVERO_GPIO_LCD_EN, 0);
|
|
|
|
gpio_set_value(OVERO_GPIO_LCD_BL, 0);
|
|
|
|
lcd_enabled = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct panel_generic_dpi_data lcd43_panel = {
|
|
|
|
.name = "samsung_lte430wq_f0c",
|
|
|
|
.platform_enable = overo_panel_enable_lcd,
|
|
|
|
.platform_disable = overo_panel_disable_lcd,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_device overo_lcd43_device = {
|
|
|
|
.name = "lcd43",
|
|
|
|
.type = OMAP_DISPLAY_TYPE_DPI,
|
|
|
|
.driver_name = "generic_dpi_panel",
|
|
|
|
.data = &lcd43_panel,
|
|
|
|
.phy.dpi.data_lines = 24,
|
|
|
|
};
|
|
|
|
|
|
|
|
#if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
|
|
|
|
defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
|
|
|
|
static struct omap_dss_device overo_lcd35_device = {
|
|
|
|
.type = OMAP_DISPLAY_TYPE_DPI,
|
|
|
|
.name = "lcd35",
|
|
|
|
.driver_name = "lgphilips_lb035q02_panel",
|
|
|
|
.phy.dpi.data_lines = 24,
|
|
|
|
.platform_enable = overo_panel_enable_lcd,
|
|
|
|
.platform_disable = overo_panel_disable_lcd,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static struct omap_dss_device *overo_dss_devices[] = {
|
|
|
|
&overo_dvi_device,
|
|
|
|
&overo_tv_device,
|
|
|
|
#if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
|
|
|
|
defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
|
|
|
|
&overo_lcd35_device,
|
|
|
|
#endif
|
|
|
|
&overo_lcd43_device,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_board_info overo_dss_data = {
|
|
|
|
.num_devices = ARRAY_SIZE(overo_dss_devices),
|
|
|
|
.devices = overo_dss_devices,
|
|
|
|
.default_device = &overo_dvi_device,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct regulator_consumer_supply overo_vdda_dac_supply =
|
|
|
|
REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");
|
|
|
|
|
|
|
|
static struct regulator_consumer_supply overo_vdds_dsi_supply[] = {
|
|
|
|
REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
|
|
|
|
REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
|
|
|
|
};
|
|
|
|
|
2008-10-09 08:51:43 -06:00
|
|
|
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,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-02-15 11:03:34 -07:00
|
|
|
static struct omap2_hsmmc_info mmc[] = {
|
2009-05-28 15:04:03 -06:00
|
|
|
{
|
|
|
|
.mmc = 1,
|
2010-09-15 08:49:23 -06:00
|
|
|
.caps = MMC_CAP_4_BIT_DATA,
|
2009-05-28 15:04:03 -06:00
|
|
|
.gpio_cd = -EINVAL,
|
|
|
|
.gpio_wp = -EINVAL,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.mmc = 2,
|
2010-09-15 08:49:23 -06:00
|
|
|
.caps = MMC_CAP_4_BIT_DATA,
|
2009-05-28 15:04:03 -06:00
|
|
|
.gpio_cd = -EINVAL,
|
|
|
|
.gpio_wp = -EINVAL,
|
|
|
|
.transceiver = true,
|
|
|
|
.ocr_mask = 0x00100000, /* 3.3V */
|
|
|
|
},
|
|
|
|
{} /* Terminator */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct regulator_consumer_supply overo_vmmc1_supply = {
|
|
|
|
.supply = "vmmc",
|
|
|
|
};
|
|
|
|
|
2011-03-09 17:08:05 -07:00
|
|
|
#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
|
|
|
|
#include <linux/leds.h>
|
|
|
|
|
|
|
|
static struct gpio_led gpio_leds[] = {
|
|
|
|
{
|
|
|
|
.name = "overo:red:gpio21",
|
|
|
|
.default_trigger = "heartbeat",
|
|
|
|
.gpio = 21,
|
|
|
|
.active_low = true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "overo:blue:gpio22",
|
|
|
|
.default_trigger = "none",
|
|
|
|
.gpio = 22,
|
|
|
|
.active_low = true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "overo:blue:COM",
|
|
|
|
.default_trigger = "mmc0",
|
|
|
|
.gpio = -EINVAL, /* gets replaced */
|
|
|
|
.active_low = true,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct gpio_led_platform_data gpio_leds_pdata = {
|
|
|
|
.leds = gpio_leds,
|
|
|
|
.num_leds = ARRAY_SIZE(gpio_leds),
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device gpio_leds_device = {
|
|
|
|
.name = "leds-gpio",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &gpio_leds_pdata,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static void __init overo_init_led(void)
|
|
|
|
{
|
|
|
|
platform_device_register(&gpio_leds_device);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
static inline void __init overo_init_led(void) { return; }
|
|
|
|
#endif
|
|
|
|
|
2011-03-09 17:08:06 -07:00
|
|
|
#if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
|
|
|
|
#include <linux/input.h>
|
|
|
|
#include <linux/gpio_keys.h>
|
|
|
|
|
|
|
|
static struct gpio_keys_button gpio_buttons[] = {
|
|
|
|
{
|
|
|
|
.code = BTN_0,
|
|
|
|
.gpio = 23,
|
|
|
|
.desc = "button0",
|
|
|
|
.wakeup = 1,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.code = BTN_1,
|
|
|
|
.gpio = 14,
|
|
|
|
.desc = "button1",
|
|
|
|
.wakeup = 1,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct gpio_keys_platform_data gpio_keys_pdata = {
|
|
|
|
.buttons = gpio_buttons,
|
|
|
|
.nbuttons = ARRAY_SIZE(gpio_buttons),
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device gpio_keys_device = {
|
|
|
|
.name = "gpio-keys",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &gpio_keys_pdata,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static void __init overo_init_keys(void)
|
|
|
|
{
|
|
|
|
platform_device_register(&gpio_keys_device);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
static inline void __init overo_init_keys(void) { return; }
|
|
|
|
#endif
|
|
|
|
|
2009-05-28 15:04:03 -06:00
|
|
|
static int overo_twl_gpio_setup(struct device *dev,
|
|
|
|
unsigned gpio, unsigned ngpio)
|
|
|
|
{
|
2010-02-15 11:03:34 -07:00
|
|
|
omap2_hsmmc_init(mmc);
|
2009-05-28 15:04:03 -06:00
|
|
|
|
|
|
|
overo_vmmc1_supply.dev = mmc[0].dev;
|
|
|
|
|
2011-03-09 17:08:05 -07:00
|
|
|
#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
|
|
|
|
/* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
|
|
|
|
gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
|
|
|
|
#endif
|
|
|
|
|
2009-05-28 15:04:03 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-10 18:37:17 -07:00
|
|
|
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,
|
2011-03-09 17:08:05 -07:00
|
|
|
.use_leds = true,
|
2009-05-28 15:04:03 -06:00
|
|
|
.setup = overo_twl_gpio_setup,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct twl4030_usb_data overo_usb_data = {
|
|
|
|
.usb_mode = T2_USB_MODE_ULPI,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct regulator_init_data overo_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 = &overo_vmmc1_supply,
|
2008-12-10 18:37:17 -07:00
|
|
|
};
|
|
|
|
|
2011-03-05 06:58:39 -07:00
|
|
|
/* VDAC for DSS driving S-Video (8 mA unloaded, max 65 mA) */
|
|
|
|
static struct regulator_init_data overo_vdac = {
|
|
|
|
.constraints = {
|
|
|
|
.min_uV = 1800000,
|
|
|
|
.max_uV = 1800000,
|
|
|
|
.valid_modes_mask = REGULATOR_MODE_NORMAL
|
|
|
|
| REGULATOR_MODE_STANDBY,
|
|
|
|
.valid_ops_mask = REGULATOR_CHANGE_MODE
|
|
|
|
| REGULATOR_CHANGE_STATUS,
|
|
|
|
},
|
|
|
|
.num_consumer_supplies = 1,
|
|
|
|
.consumer_supplies = &overo_vdda_dac_supply,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* VPLL2 for digital video outputs */
|
|
|
|
static struct regulator_init_data overo_vpll2 = {
|
|
|
|
.constraints = {
|
|
|
|
.name = "VDVI",
|
|
|
|
.min_uV = 1800000,
|
|
|
|
.max_uV = 1800000,
|
|
|
|
.valid_modes_mask = REGULATOR_MODE_NORMAL
|
|
|
|
| REGULATOR_MODE_STANDBY,
|
|
|
|
.valid_ops_mask = REGULATOR_CHANGE_MODE
|
|
|
|
| REGULATOR_CHANGE_STATUS,
|
|
|
|
},
|
|
|
|
.num_consumer_supplies = ARRAY_SIZE(overo_vdds_dsi_supply),
|
|
|
|
.consumer_supplies = overo_vdds_dsi_supply,
|
|
|
|
};
|
|
|
|
|
2011-03-02 06:24:05 -07:00
|
|
|
static struct twl4030_codec_audio_data overo_audio_data;
|
2009-10-22 04:26:46 -06:00
|
|
|
|
|
|
|
static struct twl4030_codec_data overo_codec_data = {
|
2009-11-04 00:58:18 -07:00
|
|
|
.audio_mclk = 26000000,
|
2009-10-22 04:26:46 -06:00
|
|
|
.audio = &overo_audio_data,
|
|
|
|
};
|
|
|
|
|
2008-12-10 18:37:17 -07:00
|
|
|
static struct twl4030_platform_data overo_twldata = {
|
|
|
|
.irq_base = TWL4030_IRQ_BASE,
|
|
|
|
.irq_end = TWL4030_IRQ_END,
|
|
|
|
.gpio = &overo_gpio_data,
|
2009-05-28 15:04:03 -06:00
|
|
|
.usb = &overo_usb_data,
|
2009-10-22 04:26:46 -06:00
|
|
|
.codec = &overo_codec_data,
|
2009-05-28 15:04:03 -06:00
|
|
|
.vmmc1 = &overo_vmmc1,
|
2011-03-05 06:58:39 -07:00
|
|
|
.vdac = &overo_vdac,
|
|
|
|
.vpll2 = &overo_vpll2,
|
2008-12-10 18:37:17 -07:00
|
|
|
};
|
|
|
|
|
2008-10-09 08:51:43 -06:00
|
|
|
static int __init overo_i2c_init(void)
|
|
|
|
{
|
2011-04-24 16:09:06 -06:00
|
|
|
omap3_pmic_init("tps65950", &overo_twldata);
|
2008-10-09 08:51:43 -06:00
|
|
|
/* i2c2 pins are used for gpio */
|
|
|
|
omap_register_i2c_bus(3, 400, NULL, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-03-05 06:58:39 -07:00
|
|
|
static struct spi_board_info overo_spi_board_info[] __initdata = {
|
|
|
|
#if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
|
|
|
|
defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
|
|
|
|
{
|
|
|
|
.modalias = "lgphilips_lb035q02_panel-spi",
|
|
|
|
.bus_num = 1,
|
|
|
|
.chip_select = 1,
|
|
|
|
.max_speed_hz = 500000,
|
|
|
|
.mode = SPI_MODE_3,
|
|
|
|
},
|
|
|
|
#endif
|
2008-10-09 08:51:43 -06:00
|
|
|
};
|
|
|
|
|
2011-03-05 06:58:39 -07:00
|
|
|
static int __init overo_spi_init(void)
|
|
|
|
{
|
|
|
|
overo_ads7846_init();
|
|
|
|
spi_register_board_info(overo_spi_board_info,
|
|
|
|
ARRAY_SIZE(overo_spi_board_info));
|
|
|
|
return 0;
|
|
|
|
}
|
2008-10-09 08:51:43 -06:00
|
|
|
|
2011-02-14 16:40:20 -07:00
|
|
|
static void __init overo_init_early(void)
|
2009-09-03 11:14:02 -06:00
|
|
|
{
|
OMAP2+: io: split omap2_init_common_hw()
Split omap2_init_common_hw() into two functions. The first,
omap2_init_common_infrastructure(), initializes the hwmod code and
data, the OMAP PM code, and the clock code and data. The second,
omap2_init_common_devices(), handles any other early device
initialization that, for whatever reason, has not been or cannot be
moved to initcalls or early platform devices.
This patch is required for the hwmod postsetup patch, which allows
board files to change the state that hwmods should be placed into at
the conclusion of the hwmod _setup() function. For example, for a
board whose creators wish to ensure watchdog coverage across the
entire kernel boot process, code to change the watchdog's postsetup
state will be added in the board-*.c file between the
omap2_init_common_infrastructure() and omap2_init_common_devices() function
calls.
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Cc: Tony Lindgren <tony@atomide.com>
2010-12-21 15:25:10 -07:00
|
|
|
omap2_init_common_infrastructure();
|
|
|
|
omap2_init_common_devices(mt46h32m32lf6_sdrc_params,
|
|
|
|
mt46h32m32lf6_sdrc_params);
|
2009-09-03 11:14:02 -06:00
|
|
|
}
|
|
|
|
|
2011-03-01 07:38:16 -07:00
|
|
|
static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
|
|
|
|
.port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
|
|
|
|
.port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
|
|
|
|
.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
|
2009-11-22 11:11:01 -07:00
|
|
|
.phy_reset = true,
|
|
|
|
.reset_gpio_port[0] = -EINVAL,
|
|
|
|
.reset_gpio_port[1] = OVERO_GPIO_USBH_NRESET,
|
|
|
|
.reset_gpio_port[2] = -EINVAL
|
|
|
|
};
|
|
|
|
|
2009-12-11 17:16:32 -07:00
|
|
|
#ifdef CONFIG_OMAP_MUX
|
|
|
|
static struct omap_board_mux board_mux[] __initdata = {
|
|
|
|
{ .reg_offset = OMAP_MUX_TERMINATOR },
|
|
|
|
};
|
|
|
|
#endif
|
2009-11-22 11:11:01 -07:00
|
|
|
|
2011-05-03 09:22:09 -06:00
|
|
|
static struct gpio overo_bt_gpios[] __initdata = {
|
|
|
|
{ OVERO_GPIO_BT_XGATE, GPIOF_OUT_INIT_LOW, "lcd enable" },
|
|
|
|
{ OVERO_GPIO_BT_NRESET, GPIOF_OUT_INIT_HIGH, "lcd bl enable" },
|
2010-02-17 15:09:30 -07:00
|
|
|
};
|
|
|
|
|
2008-10-09 08:51:43 -06:00
|
|
|
static void __init overo_init(void)
|
|
|
|
{
|
2011-05-03 09:22:09 -06:00
|
|
|
int ret;
|
|
|
|
|
2009-12-11 17:16:32 -07:00
|
|
|
omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
|
2008-10-09 08:51:43 -06:00
|
|
|
overo_i2c_init();
|
2011-03-05 06:58:39 -07:00
|
|
|
omap_display_init(&overo_dss_data);
|
2008-10-09 08:51:43 -06:00
|
|
|
omap_serial_init();
|
2011-04-24 16:09:07 -06:00
|
|
|
omap_nand_flash_init(0, overo_nand_partitions,
|
|
|
|
ARRAY_SIZE(overo_nand_partitions));
|
2011-04-27 02:56:12 -06:00
|
|
|
usb_musb_init(NULL);
|
2011-03-01 07:38:19 -07:00
|
|
|
usbhs_init(&usbhs_bdata);
|
2011-03-05 06:58:39 -07:00
|
|
|
overo_spi_init();
|
2009-03-23 19:38:16 -06:00
|
|
|
overo_ads7846_init();
|
2009-02-01 23:27:49 -07:00
|
|
|
overo_init_smsc911x();
|
2011-03-05 06:58:39 -07:00
|
|
|
overo_display_init();
|
2011-03-09 17:08:05 -07:00
|
|
|
overo_init_led();
|
2011-03-09 17:08:06 -07:00
|
|
|
overo_init_keys();
|
2008-10-09 08:51:43 -06:00
|
|
|
|
2009-07-24 19:43:25 -06:00
|
|
|
/* Ensure SDRC pins are mux'd for self-refresh */
|
2009-12-11 17:16:32 -07:00
|
|
|
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
|
|
|
|
omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
|
2009-07-24 19:43:25 -06:00
|
|
|
|
2011-05-03 09:22:09 -06:00
|
|
|
ret = gpio_request_one(OVERO_GPIO_W2W_NRESET, GPIOF_OUT_INIT_HIGH,
|
|
|
|
"OVERO_GPIO_W2W_NRESET");
|
|
|
|
if (ret == 0) {
|
2008-10-09 08:51:43 -06:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
|
2011-05-03 09:22:09 -06:00
|
|
|
ret = gpio_request_array(overo_bt_gpios, ARRAY_SIZE(overo_bt_gpios));
|
|
|
|
if (ret) {
|
|
|
|
pr_err("%s: could not obtain BT gpios\n", __func__);
|
|
|
|
} else {
|
2008-10-09 08:51:43 -06:00
|
|
|
gpio_export(OVERO_GPIO_BT_XGATE, 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);
|
|
|
|
}
|
|
|
|
|
2011-05-03 09:22:09 -06:00
|
|
|
ret = gpio_request_one(OVERO_GPIO_USBH_CPEN, GPIOF_OUT_INIT_HIGH,
|
|
|
|
"OVERO_GPIO_USBH_CPEN");
|
|
|
|
if (ret == 0)
|
2008-10-09 08:51:43 -06:00
|
|
|
gpio_export(OVERO_GPIO_USBH_CPEN, 0);
|
|
|
|
else
|
|
|
|
printk(KERN_ERR "could not obtain gpio for "
|
|
|
|
"OVERO_GPIO_USBH_CPEN\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
MACHINE_START(OVERO, "Gumstix Overo")
|
|
|
|
.boot_params = 0x80000100,
|
2010-05-23 03:18:16 -06:00
|
|
|
.reserve = omap_reserve,
|
2011-02-14 16:40:20 -07:00
|
|
|
.map_io = omap3_map_io,
|
|
|
|
.init_early = overo_init_early,
|
|
|
|
.init_irq = omap_init_irq,
|
2008-10-09 08:51:43 -06:00
|
|
|
.init_machine = overo_init,
|
|
|
|
.timer = &omap_timer,
|
|
|
|
MACHINE_END
|