| /* Copyright (c) 2011, Code Aurora Forum. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only 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. |
| */ |
| |
| #include <linux/kernel.h> |
| #include <linux/init.h> |
| #include <linux/gpio_event.h> |
| #include <linux/usb/android.h> |
| #include <linux/platform_device.h> |
| #include <linux/io.h> |
| #include <linux/gpio.h> |
| #include <linux/mtd/nand.h> |
| #include <linux/mtd/partitions.h> |
| #include <linux/i2c.h> |
| #include <linux/android_pmem.h> |
| #include <linux/bootmem.h> |
| #include <linux/mfd/marimba.h> |
| #include <linux/power_supply.h> |
| #include <linux/input/rmi_platformdata.h> |
| #include <linux/input/rmi_i2c.h> |
| #include <linux/regulator/consumer.h> |
| #include <asm/mach/mmc.h> |
| #include <asm/mach-types.h> |
| #include <asm/mach/arch.h> |
| #include <mach/board.h> |
| #include <mach/msm_iomap.h> |
| #include <mach/msm_hsusb.h> |
| #include <mach/rpc_hsusb.h> |
| #include <mach/rpc_pmapp.h> |
| #include <mach/usbdiag.h> |
| #include <mach/usb_gadget_fserial.h> |
| #include <mach/msm_memtypes.h> |
| #include <mach/msm_serial_hs.h> |
| #include <mach/pmic.h> |
| #include <mach/socinfo.h> |
| #include <mach/vreg.h> |
| #include <mach/rpc_pmapp.h> |
| #include <mach/msm_battery.h> |
| #include <mach/rpc_server_handset.h> |
| #include <mach/socinfo.h> |
| #include "board-msm7x27a-regulator.h" |
| #include "devices.h" |
| #include "devices-msm7x2xa.h" |
| #include "pm.h" |
| #include "timer.h" |
| #include "pm-boot.h" |
| #include "board-msm7x27a-regulator.h" |
| |
| #define PMEM_KERNEL_EBI1_SIZE 0x3A000 |
| #define MSM_PMEM_AUDIO_SIZE 0x5B000 |
| #define BAHAMA_SLAVE_ID_FM_ADDR 0x2A |
| #define BAHAMA_SLAVE_ID_QMEMBIST_ADDR 0x7B |
| #define BAHAMA_SLAVE_ID_FM_REG 0x02 |
| #define FM_GPIO 83 |
| |
| enum { |
| GPIO_HOST_VBUS_EN = 107, |
| GPIO_BT_SYS_REST_EN = 114, |
| GPIO_WAKE_ON_WIRELESS, |
| GPIO_BACKLIGHT_EN, |
| GPIO_NC, |
| GPIO_CAM_3MP_PWDN, /* CAM_VGA */ |
| GPIO_WLAN_EN, |
| GPIO_CAM_5MP_SHDN_EN, |
| GPIO_CAM_5MP_RESET, |
| GPIO_TP, |
| GPIO_CAM_GP_CAMIF_RESET, |
| }; |
| |
| /* FM Platform power and shutdown routines */ |
| #define FPGA_MSM_CNTRL_REG2 0x90008010 |
| |
| static void config_pcm_i2s_mode(int mode) |
| { |
| void __iomem *cfg_ptr; |
| u8 reg2; |
| |
| cfg_ptr = ioremap_nocache(FPGA_MSM_CNTRL_REG2, sizeof(char)); |
| |
| if (!cfg_ptr) |
| return; |
| if (mode) { |
| /*enable the pcm mode in FPGA*/ |
| reg2 = readb_relaxed(cfg_ptr); |
| if (reg2 == 0) { |
| reg2 = 1; |
| writeb_relaxed(reg2, cfg_ptr); |
| } |
| } else { |
| /*enable i2s mode in FPGA*/ |
| reg2 = readb_relaxed(cfg_ptr); |
| if (reg2 == 1) { |
| reg2 = 0; |
| writeb_relaxed(reg2, cfg_ptr); |
| } |
| } |
| iounmap(cfg_ptr); |
| } |
| |
| static unsigned fm_i2s_config_power_on[] = { |
| /*FM_I2S_SD*/ |
| GPIO_CFG(68, 1, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| /*FM_I2S_WS*/ |
| GPIO_CFG(70, 1, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| /*FM_I2S_SCK*/ |
| GPIO_CFG(71, 1, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| }; |
| |
| static unsigned fm_i2s_config_power_off[] = { |
| /*FM_I2S_SD*/ |
| GPIO_CFG(68, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| /*FM_I2S_WS*/ |
| GPIO_CFG(70, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| /*FM_I2S_SCK*/ |
| GPIO_CFG(71, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| }; |
| |
| static unsigned bt_config_power_on[] = { |
| /*RFR*/ |
| GPIO_CFG(43, 2, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| /*CTS*/ |
| GPIO_CFG(44, 2, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| /*RX*/ |
| GPIO_CFG(45, 2, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| /*TX*/ |
| GPIO_CFG(46, 2, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| }; |
| static unsigned bt_config_pcm_on[] = { |
| /*PCM_DOUT*/ |
| GPIO_CFG(68, 1, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| /*PCM_DIN*/ |
| GPIO_CFG(69, 1, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| /*PCM_SYNC*/ |
| GPIO_CFG(70, 1, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| /*PCM_CLK*/ |
| GPIO_CFG(71, 1, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| }; |
| static unsigned bt_config_power_off[] = { |
| /*RFR*/ |
| GPIO_CFG(43, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| /*CTS*/ |
| GPIO_CFG(44, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| /*RX*/ |
| GPIO_CFG(45, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| /*TX*/ |
| GPIO_CFG(46, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| }; |
| static unsigned bt_config_pcm_off[] = { |
| /*PCM_DOUT*/ |
| GPIO_CFG(68, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| /*PCM_DIN*/ |
| GPIO_CFG(69, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| /*PCM_SYNC*/ |
| GPIO_CFG(70, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| /*PCM_CLK*/ |
| GPIO_CFG(71, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| }; |
| |
| |
| static int config_i2s(int mode) |
| { |
| int pin, rc = 0; |
| |
| if (mode == FM_I2S_ON) { |
| if (machine_is_msm7627a_qrd1()) |
| config_pcm_i2s_mode(0); |
| pr_err("%s mode = FM_I2S_ON", __func__); |
| for (pin = 0; pin < ARRAY_SIZE(fm_i2s_config_power_on); |
| pin++) { |
| rc = gpio_tlmm_config( |
| fm_i2s_config_power_on[pin], |
| GPIO_CFG_ENABLE |
| ); |
| if (rc < 0) |
| return rc; |
| } |
| } else if (mode == FM_I2S_OFF) { |
| pr_err("%s mode = FM_I2S_OFF", __func__); |
| for (pin = 0; pin < ARRAY_SIZE(fm_i2s_config_power_off); |
| pin++) { |
| rc = gpio_tlmm_config( |
| fm_i2s_config_power_off[pin], |
| GPIO_CFG_ENABLE |
| ); |
| if (rc < 0) |
| return rc; |
| } |
| } |
| return rc; |
| } |
| static int config_pcm(int mode) |
| { |
| int pin, rc = 0; |
| |
| if (mode == BT_PCM_ON) { |
| if (machine_is_msm7627a_qrd1()) |
| config_pcm_i2s_mode(1); |
| pr_err("%s mode =BT_PCM_ON", __func__); |
| for (pin = 0; pin < ARRAY_SIZE(bt_config_pcm_on); |
| pin++) { |
| rc = gpio_tlmm_config(bt_config_pcm_on[pin], |
| GPIO_CFG_ENABLE); |
| if (rc < 0) |
| return rc; |
| } |
| } else if (mode == BT_PCM_OFF) { |
| pr_err("%s mode =BT_PCM_OFF", __func__); |
| for (pin = 0; pin < ARRAY_SIZE(bt_config_pcm_off); |
| pin++) { |
| rc = gpio_tlmm_config(bt_config_pcm_off[pin], |
| GPIO_CFG_ENABLE); |
| if (rc < 0) |
| return rc; |
| } |
| |
| } |
| |
| return rc; |
| } |
| |
| static int msm_bahama_setup_pcm_i2s(int mode) |
| { |
| int fm_state = 0, bt_state = 0; |
| int rc = 0; |
| struct marimba config = { .mod_id = SLAVE_ID_BAHAMA}; |
| |
| fm_state = marimba_get_fm_status(&config); |
| bt_state = marimba_get_bt_status(&config); |
| |
| switch (mode) { |
| case BT_PCM_ON: |
| case BT_PCM_OFF: |
| if (!fm_state) |
| rc = config_pcm(mode); |
| break; |
| case FM_I2S_ON: |
| rc = config_i2s(mode); |
| break; |
| case FM_I2S_OFF: |
| if (bt_state) |
| rc = config_pcm(BT_PCM_ON); |
| else |
| rc = config_i2s(mode); |
| break; |
| default: |
| rc = -EIO; |
| pr_err("%s:Unsupported mode", __func__); |
| } |
| return rc; |
| } |
| |
| static int bt_set_gpio(int on) |
| { |
| int rc = 0; |
| struct marimba config = { .mod_id = SLAVE_ID_BAHAMA}; |
| |
| if (on) { |
| rc = gpio_direction_output(GPIO_BT_SYS_REST_EN, 1); |
| msleep(100); |
| } else { |
| if (!marimba_get_fm_status(&config) && |
| !marimba_get_bt_status(&config)) { |
| gpio_set_value_cansleep(GPIO_BT_SYS_REST_EN, 0); |
| rc = gpio_direction_input(GPIO_BT_SYS_REST_EN); |
| msleep(100); |
| } |
| } |
| if (rc) |
| pr_err("%s: BT sys_reset_en GPIO : Error", __func__); |
| |
| return rc; |
| } |
| static struct regulator *fm_regulator; |
| static int fm_radio_setup(struct marimba_fm_platform_data *pdata) |
| { |
| int rc = 0; |
| const char *id = "FMPW"; |
| uint32_t irqcfg; |
| struct marimba config = { .mod_id = SLAVE_ID_BAHAMA}; |
| u8 value; |
| |
| /* Voting for 1.8V Regulator */ |
| fm_regulator = regulator_get(NULL , "msme1"); |
| if (IS_ERR(fm_regulator)) { |
| rc = PTR_ERR(fm_regulator); |
| pr_err("%s: could not get regulator: %d\n", __func__, rc); |
| goto out; |
| } |
| |
| /* Set the voltage level to 1.8V */ |
| rc = regulator_set_voltage(fm_regulator, 1800000, 1800000); |
| if (rc < 0) { |
| pr_err("%s: could not set voltage: %d\n", __func__, rc); |
| goto reg_free; |
| } |
| |
| /* Enabling the 1.8V regulator */ |
| rc = regulator_enable(fm_regulator); |
| if (rc) { |
| pr_err("%s: could not enable regulator: %d\n", __func__, rc); |
| goto reg_free; |
| } |
| |
| /* Voting for 19.2MHz clock */ |
| rc = pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1, |
| PMAPP_CLOCK_VOTE_ON); |
| if (rc < 0) { |
| pr_err("%s: clock vote failed with :(%d)\n", |
| __func__, rc); |
| goto reg_disable; |
| } |
| |
| rc = bt_set_gpio(1); |
| if (rc) { |
| pr_err("%s: bt_set_gpio = %d", __func__, rc); |
| goto gpio_deconfig; |
| } |
| /*re-write FM Slave Id, after reset*/ |
| value = BAHAMA_SLAVE_ID_FM_ADDR; |
| rc = marimba_write_bit_mask(&config, |
| BAHAMA_SLAVE_ID_FM_REG, &value, 1, 0xFF); |
| if (rc < 0) { |
| pr_err("%s: FM Slave ID rewrite Failed = %d", __func__, rc); |
| goto gpio_deconfig; |
| } |
| /* Configuring the FM GPIO */ |
| irqcfg = GPIO_CFG(FM_GPIO, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, |
| GPIO_CFG_2MA); |
| |
| rc = gpio_tlmm_config(irqcfg, GPIO_CFG_ENABLE); |
| if (rc) { |
| pr_err("%s: gpio_tlmm_config(%#x)=%d\n", |
| __func__, irqcfg, rc); |
| goto gpio_deconfig; |
| } |
| |
| return 0; |
| |
| gpio_deconfig: |
| pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1, |
| PMAPP_CLOCK_VOTE_OFF); |
| bt_set_gpio(0); |
| reg_disable: |
| regulator_disable(fm_regulator); |
| reg_free: |
| regulator_put(fm_regulator); |
| fm_regulator = NULL; |
| out: |
| return rc; |
| }; |
| |
| static void fm_radio_shutdown(struct marimba_fm_platform_data *pdata) |
| { |
| int rc; |
| const char *id = "FMPW"; |
| |
| /* Releasing the GPIO line used by FM */ |
| uint32_t irqcfg = GPIO_CFG(FM_GPIO, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, |
| GPIO_CFG_2MA); |
| |
| rc = gpio_tlmm_config(irqcfg, GPIO_CFG_ENABLE); |
| if (rc) |
| pr_err("%s: gpio_tlmm_config(%#x)=%d\n", |
| __func__, irqcfg, rc); |
| |
| /* Releasing the 1.8V Regulator */ |
| if (!IS_ERR_OR_NULL(fm_regulator)) { |
| rc = regulator_disable(fm_regulator); |
| if (rc) |
| pr_err("%s: could not disable regulator: %d\n", |
| __func__, rc); |
| regulator_put(fm_regulator); |
| fm_regulator = NULL; |
| } |
| |
| /* Voting off the clock */ |
| rc = pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1, |
| PMAPP_CLOCK_VOTE_OFF); |
| if (rc < 0) |
| pr_err("%s: voting off failed with :(%d)\n", |
| __func__, rc); |
| rc = bt_set_gpio(0); |
| if (rc) |
| pr_err("%s: bt_set_gpio = %d", __func__, rc); |
| } |
| |
| static struct marimba_fm_platform_data marimba_fm_pdata = { |
| .fm_setup = fm_radio_setup, |
| .fm_shutdown = fm_radio_shutdown, |
| .irq = MSM_GPIO_TO_INT(FM_GPIO), |
| .vreg_s2 = NULL, |
| .vreg_xo_out = NULL, |
| /* Configuring the FM SoC as I2S Master */ |
| .is_fm_soc_i2s_master = true, |
| .config_i2s_gpio = msm_bahama_setup_pcm_i2s, |
| }; |
| |
| static struct platform_device msm_wlan_ar6000_pm_device = { |
| .name = "wlan_ar6000_pm_dev", |
| .id = -1, |
| }; |
| |
| #if defined(CONFIG_BT) && defined(CONFIG_MARIMBA_CORE) |
| |
| static struct platform_device msm_bt_power_device = { |
| .name = "bt_power", |
| }; |
| struct bahama_config_register { |
| u8 reg; |
| u8 value; |
| u8 mask; |
| }; |
| struct bt_vreg_info { |
| const char *name; |
| unsigned int pmapp_id; |
| unsigned int min_level; |
| unsigned int max_level; |
| unsigned int is_pin_controlled; |
| struct regulator *reg; |
| }; |
| static struct bt_vreg_info bt_vregs[] = { |
| {"msme1", 2, 1800000, 1800000, 0, NULL}, |
| {"bt", 21, 2900000, 3050000, 1, NULL} |
| }; |
| |
| static int bahama_bt(int on) |
| { |
| int rc = 0; |
| int i; |
| |
| struct marimba config = { .mod_id = SLAVE_ID_BAHAMA}; |
| |
| struct bahama_variant_register { |
| const size_t size; |
| const struct bahama_config_register *set; |
| }; |
| |
| const struct bahama_config_register *p; |
| |
| u8 version; |
| |
| const struct bahama_config_register v10_bt_on[] = { |
| { 0xE9, 0x00, 0xFF }, |
| { 0xF4, 0x80, 0xFF }, |
| { 0xE4, 0x00, 0xFF }, |
| { 0xE5, 0x00, 0x0F }, |
| #ifdef CONFIG_WLAN |
| { 0xE6, 0x38, 0x7F }, |
| { 0xE7, 0x06, 0xFF }, |
| #endif |
| { 0xE9, 0x21, 0xFF }, |
| { 0x01, 0x0C, 0x1F }, |
| { 0x01, 0x08, 0x1F }, |
| }; |
| |
| const struct bahama_config_register v20_bt_on_fm_off[] = { |
| { 0x11, 0x0C, 0xFF }, |
| { 0x13, 0x01, 0xFF }, |
| { 0xF4, 0x80, 0xFF }, |
| { 0xF0, 0x00, 0xFF }, |
| { 0xE9, 0x00, 0xFF }, |
| #ifdef CONFIG_WLAN |
| { 0x81, 0x00, 0x7F }, |
| { 0x82, 0x00, 0xFF }, |
| { 0xE6, 0x38, 0x7F }, |
| { 0xE7, 0x06, 0xFF }, |
| #endif |
| { 0x8E, 0x15, 0xFF }, |
| { 0x8F, 0x15, 0xFF }, |
| { 0x90, 0x15, 0xFF }, |
| |
| { 0xE9, 0x21, 0xFF }, |
| }; |
| |
| const struct bahama_config_register v20_bt_on_fm_on[] = { |
| { 0x11, 0x0C, 0xFF }, |
| { 0x13, 0x01, 0xFF }, |
| { 0xF4, 0x86, 0xFF }, |
| { 0xF0, 0x06, 0xFF }, |
| { 0xE9, 0x00, 0xFF }, |
| #ifdef CONFIG_WLAN |
| { 0x81, 0x00, 0x7F }, |
| { 0x82, 0x00, 0xFF }, |
| { 0xE6, 0x38, 0x7F }, |
| { 0xE7, 0x06, 0xFF }, |
| #endif |
| { 0xE9, 0x21, 0xFF }, |
| }; |
| |
| const struct bahama_config_register v10_bt_off[] = { |
| { 0xE9, 0x00, 0xFF }, |
| }; |
| |
| const struct bahama_config_register v20_bt_off_fm_off[] = { |
| { 0xF4, 0x84, 0xFF }, |
| { 0xF0, 0x04, 0xFF }, |
| { 0xE9, 0x00, 0xFF } |
| }; |
| |
| const struct bahama_config_register v20_bt_off_fm_on[] = { |
| { 0xF4, 0x86, 0xFF }, |
| { 0xF0, 0x06, 0xFF }, |
| { 0xE9, 0x00, 0xFF } |
| }; |
| const struct bahama_variant_register bt_bahama[2][3] = { |
| { |
| { ARRAY_SIZE(v10_bt_off), v10_bt_off }, |
| { ARRAY_SIZE(v20_bt_off_fm_off), v20_bt_off_fm_off }, |
| { ARRAY_SIZE(v20_bt_off_fm_on), v20_bt_off_fm_on } |
| }, |
| { |
| { ARRAY_SIZE(v10_bt_on), v10_bt_on }, |
| { ARRAY_SIZE(v20_bt_on_fm_off), v20_bt_on_fm_off }, |
| { ARRAY_SIZE(v20_bt_on_fm_on), v20_bt_on_fm_on } |
| } |
| }; |
| |
| u8 offset = 0; /* index into bahama configs */ |
| on = on ? 1 : 0; |
| version = marimba_read_bahama_ver(&config); |
| if ((int)version < 0 || version == BAHAMA_VER_UNSUPPORTED) { |
| dev_err(&msm_bt_power_device.dev, "%s: Bahama \ |
| version read Error, version = %d \n", |
| __func__, version); |
| return -EIO; |
| } |
| |
| if (version == BAHAMA_VER_2_0) { |
| if (marimba_get_fm_status(&config)) |
| offset = 0x01; |
| } |
| |
| p = bt_bahama[on][version + offset].set; |
| |
| dev_info(&msm_bt_power_device.dev, |
| "%s: found version %d\n", __func__, version); |
| |
| for (i = 0; i < bt_bahama[on][version + offset].size; i++) { |
| u8 value = (p+i)->value; |
| rc = marimba_write_bit_mask(&config, |
| (p+i)->reg, |
| &value, |
| sizeof((p+i)->value), |
| (p+i)->mask); |
| if (rc < 0) { |
| dev_err(&msm_bt_power_device.dev, |
| "%s: reg %x write failed: %d\n", |
| __func__, (p+i)->reg, rc); |
| return rc; |
| } |
| dev_dbg(&msm_bt_power_device.dev, |
| "%s: reg 0x%02x write value 0x%02x mask 0x%02x\n", |
| __func__, (p+i)->reg, |
| value, (p+i)->mask); |
| value = 0; |
| rc = marimba_read_bit_mask(&config, |
| (p+i)->reg, &value, |
| sizeof((p+i)->value), (p+i)->mask); |
| if (rc < 0) |
| dev_err(&msm_bt_power_device.dev, "%s marimba_read_bit_mask- error", |
| __func__); |
| dev_dbg(&msm_bt_power_device.dev, |
| "%s: reg 0x%02x read value 0x%02x mask 0x%02x\n", |
| __func__, (p+i)->reg, |
| value, (p+i)->mask); |
| } |
| /* Update BT Status */ |
| if (on) |
| marimba_set_bt_status(&config, true); |
| else |
| marimba_set_bt_status(&config, false); |
| return rc; |
| } |
| static int bluetooth_switch_regulators(int on) |
| { |
| int i, rc = 0; |
| const char *id = "BTPW"; |
| |
| for (i = 0; i < ARRAY_SIZE(bt_vregs); i++) { |
| if (IS_ERR_OR_NULL(bt_vregs[i].reg)) { |
| rc = bt_vregs[i].reg ? |
| PTR_ERR(bt_vregs[i].reg) : |
| -ENODEV; |
| dev_err(&msm_bt_power_device.dev, |
| "%s: invalid regulator handle for %s: %d\n", |
| __func__, bt_vregs[i].name, rc); |
| goto reg_disable; |
| } |
| |
| rc = on ? regulator_set_voltage(bt_vregs[i].reg, |
| bt_vregs[i].min_level, |
| bt_vregs[i].max_level) : 0; |
| if (rc) { |
| dev_err(&msm_bt_power_device.dev, |
| "%s: could not set voltage for %s: %d\n", |
| __func__, bt_vregs[i].name, rc); |
| goto reg_disable; |
| } |
| |
| rc = on ? regulator_enable(bt_vregs[i].reg) : 0; |
| if (rc) { |
| dev_err(&msm_bt_power_device.dev, |
| "%s: could not %sable regulator %s: %d\n", |
| __func__, "en", bt_vregs[i].name, rc); |
| goto reg_disable; |
| } |
| |
| if (bt_vregs[i].is_pin_controlled) { |
| rc = pmapp_vreg_lpm_pincntrl_vote(id, |
| bt_vregs[i].pmapp_id, |
| PMAPP_CLOCK_ID_D1, |
| on ? PMAPP_CLOCK_VOTE_ON : |
| PMAPP_CLOCK_VOTE_OFF); |
| if (rc) { |
| dev_err(&msm_bt_power_device.dev, |
| "%s: pin control failed for %s: %d\n", |
| __func__, bt_vregs[i].name, rc); |
| goto pin_cnt_fail; |
| } |
| } |
| rc = on ? 0 : regulator_disable(bt_vregs[i].reg); |
| |
| if (rc) { |
| dev_err(&msm_bt_power_device.dev, |
| "%s: could not %sable regulator %s: %d\n", |
| __func__, "dis", bt_vregs[i].name, rc); |
| goto reg_disable; |
| } |
| } |
| |
| return rc; |
| pin_cnt_fail: |
| if (on) |
| regulator_disable(bt_vregs[i].reg); |
| reg_disable: |
| while (i) { |
| if (on) { |
| i--; |
| regulator_disable(bt_vregs[i].reg); |
| regulator_put(bt_vregs[i].reg); |
| } |
| } |
| return rc; |
| } |
| |
| static struct regulator *reg_s3; |
| static unsigned int msm_bahama_setup_power(void) |
| { |
| int rc = 0; |
| |
| reg_s3 = regulator_get(NULL, "msme1"); |
| if (IS_ERR(reg_s3)) { |
| rc = PTR_ERR(reg_s3); |
| pr_err("%s: could not get regulator: %d\n", __func__, rc); |
| goto out; |
| } |
| |
| rc = regulator_set_voltage(reg_s3, 1800000, 1800000); |
| if (rc < 0) { |
| pr_err("%s: could not set voltage: %d\n", __func__, rc); |
| goto reg_fail; |
| } |
| |
| rc = regulator_enable(reg_s3); |
| if (rc < 0) { |
| pr_err("%s: could not enable regulator: %d\n", __func__, rc); |
| goto reg_fail; |
| } |
| |
| /*setup Bahama_sys_reset_n*/ |
| rc = gpio_request(GPIO_BT_SYS_REST_EN, "bahama sys_rst_n"); |
| if (rc < 0) { |
| pr_err("%s: gpio_request %d = %d\n", __func__, |
| GPIO_BT_SYS_REST_EN, rc); |
| goto reg_disable; |
| } |
| |
| rc = bt_set_gpio(1); |
| if (rc < 0) { |
| pr_err("%s: bt_set_gpio %d = %d\n", __func__, |
| GPIO_BT_SYS_REST_EN, rc); |
| goto gpio_fail; |
| } |
| |
| return rc; |
| |
| gpio_fail: |
| gpio_free(GPIO_BT_SYS_REST_EN); |
| reg_disable: |
| regulator_disable(reg_s3); |
| reg_fail: |
| regulator_put(reg_s3); |
| out: |
| reg_s3 = NULL; |
| return rc; |
| } |
| |
| static unsigned int msm_bahama_shutdown_power(int value) |
| { |
| int rc = 0; |
| |
| if (IS_ERR_OR_NULL(reg_s3)) { |
| rc = reg_s3 ? PTR_ERR(reg_s3) : -ENODEV; |
| goto out; |
| } |
| |
| rc = regulator_disable(reg_s3); |
| if (rc) { |
| pr_err("%s: could not disable regulator: %d\n", __func__, rc); |
| goto out; |
| } |
| |
| if (value == BAHAMA_ID) { |
| rc = bt_set_gpio(0); |
| if (rc) { |
| pr_err("%s: bt_set_gpio = %d\n", |
| __func__, rc); |
| goto reg_enable; |
| } |
| gpio_free(GPIO_BT_SYS_REST_EN); |
| } |
| |
| regulator_put(reg_s3); |
| reg_s3 = NULL; |
| |
| return 0; |
| |
| reg_enable: |
| regulator_enable(reg_s3); |
| out: |
| return rc; |
| } |
| |
| static unsigned int msm_bahama_core_config(int type) |
| { |
| int rc = 0; |
| |
| if (type == BAHAMA_ID) { |
| int i; |
| struct marimba config = { .mod_id = SLAVE_ID_BAHAMA}; |
| const struct bahama_config_register v20_init[] = { |
| /* reg, value, mask */ |
| { 0xF4, 0x84, 0xFF }, /* AREG */ |
| { 0xF0, 0x04, 0xFF } /* DREG */ |
| }; |
| if (marimba_read_bahama_ver(&config) == BAHAMA_VER_2_0) { |
| for (i = 0; i < ARRAY_SIZE(v20_init); i++) { |
| u8 value = v20_init[i].value; |
| rc = marimba_write_bit_mask(&config, |
| v20_init[i].reg, |
| &value, |
| sizeof(v20_init[i].value), |
| v20_init[i].mask); |
| if (rc < 0) { |
| pr_err("%s: reg %d write failed: %d\n", |
| __func__, v20_init[i].reg, rc); |
| return rc; |
| } |
| pr_debug("%s: reg 0x%02x value 0x%02x" |
| " mask 0x%02x\n", |
| __func__, v20_init[i].reg, |
| v20_init[i].value, v20_init[i].mask); |
| } |
| } |
| } |
| rc = bt_set_gpio(0); |
| if (rc) { |
| pr_err("%s: bt_set_gpio = %d\n", |
| __func__, rc); |
| } |
| pr_debug("core type: %d\n", type); |
| return rc; |
| } |
| |
| static int bluetooth_power(int on) |
| { |
| int pin, rc = 0; |
| const char *id = "BTPW"; |
| int cid = 0; |
| |
| cid = adie_get_detected_connectivity_type(); |
| if (cid != BAHAMA_ID) { |
| pr_err("%s: unexpected adie connectivity type: %d\n", |
| __func__, cid); |
| return -ENODEV; |
| } |
| if (on) { |
| /*setup power for BT SOC*/ |
| rc = bt_set_gpio(on); |
| if (rc) { |
| pr_err("%s: bt_set_gpio = %d\n", |
| __func__, rc); |
| goto exit; |
| } |
| rc = bluetooth_switch_regulators(on); |
| if (rc < 0) { |
| pr_err("%s: bluetooth_switch_regulators rc = %d", |
| __func__, rc); |
| goto exit; |
| } |
| /*setup BT GPIO lines*/ |
| for (pin = 0; pin < ARRAY_SIZE(bt_config_power_on); |
| pin++) { |
| rc = gpio_tlmm_config(bt_config_power_on[pin], |
| GPIO_CFG_ENABLE); |
| if (rc < 0) { |
| pr_err("%s: gpio_tlmm_config(%#x)=%d\n", |
| __func__, |
| bt_config_power_on[pin], |
| rc); |
| goto fail_power; |
| } |
| } |
| /*Setup BT clocks*/ |
| rc = pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1, |
| PMAPP_CLOCK_VOTE_ON); |
| if (rc < 0) { |
| pr_err("Failed to vote for TCXO_D1 ON\n"); |
| goto fail_clock; |
| } |
| msleep(20); |
| |
| /*I2C config for Bahama*/ |
| rc = bahama_bt(1); |
| if (rc < 0) { |
| pr_err("%s: bahama_bt rc = %d", __func__, rc); |
| goto fail_i2c; |
| } |
| msleep(20); |
| |
| /*setup BT PCM lines*/ |
| rc = msm_bahama_setup_pcm_i2s(BT_PCM_ON); |
| if (rc < 0) { |
| pr_err("%s: msm_bahama_setup_pcm_i2s , rc =%d\n", |
| __func__, rc); |
| goto fail_power; |
| } |
| rc = pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1, |
| PMAPP_CLOCK_VOTE_PIN_CTRL); |
| if (rc < 0) |
| pr_err("%s:Pin Control Failed, rc = %d", |
| __func__, rc); |
| |
| } else { |
| rc = bahama_bt(0); |
| if (rc < 0) |
| pr_err("%s: bahama_bt rc = %d", __func__, rc); |
| |
| rc = bt_set_gpio(on); |
| if (rc) { |
| pr_err("%s: bt_set_gpio = %d\n", |
| __func__, rc); |
| } |
| fail_i2c: |
| rc = pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1, |
| PMAPP_CLOCK_VOTE_OFF); |
| if (rc < 0) |
| pr_err("%s: Failed to vote Off D1\n", __func__); |
| fail_clock: |
| for (pin = 0; pin < ARRAY_SIZE(bt_config_power_off); |
| pin++) { |
| rc = gpio_tlmm_config(bt_config_power_off[pin], |
| GPIO_CFG_ENABLE); |
| if (rc < 0) { |
| pr_err("%s: gpio_tlmm_config(%#x)=%d\n", |
| __func__, bt_config_power_off[pin], rc); |
| } |
| } |
| rc = msm_bahama_setup_pcm_i2s(BT_PCM_OFF); |
| if (rc < 0) { |
| pr_err("%s: msm_bahama_setup_pcm_i2s, rc =%d\n", |
| __func__, rc); |
| } |
| fail_power: |
| rc = bluetooth_switch_regulators(0); |
| if (rc < 0) { |
| pr_err("%s: switch_regulators : rc = %d",\ |
| __func__, rc); |
| goto exit; |
| } |
| } |
| return rc; |
| exit: |
| pr_err("%s: failed with rc = %d", __func__, rc); |
| return rc; |
| } |
| |
| static int __init bt_power_init(void) |
| { |
| int i, rc = 0; |
| struct device *dev = &msm_bt_power_device.dev; |
| |
| for (i = 0; i < ARRAY_SIZE(bt_vregs); i++) { |
| bt_vregs[i].reg = regulator_get(dev, bt_vregs[i].name); |
| if (IS_ERR(bt_vregs[i].reg)) { |
| rc = PTR_ERR(bt_vregs[i].reg); |
| dev_err(dev, "%s: could not get regulator %s: %d\n", |
| __func__, bt_vregs[i].name, rc); |
| goto reg_get_fail; |
| } |
| } |
| |
| dev->platform_data = &bluetooth_power; |
| |
| return rc; |
| |
| reg_get_fail: |
| while (i--) { |
| regulator_put(bt_vregs[i].reg); |
| bt_vregs[i].reg = NULL; |
| } |
| return rc; |
| } |
| |
| static struct marimba_platform_data marimba_pdata = { |
| .slave_id[SLAVE_ID_BAHAMA_FM] = BAHAMA_SLAVE_ID_FM_ADDR, |
| .slave_id[SLAVE_ID_BAHAMA_QMEMBIST] = BAHAMA_SLAVE_ID_QMEMBIST_ADDR, |
| .bahama_setup = msm_bahama_setup_power, |
| .bahama_shutdown = msm_bahama_shutdown_power, |
| .bahama_core_config = msm_bahama_core_config, |
| .fm = &marimba_fm_pdata, |
| }; |
| |
| #endif |
| |
| #if defined(CONFIG_BT) && defined(CONFIG_MARIMBA_CORE) |
| static struct i2c_board_info bahama_devices[] = { |
| { |
| I2C_BOARD_INFO("marimba", 0xc), |
| .platform_data = &marimba_pdata, |
| }, |
| }; |
| #endif |
| |
| static struct msm_gpio qup_i2c_gpios_io[] = { |
| { GPIO_CFG(60, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "qup_scl" }, |
| { GPIO_CFG(61, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "qup_sda" }, |
| { GPIO_CFG(131, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "qup_scl" }, |
| { GPIO_CFG(132, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "qup_sda" }, |
| }; |
| |
| static struct msm_gpio qup_i2c_gpios_hw[] = { |
| { GPIO_CFG(60, 1, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "qup_scl" }, |
| { GPIO_CFG(61, 1, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "qup_sda" }, |
| { GPIO_CFG(131, 2, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "qup_scl" }, |
| { GPIO_CFG(132, 2, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "qup_sda" }, |
| }; |
| |
| static void gsbi_qup_i2c_gpio_config(int adap_id, int config_type) |
| { |
| int rc; |
| |
| if (adap_id < 0 || adap_id > 1) |
| return; |
| |
| /* Each adapter gets 2 lines from the table */ |
| if (config_type) |
| rc = msm_gpios_request_enable(&qup_i2c_gpios_hw[adap_id*2], 2); |
| else |
| rc = msm_gpios_request_enable(&qup_i2c_gpios_io[adap_id*2], 2); |
| if (rc < 0) |
| pr_err("QUP GPIO request/enable failed: %d\n", rc); |
| } |
| |
| static struct msm_i2c_platform_data msm_gsbi0_qup_i2c_pdata = { |
| .clk_freq = 100000, |
| .msm_i2c_config_gpio = gsbi_qup_i2c_gpio_config, |
| }; |
| |
| static struct msm_i2c_platform_data msm_gsbi1_qup_i2c_pdata = { |
| .clk_freq = 100000, |
| .msm_i2c_config_gpio = gsbi_qup_i2c_gpio_config, |
| }; |
| |
| #ifdef CONFIG_ARCH_MSM7X27A |
| #define MSM_PMEM_MDP_SIZE 0x1DD1000 |
| #define MSM_PMEM_ADSP_SIZE 0x1000000 |
| |
| #ifdef CONFIG_FB_MSM_TRIPLE_BUFFER |
| #define MSM_FB_SIZE 0x260000 |
| #else |
| #define MSM_FB_SIZE 0x195000 |
| #endif |
| |
| #endif |
| |
| #if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_RMI4_I2C) || \ |
| defined(CONFIG_TOUCHSCREEN_SYNAPTICS_RMI4_I2C_MODULE) |
| |
| #ifndef CLEARPAD3000_ATTEN_GPIO |
| #define CLEARPAD3000_ATTEN_GPIO (48) |
| #endif |
| |
| #ifndef CLEARPAD3000_RESET_GPIO |
| #define CLEARPAD3000_RESET_GPIO (26) |
| #endif |
| |
| static int synaptics_touchpad_setup(void); |
| |
| static struct msm_gpio clearpad3000_cfg_data[] = { |
| {GPIO_CFG(CLEARPAD3000_ATTEN_GPIO, 0, GPIO_CFG_INPUT, |
| GPIO_CFG_NO_PULL, GPIO_CFG_6MA), "rmi4_attn"}, |
| {GPIO_CFG(CLEARPAD3000_RESET_GPIO, 0, GPIO_CFG_OUTPUT, |
| GPIO_CFG_PULL_DOWN, GPIO_CFG_8MA), "rmi4_reset"}, |
| }; |
| |
| static struct rmi_XY_pair rmi_offset = {.x = 0, .y = 0}; |
| static struct rmi_range rmi_clipx = {.min = 48, .max = 980}; |
| static struct rmi_range rmi_clipy = {.min = 7, .max = 1647}; |
| static struct rmi_f11_functiondata synaptics_f11_data = { |
| .swap_axes = false, |
| .flipX = false, |
| .flipY = false, |
| .offset = &rmi_offset, |
| .button_height = 113, |
| .clipX = &rmi_clipx, |
| .clipY = &rmi_clipy, |
| }; |
| |
| #define MAX_LEN 100 |
| |
| static ssize_t clearpad3000_virtual_keys_register(struct kobject *kobj, |
| struct kobj_attribute *attr, char *buf) |
| { |
| char *virtual_keys = __stringify(EV_KEY) ":" __stringify(KEY_MENU) \ |
| ":60:830:120:60" ":" __stringify(EV_KEY) \ |
| ":" __stringify(KEY_HOME) ":180:830:120:60" \ |
| ":" __stringify(EV_KEY) ":" \ |
| __stringify(KEY_SEARCH) ":300:830:120:60" \ |
| ":" __stringify(EV_KEY) ":" \ |
| __stringify(KEY_BACK) ":420:830:120:60" "\n"; |
| |
| return snprintf(buf, strnlen(virtual_keys, MAX_LEN) + 1 , "%s", |
| virtual_keys); |
| } |
| |
| static struct kobj_attribute clearpad3000_virtual_keys_attr = { |
| .attr = { |
| .name = "virtualkeys.sensor00fn11", |
| .mode = S_IRUGO, |
| }, |
| .show = &clearpad3000_virtual_keys_register, |
| }; |
| |
| static struct attribute *virtual_key_properties_attrs[] = { |
| &clearpad3000_virtual_keys_attr.attr, |
| NULL |
| }; |
| |
| static struct attribute_group virtual_key_properties_attr_group = { |
| .attrs = virtual_key_properties_attrs, |
| }; |
| |
| struct kobject *virtual_key_properties_kobj; |
| |
| static struct rmi_functiondata synaptics_functiondata[] = { |
| { |
| .function_index = RMI_F11_INDEX, |
| .data = &synaptics_f11_data, |
| }, |
| }; |
| |
| static struct rmi_functiondata_list synaptics_perfunctiondata = { |
| .count = ARRAY_SIZE(synaptics_functiondata), |
| .functiondata = synaptics_functiondata, |
| }; |
| |
| static struct rmi_sensordata synaptics_sensordata = { |
| .perfunctiondata = &synaptics_perfunctiondata, |
| .rmi_sensor_setup = synaptics_touchpad_setup, |
| }; |
| |
| static struct rmi_i2c_platformdata synaptics_platformdata = { |
| .i2c_address = 0x2c, |
| .irq_type = IORESOURCE_IRQ_LOWLEVEL, |
| .sensordata = &synaptics_sensordata, |
| }; |
| |
| static struct i2c_board_info synaptic_i2c_clearpad3k[] = { |
| { |
| I2C_BOARD_INFO("rmi4_ts", 0x2c), |
| .platform_data = &synaptics_platformdata, |
| }, |
| }; |
| |
| static int synaptics_touchpad_setup(void) |
| { |
| int retval = 0; |
| |
| virtual_key_properties_kobj = |
| kobject_create_and_add("board_properties", NULL); |
| if (virtual_key_properties_kobj) |
| retval = sysfs_create_group(virtual_key_properties_kobj, |
| &virtual_key_properties_attr_group); |
| if (!virtual_key_properties_kobj || retval) |
| pr_err("failed to create ft5202 board_properties\n"); |
| |
| retval = msm_gpios_request_enable(clearpad3000_cfg_data, |
| sizeof(clearpad3000_cfg_data)/sizeof(struct msm_gpio)); |
| if (retval) { |
| pr_err("%s:Failed to obtain touchpad GPIO %d. Code: %d.", |
| __func__, CLEARPAD3000_ATTEN_GPIO, retval); |
| retval = 0; /* ignore the err */ |
| } |
| synaptics_platformdata.irq = gpio_to_irq(CLEARPAD3000_ATTEN_GPIO); |
| |
| gpio_set_value(CLEARPAD3000_RESET_GPIO, 0); |
| usleep(10000); |
| gpio_set_value(CLEARPAD3000_RESET_GPIO, 1); |
| usleep(50000); |
| |
| return retval; |
| } |
| #endif |
| |
| |
| static struct android_usb_platform_data android_usb_pdata = { |
| .update_pid_and_serial_num = usb_diag_update_pid_and_serial_num, |
| }; |
| |
| static struct platform_device android_usb_device = { |
| .name = "android_usb", |
| .id = -1, |
| .dev = { |
| .platform_data = &android_usb_pdata, |
| }, |
| }; |
| |
| #ifdef CONFIG_USB_EHCI_MSM_72K |
| static void msm_hsusb_vbus_power(unsigned phy_info, int on) |
| { |
| int rc = 0; |
| unsigned gpio; |
| |
| gpio = GPIO_HOST_VBUS_EN; |
| |
| rc = gpio_request(gpio, "i2c_host_vbus_en"); |
| if (rc < 0) { |
| pr_err("failed to request %d GPIO\n", gpio); |
| return; |
| } |
| gpio_direction_output(gpio, !!on); |
| gpio_set_value_cansleep(gpio, !!on); |
| gpio_free(gpio); |
| } |
| |
| static struct msm_usb_host_platform_data msm_usb_host_pdata = { |
| .phy_info = (USB_PHY_INTEGRATED | USB_PHY_MODEL_45NM), |
| }; |
| |
| static void __init msm7627a_init_host(void) |
| { |
| msm_add_host(0, &msm_usb_host_pdata); |
| } |
| #endif |
| |
| #ifdef CONFIG_USB_MSM_OTG_72K |
| static int hsusb_rpc_connect(int connect) |
| { |
| if (connect) |
| return msm_hsusb_rpc_connect(); |
| else |
| return msm_hsusb_rpc_close(); |
| } |
| |
| static struct regulator *reg_hsusb; |
| static int msm_hsusb_ldo_init(int init) |
| { |
| int rc = 0; |
| |
| if (init) { |
| reg_hsusb = regulator_get(NULL, "usb"); |
| if (IS_ERR(reg_hsusb)) { |
| rc = PTR_ERR(reg_hsusb); |
| pr_err("%s: could not get regulator: %d\n", |
| __func__, rc); |
| goto out; |
| } |
| |
| rc = regulator_set_voltage(reg_hsusb, 3300000, 3300000); |
| if (rc) { |
| pr_err("%s: could not set voltage: %d\n", |
| __func__, rc); |
| goto reg_free; |
| } |
| |
| return 0; |
| } |
| /* else fall through */ |
| reg_free: |
| regulator_put(reg_hsusb); |
| out: |
| reg_hsusb = NULL; |
| return rc; |
| } |
| |
| static int msm_hsusb_ldo_enable(int enable) |
| { |
| static int ldo_status; |
| |
| if (IS_ERR_OR_NULL(reg_hsusb)) |
| return reg_hsusb ? PTR_ERR(reg_hsusb) : -ENODEV; |
| |
| if (ldo_status == enable) |
| return 0; |
| |
| ldo_status = enable; |
| |
| return enable ? |
| regulator_enable(reg_hsusb) : |
| regulator_disable(reg_hsusb); |
| } |
| |
| #ifndef CONFIG_USB_EHCI_MSM_72K |
| static int msm_hsusb_pmic_notif_init(void (*callback)(int online), int init) |
| { |
| int ret = 0; |
| |
| if (init) |
| ret = msm_pm_app_rpc_init(callback); |
| else |
| msm_pm_app_rpc_deinit(callback); |
| |
| return ret; |
| } |
| #endif |
| |
| static struct msm_otg_platform_data msm_otg_pdata = { |
| #ifndef CONFIG_USB_EHCI_MSM_72K |
| .pmic_vbus_notif_init = msm_hsusb_pmic_notif_init, |
| #else |
| .vbus_power = msm_hsusb_vbus_power, |
| #endif |
| .rpc_connect = hsusb_rpc_connect, |
| .core_clk = 1, |
| .pemp_level = PRE_EMPHASIS_WITH_20_PERCENT, |
| .cdr_autoreset = CDR_AUTO_RESET_DISABLE, |
| .drv_ampl = HS_DRV_AMPLITUDE_DEFAULT, |
| .se1_gating = SE1_GATING_DISABLE, |
| .ldo_init = msm_hsusb_ldo_init, |
| .ldo_enable = msm_hsusb_ldo_enable, |
| .chg_init = hsusb_chg_init, |
| .chg_connected = hsusb_chg_connected, |
| .chg_vbus_draw = hsusb_chg_vbus_draw, |
| }; |
| #endif |
| |
| static struct msm_hsusb_gadget_platform_data msm_gadget_pdata = { |
| .is_phy_status_timer_on = 1, |
| }; |
| |
| #if (defined(CONFIG_MMC_MSM_SDC1_SUPPORT)\ |
| || defined(CONFIG_MMC_MSM_SDC2_SUPPORT)\ |
| || defined(CONFIG_MMC_MSM_SDC3_SUPPORT)\ |
| || defined(CONFIG_MMC_MSM_SDC4_SUPPORT)) |
| |
| static unsigned long vreg_sts, gpio_sts; |
| |
| struct sdcc_gpio { |
| struct msm_gpio *cfg_data; |
| uint32_t size; |
| struct msm_gpio *sleep_cfg_data; |
| }; |
| |
| /** |
| * Due to insufficient drive strengths for SDC GPIO lines some old versioned |
| * SD/MMC cards may cause data CRC errors. Hence, set optimal values |
| * for SDC slots based on timing closure and marginality. SDC1 slot |
| * require higher value since it should handle bad signal quality due |
| * to size of T-flash adapters. |
| */ |
| static struct msm_gpio sdc1_cfg_data[] = { |
| {GPIO_CFG(51, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_14MA), |
| "sdc1_dat_3"}, |
| {GPIO_CFG(52, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_14MA), |
| "sdc1_dat_2"}, |
| {GPIO_CFG(53, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_14MA), |
| "sdc1_dat_1"}, |
| {GPIO_CFG(54, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_14MA), |
| "sdc1_dat_0"}, |
| {GPIO_CFG(55, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_14MA), |
| "sdc1_cmd"}, |
| {GPIO_CFG(56, 1, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_14MA), |
| "sdc1_clk"}, |
| }; |
| |
| static struct msm_gpio sdc2_cfg_data[] = { |
| {GPIO_CFG(62, 2, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "sdc2_clk"}, |
| {GPIO_CFG(63, 2, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc2_cmd"}, |
| {GPIO_CFG(64, 2, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc2_dat_3"}, |
| {GPIO_CFG(65, 2, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc2_dat_2"}, |
| {GPIO_CFG(66, 2, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc2_dat_1"}, |
| {GPIO_CFG(67, 2, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc2_dat_0"}, |
| }; |
| |
| static struct msm_gpio sdc2_sleep_cfg_data[] = { |
| {GPIO_CFG(62, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| "sdc2_clk"}, |
| {GPIO_CFG(63, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| "sdc2_cmd"}, |
| {GPIO_CFG(64, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| "sdc2_dat_3"}, |
| {GPIO_CFG(65, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| "sdc2_dat_2"}, |
| {GPIO_CFG(66, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| "sdc2_dat_1"}, |
| {GPIO_CFG(67, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| "sdc2_dat_0"}, |
| }; |
| static struct msm_gpio sdc3_cfg_data[] = { |
| {GPIO_CFG(88, 1, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "sdc3_clk"}, |
| {GPIO_CFG(89, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_cmd"}, |
| {GPIO_CFG(90, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_dat_3"}, |
| {GPIO_CFG(91, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_dat_2"}, |
| {GPIO_CFG(92, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_dat_1"}, |
| {GPIO_CFG(93, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_dat_0"}, |
| #ifdef CONFIG_MMC_MSM_SDC3_8_BIT_SUPPORT |
| {GPIO_CFG(19, 3, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_dat_7"}, |
| {GPIO_CFG(20, 3, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_dat_6"}, |
| {GPIO_CFG(21, 3, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_dat_5"}, |
| {GPIO_CFG(108, 3, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc3_dat_4"}, |
| #endif |
| }; |
| |
| static struct msm_gpio sdc4_cfg_data[] = { |
| {GPIO_CFG(19, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc4_dat_3"}, |
| {GPIO_CFG(20, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc4_dat_2"}, |
| {GPIO_CFG(21, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc4_dat_1"}, |
| {GPIO_CFG(107, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc4_cmd"}, |
| {GPIO_CFG(108, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_10MA), |
| "sdc4_dat_0"}, |
| {GPIO_CFG(109, 1, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), |
| "sdc4_clk"}, |
| }; |
| |
| static struct sdcc_gpio sdcc_cfg_data[] = { |
| { |
| .cfg_data = sdc1_cfg_data, |
| .size = ARRAY_SIZE(sdc1_cfg_data), |
| }, |
| { |
| .cfg_data = sdc2_cfg_data, |
| .size = ARRAY_SIZE(sdc2_cfg_data), |
| .sleep_cfg_data = sdc2_sleep_cfg_data, |
| }, |
| { |
| .cfg_data = sdc3_cfg_data, |
| .size = ARRAY_SIZE(sdc3_cfg_data), |
| }, |
| { |
| .cfg_data = sdc4_cfg_data, |
| .size = ARRAY_SIZE(sdc4_cfg_data), |
| }, |
| }; |
| |
| static struct regulator *sdcc_vreg_data[ARRAY_SIZE(sdcc_cfg_data)]; |
| static int msm_sdcc_setup_gpio(int dev_id, unsigned int enable) |
| { |
| int rc = 0; |
| struct sdcc_gpio *curr; |
| |
| curr = &sdcc_cfg_data[dev_id - 1]; |
| if (!(test_bit(dev_id, &gpio_sts)^enable)) |
| return rc; |
| |
| if (enable) { |
| set_bit(dev_id, &gpio_sts); |
| rc = msm_gpios_request_enable(curr->cfg_data, curr->size); |
| if (rc) |
| pr_err("%s: Failed to turn on GPIOs for slot %d\n", |
| __func__, dev_id); |
| } else { |
| clear_bit(dev_id, &gpio_sts); |
| if (curr->sleep_cfg_data) { |
| rc = msm_gpios_enable(curr->sleep_cfg_data, curr->size); |
| msm_gpios_free(curr->sleep_cfg_data, curr->size); |
| return rc; |
| } |
| msm_gpios_disable_free(curr->cfg_data, curr->size); |
| } |
| return rc; |
| } |
| |
| static int msm_sdcc_setup_vreg(int dev_id, unsigned int enable) |
| { |
| int rc = 0; |
| struct regulator *curr = sdcc_vreg_data[dev_id - 1]; |
| |
| if (test_bit(dev_id, &vreg_sts) == enable) |
| return 0; |
| |
| if (!curr) |
| return -ENODEV; |
| |
| if (IS_ERR(curr)) |
| return PTR_ERR(curr); |
| |
| if (enable) { |
| set_bit(dev_id, &vreg_sts); |
| |
| rc = regulator_enable(curr); |
| if (rc) |
| pr_err("%s: could not enable regulator: %d\n", |
| __func__, rc); |
| } else { |
| clear_bit(dev_id, &vreg_sts); |
| |
| rc = regulator_disable(curr); |
| if (rc) |
| pr_err("%s: could not disable regulator: %d\n", |
| __func__, rc); |
| } |
| return rc; |
| } |
| |
| static uint32_t msm_sdcc_setup_power(struct device *dv, unsigned int vdd) |
| { |
| int rc = 0; |
| struct platform_device *pdev; |
| |
| pdev = container_of(dv, struct platform_device, dev); |
| |
| rc = msm_sdcc_setup_gpio(pdev->id, !!vdd); |
| if (rc) |
| goto out; |
| |
| rc = msm_sdcc_setup_vreg(pdev->id, !!vdd); |
| out: |
| return rc; |
| } |
| |
| #define GPIO_SDC1_HW_DET 42 |
| |
| #if defined(CONFIG_MMC_MSM_SDC1_SUPPORT) \ |
| && defined(CONFIG_MMC_MSM_CARD_HW_DETECTION) |
| static unsigned int msm7627a_sdcc_slot_status(struct device *dev) |
| { |
| int status; |
| |
| status = gpio_tlmm_config(GPIO_CFG(GPIO_SDC1_HW_DET, 2, GPIO_CFG_INPUT, |
| GPIO_CFG_PULL_UP, GPIO_CFG_8MA), GPIO_CFG_ENABLE); |
| if (status) |
| pr_err("%s:Failed to configure tlmm for GPIO %d\n", __func__, |
| GPIO_SDC1_HW_DET); |
| |
| status = gpio_request(GPIO_SDC1_HW_DET, "SD_HW_Detect"); |
| if (status) { |
| pr_err("%s:Failed to request GPIO %d\n", __func__, |
| GPIO_SDC1_HW_DET); |
| } else { |
| status = gpio_direction_input(GPIO_SDC1_HW_DET); |
| if (!status) |
| status = !gpio_get_value(GPIO_SDC1_HW_DET); |
| gpio_free(GPIO_SDC1_HW_DET); |
| } |
| return status; |
| } |
| #endif |
| |
| #ifdef CONFIG_MMC_MSM_SDC1_SUPPORT |
| static struct mmc_platform_data sdc1_plat_data = { |
| .ocr_mask = MMC_VDD_28_29, |
| .translate_vdd = msm_sdcc_setup_power, |
| .mmc_bus_width = MMC_CAP_4_BIT_DATA, |
| .msmsdcc_fmin = 144000, |
| .msmsdcc_fmid = 24576000, |
| .msmsdcc_fmax = 49152000, |
| #ifdef CONFIG_MMC_MSM_CARD_HW_DETECTION |
| .status = msm7627a_sdcc_slot_status, |
| .status_irq = MSM_GPIO_TO_INT(GPIO_SDC1_HW_DET), |
| .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| #endif |
| }; |
| #endif |
| |
| #ifdef CONFIG_MMC_MSM_SDC2_SUPPORT |
| static struct mmc_platform_data sdc2_plat_data = { |
| /* |
| * SDC2 supports only 1.8V, claim for 2.85V range is just |
| * for allowing buggy cards who advertise 2.8V even though |
| * they can operate at 1.8V supply. |
| */ |
| .ocr_mask = MMC_VDD_28_29 | MMC_VDD_165_195, |
| .translate_vdd = msm_sdcc_setup_power, |
| .mmc_bus_width = MMC_CAP_4_BIT_DATA, |
| #ifdef CONFIG_MMC_MSM_SDIO_SUPPORT |
| .sdiowakeup_irq = MSM_GPIO_TO_INT(66), |
| #endif |
| .msmsdcc_fmin = 144000, |
| .msmsdcc_fmid = 24576000, |
| .msmsdcc_fmax = 49152000, |
| #ifdef CONFIG_MMC_MSM_SDC2_DUMMY52_REQUIRED |
| .dummy52_required = 1, |
| #endif |
| }; |
| #endif |
| |
| #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT |
| static struct mmc_platform_data sdc3_plat_data = { |
| .ocr_mask = MMC_VDD_28_29, |
| .translate_vdd = msm_sdcc_setup_power, |
| #ifdef CONFIG_MMC_MSM_SDC3_8_BIT_SUPPORT |
| .mmc_bus_width = MMC_CAP_8_BIT_DATA, |
| #else |
| .mmc_bus_width = MMC_CAP_4_BIT_DATA, |
| #endif |
| .msmsdcc_fmin = 144000, |
| .msmsdcc_fmid = 24576000, |
| .msmsdcc_fmax = 49152000, |
| .nonremovable = 1, |
| }; |
| #endif |
| |
| #if (defined(CONFIG_MMC_MSM_SDC4_SUPPORT)\ |
| && !defined(CONFIG_MMC_MSM_SDC3_8_BIT_SUPPORT)) |
| static struct mmc_platform_data sdc4_plat_data = { |
| .ocr_mask = MMC_VDD_28_29, |
| .translate_vdd = msm_sdcc_setup_power, |
| .mmc_bus_width = MMC_CAP_4_BIT_DATA, |
| .msmsdcc_fmin = 144000, |
| .msmsdcc_fmid = 24576000, |
| .msmsdcc_fmax = 49152000, |
| }; |
| #endif |
| #endif |
| |
| #ifdef CONFIG_SERIAL_MSM_HS |
| static struct msm_serial_hs_platform_data msm_uart_dm1_pdata = { |
| .inject_rx_on_wakeup = 1, |
| .rx_to_inject = 0xFD, |
| }; |
| #endif |
| static struct msm_pm_platform_data msm7627a_pm_data[MSM_PM_SLEEP_MODE_NR] = { |
| [MSM_PM_SLEEP_MODE_POWER_COLLAPSE] = { |
| .idle_supported = 1, |
| .suspend_supported = 1, |
| .idle_enabled = 1, |
| .suspend_enabled = 1, |
| .latency = 16000, |
| .residency = 20000, |
| }, |
| [MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN] = { |
| .idle_supported = 1, |
| .suspend_supported = 1, |
| .idle_enabled = 1, |
| .suspend_enabled = 1, |
| .latency = 12000, |
| .residency = 20000, |
| }, |
| [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT] = { |
| .idle_supported = 1, |
| .suspend_supported = 1, |
| .idle_enabled = 0, |
| .suspend_enabled = 1, |
| .latency = 2000, |
| .residency = 0, |
| }, |
| [MSM_PM_SLEEP_MODE_WAIT_FOR_INTERRUPT] = { |
| .idle_supported = 1, |
| .suspend_supported = 1, |
| .idle_enabled = 1, |
| .suspend_enabled = 1, |
| .latency = 2, |
| .residency = 0, |
| }, |
| }; |
| |
| static struct android_pmem_platform_data android_pmem_adsp_pdata = { |
| .name = "pmem_adsp", |
| .allocator_type = PMEM_ALLOCATORTYPE_BITMAP, |
| .cached = 1, |
| .memory_type = MEMTYPE_EBI1, |
| }; |
| |
| static struct platform_device android_pmem_adsp_device = { |
| .name = "android_pmem", |
| .id = 1, |
| .dev = { .platform_data = &android_pmem_adsp_pdata }, |
| }; |
| |
| static unsigned pmem_mdp_size = MSM_PMEM_MDP_SIZE; |
| static int __init pmem_mdp_size_setup(char *p) |
| { |
| pmem_mdp_size = memparse(p, NULL); |
| return 0; |
| } |
| |
| early_param("pmem_mdp_size", pmem_mdp_size_setup); |
| |
| static unsigned pmem_adsp_size = MSM_PMEM_ADSP_SIZE; |
| static int __init pmem_adsp_size_setup(char *p) |
| { |
| pmem_adsp_size = memparse(p, NULL); |
| return 0; |
| } |
| |
| early_param("pmem_adsp_size", pmem_adsp_size_setup); |
| |
| static unsigned fb_size = MSM_FB_SIZE; |
| static int __init fb_size_setup(char *p) |
| { |
| fb_size = memparse(p, NULL); |
| return 0; |
| } |
| |
| early_param("fb_size", fb_size_setup); |
| |
| static struct resource msm_fb_resources[] = { |
| { |
| .flags = IORESOURCE_DMA, |
| } |
| }; |
| |
| static int msm_fb_detect_panel(const char *name) |
| { |
| int ret; |
| |
| if (!strncmp(name, "mipi_video_truly_wvga", 21)) |
| ret = 0; |
| else |
| ret = -ENODEV; |
| |
| return ret; |
| } |
| |
| static int mipi_truly_set_bl(int on) |
| { |
| gpio_set_value_cansleep(GPIO_BACKLIGHT_EN, !!on); |
| |
| return 1; |
| } |
| |
| static struct msm_fb_platform_data msm_fb_pdata = { |
| .detect_client = msm_fb_detect_panel, |
| }; |
| |
| static struct platform_device msm_fb_device = { |
| .name = "msm_fb", |
| .id = 0, |
| .num_resources = ARRAY_SIZE(msm_fb_resources), |
| .resource = msm_fb_resources, |
| .dev = { |
| .platform_data = &msm_fb_pdata, |
| } |
| }; |
| |
| static struct msm_panel_common_pdata mipi_truly_pdata = { |
| .pmic_backlight = mipi_truly_set_bl, |
| }; |
| |
| static struct platform_device mipi_dsi_truly_panel_device = { |
| .name = "mipi_truly", |
| .id = 0, |
| .dev = { |
| .platform_data = &mipi_truly_pdata, |
| } |
| }; |
| |
| static int __init mmc_regulator_init(int sdcc_no, const char *supply, int uV) |
| { |
| int rc; |
| |
| BUG_ON(sdcc_no < 1 || sdcc_no > 4); |
| |
| sdcc_no--; |
| |
| sdcc_vreg_data[sdcc_no] = regulator_get(NULL, supply); |
| |
| if (IS_ERR(sdcc_vreg_data[sdcc_no])) { |
| rc = PTR_ERR(sdcc_vreg_data[sdcc_no]); |
| pr_err("%s: could not get regulator \"%s\": %d\n", |
| __func__, supply, rc); |
| goto out; |
| } |
| |
| rc = regulator_set_voltage(sdcc_vreg_data[sdcc_no], uV, uV); |
| |
| if (rc) { |
| pr_err("%s: could not set voltage for \"%s\" to %d uV: %d\n", |
| __func__, supply, uV, rc); |
| goto reg_free; |
| } |
| |
| return rc; |
| |
| reg_free: |
| regulator_put(sdcc_vreg_data[sdcc_no]); |
| out: |
| sdcc_vreg_data[sdcc_no] = NULL; |
| return rc; |
| } |
| |
| static void __init msm7627a_init_mmc(void) |
| { |
| /* eMMC slot */ |
| #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT |
| if (mmc_regulator_init(3, "emmc", 3000000)) |
| return; |
| msm_add_sdcc(3, &sdc3_plat_data); |
| #endif |
| /* Micro-SD slot */ |
| #ifdef CONFIG_MMC_MSM_SDC1_SUPPORT |
| if (mmc_regulator_init(1, "mmc", 2850000)) |
| return; |
| msm_add_sdcc(1, &sdc1_plat_data); |
| #endif |
| /* SDIO WLAN slot */ |
| #ifdef CONFIG_MMC_MSM_SDC2_SUPPORT |
| if (mmc_regulator_init(2, "mmc", 2850000)) |
| return; |
| msm_add_sdcc(2, &sdc2_plat_data); |
| #endif |
| /* Not Used */ |
| #if (defined(CONFIG_MMC_MSM_SDC4_SUPPORT)\ |
| && !defined(CONFIG_MMC_MSM_SDC3_8_BIT_SUPPORT)) |
| if (mmc_regulator_init(4, "mmc", 2850000)) |
| return; |
| msm_add_sdcc(4, &sdc4_plat_data); |
| #endif |
| } |
| |
| #define SND(desc, num) { .name = #desc, .id = num } |
| static struct snd_endpoint snd_endpoints_list[] = { |
| SND(HANDSET, 0), |
| SND(MONO_HEADSET, 2), |
| SND(HEADSET, 3), |
| SND(SPEAKER, 6), |
| SND(TTY_HEADSET, 8), |
| SND(TTY_VCO, 9), |
| SND(TTY_HCO, 10), |
| SND(BT, 12), |
| SND(IN_S_SADC_OUT_HANDSET, 16), |
| SND(IN_S_SADC_OUT_SPEAKER_PHONE, 25), |
| SND(FM_DIGITAL_STEREO_HEADSET, 26), |
| SND(FM_DIGITAL_SPEAKER_PHONE, 27), |
| SND(FM_DIGITAL_BT_A2DP_HEADSET, 28), |
| SND(STEREO_HEADSET_AND_SPEAKER, 31), |
| SND(CURRENT, 0x7FFFFFFE), |
| SND(FM_ANALOG_STEREO_HEADSET, 35), |
| SND(FM_ANALOG_STEREO_HEADSET_CODEC, 36), |
| }; |
| #undef SND |
| |
| static struct msm_snd_endpoints msm_device_snd_endpoints = { |
| .endpoints = snd_endpoints_list, |
| .num = sizeof(snd_endpoints_list) / sizeof(struct snd_endpoint) |
| }; |
| |
| static struct platform_device msm_device_snd = { |
| .name = "msm_snd", |
| .id = -1, |
| .dev = { |
| .platform_data = &msm_device_snd_endpoints |
| }, |
| }; |
| |
| #define DEC0_FORMAT ((1<<MSM_ADSP_CODEC_MP3)| \ |
| (1<<MSM_ADSP_CODEC_AAC)|(1<<MSM_ADSP_CODEC_WMA)| \ |
| (1<<MSM_ADSP_CODEC_WMAPRO)|(1<<MSM_ADSP_CODEC_AMRWB)| \ |
| (1<<MSM_ADSP_CODEC_AMRNB)|(1<<MSM_ADSP_CODEC_WAV)| \ |
| (1<<MSM_ADSP_CODEC_ADPCM)|(1<<MSM_ADSP_CODEC_YADPCM)| \ |
| (1<<MSM_ADSP_CODEC_EVRC)|(1<<MSM_ADSP_CODEC_QCELP)) |
| #define DEC1_FORMAT ((1<<MSM_ADSP_CODEC_MP3)| \ |
| (1<<MSM_ADSP_CODEC_AAC)|(1<<MSM_ADSP_CODEC_WMA)| \ |
| (1<<MSM_ADSP_CODEC_WMAPRO)|(1<<MSM_ADSP_CODEC_AMRWB)| \ |
| (1<<MSM_ADSP_CODEC_AMRNB)|(1<<MSM_ADSP_CODEC_WAV)| \ |
| (1<<MSM_ADSP_CODEC_ADPCM)|(1<<MSM_ADSP_CODEC_YADPCM)| \ |
| (1<<MSM_ADSP_CODEC_EVRC)|(1<<MSM_ADSP_CODEC_QCELP)) |
| #define DEC2_FORMAT ((1<<MSM_ADSP_CODEC_MP3)| \ |
| (1<<MSM_ADSP_CODEC_AAC)|(1<<MSM_ADSP_CODEC_WMA)| \ |
| (1<<MSM_ADSP_CODEC_WMAPRO)|(1<<MSM_ADSP_CODEC_AMRWB)| \ |
| (1<<MSM_ADSP_CODEC_AMRNB)|(1<<MSM_ADSP_CODEC_WAV)| \ |
| (1<<MSM_ADSP_CODEC_ADPCM)|(1<<MSM_ADSP_CODEC_YADPCM)| \ |
| (1<<MSM_ADSP_CODEC_EVRC)|(1<<MSM_ADSP_CODEC_QCELP)) |
| #define DEC3_FORMAT ((1<<MSM_ADSP_CODEC_MP3)| \ |
| (1<<MSM_ADSP_CODEC_AAC)|(1<<MSM_ADSP_CODEC_WMA)| \ |
| (1<<MSM_ADSP_CODEC_WMAPRO)|(1<<MSM_ADSP_CODEC_AMRWB)| \ |
| (1<<MSM_ADSP_CODEC_AMRNB)|(1<<MSM_ADSP_CODEC_WAV)| \ |
| (1<<MSM_ADSP_CODEC_ADPCM)|(1<<MSM_ADSP_CODEC_YADPCM)| \ |
| (1<<MSM_ADSP_CODEC_EVRC)|(1<<MSM_ADSP_CODEC_QCELP)) |
| #define DEC4_FORMAT (1<<MSM_ADSP_CODEC_MIDI) |
| |
| static unsigned int dec_concurrency_table[] = { |
| /* Audio LP */ |
| (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DMA)), 0, |
| 0, 0, 0, |
| |
| /* Concurrency 1 */ |
| (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC1_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC2_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC3_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC4_FORMAT), |
| |
| /* Concurrency 2 */ |
| (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC1_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC2_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC3_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC4_FORMAT), |
| |
| /* Concurrency 3 */ |
| (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC1_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC2_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC3_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC4_FORMAT), |
| |
| /* Concurrency 4 */ |
| (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC1_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC2_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC3_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC4_FORMAT), |
| |
| /* Concurrency 5 */ |
| (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC1_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC2_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC3_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC4_FORMAT), |
| |
| /* Concurrency 6 */ |
| (DEC0_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| 0, 0, 0, 0, |
| |
| /* Concurrency 7 */ |
| (DEC0_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC1_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC2_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC3_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)), |
| (DEC4_FORMAT), |
| }; |
| |
| #define DEC_INFO(name, queueid, decid, nr_codec) { .module_name = name, \ |
| .module_queueid = queueid, .module_decid = decid, \ |
| .nr_codec_support = nr_codec} |
| |
| static struct msm_adspdec_info dec_info_list[] = { |
| DEC_INFO("AUDPLAY0TASK", 13, 0, 11), /* AudPlay0BitStreamCtrlQueue */ |
| DEC_INFO("AUDPLAY1TASK", 14, 1, 11), /* AudPlay1BitStreamCtrlQueue */ |
| DEC_INFO("AUDPLAY2TASK", 15, 2, 11), /* AudPlay2BitStreamCtrlQueue */ |
| DEC_INFO("AUDPLAY3TASK", 16, 3, 11), /* AudPlay3BitStreamCtrlQueue */ |
| DEC_INFO("AUDPLAY4TASK", 17, 4, 1), /* AudPlay4BitStreamCtrlQueue */ |
| }; |
| |
| static struct msm_adspdec_database msm_device_adspdec_database = { |
| .num_dec = ARRAY_SIZE(dec_info_list), |
| .num_concurrency_support = (ARRAY_SIZE(dec_concurrency_table) / \ |
| ARRAY_SIZE(dec_info_list)), |
| .dec_concurrency_table = dec_concurrency_table, |
| .dec_info_list = dec_info_list, |
| }; |
| |
| static struct platform_device msm_device_adspdec = { |
| .name = "msm_adspdec", |
| .id = -1, |
| .dev = { |
| .platform_data = &msm_device_adspdec_database |
| }, |
| }; |
| |
| static struct android_pmem_platform_data android_pmem_audio_pdata = { |
| .name = "pmem_audio", |
| .allocator_type = PMEM_ALLOCATORTYPE_BITMAP, |
| .cached = 0, |
| .memory_type = MEMTYPE_EBI1, |
| }; |
| |
| static struct platform_device android_pmem_audio_device = { |
| .name = "android_pmem", |
| .id = 2, |
| .dev = { .platform_data = &android_pmem_audio_pdata }, |
| }; |
| |
| static struct android_pmem_platform_data android_pmem_pdata = { |
| .name = "pmem", |
| .allocator_type = PMEM_ALLOCATORTYPE_BITMAP, |
| .cached = 1, |
| .memory_type = MEMTYPE_EBI1, |
| }; |
| static struct platform_device android_pmem_device = { |
| .name = "android_pmem", |
| .id = 0, |
| .dev = { .platform_data = &android_pmem_pdata }, |
| }; |
| |
| static u32 msm_calculate_batt_capacity(u32 current_voltage); |
| |
| static struct msm_psy_batt_pdata msm_psy_batt_data = { |
| .voltage_min_design = 2800, |
| .voltage_max_design = 4300, |
| .avail_chg_sources = AC_CHG | USB_CHG , |
| .batt_technology = POWER_SUPPLY_TECHNOLOGY_LION, |
| .calculate_capacity = &msm_calculate_batt_capacity, |
| }; |
| |
| static u32 msm_calculate_batt_capacity(u32 current_voltage) |
| { |
| u32 low_voltage = msm_psy_batt_data.voltage_min_design; |
| u32 high_voltage = msm_psy_batt_data.voltage_max_design; |
| |
| return (current_voltage - low_voltage) * 100 |
| / (high_voltage - low_voltage); |
| } |
| |
| static struct platform_device msm_batt_device = { |
| .name = "msm-battery", |
| .id = -1, |
| .dev.platform_data = &msm_psy_batt_data, |
| }; |
| |
| #ifdef CONFIG_MSM_CAMERA |
| static uint32_t camera_off_gpio_table[] = { |
| GPIO_CFG(15, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| }; |
| |
| static uint32_t camera_on_gpio_table[] = { |
| GPIO_CFG(15, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), |
| }; |
| |
| static void qrd1_camera_gpio_cfg(void) |
| { |
| |
| int rc = 0; |
| |
| rc = gpio_request(GPIO_CAM_5MP_SHDN_EN, "ov5640"); |
| if (rc < 0) |
| pr_err("%s: gpio_request---GPIO_CAM_5MP_SHDN_EN failed!", |
| __func__); |
| |
| |
| rc = gpio_tlmm_config(GPIO_CFG(GPIO_CAM_5MP_SHDN_EN, 0, |
| GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, |
| GPIO_CFG_2MA), GPIO_CFG_ENABLE); |
| if (rc < 0) { |
| pr_err("%s: unable to enable Power Down gpio for main" |
| "camera!\n", __func__); |
| gpio_free(GPIO_CAM_5MP_SHDN_EN); |
| } |
| |
| |
| rc = gpio_request(GPIO_CAM_5MP_RESET, "ov5640"); |
| if (rc < 0) { |
| pr_err("%s: gpio_request---GPIO_CAM_5MP_RESET failed!", |
| __func__); |
| gpio_free(GPIO_CAM_5MP_SHDN_EN); |
| } |
| |
| |
| rc = gpio_tlmm_config(GPIO_CFG(GPIO_CAM_5MP_RESET, 0, |
| GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, |
| GPIO_CFG_2MA), GPIO_CFG_ENABLE); |
| if (rc < 0) { |
| pr_err("%s: unable to enable reset gpio for main camera!\n", |
| __func__); |
| gpio_free(GPIO_CAM_5MP_RESET); |
| } |
| |
| rc = gpio_request(GPIO_CAM_3MP_PWDN, "ov7692"); |
| if (rc < 0) |
| pr_err("%s: gpio_request---GPIO_CAM_3MP_PWDN failed!", |
| __func__); |
| |
| rc = gpio_tlmm_config(GPIO_CFG(GPIO_CAM_3MP_PWDN, 0, |
| GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, |
| GPIO_CFG_2MA), GPIO_CFG_ENABLE); |
| if (rc < 0) { |
| pr_err("%s: unable to enable Power Down gpio for front" |
| "camera!\n", __func__); |
| gpio_free(GPIO_CAM_3MP_PWDN); |
| } |
| |
| gpio_direction_output(GPIO_CAM_5MP_SHDN_EN, 1); |
| gpio_direction_output(GPIO_CAM_5MP_RESET, 1); |
| gpio_direction_output(GPIO_CAM_3MP_PWDN, 1); |
| } |
| |
| #endif |
| static struct regulator_bulk_data regs_camera[] = { |
| { .supply = "msme1", .min_uV = 1800000, .max_uV = 1800000 }, |
| { .supply = "gp2", .min_uV = 2850000, .max_uV = 2850000 }, |
| { .supply = "usb2", .min_uV = 1800000, .max_uV = 1800000 }, |
| }; |
| |
| static void __init msm_camera_vreg_init(void) |
| { |
| int rc; |
| |
| rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_camera), regs_camera); |
| if (rc) { |
| pr_err("%s: could not get regulators: %d\n", __func__, rc); |
| return; |
| } |
| |
| rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_camera), regs_camera); |
| if (rc) { |
| pr_err("%s: could not set voltages: %d\n", __func__, rc); |
| return; |
| } |
| } |
| |
| static void msm_camera_vreg_config(int vreg_en) |
| { |
| int rc = vreg_en ? |
| regulator_bulk_enable(ARRAY_SIZE(regs_camera), regs_camera) : |
| regulator_bulk_disable(ARRAY_SIZE(regs_camera), regs_camera); |
| |
| if (rc) |
| pr_err("%s: could not %sable regulators: %d\n", |
| __func__, vreg_en ? "en" : "dis", rc); |
| } |
| static int config_gpio_table(uint32_t *table, int len) |
| { |
| int rc = 0, i = 0; |
| |
| for (i = 0; i < len; i++) { |
| rc = gpio_tlmm_config(table[i], GPIO_CFG_ENABLE); |
| if (rc) { |
| pr_err("%s not able to get gpio\n", __func__); |
| for (i--; i >= 0; i--) |
| gpio_tlmm_config(camera_off_gpio_table[i], |
| GPIO_CFG_ENABLE); |
| break; |
| } |
| } |
| return rc; |
| } |
| |
| static int config_camera_on_gpios_rear(void) |
| { |
| int rc = 0; |
| |
| msm_camera_vreg_config(1); |
| |
| rc = config_gpio_table(camera_on_gpio_table, |
| ARRAY_SIZE(camera_on_gpio_table)); |
| if (rc < 0) { |
| pr_err("%s: CAMSENSOR gpio table request" |
| "failed\n", __func__); |
| return rc; |
| } |
| |
| return rc; |
| } |
| |
| static void config_camera_off_gpios_rear(void) |
| { |
| msm_camera_vreg_config(0); |
| config_gpio_table(camera_off_gpio_table, |
| ARRAY_SIZE(camera_off_gpio_table)); |
| } |
| |
| static int config_camera_on_gpios_front(void) |
| { |
| int rc = 0; |
| |
| msm_camera_vreg_config(1); |
| |
| rc = config_gpio_table(camera_on_gpio_table, |
| ARRAY_SIZE(camera_on_gpio_table)); |
| if (rc < 0) { |
| pr_err("%s: CAMSENSOR gpio table request" |
| "failed\n", __func__); |
| return rc; |
| } |
| |
| return rc; |
| } |
| |
| static void config_camera_off_gpios_front(void) |
| { |
| msm_camera_vreg_config(0); |
| |
| config_gpio_table(camera_off_gpio_table, |
| ARRAY_SIZE(camera_off_gpio_table)); |
| } |
| |
| struct msm_camera_device_platform_data msm_camera_data_rear = { |
| .camera_gpio_on = config_camera_on_gpios_rear, |
| .camera_gpio_off = config_camera_off_gpios_rear, |
| .ioext.csiphy = 0xA1000000, |
| .ioext.csisz = 0x00100000, |
| .ioext.csiirq = INT_CSI_IRQ_1, |
| .ioclk.mclk_clk_rate = 24000000, |
| .ioclk.vfe_clk_rate = 192000000, |
| .ioext.appphy = MSM_CLK_CTL_PHYS, |
| .ioext.appsz = MSM_CLK_CTL_SIZE, |
| }; |
| |
| struct msm_camera_device_platform_data msm_camera_data_front = { |
| .camera_gpio_on = config_camera_on_gpios_front, |
| .camera_gpio_off = config_camera_off_gpios_front, |
| .ioext.csiphy = 0xA0F00000, |
| .ioext.csisz = 0x00100000, |
| .ioext.csiirq = INT_CSI_IRQ_0, |
| .ioclk.mclk_clk_rate = 24000000, |
| .ioclk.vfe_clk_rate = 192000000, |
| .ioext.appphy = MSM_CLK_CTL_PHYS, |
| .ioext.appsz = MSM_CLK_CTL_SIZE, |
| }; |
| |
| #ifdef CONFIG_OV5640 |
| static struct msm_camera_sensor_platform_info ov5640_sensor_info = { |
| .mount_angle = 90 |
| }; |
| |
| static struct msm_camera_sensor_flash_src msm_flash_src_ov5640 = { |
| .flash_sr_type = MSM_CAMERA_FLASH_SRC_LED, |
| ._fsrc.led_src.led_name = "flashlight", |
| ._fsrc.led_src.led_name_len = 10, |
| }; |
| |
| static struct msm_camera_sensor_flash_data flash_ov5640 = { |
| .flash_type = MSM_CAMERA_FLASH_LED, |
| .flash_src = &msm_flash_src_ov5640, |
| }; |
| |
| static struct msm_camera_sensor_info msm_camera_sensor_ov5640_data = { |
| .sensor_name = "ov5640", |
| .sensor_reset_enable = 1, |
| .sensor_reset = GPIO_CAM_5MP_RESET, |
| .sensor_pwd = GPIO_CAM_5MP_SHDN_EN, |
| .vcm_pwd = 0, |
| .vcm_enable = 0, |
| .pdata = &msm_camera_data_rear, |
| .flash_data = &flash_ov5640, |
| .sensor_platform_info = &ov5640_sensor_info, |
| .csi_if = 1, |
| }; |
| |
| static struct platform_device msm_camera_sensor_ov5640 = { |
| .name = "msm_camera_ov5640", |
| .dev = { |
| .platform_data = &msm_camera_sensor_ov5640_data, |
| }, |
| }; |
| #endif |
| |
| #ifdef CONFIG_WEBCAM_OV7692_QRD |
| static struct msm_camera_sensor_platform_info ov7692_sensor_7627a_info = { |
| .mount_angle = 90 |
| }; |
| |
| static struct msm_camera_sensor_flash_data flash_ov7692 = { |
| .flash_type = MSM_CAMERA_FLASH_NONE, |
| }; |
| |
| static struct msm_camera_sensor_info msm_camera_sensor_ov7692_data = { |
| .sensor_name = "ov7692", |
| .sensor_reset_enable = 0, |
| .sensor_reset = 0, |
| .sensor_pwd = GPIO_CAM_3MP_PWDN, |
| .vcm_pwd = 0, |
| .vcm_enable = 0, |
| .pdata = &msm_camera_data_front, |
| .flash_data = &flash_ov7692, |
| .sensor_platform_info = &ov7692_sensor_7627a_info, |
| .csi_if = 1, |
| }; |
| |
| static struct platform_device msm_camera_sensor_ov7692 = { |
| .name = "msm_camera_ov7692", |
| .dev = { |
| .platform_data = &msm_camera_sensor_ov7692_data, |
| }, |
| }; |
| #endif |
| |
| static struct i2c_board_info i2c_camera_devices[] = { |
| #ifdef CONFIG_OV5640 |
| { |
| I2C_BOARD_INFO("ov5640", 0x78 >> 1), |
| }, |
| #endif |
| #ifdef CONFIG_WEBCAM_OV7692_QRD |
| { |
| I2C_BOARD_INFO("ov7692", 0x78), |
| }, |
| #endif |
| }; |
| static struct platform_device *qrd1_devices[] __initdata = { |
| &msm_device_dmov, |
| &msm_device_smd, |
| &msm_device_uart1, |
| &msm_device_uart_dm1, |
| &msm_gsbi0_qup_i2c_device, |
| &msm_gsbi1_qup_i2c_device, |
| &msm_device_otg, |
| &msm_device_gadget_peripheral, |
| &android_usb_device, |
| &android_pmem_device, |
| &android_pmem_adsp_device, |
| &msm_fb_device, |
| &android_pmem_audio_device, |
| &msm_device_snd, |
| &msm_device_adspdec, |
| &msm_batt_device, |
| #ifdef CONFIG_OV5640 |
| &msm_camera_sensor_ov5640, |
| #endif |
| #ifdef CONFIG_WEBCAM_OV7692_QRD |
| &msm_camera_sensor_ov7692, |
| #endif |
| &msm_kgsl_3d0, |
| #ifdef CONFIG_BT |
| &msm_bt_power_device, |
| #endif |
| &mipi_dsi_truly_panel_device, |
| &msm_wlan_ar6000_pm_device, |
| &asoc_msm_pcm, |
| &asoc_msm_dai0, |
| &asoc_msm_dai1, |
| }; |
| |
| static unsigned pmem_kernel_ebi1_size = PMEM_KERNEL_EBI1_SIZE; |
| static int __init pmem_kernel_ebi1_size_setup(char *p) |
| { |
| pmem_kernel_ebi1_size = memparse(p, NULL); |
| return 0; |
| } |
| early_param("pmem_kernel_ebi1_size", pmem_kernel_ebi1_size_setup); |
| |
| static unsigned pmem_audio_size = MSM_PMEM_AUDIO_SIZE; |
| static int __init pmem_audio_size_setup(char *p) |
| { |
| pmem_audio_size = memparse(p, NULL); |
| return 0; |
| } |
| early_param("pmem_audio_size", pmem_audio_size_setup); |
| |
| static void __init msm_msm7627a_allocate_memory_regions(void) |
| { |
| void *addr; |
| unsigned long size; |
| |
| size = fb_size ? : MSM_FB_SIZE; |
| addr = alloc_bootmem_align(size, 0x1000); |
| msm_fb_resources[0].start = __pa(addr); |
| msm_fb_resources[0].end = msm_fb_resources[0].start + size - 1; |
| pr_info("allocating %lu bytes at %p (%lx physical) for fb\n", size, |
| addr, __pa(addr)); |
| } |
| |
| static struct memtype_reserve msm7627a_reserve_table[] __initdata = { |
| [MEMTYPE_SMI] = { |
| }, |
| [MEMTYPE_EBI0] = { |
| .flags = MEMTYPE_FLAGS_1M_ALIGN, |
| }, |
| [MEMTYPE_EBI1] = { |
| .flags = MEMTYPE_FLAGS_1M_ALIGN, |
| }, |
| }; |
| |
| static struct msm_panel_common_pdata mdp_pdata = { |
| .gpio = 97, |
| .mdp_rev = MDP_REV_303, |
| }; |
| |
| #define GPIO_LCDC_BRDG_PD 128 |
| #define GPIO_LCDC_BRDG_RESET_N 129 |
| #define GPIO_LCD_DSI_SEL 125 |
| |
| static unsigned mipi_dsi_gpio[] = { |
| GPIO_CFG(GPIO_LCDC_BRDG_RESET_N, 0, GPIO_CFG_OUTPUT, |
| GPIO_CFG_NO_PULL, GPIO_CFG_2MA), /* LCDC_BRDG_RESET_N */ |
| GPIO_CFG(GPIO_LCDC_BRDG_PD, 0, GPIO_CFG_OUTPUT, |
| GPIO_CFG_NO_PULL, GPIO_CFG_2MA), /* LCDC_BRDG_PD */ |
| }; |
| |
| static unsigned lcd_dsi_sel_gpio[] = { |
| GPIO_CFG(GPIO_LCD_DSI_SEL, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, |
| GPIO_CFG_2MA), |
| }; |
| |
| enum { |
| DSI_SINGLE_LANE = 1, |
| DSI_TWO_LANES, |
| }; |
| |
| static int msm_fb_get_lane_config(void) |
| { |
| pr_info("DSI_TWO_LANES\n"); |
| return DSI_TWO_LANES; |
| } |
| |
| static int mipi_truly_sel_mode(int video_mode) |
| { |
| int rc = 0; |
| |
| rc = gpio_request(GPIO_LCD_DSI_SEL, "lcd_dsi_sel"); |
| if (rc < 0) |
| goto gpio_error; |
| |
| rc = gpio_tlmm_config(lcd_dsi_sel_gpio[0], GPIO_CFG_ENABLE); |
| if (rc) |
| goto gpio_error; |
| |
| rc = gpio_direction_output(GPIO_LCD_DSI_SEL, 1); |
| if (!rc) { |
| gpio_set_value_cansleep(GPIO_LCD_DSI_SEL, video_mode); |
| return rc; |
| } else { |
| goto gpio_error; |
| } |
| |
| gpio_error: |
| pr_err("mipi_truly_sel_mode failed\n"); |
| gpio_free(GPIO_LCD_DSI_SEL); |
| return rc; |
| } |
| |
| static int msm_fb_dsi_client_qrd1_reset(void) |
| { |
| int rc = 0; |
| |
| rc = gpio_request(GPIO_LCDC_BRDG_RESET_N, "lcdc_brdg_reset_n"); |
| if (rc < 0) { |
| pr_err("failed to request lcd brdg reset_n\n"); |
| return rc; |
| } |
| |
| rc = gpio_tlmm_config(mipi_dsi_gpio[0], GPIO_CFG_ENABLE); |
| if (rc < 0) { |
| pr_err("Failed to enable LCDC Bridge reset enable\n"); |
| return rc; |
| } |
| |
| rc = gpio_direction_output(GPIO_LCDC_BRDG_RESET_N, 1); |
| if (rc < 0) { |
| pr_err("Failed GPIO bridge pd\n"); |
| gpio_free(GPIO_LCDC_BRDG_RESET_N); |
| return rc; |
| } |
| |
| mipi_truly_sel_mode(1); |
| |
| return rc; |
| } |
| |
| static int msm_fb_dsi_client_reset(void) |
| { |
| int rc = 0; |
| |
| rc = msm_fb_dsi_client_qrd1_reset(); |
| return rc; |
| } |
| |
| static int dsi_gpio_initialized; |
| |
| static int mipi_dsi_panel_qrd1_power(int on) |
| { |
| int rc = 0; |
| |
| if (!dsi_gpio_initialized) { |
| rc = gpio_request(GPIO_BACKLIGHT_EN, "gpio_bkl_en"); |
| if (rc < 0) |
| return rc; |
| |
| rc = gpio_tlmm_config(GPIO_CFG(GPIO_BACKLIGHT_EN, 0, |
| GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), |
| GPIO_CFG_ENABLE); |
| if (rc < 0) { |
| pr_err("failed GPIO_BACKLIGHT_EN tlmm config\n"); |
| return rc; |
| } |
| |
| rc = gpio_direction_output(GPIO_BACKLIGHT_EN, 1); |
| if (rc < 0) { |
| pr_err("failed to enable backlight\n"); |
| gpio_free(GPIO_BACKLIGHT_EN); |
| return rc; |
| } |
| dsi_gpio_initialized = 1; |
| } |
| |
| gpio_set_value_cansleep(GPIO_BACKLIGHT_EN, !!on); |
| |
| if (!on) { |
| gpio_set_value_cansleep(GPIO_LCDC_BRDG_RESET_N, 1); |
| msleep(20); |
| gpio_set_value_cansleep(GPIO_LCDC_BRDG_RESET_N, 0); |
| msleep(20); |
| gpio_set_value_cansleep(GPIO_LCDC_BRDG_RESET_N, 1); |
| |
| } |
| |
| return rc; |
| } |
| |
| static int mipi_dsi_panel_power(int on) |
| { |
| int rc = 0; |
| |
| rc = mipi_dsi_panel_qrd1_power(on); |
| return rc; |
| } |
| |
| #define MDP_303_VSYNC_GPIO 97 |
| |
| #ifdef CONFIG_FB_MSM_MDP303 |
| static struct mipi_dsi_platform_data mipi_dsi_pdata = { |
| .vsync_gpio = MDP_303_VSYNC_GPIO, |
| .dsi_power_save = mipi_dsi_panel_power, |
| .dsi_client_reset = msm_fb_dsi_client_reset, |
| .get_lane_config = msm_fb_get_lane_config, |
| }; |
| #endif |
| |
| static void __init msm_fb_add_devices(void) |
| { |
| msm_fb_register_device("mdp", &mdp_pdata); |
| msm_fb_register_device("mipi_dsi", &mipi_dsi_pdata); |
| } |
| |
| static void __init size_pmem_devices(void) |
| { |
| #ifdef CONFIG_ANDROID_PMEM |
| android_pmem_adsp_pdata.size = pmem_adsp_size; |
| android_pmem_pdata.size = pmem_mdp_size; |
| android_pmem_audio_pdata.size = pmem_audio_size; |
| #endif |
| } |
| |
| static void __init reserve_memory_for(struct android_pmem_platform_data *p) |
| { |
| msm7627a_reserve_table[p->memory_type].size += p->size; |
| } |
| |
| static void __init reserve_pmem_memory(void) |
| { |
| #ifdef CONFIG_ANDROID_PMEM |
| reserve_memory_for(&android_pmem_adsp_pdata); |
| reserve_memory_for(&android_pmem_pdata); |
| reserve_memory_for(&android_pmem_audio_pdata); |
| msm7627a_reserve_table[MEMTYPE_EBI1].size += pmem_kernel_ebi1_size; |
| #endif |
| } |
| |
| static void __init msm7627a_calculate_reserve_sizes(void) |
| { |
| size_pmem_devices(); |
| reserve_pmem_memory(); |
| } |
| |
| static int msm7627a_paddr_to_memtype(unsigned int paddr) |
| { |
| return MEMTYPE_EBI1; |
| } |
| |
| static struct reserve_info msm7627a_reserve_info __initdata = { |
| .memtype_reserve_table = msm7627a_reserve_table, |
| .calculate_reserve_sizes = msm7627a_calculate_reserve_sizes, |
| .paddr_to_memtype = msm7627a_paddr_to_memtype, |
| }; |
| |
| static void __init msm7627a_reserve(void) |
| { |
| reserve_info = &msm7627a_reserve_info; |
| msm_reserve(); |
| } |
| |
| static void __init msm_device_i2c_init(void) |
| { |
| msm_gsbi0_qup_i2c_device.dev.platform_data = &msm_gsbi0_qup_i2c_pdata; |
| msm_gsbi1_qup_i2c_device.dev.platform_data = &msm_gsbi1_qup_i2c_pdata; |
| } |
| |
| static struct msm_handset_platform_data hs_platform_data = { |
| .hs_name = "7k_handset", |
| .pwr_key_delay_ms = 500, /* 0 will disable end key */ |
| }; |
| |
| static struct platform_device hs_pdev = { |
| .name = "msm-handset", |
| .id = -1, |
| .dev = { |
| .platform_data = &hs_platform_data, |
| }, |
| }; |
| |
| static struct platform_device msm_proccomm_regulator_dev = { |
| .name = PROCCOMM_REGULATOR_DEV_NAME, |
| .id = -1, |
| .dev = { |
| .platform_data = &msm7x27a_proccomm_regulator_data |
| } |
| }; |
| |
| static void __init msm7627a_init_regulators(void) |
| { |
| int rc = platform_device_register(&msm_proccomm_regulator_dev); |
| if (rc) |
| pr_err("%s: could not register regulator device: %d\n", |
| __func__, rc); |
| } |
| |
| #define UART1DM_RX_GPIO 45 |
| static void __init msm_qrd1_init(void) |
| { |
| msm7x2x_misc_init(); |
| msm7627a_init_regulators(); |
| msm_device_i2c_init(); |
| msm7627a_init_mmc(); |
| |
| qrd1_camera_gpio_cfg(); |
| #ifdef CONFIG_SERIAL_MSM_HS |
| msm_uart_dm1_pdata.wakeup_irq = gpio_to_irq(UART1DM_RX_GPIO); |
| msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata; |
| #endif |
| |
| #ifdef CONFIG_USB_MSM_OTG_72K |
| msm_otg_pdata.swfi_latency = msm7627a_pm_data |
| [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency; |
| msm_device_otg.dev.platform_data = &msm_otg_pdata; |
| #endif |
| msm_device_gadget_peripheral.dev.platform_data = |
| &msm_gadget_pdata; |
| platform_add_devices(qrd1_devices, |
| ARRAY_SIZE(qrd1_devices)); |
| #ifdef CONFIG_USB_EHCI_MSM_72K |
| msm7627a_init_host(); |
| #endif |
| msm_pm_set_platform_data(msm7627a_pm_data, |
| ARRAY_SIZE(msm7627a_pm_data)); |
| BUG_ON(msm_pm_boot_init(MSM_PM_BOOT_CONFIG_RESET_VECTOR, |
| ioremap(0, PAGE_SIZE))); |
| |
| msm_fb_add_devices(); |
| |
| #if defined(CONFIG_BT) && defined(CONFIG_MARIMBA_CORE) |
| i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, |
| bahama_devices, |
| ARRAY_SIZE(bahama_devices)); |
| bt_power_init(); |
| #endif |
| |
| msm_camera_vreg_init(); |
| i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices, |
| ARRAY_SIZE(i2c_camera_devices)); |
| |
| #if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_RMI4_I2C) || \ |
| defined(CONFIG_TOUCHSCREEN_SYNAPTICS_RMI4_I2C_MODULE) |
| i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, |
| synaptic_i2c_clearpad3k, |
| ARRAY_SIZE(synaptic_i2c_clearpad3k)); |
| #endif |
| platform_device_register(&hs_pdev); |
| |
| #ifdef CONFIG_MSM_RPC_VIBRATOR |
| msm_init_pmic_vibrator(); |
| #endif |
| } |
| |
| static void __init qrd7627a_init_early(void) |
| { |
| msm_msm7627a_allocate_memory_regions(); |
| } |
| |
| MACHINE_START(MSM7627A_QRD1, "QRD MSM7627a QRD1") |
| .boot_params = PHYS_OFFSET + 0x100, |
| .map_io = msm_common_io_init, |
| .reserve = msm7627a_reserve, |
| .init_irq = msm_init_irq, |
| .init_machine = msm_qrd1_init, |
| .timer = &msm_timer, |
| .init_early = qrd7627a_init_early, |
| .handle_irq = vic_handle_irq, |
| MACHINE_END |