static int prox_regulator_onoff(struct device *dev, bool onoff) { struct regulator* ldo19; struct regulator* lvs1; printk(KERN_ERR "%s %s\n", __func__, (onoff) ? "on" : "off"); ldo19 = devm_regulator_get(dev, "reg_vdd"); if (IS_ERR(ldo19)) { pr_err("%s: cannot get ldo19\n", __func__); return -ENOMEM; } lvs1 = devm_regulator_get(dev, "reg_vio"); if (IS_ERR(lvs1)) { pr_err("%s: cannot get lvs1\n", __func__); return -ENOMEM; } if (onoff) { regulator_enable(ldo19); msleep(5); regulator_enable(lvs1); msleep(5); } else { regulator_disable(ldo19); msleep(5); regulator_disable(lvs1); msleep(5); } devm_regulator_put(ldo19); devm_regulator_put(lvs1); msleep(10); return 0; }
void dsi_panel_deinit(void) { if (!panel_private) return; kfree(panel_private->dsi_panel_tx_buf.start); kfree(panel_private->dsi_panel_rx_buf.start); if (!IS_ERR(panel_private->vddio_vreg)) devm_regulator_put(panel_private->vddio_vreg); if (!IS_ERR(panel_private->vdda_vreg)) devm_regulator_put(panel_private->vdda_vreg); if (panel_private->on_cmds_list) { kfree(panel_private->on_cmds_list->buf); kfree(panel_private->on_cmds_list); } if (panel_private->off_cmds_list) { kfree(panel_private->off_cmds_list->buf); kfree(panel_private->off_cmds_list); } kfree(panel_private->on_cmds); kfree(panel_private->off_cmds); kfree(panel_private); panel_private = NULL; if (bl_led_trigger) { led_trigger_unregister_simple(bl_led_trigger); bl_led_trigger = NULL; } }
static void ak09911c_power_enable(struct device *dev, bool onoff) { struct regulator *ak09911c_vcc, *ak09911c_lvs1; ak09911c_vcc = devm_regulator_get(dev, "ak09911c-i2c-vcc"); if (IS_ERR(ak09911c_vcc)) { pr_err("%s: cannot get ak09911c_vcc\n", __func__); return; } ak09911c_lvs1 = devm_regulator_get(dev, "ak09911c-i2c-lvs1"); if (IS_ERR(ak09911c_lvs1)) { pr_err("%s: cannot get ak09911c_lvs1\n", __func__); devm_regulator_put(ak09911c_vcc); return; } if (onoff) { regulator_enable(ak09911c_vcc); regulator_enable(ak09911c_lvs1); } else { regulator_disable(ak09911c_lvs1); regulator_disable(ak09911c_vcc); } devm_regulator_put(ak09911c_vcc); devm_regulator_put(ak09911c_lvs1); return; }
static int gp2a_regulator_onoff(struct device *dev, bool onoff) { struct regulator *gp2a_vcc, *gp2a_lvs1; gp2a_vcc = devm_regulator_get(dev, "gp2a030a-vcc"); if (IS_ERR(gp2a_vcc)) { pr_err("%s: cannot get gp2a_vcc\n", __func__); return -ENOMEM; } gp2a_lvs1 = devm_regulator_get(dev, "gp2a030a-lvs1"); if (IS_ERR(gp2a_lvs1)) { pr_err("%s: cannot get gp2a_vcc\n", __func__); devm_regulator_put(gp2a_vcc); return -ENOMEM; } if (onoff) { regulator_enable(gp2a_vcc); msleep(5); regulator_enable(gp2a_lvs1); } else { regulator_disable(gp2a_lvs1); msleep(5); regulator_disable(gp2a_vcc); } devm_regulator_put(gp2a_vcc); devm_regulator_put(gp2a_lvs1); msleep(10); return 0; }
static int gp2a_regulator_onoff(struct device *dev, bool onoff) { struct regulator *gp2a_vio; struct regulator *gp2a_vdd; int ret; pr_info("%s %s\n", __func__, (onoff) ? "on" : "off"); gp2a_vdd = devm_regulator_get(dev, "gp2a-vdd"); if (IS_ERR(gp2a_vdd)) { pr_err("[SENSOR]: %s - cannot get gp2a_vdd\n", __func__); return -ENOMEM; } gp2a_vio = devm_regulator_get(dev, "gp2a-vio"); if (IS_ERR(gp2a_vio)) { pr_err("%s: cannot get gp2a_vio\n", __func__); return -ENOMEM; } if (onoff) { ret = regulator_enable(gp2a_vdd); if (ret) { pr_err("%s: enable gp2a_vdd failed, rc=%d\n", __func__, ret); return ret; } ret = regulator_enable(gp2a_vio); if (ret) { pr_err("%s: enable gp2a_vio failed, rc=%d\n", __func__, ret); return ret; } } else { ret = regulator_disable(gp2a_vdd); if (ret) { pr_err("%s: disable gp2a_vdd failed, rc=%d\n", __func__, ret); return ret; } ret = regulator_disable(gp2a_vio); if (ret) { pr_err("%s: disable gp2a_vio failed, rc=%d\n", __func__, ret); return ret; } } devm_regulator_put(gp2a_vdd); devm_regulator_put(gp2a_vio); msleep(20); return 0; }
static int hw_scharger_probe(struct platform_device *pdev) { int ret = 0; struct regulator *ldo = NULL; memset(&hw_scharger_pdata, 0, sizeof(hw_scharger_pdata)); ldo = devm_regulator_get(&pdev->dev, SCHG_BOOST_REGULATOR); if (IS_ERR_OR_NULL(ldo)) { cam_err("%s: Could not get regulator : %s\n", __func__, SCHG_BOOST_REGULATOR); ret = -ENXIO; goto fail; } hw_scharger_pdata.flash_inter_ldo = ldo; /* get flash mode regulator */ ldo = devm_regulator_get(&pdev->dev, SCHG_FLASH_MODE_REGULATOR); if (IS_ERR_OR_NULL(ldo)) { cam_err("%s: Could not get regulator : %s\n", __func__, SCHG_FLASH_MODE_REGULATOR); ret = -ENXIO; goto fail; } hw_scharger_pdata.flash_mode_ldo = ldo; /* get torch mode regulator */ ldo = devm_regulator_get(&pdev->dev, SCHG_TORCH_MODE_REGULATOR); if (IS_ERR_OR_NULL(ldo)) { cam_err("%s: Could not get regulator : %s\n", __func__, SCHG_TORCH_MODE_REGULATOR); ret = -ENXIO; goto fail; } hw_scharger_pdata.torch_mode_ldo = ldo; hw_scharger_ctrl.pdata = &hw_scharger_pdata; platform_set_drvdata(pdev, &hw_scharger_ctrl); return hw_flash_platform_probe(pdev, &hw_scharger_ctrl); fail: if (NULL != hw_scharger_pdata.flash_inter_ldo) { devm_regulator_put(hw_scharger_pdata.flash_inter_ldo); hw_scharger_pdata.flash_inter_ldo = NULL; } if (NULL != hw_scharger_pdata.flash_mode_ldo) { devm_regulator_put(hw_scharger_pdata.flash_mode_ldo); hw_scharger_pdata.flash_mode_ldo = NULL; } return ret; }
static int ak09911c_regulator_onoff(struct device *dev, bool onoff) { struct regulator *vdd; struct regulator *vio; int ret = 0; pr_info("%s %s\n", __func__, (onoff) ? "on" : "off"); vdd = devm_regulator_get(dev, "ak09911c,vdd"); if (IS_ERR(vdd)) { pr_err("%s: cannot get vdd\n", __func__); ret = -ENOMEM; goto err_vdd; } else if (!regulator_get_voltage(vdd)) { ret = regulator_set_voltage(vdd, 2850000, 2850000); } vio = devm_regulator_get(dev, "ak09911c,vio"); if (IS_ERR(vio)) { pr_err("%s: cannot get vio\n", __func__); ret = -ENOMEM; goto err_vio; } else if (!regulator_get_voltage(vio)) { ret = regulator_set_voltage(vio, 1800000, 1800000); } if (onoff) { ret = regulator_enable(vdd); if (ret) pr_err("%s: Failed to enable vdd.\n", __func__); ret = regulator_enable(vio); if (ret) pr_err("%s: Failed to enable vio.\n", __func__); } else { ret = regulator_disable(vdd); if (ret) pr_err("%s: Failed to enable vdd.\n", __func__); ret = regulator_disable(vio); if (ret) pr_err("%s: Failed to enable vio.\n", __func__); } msleep(20); devm_regulator_put(vio); err_vio: devm_regulator_put(vdd); err_vdd: return ret; }
/** * devm_regulator_bulk_get - managed get multiple regulator consumers * * @dev: Device to supply * @num_consumers: Number of consumers to register * @consumers: Configuration of consumers; clients are stored here. * * @return 0 on success, an errno on failure. * * This helper function allows drivers to get several regulator * consumers in one operation with management, the regulators will * automatically be freed when the device is unbound. If any of the * regulators cannot be acquired then any regulators that were * allocated will be freed before returning to the caller. */ int devm_regulator_bulk_get(struct device *dev, int num_consumers, struct regulator_bulk_data *consumers) { int i; int ret; for (i = 0; i < num_consumers; i++) consumers[i].consumer = NULL; for (i = 0; i < num_consumers; i++) { consumers[i].consumer = devm_regulator_get(dev, consumers[i].supply); if (IS_ERR(consumers[i].consumer)) { ret = PTR_ERR(consumers[i].consumer); dev_err(dev, "Failed to get supply '%s': %d\n", consumers[i].supply, ret); consumers[i].consumer = NULL; goto err; } } return 0; err: for (i = 0; i < num_consumers && consumers[i].consumer; i++) devm_regulator_put(consumers[i].consumer); return ret; }
static int hdmi_init_regulator(void) { int r; struct regulator *reg; if (hdmi.vdda_reg != NULL) return 0; reg = devm_regulator_get(&hdmi.pdev->dev, "vdda"); if (IS_ERR(reg)) { DSSERR("can't get VDDA regulator\n"); return PTR_ERR(reg); } r = regulator_set_voltage(reg, 1800000, 1800000); if (r) { devm_regulator_put(reg); DSSWARN("can't set the regulator voltage\n"); return r; } hdmi.vdda_reg = reg; return 0; }
/* initialize chip */ static int lm3630a_chip_init(struct lm3630a_chip *pchip) { int rval = 0; struct lm3630a_platform_data *pdata = pchip->pdata; /* enable vddio power supply */ if (pdata->vddio_name[0] != 0) { pchip->vddio = devm_regulator_get(pchip->dev, pdata->vddio_name); if (IS_ERR(pchip->vddio)) { dev_err(pchip->dev, "Fail to get regulator rc = %ld\n", PTR_ERR(pchip->vddio)); rval = -ENXIO; goto err; } } /* enable chip */ if (gpio_is_valid(pdata->hwen_gpio)) { if (devm_gpio_request(pchip->dev, pdata->hwen_gpio, LM3630A_NAME)) { dev_err(pchip->dev, "gpio %d unavailable\n", pdata->hwen_gpio); rval = -EOPNOTSUPP; goto err; } } lm3630a_chip_enable(pchip); if (pdata->skip_init_config) { dev_info(pchip->dev, "Skip init configuration."); goto end; } usleep_range(1000, 2000); rval = lm3630a_chip_config(pchip); /* set brightness A and B */ rval |= lm3630a_write(pchip, REG_BRT_A, pdata->leda_init_brt); rval |= lm3630a_write(pchip, REG_BRT_B, pdata->ledb_init_brt); if (rval < 0) dev_err(pchip->dev, "i2c failed to access register\n"); end: return rval; err: if (!IS_ERR(pchip->vddio)) devm_regulator_put(pchip->vddio); return rval; }
int mdss_dsi_panel_power_detect(struct platform_device *pdev, int enable) { int ret; static struct regulator *vddio_vreg; if (!vddio_vreg) { vddio_vreg = devm_regulator_get(&pdev->dev, "vddio"); if (IS_ERR(vddio_vreg)) { pr_err("could not get 8941_lvs3, rc = %ld\n", PTR_ERR(vddio_vreg)); return -ENODEV; } } if (enable) { ret = regulator_set_optimum_mode(vddio_vreg, 100000); if (ret < 0) { pr_err("%s: vdd_vreg set regulator mode failed.\n", __func__); return ret; } ret = regulator_enable(vddio_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return ret; } msleep(50); wmb(); } else { ret = regulator_disable(vddio_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return ret; } ret = regulator_set_optimum_mode(vddio_vreg, 100); if (ret < 0) { pr_err("%s: vdd_vreg set regulator mode failed.\n", __func__); return ret; } usleep_range(9000, 10000); devm_regulator_put(vddio_vreg); } return 0; }
static int __devexit ux500_msp_drv_remove(struct platform_device *pdev) { struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(&pdev->dev); snd_soc_unregister_dais(&pdev->dev, ARRAY_SIZE(ux500_msp_dai_drv)); devm_regulator_put(drvdata->reg_vape); prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "ux500_msp_i2s"); clk_put(drvdata->clk); ux500_msp_i2s_cleanup_msp(pdev, drvdata->msp); return 0; }
static int msm_sata_vreg_get_enable_set_vdd(struct device *dev, const char *name, struct regulator **out_vreg, int min_uV, int max_uV, int hpm_uA) { int ret = 0; struct regulator *vreg; vreg = devm_regulator_get(dev, name); if (IS_ERR(vreg)) { ret = PTR_ERR(vreg); dev_err(dev, "Regulator: %s get failed, err=%d\n", name, ret); goto out; } if (regulator_count_voltages(vreg) > 0) { ret = regulator_set_voltage(vreg, min_uV, max_uV); if (ret) { dev_err(dev, "Regulator: %s set voltage failed, err=%d\n", name, ret); goto err; } ret = regulator_set_optimum_mode(vreg, hpm_uA); if (ret < 0) { dev_err(dev, "Regulator: %s set optimum mode(uA_load=%d) failed, err=%d\n", name, hpm_uA, ret); goto err; } else { /* * regulator_set_optimum_mode() can return non zero * value even for success case. */ ret = 0; } } ret = regulator_enable(vreg); if (ret) dev_err(dev, "Regulator: %s enable failed, err=%d\n", name, ret); err: if (!ret) *out_vreg = vreg; else devm_regulator_put(vreg); out: return ret; }
static void free_resources(void *data, async_cookie_t cookie) { struct inrush_driver_data *drv_data = data; struct subsystem *subsys; int i; gdsc_allow_clear_retention(drv_data->vreg); devm_regulator_put(drv_data->vreg); for (i = 0; i < drv_data->subsys_count; i++) { subsys = &drv_data->subsystems[i]; subsys_notif_unregister_notifier(subsys->notif_handle, &subsys->nb); } kfree(drv_data); pr_info("inrush-current-mitigation driver exited\n"); }
static int msm_sata_vreg_put_disable(struct device *dev, struct regulator *reg, const char *name, int max_uV) { int ret; if (!reg) return 0; ret = regulator_disable(reg); if (ret) { dev_err(dev, "Regulator: %s disable failed err=%d\n", name, ret); goto err; } if (regulator_count_voltages(reg) > 0) { ret = regulator_set_voltage(reg, 0, max_uV); if (ret < 0) { dev_err(dev, "Regulator: %s set voltage to 0 failed, err=%d\n", name, ret); goto err; } ret = regulator_set_optimum_mode(reg, 0); if (ret < 0) { dev_err(dev, "Regulator: %s set optimum mode(uA_load = 0) failed, err=%d\n", name, ret); goto err; } else { /* * regulator_set_optimum_mode() can return non zero * value even for success case. */ ret = 0; } } err: devm_regulator_put(reg); return ret; }
int ar1335_power_down( hwsensor_intf_t* si) { int ret = 0; int i, num_consumers; sensor_t* sensor = NULL; struct regulator_bulk_data *consumers; sensor = I2S(si); ret = hw_sensor_power_down(sensor); consumers = sensor->board_info->ldo; num_consumers = sensor->board_info->ldo_num; for (i = 0; i < num_consumers && consumers[i].consumer; i++) { devm_regulator_put(consumers[i].consumer); consumers[i].consumer = NULL; } return ret; }
static int bma254_regulator_onoff(struct device *dev, bool onoff) { struct regulator *bma_vdd; pr_info("%s %s\n", __func__, (onoff) ? "on" : "off"); bma_vdd = devm_regulator_get(dev, "bma254-vdd"); if (IS_ERR(bma_vdd)) { pr_err("%s: cannot get bma_vdd\n", __func__); return -ENOMEM; } if (onoff) { regulator_enable(bma_vdd); } else { regulator_disable(bma_vdd); } devm_regulator_put(bma_vdd); msleep(10); return 0; }
static int prox_led_onoff(struct cm36686_data *cm36686, bool onoff) { #if !defined(CONFIG_SEC_ATLANTIC3G_COMMON) struct regulator *leda; leda = devm_regulator_get(&cm36686->i2c_client->dev, "reg_leda"); if (IS_ERR(leda)) { pr_err("%s: regulator pointer null l23 leda fail \n",__func__); return -ENOMEM; } if (onoff) { regulator_enable(leda); } else { regulator_disable(leda); } devm_regulator_put(leda); msleep(10); return 0; #else return 0; #endif }
void mdss_dsi_panel_power_detect(struct platform_device *pdev, int enable) { #ifdef CONFIG_MACH_SONY_RHINE int ret; static struct regulator *vdd_vreg; pr_debug("%s: enable=%d\n", __func__, enable); if (!vdd_vreg) { vdd_vreg = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(vdd_vreg)) { pr_err("could not get 8941_lvs3, rc = %ld\n", PTR_ERR(vdd_vreg)); return; } } if (enable) { ret = regulator_set_optimum_mode(vdd_vreg, 100000); if (ret < 0) { pr_err("%s: vdd_vreg set regulator mode failed.\n", __func__); return; } ret = regulator_enable(vdd_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return; } msleep(50); wmb(); } else { ret = regulator_disable(vdd_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return; } ret = regulator_set_optimum_mode(vdd_vreg, 100); if (ret < 0) { pr_err("%s: vdd_vreg set regulator mode failed.\n", __func__); return; } msleep(20); devm_regulator_put(vdd_vreg); } #endif /* CONFIG_MACH_SONY_RHINE */ #ifdef CONFIG_MACH_SONY_YUKON int ret; static struct regulator *vddio_vreg; if (!vddio_vreg) { vddio_vreg = devm_regulator_get(&pdev->dev, "vddio"); if (IS_ERR(vddio_vreg)) { pr_err("could not get 8941_lvs3, rc = %ld\n", PTR_ERR(vddio_vreg)); return; } } if (enable) { ret = regulator_set_optimum_mode(vddio_vreg, 100000); if (ret < 0) { pr_err("%s: vdd_vreg set regulator mode failed.\n", __func__); return; } ret = regulator_enable(vddio_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return; } msleep(50); wmb(); } else { ret = regulator_disable(vddio_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return; } ret = regulator_set_optimum_mode(vddio_vreg, 100); if (ret < 0) { pr_err("%s: vdd_vreg set regulator mode failed.\n", __func__); return; } usleep_range(9000, 10000); devm_regulator_put(vddio_vreg); } #endif }
static int ux500_msp_drv_probe(struct platform_device *pdev) { struct ux500_msp_i2s_drvdata *drvdata; int ret = 0; dev_dbg(&pdev->dev, "%s: Enter (pdev->name = %s).\n", __func__, pdev->name); drvdata = devm_kzalloc(&pdev->dev, sizeof(struct ux500_msp_i2s_drvdata), GFP_KERNEL); if (!drvdata) return -ENOMEM; drvdata->fmt = 0; drvdata->slots = 1; drvdata->tx_mask = 0x01; drvdata->rx_mask = 0x01; drvdata->slot_width = 16; drvdata->master_clk = MSP_INPUT_FREQ_APB; drvdata->reg_vape = devm_regulator_get(&pdev->dev, "v-ape"); if (IS_ERR(drvdata->reg_vape)) { ret = (int)PTR_ERR(drvdata->reg_vape); dev_err(&pdev->dev, "%s: ERROR: Failed to get Vape supply (%d)!\n", __func__, ret); return ret; } prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, (char *)pdev->name, 50); drvdata->pclk = clk_get(&pdev->dev, "apb_pclk"); if (IS_ERR(drvdata->pclk)) { ret = (int)PTR_ERR(drvdata->pclk); dev_err(&pdev->dev, "%s: ERROR: clk_get of pclk failed (%d)!\n", __func__, ret); goto err_pclk; } drvdata->clk = clk_get(&pdev->dev, NULL); if (IS_ERR(drvdata->clk)) { ret = (int)PTR_ERR(drvdata->clk); dev_err(&pdev->dev, "%s: ERROR: clk_get failed (%d)!\n", __func__, ret); goto err_clk; } ret = ux500_msp_i2s_init_msp(pdev, &drvdata->msp, pdev->dev.platform_data); if (!drvdata->msp) { dev_err(&pdev->dev, "%s: ERROR: Failed to init MSP-struct (%d)!", __func__, ret); goto err_init_msp; } dev_set_drvdata(&pdev->dev, drvdata); ret = snd_soc_register_component(&pdev->dev, &ux500_msp_component, &ux500_msp_dai_drv[drvdata->msp->id], 1); if (ret < 0) { dev_err(&pdev->dev, "Error: %s: Failed to register MSP%d!\n", __func__, drvdata->msp->id); goto err_init_msp; } ret = ux500_pcm_register_platform(pdev); if (ret < 0) { dev_err(&pdev->dev, "Error: %s: Failed to register PCM platform device!\n", __func__); goto err_reg_plat; } return 0; err_reg_plat: snd_soc_unregister_component(&pdev->dev); err_init_msp: clk_put(drvdata->clk); err_clk: clk_put(drvdata->pclk); err_pclk: devm_regulator_put(drvdata->reg_vape); return ret; }
int vcc_cmds_tx(struct platform_device *pdev, struct vcc_desc *cmds, int cnt) { int ret = 0; struct vcc_desc *cm = NULL; int i = 0; cm = cmds; for (i = 0; i < cnt; i++) { if ((cm == NULL) || (cm->id == NULL)) { HISI_FB_ERR("cm or cm->id is null! index=%d\n", i); ret = -1; goto error; } if (cm->dtype == DTYPE_VCC_GET) { BUG_ON(pdev == NULL); *(cm->regulator) = devm_regulator_get(&pdev->dev, cm->id); if (IS_ERR(*(cm->regulator))) { HISI_FB_ERR("failed to get %s regulator!\n", cm->id); ret = -1; goto error; } } else if (cm->dtype == DTYPE_VCC_PUT) { if (!IS_ERR(*(cm->regulator))) { devm_regulator_put(*(cm->regulator)); } } else if (cm->dtype == DTYPE_VCC_ENABLE) { if (!IS_ERR(*(cm->regulator))) { if (regulator_enable(*(cm->regulator)) != 0) { HISI_FB_ERR("failed to enable %s regulator!\n", cm->id); ret = -1; goto error; } } mdelay(3); } else if (cm->dtype == DTYPE_VCC_DISABLE) { if (!IS_ERR(*(cm->regulator))) { if (regulator_disable(*(cm->regulator)) != 0) { HISI_FB_ERR("failed to disable %s regulator!\n", cm->id); ret = -1; goto error; } } mdelay(3); } else if (cm->dtype == DTYPE_VCC_SET_VOLTAGE) { if (!IS_ERR(*(cm->regulator))) { if (regulator_set_voltage(*(cm->regulator), cm->min_uV, cm->max_uV) != 0) { HISI_FB_ERR("failed to set %s regulator voltage!\n", cm->id); ret = -1; goto error; } } } else { HISI_FB_ERR("dtype=%x NOT supported\n", cm->dtype); ret = -1; goto error; } cm++; } return 0; error: return ret; }