2008-10-09 08:51:42 -06:00
|
|
|
/*
|
|
|
|
* linux/arch/arm/mach-omap2/board-omap3beagle.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Texas Instruments
|
|
|
|
*
|
|
|
|
* Modified from mach-omap2/board-3430sdp.c
|
|
|
|
*
|
|
|
|
* Initial code: Syed Mohammed Khasim
|
|
|
|
*
|
|
|
|
* 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/leds.h>
|
|
|
|
#include <linux/gpio.h>
|
|
|
|
#include <linux/input.h>
|
|
|
|
#include <linux/gpio_keys.h>
|
2011-01-07 08:41:13 -07:00
|
|
|
#include <linux/opp.h>
|
2008-10-09 08:51:42 -06:00
|
|
|
|
|
|
|
#include <linux/mtd/mtd.h>
|
|
|
|
#include <linux/mtd/partitions.h>
|
|
|
|
#include <linux/mtd/nand.h>
|
2010-09-15 08:49:23 -06:00
|
|
|
#include <linux/mmc/host.h>
|
2008-10-09 08:51:42 -06:00
|
|
|
|
2009-05-28 15:04:03 -06:00
|
|
|
#include <linux/regulator/machine.h>
|
2009-12-13 12:05:51 -07:00
|
|
|
#include <linux/i2c/twl.h>
|
2009-01-15 04:09:53 -07:00
|
|
|
|
2008-10-09 08:51:42 -06:00
|
|
|
#include <mach/hardware.h>
|
|
|
|
#include <asm/mach-types.h>
|
|
|
|
#include <asm/mach/arch.h>
|
|
|
|
#include <asm/mach/map.h>
|
|
|
|
#include <asm/mach/flash.h>
|
|
|
|
|
2009-10-20 10:40:47 -06:00
|
|
|
#include <plat/board.h>
|
|
|
|
#include <plat/common.h>
|
2010-04-22 02:23:42 -06:00
|
|
|
#include <plat/display.h>
|
2010-11-17 06:34:34 -07:00
|
|
|
#include <plat/panel-generic-dpi.h>
|
2009-10-20 10:40:47 -06:00
|
|
|
#include <plat/gpmc.h>
|
|
|
|
#include <plat/nand.h>
|
|
|
|
#include <plat/usb.h>
|
2011-01-07 08:41:13 -07:00
|
|
|
#include <plat/omap_device.h>
|
2008-10-09 08:51:42 -06:00
|
|
|
|
2009-12-11 17:16:32 -07:00
|
|
|
#include "mux.h"
|
2010-02-15 11:03:34 -07:00
|
|
|
#include "hsmmc.h"
|
2010-10-08 10:58:35 -06:00
|
|
|
#include "timer-gp.h"
|
2011-01-07 08:41:13 -07:00
|
|
|
#include "pm.h"
|
2008-10-09 08:51:42 -06:00
|
|
|
|
|
|
|
#define NAND_BLOCK_SIZE SZ_128K
|
|
|
|
|
2010-09-23 19:22:47 -06:00
|
|
|
/*
|
|
|
|
* OMAP3 Beagle revision
|
|
|
|
* Run time detection of Beagle revision is done by reading GPIO.
|
|
|
|
* GPIO ID -
|
|
|
|
* AXBX = GPIO173, GPIO172, GPIO171: 1 1 1
|
|
|
|
* C1_3 = GPIO173, GPIO172, GPIO171: 1 1 0
|
|
|
|
* C4 = GPIO173, GPIO172, GPIO171: 1 0 1
|
|
|
|
* XM = GPIO173, GPIO172, GPIO171: 0 0 0
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
OMAP3BEAGLE_BOARD_UNKN = 0,
|
|
|
|
OMAP3BEAGLE_BOARD_AXBX,
|
|
|
|
OMAP3BEAGLE_BOARD_C1_3,
|
|
|
|
OMAP3BEAGLE_BOARD_C4,
|
|
|
|
OMAP3BEAGLE_BOARD_XM,
|
|
|
|
};
|
|
|
|
|
|
|
|
static u8 omap3_beagle_version;
|
|
|
|
|
|
|
|
static u8 omap3_beagle_get_rev(void)
|
|
|
|
{
|
|
|
|
return omap3_beagle_version;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init omap3_beagle_init_rev(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u16 beagle_rev = 0;
|
|
|
|
|
|
|
|
omap_mux_init_gpio(171, OMAP_PIN_INPUT_PULLUP);
|
|
|
|
omap_mux_init_gpio(172, OMAP_PIN_INPUT_PULLUP);
|
|
|
|
omap_mux_init_gpio(173, OMAP_PIN_INPUT_PULLUP);
|
|
|
|
|
|
|
|
ret = gpio_request(171, "rev_id_0");
|
|
|
|
if (ret < 0)
|
|
|
|
goto fail0;
|
|
|
|
|
|
|
|
ret = gpio_request(172, "rev_id_1");
|
|
|
|
if (ret < 0)
|
|
|
|
goto fail1;
|
|
|
|
|
|
|
|
ret = gpio_request(173, "rev_id_2");
|
|
|
|
if (ret < 0)
|
|
|
|
goto fail2;
|
|
|
|
|
|
|
|
gpio_direction_input(171);
|
|
|
|
gpio_direction_input(172);
|
|
|
|
gpio_direction_input(173);
|
|
|
|
|
|
|
|
beagle_rev = gpio_get_value(171) | (gpio_get_value(172) << 1)
|
|
|
|
| (gpio_get_value(173) << 2);
|
|
|
|
|
|
|
|
switch (beagle_rev) {
|
|
|
|
case 7:
|
|
|
|
printk(KERN_INFO "OMAP3 Beagle Rev: Ax/Bx\n");
|
|
|
|
omap3_beagle_version = OMAP3BEAGLE_BOARD_AXBX;
|
|
|
|
break;
|
|
|
|
case 6:
|
|
|
|
printk(KERN_INFO "OMAP3 Beagle Rev: C1/C2/C3\n");
|
|
|
|
omap3_beagle_version = OMAP3BEAGLE_BOARD_C1_3;
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
printk(KERN_INFO "OMAP3 Beagle Rev: C4\n");
|
|
|
|
omap3_beagle_version = OMAP3BEAGLE_BOARD_C4;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
printk(KERN_INFO "OMAP3 Beagle Rev: xM\n");
|
|
|
|
omap3_beagle_version = OMAP3BEAGLE_BOARD_XM;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_INFO "OMAP3 Beagle Rev: unknown %hd\n", beagle_rev);
|
|
|
|
omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail2:
|
|
|
|
gpio_free(172);
|
|
|
|
fail1:
|
|
|
|
gpio_free(171);
|
|
|
|
fail0:
|
|
|
|
printk(KERN_ERR "Unable to get revision detection GPIO pins\n");
|
|
|
|
omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-10-09 08:51:42 -06:00
|
|
|
static struct mtd_partition omap3beagle_nand_partitions[] = {
|
|
|
|
/* All the partition sizes are listed in terms of NAND block size */
|
|
|
|
{
|
|
|
|
.name = "X-Loader",
|
|
|
|
.offset = 0,
|
|
|
|
.size = 4 * NAND_BLOCK_SIZE,
|
|
|
|
.mask_flags = MTD_WRITEABLE, /* force read-only */
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "U-Boot",
|
|
|
|
.offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */
|
|
|
|
.size = 15 * NAND_BLOCK_SIZE,
|
|
|
|
.mask_flags = MTD_WRITEABLE, /* force read-only */
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "U-Boot Env",
|
|
|
|
.offset = MTDPART_OFS_APPEND, /* Offset = 0x260000 */
|
|
|
|
.size = 1 * NAND_BLOCK_SIZE,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "Kernel",
|
|
|
|
.offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */
|
|
|
|
.size = 32 * NAND_BLOCK_SIZE,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "File System",
|
|
|
|
.offset = MTDPART_OFS_APPEND, /* Offset = 0x680000 */
|
|
|
|
.size = MTDPART_SIZ_FULL,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_nand_platform_data omap3beagle_nand_data = {
|
|
|
|
.options = NAND_BUSWIDTH_16,
|
|
|
|
.parts = omap3beagle_nand_partitions,
|
|
|
|
.nr_parts = ARRAY_SIZE(omap3beagle_nand_partitions),
|
|
|
|
.dma_channel = -1, /* disable DMA in OMAP NAND driver */
|
|
|
|
.nand_setup = NULL,
|
|
|
|
.dev_ready = NULL,
|
|
|
|
};
|
|
|
|
|
2010-04-22 02:23:42 -06:00
|
|
|
/* DSS */
|
|
|
|
|
|
|
|
static int beagle_enable_dvi(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
if (gpio_is_valid(dssdev->reset_gpio))
|
|
|
|
gpio_set_value(dssdev->reset_gpio, 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void beagle_disable_dvi(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
if (gpio_is_valid(dssdev->reset_gpio))
|
|
|
|
gpio_set_value(dssdev->reset_gpio, 0);
|
|
|
|
}
|
|
|
|
|
2010-11-17 06:34:34 -07:00
|
|
|
static struct panel_generic_dpi_data dvi_panel = {
|
|
|
|
.name = "generic",
|
|
|
|
.platform_enable = beagle_enable_dvi,
|
|
|
|
.platform_disable = beagle_disable_dvi,
|
|
|
|
};
|
|
|
|
|
2010-04-22 02:23:42 -06:00
|
|
|
static struct omap_dss_device beagle_dvi_device = {
|
|
|
|
.type = OMAP_DISPLAY_TYPE_DPI,
|
|
|
|
.name = "dvi",
|
2010-11-17 06:34:34 -07:00
|
|
|
.driver_name = "generic_dpi_panel",
|
|
|
|
.data = &dvi_panel,
|
2010-04-22 02:23:42 -06:00
|
|
|
.phy.dpi.data_lines = 24,
|
2011-01-11 10:13:36 -07:00
|
|
|
.reset_gpio = -EINVAL,
|
2010-04-22 02:23:42 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_device beagle_tv_device = {
|
|
|
|
.name = "tv",
|
|
|
|
.driver_name = "venc",
|
|
|
|
.type = OMAP_DISPLAY_TYPE_VENC,
|
|
|
|
.phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_device *beagle_dss_devices[] = {
|
|
|
|
&beagle_dvi_device,
|
|
|
|
&beagle_tv_device,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_board_info beagle_dss_data = {
|
|
|
|
.num_devices = ARRAY_SIZE(beagle_dss_devices),
|
|
|
|
.devices = beagle_dss_devices,
|
|
|
|
.default_device = &beagle_dvi_device,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct regulator_consumer_supply beagle_vdac_supply =
|
2011-01-23 23:22:01 -07:00
|
|
|
REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");
|
2010-04-22 02:23:42 -06:00
|
|
|
|
2011-01-23 23:22:02 -07:00
|
|
|
static struct regulator_consumer_supply beagle_vdvi_supplies[] = {
|
|
|
|
REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
|
|
|
|
REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
|
|
|
|
};
|
2010-04-22 02:23:42 -06:00
|
|
|
|
|
|
|
static void __init beagle_display_init(void)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = gpio_request(beagle_dvi_device.reset_gpio, "DVI reset");
|
|
|
|
if (r < 0) {
|
|
|
|
printk(KERN_ERR "Unable to get DVI reset GPIO\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
gpio_direction_output(beagle_dvi_device.reset_gpio, 0);
|
|
|
|
}
|
|
|
|
|
2009-05-28 15:03:59 -06:00
|
|
|
#include "sdram-micron-mt46h32m32lf-6.h"
|
|
|
|
|
2010-02-15 11:03:34 -07:00
|
|
|
static struct omap2_hsmmc_info mmc[] = {
|
2008-12-10 18:37:17 -07:00
|
|
|
{
|
|
|
|
.mmc = 1,
|
2010-09-15 08:49:23 -06:00
|
|
|
.caps = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
|
2008-12-10 18:37:17 -07:00
|
|
|
.gpio_wp = 29,
|
|
|
|
},
|
|
|
|
{} /* Terminator */
|
|
|
|
};
|
|
|
|
|
2009-05-28 15:04:03 -06:00
|
|
|
static struct regulator_consumer_supply beagle_vmmc1_supply = {
|
|
|
|
.supply = "vmmc",
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct regulator_consumer_supply beagle_vsim_supply = {
|
|
|
|
.supply = "vmmc_aux",
|
|
|
|
};
|
|
|
|
|
2008-12-10 18:37:17 -07:00
|
|
|
static struct gpio_led gpio_leds[];
|
|
|
|
|
|
|
|
static int beagle_twl_gpio_setup(struct device *dev,
|
|
|
|
unsigned gpio, unsigned ngpio)
|
|
|
|
{
|
2011-01-11 17:23:29 -07:00
|
|
|
int r;
|
|
|
|
|
2010-09-23 19:22:48 -06:00
|
|
|
if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
|
|
|
|
mmc[0].gpio_wp = -EINVAL;
|
|
|
|
} else if ((omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C1_3) ||
|
2010-09-23 19:22:48 -06:00
|
|
|
(omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C4)) {
|
2009-12-11 17:16:32 -07:00
|
|
|
omap_mux_init_gpio(23, OMAP_PIN_INPUT);
|
2009-09-24 17:23:17 -06:00
|
|
|
mmc[0].gpio_wp = 23;
|
|
|
|
} else {
|
2009-12-11 17:16:32 -07:00
|
|
|
omap_mux_init_gpio(29, OMAP_PIN_INPUT);
|
2009-09-24 17:23:17 -06:00
|
|
|
}
|
2008-12-10 18:37:17 -07:00
|
|
|
/* gpio + 0 is "mmc0_cd" (input/IRQ) */
|
2009-01-15 04:09:53 -07:00
|
|
|
mmc[0].gpio_cd = gpio + 0;
|
2010-02-15 11:03:34 -07:00
|
|
|
omap2_hsmmc_init(mmc);
|
2008-12-10 18:37:17 -07:00
|
|
|
|
2009-05-28 15:04:03 -06:00
|
|
|
/* link regulators to MMC adapters */
|
|
|
|
beagle_vmmc1_supply.dev = mmc[0].dev;
|
|
|
|
beagle_vsim_supply.dev = mmc[0].dev;
|
|
|
|
|
2008-12-10 18:37:17 -07:00
|
|
|
/* REVISIT: need ehci-omap hooks for external VBUS
|
|
|
|
* power switch and overcurrent detect
|
|
|
|
*/
|
2011-01-11 17:23:29 -07:00
|
|
|
if (omap3_beagle_get_rev() != OMAP3BEAGLE_BOARD_XM) {
|
|
|
|
r = gpio_request(gpio + 1, "EHCI_nOC");
|
|
|
|
if (!r) {
|
|
|
|
r = gpio_direction_input(gpio + 1);
|
|
|
|
if (r)
|
|
|
|
gpio_free(gpio + 1);
|
|
|
|
}
|
|
|
|
if (r)
|
|
|
|
pr_err("%s: unable to configure EHCI_nOC\n", __func__);
|
|
|
|
}
|
2008-12-10 18:37:17 -07:00
|
|
|
|
2011-01-11 10:13:35 -07:00
|
|
|
/*
|
|
|
|
* TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active
|
|
|
|
* high / others active low)
|
|
|
|
*/
|
2008-12-10 18:37:17 -07:00
|
|
|
gpio_request(gpio + TWL4030_GPIO_MAX, "nEN_USB_PWR");
|
2011-01-11 10:13:35 -07:00
|
|
|
if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM)
|
|
|
|
gpio_direction_output(gpio + TWL4030_GPIO_MAX, 1);
|
|
|
|
else
|
|
|
|
gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0);
|
2008-12-10 18:37:17 -07:00
|
|
|
|
2011-01-11 10:13:36 -07:00
|
|
|
/* DVI reset GPIO is different between beagle revisions */
|
|
|
|
if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM)
|
|
|
|
beagle_dvi_device.reset_gpio = 129;
|
|
|
|
else
|
|
|
|
beagle_dvi_device.reset_gpio = 170;
|
2008-12-10 18:37:17 -07:00
|
|
|
|
|
|
|
/* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
|
|
|
|
gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
|
|
|
|
|
2011-01-11 17:23:29 -07:00
|
|
|
/*
|
|
|
|
* gpio + 1 on Xm controls the TFP410's enable line (active low)
|
|
|
|
* gpio + 2 control varies depending on the board rev as follows:
|
|
|
|
* P7/P8 revisions(prototype): Camera EN
|
|
|
|
* A2+ revisions (production): LDO (supplies DVI, serial, led blocks)
|
|
|
|
*/
|
|
|
|
if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
|
|
|
|
r = gpio_request(gpio + 1, "nDVI_PWR_EN");
|
|
|
|
if (!r) {
|
|
|
|
r = gpio_direction_output(gpio + 1, 0);
|
|
|
|
if (r)
|
|
|
|
gpio_free(gpio + 1);
|
|
|
|
}
|
|
|
|
if (r)
|
|
|
|
pr_err("%s: unable to configure nDVI_PWR_EN\n",
|
|
|
|
__func__);
|
|
|
|
r = gpio_request(gpio + 2, "DVI_LDO_EN");
|
|
|
|
if (!r) {
|
|
|
|
r = gpio_direction_output(gpio + 2, 1);
|
|
|
|
if (r)
|
|
|
|
gpio_free(gpio + 2);
|
|
|
|
}
|
|
|
|
if (r)
|
|
|
|
pr_err("%s: unable to configure DVI_LDO_EN\n",
|
|
|
|
__func__);
|
|
|
|
}
|
|
|
|
|
2008-12-10 18:37:17 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct twl4030_gpio_platform_data beagle_gpio_data = {
|
|
|
|
.gpio_base = OMAP_MAX_GPIO_LINES,
|
|
|
|
.irq_base = TWL4030_GPIO_IRQ_BASE,
|
|
|
|
.irq_end = TWL4030_GPIO_IRQ_END,
|
|
|
|
.use_leds = true,
|
|
|
|
.pullups = BIT(1),
|
|
|
|
.pulldowns = BIT(2) | BIT(6) | BIT(7) | BIT(8) | BIT(13)
|
|
|
|
| BIT(15) | BIT(16) | BIT(17),
|
|
|
|
.setup = beagle_twl_gpio_setup,
|
|
|
|
};
|
|
|
|
|
2009-05-28 15:04:03 -06:00
|
|
|
/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
|
|
|
|
static struct regulator_init_data beagle_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 = &beagle_vmmc1_supply,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */
|
|
|
|
static struct regulator_init_data beagle_vsim = {
|
|
|
|
.constraints = {
|
|
|
|
.min_uV = 1800000,
|
|
|
|
.max_uV = 3000000,
|
|
|
|
.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 = &beagle_vsim_supply,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* VDAC for DSS driving S-Video (8 mA unloaded, max 65 mA) */
|
|
|
|
static struct regulator_init_data beagle_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 = &beagle_vdac_supply,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* VPLL2 for digital video outputs */
|
|
|
|
static struct regulator_init_data beagle_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,
|
|
|
|
},
|
2011-01-23 23:22:02 -07:00
|
|
|
.num_consumer_supplies = ARRAY_SIZE(beagle_vdvi_supplies),
|
|
|
|
.consumer_supplies = beagle_vdvi_supplies,
|
2009-05-28 15:04:03 -06:00
|
|
|
};
|
|
|
|
|
2009-08-28 12:24:15 -06:00
|
|
|
static struct twl4030_usb_data beagle_usb_data = {
|
|
|
|
.usb_mode = T2_USB_MODE_ULPI,
|
|
|
|
};
|
|
|
|
|
2011-03-02 06:24:05 -07:00
|
|
|
static struct twl4030_codec_audio_data beagle_audio_data;
|
2009-10-22 04:26:46 -06:00
|
|
|
|
|
|
|
static struct twl4030_codec_data beagle_codec_data = {
|
2009-11-04 00:58:18 -07:00
|
|
|
.audio_mclk = 26000000,
|
2009-10-22 04:26:46 -06:00
|
|
|
.audio = &beagle_audio_data,
|
|
|
|
};
|
|
|
|
|
2008-12-10 18:37:17 -07:00
|
|
|
static struct twl4030_platform_data beagle_twldata = {
|
|
|
|
.irq_base = TWL4030_IRQ_BASE,
|
|
|
|
.irq_end = TWL4030_IRQ_END,
|
|
|
|
|
|
|
|
/* platform_data for children goes here */
|
2009-08-28 12:24:15 -06:00
|
|
|
.usb = &beagle_usb_data,
|
2008-12-10 18:37:17 -07:00
|
|
|
.gpio = &beagle_gpio_data,
|
2009-10-22 04:26:46 -06:00
|
|
|
.codec = &beagle_codec_data,
|
2009-05-28 15:04:03 -06:00
|
|
|
.vmmc1 = &beagle_vmmc1,
|
|
|
|
.vsim = &beagle_vsim,
|
|
|
|
.vdac = &beagle_vdac,
|
|
|
|
.vpll2 = &beagle_vpll2,
|
2008-12-10 18:37:17 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = {
|
|
|
|
{
|
|
|
|
I2C_BOARD_INFO("twl4030", 0x48),
|
|
|
|
.flags = I2C_CLIENT_WAKE,
|
|
|
|
.irq = INT_34XX_SYS_NIRQ,
|
|
|
|
.platform_data = &beagle_twldata,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-09-23 19:22:48 -06:00
|
|
|
static struct i2c_board_info __initdata beagle_i2c_eeprom[] = {
|
|
|
|
{
|
|
|
|
I2C_BOARD_INFO("eeprom", 0x50),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2008-12-10 18:37:17 -07:00
|
|
|
static int __init omap3_beagle_i2c_init(void)
|
|
|
|
{
|
|
|
|
omap_register_i2c_bus(1, 2600, beagle_i2c_boardinfo,
|
|
|
|
ARRAY_SIZE(beagle_i2c_boardinfo));
|
2009-03-04 11:07:42 -07:00
|
|
|
/* Bus 3 is attached to the DVI port where devices like the pico DLP
|
|
|
|
* projector don't work reliably with 400kHz */
|
2010-09-23 19:22:48 -06:00
|
|
|
omap_register_i2c_bus(3, 100, beagle_i2c_eeprom, ARRAY_SIZE(beagle_i2c_eeprom));
|
2008-12-10 18:37:17 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-09 08:51:42 -06:00
|
|
|
static struct gpio_led gpio_leds[] = {
|
|
|
|
{
|
|
|
|
.name = "beagleboard::usr0",
|
|
|
|
.default_trigger = "heartbeat",
|
|
|
|
.gpio = 150,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "beagleboard::usr1",
|
|
|
|
.default_trigger = "mmc0",
|
|
|
|
.gpio = 149,
|
|
|
|
},
|
2008-12-10 18:37:17 -07:00
|
|
|
{
|
|
|
|
.name = "beagleboard::pmu_stat",
|
|
|
|
.gpio = -EINVAL, /* gets replaced */
|
|
|
|
.active_low = true,
|
|
|
|
},
|
2008-10-09 08:51:42 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct gpio_led_platform_data gpio_led_info = {
|
|
|
|
.leds = gpio_leds,
|
|
|
|
.num_leds = ARRAY_SIZE(gpio_leds),
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device leds_gpio = {
|
|
|
|
.name = "leds-gpio",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &gpio_led_info,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct gpio_keys_button gpio_buttons[] = {
|
|
|
|
{
|
|
|
|
.code = BTN_EXTRA,
|
|
|
|
.gpio = 7,
|
|
|
|
.desc = "user",
|
|
|
|
.wakeup = 1,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct gpio_keys_platform_data gpio_key_info = {
|
|
|
|
.buttons = gpio_buttons,
|
|
|
|
.nbuttons = ARRAY_SIZE(gpio_buttons),
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device keys_gpio = {
|
|
|
|
.name = "gpio-keys",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &gpio_key_info,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-02-14 16:40:20 -07:00
|
|
|
static void __init omap3_beagle_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);
|
2011-02-14 16:40:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __init omap3_beagle_init_irq(void)
|
|
|
|
{
|
2009-09-03 11:14:02 -06:00
|
|
|
omap_init_irq();
|
|
|
|
#ifdef CONFIG_OMAP_32K_TIMER
|
|
|
|
omap2_gp_clockevent_set_gptimer(12);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-10-09 08:51:42 -06:00
|
|
|
static struct platform_device *omap3_beagle_devices[] __initdata = {
|
|
|
|
&leds_gpio,
|
|
|
|
&keys_gpio,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void __init omap3beagle_flash_init(void)
|
|
|
|
{
|
|
|
|
u8 cs = 0;
|
|
|
|
u8 nandcs = GPMC_CS_NUM + 1;
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
omap3beagle_nand_data.cs = nandcs;
|
|
|
|
|
|
|
|
printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
|
2010-07-09 03:14:46 -06:00
|
|
|
if (gpmc_nand_init(&omap3beagle_nand_data) < 0)
|
2008-10-09 08:51:42 -06:00
|
|
|
printk(KERN_ERR "Unable to register NAND device\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-01 07:38:16 -07:00
|
|
|
static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
|
2009-11-22 11:11:01 -07:00
|
|
|
|
2011-03-01 07:38:16 -07:00
|
|
|
.port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
|
|
|
|
.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] = 147,
|
|
|
|
.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
|
|
|
|
|
2010-02-17 15:09:30 -07:00
|
|
|
static struct omap_musb_board_data musb_board_data = {
|
|
|
|
.interface_type = MUSB_INTERFACE_ULPI,
|
|
|
|
.mode = MUSB_OTG,
|
|
|
|
.power = 100,
|
|
|
|
};
|
|
|
|
|
2011-01-07 08:41:13 -07:00
|
|
|
static void __init beagle_opp_init(void)
|
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
/* Initialize the omap3 opp table */
|
|
|
|
if (omap3_opp_init()) {
|
|
|
|
pr_err("%s: opp default init failed\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Custom OPP enabled for XM */
|
|
|
|
if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
|
|
|
|
struct omap_hwmod *mh = omap_hwmod_lookup("mpu");
|
|
|
|
struct omap_hwmod *dh = omap_hwmod_lookup("iva");
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
if (!mh || !dh) {
|
|
|
|
pr_err("%s: Aiee.. no mpu/dsp devices? %p %p\n",
|
|
|
|
__func__, mh, dh);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Enable MPU 1GHz and lower opps */
|
|
|
|
dev = &mh->od->pdev.dev;
|
|
|
|
r = opp_enable(dev, 800000000);
|
|
|
|
/* TODO: MPU 1GHz needs SR and ABB */
|
|
|
|
|
|
|
|
/* Enable IVA 800MHz and lower opps */
|
|
|
|
dev = &dh->od->pdev.dev;
|
|
|
|
r |= opp_enable(dev, 660000000);
|
|
|
|
/* TODO: DSP 800MHz needs SR and ABB */
|
|
|
|
if (r) {
|
|
|
|
pr_err("%s: failed to enable higher opp %d\n",
|
|
|
|
__func__, r);
|
|
|
|
/*
|
|
|
|
* Cleanup - disable the higher freqs - we dont care
|
|
|
|
* about the results
|
|
|
|
*/
|
|
|
|
dev = &mh->od->pdev.dev;
|
|
|
|
opp_disable(dev, 800000000);
|
|
|
|
dev = &dh->od->pdev.dev;
|
|
|
|
opp_disable(dev, 660000000);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-10-09 08:51:42 -06:00
|
|
|
static void __init omap3_beagle_init(void)
|
|
|
|
{
|
2009-12-11 17:16:32 -07:00
|
|
|
omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
|
2010-09-23 19:22:47 -06:00
|
|
|
omap3_beagle_init_rev();
|
2008-12-10 18:37:17 -07:00
|
|
|
omap3_beagle_i2c_init();
|
2008-10-09 08:51:42 -06:00
|
|
|
platform_add_devices(omap3_beagle_devices,
|
|
|
|
ARRAY_SIZE(omap3_beagle_devices));
|
2011-02-22 02:24:50 -07:00
|
|
|
omap_display_init(&beagle_dss_data);
|
2008-10-09 08:51:42 -06:00
|
|
|
omap_serial_init();
|
2008-12-10 18:37:17 -07:00
|
|
|
|
2009-12-11 17:16:32 -07:00
|
|
|
omap_mux_init_gpio(170, OMAP_PIN_INPUT);
|
2008-12-10 18:37:17 -07:00
|
|
|
gpio_request(170, "DVI_nPD");
|
|
|
|
/* REVISIT leave DVI powered down until it's needed ... */
|
|
|
|
gpio_direction_output(170, true);
|
|
|
|
|
2010-02-17 15:09:30 -07:00
|
|
|
usb_musb_init(&musb_board_data);
|
2011-03-01 07:38:19 -07:00
|
|
|
usbhs_init(&usbhs_bdata);
|
2008-10-09 08:51:42 -06:00
|
|
|
omap3beagle_flash_init();
|
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);
|
2010-04-22 02:23:42 -06:00
|
|
|
|
|
|
|
beagle_display_init();
|
2011-01-07 08:41:13 -07:00
|
|
|
beagle_opp_init();
|
2008-10-09 08:51:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
MACHINE_START(OMAP3_BEAGLE, "OMAP3 Beagle Board")
|
|
|
|
/* Maintainer: Syed Mohammed Khasim - http://beagleboard.org */
|
|
|
|
.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 = omap3_beagle_init_early,
|
2008-10-09 08:51:42 -06:00
|
|
|
.init_irq = omap3_beagle_init_irq,
|
|
|
|
.init_machine = omap3_beagle_init,
|
|
|
|
.timer = &omap_timer,
|
|
|
|
MACHINE_END
|