static int max77650_regulator_set_voltage_sel(struct regulator_dev *rdev,
unsigned int sel)
{
struct max77650_regulator_desc *rdesc = rdev_get_drvdata(rdev);
int rv = 0, curr, diff;
bool ascending;
/*
* If the regulator is disabled, we can program the desired
* voltage right away.
*/
if (!max77650_regulator_is_enabled(rdev)) {
if (rdesc == &max77651_SBB1_desc)
return regulator_set_voltage_sel_pickable_regmap(rdev,
sel);
else
return regulator_set_voltage_sel_regmap(rdev, sel);
}
/*
* Otherwise we need to manually ramp the output voltage up/down
* one step at a time.
*/
if (rdesc == &max77651_SBB1_desc)
curr = regulator_get_voltage_sel_pickable_regmap(rdev);
else
curr = regulator_get_voltage_sel_regmap(rdev);
if (curr < 0)
return curr;
diff = curr - sel;
if (diff == 0)
return 0; /* Already there. */
else if (diff > 0)
ascending = false;
else
ascending = true;
/*
* Make sure we'll get to the right voltage and break the loop even if
* the selector equals 0.
*/
for (ascending ? curr++ : curr--;; ascending ? curr++ : curr--) {
if (rdesc == &max77651_SBB1_desc)
rv = regulator_set_voltage_sel_pickable_regmap(rdev,
curr);
else
rv = regulator_set_voltage_sel_regmap(rdev, curr);
if (rv)
return rv;
if (curr == sel)
break;
}
return 0;
}
static int pm800_set_voltage(struct regulator_dev *rdev,
int min_uv, int max_uv, unsigned *selector)
{
struct pm800_regulator_info *info = rdev_get_drvdata(rdev);
int ret, old_selector = -1, best_val = 0;
if (!info)
return -EINVAL;
if (info->desc.id == PM800_ID_VOUTSW)
return 0;
ret = regulator_map_voltage_iterate(rdev, min_uv, max_uv);
if (ret >= 0) {
best_val = rdev->desc->ops->list_voltage(rdev, ret);
if (min_uv <= best_val && max_uv >= best_val) {
*selector = ret;
if (old_selector == *selector)
ret = 0;
else
ret = regulator_set_voltage_sel_regmap(rdev, ret);
} else {
ret = -EINVAL;
}
} else {
ret = -EINVAL;
}
return ret;
}
/* Bucks 1 to 4 support DVS. PWM mode is used when voltage is changed.
* Bucks 5 to 8 and LDOs can use PFM and must be disabled when voltage
* is changed. Hence we return -EBUSY for these if voltage is changed
* when BUCK/LDO is enabled.
*/
static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
unsigned int sel)
{
if (regulator_is_enabled_regmap(rdev))
return -EBUSY;
return regulator_set_voltage_sel_regmap(rdev, sel);
}
static int anatop_regmap_set_voltage_sel(struct regulator_dev *reg,
unsigned selector)
{
struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
if (!anatop_reg->control_reg)
return -ENOTSUPP;
return regulator_set_voltage_sel_regmap(reg, selector);
}
static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
unsigned selector)
{
struct tps_pmic *tps = rdev_get_drvdata(dev);
int dcdc = rdev_get_id(dev);
if (dcdc != tps->core_regulator)
return -EINVAL;
return regulator_set_voltage_sel_regmap(dev, selector);
}
static int ltc3676_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
{
struct ltc3676 *ltc3676 = rdev_get_drvdata(rdev);
struct device *dev = ltc3676->dev;
int ret, dcdc = rdev_get_id(rdev);
dev_dbg(dev, "%s id=%d selector=%d\n", __func__, dcdc, selector);
ret = regmap_update_bits(ltc3676->regmap, rdev->desc->vsel_reg + 1,
LTC3676_DVBxB_PGOOD_MASK,
LTC3676_DVBxB_PGOOD_MASK);
if (ret)
return ret;
return regulator_set_voltage_sel_regmap(rdev, selector);
}
static int arizona_ldo1_hc_set_voltage_sel(struct regulator_dev *rdev,
unsigned sel)
{
struct regmap *regmap = rdev_get_regmap(rdev);
unsigned int val;
int ret;
if (sel == rdev->desc->n_voltages - 1)
val = ARIZONA_LDO1_HI_PWR;
else
val = 0;
ret = regmap_update_bits(regmap, ARIZONA_LDO1_CONTROL_2,
ARIZONA_LDO1_HI_PWR, val);
if (ret != 0)
return ret;
if (val)
return 0;
return regulator_set_voltage_sel_regmap(rdev, sel);
}
static int pm800_set_voltage(struct regulator_dev *rdev,
int min_uv, int max_uv, unsigned *selector)
{
struct pm800_regulator_info *info = rdev_get_drvdata(rdev);
struct pm800_regulator_volt_range *range;
int i, best_index = -1;
if (info->volt == NULL)
return -EINVAL;
if (info->desc.id == PM800_ID_VOUTSW)
return 0;
/*
* Ranges are sorted in ascending order. So if we found a best_uv
* in this range, we can break out.
*/
for (i = 0; i < info->ranges; i++) {
range = &info->volt[i];
if (min_uv <= range->max_uv && max_uv >= range->min_uv) {
if (min_uv <= range->min_uv)
best_index = 0;
else
best_index = (min_uv - range->min_uv +
range->step_uv - 1) / range->step_uv;
break;
}
}
if (best_index == -1)
return -EINVAL;
*selector = best_index + range->min_val;
return regulator_set_voltage_sel_regmap(rdev, *selector);
}
