static int t6china_rawchip_vreg_on(void) { int rc = 0; pr_info("%s\n", __func__); rc = camera_sensor_power_enable("8921_lvs4", 1800000, ®_8921_lvs4); if (rc < 0) { pr_err("sensor_power_enable(\"8921_lvs4\") FAILED %d\n", rc); goto RAW_FAIL_1V8; } mdelay(5); rc = gpio_set(PM8921_GPIO_PM_TO_SYS(V_RAW_1V2_EN), 1); if (rc < 0) goto RAW_FAIL_1V2; return rc; RAW_FAIL_1V2: camera_sensor_power_disable(reg_8921_lvs4); RAW_FAIL_1V8: return rc; }
int init_hw_setting(struct device *dev) { int rc =0; rc = hw_on_off(dev, true); if(rc<0) { dev_err(dev, "%s: fail to turn on power. rc=%d\n", __func__, rc); return rc; } #if CONFIG_BOARD_VER == CONFIG_PT10 rc = gpio_request(PM8921_GPIO_PM_TO_SYS(GPIO_TOUCH_LDO1), "touch_ldo1"); if (rc) { dev_err(dev, "%s: gpio_request GPIO_TOUCH_LDO1 failed, rc=%d\n",__func__, rc); return -EINVAL; } rc = gpio_direction_output(PM8921_GPIO_PM_TO_SYS(GPIO_TOUCH_LDO1), 1); if (rc) { dev_err(dev, "%s: gpio_direction_output GPIO_TOUCH_LDO1 failed, rc=%d\n", __func__, rc); return -EINVAL; } rc = gpio_request(PM8921_GPIO_PM_TO_SYS(GPIO_TOUCH_LDO2), "touch_ldo2"); if (rc) { dev_err(dev, "%s: gpio_request GPIO_TOUCH_LDO2 failed, rc=%d\n", __func__, rc); return -EINVAL; } rc = gpio_direction_output(PM8921_GPIO_PM_TO_SYS(GPIO_TOUCH_LDO2), 1); if (rc) { dev_err(dev, "%s: gpio_direction_output GPIO_TOUCH_LDO2 failed, rc=%d\n",__func__, rc); return -EINVAL; } #endif rc = gpio_request(GPIO_TOUCH_RST, "touch_rst"); if (rc) { gpio_free(GPIO_TOUCH_RST); rc = gpio_request(GPIO_TOUCH_RST, "touch_rst"); if (rc) { dev_err(dev, "%s: gpio_request GPIO_TOUCH_RST : %d failed, rc=%d\n",__func__, GPIO_TOUCH_RST, rc); } } rc = gpio_direction_output(GPIO_TOUCH_RST, 1); if (rc) { dev_err(dev, "%s: gpio_direction_output GPIO_TOUCH_RST : %d failed, rc=%d\n",__func__, GPIO_TOUCH_RST, rc); } rc = gpio_request(GPIO_TOUCH_CHG, "touch_chg"); if (rc) { gpio_free(GPIO_TOUCH_CHG); rc = gpio_request(GPIO_TOUCH_CHG, "touch_chg"); if (rc) { dev_err(dev, "%s: gpio_request GPIO_TOUCH_CHG : %d failed, rc=%d\n",__func__, GPIO_TOUCH_CHG, rc); } } rc = gpio_direction_input(GPIO_TOUCH_CHG); if (rc) { dev_err(dev, "%s: gpio_direction_input gpio_chg : %d failed, rc=%d\n",__func__, GPIO_TOUCH_CHG, rc); } msleep(5); return 0; }
static int msm8960_configure_headset_mic_gpios(void) { int ret; struct pm_gpio param = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 1, .pull = PM_GPIO_PULL_NO, .vin_sel = PM_GPIO_VIN_S4, .out_strength = PM_GPIO_STRENGTH_MED, .function = PM_GPIO_FUNC_NORMAL, }; ret = gpio_request(PM8921_GPIO_PM_TO_SYS(23), "AV_SWITCH"); if (ret) { pr_err("%s: Failed to request gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(23)); return ret; } ret = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(23), ¶m); if (ret) pr_err("%s: Failed to configure gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(23)); else gpio_direction_output(PM8921_GPIO_PM_TO_SYS(23), 0); ret = gpio_request(PM8921_GPIO_PM_TO_SYS(35), "US_EURO_SWITCH"); if (ret) { pr_err("%s: Failed to request gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(35)); gpio_free(PM8921_GPIO_PM_TO_SYS(23)); return ret; } ret = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(35), ¶m); if (ret) pr_err("%s: Failed to configure gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(35)); else gpio_direction_output(PM8921_GPIO_PM_TO_SYS(35), 1); return 0; } static void msm8960_free_headset_mic_gpios(void) { if (msm8960_headset_gpios_configured) { gpio_free(PM8921_GPIO_PM_TO_SYS(23)); gpio_free(PM8921_GPIO_PM_TO_SYS(35)); } } static int __init msm8960_audio_init(void) { int ret; msm8960_snd_device = platform_device_alloc("soc-audio", 0); if (!msm8960_snd_device) { pr_err("Platform device allocation failed\n"); return -ENOMEM; } platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960); ret = platform_device_add(msm8960_snd_device); if (ret) { platform_device_put(msm8960_snd_device); return ret; } if (msm8960_configure_headset_mic_gpios()) { pr_err("%s Fail to configure headset mic gpios\n", __func__); msm8960_headset_gpios_configured = 0; } else msm8960_headset_gpios_configured = 1; return ret; }
msm_fb_register_device("mipi_dsi", &mipi_dsi_pdata); platform_device_register(&hdmi_msm_device); msm_fb_register_device("dtv", &dtv_pdata); } #ifdef CONFIG_LGIT_VIDEO_WXGA_CABC #define PWM_SIMPLE_EN 0xA0 #define PWM_BRIGHTNESS 0x20 #endif #if defined (CONFIG_BACKLIGHT_LM3530) static struct backlight_platform_data lm3530_data = { .gpio = PM8921_GPIO_PM_TO_SYS(24), #ifdef CONFIG_LGIT_VIDEO_WXGA_CABC .max_current = 0x17 | PWM_BRIGHTNESS, #else .max_current = 0x17, #endif .min_brightness = 0x02, .max_brightness = 0x72, .default_brightness = 0x11, .blmap = NULL, .blmap_size = 0, }; #endif static struct i2c_board_info msm_i2c_backlight_info[] = { {
static int mipi_dsi_panel_plf_init(void) { int rc = 0; pr_debug("%s\n", __func__); if (!dsi_power_on) { reg_l29 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi1_vddio"); if (IS_ERR_OR_NULL(reg_l29)) { pr_err("%s: could not get l29 dsi1_vddio, rc = %ld\n", __func__, PTR_ERR(reg_l29)); return -ENODEV; } reg_l11 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi1_avdd"); if (IS_ERR_OR_NULL(reg_l11)) { pr_err("%s: could not get l11 dsi1_avdd, rc = %ld\n", __func__, PTR_ERR(reg_l11)); rc = -ENODEV; goto put_l29; } rc = regulator_set_voltage(reg_l11, 2850000, 2850000); if (rc) { pr_err("%s: set_voltage l11 dsi1_avdd failed, rc=%d\n", __func__, rc); goto put_l29_l11; } reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi1_pll_vdda"); if (IS_ERR_OR_NULL(reg_l2)) { pr_err("%s:could not get l2 dsi1_pll_vdda, rc = %ld\n", __func__, PTR_ERR(reg_l2)); rc = -ENODEV; goto put_l29_l11; } rc = regulator_set_voltage(reg_l29, 1800000, 1800000); if (rc) { pr_err("%s: set_voltage l29 dsi1_vddio failed, rc=%d\n", __func__, rc); goto put_l29_l11_l2; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("%s: set_voltage l2 dsi1_pll_vdda failed, rc=%d\n", __func__, rc); goto put_l29_l11_l2; } lcd_dcdc_en_gpio = PM8921_GPIO_PM_TO_SYS(LCD_DCDC_EN); rc = gpio_request(lcd_dcdc_en_gpio, "lcd_dcdc_en"); if (rc) { pr_err("%s: request LCD_DCDC_EN (gpio %d) failed, rc=%d\n", __func__, LCD_DCDC_EN, rc); goto put_l29_l11_l2; } lcd_reset_gpio = PM8921_GPIO_PM_TO_SYS(MLCD_RESET_N); rc = gpio_request(lcd_reset_gpio, "mlcd_reset_n"); if (rc) { pr_err("%s:request MLCD_RESET_N (gpio %d) failed, rc=%d\n", __func__, MLCD_RESET_N, rc); goto put_l29_l11_l2; } dsi_power_on = true; } return 0; put_l29_l11_l2: regulator_put(reg_l2); put_l29_l11: regulator_put(reg_l11); put_l29: regulator_put(reg_l29); return rc; }
static int msm8960_audrx_init(struct snd_soc_pcm_runtime *rtd) { int err; #ifdef CONFIG_PANTECH_SND //kdkim #if defined(T_STARQ) || defined(T_OSCAR) || defined(T_EF45K) || defined(T_EF46L) || defined(T_EF47S) int ret = 0; int hw_rev; #endif #endif struct snd_soc_codec *codec = rtd->codec; struct snd_soc_dapm_context *dapm = &codec->dapm; #ifndef CONFIG_PANTECH_SND //Qualcomm original...kdkim struct pm_gpio jack_gpio_cfg = { .direction = PM_GPIO_DIR_IN, .pull = PM_GPIO_PULL_UP_1P5, .function = PM_GPIO_FUNC_NORMAL, .vin_sel = 2, .inv_int_pol = 0, }; #endif pr_debug("%s()\n", __func__); if (machine_is_msm8960_liquid()) { top_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(19)); bottom_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(18)); } rtd->pmdown_time = 0; err = snd_soc_add_controls(codec, tabla_msm8960_controls, ARRAY_SIZE(tabla_msm8960_controls)); if (err < 0) return err; snd_soc_dapm_new_controls(dapm, msm8960_dapm_widgets, ARRAY_SIZE(msm8960_dapm_widgets)); #ifdef CONFIG_PANTECH_SND if(wcd9310_tablaVersionStatusGet()) //Tabla CS Version snd_soc_dapm_add_routes(dapm, common_cs_audio_map, ARRAY_SIZE(common_cs_audio_map)); else //Tabla ES Version snd_soc_dapm_add_routes(dapm, common_audio_map, ARRAY_SIZE(common_audio_map)); #else //Qualcomm Original Source snd_soc_dapm_add_routes(dapm, common_audio_map, ARRAY_SIZE(common_audio_map)); #endif snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Pos"); snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Neg"); snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Pos"); snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Neg"); snd_soc_dapm_sync(dapm); err = snd_soc_jack_new(codec, "Headset Jack", (SND_JACK_HEADSET | SND_JACK_OC_HPHL | SND_JACK_OC_HPHR), &hs_jack); if (err) { pr_err("failed to create new jack\n"); return err; } err = snd_soc_jack_new(codec, "Button Jack", TABLA_JACK_BUTTON_MASK, &button_jack); if (err) { pr_err("failed to create new jack\n"); return err; } #ifdef CONFIG_PANTECH_SND //kdkim hw_rev = get_hw_revision(); pr_debug("########### msm8960 hw_rev : %d\n", hw_rev); #if defined(T_STARQ) if(hw_rev < 5) { mbhc_cfg.gpio = 0; mbhc_cfg.gpio_irq = 0; } #elif defined(T_OSCAR) if(hw_rev < 4) { /*revision is checked by elecjang 20120326*/ mbhc_cfg.gpio = 0; mbhc_cfg.gpio_irq = 0; } #elif defined(T_EF47S) || defined(T_EF45K) if(hw_rev < 5) { mbhc_cfg.gpio = 0; mbhc_cfg.gpio_irq = 0; } #elif defined(T_EF46L) if(hw_rev < 4) { mbhc_cfg.gpio = 0; mbhc_cfg.gpio_irq = 0; } #endif #endif #ifdef CONFIG_PANTECH_SND //kdkim #if defined(T_STARQ) || defined(T_OSCAR) || defined(T_EF45K) || defined(T_EF46L) || defined(T_EF47S) if (mbhc_cfg.gpio) { ret = gpio_request(JACK_DETECT_GPIO, "headset_detect"); if(ret){ pr_err("%s: gpio_request failed %d\n", __func__, ret); headset_gpio_config = false; gpio_free(JACK_DETECT_GPIO); } ret = gpio_direction_input(mbhc_cfg.gpio); if(ret){ pr_err("%s: gpio_direction_input failed %d\n", __func__, ret); headset_gpio_config = false; gpio_free(JACK_DETECT_GPIO); } mbhc_cfg.gpio_irq = gpio_to_irq(mbhc_cfg.gpio); } #endif #else //Qualcomm original if (GPIO_DETECT_USED) { mbhc_cfg.gpio = PM8921_GPIO_PM_TO_SYS(JACK_DETECT_GPIO); mbhc_cfg.gpio_irq = JACK_DETECT_INT; } if (mbhc_cfg.gpio) { err = pm8xxx_gpio_config(mbhc_cfg.gpio, &jack_gpio_cfg); if (err) { pr_err("%s: pm8xxx_gpio_config failed %d\n", __func__, err); return err; } } #endif err = tabla_hs_detect(codec, &mbhc_cfg); return err; } static struct snd_soc_dsp_link lpa_fe_media = { .playback = true, .trigger = { SND_SOC_DSP_TRIGGER_POST, SND_SOC_DSP_TRIGGER_POST }, }; static struct snd_soc_dsp_link fe_media = { .playback = true, .capture = true, .trigger = { SND_SOC_DSP_TRIGGER_POST, SND_SOC_DSP_TRIGGER_POST }, }; /* bi-directional media definition for hostless PCM device */ static struct snd_soc_dsp_link bidir_hl_media = { .playback = true, .capture = true, .trigger = { SND_SOC_DSP_TRIGGER_POST, SND_SOC_DSP_TRIGGER_POST }, }; static struct snd_soc_dsp_link hdmi_rx_hl = { .playback = true, .trigger = { SND_SOC_DSP_TRIGGER_POST, SND_SOC_DSP_TRIGGER_POST }, }; static int msm8960_slim_0_rx_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, struct snd_pcm_hw_params *params) { struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); pr_debug("%s()\n", __func__); rate->min = rate->max = 48000; channels->min = channels->max = msm8960_slim_0_rx_ch; return 0; } static int msm8960_slim_0_tx_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, struct snd_pcm_hw_params *params) { struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); pr_debug("%s()\n", __func__); rate->min = rate->max = 48000; channels->min = channels->max = msm8960_slim_0_tx_ch; return 0; } static int msm8960_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, struct snd_pcm_hw_params *params) { struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); pr_debug("%s()\n", __func__); rate->min = rate->max = 48000; return 0; } static int msm8960_hdmi_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, struct snd_pcm_hw_params *params) { struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); pr_debug("%s channels->min %u channels->max %u ()\n", __func__, channels->min, channels->max); rate->min = rate->max = 48000; return 0; } static int msm8960_btsco_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, struct snd_pcm_hw_params *params) { struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); rate->min = rate->max = msm8960_btsco_rate; channels->min = channels->max = msm8960_btsco_ch; return 0; } static int msm8960_auxpcm_be_params_fixup(struct snd_soc_pcm_runtime *rtd, struct snd_pcm_hw_params *params) { struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); /* PCM only supports mono output with 8khz sample rate */ rate->min = rate->max = 8000; channels->min = channels->max = 1; return 0; } static int msm8960_aux_pcm_get_gpios(void) { int ret = 0; pr_debug("%s\n", __func__); ret = gpio_request(GPIO_AUX_PCM_DOUT, "AUX PCM DOUT"); if (ret < 0) { pr_err("%s: Failed to request gpio(%d): AUX PCM DOUT", __func__, GPIO_AUX_PCM_DOUT); goto fail_dout; } ret = gpio_request(GPIO_AUX_PCM_DIN, "AUX PCM DIN"); if (ret < 0) { pr_err("%s: Failed to request gpio(%d): AUX PCM DIN", __func__, GPIO_AUX_PCM_DIN); goto fail_din; } ret = gpio_request(GPIO_AUX_PCM_SYNC, "AUX PCM SYNC"); if (ret < 0) { pr_err("%s: Failed to request gpio(%d): AUX PCM SYNC", __func__, GPIO_AUX_PCM_SYNC); goto fail_sync; } ret = gpio_request(GPIO_AUX_PCM_CLK, "AUX PCM CLK"); if (ret < 0) { pr_err("%s: Failed to request gpio(%d): AUX PCM CLK", __func__, GPIO_AUX_PCM_CLK); goto fail_clk; } return 0; fail_clk: gpio_free(GPIO_AUX_PCM_SYNC); fail_sync: gpio_free(GPIO_AUX_PCM_DIN); fail_din: gpio_free(GPIO_AUX_PCM_DOUT); fail_dout: return ret; } static int msm8960_aux_pcm_free_gpios(void) { gpio_free(GPIO_AUX_PCM_DIN); gpio_free(GPIO_AUX_PCM_DOUT); gpio_free(GPIO_AUX_PCM_SYNC); gpio_free(GPIO_AUX_PCM_CLK); return 0; } static int msm8960_startup(struct snd_pcm_substream *substream) { pr_debug("%s(): substream = %s stream = %d\n", __func__, substream->name, substream->stream); return 0; } static int msm8960_auxpcm_startup(struct snd_pcm_substream *substream) { int ret = 0; pr_debug("%s(): substream = %s\n", __func__, substream->name); ret = msm8960_aux_pcm_get_gpios(); if (ret < 0) { pr_err("%s: Aux PCM GPIO request failed\n", __func__); return -EINVAL; } return 0; } static void msm8960_auxpcm_shutdown(struct snd_pcm_substream *substream) { pr_debug("%s(): substream = %s\n", __func__, substream->name); msm8960_aux_pcm_free_gpios(); }
#if defined(T_STARQ) #define JACK_DETECT_GPIO 50 #define JACK_DETECT_INT MSM_GPIO_TO_INT(JACK_DETECT_GPIO) #define GPIO_DETECT_USED JACK_DETECT_INT #elif defined(T_OSCAR) || defined(T_EF45K) || defined(T_EF46L) || defined(T_EF47S) #define JACK_DETECT_GPIO 35 #define JACK_DETECT_INT MSM_GPIO_TO_INT(JACK_DETECT_GPIO) #define GPIO_DETECT_USED JACK_DETECT_INT #else //Qualcomm original #define JACK_DETECT_GPIO 38 #define JACK_DETECT_INT PM8921_GPIO_IRQ(PM8921_IRQ_BASE, JACK_DETECT_GPIO) #define GPIO_DETECT_USED false #endif #endif static u32 top_spk_pamp_gpio = PM8921_GPIO_PM_TO_SYS(18); static u32 bottom_spk_pamp_gpio = PM8921_GPIO_PM_TO_SYS(19); static int msm8960_spk_control; static int msm8960_ext_bottom_spk_pamp; static int msm8960_ext_top_spk_pamp; static int msm8960_slim_0_rx_ch = 1; static int msm8960_slim_0_tx_ch = 1; static int msm8960_btsco_rate = BTSCO_RATE_8KHZ; static int msm8960_btsco_ch = 1; static struct clk *codec_clk; static int clk_users; static int msm8960_headset_gpios_configured;
static struct mmc_platform_data *apq8064_sdc2_pdata; #endif #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT static unsigned int sdc3_sup_clk_rates[] = { 400000, 24000000, 48000000, 96000000, 192000000 }; static struct mmc_platform_data sdc3_data = { .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, .mmc_bus_width = MMC_CAP_4_BIT_DATA, .sup_clk_table = sdc3_sup_clk_rates, .sup_clk_cnt = ARRAY_SIZE(sdc3_sup_clk_rates), .pin_data = &mmc_slot_pin_data[SDCC3], .vreg_data = &mmc_slot_vreg_data[SDCC3], .wpswitch_gpio = PM8921_GPIO_PM_TO_SYS(17), .is_wpswitch_active_low = true, .status_gpio = 26, .status_irq = MSM_GPIO_TO_INT(26), .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, .is_status_gpio_active_low = 1, .xpc_cap = 1, .uhs_caps = (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_DDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_MAX_CURRENT_800), .mpm_sdiowakeup_int = MSM_MPM_PIN_SDC3_DAT1, .msm_bus_voting_data = &sps_to_ddr_bus_voting_data, }; static struct mmc_platform_data *apq8064_sdc3_pdata = &sdc3_data; #else static struct mmc_platform_data *apq8064_sdc3_pdata;
* microphones operating at 1800 mV. Technically, all micbiases * can source from single cfilter since all microphones operate * at the same voltage level. The arrangement below is to make * sure all cfilters are exercised. LDO_H regulator ouput level * does not need to be as high as 2.85V. It is choosen for * microphone sensitivity purpose. */ static struct tabla_pdata apq8064_tabla_platform_data = { .slimbus_slave_device = { .name = "tabla-slave", .e_addr = {0, 0, 0x10, 0, 0x17, 2}, }, .irq = MSM_GPIO_TO_INT(62), .irq_base = TABLA_INTERRUPT_BASE, .num_irqs = NR_TABLA_IRQS, .reset_gpio = PM8921_GPIO_PM_TO_SYS(34), .micbias = { .ldoh_v = TABLA_LDOH_2P85_V, .cfilt1_mv = 1800, .cfilt2_mv = 1800, .cfilt3_mv = 1800, .bias1_cfilt_sel = TABLA_CFILT1_SEL, .bias2_cfilt_sel = TABLA_CFILT2_SEL, .bias3_cfilt_sel = TABLA_CFILT3_SEL, .bias4_cfilt_sel = TABLA_CFILT3_SEL, } }; static struct slim_device apq8064_slim_tabla = { .name = "tabla-slim", .e_addr = {0, 1, 0x10, 0, 0x17, 2},
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev) { int ret, rc; struct platform_device *msm_fb_added_dev; struct lcd_device *lcd_device; struct backlight_device *bd = NULL; printk(KERN_INFO "[lcd] mipi_samsung_disp_probe start\n"); if (pdev->id == 0) { msd.mipi_samsung_disp_pdata = pdev->dev.platform_data; printk(KERN_INFO "[lcd] pdev->id =%d, pdev-name = %s\n", pdev->id, pdev->name); sec_debug_mdp_init(); printk(KERN_INFO "[lcd] mipi_samsung_disp_probe end since pdev-id is 0\n"); return 0; } printk(KERN_INFO "[lcd] msm_fb_add_device : %s\n", pdev->name); msm_fb_added_dev = msm_fb_add_device(pdev); mutex_init(&dsi_tx_mutex); #if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE) msd.msm_pdev = msm_fb_added_dev; #endif pm_gpio8 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_ERR_FG); rc = gpio_request(pm_gpio8, "err_fg"); if (rc) { pr_err("request gpio err_fg failed, rc=%d\n", rc); return -ENODEV; } rc = pm8xxx_gpio_config(pm_gpio8, &gpio_get_param); if (rc) { pr_err("gpio_config mlcd_rst failed (3), rc=%d\n", rc); return -EINVAL; } #if defined(CONFIG_HAS_EARLYSUSPEND) msd.early_suspend.suspend = mipi_samsung_disp_early_suspend; msd.early_suspend.resume = mipi_samsung_disp_late_resume; msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; register_early_suspend(&msd.early_suspend); #endif #if defined(CONFIG_LCD_CLASS_DEVICE) printk(KERN_INFO "[lcd] lcd_device_register for panel start\n"); lcd_device = lcd_device_register("panel", &pdev->dev, NULL, &mipi_samsung_disp_props); if (IS_ERR(lcd_device)) { ret = PTR_ERR(lcd_device); printk(KERN_ERR "lcd : failed to register device\n"); return ret; } sysfs_remove_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_power.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_type.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_window_type.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_window_type.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_power_reduce.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_power_reduce.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_siop_enable.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_siop_enable.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_backlight.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_backlight.attr.name); } #if defined(RUMTIME_MIPI_CLK_CHANGE) ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_fps_change.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_fps_change.attr.name); } #endif ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_temperature.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_temperature.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_panel_colors.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_panel_colors.attr.name); } printk(KERN_INFO "[lcd] backlight_device_register for panel start\n"); bd = backlight_device_register("panel", &lcd_device->dev, NULL, NULL, NULL); if (IS_ERR(bd)) { ret = PTR_ERR(bd); pr_info("backlight : failed to register device\n"); return ret; } ret = sysfs_create_file(&bd->dev.kobj, &dev_attr_auto_brightness.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_auto_brightness.attr.name); } #endif #if defined(CONFIG_MDNIE_LITE_TUNING) pr_info("[%s] CONFIG_MDNIE_LITE_TUNING ok ! init class called!\n", __func__); mdnie_lite_tuning_init(); #endif #if defined(DDI_VIDEO_ENHANCE_TUNING) ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_tuning.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_tuning.attr.name); } #endif printk(KERN_INFO "[lcd] mipi_samsung_disp_probe end\n"); return 0; }
static void mipi_dsi_panel_pwm_cfg(void) { int rc; static int mipi_dsi_panel_gpio_configured; static struct pm_gpio pwm_enable = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 1, .pull = PM_GPIO_PULL_NO, .vin_sel = PM_GPIO_VIN_VPH, .out_strength = PM_GPIO_STRENGTH_HIGH, .function = PM_GPIO_FUNC_NORMAL, .inv_int_pol = 0, .disable_pin = 0, }; static struct pm_gpio pwm_mode = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 0, .pull = PM_GPIO_PULL_NO, .vin_sel = PM_GPIO_VIN_S4, .out_strength = PM_GPIO_STRENGTH_HIGH, .function = PM_GPIO_FUNC_2, .inv_int_pol = 0, .disable_pin = 0, }; if (mipi_dsi_panel_gpio_configured == 0) { /* pm8xxx: gpio-21, Backlight Enable */ rc = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(21), &pwm_enable); if (rc != 0) pr_err("%s: pwm_enabled failed\n", __func__); /* pm8xxx: gpio-24, Bl: Off, PWM mode */ rc = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(24), &pwm_mode); if (rc != 0) pr_err("%s: pwm_mode failed\n", __func__); mipi_dsi_panel_gpio_configured++; } } /** * LiQUID panel on/off * * @param on * * @return int */ static int mipi_dsi_liquid_panel_power(int on) { static struct regulator *reg_l2, *reg_ext_3p3v; static int gpio21, gpio24, gpio43; int rc; mipi_dsi_panel_pwm_cfg(); pr_debug("%s: on=%d\n", __func__, on); gpio21 = PM8921_GPIO_PM_TO_SYS(21); /* disp power enable_n */ gpio43 = PM8921_GPIO_PM_TO_SYS(43); /* Displays Enable (rst_n)*/ gpio24 = PM8921_GPIO_PM_TO_SYS(24); /* Backlight PWM */ if (!dsi_power_on) { reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } reg_ext_3p3v = regulator_get(&msm_mipi_dsi1_device.dev, "vdd_lvds_3p3v"); if (IS_ERR(reg_ext_3p3v)) { pr_err("could not get reg_ext_3p3v, rc = %ld\n", PTR_ERR(reg_ext_3p3v)); return -ENODEV; } rc = gpio_request(gpio21, "disp_pwr_en_n"); if (rc) { pr_err("request gpio 21 failed, rc=%d\n", rc); return -ENODEV; } rc = gpio_request(gpio43, "disp_rst_n"); if (rc) { pr_err("request gpio 43 failed, rc=%d\n", rc); return -ENODEV; } rc = gpio_request(gpio24, "disp_backlight_pwm"); if (rc) { pr_err("request gpio 24 failed, rc=%d\n", rc); return -ENODEV; } dsi_power_on = true; } if (on) { rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_enable(reg_ext_3p3v); if (rc) { pr_err("enable reg_ext_3p3v failed, rc=%d\n", rc); return -ENODEV; } /* set reset pin before power enable */ gpio_set_value_cansleep(gpio43, 0); /* disp disable (resx=0) */ gpio_set_value_cansleep(gpio21, 0); /* disp power enable_n */ msleep(20); gpio_set_value_cansleep(gpio43, 1); /* disp enable */ msleep(20); gpio_set_value_cansleep(gpio43, 0); /* disp enable */ msleep(20); gpio_set_value_cansleep(gpio43, 1); /* disp enable */ msleep(20); } else { gpio_set_value_cansleep(gpio43, 0); gpio_set_value_cansleep(gpio21, 1); rc = regulator_disable(reg_l2); if (rc) { pr_err("disable reg_l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_ext_3p3v); if (rc) { pr_err("disable reg_ext_3p3v failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l2, 100); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } } return 0; } static int mipi_dsi_cdp_panel_power(int on) { static struct regulator *reg_l8, *reg_l23, *reg_l2; static int gpio43; int rc; pr_debug("%s: state : %d\n", __func__, on); if (!dsi_power_on) { reg_l8 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdc"); if (IS_ERR(reg_l8)) { pr_err("could not get 8921_l8, rc = %ld\n", PTR_ERR(reg_l8)); return -ENODEV; } reg_l23 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vddio"); if (IS_ERR(reg_l23)) { pr_err("could not get 8921_l23, rc = %ld\n", PTR_ERR(reg_l23)); return -ENODEV; } reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l8, 2800000, 3000000); if (rc) { pr_err("set_voltage l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_voltage(reg_l23, 1800000, 1800000); if (rc) { pr_err("set_voltage l23 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } gpio43 = PM8921_GPIO_PM_TO_SYS(43); rc = gpio_request(gpio43, "disp_rst_n"); if (rc) { pr_err("request gpio 43 failed, rc=%d\n", rc); return -ENODEV; } dsi_power_on = true; } if (on) { rc = regulator_set_optimum_mode(reg_l8, 100000); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l23, 100000); if (rc < 0) { pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l8); if (rc) { pr_err("enable l8 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_enable(reg_l23); if (rc) { pr_err("enable l8 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } gpio_set_value_cansleep(gpio43, 1); } else { rc = regulator_disable(reg_l2); if (rc) { pr_err("disable reg_l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_l8); if (rc) { pr_err("disable reg_l8 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_l23); if (rc) { pr_err("disable reg_l23 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l8, 100); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l23, 100); if (rc < 0) { pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } gpio_set_value_cansleep(gpio43, 0); } return 0; } static int mipi_dsi_panel_power(int on) { int ret; pr_debug("%s: on=%d\n", __func__, on); if (machine_is_msm8960_liquid()) ret = mipi_dsi_liquid_panel_power(on); else ret = mipi_dsi_cdp_panel_power(on); return ret; } #elif defined(CONFIG_FB_MSM_MIPI_LGIT_LH470WX1_VIDEO_HD_PT) int mipi_dsi_panel_power(int on) { static struct regulator *reg_l8, *reg_l2, *reg_lvs6; static int gpio20; int rc; struct pm_gpio gpio20_param = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 1, .pull = PM_GPIO_PULL_NO, .vin_sel = 2, .out_strength = PM_GPIO_STRENGTH_HIGH, .function = PM_GPIO_FUNC_PAIRED, .inv_int_pol = 0, .disable_pin = 0, }; pr_debug("%s: state : %d\n", __func__, on); if (!dsi_power_on) { reg_l8 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdc"); if (IS_ERR(reg_l8)) { pr_err("could not get 8921_l8, rc = %ld\n", PTR_ERR(reg_l8)); return -ENODEV; } reg_lvs6 = regulator_get(&msm_mipi_dsi1_device.dev, "8921_lvs6"); if (IS_ERR(reg_lvs6)) { pr_err("could not get 8921_lvs6, rc = %ld\n", PTR_ERR(reg_lvs6)); return -ENODEV; } reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l8, 3000000, 3000000); if (rc) { pr_err("set_voltage l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } gpio20 = PM8921_GPIO_PM_TO_SYS(20); rc = gpio_request(gpio20, "disp_rst_n"); if (rc) { pr_err("request gpio 20 failed, rc=%d\n", rc); return -ENODEV; } rc = pm8xxx_gpio_config(gpio20, &gpio20_param); if (rc) { pr_err("gpio_config 20 failed (4), rc=%d\n", rc); return -EINVAL; } dsi_power_on = true; } if (on) { rc = regulator_set_optimum_mode(reg_l8, 100000); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_lvs6, 100000); if (rc < 0) { pr_err("set_optimum_mode lvs6 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_lvs6); if (rc) { pr_err("enable lvs6 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); rc = regulator_enable(reg_l8); if (rc) { pr_err("enable l8 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } mdelay(5); } else { gpio_set_value_cansleep(gpio20, 0); rc = regulator_disable(reg_l8); if (rc) { pr_err("disable reg_l8 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_lvs6); if (rc) { pr_err("disable reg_lvs6 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l8, 100); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_lvs6, 100); if (rc < 0) { pr_err("set_optimum_mode lvs6 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } } return 0; } #elif defined(CONFIG_FB_MSM_MIPI_LGIT_VIDEO_HD_PT) static int mipi_dsi_panel_power(int on) { static struct regulator *reg_l8, *reg_l2, *reg_lvs6; static int gpio43; int rc; struct pm_gpio gpio43_param = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 0, .pull = PM_GPIO_PULL_NO, .vin_sel = 2, .out_strength = PM_GPIO_STRENGTH_HIGH, .function = PM_GPIO_FUNC_PAIRED, .inv_int_pol = 0, .disable_pin = 0, }; pr_debug("%s: state : %d\n", __func__, on); if (!dsi_power_on) { reg_l8 = regulator_get(&msm_mipi_dsi1_device.dev, "8921_l8"); if (IS_ERR(reg_l8)) { pr_err("could not get 8921_l8, rc = %ld\n", PTR_ERR(reg_l8)); return -ENODEV; } reg_lvs6 = regulator_get(&msm_mipi_dsi1_device.dev, "8921_lvs6"); if (IS_ERR(reg_lvs6)) { pr_err("could not get 8921_lvs6, rc = %ld\n", PTR_ERR(reg_lvs6)); return -ENODEV; } reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l8, 3000000, 3000000); if (rc) { pr_err("set_voltage l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } gpio43 = PM8921_GPIO_PM_TO_SYS(43); rc = gpio_request(gpio43, "disp_rst_n"); if (rc) { pr_err("request gpio 43 failed, rc=%d\n", rc); return -ENODEV; } dsi_power_on = true; } if (on) { //gpio_set_value_cansleep(gpio43, 0); rc = regulator_set_optimum_mode(reg_l8, 100000); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l8); // dsi_vci if (rc) { pr_err("enable l8 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); // 100us rc = regulator_enable(reg_lvs6); if (rc) { pr_err("enable lvs6 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } printk(KERN_INFO " %s : reset start.", __func__); // LCD RESET HIGH mdelay(2); gpio43_param.pull = PM_GPIO_PULL_NO; rc = pm8xxx_gpio_config(gpio43, &gpio43_param); if (rc) { pr_err("gpio_config 43 failed (1), rc=%d\n", rc); return -EINVAL; } gpio43_param.pull = PM_GPIO_PULL_UP_30; rc = pm8xxx_gpio_config(gpio43, &gpio43_param); if (rc) { pr_err("gpio_config 43 failed (2), rc=%d\n", rc); return -EINVAL; } gpio43_param.pull = PM_GPIO_PULL_NO; rc = pm8xxx_gpio_config(gpio43, &gpio43_param); if (rc) { pr_err("gpio_config 43 failed (3), rc=%d\n", rc); return -EINVAL; } gpio43_param.pull = PM_GPIO_PULL_UP_30; rc = pm8xxx_gpio_config(gpio43, &gpio43_param); if (rc) { pr_err("gpio_config 43 failed (4), rc=%d\n", rc); return -EINVAL; } gpio_set_value_cansleep(gpio43, 1); mdelay(11); } else { gpio_set_value_cansleep(gpio43, 0); udelay(100); rc = regulator_disable(reg_lvs6); if (rc) { pr_err("disable reg_lvs6 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); rc = regulator_disable(reg_l8); if (rc) { pr_err("disable reg_l8 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); rc = regulator_disable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l8, 100); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } } return 0; } #else static int mipi_dsi_panel_power(int on) { int ret; pr_debug("%s: on=%d\n", __func__, on); if (machine_is_msm8960_liquid()) ret = mipi_dsi_liquid_panel_power(on); else ret = mipi_dsi_cdp_panel_power(on); return ret; } #endif static struct mipi_dsi_platform_data mipi_dsi_pdata = { .vsync_gpio = MDP_VSYNC_GPIO, .dsi_power_save = mipi_dsi_panel_power, .splash_is_enabled = mipi_dsi_splash_is_enabled, }; #ifdef CONFIG_LGE_LCD_TUNING static int tuning_read_porch(unsigned long tmp) { int size = ARRAY_SIZE(porch_value)*4; printk(KERN_INFO "read_porch_value\n"); if (copy_to_user((uint32_t *)tmp, porch_value, size)) { printk(KERN_ERR "read_file : error of copy_to_user_buff\n"); return -EFAULT; } return 0; } static int tuning_write_porch(unsigned long tmp) { u32 *buf; int size = ARRAY_SIZE(porch_value)*4; printk(KERN_INFO "write porch file\n"); buf = kmalloc(size, GFP_KERNEL); if (copy_from_user(buf, (u32 *)tmp, size)) { printk(KERN_ERR "write_file : error of copy_from_user\n"); return -EFAULT; } memcpy(porch_value, buf, size); kfree(buf); return 0; }
static int mipi_dsi_panel_power(int on) { static struct regulator *reg_lvs5, *reg_l2; static int gpio36, gpio37; int rc; PR_DISP_INFO("%s: on=%d\n", __func__, on); if (!dsi_power_on) { reg_lvs5 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi1_vddio"); if (IS_ERR_OR_NULL(reg_lvs5)) { pr_err("could not get 8921_lvs5, rc = %ld\n", PTR_ERR(reg_lvs5)); return -ENODEV; } reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi1_pll_vdda"); if (IS_ERR_OR_NULL(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } gpio36 = PM8921_GPIO_PM_TO_SYS(V_LCM_N5V_EN); rc = gpio_request(gpio36, "lcd_5v-"); if (rc) { pr_err("request lcd_5v- failed, rc=%d\n", rc); return -ENODEV; } gpio37 = PM8921_GPIO_PM_TO_SYS(V_LCM_P5V_EN); rc = gpio_request(gpio37, "lcd_5v+"); if (rc) { pr_err("request lcd_5v+ failed, rc=%d\n", rc); return -ENODEV; } gpio_tlmm_config(GPIO_CFG(LCD_RST, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); dsi_power_on = true; } if (on) { if (!first_init) { rc = regulator_enable(reg_lvs5); if (rc) { pr_err("enable lvs5 failed, rc=%d\n", rc); return -ENODEV; } msleep(200); gpio_set_value_cansleep(gpio37, 1); msleep(10); gpio_set_value_cansleep(gpio36, 1); rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } msm_xo_mode_vote(wa_xo, MSM_XO_MODE_ON); gpio_set_value(LCD_RST, 0); msleep(10); gpio_set_value(LCD_RST, 1); msm_xo_mode_vote(wa_xo, MSM_XO_MODE_OFF); } else { rc = regulator_enable(reg_lvs5); if (rc) { pr_err("enable lvs5 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } msm_xo_mode_vote(wa_xo, MSM_XO_MODE_ON); msleep(10); msm_xo_mode_vote(wa_xo, MSM_XO_MODE_OFF); } } else { gpio_tlmm_config(GPIO_CFG(BL_HW_EN, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); gpio_set_value(BL_HW_EN, 0); gpio_set_value(LCD_RST, 0); msleep(10); rc = regulator_disable(reg_l2); if (rc) { pr_err("disable reg_l2 failed, rc=%d\n", rc); return -ENODEV; } gpio_set_value_cansleep(gpio36, 0); msleep(10); gpio_set_value_cansleep(gpio37, 0); msleep(100); rc = regulator_disable(reg_lvs5); if (rc) { pr_err("disable reg_lvs5 failed, rc=%d\n", rc); return -ENODEV; } } return 0; }
.pin_data = &mmc_slot_pin_data[SDCC2], .sdiowakeup_irq = MSM_GPIO_TO_INT(90), .msm_bus_voting_data = &sps_to_ddr_bus_voting_data, }; #endif #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT static unsigned int fighter_sd_slot_type = MMC_TYPE_SD; static struct mmc_platform_data msm8960_sdc3_data = { .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, .mmc_bus_width = MMC_CAP_4_BIT_DATA, .sup_clk_table = sdc3_sup_clk_rates, .sup_clk_cnt = ARRAY_SIZE(sdc3_sup_clk_rates), .slot_type = &fighter_sd_slot_type, #ifdef CONFIG_MMC_MSM_SDC3_WP_SUPPORT .wpswitch_gpio = PM8921_GPIO_PM_TO_SYS(16), #endif .vreg_data = &mmc_slot_vreg_data[SDCC3], .pin_data = &mmc_slot_pin_data[SDCC3], #ifdef CONFIG_MMC_MSM_CARD_HW_DETECTION .status_gpio = PM8921_GPIO_PM_TO_SYS(FIGHTER_PMGPIO_SD_CDETz), .status_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE, FIGHTER_PMGPIO_SD_CDETz), .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, .is_status_gpio_active_low = true, #endif #if 0 .xpc_cap = 1, .uhs_caps = (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_DDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_MAX_CURRENT_600), #endif
#endif #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT static unsigned int sdc3_sup_clk_rates[] = { 400000, 24000000, 48000000, 96000000, 192000000 }; static struct mmc_platform_data sdc3_data = { .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, .mmc_bus_width = MMC_CAP_4_BIT_DATA, .sup_clk_table = sdc3_sup_clk_rates, .sup_clk_cnt = ARRAY_SIZE(sdc3_sup_clk_rates), .pin_data = &mmc_slot_pin_data[SDCC3], .vreg_data = &mmc_slot_vreg_data[SDCC3], #ifdef CONFIG_PANTECH_EXTERNAL_SDCARD .status_gpio = PM8921_GPIO_PM_TO_SYS(24), .status_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE, 24), #else .wpswitch_gpio = PM8921_GPIO_PM_TO_SYS(17), .is_wpswitch_active_low = true, .status_gpio = 26, .status_irq = MSM_GPIO_TO_INT(26), #endif .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, .is_status_gpio_active_low = 1, .xpc_cap = 1, .uhs_caps = (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_DDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_MAX_CURRENT_800), .mpm_sdiowakeup_int = MSM_MPM_PIN_SDC3_DAT1, .msm_bus_voting_data = &sps_to_ddr_bus_voting_data,
#ifdef CONFIG_MMC_MSM_SDC3_SUPPORT static unsigned int sdc3_sup_clk_rates[] = { 400000, 24000000, 45176400, 96000000, 192000000 }; static unsigned int dlxj_sdc3_slot_type = MMC_TYPE_SD; static struct mmc_platform_data sdc3_data = { .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, .mmc_bus_width = MMC_CAP_4_BIT_DATA, .sup_clk_table = sdc3_sup_clk_rates, .sup_clk_cnt = ARRAY_SIZE(sdc3_sup_clk_rates), .pin_data = &mmc_slot_pin_data[SDCC3], .vreg_data = &mmc_slot_vreg_data[SDCC3], .status_gpio = PM8921_GPIO_PM_TO_SYS(SD_CDETz), .status_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE, SD_CDETz), .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, .is_status_gpio_active_low = 1, .slot_type = &dlxj_sdc3_slot_type, #if 0 .xpc_cap = 1, .uhs_caps = (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_DDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_MAX_CURRENT_800), #endif .msm_bus_voting_data = &sps_to_ddr_bus_voting_data, }; static struct mmc_platform_data *deluxe_j_sdc3_pdata = &sdc3_data; #else static struct mmc_platform_data *deluxe_j_sdc3_pdata;
static __devinit int tspdrv_probe(struct platform_device *pdev) { struct vibrator_platform_data *pdata; int ret, i; /* initialized below */ DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n")); /* This condition will be removed,after all board files changes done */ if (pdev->dev.platform_data == NULL) { vibrator_drvdata.is_pmic_vib_en = 0; #if defined(CONFIG_MACH_M2_ATT) || defined(CONFIG_MACH_M2_VZW) || \ defined(CONFIG_MACH_M2_SPR) || defined(CONFIG_MACH_M2_DCM) || \ defined(CONFIG_MACH_M2_SKT) || defined(CONFIG_MACH_JAGUAR) || \ defined(CONFIG_MACH_AEGIS2) || defined(CONFIG_MACH_COMANCHE) vibrator_drvdata.vib_pwm_gpio = GPIO_VIB_PWM; vibrator_drvdata.vib_en_gpio = GPIO_VIB_ON; vibrator_drvdata.haptic_pwr_en_gpio = GPIO_HAPTIC_PWR_EN; vibrator_drvdata.vib_model = HAPTIC_PWM; #endif #if defined(CONFIG_MACH_APEXQ) || defined(CONFIG_MACH_JASPER) || \ defined(CONFIG_MACH_GOGH) || defined(CONFIG_MACH_ESPRESSO_ATT) vibrator_drvdata.vib_pwm_gpio = GPIO_MOTOR_EN; vibrator_drvdata.vib_en_gpio = GPIO_MOTOR_EN; vibrator_drvdata.haptic_pwr_en_gpio = GPIO_MOTOR_EN; vibrator_drvdata.vib_model = HAPTIC_MOTOR; #endif #ifdef CONFIG_MACH_M2_ATT if (system_rev >= BOARD_REV04) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } if (system_rev >= BOARD_REV08) { vibrator_drvdata.haptic_pwr_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_HAPTIC_PWR_EN); vibrator_drvdata.is_pmic_haptic_pwr_en = 1; } #endif #ifdef CONFIG_MACH_M2_VZW if (system_rev >= BOARD_REV09) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_M2_SPR if (system_rev >= BOARD_REV03) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_M2_DCM if (system_rev >= BOARD_REV01) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_AEGIS2 if (system_rev >= BOARD_REV01) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif } else { pdata = pdev->dev.platform_data; vibrator_drvdata.vib_model = pdata->vib_model; vibrator_drvdata.is_pmic_haptic_pwr_en = \ pdata->is_pmic_haptic_pwr_en; if (pdata->is_pmic_haptic_pwr_en) vibrator_drvdata.haptic_pwr_en_gpio = \ PM8921_GPIO_PM_TO_SYS(pdata->haptic_pwr_en_gpio); else vibrator_drvdata.haptic_pwr_en_gpio = \ pdata->haptic_pwr_en_gpio; if (pdata->vib_model == HAPTIC_PWM) { vibrator_drvdata.vib_pwm_gpio = pdata->vib_pwm_gpio; vibrator_drvdata.is_pmic_vib_en = \ pdata->is_pmic_vib_en; if (pdata->is_pmic_vib_en) vibrator_drvdata.vib_en_gpio = \ PM8921_GPIO_PM_TO_SYS(pdata->vib_en_gpio); else vibrator_drvdata.vib_en_gpio = \ pdata->vib_en_gpio; } } #ifdef IMPLEMENT_AS_CHAR_DRIVER g_nmajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nmajor < 0) { DbgOut((KERN_ERR "tspdrv: can't get major number.\n")); ret = g_nmajor; goto register_err; } #else ret = misc_register(&miscdev); if (ret) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); goto register_err; } #endif DbgRecorderInit(()); vibetonz_clk_on(&pdev->dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchdevice_name = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szdevice_name + g_cchdevice_name; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strncat(szName, VERSION_STR, sizeof(VERSION_STR)); g_cchdevice_name += strnlen(szName, sizeof(szName)); g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */ g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0; g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vibetonz_start(); return 0; register_err: #ifdef IMPLEMENT_AS_CHAR_DRIVER unregister_chrdev(g_nmajor, MODULE_NAME); #else misc_deregister(&miscdev); #endif return ret; }
.sup_clk_cnt = ARRAY_SIZE(sdc2_sup_clk_rates), .vreg_data = &mmc_slot_vreg_data[SDCC2], .pin_data = &mmc_slot_pin_data[SDCC2], .sdiowakeup_irq = MSM_GPIO_TO_INT(90), .msm_bus_voting_data = &sps_to_ddr_bus_voting_data, }; #endif #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT static struct mmc_platform_data msm8960_sdc3_data = { .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, .mmc_bus_width = MMC_CAP_4_BIT_DATA, .sup_clk_table = sdc3_sup_clk_rates, .sup_clk_cnt = ARRAY_SIZE(sdc3_sup_clk_rates), #ifdef CONFIG_MMC_MSM_SDC3_WP_SUPPORT .wpswitch_gpio = PM8921_GPIO_PM_TO_SYS(16), #endif .vreg_data = &mmc_slot_vreg_data[SDCC3], .pin_data = &mmc_slot_pin_data[SDCC3], #ifndef CONFIG_MMC_MSM_SDC3_POLLING .status_gpio = PM8921_GPIO_PM_TO_SYS(26), .status_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE, 26), .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, #endif .is_status_gpio_active_low = true, .xpc_cap = 1, .uhs_caps = (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_DDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_MAX_CURRENT_600), .mpm_sdiowakeup_int = MSM_MPM_PIN_SDC3_DAT1, .msm_bus_voting_data = &sps_to_ddr_bus_voting_data,
#endif #ifdef CONFIG_MMC_MSM_SDC4_SUPPORT static unsigned int sdc4_sup_clk_rates[] = { 400000, 24000000, 48000000, 96000000, 192000000 }; static unsigned int sdc4_slot_type = MMC_TYPE_SD; static struct mmc_platform_data sdc4_data = { .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, .config_sdgpio = msm_sdcc_setup_gpio, .mmc_bus_width = MMC_CAP_4_BIT_DATA, .sup_clk_table = sdc4_sup_clk_rates, .sup_clk_cnt = ARRAY_SIZE(sdc4_sup_clk_rates), .vreg_data = &mmc_slot_vreg_data[SDCC4], .status_gpio = PM8921_GPIO_PM_TO_SYS(25), .status_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE, 25), .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, .is_status_gpio_active_low = 1, .slot_type = &sdc4_slot_type, #if 0 .xpc_cap = 1, .uhs_caps = (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_DDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_MAX_CURRENT_800), #endif .msm_bus_voting_data = &sps_to_ddr_bus_voting_data, }; static struct mmc_platform_data *m7wlj_sdc4_pdata = &sdc4_data; #else static struct mmc_platform_data *m7wlj_sdc4_pdata;
void __init apq8064_init_mmc(void) { if (apq8064_sdc1_pdata) { /* 8064 v2 supports upto 200MHz clock on SDC1 slot */ if (SOCINFO_VERSION_MAJOR(socinfo_get_version()) >= 2) { apq8064_sdc1_pdata->sup_clk_table = sdc1_sup_clk_rates_all; apq8064_sdc1_pdata->sup_clk_cnt = ARRAY_SIZE(sdc1_sup_clk_rates_all); } apq8064_add_sdcc(1, apq8064_sdc1_pdata); } msm_add_uio(); if (apq8064_sdc2_pdata) apq8064_add_sdcc(2, apq8064_sdc2_pdata); if (apq8064_sdc3_pdata) { if (!machine_is_apq8064_cdp()) { apq8064_sdc3_pdata->wpswitch_gpio = 0; #if defined(CONFIG_MACH_LGE) //apq8064_sdc3_pdata->is_wpswitch_active_low = false; #endif } if (machine_is_mpq8064_cdp() || machine_is_mpq8064_hrd() || machine_is_mpq8064_dtv()) { int rc; struct pm_gpio sd_card_det_init_cfg = { .direction = PM_GPIO_DIR_IN, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .pull = PM_GPIO_PULL_UP_30, .vin_sel = PM_GPIO_VIN_S4, .out_strength = PM_GPIO_STRENGTH_NO, .function = PM_GPIO_FUNC_NORMAL, }; apq8064_sdc3_pdata->status_gpio = PM8921_GPIO_PM_TO_SYS(31); apq8064_sdc3_pdata->status_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE, 31); rc = pm8xxx_gpio_config(apq8064_sdc3_pdata->status_gpio, &sd_card_det_init_cfg); if (rc) { pr_info("%s: SD_CARD_DET GPIO%d config " "failed(%d)\n", __func__, apq8064_sdc3_pdata->status_gpio, rc); apq8064_sdc3_pdata->status_gpio = 0; apq8064_sdc3_pdata->status_irq = 0; } } if (machine_is_apq8064_cdp()) { int i; for (i = 0; i < apq8064_sdc3_pdata->pin_data->pad_data->\ drv->size; i++) apq8064_sdc3_pdata->pin_data->pad_data->\ drv->on[i].val = GPIO_CFG_10MA; } apq8064_add_sdcc(3, apq8064_sdc3_pdata); }
static void mipi_dsi_panel_pwm_cfg(void) { int rc; static int mipi_dsi_panel_gpio_configured; static struct pm_gpio pwm_enable = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 1, .pull = PM_GPIO_PULL_NO, .vin_sel = PM_GPIO_VIN_VPH, .out_strength = PM_GPIO_STRENGTH_HIGH, .function = PM_GPIO_FUNC_NORMAL, .inv_int_pol = 0, .disable_pin = 0, }; static struct pm_gpio pwm_mode = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 0, .pull = PM_GPIO_PULL_NO, .vin_sel = PM_GPIO_VIN_S4, .out_strength = PM_GPIO_STRENGTH_HIGH, .function = PM_GPIO_FUNC_2, .inv_int_pol = 0, .disable_pin = 0, }; if (mipi_dsi_panel_gpio_configured == 0) { /* pm8xxx: gpio-21, Backlight Enable */ rc = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(21), &pwm_enable); if (rc != 0) pr_err("%s: pwm_enabled failed\n", __func__); /* pm8xxx: gpio-24, Bl: Off, PWM mode */ rc = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(24), &pwm_mode); if (rc != 0) pr_err("%s: pwm_mode failed\n", __func__); mipi_dsi_panel_gpio_configured++; } } static bool dsi_power_on; /** * LiQUID panel on/off * * @param on * * @return int */ static int mipi_dsi_liquid_panel_power(int on) { static struct regulator *reg_l2, *reg_ext_3p3v; static int gpio21, gpio24, gpio43; int rc; mipi_dsi_panel_pwm_cfg(); pr_debug("%s: on=%d\n", __func__, on); gpio21 = PM8921_GPIO_PM_TO_SYS(21); /* disp power enable_n */ gpio43 = PM8921_GPIO_PM_TO_SYS(43); /* Displays Enable (rst_n)*/ gpio24 = PM8921_GPIO_PM_TO_SYS(24); /* Backlight PWM */ if (!dsi_power_on) { reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } reg_ext_3p3v = regulator_get(&msm_mipi_dsi1_device.dev, "vdd_lvds_3p3v"); if (IS_ERR(reg_ext_3p3v)) { pr_err("could not get reg_ext_3p3v, rc = %ld\n", PTR_ERR(reg_ext_3p3v)); return -ENODEV; } rc = gpio_request(gpio21, "disp_pwr_en_n"); if (rc) { pr_err("request gpio 21 failed, rc=%d\n", rc); return -ENODEV; } rc = gpio_request(gpio43, "disp_rst_n"); if (rc) { pr_err("request gpio 43 failed, rc=%d\n", rc); return -ENODEV; } rc = gpio_request(gpio24, "disp_backlight_pwm"); if (rc) { pr_err("request gpio 24 failed, rc=%d\n", rc); return -ENODEV; } dsi_power_on = true; } if (on) { rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_enable(reg_ext_3p3v); if (rc) { pr_err("enable reg_ext_3p3v failed, rc=%d\n", rc); return -ENODEV; } /* set reset pin before power enable */ gpio_set_value_cansleep(gpio43, 0); /* disp disable (resx=0) */ gpio_set_value_cansleep(gpio21, 0); /* disp power enable_n */ msleep(20); gpio_set_value_cansleep(gpio43, 1); /* disp enable */ msleep(20); gpio_set_value_cansleep(gpio43, 0); /* disp enable */ msleep(20); gpio_set_value_cansleep(gpio43, 1); /* disp enable */ msleep(20); } else { gpio_set_value_cansleep(gpio43, 0); gpio_set_value_cansleep(gpio21, 1); rc = regulator_disable(reg_l2); if (rc) { pr_err("disable reg_l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_ext_3p3v); if (rc) { pr_err("disable reg_ext_3p3v failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l2, 100); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } } return 0; } static int mipi_dsi_cdp_panel_power(int on) { static struct regulator *reg_l8, *reg_l23, *reg_l2; static int gpio43; int rc; pr_debug("%s: state : %d\n", __func__, on); if (!dsi_power_on) { reg_l8 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdc"); if (IS_ERR(reg_l8)) { pr_err("could not get 8921_l8, rc = %ld\n", PTR_ERR(reg_l8)); return -ENODEV; } reg_l23 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vddio"); if (IS_ERR(reg_l23)) { pr_err("could not get 8921_l23, rc = %ld\n", PTR_ERR(reg_l23)); return -ENODEV; } reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l8, 2800000, 3000000); if (rc) { pr_err("set_voltage l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_voltage(reg_l23, 1800000, 1800000); if (rc) { pr_err("set_voltage l23 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } gpio43 = PM8921_GPIO_PM_TO_SYS(43); rc = gpio_request(gpio43, "disp_rst_n"); if (rc) { pr_err("request gpio 43 failed, rc=%d\n", rc); return -ENODEV; } dsi_power_on = true; } if (on) { rc = regulator_set_optimum_mode(reg_l8, 100000); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l23, 100000); if (rc < 0) { pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l8); if (rc) { pr_err("enable l8 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_enable(reg_l23); if (rc) { pr_err("enable l8 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } gpio_set_value_cansleep(gpio43, 1); } else { rc = regulator_disable(reg_l2); if (rc) { pr_err("disable reg_l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_l8); if (rc) { pr_err("disable reg_l8 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_l23); if (rc) { pr_err("disable reg_l23 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l8, 100); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l23, 100); if (rc < 0) { pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } gpio_set_value_cansleep(gpio43, 0); } return 0; } static char mipi_dsi_splash_is_enabled(void); static int mipi_dsi_panel_power(int on) { int ret; pr_debug("%s: on=%d\n", __func__, on); if (machine_is_msm8960_liquid()) ret = mipi_dsi_liquid_panel_power(on); else ret = mipi_dsi_cdp_panel_power(on); return ret; } static struct mipi_dsi_platform_data mipi_dsi_pdata = { .vsync_gpio = MDP_VSYNC_GPIO, .dsi_power_save = mipi_dsi_panel_power, .splash_is_enabled = mipi_dsi_splash_is_enabled, }; #ifdef CONFIG_MSM_BUS_SCALING static struct msm_bus_vectors mdp_init_vectors[] = { { .src = MSM_BUS_MASTER_MDP_PORT0, .dst = MSM_BUS_SLAVE_EBI_CH0, .ab = 0, .ib = 0, }, };
static int msm8960_configure_headset_mic_gpios(void) { int ret; struct pm_gpio param = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 1, .pull = PM_GPIO_PULL_NO, .vin_sel = PM_GPIO_VIN_S4, .out_strength = PM_GPIO_STRENGTH_MED, .function = PM_GPIO_FUNC_NORMAL, }; ret = gpio_request(PM8921_GPIO_PM_TO_SYS(23), "AV_SWITCH"); if (ret) { pr_err("%s: Failed to request gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(23)); return ret; } ret = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(23), ¶m); if (ret) pr_err("%s: Failed to configure gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(23)); else gpio_direction_output(PM8921_GPIO_PM_TO_SYS(23), 0); ret = gpio_request(PM8921_GPIO_PM_TO_SYS(35), "US_EURO_SWITCH"); if (ret) { pr_err("%s: Failed to request gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(35)); gpio_free(PM8921_GPIO_PM_TO_SYS(23)); return ret; } ret = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(35), ¶m); if (ret) pr_err("%s: Failed to configure gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(35)); else gpio_direction_output(PM8921_GPIO_PM_TO_SYS(35), 0); return 0; } static void msm8960_free_headset_mic_gpios(void) { if (msm8960_headset_gpios_configured) { gpio_free(PM8921_GPIO_PM_TO_SYS(23)); gpio_free(PM8921_GPIO_PM_TO_SYS(35)); } } static int __init msm8960_audio_init(void) { int ret; if (!cpu_is_msm8960() && !cpu_is_msm8930()) { pr_err("%s: Not the right machine type\n", __func__); return -ENODEV ; } mbhc_cfg.calibration = def_tabla_mbhc_cal(); if (!mbhc_cfg.calibration) { pr_err("Calibration data allocation failed\n"); return -ENOMEM; } msm8960_snd_device = platform_device_alloc("soc-audio", 0); if (!msm8960_snd_device) { pr_err("Platform device allocation failed\n"); kfree(mbhc_cfg.calibration); return -ENOMEM; } memcpy(msm8960_dai, msm8960_dai_common, sizeof(msm8960_dai_common)); memcpy(msm8960_dai + ARRAY_SIZE(msm8960_dai_common), msm8960_dai_delta_tabla2x, sizeof(msm8960_dai_delta_tabla2x)); platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960); ret = platform_device_add(msm8960_snd_device); if (ret) { platform_device_put(msm8960_snd_device); kfree(mbhc_cfg.calibration); return ret; } msm8960_snd_tabla1x_device = platform_device_alloc("soc-audio", 1); if (!msm8960_snd_tabla1x_device) { pr_err("Platform device allocation failed\n"); kfree(mbhc_cfg.calibration); return -ENOMEM; } memcpy(msm8960_tabla1x_dai, msm8960_dai_common, sizeof(msm8960_dai_common)); memcpy(msm8960_tabla1x_dai + ARRAY_SIZE(msm8960_dai_common), msm8960_dai_delta_tabla1x, sizeof(msm8960_dai_delta_tabla1x)); platform_set_drvdata(msm8960_snd_tabla1x_device, &snd_soc_tabla1x_card_msm8960); ret = platform_device_add(msm8960_snd_tabla1x_device); if (ret) { platform_device_put(msm8960_snd_tabla1x_device); kfree(mbhc_cfg.calibration); return -ENOMEM; return ret; } if (msm8960_configure_headset_mic_gpios()) { pr_err("%s Fail to configure headset mic gpios\n", __func__); msm8960_headset_gpios_configured = 0; } else msm8960_headset_gpios_configured = 1; mutex_init(&cdc_mclk_mutex); return ret; }
static int pmic_set_func(uint8_t pmic_gpio, uint8_t onoff) { pmic_gpio_ctrl(PM8921_GPIO_PM_TO_SYS(pmic_gpio), onoff); return 0; }
.charging_reset_time = 10 * 60, /* Fuel Gauge */ .fg_irq = 0, .fg_irq_attr = IRQF_TRIGGER_LOW | IRQF_ONESHOT, .fuel_alert_soc = 1, .repeated_fuelalert = false, .capacity_calculation_type = SEC_FUELGAUGE_CAPACITY_TYPE_RAW | SEC_FUELGAUGE_CAPACITY_TYPE_SCALE, /* SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC, */ .capacity_max = 1000, .capacity_min = 0, /* Charger */ .chg_gpio_en = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_CHG_EN), .chg_polarity_en = 0, .chg_gpio_status = 0, .chg_polarity_status = 0, .chg_irq = 0, .chg_irq_attr = 0, .chg_float_voltage = 4360, }; static struct platform_device sec_device_battery = { .name = "sec-battery", .id = -1, .dev.platform_data = &sec_battery_pdata, }; static struct i2c_gpio_platform_data gpio_i2c_data_fgchg = {
} /* GPIO regulator constraints */ struct gpio_regulator_platform_data apq8064_gpio_regulator_pdata[] __devinitdata = { /* ID vreg_name gpio_label gpio supply */ #ifdef CONFIG_USB_OTG GPIO_VREG(EXT_5V, "ext_5v", "ext_5v_en", PM8921_MPP_PM_TO_SYS(7), NULL), GPIO_VREG(EXT_MPP8, "ext_mpp8", "ext_mpp8_en", PM8921_MPP_PM_TO_SYS(8), NULL), #endif /* CONFIG_USB_OTG */ #if !defined(CONFIG_MACH_LGE) GPIO_VREG(EXT_3P3V, "ext_3p3v", "ext_3p3v_en", APQ8064_EXT_3P3V_REG_EN_GPIO, NULL), GPIO_VREG(EXT_TS_SW, "ext_ts_sw", "ext_ts_sw_en", PM8921_GPIO_PM_TO_SYS(23), "ext_3p3v"), GPIO_VREG(EXT_MPP8, "ext_mpp8", "ext_mpp8_en", PM8921_MPP_PM_TO_SYS(8), NULL), #endif }; struct gpio_regulator_platform_data mpq8064_gpio_regulator_pdata[] __devinitdata = { GPIO_VREG(AVC_1P2V, "avc_1p2v", "avc_1p2v_en", SX150X_GPIO(4, 2), NULL), GPIO_VREG(AVC_1P8V, "avc_1p8v", "avc_1p8v_en", SX150X_GPIO(4, 4), NULL), GPIO_VREG(AVC_2P2V, "avc_2p2v", "avc_2p2v_en", SX150X_GPIO(4, 14), NULL), GPIO_VREG(AVC_5V, "avc_5v", "avc_5v_en", SX150X_GPIO(4, 3), NULL), GPIO_VREG(AVC_3P3V, "avc_3p3v", "avc_3p3v_en", SX150X_GPIO(4, 15), "avc_5v"), };
static int hdmi_gpio_config(int on) { int rc = 0; static int prev_on; int pmic_gpio14 = PM8921_GPIO_PM_TO_SYS(14); if (on == prev_on) return 0; if (on) { rc = gpio_request(HDMI_DDC_CLK_GPIO, "HDMI_DDC_CLK"); if (rc) { pr_err("'%s'(%d) gpio_request failed, rc=%d\n", "HDMI_DDC_CLK", HDMI_DDC_CLK_GPIO, rc); goto error1; } rc = gpio_request(HDMI_DDC_DATA_GPIO, "HDMI_DDC_DATA"); if (rc) { pr_err("'%s'(%d) gpio_request failed, rc=%d\n", "HDMI_DDC_DATA", HDMI_DDC_DATA_GPIO, rc); goto error2; } rc = gpio_request(HDMI_HPD_GPIO, "HDMI_HPD"); if (rc) { pr_err("'%s'(%d) gpio_request failed, rc=%d\n", "HDMI_HPD", HDMI_HPD_GPIO, rc); goto error3; } if (machine_is_apq8064_liquid()) { rc = gpio_request(pmic_gpio14, "PMIC_HDMI_MUX_SEL"); if (rc) { pr_err("'%s'(%d) gpio_request failed, rc=%d\n", "PMIC_HDMI_MUX_SEL", 14, rc); goto error4; } gpio_set_value_cansleep(pmic_gpio14, 0); } pr_debug("%s(on): success\n", __func__); } else { gpio_free(HDMI_DDC_CLK_GPIO); gpio_free(HDMI_DDC_DATA_GPIO); gpio_free(HDMI_HPD_GPIO); if (machine_is_apq8064_liquid()) { gpio_set_value_cansleep(pmic_gpio14, 1); gpio_free(pmic_gpio14); } pr_debug("%s(off): success\n", __func__); } prev_on = on; return 0; error4: gpio_free(HDMI_HPD_GPIO); error3: gpio_free(HDMI_DDC_DATA_GPIO); error2: gpio_free(HDMI_DDC_CLK_GPIO); error1: return rc; }
.id = RPM_VREG_ID_PM8921_##_id##_PC, \ .pin_fn = RPM_VREG_PIN_FN_8960_##_pin_fn, \ .pin_ctrl = _pin_ctrl, \ } /* GPIO regulator constraints. * Must be in sync with corresponding platform_device structures in * board_sony_fusion3.c */ struct gpio_regulator_platform_data apq8064_gpio_regulator_pdata[] __devinitdata = { /* ID vreg_name gpio_label gpio supply active_low*/ GPIO_VREG(EXT_5V, "ext_5v", "ext_5v_en", PM8921_MPP_PM_TO_SYS(7), NULL, 0), GPIO_VREG(EXT_OTG_SW, "ext_otg_sw", "ext_otg_sw_en", PM8921_GPIO_PM_TO_SYS(42), NULL, 1), }; /* SAW regulator constraints */ struct regulator_init_data msm8064_saw_regulator_pdata_8921_s5 = /* ID vreg_name min_uV max_uV */ SAW_VREG_INIT(S5, "8921_s5", 850000, 1300000); struct regulator_init_data msm8064_saw_regulator_pdata_8921_s6 = SAW_VREG_INIT(S6, "8921_s6", 850000, 1300000); struct regulator_init_data msm8064_saw_regulator_pdata_8821_s0 = /* ID vreg_name min_uV max_uV */ SAW_VREG_INIT(8821_S0, "8821_s0", 850000, 1300000); struct regulator_init_data msm8064_saw_regulator_pdata_8821_s1 = SAW_VREG_INIT(8821_S1, "8821_s1", 850000, 1300000);
static int mipi_dsi_panel_power(int on) { static struct regulator *reg_l8, *reg_l2, *reg_lvs6, *ext_dsv_load; static int gpio42; int rc; struct pm_gpio gpio42_param = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 0, .pull = PM_GPIO_PULL_NO, .vin_sel = 2, .out_strength = PM_GPIO_STRENGTH_HIGH, .function = PM_GPIO_FUNC_PAIRED, .inv_int_pol = 0, .disable_pin = 0, }; printk(KERN_INFO"%s: mipi lcd function started status = %d \n", __func__, on); pr_debug("%s: state : %d\n", __func__, on); if (!dsi_power_on) { gpio42 = PM8921_GPIO_PM_TO_SYS(42); rc = gpio_request(gpio42, "disp_rst_n"); if (rc) { pr_err("request gpio 42 failed, rc=%d\n", rc); return -ENODEV; } if (lge_get_board_revno() > HW_REV_C) { ext_dsv_load = regulator_get(NULL, "ext_dsv_load"); if (IS_ERR(ext_dsv_load)) { pr_err("could not get ext_dsv_load, rc = %ld\n", PTR_ERR(ext_dsv_load)); return -ENODEV; } } reg_l8 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vci"); if (IS_ERR(reg_l8)) { pr_err("could not get 8921_l8, rc = %ld\n", PTR_ERR(reg_l8)); return -ENODEV; } reg_lvs6 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_iovcc"); if (IS_ERR(reg_lvs6)) { pr_err("could not get 8921_lvs6, rc = %ld\n", PTR_ERR(reg_lvs6)); return -ENODEV; } reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l8, 3000000, 3000000); if (rc) { pr_err("set_voltage l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } dsi_power_on = true; } if (on) { if (lge_get_board_revno() > HW_REV_C) { rc = regulator_enable(ext_dsv_load); if (rc) { pr_err("enable ext_dsv_load failed, rc=%d\n", rc); return -ENODEV; } } rc = regulator_set_optimum_mode(reg_l8, 100000); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } #if defined(CONFIG_FB_MSM_MIPI_LGIT_VIDEO_WXGA_PT) rc = regulator_enable(reg_l8); // dsi_vci if (rc) { pr_err("enable l8 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); rc = regulator_enable(reg_lvs6); // IOVCC if (rc) { pr_err("enable lvs6 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); #endif rc = regulator_enable(reg_l2); // DSI if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } printk(KERN_INFO " %s : reset start.", __func__); /* LCD RESET HIGH */ mdelay(2); gpio42_param.output_value = 1; rc = pm8xxx_gpio_config(gpio42,&gpio42_param); if (rc) { pr_err("gpio_config 42 failed (3), rc=%d\n", rc); return -EINVAL; } mdelay(5); } else { /* LCD RESET LOW */ gpio42_param.output_value = 0; rc = pm8xxx_gpio_config(gpio42,&gpio42_param); if (rc) { pr_err("gpio_config 42 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); #if defined(CONFIG_FB_MSM_MIPI_LGIT_VIDEO_WXGA_PT) rc = regulator_disable(reg_lvs6); // IOVCC if (rc) { pr_err("disable lvs6 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); rc = regulator_disable(reg_l8); //VCI if (rc) { pr_err("disable reg_l8 failed, rc=%d\n", rc); return -ENODEV; } udelay(100); #endif rc = regulator_disable(reg_l2); //DSI if (rc) { pr_err("disable reg_l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l8, 100); if (rc < 0) { pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_optimum_mode(reg_l2, 100); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } if (lge_get_board_revno() > HW_REV_C) { rc = regulator_disable(ext_dsv_load); if (rc) { pr_err("disable ext_dsv_load failed, rc=%d\n", rc); return -ENODEV; } } } return 0; } static char mipi_dsi_splash_is_enabled(void) { return mdp_pdata.cont_splash_enabled; } static struct mipi_dsi_platform_data mipi_dsi_pdata = { .dsi_power_save = mipi_dsi_panel_power, .splash_is_enabled = mipi_dsi_splash_is_enabled, }; static struct msm_bus_vectors dtv_bus_init_vectors[] = { { .src = MSM_BUS_MASTER_MDP_PORT0, .dst = MSM_BUS_SLAVE_EBI_CH0, .ab = 0, .ib = 0, }, };
* microphones operating at 1800 mV. Technically, all micbiases * can source from single cfilter since all microphones operate * at the same voltage level. The arrangement below is to make * sure all cfilters are exercised. LDO_H regulator ouput level * does not need to be as high as 2.85V. It is choosen for * microphone sensitivity purpose. */ static struct tabla_pdata apq8064_tabla_platform_data = { .slimbus_slave_device = { .name = "tabla-slave", .e_addr = {0, 0, 0x10, 0, 0x17, 2}, }, .irq = MSM_GPIO_TO_INT(42), .irq_base = TABLA_INTERRUPT_BASE, .num_irqs = NR_TABLA_IRQS, .reset_gpio = PM8921_GPIO_PM_TO_SYS(34), .micbias = { .ldoh_v = TABLA_LDOH_2P85_V, .cfilt1_mv = 1800, .cfilt2_mv = 1800, .cfilt3_mv = 1800, .bias1_cfilt_sel = TABLA_CFILT1_SEL, .bias2_cfilt_sel = TABLA_CFILT2_SEL, .bias3_cfilt_sel = TABLA_CFILT3_SEL, .bias4_cfilt_sel = TABLA_CFILT3_SEL, } }; static struct slim_device apq8064_slim_tabla = { .name = "tabla-slim", .e_addr = {0, 1, 0x10, 0, 0x17, 2},
ARRAY_SIZE(vreg_consumers_##_id##_PC), \ .consumer_supplies = vreg_consumers_##_id##_PC, \ .supply_regulator = _supply_regulator, \ }, \ .id = RPM_VREG_ID_PM8921_##_id##_PC, \ .pin_fn = RPM_VREG_PIN_FN_8960_##_pin_fn, \ .pin_ctrl = _pin_ctrl, \ } /* GPIO regulator constraints */ struct gpio_regulator_platform_data msm_gpio_regulator_pdata[] __devinitdata = { /* ID vreg_name gpio_label gpio supply */ GPIO_VREG(EXT_5V, "ext_5v", "ext_5v_en", PM8921_MPP_PM_TO_SYS(7), NULL), GPIO_VREG(EXT_L2, "ext_l2", "ext_l2_en", 91, NULL), GPIO_VREG(EXT_3P3V, "ext_3p3v", "ext_3p3v_en", PM8921_GPIO_PM_TO_SYS(17), NULL), GPIO_VREG(EXT_OTG_SW, "ext_otg_sw", "ext_otg_sw_en", PM8921_GPIO_PM_TO_SYS(42), "8921_usb_otg"), }; /* SAW regulator constraints */ struct regulator_init_data msm_saw_regulator_pdata_s5 = /* ID vreg_name min_uV max_uV */ SAW_VREG_INIT(S5, "8921_s5", 850000, 1300000); struct regulator_init_data msm_saw_regulator_pdata_s6 = SAW_VREG_INIT(S6, "8921_s6", 850000, 1300000); /* PM8921 regulator constraints */ struct pm8xxx_regulator_platform_data msm_pm8921_regulator_pdata[] __devinitdata = { /*
.pin_data = &mmc_slot_pin_data[SDCC2], .sdiowakeup_irq = MSM_GPIO_TO_INT(90), .msm_bus_voting_data = &sps_to_ddr_bus_voting_data, }; #endif */ #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT static unsigned int valente_sdslot_type = MMC_TYPE_SD; static struct mmc_platform_data msm8960_sdc3_data = { .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, .mmc_bus_width = MMC_CAP_4_BIT_DATA, .sup_clk_table = sdc3_sup_clk_rates, .sup_clk_cnt = ARRAY_SIZE(sdc3_sup_clk_rates), #ifdef CONFIG_MMC_MSM_SDC3_WP_SUPPORT .wpswitch_gpio = PM8921_GPIO_PM_TO_SYS(16), #endif .vreg_data = &mmc_slot_vreg_data[SDCC3], .pin_data = &mmc_slot_pin_data[SDCC3], #ifdef CONFIG_MMC_MSM_CARD_HW_DETECTION .status_gpio = PM8921_GPIO_PM_TO_SYS(VALENTE_WX_C9_PMGPIO_SDC3_CDz), .status_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE, VALENTE_WX_C9_PMGPIO_SDC3_CDz), .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, .is_status_gpio_active_low = true, #endif .slot_type = &valente_sdslot_type, #if 0 .xpc_cap = 1, .uhs_caps = (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_DDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_MAX_CURRENT_600),