static int __devinit s3cfb_probe(struct platform_device *pdev) { struct s3c_platform_fb *pdata; struct s3cfb_global *fbdev; struct resource *res; int i, j, ret = 0; fbdev = kzalloc(sizeof(struct s3cfb_global), GFP_KERNEL); if (!fbdev) { dev_err(fbdev->dev, "failed to allocate for " "global fb structure\n"); ret = -ENOMEM; goto err_global; } fbdev->dev = &pdev->dev; fbdev->regulator = regulator_get(&pdev->dev, "pd"); if (!fbdev->regulator) { dev_err(fbdev->dev, "failed to get regulator\n"); ret = -EINVAL; goto err_regulator; } ret = regulator_enable(fbdev->regulator); if (ret < 0) { dev_err(fbdev->dev, "failed to enable regulator\n"); ret = -EINVAL; goto err_regulator; } #ifndef CONFIG_MACH_MID fbdev->vcc_lcd = regulator_get(&pdev->dev, "vcc_lcd"); if (!fbdev->vcc_lcd) { dev_err(fbdev->dev, "failed to get vcc_lcd\n"); ret = -EINVAL; goto err_vcc_lcd; } ret = regulator_enable(fbdev->vcc_lcd); if (ret < 0) { dev_err(fbdev->dev, "failed to enable vcc_lcd\n"); ret = -EINVAL; goto err_vcc_lcd; } fbdev->vlcd = regulator_get(&pdev->dev, "vlcd"); if (!fbdev->vlcd) { dev_err(fbdev->dev, "failed to get vlcd\n"); ret = -EINVAL; goto err_vlcd; } ret = regulator_enable(fbdev->vlcd); if (ret < 0) { dev_err(fbdev->dev, "failed to enable vlcd\n"); ret = -EINVAL; goto err_vlcd; } #endif pdata = to_fb_plat(&pdev->dev); if (!pdata) { dev_err(fbdev->dev, "failed to get platform data\n"); ret = -EINVAL; goto err_pdata; } fbdev->lcd = (struct s3cfb_lcd *)pdata->lcd; if (pdata->cfg_gpio) pdata->cfg_gpio(pdev); if (pdata->clk_on) pdata->clk_on(pdev, &fbdev->clock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(fbdev->dev, "failed to get io memory region\n"); ret = -EINVAL; goto err_io; } res = request_mem_region(res->start, res->end - res->start + 1, pdev->name); if (!res) { dev_err(fbdev->dev, "failed to request io memory region\n"); ret = -EINVAL; goto err_io; } fbdev->regs = ioremap(res->start, res->end - res->start + 1); if (!fbdev->regs) { dev_err(fbdev->dev, "failed to remap io region\n"); ret = -EINVAL; goto err_mem; } s3cfb_set_vsync_interrupt(fbdev, 1); s3cfb_set_global_interrupt(fbdev, 1); s3cfb_init_global(fbdev); if (s3cfb_alloc_framebuffer(fbdev)) { ret = -ENOMEM; goto err_alloc; } if (s3cfb_register_framebuffer(fbdev)) { ret = -EINVAL; goto err_register; } s3cfb_set_clock(fbdev); s3cfb_set_window(fbdev, pdata->default_win, 1); s3cfb_display_on(fbdev); fbdev->irq = platform_get_irq(pdev, 0); if (request_irq(fbdev->irq, s3cfb_irq_frame, IRQF_SHARED, pdev->name, fbdev)) { dev_err(fbdev->dev, "request_irq failed\n"); ret = -EINVAL; goto err_irq; } #ifdef CONFIG_FB_S3C_LCD_INIT #if defined(CONFIG_FB_S3C_TL2796) if (pdata->backlight_on) pdata->backlight_on(pdev); #endif if (!bootloaderfb && pdata->reset_lcd) pdata->reset_lcd(pdev); #endif #ifdef CONFIG_HAS_EARLYSUSPEND fbdev->early_suspend.suspend = s3cfb_early_suspend; fbdev->early_suspend.resume = s3cfb_late_resume; fbdev->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB; register_early_suspend(&fbdev->early_suspend); #endif fbdev->vsync_thread = kthread_run(s3cfb_wait_for_vsync_thread, fbdev, "s3cfb-vsync"); if (fbdev->vsync_thread == ERR_PTR(-ENOMEM)) { dev_err(fbdev->dev, "failed to run vsync thread\n"); fbdev->vsync_thread = NULL; } ret = device_create_file(&(pdev->dev), &dev_attr_win_power); if (ret < 0) dev_err(fbdev->dev, "failed to add sysfs entries\n"); dev_info(fbdev->dev, "registered successfully\n"); return 0; err_irq: s3cfb_display_off(fbdev); s3cfb_set_window(fbdev, pdata->default_win, 0); for (i = pdata->default_win; i < pdata->nr_wins + pdata->default_win; i++) { j = i % pdata->nr_wins; unregister_framebuffer(fbdev->fb[j]); } err_register: for (i = 0; i < pdata->nr_wins; i++) { if (i == pdata->default_win) s3cfb_unmap_default_video_memory(fbdev->fb[i]); framebuffer_release(fbdev->fb[i]); } kfree(fbdev->fb); err_alloc: iounmap(fbdev->regs); err_mem: release_mem_region(res->start, res->end - res->start + 1); err_io: pdata->clk_off(pdev, &fbdev->clock); err_pdata: #ifndef CONFIG_MACH_MID regulator_disable(fbdev->vlcd); err_vlcd: regulator_disable(fbdev->vcc_lcd); err_vcc_lcd: #endif regulator_disable(fbdev->regulator); err_regulator: kfree(fbdev); err_global: return ret; }
static int imx135_power_ctrl(struct v4l2_subdev *sd, int flag) { struct i2c_client *client = v4l2_get_subdevdata(sd); int ret = 0; if (flag) { if (is_ctp()) { if (!camera_vemmc1_on) { camera_vemmc1_on = 1; ret = regulator_enable(vemmc1_reg); if (ret) { dev_err(&client->dev, "Failed to enable regulator vemmc1\n"); return ret; } } if (vprog1_reg && !camera_vprog1_on) { camera_vprog1_on = 1; ret = regulator_enable(vprog1_reg); if (ret) { dev_err(&client->dev, "Failed to enable regulator vprog1\n"); return ret; } } if (!is_victoriabay()) { if (camera_power < 0) { ret = camera_sensor_gpio(-1, GP_CAMERA_1_POWER_DOWN, GPIOF_DIR_OUT, 1); if (ret < 0) return ret; camera_power = ret; } gpio_set_value(camera_power, 1); } /* min 250us -Initializing time of silicon */ usleep_range(250, 300); } else { if (!camera_vprog1_on) { ret = regulator_enable(vprog1_reg); if (!ret) { /* imx1x5 VDIG rise to XCLR release */ usleep_range(1000, 1200); camera_vprog1_on = 1; } return ret; } } } else { if (is_ctp()) { if (camera_vemmc1_on) { camera_vemmc1_on = 0; ret = regulator_disable(vemmc1_reg); if (ret) { dev_err(&client->dev, "Failed to disable regulator vemmc1\n"); return ret; } } if (vprog1_reg && camera_vprog1_on) { camera_vprog1_on = 0; ret = regulator_disable(vprog1_reg); if (ret) { dev_err(&client->dev, "Failed to disable regulator vprog1\n"); return ret; } } } else { if (camera_vprog1_on) { ret = regulator_disable(vprog1_reg); if (!ret) camera_vprog1_on = 0; 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 t4k35_180_power_ctrl(struct v4l2_subdev *sd, int flag) { int reg_err; int ret = 0; printk("%s: ++\n",__func__); if (camera_reset < 0) { ret = camera_sensor_gpio(-1, GP_CAMERA_0_RESET, GPIOF_DIR_OUT, 0); if (ret < 0){ printk("camera_reset not available.\n"); return ret; } camera_reset = ret; } printk("<< camera_reset:%d, flag:%d\n", camera_reset, flag); if (flag) { if (camera_reset >= 0){ gpio_set_value(camera_reset, 0); printk("<<< camera_reset = 0\n"); } //turn on VCM power 2.85V if (!camera_vemmc1_on) { camera_vemmc1_on = 1; reg_err = regulator_enable(vemmc1_reg); if (reg_err) { printk(KERN_ALERT "Failed to enable regulator vemmc1\n"); return reg_err; } printk("<<< VCM 2.85V = 1\n"); } //turn on power 1.8V and 2.8V if (!camera_vprog1_on) { camera_vprog1_on = 1; reg_err = regulator_enable(vprog1_reg); if (reg_err) { printk(KERN_ALERT "Failed to enable regulator vprog1\n"); return reg_err; } printk("<<< 1.8V and 2.8V = 1\n"); } //turn on power 1.2V if (!camera_vprog2_on) { camera_vprog2_on = 1; reg_err = regulator_enable(vprog2_reg); if (reg_err) { printk(KERN_ALERT "Failed to enable regulator vprog2\n"); return reg_err; } printk("<<< 1.2V = 1\n"); } usleep_range(2000, 2100); //wait vprog1 and vprog2 from enable to 90% (max:2000us) } else { if (camera_reset >= 0){ gpio_free(camera_reset); camera_reset = -1; } //turn off power 1.2V if (camera_vprog2_on) { camera_vprog2_on = 0; reg_err = regulator_disable(vprog2_reg); if (reg_err) { printk(KERN_ALERT "Failed to disable regulator vprog2\n"); return reg_err; } printk("<<< 1.2V = 0\n"); } //turn off power 1.8V and 2.8V if (camera_vprog1_on) { camera_vprog1_on = 0; reg_err = regulator_disable(vprog1_reg); if (reg_err) { printk(KERN_ALERT "Failed to disable regulator vprog1\n"); return reg_err; } printk("<<< 1.8V and 2.8V = 0\n"); } //turn off VCM power 2.85V if (camera_vemmc1_on) { camera_vemmc1_on = 0; reg_err = regulator_disable(vemmc1_reg); if (reg_err) { printk(KERN_ALERT "Failed to disable regulator vemmc1\n"); return reg_err; } printk("<<< VCM 2.85V = 0\n"); } } return 0; }
int msm_mdss_init(struct drm_device *dev) { struct platform_device *pdev = to_platform_device(dev->dev); struct msm_drm_private *priv = dev->dev_private; struct msm_mdss *mdss; int ret; DBG(""); if (!of_device_is_compatible(dev->dev->of_node, "qcom,mdss")) return 0; mdss = devm_kzalloc(dev->dev, sizeof(*mdss), GFP_KERNEL); if (!mdss) { ret = -ENOMEM; goto fail; } mdss->dev = dev; mdss->mmio = msm_ioremap(pdev, "mdss_phys", "MDSS"); if (IS_ERR(mdss->mmio)) { ret = PTR_ERR(mdss->mmio); goto fail; } mdss->vbif = msm_ioremap(pdev, "vbif_phys", "VBIF"); if (IS_ERR(mdss->vbif)) { ret = PTR_ERR(mdss->vbif); goto fail; } /* Regulator to enable GDSCs in downstream kernels */ mdss->vdd = devm_regulator_get(dev->dev, "vdd"); if (IS_ERR(mdss->vdd)) { ret = PTR_ERR(mdss->vdd); goto fail; } ret = regulator_enable(mdss->vdd); if (ret) { dev_err(dev->dev, "failed to enable regulator vdd: %d\n", ret); goto fail; } ret = devm_request_irq(dev->dev, platform_get_irq(pdev, 0), mdss_irq, 0, "mdss_isr", mdss); if (ret) { dev_err(dev->dev, "failed to init irq: %d\n", ret); goto fail_irq; } ret = mdss_irq_domain_init(mdss); if (ret) { dev_err(dev->dev, "failed to init sub-block irqs: %d\n", ret); goto fail_irq; } priv->mdss = mdss; pm_runtime_enable(dev->dev); /* * TODO: This is needed as the MDSS GDSC is only tied to MDSS's power * domain. Remove this once runtime PM is adapted for all the devices. */ pm_runtime_get_sync(dev->dev); return 0; fail_irq: regulator_disable(mdss->vdd); fail: return ret; }
int omapdss_dpi_display_enable(struct omap_dss_device *dssdev) { int r; if (cpu_is_omap44xx() && dssdev->channel != OMAP_DSS_CHANNEL_LCD2) { /* Only LCD2 channel is connected to DPI on OMAP4 */ return -EINVAL; } r = omap_dss_start_device(dssdev); if (r) { DSSERR("failed to start device\n"); return r; } if (cpu_is_omap34xx() && !cpu_is_omap3630()) { r = regulator_enable(dpi.vdds_dsi_reg); if (r) goto err0; } /* turn on clock(s) */ dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; if (!cpu_is_omap44xx()) dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1); dss_mainclk_state_enable(); dpi_basic_init(dssdev); #ifdef CONFIG_OMAP2_DSS_USE_DSI_PLL r = dsi_pll_init(dssdev, 0, 1); if (r) goto err1; #endif /* CONFIG_OMAP2_DSS_USE_DSI_PLL */ r = dpi_set_mode(dssdev); if (r) goto err2; mdelay(2); if (dssdev->manager) { if (cpu_is_omap44xx()) dpi_start_auto_update(dssdev); dssdev->manager->enable(dssdev->manager); } return 0; err2: #ifdef CONFIG_OMAP2_DSS_USE_DSI_PLL dsi_pll_uninit(dssdev->channel == OMAP_DSS_CHANNEL_LCD ? DSI1 : DSI2); err1: #endif dssdev->state = OMAP_DSS_DISPLAY_DISABLED; if (!cpu_is_omap44xx()) dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1); dss_mainclk_state_disable(true); if (cpu_is_omap34xx() && !cpu_is_omap3630()) regulator_disable(dpi.vdds_dsi_reg); err0: omap_dss_stop_device(dssdev); return r; }
static int __devinit px3315_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct px3315_platform_data *pdata = client->dev.platform_data; struct px3315_data *data; struct device *proximity_device = NULL; int err = 0; int ret = 0; int error = 0; this_client = client; printk("%s\n", __func__); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) return -EIO; data = kzalloc(sizeof(struct px3315_data), GFP_KERNEL); if (!data) return -ENOMEM; px3315_power.regulator_vdd = NULL; px3315_power.regulator_vio = NULL; px3315_power.regulator_vdd = regulator_get(&client->dev, "vdd-proxi"); if (IS_ERR(px3315_power.regulator_vdd)) { ret = PTR_ERR(px3315_power.regulator_vdd); pr_err("%s: failed to get vdd-proxi regulator %d\n", __func__, ret); goto err_setup_regulator; } px3315_power.regulator_vio = regulator_get(&client->dev, "vio_proxi"); if (IS_ERR(px3315_power.regulator_vio)) { ret = PTR_ERR(px3315_power.regulator_vio); pr_err("%s: failed to get vio_proxi regulator %d\n", __func__, ret); goto err_setup_regulator; } regulator_enable(px3315_power.regulator_vdd); mdelay(15); regulator_enable(px3315_power.regulator_vio); dev_set_name(&client->dev, client->name); data->gpio = pdata->ps_vout_gpio; data->client = client; data->irq = client->irq; i2c_set_clientdata(client, data); mutex_init(&data->lock); /* INT Settings */ data->irq = gpio_to_irq(data->gpio); if (data->irq < 0) { err = data->irq; pr_err("%s: Failed to convert GPIO %u to IRQ [errno=%d]", __func__, data->gpio, err); goto exit_kfree; } err = request_threaded_irq(data->irq, NULL, px3315_irq, IRQF_TRIGGER_FALLING, "px3315", data); if (err) { pr_err("%s: request_irq failed for taos\n", __func__); goto exit_kfree; } disable_irq(data->irq); INIT_WORK(&data->work_ptime, px3315_work_func); /* initialize the PX3315 chip */ err = px3315_init_client(client); if (err) goto exit_kfree; /* create input device */ err = px3315_input_init(data); if (err) goto exit_kfree; /* register sysfs hooks */ err = sysfs_create_group(&data->input->dev.kobj, &px3315_attr_group); if (err) goto exit_input; error = sensors_register(proximity_device, data, proximity_attrs, "proximity_sensor"); if (error < 0) { pr_err("%s: could not register proximity sensor device(%d).\n", __func__, error); goto exit_input; } dev_info(&client->dev, "px3315 driver version %s enabled\n", DRIVER_VERSION); return 0; exit_input: px3315_input_fini(data); exit_kfree: kfree(data); err_setup_regulator: if (px3315_power.regulator_vdd) { regulator_disable(px3315_power.regulator_vdd); regulator_put(px3315_power.regulator_vdd); } if (px3315_power.regulator_vio) { regulator_disable(px3315_power.regulator_vio); regulator_put(px3315_power.regulator_vio); } return err; }
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; }
/* 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; }
/** * 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; }
static void mop500_prox_deactivate(struct device *dev) { regulator_disable(prox_regulator); regulator_put(prox_regulator); }
static int wl1251_spi_probe(struct spi_device *spi) { struct wl1251_platform_data *pdata = dev_get_platdata(&spi->dev); struct device_node *np = spi->dev.of_node; struct ieee80211_hw *hw; struct wl1251 *wl; int ret; if (!np && !pdata) { wl1251_error("no platform data"); return -ENODEV; } hw = wl1251_alloc_hw(); if (IS_ERR(hw)) return PTR_ERR(hw); wl = hw->priv; SET_IEEE80211_DEV(hw, &spi->dev); spi_set_drvdata(spi, wl); wl->if_priv = spi; wl->if_ops = &wl1251_spi_ops; /* This is the only SPI value that we need to set here, the rest * comes from the board-peripherals file */ spi->bits_per_word = 32; ret = spi_setup(spi); if (ret < 0) { wl1251_error("spi_setup failed"); goto out_free; } if (np) { wl->use_eeprom = of_property_read_bool(np, "ti,wl1251-has-eeprom"); wl->power_gpio = of_get_named_gpio(np, "ti,power-gpio", 0); } else if (pdata) { wl->power_gpio = pdata->power_gpio; wl->use_eeprom = pdata->use_eeprom; } if (wl->power_gpio == -EPROBE_DEFER) { ret = -EPROBE_DEFER; goto out_free; } if (gpio_is_valid(wl->power_gpio)) { ret = devm_gpio_request_one(&spi->dev, wl->power_gpio, GPIOF_OUT_INIT_LOW, "wl1251 power"); if (ret) { wl1251_error("Failed to request gpio: %d\n", ret); goto out_free; } } else { wl1251_error("set power gpio missing in platform data"); ret = -ENODEV; goto out_free; } wl->irq = spi->irq; if (wl->irq < 0) { wl1251_error("irq missing in platform data"); ret = -ENODEV; goto out_free; } irq_set_status_flags(wl->irq, IRQ_NOAUTOEN); ret = devm_request_irq(&spi->dev, wl->irq, wl1251_irq, 0, DRIVER_NAME, wl); if (ret < 0) { wl1251_error("request_irq() failed: %d", ret); goto out_free; } irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING); wl->vio = devm_regulator_get(&spi->dev, "vio"); if (IS_ERR(wl->vio)) { ret = PTR_ERR(wl->vio); wl1251_error("vio regulator missing: %d", ret); goto out_free; } ret = regulator_enable(wl->vio); if (ret) goto out_free; ret = wl1251_init_ieee80211(wl); if (ret) goto disable_regulator; return 0; disable_regulator: regulator_disable(wl->vio); out_free: ieee80211_free_hw(hw); return ret; }
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 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 mipi_dsi_panel_power(int on) { int rc = 0; /* LGE_CHANGE_S [email protected] 2013-01-15 booting animation sometimes no display*/ if(on == 0){ if(firstbootend == 0){ firstbootend = 1; return 0; } } /* LGE_CHANGE_E [email protected] 2013-01-15 booting animation sometimes no display*/ if (unlikely(!dsi_gpio_initialized)) { /* Resetting LCD Panel*/ rc = gpio_request(GPIO_LCD_RESET, "lcd_reset"); if (rc) { pr_err("%s: gpio_request GPIO_LCD_RESET failed\n", __func__); } rc = gpio_tlmm_config(GPIO_CFG(GPIO_LCD_RESET, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); if (rc) { printk(KERN_ERR "%s: Failed to configure GPIO %d\n", __func__, rc); } dsi_gpio_initialized = 1; } if (on) { rc = regulator_enable(regulator_mipi_dsi[0]); if (rc) { pr_err("%s: vreg_enable failed for mipi_dsi_v18\n", __func__); goto vreg_put_dsi_v18; } msleep(3); //LGE_CHANGE_S [changbum.lee] 20120130 : add delay rc = regulator_enable(regulator_mipi_dsi[1]); if (rc) { pr_err("%s: vreg_enable failed for mipi_dsi_v28\n", __func__); goto vreg_put_dsi_v28; } rc = gpio_direction_output(GPIO_LCD_RESET, 1); if (rc) { pr_err("%s: gpio_direction_output failed for lcd_reset\n", __func__); goto vreg_put_dsi_v28; } if (firstbootend) { gpio_set_value(GPIO_LCD_RESET, 0); //sohyun.nam, 12-11-23, arrange nReset pin msleep(8); //sohyun.nam, 12-11-23, arrange nReset pin rc = regulator_disable(regulator_mipi_dsi[1]);//2.8v msleep(15); //sohyun.nam, 12-11-23, arrange nReset pin if (rc) { pr_err("%s: vreg_disable failed for mipi_dsi_v28\n", __func__); goto vreg_put_dsi_v28; } rc = regulator_enable(regulator_mipi_dsi[1]);//2.8v msleep(15); //sohyun.nam, 12-11-23, arrange nReset pin gpio_set_value(GPIO_LCD_RESET, 1); //sohyun.nam msleep(8); if (rc) { pr_err("%s: vreg_enable failed for mipi_dsi_v28\n", __func__); goto vreg_put_dsi_v28; } } else { firstbootend=1; } } else//off { rc = regulator_disable(regulator_mipi_dsi[0]); if (rc) { pr_err("%s: vreg_disable failed for mipi_dsi_v18\n", __func__); goto vreg_put_dsi_v18; } rc = regulator_disable(regulator_mipi_dsi[1]); if (rc) { pr_err("%s: vreg_disable failed for mipi_dsi_v28\n", __func__); goto vreg_put_dsi_v28; } } return 0; vreg_put_dsi_v28: regulator_put(regulator_mipi_dsi[1]); vreg_put_dsi_v18: regulator_put(regulator_mipi_dsi[0]); 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 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 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; }
static int icp_hd_power(int on) { int rc = 0; //int status=0; //CAM_INFO("%s %s:%d power = %d\n", __FILE__, __func__, __LINE__,on); if(on) { //standby control rc = gpio_tlmm_config(GPIO_CFG(SENSOR_STANDBY_8M, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA),GPIO_CFG_ENABLE); if (!rc) { //CAM_INFO("%s %s:%d\n", __FILE__, __func__, __LINE__); gpio_set_value(SENSOR_STANDBY_8M,0); } rc = regulator_enable(s2b_1p2v_8m); if (rc) { //CAM_ERR("%s: Enable regulator s2b_1p2v failed\n", __func__); goto fail; } msleep(1); rc = regulator_enable(mvs0b_1p8v_8m); if (rc) { //CAM_ERR("%s: Enable regulator mvs0b_1p8v failed\n", __func__); goto fail; } msleep(1); rc = regulator_enable(lvs3b_1p8v); if (rc) { //CAM_ERR("%s: Enable regulator lvs3b_1p8v failed\n", __func__); goto fail; } msleep(1); rc = regulator_enable(l2b_2p8v_8m); if (rc) { //CAM_ERR("%s: Enable regulator l2b_2p8v failed\n", __func__); goto fail; } msleep(1); rc = regulator_enable(l3b_2p8v_8m); if (rc) { //CAM_ERR("%s: Enable regulator l3b_2p8v failed\n", __func__); goto fail; } //CAM_INFO("%s %s ON Success:%d\n", __FILE__, __func__, __LINE__); } else { //CAM_INFO("%s %s:%d power \n", __FILE__, __func__, __LINE__); //CAM_INFO("%s %s:%d power \n", __FILE__, __func__, __LINE__); if(1)//mvs0b_1p8v) { rc = regulator_disable(mvs0b_1p8v_8m); if (rc){ //CAM_ERR("%s: Disable regulator mvs0b_1p8v failed\n", __func__); goto fail; } } //CAM_INFO("%s %s:%d power \n", __FILE__, __func__, __LINE__); if(1)//l2b_2p8v) { rc = regulator_disable(l2b_2p8v_8m); if (rc){ //CAM_ERR("%s: Disable regulator l2b_2p8v failed\n", __func__); goto fail; } regulator_put(l2b_2p8v_8m); } //CAM_INFO("%s %s:%d power \n", __FILE__, __func__, __LINE__); if(1)//l3b_2p8v) { rc = regulator_disable(l3b_2p8v_8m); if (rc){ //CAM_ERR("%s: Disable regulator l3b_2p8v failed\n", __func__); goto fail; } regulator_put(l3b_2p8v_8m); } //CAM_INFO("%s %s OFF Success:%d\n", __FILE__, __func__, __LINE__); } return rc; fail: CAM_ERR("%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 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; }
/** * dwc3_otg_start_host - helper function for starting/stoping the host controller driver. * * @otg: Pointer to the otg_transceiver structure. * @on: start / stop the host controller driver. * * Returns 0 on success otherwise negative errno. */ static int dwc3_otg_start_host(struct usb_otg *otg, int on) { struct dwc3_otg *dotg = container_of(otg, struct dwc3_otg, otg); struct dwc3_ext_xceiv *ext_xceiv = dotg->ext_xceiv; struct dwc3 *dwc = dotg->dwc; int ret = 0; if (!dwc->xhci) return -EINVAL; if (!dotg->vbus_otg) { dotg->vbus_otg = devm_regulator_get(dwc->dev->parent, "vbus_dwc3"); if (IS_ERR(dotg->vbus_otg)) { dev_err(dwc->dev, "Failed to get vbus regulator\n"); ret = PTR_ERR(dotg->vbus_otg); dotg->vbus_otg = 0; return ret; } } if (on) { dev_dbg(otg->phy->dev, "%s: turn on host\n", __func__); /* * This should be revisited for more testing post-silicon. * In worst case we may need to disconnect the root hub * before stopping the controller so that it does not * interfere with runtime pm/system pm. * We can also consider registering and unregistering xhci * platform device. It is almost similar to add_hcd and * remove_hcd, But we may not use standard set_host method * anymore. */ dwc3_otg_set_hsphy_auto_suspend(dotg, true); dwc3_otg_set_host_regs(dotg); /* * FIXME If micro A cable is disconnected during system suspend, * xhci platform device will be removed before runtime pm is * enabled for xhci device. Due to this, disable_depth becomes * greater than one and runtimepm is not enabled for next microA * connect. Fix this by calling pm_runtime_init for xhci device. */ pm_runtime_init(&dwc->xhci->dev); ret = platform_device_add(dwc->xhci); if (ret) { dev_err(otg->phy->dev, "%s: failed to add XHCI pdev ret=%d\n", __func__, ret); return ret; } dwc3_otg_notify_host_mode(otg, on); ret = regulator_enable(dotg->vbus_otg); if (ret) { dev_err(otg->phy->dev, "unable to enable vbus_otg\n"); platform_device_del(dwc->xhci); return ret; } /* re-init OTG EVTEN register as XHCI reset clears it */ if (ext_xceiv && !ext_xceiv->otg_capability) dwc3_otg_reset(dotg); } else { dev_dbg(otg->phy->dev, "%s: turn off host\n", __func__); ret = regulator_disable(dotg->vbus_otg); if (ret) { dev_err(otg->phy->dev, "unable to disable vbus_otg\n"); return ret; } dwc3_otg_notify_host_mode(otg, on); platform_device_del(dwc->xhci); /* * Perform USB hardware RESET (both core reset and DBM reset) * when moving from host to peripheral. This is required for * peripheral mode to work. */ if (ext_xceiv && ext_xceiv->otg_capability && ext_xceiv->ext_block_reset) ext_xceiv->ext_block_reset(ext_xceiv, true); dwc3_otg_set_hsphy_auto_suspend(dotg, false); dwc3_otg_set_peripheral_regs(dotg); /* re-init core and OTG registers as block reset clears these */ dwc3_post_host_reset_core_init(dwc); if (ext_xceiv && !ext_xceiv->otg_capability) dwc3_otg_reset(dotg); } return 0; }
static void pil_riva_remove_proxy_vote(struct pil_desc *pil) { struct riva_data *drv = dev_get_drvdata(pil->dev); regulator_disable(drv->pll_supply); clk_disable_unprepare(drv->xo); }
static int ist30xx_ldo_power_on(struct ist30xx_data *ts, bool on) { int retval; if (on == true) { tsp_debug("ist30xx_ldo_power_on : On \n"); } else { tsp_debug("ist30xx_ldo_power_on : Off \n"); } if (on == false) goto power_off; retval = reg_set_optimum_mode_check(ts->vdd, 100000); if (retval < 0) { tsp_debug("Regulator vdd set opt failed retval = %d \n", retval); return retval; } retval = regulator_enable(ts->vdd); if (retval < 0) { tsp_debug("Regulator vdd enable failed retval = %d \n", retval); goto err_reg_en_vdd; } if (ts->pdata->i2c_pull_up) { retval = reg_set_optimum_mode_check(ts->vcc_i2c, 100000); if (retval < 0) { tsp_debug("Regulator vcc_i2c set opt failed retval = %d \n", retval); goto err_reg_opt_i2c; } retval = regulator_enable(ts->vcc_i2c); if (retval < 0) { tsp_debug("Regulator vcc_i2c enable failed retval = %d \n", retval); goto err_reg_en_vcc_i2c; } } tsp_debug("ist30xx_ldo_power_on On Done \n"); return 0; err_reg_en_vcc_i2c: reg_set_optimum_mode_check(ts->vdd, 0); err_reg_opt_i2c: regulator_disable(ts->vdd); err_reg_en_vdd: reg_set_optimum_mode_check(ts->vdd, 0); tsp_debug("ist30xx_ldo_power_on err \n"); return retval; power_off: reg_set_optimum_mode_check(ts->vdd, 0); regulator_disable(ts->vdd); if (ts->pdata->i2c_pull_up) { reg_set_optimum_mode_check(ts->vcc_i2c, 0); regulator_disable(ts->vcc_i2c); } tsp_debug("ist30xx_ldo_power_on : Off Done \n"); return 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; }
/** * 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; }
int msm_camera_enable_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 enable) { int i = 0, j = 0, rc = 0; //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__,enable,client->addr); //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 (enable) { for (i = 0; i < num_vreg_seq; i++) { if (vreg_seq) { j = vreg_seq[i]; if (j >= num_vreg) continue; } else j = i; if (IS_ERR(reg_ptr[j])) { pr_err("%s: %s null regulator\n", __func__, cam_vreg[j].reg_name); goto disable_vreg; } //Eric Liu+ MSG2("%s, On, %s, %dms",__func__,get_vreg_name(j),cam_vreg[j].delay); if(j == CAM_VANA_EXT) { gpio_set_value_cansleep(35, 1); //second, l9, 2.8v if (cam_vreg[j].delay > 20) msleep(cam_vreg[j].delay); else if (cam_vreg[j].delay) usleep_range(cam_vreg[j].delay * 1000, (cam_vreg[j].delay * 1000) + 1000); continue; } //Eric Liu- rc = regulator_enable(reg_ptr[j]); if (rc < 0) { pr_err("%s: %s enable failed\n", __func__, cam_vreg[j].reg_name); goto disable_vreg; } if (cam_vreg[j].delay > 20) msleep(cam_vreg[j].delay); else if (cam_vreg[j].delay) usleep_range(cam_vreg[j].delay * 1000, (cam_vreg[j].delay * 1000) + 1000); } } 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; if (IS_ERR(reg_ptr[j])) { pr_warn("%s: %s null regulator, skipping\n", __func__, cam_vreg[j].reg_name); continue; } //Eric Liu+ MSG2("%s, Off, %s, %dms",__func__,get_vreg_name(j),cam_vreg[j].delay); if(j == CAM_VANA_EXT) { gpio_set_value_cansleep(35, 0); //second, l9, 2.8v if (cam_vreg[j].delay > 20) msleep(cam_vreg[j].delay); else if (cam_vreg[j].delay) usleep_range(cam_vreg[j].delay * 1000, (cam_vreg[j].delay * 1000) + 1000); continue; } //Eric Liu- regulator_disable(reg_ptr[j]); if (cam_vreg[j].delay > 20) msleep(cam_vreg[j].delay); else if (cam_vreg[j].delay) usleep_range(cam_vreg[j].delay * 1000, (cam_vreg[j].delay * 1000) + 1000); } } //MSG2("%s-, rc=%d",__func__,rc); return rc; disable_vreg: for (i--; i >= 0; i--) { if (vreg_seq) { j = vreg_seq[i]; if (j >= num_vreg) continue; } else j = i; if (IS_ERR(reg_ptr[j])) { pr_warn("%s: %s null regulator, skipping\n", __func__, cam_vreg[j].reg_name); continue; } regulator_disable(reg_ptr[j]); if (cam_vreg[j].delay > 20) msleep(cam_vreg[j].delay); else if (cam_vreg[j].delay) usleep_range(cam_vreg[j].delay * 1000, (cam_vreg[j].delay * 1000) + 1000); } //MSG2("%s-, rc=%d",__func__,rc); return rc; }
int msm_jpeg_platform_init(struct platform_device *pdev, struct resource **mem, void **base, int *irq, irqreturn_t (*handler) (int, void *), void *context) { int rc = -1; int i = 0; int jpeg_irq; struct resource *jpeg_mem, *jpeg_io, *jpeg_irq_res; void *jpeg_base; struct msm_jpeg_device *pgmn_dev = (struct msm_jpeg_device *) context; pgmn_dev->state = MSM_JPEG_IDLE; jpeg_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!jpeg_mem) { JPEG_PR_ERR("%s: no mem resource?\n", __func__); return -ENODEV; } jpeg_irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!jpeg_irq_res) { JPEG_PR_ERR("no irq resource?\n"); return -ENODEV; } jpeg_irq = jpeg_irq_res->start; JPEG_DBG("%s base address: 0x%x, jpeg irq number: %d\n", __func__, jpeg_mem->start, jpeg_irq); pgmn_dev->jpeg_bus_client = msm_bus_scale_register_client(&msm_jpeg_bus_client_pdata); if (!pgmn_dev->jpeg_bus_client) { JPEG_PR_ERR("%s: Registration Failed!\n", __func__); pgmn_dev->jpeg_bus_client = 0; return -EINVAL; } msm_bus_scale_client_update_request( pgmn_dev->jpeg_bus_client, 1); jpeg_io = request_mem_region(jpeg_mem->start, resource_size(jpeg_mem), pdev->name); if (!jpeg_io) { JPEG_PR_ERR("%s: region already claimed\n", __func__); return -EBUSY; } jpeg_base = ioremap(jpeg_mem->start, resource_size(jpeg_mem)); if (!jpeg_base) { rc = -ENOMEM; JPEG_PR_ERR("%s: ioremap failed\n", __func__); goto fail_remap; } pgmn_dev->jpeg_fs = regulator_get(&pgmn_dev->pdev->dev, "vdd"); rc = regulator_enable(pgmn_dev->jpeg_fs); if (rc) { JPEG_PR_ERR("%s:%d]jpeg regulator get failed\n", __func__, __LINE__); goto fail_fs; } rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev, jpeg_8x_clk_info, pgmn_dev->jpeg_clk, ARRAY_SIZE(jpeg_8x_clk_info), 1); if (rc < 0) { JPEG_PR_ERR("%s: clk failed rc = %d\n", __func__, rc); goto fail_clk; } pgmn_dev->hw_version = readl_relaxed(jpeg_base + JPEG_HW_VERSION); JPEG_DBG_HIGH("%s:%d] jpeg HW version 0x%x", __func__, __LINE__, pgmn_dev->hw_version); pgmn_dev->jpeg_vbif = ioremap(VBIF_BASE_ADDRESS, VBIF_REGION_SIZE); if (!pgmn_dev->jpeg_vbif) { rc = -ENOMEM; JPEG_PR_ERR("%s:%d] ioremap failed\n", __func__, __LINE__); goto fail_vbif; } JPEG_DBG("%s:%d] jpeg_vbif 0x%x", __func__, __LINE__, (uint32_t)pgmn_dev->jpeg_vbif); #ifdef CONFIG_MSM_IOMMU for (i = 0; i < pgmn_dev->iommu_cnt; i++) { rc = iommu_attach_device(pgmn_dev->domain, pgmn_dev->iommu_ctx_arr[i]); if (rc < 0) { rc = -ENODEV; JPEG_PR_ERR("%s: Device attach failed\n", __func__); goto fail_iommu; } JPEG_DBG("%s:%d] dom 0x%x ctx 0x%x", __func__, __LINE__, (uint32_t)pgmn_dev->domain, (uint32_t)pgmn_dev->iommu_ctx_arr[i]); } #endif set_vbif_params(pgmn_dev, pgmn_dev->jpeg_vbif); rc = request_irq(jpeg_irq, handler, IRQF_TRIGGER_RISING, "jpeg", context); if (rc) { JPEG_PR_ERR("%s: request_irq failed, %d\n", __func__, jpeg_irq); goto fail_request_irq; } *mem = jpeg_mem; *base = jpeg_base; *irq = jpeg_irq; pgmn_dev->jpeg_client = msm_ion_client_create(-1, "camera-jpeg"); JPEG_DBG("%s:%d] success\n", __func__, __LINE__); pgmn_dev->state = MSM_JPEG_INIT; return rc; fail_request_irq: #ifdef CONFIG_MSM_IOMMU for (i = 0; i < pgmn_dev->iommu_cnt; i++) { JPEG_PR_ERR("%s:%d] dom 0x%x ctx 0x%x", __func__, __LINE__, (uint32_t)pgmn_dev->domain, (uint32_t)pgmn_dev->iommu_ctx_arr[i]); iommu_detach_device(pgmn_dev->domain, pgmn_dev->iommu_ctx_arr[i]); } #endif fail_iommu: iounmap(pgmn_dev->jpeg_vbif); fail_vbif: msm_cam_clk_enable(&pgmn_dev->pdev->dev, jpeg_8x_clk_info, pgmn_dev->jpeg_clk, ARRAY_SIZE(jpeg_8x_clk_info), 0); fail_clk: rc = regulator_disable(pgmn_dev->jpeg_fs); if (!rc) regulator_put(pgmn_dev->jpeg_fs); else JPEG_PR_ERR("%s:%d] regulator disable failed %d", __func__, __LINE__, rc); pgmn_dev->jpeg_fs = NULL; fail_fs: iounmap(jpeg_base); fail_remap: release_mem_region(jpeg_mem->start, resource_size(jpeg_mem)); JPEG_DBG("%s:%d] fail\n", __func__, __LINE__); return rc; }
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 mt9p012_sensor_power_set(struct device* dev, enum v4l2_power power) { static enum v4l2_power previous_power = V4L2_POWER_OFF; static struct regulator *regulator; switch (power) { case V4L2_POWER_OFF: /* Power Down Sequence */ gpio_free(GPIO_MT9P012_RESET); /* Turn off power */ if (regulator != NULL) { regulator_disable(regulator); regulator_put(regulator); regulator = NULL; } else { sholes_camera_lines_safe_mode(); pr_err("%s: Regulator for vcam is not "\ "initialized\n", __func__); return -EIO; } /* Release pm constraints */ omap_pm_set_min_bus_tput(dev, OCP_INITIATOR_AGENT, 0); sholes_camera_lines_safe_mode(); break; case V4L2_POWER_ON: if (previous_power == V4L2_POWER_OFF) { /* Power Up Sequence */ sholes_camera_lines_func_mode(); /* Set min throughput to: * 2592 x 1944 x 2bpp x 30fps x 3 L3 accesses */ omap_pm_set_min_bus_tput(dev, OCP_INITIATOR_AGENT, 885735); /* Configure pixel clock divider (here?) */ omap_writel(0x2, 0x48004f40); isp_configure_interface(&mt9p012_if_config); /* Request and configure gpio pins */ if (gpio_request(GPIO_MT9P012_RESET, "mt9p012 camera reset") != 0) return -EIO; /* set to output mode */ gpio_direction_output(GPIO_MT9P012_RESET, 0); /* nRESET is active LOW. set HIGH to release reset */ gpio_set_value(GPIO_MT9P012_RESET, 1); /* turn on digital power */ if (regulator != NULL) { pr_warning("%s: Already have "\ "regulator\n", __func__); } else { regulator = regulator_get(NULL, "vcam"); if (IS_ERR(regulator)) { pr_err("%s: Cannot get vcam "\ "regulator, err=%ld\n", __func__, PTR_ERR(regulator)); return PTR_ERR(regulator); } } if (regulator_enable(regulator) != 0) { pr_err("%s: Cannot enable vcam regulator\n", __func__); return -EIO; } } udelay(1000); if (previous_power == V4L2_POWER_OFF) { /* trigger reset */ gpio_direction_output(GPIO_MT9P012_RESET, 0); udelay(1500); /* nRESET is active LOW. set HIGH to release reset */ gpio_set_value(GPIO_MT9P012_RESET, 1); /* give sensor sometime to get out of the reset. * Datasheet says 2400 xclks. At 6 MHz, 400 usec is * enough */ udelay(300); } break; case V4L2_POWER_STANDBY: /* Stand By Sequence */ break; } /* Save powerstate to know what was before calling POWER_ON. */ previous_power = power; return 0; }
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; }