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;
}
