static int mdss_dsi_regulator_init(struct platform_device *pdev) { int ret = 0; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; struct dsi_drv_cm_data *dsi_drv = NULL; #ifdef CONFIG_MACH_LGE struct device_node *node = pdev->dev.of_node; #endif if (!pdev) { pr_err("%s: invalid input\n", __func__); return -EINVAL; } ctrl_pdata = platform_get_drvdata(pdev); if (!ctrl_pdata) { pr_err("%s: invalid driver data\n", __func__); return -EINVAL; } dsi_drv = &(ctrl_pdata->shared_pdata); if (ctrl_pdata->power_data.num_vreg > 0) { ret = msm_dss_config_vreg(&pdev->dev, ctrl_pdata->power_data.vreg_config, ctrl_pdata->power_data.num_vreg, 1); } else { #ifdef CONFIG_MACH_LGE /* if "lge,mdss-dsi-use-vdd-supply" property is not exist, we * assume that it is used in board. if don't want vdd-supply, * please use "lge,mdss-dsi-use-vdd-supply=<0>" in your dtsi. */ ret = of_property_read_u32(node, "lge,mdss-dsi-use-vdd-supply", &mdss_dsi_use_vdd_supply); if (ret == -EINVAL) mdss_dsi_use_vdd_supply = 1; if (mdss_dsi_use_vdd_supply) { dsi_drv->vdd_vreg = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(dsi_drv->vdd_vreg)) { pr_err("%s: could not get vdd vreg, rc = %ld\n", __func__, PTR_ERR(dsi_drv->vdd_vreg)); return -ENODEV; } ret = regulator_set_voltage(dsi_drv->vdd_vreg, 3000000, 3000000); if (ret) { pr_err("%s: set voltage failed on vdd vreg, rc=%d\n", __func__, ret); return -EINVAL; } } #else dsi_drv->vdd_vreg = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(dsi_drv->vdd_vreg)) { pr_err("%s: could not get vdda vreg, rc=%ld\n", __func__, PTR_ERR(dsi_drv->vdd_vreg)); return PTR_ERR(dsi_drv->vdd_vreg); } ret = regulator_set_voltage(dsi_drv->vdd_vreg, 3000000, 3000000); if (ret) { pr_err("%s: set voltage failed on vdda vreg, rc=%d\n", __func__, ret); return ret; } #endif dsi_drv->vdd_io_vreg = devm_regulator_get(&pdev->dev, "vddio"); if (IS_ERR(dsi_drv->vdd_io_vreg)) { pr_err("%s: could not get vddio reg, rc=%ld\n", __func__, PTR_ERR(dsi_drv->vdd_io_vreg)); return PTR_ERR(dsi_drv->vdd_io_vreg); } ret = regulator_set_voltage(dsi_drv->vdd_io_vreg, 1800000, 1800000); if (ret) { pr_err("%s: set voltage failed on vddio vreg, rc=%d\n", __func__, ret); return ret; } dsi_drv->vdda_vreg = devm_regulator_get(&pdev->dev, "vdda"); if (IS_ERR(dsi_drv->vdda_vreg)) { pr_err("%s: could not get vdda vreg, rc=%ld\n", __func__, PTR_ERR(dsi_drv->vdda_vreg)); return PTR_ERR(dsi_drv->vdda_vreg); } ret = regulator_set_voltage(dsi_drv->vdda_vreg, 1200000, 1200000); if (ret) { pr_err("%s: set voltage failed on vdda vreg, rc=%d\n", __func__, ret); return ret; } } return 0; }
static int mipi_dsi_panel_power(int on) { static struct regulator *reg_lvs5, *reg_l2; static int gpio36, gpio37; int rc; pr_debug("%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 { if (system_rev == XB) { gpio_tlmm_config(GPIO_CFG(MBAT_IN_XA_XB, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); gpio_set_value(MBAT_IN_XA_XB, 0); } else if (system_rev >= XC) { gpio_tlmm_config(GPIO_CFG(BL_HW_EN_XC_XD, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); gpio_set_value(BL_HW_EN_XC_XD, 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; }
static int lvds_panel_power(int on) { static struct regulator *reg_lvs7, *reg_l2, *reg_ext_3p3v; static int gpio36, gpio26, mpp3; int rc; pr_debug("%s: on=%d\n", __func__, on); if (!lvds_power_on) { reg_lvs7 = regulator_get(&msm_lvds_device.dev, "lvds_vdda"); if (IS_ERR_OR_NULL(reg_lvs7)) { pr_err("could not get 8921_lvs7, rc = %ld\n", PTR_ERR(reg_lvs7)); return -ENODEV; } reg_l2 = regulator_get(&msm_lvds_device.dev, "lvds_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; } reg_ext_3p3v = regulator_get(&msm_lvds_device.dev, "lvds_vccs_3p3v"); if (IS_ERR_OR_NULL(reg_ext_3p3v)) { pr_err("could not get reg_ext_3p3v, rc = %ld\n", PTR_ERR(reg_ext_3p3v)); return -ENODEV; } gpio26 = PM8921_GPIO_PM_TO_SYS(26); rc = gpio_request(gpio26, "pwm_backlight_ctrl"); if (rc) { pr_err("request gpio 26 failed, rc=%d\n", rc); return -ENODEV; } gpio36 = PM8921_GPIO_PM_TO_SYS(36); /* lcd1_pwr_en_n */ rc = gpio_request(gpio36, "lcd1_pwr_en_n"); if (rc) { pr_err("request gpio 36 failed, rc=%d\n", rc); return -ENODEV; } mpp3 = PM8921_MPP_PM_TO_SYS(3); rc = gpio_request(mpp3, "backlight_en"); if (rc) { pr_err("request mpp3 failed, rc=%d\n", rc); return -ENODEV; } lvds_power_on = true; } if (on) { rc = regulator_enable(reg_lvs7); if (rc) { pr_err("enable lvs7 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; } rc = regulator_enable(reg_ext_3p3v); if (rc) { pr_err("enable reg_ext_3p3v failed, rc=%d\n", rc); return -ENODEV; } gpio_set_value_cansleep(gpio36, 0); gpio_set_value_cansleep(mpp3, 1); if (socinfo_get_pmic_model() == PMIC_MODEL_PM8917) gpio_set_value_cansleep(gpio26, 1); } else { if (socinfo_get_pmic_model() == PMIC_MODEL_PM8917) gpio_set_value_cansleep(gpio26, 0); gpio_set_value_cansleep(mpp3, 0); gpio_set_value_cansleep(gpio36, 1); rc = regulator_disable(reg_lvs7); if (rc) { pr_err("disable reg_lvs7 failed, rc=%d\n", rc); return -ENODEV; } 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; } } return 0; }
struct q6v5_data *pil_q6v5_init(struct platform_device *pdev) { struct q6v5_data *drv; struct resource *res; struct pil_desc *desc; int ret; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return ERR_PTR(-ENOMEM); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "qdsp6_base"); drv->reg_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->reg_base) return ERR_PTR(-ENOMEM); desc = &drv->desc; ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name", &desc->name); if (ret) return ERR_PTR(ret); desc->dev = &pdev->dev; drv->qdsp6v5_2_0 = of_device_is_compatible(pdev->dev.of_node, "qcom,pil-femto-modem"); if (drv->qdsp6v5_2_0) return drv; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_base"); drv->axi_halt_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->axi_halt_base) return ERR_PTR(-ENOMEM); drv->qdsp6v55 = of_device_is_compatible(pdev->dev.of_node, "qcom,pil-q6v55-mss"); drv->qdsp6v55 |= of_device_is_compatible(pdev->dev.of_node, "qcom,pil-q6v55-lpass"); drv->qdsp6v56 = of_device_is_compatible(pdev->dev.of_node, "qcom,pil-q6v56-mss"); drv->non_elf_image = of_property_read_bool(pdev->dev.of_node, "qcom,mba-image-is-not-elf"); drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return ERR_CAST(drv->xo); drv->vreg_cx = devm_regulator_get(&pdev->dev, "vdd_cx"); if (IS_ERR(drv->vreg_cx)) return ERR_CAST(drv->vreg_cx); drv->vreg_pll = devm_regulator_get(&pdev->dev, "vdd_pll"); if (!IS_ERR_OR_NULL(drv->vreg_pll)) { int voltage; ret = of_property_read_u32(pdev->dev.of_node, "qcom,vdd_pll", &voltage); if (ret) { dev_err(&pdev->dev, "Failed to find vdd_pll voltage.\n"); return ERR_PTR(ret); } ret = regulator_set_voltage(drv->vreg_pll, voltage, voltage); if (ret) { dev_err(&pdev->dev, "Failed to request vdd_pll voltage.\n"); return ERR_PTR(ret); } ret = regulator_set_optimum_mode(drv->vreg_pll, 10000); if (ret < 0) { dev_err(&pdev->dev, "Failed to set vdd_pll mode.\n"); return ERR_PTR(ret); } } else { drv->vreg_pll = NULL; } return drv; }
static int panel_n1_spi_probe(struct spi_device *spi) { int ret; spi->bits_per_word = 9; spi->mode = SPI_MODE_3; spi->max_speed_hz = 1000000; ret = spi_setup(spi); if (ret < 0) { dev_err(&spi->dev, "spi_setup failed: %d\n", ret); return ret; } printk(KERN_INFO "%s: probe\n", __func__); ret = gpio_request(n1_lvds_reset, "lvds_reset"); if (ret < 0) printk(KERN_INFO "%s: gpio_request failed with %d \n", __func__, ret); tegra_gpio_enable(n1_lvds_reset); //LCD_ONOFF_TEST, LCD_TYPE tune_lcd_dev = device_create(sec_class, NULL, 0, NULL, "sec_tune_lcd"); if (IS_ERR(tune_lcd_dev)) { printk("Failed to create device!"); ret = -1; } //LCD_ONOFF_TEST, LCD_TYPE #if LCD_ONOFF_TEST if (device_create_file(tune_lcd_dev, &dev_attr_lcd_onoff) < 0) { printk("Failed to create device file!(%s)!\n", dev_attr_lcd_onoff.attr.name); ret = -1; } #endif #if LCD_TYPE if (device_create_file(tune_lcd_dev, &dev_attr_lcdtype) < 0) { printk("Failed to create device file!(%s)!\n", dev_attr_lcdtype.attr.name); ret = -1; } #endif //LCD_TYPE printk(KERN_INFO "%s: device_create_file(tune_lcd_dev, &dev_attr_lcdtype) \n", __func__); reg_lcd_1v8 = regulator_get(NULL, "VLCD_1V8"); if (IS_ERR(reg_lcd_1v8)) { printk(KERN_INFO "%s: VLCD_1V8 regulator not found\n", __func__); reg_lcd_1v8 = NULL; } else { regulator_set_voltage(reg_lcd_1v8, 1800*1000,1800*1000); // regulator_enable(reg_lcd_1v8); } reg_lcd_3v0 = regulator_get(NULL, "VLCD_3V0"); if (IS_ERR(reg_lcd_3v0)) { printk(KERN_INFO "%s: VLCD_3V0 regulator not found\n", __func__); reg_lcd_3v0 = NULL; } else { regulator_set_voltage(reg_lcd_3v0, 3000*1000,3000*1000); // regulator_enable(reg_lcd_3v0); } n1_disp1_spi = spi; n1_panel_early_suspend.level = EARLY_SUSPEND_LEVEL_STOP_DRAWING - 1; // n1_panel_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;/* EARLY_SUSPEND_LEVEL_DISABLE_FB; */ // n1_panel_early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB-1; n1_panel_early_suspend.suspend = panel_n1_spi_suspend; n1_panel_early_suspend.resume = panel_n1_spi_resume; register_early_suspend(&n1_panel_early_suspend); n1_panel_enable(); muxtex_temp = 2 ; return 0; }
static int mipi_dsi_panel_power(int on) { int rc = 0, retVal = 0; static struct regulator *reg_vdd, *reg_iovdd, *reg_vdd_mipi; static bool dsi_power_on = false; unsigned int phaseid = 0; pr_info("[DISPLAY] +%s(%d)\n", __func__, on); if (!dsi_power_on) { /* INIT VDD_MIPI */ reg_vdd_mipi = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_vdd_mipi)) { pr_err("[DISPLAY]could not get reg_vdd_mipi, rc = %ld\n", PTR_ERR(reg_vdd_mipi)); retVal = -ENODEV; goto error; } rc = regulator_set_voltage(reg_vdd_mipi, 1200000, 1200000); if (rc) { pr_err("[DISPLAY]set_voltage VDD_MIPI failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } /* INIT VDD FOR LCD*/ reg_vdd = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdc"); if (IS_ERR(reg_vdd)) { pr_err("[DISPLAY]could not get reg_vdd, rc = %ld\n", PTR_ERR(reg_vdd)); retVal = -ENODEV; goto error; } rc = regulator_set_voltage(reg_vdd, 2800000, 2800000); if (rc) { pr_err("[DISPLAY]set_voltage reg_vdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } /* INIT IOVDD FOR LCD*/ phaseid = fih_get_product_phase(); if(phaseid == PHASE_EVM ){ pr_info("[DISPLAY]Get L18\n"); reg_iovdd = regulator_get(&msm_mipi_dsi1_device.dev, "lcd_iovdd"); }else{ pr_info("[DISPLAY]Get LVS2\n"); reg_iovdd = regulator_get(&msm_mipi_dsi1_device.dev, "lcd_lvs2"); } if (IS_ERR(reg_iovdd)) { pr_err("[DISPLAY]could not get reg_iovdd, rc = %ld\n", PTR_ERR(reg_iovdd)); retVal = -ENODEV; goto error; } if(phaseid == PHASE_EVM ){ rc = regulator_set_voltage(reg_iovdd, 1800000, 1800000); if (rc) { pr_err("[DISPLAY]set_voltage reg_iovdd failed, rc=%d\n", rc); rc = -ENODEV; goto error; } } dsi_power_on = true; } if (on) { rc = regulator_set_optimum_mode(reg_vdd_mipi, 100000); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode VDD_MIPI failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_set_optimum_mode(reg_vdd, 100000); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_vdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_set_optimum_mode(reg_iovdd, 100000); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_iovdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_enable(reg_vdd_mipi); if (rc) { pr_err("[DISPLAY]enable VDD_MIPI failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_enable(reg_iovdd); if (rc) { pr_err("[DISPLAY]enable l18 failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_enable(reg_vdd); if (rc) { pr_err("[DISPLAY]enable l8 failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } } else { rc = regulator_disable(reg_iovdd); if (rc) { pr_err("[DISPLAY]disable reg_vdd failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_disable(reg_vdd); if (rc) { pr_err("[DISPLAY]disable reg_vdd failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_disable(reg_vdd_mipi); if (rc) { pr_err("[DISPLAY]disable reg_vdd_mipi failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_set_optimum_mode(reg_vdd_mipi, 100); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_vdd_mipi failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_set_optimum_mode(reg_vdd, 100); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_vdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_set_optimum_mode(reg_iovdd, 100); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_iovdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } } error: return retVal; }
static int mipi_dsi_panel_power(int on) { static struct regulator *v_lcm, *v_lcmio, *v_dsivdd; static bool bPanelPowerOn = false; int rc; char *lcm_str = "8921_l11"; char *lcmio_str = "8921_lvs5"; char *dsivdd_str = "8921_l2"; if (panel_type == PANEL_ID_NONE) return -ENODEV; PR_DISP_INFO("%s: state : %d\n", __func__, on); if (!dsi_power_on) { v_lcm = regulator_get(&msm_mipi_dsi1_device.dev, lcm_str); if (IS_ERR(v_lcm)) { PR_DISP_ERR("could not get %s, rc = %ld\n", lcm_str, PTR_ERR(v_lcm)); return -ENODEV; } v_lcmio = regulator_get(&msm_mipi_dsi1_device.dev, lcmio_str); if (IS_ERR(v_lcmio)) { PR_DISP_ERR("could not get %s, rc = %ld\n", lcmio_str, PTR_ERR(v_lcmio)); return -ENODEV; } v_dsivdd = regulator_get(&msm_mipi_dsi1_device.dev, dsivdd_str); if (IS_ERR(v_dsivdd)) { PR_DISP_ERR("could not get %s, rc = %ld\n", dsivdd_str, PTR_ERR(v_dsivdd)); return -ENODEV; } rc = regulator_set_voltage(v_lcm, 3000000, 3000000); if (rc) { PR_DISP_ERR("%s#%d: set_voltage %s failed, rc=%d\n", __func__, __LINE__, lcm_str, rc); return -EINVAL; } rc = regulator_set_voltage(v_dsivdd, 1200000, 1200000); if (rc) { PR_DISP_ERR("%s#%d: set_voltage %s failed, rc=%d\n", __func__, __LINE__, dsivdd_str, rc); return -EINVAL; } rc = gpio_request(VILLE_GPIO_LCD_RSTz, "LCM_RST_N"); if (rc) { PR_DISP_ERR("%s:LCM gpio %d request failed, rc=%d\n", __func__, VILLE_GPIO_LCD_RSTz, rc); return -EINVAL; } dsi_power_on = true; } if (on) { PR_DISP_INFO("%s: on\n", __func__); rc = regulator_set_optimum_mode(v_lcm, 100000); if (rc < 0) { PR_DISP_ERR("set_optimum_mode %s failed, rc=%d\n", lcm_str, rc); return -EINVAL; } rc = regulator_set_optimum_mode(v_dsivdd, 100000); if (rc < 0) { PR_DISP_ERR("set_optimum_mode %s failed, rc=%d\n", dsivdd_str, rc); return -EINVAL; } rc = regulator_enable(v_dsivdd); if (rc) { PR_DISP_ERR("enable regulator %s failed, rc=%d\n", dsivdd_str, rc); return -ENODEV; } hr_msleep(1); rc = regulator_enable(v_lcmio); if (rc) { PR_DISP_ERR("enable regulator %s failed, rc=%d\n", lcmio_str, rc); return -ENODEV; } rc = regulator_enable(v_lcm); if (rc) { PR_DISP_ERR("enable regulator %s failed, rc=%d\n", lcm_str, rc); return -ENODEV; } if (!mipi_lcd_on) { hr_msleep(10); gpio_set_value(VILLE_GPIO_LCD_RSTz, 1); hr_msleep(1); gpio_set_value(VILLE_GPIO_LCD_RSTz, 0); hr_msleep(35); gpio_set_value(VILLE_GPIO_LCD_RSTz, 1); } hr_msleep(60); bPanelPowerOn = true; } else { PR_DISP_INFO("%s: off\n", __func__); if (!bPanelPowerOn) return 0; hr_msleep(100); gpio_set_value(VILLE_GPIO_LCD_RSTz, 0); hr_msleep(10); if (regulator_disable(v_dsivdd)) { PR_DISP_ERR("%s: Unable to enable the regulator: %s\n", __func__, dsivdd_str); return -EINVAL; } if (regulator_disable(v_lcm)) { PR_DISP_ERR("%s: Unable to enable the regulator: %s\n", __func__, lcm_str); return -EINVAL; } hr_msleep(5); if (regulator_disable(v_lcmio)) { PR_DISP_ERR("%s: Unable to enable the regulator: %s\n", __func__, lcmio_str); return -EINVAL; } rc = regulator_set_optimum_mode(v_dsivdd, 100); if (rc < 0) { PR_DISP_ERR("%s: Unable to enable the regulator: %s\n", __func__, dsivdd_str); return -EINVAL; } bPanelPowerOn = false; } return 0; }
static int sr030pc30_power(struct device *dev, int flag) { #ifdef CONFIG_LEDS_RT8547 static struct regulator *vcamera_vbuck5; // 5M CORE : 1.2V if (!vcamera_vbuck5) { vcamera_vbuck5 = regulator_get(dev, "v_cam_c"); if (IS_ERR(vcamera_vbuck5)) { vcamera_vbuck5 = NULL; pr_err(KERN_ERR "Enable vcamera_vbuck5 failed!\n"); return -EIO; } } #endif if (flag) { switch_i2c_gpio_mfp(I2C_PIN); Cam_Printk("---sr030pc30_power power ON ----------\n"); /* Sensor AVDD : 2.8V ON */ gpio_direction_output(CAM_AVDD, 1); udelay(50); /* Sensor IO : 1.8V ON */ gpio_direction_output(CAM_IO, 1); /* 5M Core : 1.2V ON */ #ifdef CONFIG_LEDS_RT8547 regulator_set_voltage(vcamera_vbuck5, 1200000, 1200000); regulator_enable(vcamera_vbuck5); #elif CONFIG_FLED_RT5033 gpio_direction_output(CAM_CORE, 1); #endif /* 5M Core : 1.2V OFF */ msleep(5); #ifdef CONFIG_LEDS_RT8547 regulator_disable(vcamera_vbuck5); #elif CONFIG_FLED_RT5033 gpio_direction_output(CAM_CORE, 0); #endif msleep(1); /* VT STBY Enable */ gpio_direction_output(Sub_EN, 1); /* Ccic Mclk enbale, enable/disable clk api is in mmp_camera.c */ pxa_ccic_enable_mclk(samsung_camera.pcdev, V4L2_MBUS_PARALLEL); msleep(1); /* VT Rest Enable */ gpio_direction_output(Sub_RST, 0); msleep(5); gpio_direction_output(Sub_RST, 1); msleep(40); /*for s5k power off maybe pull down the i2c data pin, so we have to reset i2c controller */ samsung_camera.i2c_pxa_reset(samsung_camera.i2c); }else { Cam_Printk("---sr030pc30_power power OFF ----------\n"); /* VT Rest Disable */ gpio_direction_output(Sub_RST, 0); /* Ccic Mclk enbale, enable/disable clk api is in mmp_camera.c */ msleep(5); pxa_ccic_disable_mclk(samsung_camera.pcdev, V4L2_MBUS_PARALLEL); msleep(5); /* VT STBY Disable */ gpio_direction_output(Sub_EN, 0); /* Sensor IO : 1.8V OFF */ gpio_direction_output(CAM_IO, 0); /* Sensor AVDD : 2.8V OFF */ gpio_direction_output(CAM_AVDD, 0); switch_i2c_gpio_mfp(GPIO_PIN); } return 0; }
static int s5k43_power(struct device *dev, int flag) { static int initialized = FALSE; // for checking is probe state #ifdef CONFIG_LEDS_RT8547 static struct regulator *vcamera_vbuck5; // 5M CORE : 1.2V if (!vcamera_vbuck5) { vcamera_vbuck5 = regulator_get(dev, "v_cam_c"); if (IS_ERR(vcamera_vbuck5)) { vcamera_vbuck5 = NULL; pr_err(KERN_ERR "Enable vcamera_vbuck5 failed!\n"); return -EIO; } } #endif if (flag) { switch_i2c_gpio_mfp(I2C_PIN); Cam_Printk("---camera power ON ----------\n"); /* Sensor AVDD : 2.8V ON */ gpio_direction_output(CAM_AVDD, 1); msleep(1); /* Sensor IO : 1.8V ON */ gpio_direction_output(CAM_IO, 1); /* AF : 2.8V ON */ gpio_direction_output(CAM_AF, 1); msleep(1); /* VT STBY Enable */ gpio_direction_output(Sub_EN, 1); /* Ccic Mclk enbale, enable/disable clk api is in mmp_camera.c */ pxa_ccic_enable_mclk(samsung_camera.pcdev, V4L2_MBUS_CSI2); /* VT Rest Enable */ gpio_direction_output(Sub_RST, 0); msleep(5); gpio_direction_output(Sub_RST, 1); msleep(2); /* VT STBY Disable */ gpio_direction_output(Sub_EN, 0); /* 5M Core : 1.2V ON */ #ifdef CONFIG_LEDS_RT8547 regulator_set_voltage(vcamera_vbuck5, 1200000, 1200000); regulator_enable(vcamera_vbuck5); #else gpio_direction_output(CAM_CORE, 1); #endif msleep(1); /* 5M STBY Enable */ gpio_direction_output(Main_STBY, 1); /* 5M Reset Enable*/ gpio_direction_output(Main_RST, 0); msleep(2); gpio_direction_output(Main_RST, 1); msleep(5); /*for s5k power off maybe pull down the i2c data pin, so we have to reset i2c controller */ samsung_camera.i2c_pxa_reset(samsung_camera.i2c); }else { Cam_Printk("---camera power OFF ----------\n"); if((initialized==TRUE)&&(rear_camera==FALSE)) camera_flash_on_off(POWER_OFF); // Flash Off /* 5M Reset Disable*/ gpio_direction_output(Main_RST, 0); msleep(1); /* Ccic Mclk enbale, enable/disable clk api is in mmp_camera.c */ msleep(5); pxa_ccic_disable_mclk(samsung_camera.pcdev, V4L2_MBUS_CSI2); /* 5M STBY Disable */ gpio_direction_output(Main_STBY, 0); /* VT Rest Disable */ gpio_direction_output(Sub_RST, 0); /* 5M Core : 1.2V OFF */ #ifdef CONFIG_LEDS_RT8547 regulator_disable(vcamera_vbuck5); #else gpio_direction_output(CAM_CORE, 0); #endif /* Sensor IO : 1.8V OFF */ gpio_direction_output(CAM_IO, 0); /* Sensor AVDD : 2.8V OFF */ gpio_direction_output(CAM_AVDD, 0); /* AF : 2.8V OFF */ gpio_direction_output(CAM_AF, 0); switch_i2c_gpio_mfp(GPIO_PIN); if(initialized==FALSE) initialized = TRUE; } return 0; }
static void msm_camera_vreg_enable(void) { #if 0 ldo15 = regulator_get(NULL, "8058_l15"); if (IS_ERR(ldo15)) { pr_err("%s: VREG LDO15 get failed\n", __func__); ldo15 = NULL; return; } if (regulator_set_voltage(ldo15, 2850000, 2850000)) { pr_err("%s: VREG LDO15 set voltage failed\n", __func__); goto ldo15_disable; } if (regulator_enable(ldo15)) { pr_err("%s: VREG LDO15 enable failed\n", __func__); goto ldo15_put; } lvs0 = regulator_get(NULL, "8058_lvs0"); if (IS_ERR(lvs0)) { pr_err("%s: VREG LVS0 get failed\n", __func__); lvs0 = NULL; goto ldo15_disable; } if (regulator_enable(lvs0)) { pr_err("%s: VREG LVS0 enable failed\n", __func__); goto lvs0_put; } ldo25 = regulator_get(NULL, "8058_l25"); if (IS_ERR(ldo25)) { pr_err("%s: VREG LDO25 get failed\n", __func__); ldo25 = NULL; goto lvs0_disable; } if (regulator_set_voltage(ldo25, 1200000, 1200000)) { pr_err("%s: VREG LDO25 set voltage failed\n", __func__); goto ldo25_disable; } if (regulator_enable(ldo25)) { pr_err("%s: VREG LDO25 enable failed\n", __func__); goto ldo25_put; } #endif #ifdef F_SKYCAM_ICP_HD s2b12 = regulator_get(NULL, "8901_s2"); if (IS_ERR(s2b12)) { CDBG("%s: VREG s2b12 get failed\n", __func__); s2b12 = NULL; return; } if (regulator_set_voltage(s2b12, 1300000, 1300000)) { CDBG("%s: VREG s2b12 set voltage failed\n", __func__); regulator_disable(s2b12); } if (regulator_enable(s2b12)) { CDBG("%s: VREG s2b12 enable failed\n", __func__); regulator_put(s2b12); } lvs3b18 = regulator_get(NULL, "8901_lvs3"); if (IS_ERR(lvs3b18)) { CDBG("%s: VREG lvs3b18 get failed\n", __func__); lvs3b18 = NULL; return; } if (regulator_enable(lvs3b18)) { CDBG("%s: VREG lvs3b18 enable failed\n", __func__); regulator_disable(lvs3b18); } mvs0b18 = regulator_get(NULL, "8901_mvs0"); if (IS_ERR(mvs0b18)) { CDBG("%s: VREG mvs0b18 get failed\n", __func__); mvs0b18 = NULL; return; } if (regulator_enable(mvs0b18)) { CDBG("%s: VREG mvs0b18 enable failed\n", __func__); regulator_disable(mvs0b18); } l2b28 = regulator_get(NULL, "8901_l2"); if (IS_ERR(l2b28)) { CDBG("%s: VREG l2b28 get failed\n", __func__); l2b28 = NULL; return; } if (regulator_set_voltage(l2b28, 2800000, 2800000)) { CDBG("%s: VREG s2b12 set voltage failed\n", __func__); regulator_disable(l2b28); } if (regulator_enable(l2b28)) { CDBG("%s: VREG s2b12 enable failed\n", __func__); regulator_put(l2b28); } l3b28 = regulator_get(NULL, "8901_l3"); if (IS_ERR(l3b28)) { CDBG("%s: VREG l3b28 get failed\n", __func__); l3b28 = NULL; return; } if (regulator_set_voltage(l3b28, 2800000, 2800000)) { CDBG("%s: VREG l3b28 set voltage failed\n", __func__); regulator_disable(l3b28); } if (regulator_enable(l3b28)) { CDBG("%s: VREG l3b28 enable failed\n", __func__); regulator_put(l3b28); } #endif fs_vfe = regulator_get(NULL, "fs_vfe"); if (IS_ERR(fs_vfe)) { CDBG("%s: Regulator FS_VFE get failed %ld\n", __func__, PTR_ERR(fs_vfe)); fs_vfe = NULL; } else if (regulator_enable(fs_vfe)) { CDBG("%s: Regulator FS_VFE enable failed\n", __func__); regulator_put(fs_vfe); } return; #if 0//def F_SKYCAM_ICP_HD ldo25_disable: regulator_disable(ldo25); ldo25_put: regulator_put(ldo25); lvs0_disable: regulator_disable(lvs0); lvs0_put: regulator_put(lvs0); ldo15_disable: regulator_disable(ldo15); ldo15_put: regulator_put(ldo15); #endif }
static int mipi_dsi_cdp_panel_power(int on) { static struct regulator *reg_l8, *reg_l23, *reg_l2; /* Control backlight GPIO (24) directly when using PM8917 */ int gpio24 = PM8917_GPIO_PM_TO_SYS(24); 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 8038_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 8038_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 8038_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; } rc = gpio_request(DISP_RST_GPIO, "disp_rst_n"); if (rc) { pr_err("request gpio DISP_RST_GPIO failed, rc=%d\n", rc); gpio_free(DISP_RST_GPIO); return -ENODEV; } if (machine_is_msm8930_evt()) { rc = gpio_direction_output(DISP_RST_GPIO, 1); if (rc) { pr_err("gpio_direction_output failed for %d gpio rc=%d\n", DISP_RST_GPIO, rc); return -ENODEV; } } if (!machine_is_msm8930_evt()) { rc = gpio_request(DISP_3D_2D_MODE, "disp_3d_2d"); if (rc) { pr_err("request gpio DISP_3D_2D_MODE failed, rc=%d\n", rc); gpio_free(DISP_3D_2D_MODE); return -ENODEV; } rc = gpio_direction_output(DISP_3D_2D_MODE, 0); if (rc) { pr_err("gpio_direction_output failed for %d gpio rc=%d\n", DISP_3D_2D_MODE, rc); return -ENODEV; } } if (socinfo_get_pmic_model() == PMIC_MODEL_PM8917) { rc = gpio_request(gpio24, "disp_bl"); if (rc) { pr_err("request for gpio 24 failed, rc=%d\n", rc); return -ENODEV; } gpio_set_value_cansleep(gpio24, 0); novatek_pdata.gpio_set_backlight = pm8917_gpio_set_backlight; } 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; } usleep(10000); gpio_set_value(DISP_RST_GPIO, 1); usleep(10); gpio_set_value(DISP_RST_GPIO, 0); usleep(20); gpio_set_value(DISP_RST_GPIO, 1); if (!machine_is_msm8930_evt()) gpio_set_value(DISP_3D_2D_MODE, 1); usleep(20); } else { gpio_set_value(DISP_RST_GPIO, 0); 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; } if (!machine_is_msm8930_evt()) gpio_set_value(DISP_3D_2D_MODE, 0); usleep(20); } return 0; }
static int hdmi_core_power(int on, int show) { static struct regulator *reg_8921_l23, *reg_8921_s4; static int prev_on; int rc; if (on == prev_on) return 0; /* TBD: PM8921 regulator instead of 8901 */ if (!reg_8921_l23) { reg_8921_l23 = regulator_get(&hdmi_msm_device.dev, "hdmi_avdd"); if (IS_ERR(reg_8921_l23)) { pr_err("could not get reg_8921_l23, rc = %ld\n", PTR_ERR(reg_8921_l23)); return -ENODEV; } rc = regulator_set_voltage(reg_8921_l23, 1800000, 1800000); if (rc) { pr_err("set_voltage failed for 8921_l23, rc=%d\n", rc); return -EINVAL; } } if (!reg_8921_s4) { reg_8921_s4 = regulator_get(&hdmi_msm_device.dev, "hdmi_vcc"); if (IS_ERR(reg_8921_s4)) { pr_err("could not get reg_8921_s4, rc = %ld\n", PTR_ERR(reg_8921_s4)); return -ENODEV; } rc = regulator_set_voltage(reg_8921_s4, 1800000, 1800000); if (rc) { pr_err("set_voltage failed for 8921_s4, rc=%d\n", rc); return -EINVAL; } } if (on) { rc = regulator_set_optimum_mode(reg_8921_l23, 100000); if (rc < 0) { pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_8921_l23); if (rc) { pr_err("'%s' regulator enable failed, rc=%d\n", "hdmi_avdd", rc); return rc; } rc = regulator_enable(reg_8921_s4); if (rc) { pr_err("'%s' regulator enable failed, rc=%d\n", "hdmi_vcc", rc); return rc; } pr_debug("%s(on): success\n", __func__); } else { rc = regulator_disable(reg_8921_l23); if (rc) { pr_err("disable reg_8921_l23 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_8921_s4); if (rc) { pr_err("disable reg_8921_s4 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_8921_l23, 100); if (rc < 0) { pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); return -EINVAL; } pr_debug("%s(off): success\n", __func__); } prev_on = on; 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++; } } 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 msm_hsusb_ldo_enable(struct msm_hsphy *phy, int on) { int rc = 0; dev_dbg(phy->phy.dev, "reg (%s)\n", on ? "HPM" : "LPM"); if (!on) goto disable_regulators; rc = regulator_set_optimum_mode(phy->vdda18, USB_HSPHY_1P8_HPM_LOAD); if (rc < 0) { dev_err(phy->phy.dev, "Unable to set HPM of vdda18\n"); return rc; } rc = regulator_set_voltage(phy->vdda18, USB_HSPHY_1P8_VOL_MIN, USB_HSPHY_1P8_VOL_MAX); if (rc) { dev_err(phy->phy.dev, "unable to set voltage for vdda18\n"); goto put_vdda18_lpm; } rc = regulator_enable(phy->vdda18); if (rc) { dev_err(phy->phy.dev, "Unable to enable vdda18\n"); goto unset_vdda18; } rc = regulator_set_optimum_mode(phy->vdda33, USB_HSPHY_3P3_HPM_LOAD); if (rc < 0) { dev_err(phy->phy.dev, "Unable to set HPM of vdda33\n"); goto disable_vdda18; } rc = regulator_set_voltage(phy->vdda33, USB_HSPHY_3P3_VOL_MIN, USB_HSPHY_3P3_VOL_MAX); if (rc) { dev_err(phy->phy.dev, "unable to set voltage for vdda33\n"); goto put_vdda33_lpm; } rc = regulator_enable(phy->vdda33); if (rc) { dev_err(phy->phy.dev, "Unable to enable vdda33\n"); goto unset_vdda33; } return 0; disable_regulators: rc = regulator_disable(phy->vdda33); if (rc) dev_err(phy->phy.dev, "Unable to disable vdda33\n"); unset_vdda33: rc = regulator_set_voltage(phy->vdda33, 0, USB_HSPHY_3P3_VOL_MAX); if (rc) dev_err(phy->phy.dev, "unable to set voltage for vdda33\n"); put_vdda33_lpm: rc = regulator_set_optimum_mode(phy->vdda33, 0); if (rc < 0) dev_err(phy->phy.dev, "Unable to set LPM of vdda33\n"); disable_vdda18: rc = regulator_disable(phy->vdda18); if (rc) dev_err(phy->phy.dev, "Unable to disable vdda18\n"); unset_vdda18: rc = regulator_set_voltage(phy->vdda18, 0, USB_HSPHY_1P8_VOL_MAX); if (rc) dev_err(phy->phy.dev, "unable to set voltage for vdda18\n"); put_vdda18_lpm: rc = regulator_set_optimum_mode(phy->vdda18, 0); if (rc < 0) dev_err(phy->phy.dev, "Unable to set LPM of vdda18\n"); return rc < 0 ? rc : 0; }
static int mpu3050_config_regulator(struct i2c_client *client, bool on) { int rc = 0, i; int num_reg = sizeof(mpu_vreg) / sizeof(struct sensor_regulator); if (on) { for (i = 0; i < num_reg; i++) { mpu_vreg[i].vreg = regulator_get(&client->dev, mpu_vreg[i].name); if (IS_ERR(mpu_vreg[i].vreg)) { rc = PTR_ERR(mpu_vreg[i].vreg); pr_err("%s:regulator get failed rc=%d\n", __func__, rc); mpu_vreg[i].vreg = NULL; goto error_vdd; } if (regulator_count_voltages(mpu_vreg[i].vreg) > 0) { rc = regulator_set_voltage(mpu_vreg[i].vreg, mpu_vreg[i].min_uV, mpu_vreg[i].max_uV); if (rc) { pr_err("%s:set_voltage failed rc=%d\n", __func__, rc); regulator_put(mpu_vreg[i].vreg); mpu_vreg[i].vreg = NULL; goto error_vdd; } } rc = regulator_enable(mpu_vreg[i].vreg); if (rc) { pr_err("%s: regulator_enable failed rc =%d\n", __func__, rc); if (regulator_count_voltages( mpu_vreg[i].vreg) > 0) { regulator_set_voltage(mpu_vreg[i].vreg, 0, mpu_vreg[i].max_uV); } regulator_put(mpu_vreg[i].vreg); mpu_vreg[i].vreg = NULL; goto error_vdd; } } return rc; } else { i = num_reg; } error_vdd: while (--i >= 0) { if (!IS_ERR_OR_NULL(mpu_vreg[i].vreg)) { if (regulator_count_voltages( mpu_vreg[i].vreg) > 0) { regulator_set_voltage(mpu_vreg[i].vreg, 0, mpu_vreg[i].max_uV); } regulator_disable(mpu_vreg[i].vreg); regulator_put(mpu_vreg[i].vreg); mpu_vreg[i].vreg = NULL; } } return rc; }
/** * vos_chip_power_qrf8615() - WLAN Power Up Seq for WCN1314 rev 2.0 on QRF 8615 * @on - Turn WLAN ON/OFF (1 or 0) * * Power up/down WLAN by turning on/off various regs and asserting/deasserting * Power-on-reset pin. Also, put XO A0 buffer as slave to wlan_clk_pwr_req while * turning ON WLAN and vice-versa. * * This function returns 0 on success or a non-zero value on failure. */ int vos_chip_power_qrf8615(int on) { static char wlan_on; static const char *vregs_qwlan_name[] = { "8058_l20", "8058_l8", "8901_s4", "8901_lvs1", "8901_l0", "8058_s2", "8058_s1", }; static const char *vregs_qwlan_pc_name[] = { "8058_l20_pc", "8058_l8_pc", NULL, NULL, "8901_l0_pc", "8058_s2_pc", NULL, }; static const int vregs_qwlan_val_min[] = { 1800000, 3050000, 1225000, 0, 1200000, 1300000, 500000, }; static const int vregs_qwlan_val_max[] = { 1800000, 3050000, 1225000, 0, 1200000, 1300000, 1250000, }; static const bool vregs_is_pin_controlled_default[] = { 1, 1, 0, 0, 1, 1, 0, }; static const bool vregs_is_pin_controlled_dragon[] = { 0, 0, 0, 0, 0, 1, 0, }; bool const *vregs_is_pin_controlled; static struct regulator *vregs_qwlan[ARRAY_SIZE(vregs_qwlan_name)]; static struct regulator *vregs_pc_qwlan[ARRAY_SIZE(vregs_qwlan_name)]; static struct msm_xo_voter *wlan_clock; int ret, i, rc = 0; unsigned wlan_gpio_deep_sleep = GPIO_WLAN_DEEP_SLEEP_N; vregs_is_pin_controlled = vregs_is_pin_controlled_default; if (machine_is_msm8x60_dragon()) { wlan_gpio_deep_sleep = GPIO_WLAN_DEEP_SLEEP_N_DRAGON; vregs_is_pin_controlled = vregs_is_pin_controlled_dragon; } /* WLAN RESET and CLK settings */ if (on && !wlan_on) { /* * Program U12 GPIO expander pin IO1 to de-assert (drive 0) * WLAN_EXT_POR_N to put WLAN in reset */ rc = gpio_request(wlan_gpio_deep_sleep, "WLAN_DEEP_SLEEP_N"); if (rc) { pr_err("WLAN reset GPIO %d request failed\n", wlan_gpio_deep_sleep); goto fail; } rc = gpio_direction_output(wlan_gpio_deep_sleep, WLAN_RESET); if (rc < 0) { pr_err("WLAN reset GPIO %d set output direction failed", wlan_gpio_deep_sleep); goto fail_gpio_dir_out; } /* Configure TCXO to be slave to WLAN_CLK_PWR_REQ */ if (wlan_clock == NULL) { wlan_clock = msm_xo_get(MSM_XO_TCXO_A0, id); if (IS_ERR(wlan_clock)) { pr_err("Failed to get TCXO_A0 voter (%ld)\n", PTR_ERR(wlan_clock)); goto fail_gpio_dir_out; } } rc = msm_xo_mode_vote(wlan_clock, MSM_XO_MODE_PIN_CTRL); if (rc < 0) { pr_err("Configuring TCXO to Pin controllable failed" "(%d)\n", rc); goto fail_xo_mode_vote; } } else if (!on && wlan_on) { if (wlan_clock != NULL) msm_xo_mode_vote(wlan_clock, MSM_XO_MODE_OFF); gpio_set_value_cansleep(wlan_gpio_deep_sleep, WLAN_RESET); gpio_free(wlan_gpio_deep_sleep); } /* WLAN VREG settings */ for (i = 0; i < ARRAY_SIZE(vregs_qwlan_name); i++) { if (vregs_qwlan[i] == NULL) { vregs_qwlan[i] = regulator_get(NULL, vregs_qwlan_name[i]); if (IS_ERR(vregs_qwlan[i])) { pr_err("regulator get of %s failed (%ld)\n", vregs_qwlan_name[i], PTR_ERR(vregs_qwlan[i])); rc = PTR_ERR(vregs_qwlan[i]); goto vreg_get_fail; } if (vregs_qwlan_val_min[i] || vregs_qwlan_val_max[i]) { rc = regulator_set_voltage(vregs_qwlan[i], vregs_qwlan_val_min[i], vregs_qwlan_val_max[i]); if (rc) { pr_err("regulator_set_voltage(%s) failed\n", vregs_qwlan_name[i]); goto vreg_fail; } } /* vote for pin control (if needed) */ if (vregs_is_pin_controlled[i]) { vregs_pc_qwlan[i] = regulator_get(NULL, vregs_qwlan_pc_name[i]); if (IS_ERR(vregs_pc_qwlan[i])) { pr_err("regulator get of %s failed " "(%ld)\n", vregs_qwlan_pc_name[i], PTR_ERR(vregs_pc_qwlan[i])); rc = PTR_ERR(vregs_pc_qwlan[i]); goto vreg_fail; } } } if (on && !wlan_on) { rc = regulator_enable(vregs_qwlan[i]); if (rc < 0) { pr_err("vreg %s enable failed (%d)\n", vregs_qwlan_name[i], rc); goto vreg_fail; } if (vregs_is_pin_controlled[i]) { rc = regulator_enable(vregs_pc_qwlan[i]); if (rc < 0) { pr_err("vreg %s enable failed (%d)\n", vregs_qwlan_pc_name[i], rc); goto vreg_fail; } } } else if (!on && wlan_on) { if (vregs_is_pin_controlled[i]) { rc = regulator_disable(vregs_pc_qwlan[i]); if (rc < 0) { pr_err("vreg %s disable failed (%d)\n", vregs_qwlan_pc_name[i], rc); goto vreg_fail; } } rc = regulator_disable(vregs_qwlan[i]); if (rc < 0) { pr_err("vreg %s disable failed (%d)\n", vregs_qwlan_name[i], rc); goto vreg_fail; } } } if (on) { gpio_set_value_cansleep(wlan_gpio_deep_sleep, WLAN_RESET_OUT); wlan_on = true; } else wlan_on = false; return 0; vreg_fail: regulator_put(vregs_qwlan[i]); if (vregs_is_pin_controlled[i]) regulator_put(vregs_pc_qwlan[i]); vreg_get_fail: i--; while (i >= 0) { ret = !on ? regulator_enable(vregs_qwlan[i]) : regulator_disable(vregs_qwlan[i]); if (ret < 0) { pr_err("vreg %s %s failed (%d) in err path\n", vregs_qwlan_name[i], !on ? "enable" : "disable", ret); } if (vregs_is_pin_controlled[i]) { ret = !on ? regulator_enable(vregs_pc_qwlan[i]) : regulator_disable(vregs_pc_qwlan[i]); if (ret < 0) { pr_err("vreg %s %s failed (%d) in err path\n", vregs_qwlan_pc_name[i], !on ? "enable" : "disable", ret); } } regulator_put(vregs_qwlan[i]); if (vregs_is_pin_controlled[i]) regulator_put(vregs_pc_qwlan[i]); i--; } if (!on) goto fail; fail_xo_mode_vote: msm_xo_put(wlan_clock); fail_gpio_dir_out: gpio_free(wlan_gpio_deep_sleep); fail: return rc; }
int msm_camera_config_vreg(struct device *dev, struct camera_vreg_t *cam_vreg, int num_vreg, enum msm_camera_vreg_name_t *vreg_seq, int num_vreg_seq, struct regulator **reg_ptr, int config) { int i = 0, j = 0; int rc = 0; struct camera_vreg_t *curr_vreg; //Eric Liu+ //defined in each sensor driver file: sensor_i2c_addr //mt9m114 = 0x90 //ov8825 = 0x6C //imx091 = 0x34 //struct i2c_client *client = container_of(dev, struct i2c_client, dev); //MSG2("%s+, %d, addr=0x%X",__func__,config,client->addr); //Eric Liu //Eric Liu- if (num_vreg_seq > num_vreg) { pr_err("%s:%d vreg sequence invalid\n", __func__, __LINE__); return -EINVAL; } if (!num_vreg_seq) num_vreg_seq = num_vreg; if (config) { for (i = 0; i < num_vreg_seq; i++) { if (vreg_seq) { j = vreg_seq[i]; if (j >= num_vreg) continue; } else j = i; //Eric Liu+ //MSG2("%s, On, %s",__func__,get_vreg_name(j)); if(j == CAM_VANA_EXT) { rc = gpio_request(35, "cam_vana"); // 2.8v if(rc < 0) MSG2("%s, gpio_request, cam_vana, fail = %d",__func__,rc); gpio_direction_output(35, 0); continue; } //Eric Liu- curr_vreg = &cam_vreg[j]; reg_ptr[j] = regulator_get(dev, curr_vreg->reg_name); if (IS_ERR(reg_ptr[j])) { pr_err("%s: %s get failed\n", __func__, curr_vreg->reg_name); reg_ptr[j] = NULL; goto vreg_get_fail; } if (curr_vreg->type == REG_LDO) { rc = regulator_set_voltage( reg_ptr[j], curr_vreg->min_voltage, curr_vreg->max_voltage); if (rc < 0) { pr_err("%s: %s set voltage failed\n", __func__, curr_vreg->reg_name); goto vreg_set_voltage_fail; } if (curr_vreg->op_mode >= 0) { rc = regulator_set_optimum_mode( reg_ptr[j], curr_vreg->op_mode); if (rc < 0) { pr_err( "%s: %s set optimum mode failed\n", __func__, curr_vreg->reg_name); goto vreg_set_opt_mode_fail; } } } } } else { for (i = num_vreg_seq-1; i >= 0; i--) { if (vreg_seq) { j = vreg_seq[i]; if (j >= num_vreg) continue; } else j = i; //Eric Liu+ //MSG2("%s, Off, %s",__func__,get_vreg_name(j)); if(j == CAM_VANA_EXT) { rc = gpio_direction_input(35); // 2.8v release if(rc < 0) MSG2("%s, gpio_direction_input, cam_vana, fail = %d",__func__,rc); gpio_free(35); continue; } //Eric Liu- curr_vreg = &cam_vreg[j]; if (reg_ptr[j]) { if (curr_vreg->type == REG_LDO) { if (curr_vreg->op_mode >= 0) { regulator_set_optimum_mode( reg_ptr[j], 0); } regulator_set_voltage( reg_ptr[j], 0, curr_vreg-> max_voltage); } regulator_put(reg_ptr[j]); reg_ptr[j] = NULL; } } } //MSG2("%s-, rc=0",__func__); return 0; vreg_unconfig: if (curr_vreg->type == REG_LDO) regulator_set_optimum_mode(reg_ptr[j], 0); vreg_set_opt_mode_fail: if (curr_vreg->type == REG_LDO) regulator_set_voltage(reg_ptr[j], 0, curr_vreg->max_voltage); vreg_set_voltage_fail: regulator_put(reg_ptr[j]); reg_ptr[j] = NULL; vreg_get_fail: for (i--; i >= 0; i--) { if (vreg_seq) { j = vreg_seq[i]; if (j >= num_vreg) continue; } else j = i; curr_vreg = &cam_vreg[j]; goto vreg_unconfig; } //MSG2("%s-, rc=-19(ENODEV?",__func__); return -ENODEV; }
static int mipi_dsi_panel_power(int on) { static struct regulator *reg_l2; int rc; PR_DISP_INFO("%s: power %s.\n", __func__, on ? "on" : "off"); if (!dsi_power_on) { gpio_tlmm_config(GPIO_CFG(MSM_LCD_ID0, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, 0), GPIO_CFG_ENABLE); gpio_tlmm_config(GPIO_CFG(MSM_LCD_ID1, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, 0), GPIO_CFG_ENABLE); reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_l2)) { pr_err("could not get 8038_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; } dsi_power_on = true; if (first_inited) { first_inited = false; 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; } return 0; } } if (on) { if (panel_type == PANEL_ID_K2_WL_AUO || panel_type == PANEL_ID_K2_WL_AUO_C2) { rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } gpio_set_value(MSM_V_LCMIO_1V8_EN, 1); hr_msleep(1); gpio_set_value(MSM_V_LCM_3V3_EN, 1); rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } hr_msleep(55); gpio_set_value(MSM_LCD_RSTz, 1); usleep(20); gpio_set_value(MSM_LCD_RSTz, 0); usleep(30); gpio_set_value(MSM_LCD_RSTz, 1); hr_msleep(120); } else if (panel_type == PANEL_ID_K2_WL_JDI_NT) { rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } gpio_set_value(MSM_V_LCMIO_1V8_EN, 1); hr_msleep(1); gpio_set_value(MSM_V_LCM_3V3_EN, 1); rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } hr_msleep(50); gpio_set_value(MSM_LCD_RSTz, 1); hr_msleep(10); gpio_set_value(MSM_LCD_RSTz, 0); hr_msleep(10); gpio_set_value(MSM_LCD_RSTz, 1); hr_msleep(120); } } else { if (panel_type == PANEL_ID_K2_WL_AUO || panel_type == PANEL_ID_K2_WL_AUO_C2) { rc = regulator_disable(reg_l2); if (rc) { pr_err("disable reg_l2 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; } gpio_set_value(MSM_LCD_RSTz, 0); hr_msleep(1); gpio_set_value(MSM_V_LCM_3V3_EN, 0); hr_msleep(5); gpio_set_value(MSM_V_LCMIO_1V8_EN, 0); } else if (panel_type == PANEL_ID_K2_WL_JDI_NT) { rc = regulator_disable(reg_l2); if (rc) { pr_err("disable reg_l2 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; } hr_msleep(10); gpio_set_value(MSM_LCD_RSTz, 0); hr_msleep(10); gpio_set_value(MSM_V_LCM_3V3_EN, 0); hr_msleep(10); gpio_set_value(MSM_V_LCMIO_1V8_EN, 0); } } return 0; }
static int mxhci_hsic_suspend(struct mxhci_hsic_hcd *mxhci) { struct usb_hcd *hcd = hsic_to_hcd(mxhci); int ret; if (mxhci->in_lpm) { dev_dbg(mxhci->dev, "%s called in lpm\n", __func__); return 0; } disable_irq(hcd->irq); /* make sure we don't race against a remote wakeup */ if (test_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags) || (readl_relaxed(MSM_HSIC_PORTSC) & PORT_PLS_MASK) == XDEV_RESUME) { dev_dbg(mxhci->dev, "wakeup pending, aborting suspend\n"); enable_irq(hcd->irq); return -EBUSY; } /* make sure HSIC phy is in LPM */ ret = wait_for_completion_timeout( &mxhci->phy_in_lpm, msecs_to_jiffies(PHY_LPM_WAIT_TIMEOUT_MS)); if (!ret) { dev_err(mxhci->dev, "HSIC phy failed to enter lpm\n"); init_completion(&mxhci->phy_in_lpm); enable_irq(hcd->irq); return -EBUSY; } init_completion(&mxhci->phy_in_lpm); clk_disable_unprepare(mxhci->core_clk); clk_disable_unprepare(mxhci->utmi_clk); clk_disable_unprepare(mxhci->hsic_clk); clk_disable_unprepare(mxhci->cal_clk); clk_disable_unprepare(mxhci->system_clk); ret = regulator_set_voltage(mxhci->hsic_vddcx, mxhci->vdd_no_vol_level, mxhci->vdd_high_vol_level); if (ret < 0) dev_err(mxhci->dev, "unable to set vddcx voltage for VDD MIN\n"); if (mxhci->bus_perf_client) { mxhci->bus_vote = false; queue_work(mxhci->wq, &mxhci->bus_vote_w); } mxhci->in_lpm = 1; enable_irq(hcd->irq); if (mxhci->wakeup_irq) { mxhci->wakeup_irq_enabled = 1; enable_irq_wake(mxhci->wakeup_irq); enable_irq(mxhci->wakeup_irq); } /* disable force-on mode for periph_on */ clk_set_flags(mxhci->system_clk, CLKFLAG_NORETAIN_PERIPH); pm_relax(mxhci->dev); dev_dbg(mxhci->dev, "HSIC-USB in low power mode\n"); xhci_dbg_log_event(&dbg_hsic, NULL, "Controller suspended", 0); return 0; }
/* proximity */ static int prox_power_set(unsigned char onoff) { /* just return 0, later I'll fix it */ static bool init_done = 0; int ret = 0; /* need to be fixed - for vreg using SUB PMIC */ struct regulator *ldo5 = NULL; ldo5 = regulator_get(NULL, "RT8053_LDO5"); if (ldo5 == NULL) pr_err( "%s: regulator_get(ldo5) failed\n", __func__); printk(KERN_INFO "[Proximity] %s() : Power %s\n", __func__, onoff ? "On" : "Off"); if (init_done == 0 && onoff) { if (onoff) { printk(KERN_INFO "LDO5 vreg set.\n"); ret = regulator_set_voltage(ldo5, 2800000, 2800000); if (ret < 0) pr_err( "%s: regulator_set_voltage(ldo5) failed\n", __func__); ret = regulator_enable(ldo5); if (ret < 0) pr_err( "%s: regulator_enable(ldo5) failed\n", __func__); init_done = 1; } else { ret = regulator_disable(ldo5); if (ret < 0) pr_err( "%s: regulator_disable(ldo5) failed\n", __func__); } } return ret; /* struct vreg *temp_vreg = vreg_get(0, ""); printk( "[Proximity] %s() : Power %s\n",__FUNCTION__, onoff ? "On" : "Off"); if (init_done == 0 && onoff) { if (onoff) { vreg_set_level(temp_vreg, 2800); vreg_enable(temp_vreg); init_done = 1; } else { vreg_disable(temp_vreg); } } return ret; */ return ret; }
static int icp_hd_vreg_init(void) { int rc = 0; //CAM_INFO("%s %s:%d\n", __FILE__, __func__, __LINE__); s2b_1p2v_8m = regulator_get(NULL, "8901_s2"); if (IS_ERR(s2b_1p2v_8m)) { //CAM_ERR("regulator_get s2b_1p2v fail : 0x%x\n", s2b_1p2v_8m); return -ENODEV; } rc = regulator_set_voltage(s2b_1p2v_8m, 1300000, 1300000); if (rc) { CAM_ERR("%s: unable to set s2b_1p2v voltage to 1.2V\n", __func__); goto fail; } lvs3b_1p8v = regulator_get(NULL, "8901_lvs3"); if (IS_ERR(lvs3b_1p8v)) { //CAM_ERR("regulator_get lvs3b_1p8v : 0x%x fail\n", lvs3b_1p8v); return -ENODEV; } mvs0b_1p8v_8m = regulator_get(NULL, "8901_mvs0"); if (IS_ERR(mvs0b_1p8v_8m)) { //CAM_ERR("regulator_get mvs0b_1p8v : 0x%x fail\n", mvs0b_1p8v_8m); return -ENODEV; } l2b_2p8v_8m = regulator_get(NULL, "8901_l2"); if (IS_ERR(l2b_2p8v_8m)) { //CAM_ERR("regulator_get l2b_2p8v : 0x%x fail\n", l2b_2p8v_8m); return -ENODEV; } rc = regulator_set_voltage(l2b_2p8v_8m, 2800000, 2800000); if (rc) { //CAM_ERR("%s: unable to set l2b_2p8v voltage to 2.8V\n", __func__); goto fail; } l3b_2p8v_8m = regulator_get(NULL, "8901_l3"); if (IS_ERR(l3b_2p8v_8m)) { //CAM_ERR("regulator_get l3b_2p8v : 0x%x fail\n", l3b_2p8v_8m); return -ENODEV; } rc = regulator_set_voltage(l3b_2p8v_8m, 2800000, 2800000); if (rc) { //CAM_ERR("%s: unable to set l3b_2p8v voltage to 2.8V\n", __func__); goto fail; } //CAM_INFO("%s %s Success!:%d\n", __FILE__, __func__, __LINE__); return rc; fail: //CAM_INFO("%s %s Failed!:%d\n", __FILE__, __func__, __LINE__); if(l2b_2p8v_8m) { regulator_put(l2b_2p8v_8m); } if(s2b_1p2v_8m) { regulator_put(s2b_1p2v_8m); } if(l3b_2p8v_8m) { regulator_put(l3b_2p8v_8m); } return rc; }
static int lis3dh_acc_config_regulator(struct lis3dh_acc_data *acc, bool on) { int rc = 0, i; int num_reg = sizeof(lis3dh_acc_vreg) / sizeof(struct sensor_regulator); if (on) { for (i = 0; i < num_reg; i++) { lis3dh_acc_vreg[i].vreg = regulator_get(&acc->client->dev, lis3dh_acc_vreg[i].name); if (IS_ERR(lis3dh_acc_vreg[i].vreg)) { rc = PTR_ERR(lis3dh_acc_vreg[i].vreg); pr_err("%s:regulator get failed rc=%d\n", __func__, rc); lis3dh_acc_vreg[i].vreg = NULL; goto error_vdd; } if (regulator_count_voltages( lis3dh_acc_vreg[i].vreg) > 0) { rc = regulator_set_voltage( lis3dh_acc_vreg[i].vreg, lis3dh_acc_vreg[i].min_uV, lis3dh_acc_vreg[i].max_uV); if (rc) { pr_err("%s: set voltage failed rc=%d\n", __func__, rc); regulator_put(lis3dh_acc_vreg[i].vreg); lis3dh_acc_vreg[i].vreg = NULL; goto error_vdd; } } rc = regulator_enable(lis3dh_acc_vreg[i].vreg); if (rc) { pr_err("%s: regulator_enable failed rc =%d\n", __func__, rc); if (regulator_count_voltages( lis3dh_acc_vreg[i].vreg) > 0) { regulator_set_voltage( lis3dh_acc_vreg[i].vreg, 0, lis3dh_acc_vreg[i].max_uV); } regulator_put(lis3dh_acc_vreg[i].vreg); lis3dh_acc_vreg[i].vreg = NULL; goto error_vdd; } } return rc; } else { i = num_reg; } error_vdd: while (--i >= 0) { if (!IS_ERR_OR_NULL(lis3dh_acc_vreg[i].vreg)) { if (regulator_count_voltages( lis3dh_acc_vreg[i].vreg) > 0) { regulator_set_voltage(lis3dh_acc_vreg[i].vreg, 0, lis3dh_acc_vreg[i].max_uV); } regulator_disable(lis3dh_acc_vreg[i].vreg); regulator_put(lis3dh_acc_vreg[i].vreg); lis3dh_acc_vreg[i].vreg = NULL; } } return rc; }
static int ist30xx_regulator_configure(struct ist30xx_data *ts, bool on) { int retval; if (on == true) { tsp_debug("ist30xx_regulator_configure : On \n"); } else { tsp_debug("ist30xx_regulator_configure : Off \n"); } if (on == false) goto hw_shutdown; ts->vdd = regulator_get(&ts->client->dev, "vdd"); if (IS_ERR(ts->vdd)) { tsp_debug("Failed to get vdd regulator \n"); return PTR_ERR(ts->vdd); } if (regulator_count_voltages(ts->vdd) > 0) { tsp_debug("regulator_set_voltage(VDD L22, %d, %d) \n", IST30XX_VDD_VOLTAGE, IST30XX_VDD_VOLTAGE); retval = regulator_set_voltage(ts->vdd, IST30XX_VDD_VOLTAGE, IST30XX_VDD_VOLTAGE); if (retval) { tsp_debug("regulator set_vtg failed retval=%d \n", retval); goto err_set_vtg_vdd; } } if (ts->pdata->i2c_pull_up) { tsp_debug("this device has i2c_pull_up \n"); ts->vcc_i2c = regulator_get(&ts->client->dev, "vcc_i2c"); if (IS_ERR(ts->vcc_i2c)) { tsp_debug("Failed to get i2c regulator \n"); retval = PTR_ERR(ts->vcc_i2c); goto err_get_vtg_i2c; } if (regulator_count_voltages(ts->vcc_i2c) > 0) { tsp_debug("regulator_set_voltage(vcc_i2c, %d, %d) \n", IST30XX_I2C_VOLTAGE, IST30XX_I2C_VOLTAGE); retval = regulator_set_voltage(ts->vcc_i2c, IST30XX_I2C_VOLTAGE, IST30XX_I2C_VOLTAGE); if (retval) { tsp_debug("reg set i2c vtg failed retval=%d \n", retval); goto err_set_vtg_i2c; } } } tsp_debug("ist30xx_regulator_configure : On Done \n"); return 0; err_set_vtg_i2c: if (ts->pdata->i2c_pull_up) regulator_put(ts->vcc_i2c); err_get_vtg_i2c: if (regulator_count_voltages(ts->vdd) > 0) regulator_set_voltage(ts->vdd, 0, IST30XX_VDD_VOLTAGE); err_set_vtg_vdd: regulator_put(ts->vdd); tsp_debug("ist30xx_regulator_configure err \n"); return retval; hw_shutdown: if (regulator_count_voltages(ts->vdd) > 0) regulator_set_voltage(ts->vdd, 0, IST30XX_VDD_VOLTAGE); regulator_put(ts->vdd); if (ts->pdata->i2c_pull_up) { if (regulator_count_voltages(ts->vcc_i2c) > 0) regulator_set_voltage(ts->vcc_i2c, 0, IST30XX_I2C_VOLTAGE); regulator_put(ts->vcc_i2c); } tsp_debug("ist30xx_regulator_configure : Off done \n"); return 0; }
static unsigned int wlan_switch_regulators(int on) { int rc = 0, index = 0; if (machine_is_msm7627a_qrd1()) index = 2; for ( ; index < ARRAY_SIZE(vreg_info); index++) { if (on) { rc = regulator_set_voltage(vreg_info[index].reg, vreg_info[index].level_min, vreg_info[index].level_max); if (rc) { pr_err("%s:%s set voltage failed %d\n", __func__, vreg_info[index].vreg_id, rc); goto reg_disable; } rc = regulator_enable(vreg_info[index].reg); if (rc) { pr_err("%s:%s vreg enable failed %d\n", __func__, vreg_info[index].vreg_id, rc); goto reg_disable; } if (vreg_info[index].is_vreg_pin_controlled) { rc = pmapp_vreg_lpm_pincntrl_vote(id, vreg_info[index].pmapp_id, PMAPP_CLOCK_ID_A0, 1); if (rc) { pr_err("%s:%s pincntrl failed %d\n", __func__, vreg_info[index].vreg_id, rc); goto pin_cnt_fail; } } } else { if (vreg_info[index].is_vreg_pin_controlled) { rc = pmapp_vreg_lpm_pincntrl_vote(id, vreg_info[index].pmapp_id, PMAPP_CLOCK_ID_A0, 0); if (rc) { pr_err("%s:%s pincntrl failed %d\n", __func__, vreg_info[index].vreg_id, rc); goto pin_cnt_fail; } } rc = regulator_disable(vreg_info[index].reg); if (rc) { pr_err("%s:%s vreg disable failed %d\n", __func__, vreg_info[index].vreg_id, rc); goto reg_disable; } } } return 0; pin_cnt_fail: if (on) regulator_disable(vreg_info[index].reg); reg_disable: if (!machine_is_msm7627a_qrd1()) { while (index) { if (on) { index--; regulator_disable(vreg_info[index].reg); regulator_put(vreg_info[index].reg); } } } return rc; }
/** * Power on request. * * Set clocks to ON. * Set sensors chip-select GPIO to non-reset (on) value. * */ static int dsps_power_on_handler(void) { int ret = 0; int i, ci, gi, ri; pr_debug("%s.\n", __func__); if (drv->is_on) { pr_debug("%s: already ON.\n", __func__); return 0; } for (ci = 0; ci < drv->pdata->clks_num; ci++) { const char *name = drv->pdata->clks[ci].name; u32 rate = drv->pdata->clks[ci].rate; struct clk *clock = drv->pdata->clks[ci].clock; if (clock == NULL) continue; if (rate > 0) { ret = clk_set_rate(clock, rate); pr_debug("%s: clk %s set rate %d.", __func__, name, rate); if (ret) { pr_err("%s: clk %s set rate %d. err=%d.", __func__, name, rate, ret); goto clk_err; } } ret = clk_enable(clock); if (ret) { pr_err("%s: enable clk %s err %d.", __func__, name, ret); goto clk_err; } } for (gi = 0; gi < drv->pdata->gpios_num; gi++) { const char *name = drv->pdata->gpios[gi].name; int num = drv->pdata->gpios[gi].num; int val = drv->pdata->gpios[gi].on_val; int is_owner = drv->pdata->gpios[gi].is_owner; if (!is_owner) continue; ret = gpio_direction_output(num, val); if (ret) { pr_err("%s: set GPIO %s num %d to %d err %d.", __func__, name, num, val, ret); goto gpio_err; } } for (ri = 0; ri < drv->pdata->regs_num; ri++) { const char *name = drv->pdata->regs[ri].name; struct regulator *reg = drv->pdata->regs[ri].reg; int volt = drv->pdata->regs[ri].volt; if (reg == NULL) continue; pr_debug("%s: set regulator %s.", __func__, name); ret = regulator_set_voltage(reg, volt, volt); if (ret) { pr_err("%s: set regulator %s voltage %d err = %d.\n", __func__, name, volt, ret); goto reg_err; } ret = regulator_enable(reg); if (ret) { pr_err("%s: enable regulator %s err = %d.\n", __func__, name, ret); goto reg_err; } } drv->is_on = true; return 0; /* * If failling to set ANY clock/gpio/regulator to ON then we set * them back to OFF to avoid consuming power for unused * clocks/gpios/regulators. */ reg_err: for (i = 0; i < ri; i++) { struct regulator *reg = drv->pdata->regs[ri].reg; if (reg == NULL) continue; regulator_disable(reg); } gpio_err: for (i = 0; i < gi; i++) { int num = drv->pdata->gpios[i].num; int val = drv->pdata->gpios[i].off_val; int is_owner = drv->pdata->gpios[i].is_owner; if (!is_owner) continue; ret = gpio_direction_output(num, val); } clk_err: for (i = 0; i < ci; i++) { struct clk *clock = drv->pdata->clks[i].clock; if (clock == NULL) continue; clk_disable(clock); } return -ENODEV; }
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) static 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 __devinit twl6040_vibra_probe(struct platform_device *pdev) { struct twl4030_vibra_data *pdata = pdev->dev.platform_data; struct vibra_info *info; int ret; if (!pdata) { dev_err(&pdev->dev, "platform_data not available\n"); return -EINVAL; } info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { dev_err(&pdev->dev, "couldn't allocate memory\n"); return -ENOMEM; } info->dev = &pdev->dev; info->twl6040 = dev_get_drvdata(pdev->dev.parent); info->vibldrv_res = pdata->vibldrv_res; info->vibrdrv_res = pdata->vibrdrv_res; info->viblmotor_res = pdata->viblmotor_res; info->vibrmotor_res = pdata->vibrmotor_res; if ((!info->vibldrv_res && !info->viblmotor_res) || (!info->vibrdrv_res && !info->vibrmotor_res)) { dev_err(info->dev, "invalid vibra driver/motor resistance\n"); ret = -EINVAL; goto err_kzalloc; } info->irq = platform_get_irq(pdev, 0); if (info->irq < 0) { dev_err(info->dev, "invalid irq\n"); ret = -EINVAL; goto err_kzalloc; } mutex_init(&info->mutex); info->input_dev = input_allocate_device(); if (info->input_dev == NULL) { dev_err(info->dev, "couldn't allocate input device\n"); ret = -ENOMEM; goto err_kzalloc; } input_set_drvdata(info->input_dev, info); info->input_dev->name = "twl6040:vibrator"; info->input_dev->id.version = 1; info->input_dev->dev.parent = pdev->dev.parent; info->input_dev->close = twl6040_vibra_close; __set_bit(FF_RUMBLE, info->input_dev->ffbit); ret = input_ff_create_memless(info->input_dev, NULL, vibra_play); if (ret < 0) { dev_err(info->dev, "couldn't register vibrator to FF\n"); goto err_ialloc; } ret = input_register_device(info->input_dev); if (ret < 0) { dev_err(info->dev, "couldn't register input device\n"); goto err_iff; } platform_set_drvdata(pdev, info); ret = request_threaded_irq(info->irq, NULL, twl6040_vib_irq_handler, 0, "twl6040_irq_vib", info); if (ret) { dev_err(info->dev, "VIB IRQ request failed: %d\n", ret); goto err_irq; } info->supplies[0].supply = "vddvibl"; info->supplies[1].supply = "vddvibr"; ret = regulator_bulk_get(info->dev, ARRAY_SIZE(info->supplies), info->supplies); if (ret) { dev_err(info->dev, "couldn't get regulators %d\n", ret); goto err_regulator; } if (pdata->vddvibl_uV) { ret = regulator_set_voltage(info->supplies[0].consumer, pdata->vddvibl_uV, pdata->vddvibl_uV); if (ret) { dev_err(info->dev, "failed to set VDDVIBL volt %d\n", ret); goto err_voltage; } } if (pdata->vddvibr_uV) { ret = regulator_set_voltage(info->supplies[1].consumer, pdata->vddvibr_uV, pdata->vddvibr_uV); if (ret) { dev_err(info->dev, "failed to set VDDVIBR volt %d\n", ret); goto err_voltage; } } info->workqueue = alloc_workqueue("twl6040-vibra", 0, 0); if (info->workqueue == NULL) { dev_err(info->dev, "couldn't create workqueue\n"); ret = -ENOMEM; goto err_voltage; } INIT_WORK(&info->play_work, vibra_play_work); return 0; err_voltage: regulator_bulk_free(ARRAY_SIZE(info->supplies), info->supplies); err_regulator: free_irq(info->irq, info); err_irq: input_unregister_device(info->input_dev); info->input_dev = NULL; err_iff: if (info->input_dev) input_ff_destroy(info->input_dev); err_ialloc: input_free_device(info->input_dev); err_kzalloc: kfree(info); return ret; }
static int __devinit pil_riva_probe(struct platform_device *pdev) { struct riva_data *drv; struct resource *res; struct pil_desc *desc; int ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; drv->pll_supply = devm_regulator_get(&pdev->dev, "pll_vdd"); if (IS_ERR(drv->pll_supply)) { dev_err(&pdev->dev, "failed to get pll supply\n"); return PTR_ERR(drv->pll_supply); } if (regulator_count_voltages(drv->pll_supply) > 0) { ret = regulator_set_voltage(drv->pll_supply, 1800000, 1800000); if (ret) { dev_err(&pdev->dev, "failed to set pll supply voltage\n"); return ret; } ret = regulator_set_optimum_mode(drv->pll_supply, 100000); if (ret < 0) { dev_err(&pdev->dev, "failed to set pll supply optimum mode\n"); return ret; } } desc->name = "wcnss"; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; if (pas_supported(PAS_WCNSS) > 0) { desc->ops = &pil_riva_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_riva_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } drv->xo = devm_clk_get(&pdev->dev, "cxo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) return PTR_ERR(drv->pil); return 0; }
static int hdmi_core_power(int on, int show) { static struct regulator *reg_8921_lvs7, *reg_8921_s4, *reg_ext_3p3v; static int prev_on; int rc; if (on == prev_on) return 0; /* TBD: PM8921 regulator instead of 8901 */ if (!reg_ext_3p3v) { reg_ext_3p3v = regulator_get(&hdmi_msm_device.dev, "hdmi_mux_vdd"); if (IS_ERR_OR_NULL(reg_ext_3p3v)) { pr_err("could not get reg_ext_3p3v, rc = %ld\n", PTR_ERR(reg_ext_3p3v)); reg_ext_3p3v = NULL; return -ENODEV; } } if (!reg_8921_lvs7) { reg_8921_lvs7 = regulator_get(&hdmi_msm_device.dev, "hdmi_vdda"); if (IS_ERR(reg_8921_lvs7)) { pr_err("could not get reg_8921_lvs7, rc = %ld\n", PTR_ERR(reg_8921_lvs7)); reg_8921_lvs7 = NULL; return -ENODEV; } } if (!reg_8921_s4) { reg_8921_s4 = regulator_get(&hdmi_msm_device.dev, "hdmi_lvl_tsl"); if (IS_ERR(reg_8921_s4)) { pr_err("could not get reg_8921_s4, rc = %ld\n", PTR_ERR(reg_8921_s4)); reg_8921_s4 = NULL; return -ENODEV; } rc = regulator_set_voltage(reg_8921_s4, 1800000, 1800000); if (rc) { pr_err("set_voltage failed for 8921_s4, rc=%d\n", rc); return -EINVAL; } } if (on) { /* * Configure 3P3V_BOOST_EN as GPIO, 8mA drive strength, * pull none, out-high */ rc = regulator_set_optimum_mode(reg_ext_3p3v, 290000); if (rc < 0) { pr_err("set_optimum_mode ext_3p3v failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_ext_3p3v); if (rc) { pr_err("enable reg_ext_3p3v failed, rc=%d\n", rc); return rc; } rc = regulator_enable(reg_8921_lvs7); if (rc) { pr_err("'%s' regulator enable failed, rc=%d\n", "hdmi_vdda", rc); goto error1; } rc = regulator_enable(reg_8921_s4); if (rc) { pr_err("'%s' regulator enable failed, rc=%d\n", "hdmi_lvl_tsl", rc); goto error2; } pr_debug("%s(on): success\n", __func__); } else { rc = regulator_disable(reg_ext_3p3v); if (rc) { pr_err("disable reg_ext_3p3v failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_8921_lvs7); if (rc) { pr_err("disable reg_8921_l23 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_8921_s4); if (rc) { pr_err("disable reg_8921_s4 failed, rc=%d\n", rc); return -ENODEV; } pr_debug("%s(off): success\n", __func__); } prev_on = on; return 0; error2: regulator_disable(reg_8921_lvs7); error1: regulator_disable(reg_ext_3p3v); return rc; }
int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg, int num_vreg, int config) { int i = 0, rc = 0; struct dss_vreg *curr_vreg = NULL; enum dss_vreg_type type; if (config) { for (i = 0; i < num_vreg; i++) { curr_vreg = &in_vreg[i]; curr_vreg->vreg = regulator_get(dev, curr_vreg->vreg_name); rc = PTR_RET(curr_vreg->vreg); if (rc) { DEV_ERR("%pS->%s: %s get failed. rc=%d\n", __builtin_return_address(0), __func__, curr_vreg->vreg_name, rc); curr_vreg->vreg = NULL; goto vreg_get_fail; } type = (regulator_count_voltages(curr_vreg->vreg) > 0) ? DSS_REG_LDO : DSS_REG_VS; if (type == DSS_REG_LDO) { rc = regulator_set_voltage( curr_vreg->vreg, curr_vreg->min_voltage, curr_vreg->max_voltage); if (rc < 0) { DEV_ERR("%pS->%s: %s set vltg fail\n", __builtin_return_address(0), __func__, curr_vreg->vreg_name); goto vreg_set_voltage_fail; } } } } else { for (i = num_vreg-1; i >= 0; i--) { curr_vreg = &in_vreg[i]; if (curr_vreg->vreg) { type = (regulator_count_voltages( curr_vreg->vreg) > 0) ? DSS_REG_LDO : DSS_REG_VS; if (type == DSS_REG_LDO) { regulator_set_voltage(curr_vreg->vreg, 0, curr_vreg->max_voltage); } regulator_put(curr_vreg->vreg); curr_vreg->vreg = NULL; } } } return 0; vreg_unconfig: if (type == DSS_REG_LDO) regulator_set_optimum_mode(curr_vreg->vreg, 0); vreg_set_voltage_fail: regulator_put(curr_vreg->vreg); curr_vreg->vreg = NULL; vreg_get_fail: for (i--; i >= 0; i--) { curr_vreg = &in_vreg[i]; type = (regulator_count_voltages(curr_vreg->vreg) > 0) ? DSS_REG_LDO : DSS_REG_VS; goto vreg_unconfig; } return rc; } /* msm_dss_config_vreg */