2009-05-29 04:16:05 +07:00
|
|
|
/*
|
|
|
|
* Board support file for OMAP4430 SDP.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2009 Texas Instruments
|
|
|
|
*
|
|
|
|
* Author: Santosh Shilimkar <santosh.shilimkar@ti.com>
|
|
|
|
*
|
|
|
|
* Based on mach-omap2/board-3430sdp.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/io.h>
|
|
|
|
#include <linux/gpio.h>
|
2010-02-18 05:09:32 +07:00
|
|
|
#include <linux/usb/otg.h>
|
2010-05-15 02:05:26 +07:00
|
|
|
#include <linux/spi/spi.h>
|
2010-05-12 15:27:30 +07:00
|
|
|
#include <linux/i2c/twl.h>
|
2010-09-24 08:22:49 +07:00
|
|
|
#include <linux/gpio_keys.h>
|
2010-05-12 15:27:30 +07:00
|
|
|
#include <linux/regulator/machine.h>
|
2011-07-05 17:38:23 +07:00
|
|
|
#include <linux/regulator/fixed.h>
|
2010-08-02 17:18:04 +07:00
|
|
|
#include <linux/leds.h>
|
2010-12-18 09:15:08 +07:00
|
|
|
#include <linux/leds_pwm.h>
|
2009-05-29 04:16:05 +07:00
|
|
|
|
|
|
|
#include <mach/hardware.h>
|
2011-09-06 16:23:45 +07:00
|
|
|
#include <asm/hardware/gic.h>
|
2009-05-29 04:16:05 +07:00
|
|
|
#include <asm/mach-types.h>
|
|
|
|
#include <asm/mach/arch.h>
|
|
|
|
#include <asm/mach/map.h>
|
|
|
|
|
2009-10-20 23:40:47 +07:00
|
|
|
#include <plat/board.h>
|
2011-11-11 04:45:17 +07:00
|
|
|
#include "common.h"
|
2010-02-18 05:09:32 +07:00
|
|
|
#include <plat/usb.h>
|
2010-05-16 01:21:06 +07:00
|
|
|
#include <plat/mmc.h>
|
2010-12-27 12:51:45 +07:00
|
|
|
#include <plat/omap4-keypad.h>
|
2011-05-11 18:05:07 +07:00
|
|
|
#include <video/omapdss.h>
|
2011-09-06 15:31:02 +07:00
|
|
|
#include <video/omap-panel-nokia-dsi.h>
|
2011-08-03 18:39:09 +07:00
|
|
|
#include <video/omap-panel-picodlp.h>
|
2011-07-05 17:38:23 +07:00
|
|
|
#include <linux/wl12xx.h>
|
2010-10-08 23:58:35 +07:00
|
|
|
|
2010-08-10 22:43:15 +07:00
|
|
|
#include "mux.h"
|
2010-05-16 01:21:06 +07:00
|
|
|
#include "hsmmc.h"
|
2010-10-09 00:40:20 +07:00
|
|
|
#include "control.h"
|
2011-04-25 05:09:06 +07:00
|
|
|
#include "common-board-devices.h"
|
2009-05-29 04:16:05 +07:00
|
|
|
|
2010-05-15 02:05:26 +07:00
|
|
|
#define ETH_KS8851_IRQ 34
|
|
|
|
#define ETH_KS8851_POWER_ON 48
|
|
|
|
#define ETH_KS8851_QUART 138
|
2010-09-24 08:22:49 +07:00
|
|
|
#define OMAP4_SFH7741_SENSOR_OUTPUT_GPIO 184
|
|
|
|
#define OMAP4_SFH7741_ENABLE_GPIO 188
|
2012-01-17 15:49:38 +07:00
|
|
|
#define HDMI_GPIO_CT_CP_HPD 60 /* HPD mode enable/disable */
|
2011-03-08 20:20:09 +07:00
|
|
|
#define HDMI_GPIO_LS_OE 41 /* Level shifter for HDMI */
|
2012-01-17 16:05:32 +07:00
|
|
|
#define HDMI_GPIO_HPD 63 /* Hotplug detect */
|
2011-09-06 15:31:02 +07:00
|
|
|
#define DISPLAY_SEL_GPIO 59 /* LCD2/PicoDLP switch */
|
2011-08-03 18:39:09 +07:00
|
|
|
#define DLP_POWER_ON_GPIO 40
|
2010-05-15 02:05:26 +07:00
|
|
|
|
2011-07-05 17:38:23 +07:00
|
|
|
#define GPIO_WIFI_PMENA 54
|
|
|
|
#define GPIO_WIFI_IRQ 53
|
|
|
|
|
2010-12-27 12:51:45 +07:00
|
|
|
static const int sdp4430_keymap[] = {
|
|
|
|
KEY(0, 0, KEY_E),
|
|
|
|
KEY(0, 1, KEY_R),
|
|
|
|
KEY(0, 2, KEY_T),
|
|
|
|
KEY(0, 3, KEY_HOME),
|
|
|
|
KEY(0, 4, KEY_F5),
|
|
|
|
KEY(0, 5, KEY_UNKNOWN),
|
|
|
|
KEY(0, 6, KEY_I),
|
|
|
|
KEY(0, 7, KEY_LEFTSHIFT),
|
|
|
|
|
|
|
|
KEY(1, 0, KEY_D),
|
|
|
|
KEY(1, 1, KEY_F),
|
|
|
|
KEY(1, 2, KEY_G),
|
|
|
|
KEY(1, 3, KEY_SEND),
|
|
|
|
KEY(1, 4, KEY_F6),
|
|
|
|
KEY(1, 5, KEY_UNKNOWN),
|
|
|
|
KEY(1, 6, KEY_K),
|
|
|
|
KEY(1, 7, KEY_ENTER),
|
|
|
|
|
|
|
|
KEY(2, 0, KEY_X),
|
|
|
|
KEY(2, 1, KEY_C),
|
|
|
|
KEY(2, 2, KEY_V),
|
|
|
|
KEY(2, 3, KEY_END),
|
|
|
|
KEY(2, 4, KEY_F7),
|
|
|
|
KEY(2, 5, KEY_UNKNOWN),
|
|
|
|
KEY(2, 6, KEY_DOT),
|
|
|
|
KEY(2, 7, KEY_CAPSLOCK),
|
|
|
|
|
|
|
|
KEY(3, 0, KEY_Z),
|
|
|
|
KEY(3, 1, KEY_KPPLUS),
|
|
|
|
KEY(3, 2, KEY_B),
|
|
|
|
KEY(3, 3, KEY_F1),
|
|
|
|
KEY(3, 4, KEY_F8),
|
|
|
|
KEY(3, 5, KEY_UNKNOWN),
|
|
|
|
KEY(3, 6, KEY_O),
|
|
|
|
KEY(3, 7, KEY_SPACE),
|
|
|
|
|
|
|
|
KEY(4, 0, KEY_W),
|
|
|
|
KEY(4, 1, KEY_Y),
|
|
|
|
KEY(4, 2, KEY_U),
|
|
|
|
KEY(4, 3, KEY_F2),
|
|
|
|
KEY(4, 4, KEY_VOLUMEUP),
|
|
|
|
KEY(4, 5, KEY_UNKNOWN),
|
|
|
|
KEY(4, 6, KEY_L),
|
|
|
|
KEY(4, 7, KEY_LEFT),
|
|
|
|
|
|
|
|
KEY(5, 0, KEY_S),
|
|
|
|
KEY(5, 1, KEY_H),
|
|
|
|
KEY(5, 2, KEY_J),
|
|
|
|
KEY(5, 3, KEY_F3),
|
|
|
|
KEY(5, 4, KEY_F9),
|
|
|
|
KEY(5, 5, KEY_VOLUMEDOWN),
|
|
|
|
KEY(5, 6, KEY_M),
|
|
|
|
KEY(5, 7, KEY_RIGHT),
|
|
|
|
|
|
|
|
KEY(6, 0, KEY_Q),
|
|
|
|
KEY(6, 1, KEY_A),
|
|
|
|
KEY(6, 2, KEY_N),
|
|
|
|
KEY(6, 3, KEY_BACK),
|
|
|
|
KEY(6, 4, KEY_BACKSPACE),
|
|
|
|
KEY(6, 5, KEY_UNKNOWN),
|
|
|
|
KEY(6, 6, KEY_P),
|
|
|
|
KEY(6, 7, KEY_UP),
|
|
|
|
|
|
|
|
KEY(7, 0, KEY_PROG1),
|
|
|
|
KEY(7, 1, KEY_PROG2),
|
|
|
|
KEY(7, 2, KEY_PROG3),
|
|
|
|
KEY(7, 3, KEY_PROG4),
|
|
|
|
KEY(7, 4, KEY_F4),
|
|
|
|
KEY(7, 5, KEY_UNKNOWN),
|
|
|
|
KEY(7, 6, KEY_OK),
|
|
|
|
KEY(7, 7, KEY_DOWN),
|
|
|
|
};
|
2011-10-01 01:05:56 +07:00
|
|
|
static struct omap_device_pad keypad_pads[] = {
|
2011-07-05 17:38:24 +07:00
|
|
|
{ .name = "kpd_col1.kpd_col1",
|
|
|
|
.enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_col1.kpd_col1",
|
|
|
|
.enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_col2.kpd_col2",
|
|
|
|
.enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_col3.kpd_col3",
|
|
|
|
.enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_col4.kpd_col4",
|
|
|
|
.enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_col5.kpd_col5",
|
|
|
|
.enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
|
|
|
|
},
|
|
|
|
{ .name = "gpmc_a23.kpd_col7",
|
|
|
|
.enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
|
|
|
|
},
|
|
|
|
{ .name = "gpmc_a22.kpd_col6",
|
|
|
|
.enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_row0.kpd_row0",
|
|
|
|
.enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
|
|
|
|
OMAP_MUX_MODE1 | OMAP_INPUT_EN,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_row1.kpd_row1",
|
|
|
|
.enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
|
|
|
|
OMAP_MUX_MODE1 | OMAP_INPUT_EN,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_row2.kpd_row2",
|
|
|
|
.enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
|
|
|
|
OMAP_MUX_MODE1 | OMAP_INPUT_EN,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_row3.kpd_row3",
|
|
|
|
.enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
|
|
|
|
OMAP_MUX_MODE1 | OMAP_INPUT_EN,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_row4.kpd_row4",
|
|
|
|
.enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
|
|
|
|
OMAP_MUX_MODE1 | OMAP_INPUT_EN,
|
|
|
|
},
|
|
|
|
{ .name = "kpd_row5.kpd_row5",
|
|
|
|
.enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
|
|
|
|
OMAP_MUX_MODE1 | OMAP_INPUT_EN,
|
|
|
|
},
|
|
|
|
{ .name = "gpmc_a18.kpd_row6",
|
|
|
|
.enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
|
|
|
|
OMAP_MUX_MODE1 | OMAP_INPUT_EN,
|
|
|
|
},
|
|
|
|
{ .name = "gpmc_a19.kpd_row7",
|
|
|
|
.enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
|
|
|
|
OMAP_MUX_MODE1 | OMAP_INPUT_EN,
|
|
|
|
},
|
|
|
|
};
|
2010-12-27 12:51:45 +07:00
|
|
|
|
|
|
|
static struct matrix_keymap_data sdp4430_keymap_data = {
|
|
|
|
.keymap = sdp4430_keymap,
|
|
|
|
.keymap_size = ARRAY_SIZE(sdp4430_keymap),
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap4_keypad_platform_data sdp4430_keypad_data = {
|
|
|
|
.keymap_data = &sdp4430_keymap_data,
|
|
|
|
.rows = 8,
|
|
|
|
.cols = 8,
|
|
|
|
};
|
2011-07-05 17:38:24 +07:00
|
|
|
|
|
|
|
static struct omap_board_data keypad_data = {
|
|
|
|
.id = 1,
|
|
|
|
.pads = keypad_pads,
|
|
|
|
.pads_cnt = ARRAY_SIZE(keypad_pads),
|
|
|
|
};
|
|
|
|
|
2010-08-02 17:18:04 +07:00
|
|
|
static struct gpio_led sdp4430_gpio_leds[] = {
|
|
|
|
{
|
|
|
|
.name = "omap4:green:debug0",
|
|
|
|
.gpio = 61,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "omap4:green:debug1",
|
|
|
|
.gpio = 30,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "omap4:green:debug2",
|
|
|
|
.gpio = 7,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "omap4:green:debug3",
|
|
|
|
.gpio = 8,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "omap4:green:debug4",
|
|
|
|
.gpio = 50,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "omap4:blue:user",
|
|
|
|
.gpio = 169,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "omap4:red:user",
|
|
|
|
.gpio = 170,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "omap4:green:user",
|
|
|
|
.gpio = 139,
|
|
|
|
},
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2010-09-24 08:22:49 +07:00
|
|
|
static struct gpio_keys_button sdp4430_gpio_keys[] = {
|
|
|
|
{
|
|
|
|
.desc = "Proximity Sensor",
|
|
|
|
.type = EV_SW,
|
|
|
|
.code = SW_FRONT_PROXIMITY,
|
|
|
|
.gpio = OMAP4_SFH7741_SENSOR_OUTPUT_GPIO,
|
|
|
|
.active_low = 0,
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-08-02 17:18:04 +07:00
|
|
|
static struct gpio_led_platform_data sdp4430_led_data = {
|
|
|
|
.leds = sdp4430_gpio_leds,
|
|
|
|
.num_leds = ARRAY_SIZE(sdp4430_gpio_leds),
|
|
|
|
};
|
|
|
|
|
2010-12-18 09:15:08 +07:00
|
|
|
static struct led_pwm sdp4430_pwm_leds[] = {
|
|
|
|
{
|
|
|
|
.name = "omap4:green:chrg",
|
|
|
|
.pwm_id = 1,
|
|
|
|
.max_brightness = 255,
|
|
|
|
.pwm_period_ns = 7812500,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct led_pwm_platform_data sdp4430_pwm_data = {
|
|
|
|
.num_leds = ARRAY_SIZE(sdp4430_pwm_leds),
|
|
|
|
.leds = sdp4430_pwm_leds,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device sdp4430_leds_pwm = {
|
|
|
|
.name = "leds_pwm",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &sdp4430_pwm_data,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-09-24 08:22:49 +07:00
|
|
|
static int omap_prox_activate(struct device *dev)
|
|
|
|
{
|
|
|
|
gpio_set_value(OMAP4_SFH7741_ENABLE_GPIO , 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_prox_deactivate(struct device *dev)
|
|
|
|
{
|
|
|
|
gpio_set_value(OMAP4_SFH7741_ENABLE_GPIO , 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct gpio_keys_platform_data sdp4430_gpio_keys_data = {
|
|
|
|
.buttons = sdp4430_gpio_keys,
|
|
|
|
.nbuttons = ARRAY_SIZE(sdp4430_gpio_keys),
|
|
|
|
.enable = omap_prox_activate,
|
|
|
|
.disable = omap_prox_deactivate,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device sdp4430_gpio_keys_device = {
|
|
|
|
.name = "gpio-keys",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &sdp4430_gpio_keys_data,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-08-02 17:18:04 +07:00
|
|
|
static struct platform_device sdp4430_leds_gpio = {
|
|
|
|
.name = "leds-gpio",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &sdp4430_led_data,
|
|
|
|
},
|
|
|
|
};
|
2010-05-15 02:05:26 +07:00
|
|
|
static struct spi_board_info sdp4430_spi_board_info[] __initdata = {
|
|
|
|
{
|
|
|
|
.modalias = "ks8851",
|
|
|
|
.bus_num = 1,
|
|
|
|
.chip_select = 0,
|
|
|
|
.max_speed_hz = 24000000,
|
|
|
|
.irq = ETH_KS8851_IRQ,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-05-03 22:22:09 +07:00
|
|
|
static struct gpio sdp4430_eth_gpios[] __initdata = {
|
|
|
|
{ ETH_KS8851_POWER_ON, GPIOF_OUT_INIT_HIGH, "eth_power" },
|
|
|
|
{ ETH_KS8851_QUART, GPIOF_OUT_INIT_HIGH, "quart" },
|
|
|
|
{ ETH_KS8851_IRQ, GPIOF_IN, "eth_irq" },
|
|
|
|
};
|
|
|
|
|
2011-05-30 14:11:45 +07:00
|
|
|
static int __init omap_ethernet_init(void)
|
2010-05-15 02:05:26 +07:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
/* Request of GPIO lines */
|
2011-05-03 22:22:09 +07:00
|
|
|
status = gpio_request_array(sdp4430_eth_gpios,
|
|
|
|
ARRAY_SIZE(sdp4430_eth_gpios));
|
|
|
|
if (status)
|
|
|
|
pr_err("Cannot request ETH GPIOs\n");
|
2010-05-15 02:05:26 +07:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-06-01 15:30:38 +07:00
|
|
|
static struct regulator_consumer_supply sdp4430_vbat_supply[] = {
|
|
|
|
REGULATOR_SUPPLY("vddvibl", "twl6040-vibra"),
|
|
|
|
REGULATOR_SUPPLY("vddvibr", "twl6040-vibra"),
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct regulator_init_data sdp4430_vbat_data = {
|
|
|
|
.constraints = {
|
|
|
|
.always_on = 1,
|
|
|
|
},
|
|
|
|
.num_consumer_supplies = ARRAY_SIZE(sdp4430_vbat_supply),
|
|
|
|
.consumer_supplies = sdp4430_vbat_supply,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct fixed_voltage_config sdp4430_vbat_pdata = {
|
|
|
|
.supply_name = "VBAT",
|
|
|
|
.microvolts = 3750000,
|
|
|
|
.init_data = &sdp4430_vbat_data,
|
|
|
|
.gpio = -EINVAL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device sdp4430_vbat = {
|
|
|
|
.name = "reg-fixed-voltage",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &sdp4430_vbat_pdata,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-12-14 01:48:54 +07:00
|
|
|
static struct platform_device sdp4430_dmic_codec = {
|
|
|
|
.name = "dmic-codec",
|
|
|
|
.id = -1,
|
|
|
|
};
|
|
|
|
|
2009-05-29 04:16:05 +07:00
|
|
|
static struct platform_device *sdp4430_devices[] __initdata = {
|
2010-09-24 08:22:49 +07:00
|
|
|
&sdp4430_gpio_keys_device,
|
2010-08-02 17:18:04 +07:00
|
|
|
&sdp4430_leds_gpio,
|
2010-12-18 09:15:08 +07:00
|
|
|
&sdp4430_leds_pwm,
|
2011-06-01 15:30:38 +07:00
|
|
|
&sdp4430_vbat,
|
2011-12-14 01:48:54 +07:00
|
|
|
&sdp4430_dmic_codec,
|
2009-05-29 04:16:05 +07:00
|
|
|
};
|
|
|
|
|
2010-02-18 05:09:32 +07:00
|
|
|
static struct omap_musb_board_data musb_board_data = {
|
|
|
|
.interface_type = MUSB_INTERFACE_UTMI,
|
2010-12-10 19:41:42 +07:00
|
|
|
.mode = MUSB_OTG,
|
2010-02-18 05:09:32 +07:00
|
|
|
.power = 100,
|
|
|
|
};
|
2010-05-16 01:21:06 +07:00
|
|
|
|
|
|
|
static struct omap2_hsmmc_info mmc[] = {
|
2010-05-12 15:27:30 +07:00
|
|
|
{
|
2010-05-16 01:21:06 +07:00
|
|
|
.mmc = 2,
|
2010-09-15 21:49:23 +07:00
|
|
|
.caps = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
|
2010-05-16 01:21:06 +07:00
|
|
|
.gpio_cd = -EINVAL,
|
|
|
|
.gpio_wp = -EINVAL,
|
|
|
|
.nonremovable = true,
|
2010-10-02 06:35:28 +07:00
|
|
|
.ocr_mask = MMC_VDD_29_30,
|
2011-05-30 21:25:34 +07:00
|
|
|
.no_off_init = true,
|
2010-05-12 15:27:30 +07:00
|
|
|
},
|
2011-02-28 22:18:05 +07:00
|
|
|
{
|
|
|
|
.mmc = 1,
|
|
|
|
.caps = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
|
2011-07-05 17:38:23 +07:00
|
|
|
.gpio_cd = -EINVAL,
|
2011-02-28 22:18:05 +07:00
|
|
|
.gpio_wp = -EINVAL,
|
|
|
|
},
|
2011-07-05 17:38:23 +07:00
|
|
|
{
|
|
|
|
.mmc = 5,
|
|
|
|
.caps = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
|
2011-11-22 21:02:19 +07:00
|
|
|
.pm_caps = MMC_PM_KEEP_POWER,
|
2011-07-05 17:38:23 +07:00
|
|
|
.gpio_cd = -EINVAL,
|
|
|
|
.gpio_wp = -EINVAL,
|
|
|
|
.ocr_mask = MMC_VDD_165_195,
|
|
|
|
.nonremovable = true,
|
|
|
|
},
|
2010-05-16 01:21:06 +07:00
|
|
|
{} /* Terminator */
|
|
|
|
};
|
|
|
|
|
2010-08-02 17:18:03 +07:00
|
|
|
static struct regulator_consumer_supply sdp4430_vaux_supply[] = {
|
2011-06-07 01:57:07 +07:00
|
|
|
REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
|
2010-08-02 17:18:03 +07:00
|
|
|
};
|
2011-06-07 01:57:07 +07:00
|
|
|
|
2011-07-05 17:38:23 +07:00
|
|
|
static struct regulator_consumer_supply omap4_sdp4430_vmmc5_supply = {
|
|
|
|
.supply = "vmmc",
|
|
|
|
.dev_name = "omap_hsmmc.4",
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct regulator_init_data sdp4430_vmmc5 = {
|
|
|
|
.constraints = {
|
|
|
|
.valid_ops_mask = REGULATOR_CHANGE_STATUS,
|
|
|
|
},
|
|
|
|
.num_consumer_supplies = 1,
|
|
|
|
.consumer_supplies = &omap4_sdp4430_vmmc5_supply,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct fixed_voltage_config sdp4430_vwlan = {
|
|
|
|
.supply_name = "vwl1271",
|
|
|
|
.microvolts = 1800000, /* 1.8V */
|
|
|
|
.gpio = GPIO_WIFI_PMENA,
|
|
|
|
.startup_delay = 70000, /* 70msec */
|
|
|
|
.enable_high = 1,
|
|
|
|
.enabled_at_boot = 0,
|
|
|
|
.init_data = &sdp4430_vmmc5,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device omap_vwlan_device = {
|
|
|
|
.name = "reg-fixed-voltage",
|
|
|
|
.id = 1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &sdp4430_vwlan,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-05-16 01:21:06 +07:00
|
|
|
static int omap4_twl6030_hsmmc_late_init(struct device *dev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct platform_device *pdev = container_of(dev,
|
|
|
|
struct platform_device, dev);
|
|
|
|
struct omap_mmc_platform_data *pdata = dev->platform_data;
|
|
|
|
|
|
|
|
/* Setting MMC1 Card detect Irq */
|
2010-09-25 00:13:20 +07:00
|
|
|
if (pdev->id == 0) {
|
|
|
|
ret = twl6030_mmc_card_detect_config();
|
|
|
|
if (ret)
|
|
|
|
pr_err("Failed configuring MMC1 card detect\n");
|
2010-05-16 01:21:06 +07:00
|
|
|
pdata->slots[0].card_detect_irq = TWL6030_IRQ_BASE +
|
|
|
|
MMCDETECT_INTR_OFFSET;
|
2010-09-25 00:13:20 +07:00
|
|
|
pdata->slots[0].card_detect = twl6030_mmc_card_detect;
|
|
|
|
}
|
2010-05-16 01:21:06 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __init void omap4_twl6030_hsmmc_set_late_init(struct device *dev)
|
|
|
|
{
|
2010-10-02 06:35:26 +07:00
|
|
|
struct omap_mmc_platform_data *pdata;
|
2010-05-16 01:21:06 +07:00
|
|
|
|
2010-10-02 06:35:26 +07:00
|
|
|
/* dev can be null if CONFIG_MMC_OMAP_HS is not set */
|
|
|
|
if (!dev) {
|
|
|
|
pr_err("Failed %s\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pdata = dev->platform_data;
|
2010-05-16 01:21:06 +07:00
|
|
|
pdata->init = omap4_twl6030_hsmmc_late_init;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init omap4_twl6030_hsmmc_init(struct omap2_hsmmc_info *controllers)
|
|
|
|
{
|
|
|
|
struct omap2_hsmmc_info *c;
|
|
|
|
|
|
|
|
omap2_hsmmc_init(controllers);
|
|
|
|
for (c = controllers; c->mmc; c++)
|
|
|
|
omap4_twl6030_hsmmc_set_late_init(c->dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-12 15:27:30 +07:00
|
|
|
static struct regulator_init_data sdp4430_vaux1 = {
|
|
|
|
.constraints = {
|
|
|
|
.min_uV = 1000000,
|
|
|
|
.max_uV = 3000000,
|
|
|
|
.apply_uV = true,
|
|
|
|
.valid_modes_mask = REGULATOR_MODE_NORMAL
|
|
|
|
| REGULATOR_MODE_STANDBY,
|
|
|
|
.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
|
|
|
|
| REGULATOR_CHANGE_MODE
|
|
|
|
| REGULATOR_CHANGE_STATUS,
|
|
|
|
},
|
2011-06-07 01:57:07 +07:00
|
|
|
.num_consumer_supplies = ARRAY_SIZE(sdp4430_vaux_supply),
|
2010-08-02 17:18:03 +07:00
|
|
|
.consumer_supplies = sdp4430_vaux_supply,
|
2010-05-12 15:27:30 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct regulator_init_data sdp4430_vusim = {
|
|
|
|
.constraints = {
|
|
|
|
.min_uV = 1200000,
|
|
|
|
.max_uV = 2900000,
|
|
|
|
.apply_uV = true,
|
|
|
|
.valid_modes_mask = REGULATOR_MODE_NORMAL
|
|
|
|
| REGULATOR_MODE_STANDBY,
|
|
|
|
.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
|
|
|
|
| REGULATOR_CHANGE_MODE
|
|
|
|
| REGULATOR_CHANGE_STATUS,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-02-12 08:50:37 +07:00
|
|
|
static struct twl4030_codec_data twl6040_codec = {
|
|
|
|
/* single-step ramp for headset and handsfree */
|
|
|
|
.hs_left_step = 0x0f,
|
|
|
|
.hs_right_step = 0x0f,
|
|
|
|
.hf_left_step = 0x1d,
|
|
|
|
.hf_right_step = 0x1d,
|
|
|
|
};
|
|
|
|
|
2011-06-01 15:30:38 +07:00
|
|
|
static struct twl4030_vibra_data twl6040_vibra = {
|
|
|
|
.vibldrv_res = 8,
|
|
|
|
.vibrdrv_res = 3,
|
|
|
|
.viblmotor_res = 10,
|
|
|
|
.vibrmotor_res = 10,
|
|
|
|
.vddvibl_uV = 0, /* fixed volt supply - VBAT */
|
|
|
|
.vddvibr_uV = 0, /* fixed volt supply - VBAT */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct twl4030_audio_data twl6040_audio = {
|
2011-02-12 08:50:37 +07:00
|
|
|
.codec = &twl6040_codec,
|
2011-06-01 15:30:38 +07:00
|
|
|
.vibra = &twl6040_vibra,
|
|
|
|
.audpwron_gpio = 127,
|
|
|
|
.naudint_irq = OMAP44XX_IRQ_SYS_2N,
|
|
|
|
.irq_base = TWL6040_CODEC_IRQ_BASE,
|
|
|
|
};
|
|
|
|
|
2010-05-12 15:27:30 +07:00
|
|
|
static struct twl4030_platform_data sdp4430_twldata = {
|
2011-06-01 15:30:38 +07:00
|
|
|
.audio = &twl6040_audio,
|
2010-05-12 15:27:30 +07:00
|
|
|
/* Regulators */
|
|
|
|
.vusim = &sdp4430_vusim,
|
|
|
|
.vaux1 = &sdp4430_vaux1,
|
|
|
|
};
|
|
|
|
|
2010-08-02 17:18:04 +07:00
|
|
|
static struct i2c_board_info __initdata sdp4430_i2c_3_boardinfo[] = {
|
|
|
|
{
|
|
|
|
I2C_BOARD_INFO("tmp105", 0x48),
|
|
|
|
},
|
2010-12-18 09:15:08 +07:00
|
|
|
{
|
|
|
|
I2C_BOARD_INFO("bh1780", 0x29),
|
|
|
|
},
|
2010-08-02 17:18:04 +07:00
|
|
|
};
|
2010-09-24 08:22:47 +07:00
|
|
|
static struct i2c_board_info __initdata sdp4430_i2c_4_boardinfo[] = {
|
|
|
|
{
|
|
|
|
I2C_BOARD_INFO("hmc5843", 0x1e),
|
|
|
|
},
|
|
|
|
};
|
2010-05-12 15:27:29 +07:00
|
|
|
static int __init omap4_i2c_init(void)
|
|
|
|
{
|
2011-06-07 14:26:46 +07:00
|
|
|
omap4_pmic_get_config(&sdp4430_twldata, TWL_COMMON_PDATA_USB,
|
|
|
|
TWL_COMMON_REGULATOR_VDAC |
|
|
|
|
TWL_COMMON_REGULATOR_VAUX2 |
|
|
|
|
TWL_COMMON_REGULATOR_VAUX3 |
|
|
|
|
TWL_COMMON_REGULATOR_VMMC |
|
|
|
|
TWL_COMMON_REGULATOR_VPP |
|
|
|
|
TWL_COMMON_REGULATOR_VANA |
|
|
|
|
TWL_COMMON_REGULATOR_VCXIO |
|
|
|
|
TWL_COMMON_REGULATOR_VUSB |
|
|
|
|
TWL_COMMON_REGULATOR_CLK32KG);
|
2011-04-25 05:09:06 +07:00
|
|
|
omap4_pmic_init("twl6030", &sdp4430_twldata);
|
2010-05-12 15:27:29 +07:00
|
|
|
omap_register_i2c_bus(2, 400, NULL, 0);
|
2010-08-02 17:18:04 +07:00
|
|
|
omap_register_i2c_bus(3, 400, sdp4430_i2c_3_boardinfo,
|
|
|
|
ARRAY_SIZE(sdp4430_i2c_3_boardinfo));
|
2010-09-24 08:22:47 +07:00
|
|
|
omap_register_i2c_bus(4, 400, sdp4430_i2c_4_boardinfo,
|
|
|
|
ARRAY_SIZE(sdp4430_i2c_4_boardinfo));
|
2010-05-12 15:27:29 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2010-09-24 08:22:49 +07:00
|
|
|
|
|
|
|
static void __init omap_sfh7741prox_init(void)
|
|
|
|
{
|
2011-05-03 22:22:09 +07:00
|
|
|
int error;
|
2010-09-24 08:22:49 +07:00
|
|
|
|
2011-05-03 22:22:09 +07:00
|
|
|
error = gpio_request_one(OMAP4_SFH7741_ENABLE_GPIO,
|
|
|
|
GPIOF_OUT_INIT_LOW, "sfh7741");
|
|
|
|
if (error < 0)
|
2010-09-24 08:22:49 +07:00
|
|
|
pr_err("%s:failed to request GPIO %d, error %d\n",
|
|
|
|
__func__, OMAP4_SFH7741_ENABLE_GPIO, error);
|
|
|
|
}
|
|
|
|
|
2011-05-03 22:22:09 +07:00
|
|
|
static struct gpio sdp4430_hdmi_gpios[] = {
|
2012-01-17 15:49:38 +07:00
|
|
|
{ HDMI_GPIO_CT_CP_HPD, GPIOF_OUT_INIT_HIGH, "hdmi_gpio_ct_cp_hpd" },
|
2011-05-03 22:22:09 +07:00
|
|
|
{ HDMI_GPIO_LS_OE, GPIOF_OUT_INIT_HIGH, "hdmi_gpio_ls_oe" },
|
2012-01-17 16:05:32 +07:00
|
|
|
{ HDMI_GPIO_HPD, GPIOF_DIR_IN, "hdmi_gpio_hpd" },
|
2011-05-03 22:22:09 +07:00
|
|
|
};
|
|
|
|
|
2011-03-08 20:20:09 +07:00
|
|
|
static int sdp4430_panel_enable_hdmi(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
2011-05-03 22:22:09 +07:00
|
|
|
status = gpio_request_array(sdp4430_hdmi_gpios,
|
|
|
|
ARRAY_SIZE(sdp4430_hdmi_gpios));
|
|
|
|
if (status)
|
|
|
|
pr_err("%s: Cannot request HDMI GPIOs\n", __func__);
|
2011-03-08 20:20:09 +07:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sdp4430_panel_disable_hdmi(struct omap_dss_device *dssdev)
|
|
|
|
{
|
2012-01-17 16:04:53 +07:00
|
|
|
gpio_free_array(sdp4430_hdmi_gpios, ARRAY_SIZE(sdp4430_hdmi_gpios));
|
2011-03-08 20:20:09 +07:00
|
|
|
}
|
|
|
|
|
2011-09-06 15:31:02 +07:00
|
|
|
static struct nokia_dsi_panel_data dsi1_panel = {
|
|
|
|
.name = "taal",
|
|
|
|
.reset_gpio = 102,
|
|
|
|
.use_ext_te = false,
|
|
|
|
.ext_te_gpio = 101,
|
|
|
|
.esd_interval = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_device sdp4430_lcd_device = {
|
|
|
|
.name = "lcd",
|
|
|
|
.driver_name = "taal",
|
|
|
|
.type = OMAP_DISPLAY_TYPE_DSI,
|
|
|
|
.data = &dsi1_panel,
|
|
|
|
.phy.dsi = {
|
|
|
|
.clk_lane = 1,
|
|
|
|
.clk_pol = 0,
|
|
|
|
.data1_lane = 2,
|
|
|
|
.data1_pol = 0,
|
|
|
|
.data2_lane = 3,
|
|
|
|
.data2_pol = 0,
|
|
|
|
|
|
|
|
.module = 0,
|
|
|
|
},
|
|
|
|
|
|
|
|
.clocks = {
|
|
|
|
.dispc = {
|
|
|
|
.channel = {
|
|
|
|
/* Logic Clock = 172.8 MHz */
|
|
|
|
.lck_div = 1,
|
|
|
|
/* Pixel Clock = 34.56 MHz */
|
|
|
|
.pck_div = 5,
|
|
|
|
.lcd_clk_src = OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC,
|
|
|
|
},
|
2011-04-12 15:22:25 +07:00
|
|
|
.dispc_fclk_src = OMAP_DSS_CLK_SRC_FCK,
|
|
|
|
},
|
2011-09-06 15:31:02 +07:00
|
|
|
|
|
|
|
.dsi = {
|
|
|
|
.regn = 16, /* Fint = 2.4 MHz */
|
|
|
|
.regm = 180, /* DDR Clock = 216 MHz */
|
|
|
|
.regm_dispc = 5, /* PLL1_CLK1 = 172.8 MHz */
|
|
|
|
.regm_dsi = 5, /* PLL1_CLK2 = 172.8 MHz */
|
|
|
|
|
|
|
|
.lp_clk_div = 10, /* LP Clock = 8.64 MHz */
|
|
|
|
.dsi_fclk_src = OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
.channel = OMAP_DSS_CHANNEL_LCD,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct nokia_dsi_panel_data dsi2_panel = {
|
|
|
|
.name = "taal",
|
|
|
|
.reset_gpio = 104,
|
|
|
|
.use_ext_te = false,
|
|
|
|
.ext_te_gpio = 103,
|
|
|
|
.esd_interval = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_device sdp4430_lcd2_device = {
|
|
|
|
.name = "lcd2",
|
|
|
|
.driver_name = "taal",
|
|
|
|
.type = OMAP_DISPLAY_TYPE_DSI,
|
|
|
|
.data = &dsi2_panel,
|
|
|
|
.phy.dsi = {
|
|
|
|
.clk_lane = 1,
|
|
|
|
.clk_pol = 0,
|
|
|
|
.data1_lane = 2,
|
|
|
|
.data1_pol = 0,
|
|
|
|
.data2_lane = 3,
|
|
|
|
.data2_pol = 0,
|
|
|
|
|
|
|
|
.module = 1,
|
|
|
|
},
|
|
|
|
|
|
|
|
.clocks = {
|
|
|
|
.dispc = {
|
|
|
|
.channel = {
|
|
|
|
/* Logic Clock = 172.8 MHz */
|
|
|
|
.lck_div = 1,
|
|
|
|
/* Pixel Clock = 34.56 MHz */
|
|
|
|
.pck_div = 5,
|
|
|
|
.lcd_clk_src = OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC,
|
|
|
|
},
|
|
|
|
.dispc_fclk_src = OMAP_DSS_CLK_SRC_FCK,
|
|
|
|
},
|
|
|
|
|
|
|
|
.dsi = {
|
|
|
|
.regn = 16, /* Fint = 2.4 MHz */
|
|
|
|
.regm = 180, /* DDR Clock = 216 MHz */
|
|
|
|
.regm_dispc = 5, /* PLL1_CLK1 = 172.8 MHz */
|
|
|
|
.regm_dsi = 5, /* PLL1_CLK2 = 172.8 MHz */
|
|
|
|
|
|
|
|
.lp_clk_div = 10, /* LP Clock = 8.64 MHz */
|
|
|
|
.dsi_fclk_src = OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DSI,
|
2011-04-12 15:22:25 +07:00
|
|
|
},
|
|
|
|
},
|
2011-09-06 15:31:02 +07:00
|
|
|
.channel = OMAP_DSS_CHANNEL_LCD2,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void sdp4430_lcd_init(void)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = gpio_request_one(dsi1_panel.reset_gpio, GPIOF_DIR_OUT,
|
|
|
|
"lcd1_reset_gpio");
|
|
|
|
if (r)
|
|
|
|
pr_err("%s: Could not get lcd1_reset_gpio\n", __func__);
|
|
|
|
|
|
|
|
r = gpio_request_one(dsi2_panel.reset_gpio, GPIOF_DIR_OUT,
|
|
|
|
"lcd2_reset_gpio");
|
|
|
|
if (r)
|
|
|
|
pr_err("%s: Could not get lcd2_reset_gpio\n", __func__);
|
|
|
|
}
|
|
|
|
|
OMAPDSS: HDMI: PHY burnout fix
A hardware bug in the OMAP4 HDMI PHY causes physical damage to the board
if the HDMI PHY is kept powered on when the cable is not connected.
This patch solves the problem by adding hot-plug-detection into the HDMI
IP driver. This is not a real HPD support in the sense that nobody else
than the IP driver gets to know about the HPD events, but is only meant
to fix the HW bug.
The strategy is simple: If the display device is turned off by the user,
the PHY power is set to OFF. When the display device is turned on by the
user, the PHY power is set either to LDOON or TXON, depending on whether
the HDMI cable is connected.
The reason to avoid PHY OFF when the display device is on, but the cable
is disconnected, is that when the PHY is turned OFF, the HDMI IP is not
"ticking" and thus the DISPC does not receive pixel clock from the HDMI
IP. This would, for example, prevent any VSYNCs from happening, and
would thus affect the users of omapdss. By using LDOON when the cable is
disconnected we'll avoid the HW bug, but keep the HDMI working as usual
from the user's point of view.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2012-01-17 16:09:57 +07:00
|
|
|
static struct omap_dss_hdmi_data sdp4430_hdmi_data = {
|
|
|
|
.hpd_gpio = HDMI_GPIO_HPD,
|
|
|
|
};
|
|
|
|
|
2011-03-08 20:20:09 +07:00
|
|
|
static struct omap_dss_device sdp4430_hdmi_device = {
|
|
|
|
.name = "hdmi",
|
|
|
|
.driver_name = "hdmi_panel",
|
|
|
|
.type = OMAP_DISPLAY_TYPE_HDMI,
|
|
|
|
.platform_enable = sdp4430_panel_enable_hdmi,
|
|
|
|
.platform_disable = sdp4430_panel_disable_hdmi,
|
|
|
|
.channel = OMAP_DSS_CHANNEL_DIGIT,
|
OMAPDSS: HDMI: PHY burnout fix
A hardware bug in the OMAP4 HDMI PHY causes physical damage to the board
if the HDMI PHY is kept powered on when the cable is not connected.
This patch solves the problem by adding hot-plug-detection into the HDMI
IP driver. This is not a real HPD support in the sense that nobody else
than the IP driver gets to know about the HPD events, but is only meant
to fix the HW bug.
The strategy is simple: If the display device is turned off by the user,
the PHY power is set to OFF. When the display device is turned on by the
user, the PHY power is set either to LDOON or TXON, depending on whether
the HDMI cable is connected.
The reason to avoid PHY OFF when the display device is on, but the cable
is disconnected, is that when the PHY is turned OFF, the HDMI IP is not
"ticking" and thus the DISPC does not receive pixel clock from the HDMI
IP. This would, for example, prevent any VSYNCs from happening, and
would thus affect the users of omapdss. By using LDOON when the cable is
disconnected we'll avoid the HW bug, but keep the HDMI working as usual
from the user's point of view.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2012-01-17 16:09:57 +07:00
|
|
|
.data = &sdp4430_hdmi_data,
|
2011-03-08 20:20:09 +07:00
|
|
|
};
|
|
|
|
|
2011-08-03 18:39:09 +07:00
|
|
|
static struct picodlp_panel_data sdp4430_picodlp_pdata = {
|
|
|
|
.picodlp_adapter_id = 2,
|
|
|
|
.emu_done_gpio = 44,
|
|
|
|
.pwrgood_gpio = 45,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void sdp4430_picodlp_init(void)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
const struct gpio picodlp_gpios[] = {
|
|
|
|
{DLP_POWER_ON_GPIO, GPIOF_OUT_INIT_LOW,
|
|
|
|
"DLP POWER ON"},
|
|
|
|
{sdp4430_picodlp_pdata.emu_done_gpio, GPIOF_IN,
|
|
|
|
"DLP EMU DONE"},
|
|
|
|
{sdp4430_picodlp_pdata.pwrgood_gpio, GPIOF_OUT_INIT_LOW,
|
|
|
|
"DLP PWRGOOD"},
|
|
|
|
};
|
|
|
|
|
|
|
|
r = gpio_request_array(picodlp_gpios, ARRAY_SIZE(picodlp_gpios));
|
|
|
|
if (r)
|
|
|
|
pr_err("Cannot request PicoDLP GPIOs, error %d\n", r);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sdp4430_panel_enable_picodlp(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
gpio_set_value(DISPLAY_SEL_GPIO, 0);
|
|
|
|
gpio_set_value(DLP_POWER_ON_GPIO, 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sdp4430_panel_disable_picodlp(struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
gpio_set_value(DLP_POWER_ON_GPIO, 0);
|
|
|
|
gpio_set_value(DISPLAY_SEL_GPIO, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct omap_dss_device sdp4430_picodlp_device = {
|
|
|
|
.name = "picodlp",
|
|
|
|
.driver_name = "picodlp_panel",
|
|
|
|
.type = OMAP_DISPLAY_TYPE_DPI,
|
|
|
|
.phy.dpi.data_lines = 24,
|
|
|
|
.channel = OMAP_DSS_CHANNEL_LCD2,
|
|
|
|
.platform_enable = sdp4430_panel_enable_picodlp,
|
|
|
|
.platform_disable = sdp4430_panel_disable_picodlp,
|
|
|
|
.data = &sdp4430_picodlp_pdata,
|
|
|
|
};
|
|
|
|
|
2011-03-08 20:20:09 +07:00
|
|
|
static struct omap_dss_device *sdp4430_dss_devices[] = {
|
2011-09-06 15:31:02 +07:00
|
|
|
&sdp4430_lcd_device,
|
|
|
|
&sdp4430_lcd2_device,
|
2011-03-08 20:20:09 +07:00
|
|
|
&sdp4430_hdmi_device,
|
2011-08-03 18:39:09 +07:00
|
|
|
&sdp4430_picodlp_device,
|
2011-03-08 20:20:09 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_dss_board_info sdp4430_dss_data = {
|
|
|
|
.num_devices = ARRAY_SIZE(sdp4430_dss_devices),
|
|
|
|
.devices = sdp4430_dss_devices,
|
2011-09-06 15:31:02 +07:00
|
|
|
.default_device = &sdp4430_lcd_device,
|
2011-03-08 20:20:09 +07:00
|
|
|
};
|
|
|
|
|
2011-09-06 15:31:02 +07:00
|
|
|
static void omap_4430sdp_display_init(void)
|
2011-03-08 20:20:09 +07:00
|
|
|
{
|
2011-09-06 15:31:02 +07:00
|
|
|
int r;
|
|
|
|
|
|
|
|
/* Enable LCD2 by default (instead of Pico DLP) */
|
|
|
|
r = gpio_request_one(DISPLAY_SEL_GPIO, GPIOF_OUT_INIT_HIGH,
|
|
|
|
"display_sel");
|
|
|
|
if (r)
|
|
|
|
pr_err("%s: Could not get display_sel GPIO\n", __func__);
|
|
|
|
|
|
|
|
sdp4430_lcd_init();
|
2011-08-03 18:39:09 +07:00
|
|
|
sdp4430_picodlp_init();
|
2011-03-08 20:20:09 +07:00
|
|
|
omap_display_init(&sdp4430_dss_data);
|
2012-01-02 15:32:38 +07:00
|
|
|
/*
|
|
|
|
* OMAP4460SDP/Blaze and OMAP4430 ES2.3 SDP/Blaze boards and
|
|
|
|
* later have external pull up on the HDMI I2C lines
|
|
|
|
*/
|
|
|
|
if (cpu_is_omap446x() || omap_rev() > OMAP4430_REV_ES2_2)
|
|
|
|
omap_hdmi_init(OMAP_HDMI_SDA_SCL_EXTERNAL_PULLUP);
|
|
|
|
else
|
|
|
|
omap_hdmi_init(0);
|
2012-01-17 16:02:36 +07:00
|
|
|
|
|
|
|
omap_mux_init_gpio(HDMI_GPIO_LS_OE, OMAP_PIN_OUTPUT);
|
|
|
|
omap_mux_init_gpio(HDMI_GPIO_CT_CP_HPD, OMAP_PIN_OUTPUT);
|
2012-01-17 16:05:32 +07:00
|
|
|
omap_mux_init_gpio(HDMI_GPIO_HPD, OMAP_PIN_INPUT_PULLDOWN);
|
2011-03-08 20:20:09 +07:00
|
|
|
}
|
|
|
|
|
2010-08-10 22:43:15 +07:00
|
|
|
#ifdef CONFIG_OMAP_MUX
|
|
|
|
static struct omap_board_mux board_mux[] __initdata = {
|
2011-01-12 06:31:45 +07:00
|
|
|
OMAP4_MUX(USBB2_ULPITLL_CLK, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT),
|
2010-08-10 22:43:15 +07:00
|
|
|
{ .reg_offset = OMAP_MUX_TERMINATOR },
|
|
|
|
};
|
2011-03-11 13:04:44 +07:00
|
|
|
|
2010-08-10 22:43:15 +07:00
|
|
|
#else
|
|
|
|
#define board_mux NULL
|
2011-03-11 13:04:44 +07:00
|
|
|
#endif
|
2010-08-10 22:43:15 +07:00
|
|
|
|
2012-02-07 18:07:24 +07:00
|
|
|
static void __init omap4_sdp4430_wifi_mux_init(void)
|
2011-07-05 17:38:23 +07:00
|
|
|
{
|
|
|
|
omap_mux_init_gpio(GPIO_WIFI_IRQ, OMAP_PIN_INPUT |
|
|
|
|
OMAP_PIN_OFF_WAKEUPENABLE);
|
|
|
|
omap_mux_init_gpio(GPIO_WIFI_PMENA, OMAP_PIN_OUTPUT);
|
|
|
|
|
|
|
|
omap_mux_init_signal("sdmmc5_cmd.sdmmc5_cmd",
|
|
|
|
OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
|
|
|
|
omap_mux_init_signal("sdmmc5_clk.sdmmc5_clk",
|
|
|
|
OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
|
|
|
|
omap_mux_init_signal("sdmmc5_dat0.sdmmc5_dat0",
|
|
|
|
OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
|
|
|
|
omap_mux_init_signal("sdmmc5_dat1.sdmmc5_dat1",
|
|
|
|
OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
|
|
|
|
omap_mux_init_signal("sdmmc5_dat2.sdmmc5_dat2",
|
|
|
|
OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
|
|
|
|
omap_mux_init_signal("sdmmc5_dat3.sdmmc5_dat3",
|
|
|
|
OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct wl12xx_platform_data omap4_sdp4430_wlan_data __initdata = {
|
|
|
|
.irq = OMAP_GPIO_IRQ(GPIO_WIFI_IRQ),
|
|
|
|
.board_ref_clock = WL12XX_REFCLOCK_26,
|
|
|
|
.board_tcxo_clock = WL12XX_TCXOCLOCK_26,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void omap4_sdp4430_wifi_init(void)
|
|
|
|
{
|
|
|
|
omap4_sdp4430_wifi_mux_init();
|
|
|
|
if (wl12xx_set_platform_data(&omap4_sdp4430_wlan_data))
|
|
|
|
pr_err("Error setting wl12xx data\n");
|
|
|
|
platform_device_register(&omap_vwlan_device);
|
|
|
|
}
|
|
|
|
|
2009-05-29 04:16:05 +07:00
|
|
|
static void __init omap_4430sdp_init(void)
|
|
|
|
{
|
2010-05-15 02:05:26 +07:00
|
|
|
int status;
|
2010-09-27 15:50:33 +07:00
|
|
|
int package = OMAP_PACKAGE_CBS;
|
|
|
|
|
|
|
|
if (omap_rev() == OMAP4430_REV_ES1_0)
|
|
|
|
package = OMAP_PACKAGE_CBL;
|
2011-05-05 04:57:57 +07:00
|
|
|
omap4_mux_init(board_mux, NULL, package);
|
2010-05-15 02:05:26 +07:00
|
|
|
|
2010-05-12 15:27:29 +07:00
|
|
|
omap4_i2c_init();
|
2010-09-24 08:22:49 +07:00
|
|
|
omap_sfh7741prox_init();
|
2009-05-29 04:16:05 +07:00
|
|
|
platform_add_devices(sdp4430_devices, ARRAY_SIZE(sdp4430_devices));
|
2011-11-07 20:25:05 +07:00
|
|
|
omap_serial_init();
|
2011-08-23 13:57:23 +07:00
|
|
|
omap_sdrc_init(NULL, NULL);
|
2011-07-05 17:38:23 +07:00
|
|
|
omap4_sdp4430_wifi_init();
|
2010-05-16 01:21:06 +07:00
|
|
|
omap4_twl6030_hsmmc_init(mmc);
|
2010-11-22 00:53:42 +07:00
|
|
|
|
2010-12-07 14:57:59 +07:00
|
|
|
usb_musb_init(&musb_board_data);
|
2010-05-15 02:05:26 +07:00
|
|
|
|
|
|
|
status = omap_ethernet_init();
|
|
|
|
if (status) {
|
|
|
|
pr_err("Ethernet initialization failed: %d\n", status);
|
|
|
|
} else {
|
|
|
|
sdp4430_spi_board_info[0].irq = gpio_to_irq(ETH_KS8851_IRQ);
|
|
|
|
spi_register_board_info(sdp4430_spi_board_info,
|
|
|
|
ARRAY_SIZE(sdp4430_spi_board_info));
|
|
|
|
}
|
2010-12-27 12:51:45 +07:00
|
|
|
|
2011-07-05 17:38:24 +07:00
|
|
|
status = omap4_keyboard_init(&sdp4430_keypad_data, &keypad_data);
|
2010-12-27 12:51:45 +07:00
|
|
|
if (status)
|
|
|
|
pr_err("Keypad initialization failed: %d\n", status);
|
2011-03-08 20:20:09 +07:00
|
|
|
|
|
|
|
omap_4430sdp_display_init();
|
2009-05-29 04:16:05 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
MACHINE_START(OMAP_4430SDP, "OMAP4430 4430SDP board")
|
|
|
|
/* Maintainer: Santosh Shilimkar - Texas Instruments Inc */
|
2011-07-06 09:38:15 +07:00
|
|
|
.atag_offset = 0x100,
|
2010-05-23 16:18:16 +07:00
|
|
|
.reserve = omap_reserve,
|
2011-09-27 04:52:55 +07:00
|
|
|
.map_io = omap4_map_io,
|
2011-08-23 13:57:24 +07:00
|
|
|
.init_early = omap4430_init_early,
|
2011-02-15 06:40:20 +07:00
|
|
|
.init_irq = gic_init_irq,
|
2011-09-06 16:23:45 +07:00
|
|
|
.handle_irq = gic_handle_irq,
|
2009-05-29 04:16:05 +07:00
|
|
|
.init_machine = omap_4430sdp_init,
|
2011-03-30 05:54:48 +07:00
|
|
|
.timer = &omap4_timer,
|
2011-11-06 00:06:28 +07:00
|
|
|
.restart = omap_prcm_restart,
|
2009-05-29 04:16:05 +07:00
|
|
|
MACHINE_END
|