Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-12-21 02:33:07 +00:00
Code Issues Projects Releases Packages Wiki Activity
u-boot/drivers/power/regulator/tps65910_regulator.c
Simon Glass d1998a9fde dm: treewide: Rename ofdata_to_platdata() to of_to_plat() 
This name is far too long. Rename it to remove the 'data' bits. This makes
it consistent with the platdata->plat rename.

Signed-off-by: Simon Glass <sjg@chromium.org>
2020-12-13 16:51:09 -07:00

459 lines
12 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) EETS GmbH, 2017, Felix Brack <f.brack@eets.ch>
*/
#include <common.h>
#include <dm.h>
#include <log.h>
#include <power/pmic.h>
#include <power/regulator.h>
#include <power/tps65910_pmic.h>
#define VOUT_CHOICE_COUNT 4
/*
* struct regulator_props - Properties of a LDO and VIO SMPS regulator
*
* All of these regulators allow setting one out of four output voltages.
* These output voltages are only achievable when supplying the regulator
* with a minimum input voltage.
*
* @vin_min[]: minimum supply input voltage in uV required to achieve the
* corresponding vout[] voltage
* @vout[]: regulator output voltage in uV
* @reg: I2C register used to set regulator voltage
*/
struct regulator_props {
int vin_min[VOUT_CHOICE_COUNT];
int vout[VOUT_CHOICE_COUNT];
int reg;
};
static const struct regulator_props ldo_props_vdig1 = {
.vin_min = { 1700000, 2100000, 2700000, 3200000 },
.vout = { 1200000, 1500000, 1800000, 2700000 },
.reg = TPS65910_REG_VDIG1
};
static const struct regulator_props ldo_props_vdig2 = {
.vin_min = { 1700000, 1700000, 1700000, 2700000 },
.vout = { 1000000, 1100000, 1200000, 1800000 },
.reg = TPS65910_REG_VDIG2
};
static const struct regulator_props ldo_props_vpll = {
.vin_min = { 2700000, 2700000, 2700000, 3000000 },
.vout = { 1000000, 1100000, 1800000, 2500000 },
.reg = TPS65910_REG_VPLL
};
static const struct regulator_props ldo_props_vdac = {
.vin_min = { 2700000, 3000000, 3200000, 3200000 },
.vout = { 1800000, 2600000, 2800000, 2850000 },
.reg = TPS65910_REG_VDAC
};
static const struct regulator_props ldo_props_vaux1 = {
.vin_min = { 2700000, 3200000, 3200000, 3200000 },
.vout = { 1800000, 2500000, 2800000, 2850000 },
.reg = TPS65910_REG_VAUX1
};
static const struct regulator_props ldo_props_vaux2 = {
.vin_min = { 2700000, 3200000, 3200000, 3600000 },
.vout = { 1800000, 2800000, 2900000, 3300000 },
.reg = TPS65910_REG_VAUX2
};
static const struct regulator_props ldo_props_vaux33 = {
.vin_min = { 2700000, 2700000, 3200000, 3600000 },
.vout = { 1800000, 2000000, 2800000, 3300000 },
.reg = TPS65910_REG_VAUX33
};
static const struct regulator_props ldo_props_vmmc = {
.vin_min = { 2700000, 3200000, 3200000, 3600000 },
.vout = { 1800000, 2800000, 3000000, 3300000 },
.reg = TPS65910_REG_VMMC
};
static const struct regulator_props smps_props_vio = {
.vin_min = { 3200000, 3200000, 4000000, 4400000 },
.vout = { 1500000, 1800000, 2500000, 3300000 },
.reg = TPS65910_REG_VIO
};
/* lookup table of control registers indexed by regulator unit number */
static const int ctrl_regs[] = {
TPS65910_REG_VRTC,
TPS65910_REG_VIO,
TPS65910_REG_VDD1,
TPS65910_REG_VDD2,
TPS65910_REG_VDD3,
TPS65910_REG_VDIG1,
TPS65910_REG_VDIG2,
TPS65910_REG_VPLL,
TPS65910_REG_VDAC,
TPS65910_REG_VAUX1,
TPS65910_REG_VAUX2,
TPS65910_REG_VAUX33,
TPS65910_REG_VMMC
};
/* supply names as used in DT */
static const char * const supply_names[] = {
"vccio-supply",
"vcc1-supply",
"vcc2-supply",
"vcc3-supply",
"vcc4-supply",
"vcc5-supply",
"vcc6-supply",
"vcc7-supply"
};
/* lookup table of regulator supplies indexed by regulator unit number */
static const int regulator_supplies[] = {
TPS65910_SUPPLY_VCC7,
TPS65910_SUPPLY_VCCIO,
TPS65910_SUPPLY_VCC1,
TPS65910_SUPPLY_VCC2,
TPS65910_SUPPLY_VCC7,
TPS65910_SUPPLY_VCC6,
TPS65910_SUPPLY_VCC6,
TPS65910_SUPPLY_VCC5,
TPS65910_SUPPLY_VCC5,
TPS65910_SUPPLY_VCC4,
TPS65910_SUPPLY_VCC4,
TPS65910_SUPPLY_VCC3,
TPS65910_SUPPLY_VCC3
};
static int get_ctrl_reg_from_unit_addr(const uint unit_addr)
{
if (unit_addr < ARRAY_SIZE(ctrl_regs))
return ctrl_regs[unit_addr];
return -ENXIO;
}
static int tps65910_regulator_get_value(struct udevice *dev,
const struct regulator_props *rgp)
{
int sel, val, vout;
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
int vin = pdata->supply;
val = pmic_reg_read(dev->parent, rgp->reg);
if (val < 0)
return val;
sel = (val & TPS65910_SEL_MASK) >> 2;
vout = (vin >= *(rgp->vin_min + sel)) ? *(rgp->vout + sel) : 0;
vout = ((val & TPS65910_SUPPLY_STATE_MASK) == 1) ? vout : 0;
return vout;
}
static int tps65910_ldo_get_value(struct udevice *dev)
{
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
int vin;
if (!pdata)
return 0;
vin = pdata->supply;
switch (pdata->unit) {
case TPS65910_UNIT_VRTC:
/* VRTC is fixed and can't be turned off */
return (vin >= 2500000) ? 1830000 : 0;
case TPS65910_UNIT_VDIG1:
return tps65910_regulator_get_value(dev, &ldo_props_vdig1);
case TPS65910_UNIT_VDIG2:
return tps65910_regulator_get_value(dev, &ldo_props_vdig2);
case TPS65910_UNIT_VPLL:
return tps65910_regulator_get_value(dev, &ldo_props_vpll);
case TPS65910_UNIT_VDAC:
return tps65910_regulator_get_value(dev, &ldo_props_vdac);
case TPS65910_UNIT_VAUX1:
return tps65910_regulator_get_value(dev, &ldo_props_vaux1);
case TPS65910_UNIT_VAUX2:
return tps65910_regulator_get_value(dev, &ldo_props_vaux2);
case TPS65910_UNIT_VAUX33:
return tps65910_regulator_get_value(dev, &ldo_props_vaux33);
case TPS65910_UNIT_VMMC:
return tps65910_regulator_get_value(dev, &ldo_props_vmmc);
default:
return 0;
}
}
static int tps65910_regulator_set_value(struct udevice *dev,
const struct regulator_props *ldo,
int uV)
{
int val;
int sel = 0;
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
do {
/* we only allow exact voltage matches */
if (uV == *(ldo->vout + sel))
break;
} while (++sel < VOUT_CHOICE_COUNT);
if (sel == VOUT_CHOICE_COUNT)
return -EINVAL;
if (pdata->supply < *(ldo->vin_min + sel))
return -EINVAL;
val = pmic_reg_read(dev->parent, ldo->reg);
if (val < 0)
return val;
val &= ~TPS65910_SEL_MASK;
val |= sel << 2;
return pmic_reg_write(dev->parent, ldo->reg, val);
}
static int tps65910_ldo_set_value(struct udevice *dev, int uV)
{
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
int vin = pdata->supply;
switch (pdata->unit) {
case TPS65910_UNIT_VRTC:
/* VRTC is fixed to 1.83V and can't be turned off */
if (vin < 2500000)
return -EINVAL;
return 0;
case TPS65910_UNIT_VDIG1:
return tps65910_regulator_set_value(dev, &ldo_props_vdig1, uV);
case TPS65910_UNIT_VDIG2:
return tps65910_regulator_set_value(dev, &ldo_props_vdig2, uV);
case TPS65910_UNIT_VPLL:
return tps65910_regulator_set_value(dev, &ldo_props_vpll, uV);
case TPS65910_UNIT_VDAC:
return tps65910_regulator_set_value(dev, &ldo_props_vdac, uV);
case TPS65910_UNIT_VAUX1:
return tps65910_regulator_set_value(dev, &ldo_props_vaux1, uV);
case TPS65910_UNIT_VAUX2:
return tps65910_regulator_set_value(dev, &ldo_props_vaux2, uV);
case TPS65910_UNIT_VAUX33:
return tps65910_regulator_set_value(dev, &ldo_props_vaux33, uV);
case TPS65910_UNIT_VMMC:
return tps65910_regulator_set_value(dev, &ldo_props_vmmc, uV);
default:
return 0;
}
}
static int tps65910_get_enable(struct udevice *dev)
{
int reg, val;
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
reg = get_ctrl_reg_from_unit_addr(pdata->unit);
if (reg < 0)
return reg;
val = pmic_reg_read(dev->parent, reg);
if (val < 0)
return val;
/* bits 1:0 of regulator control register define state */
return ((val & TPS65910_SUPPLY_STATE_MASK) == 1);
}
static int tps65910_set_enable(struct udevice *dev, bool enable)
{
int reg;
uint clr, set;
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
reg = get_ctrl_reg_from_unit_addr(pdata->unit);
if (reg < 0)
return reg;
if (enable) {
clr = TPS65910_SUPPLY_STATE_MASK & ~TPS65910_SUPPLY_STATE_ON;
set = TPS65910_SUPPLY_STATE_MASK & TPS65910_SUPPLY_STATE_ON;
} else {
clr = TPS65910_SUPPLY_STATE_MASK & ~TPS65910_SUPPLY_STATE_OFF;
set = TPS65910_SUPPLY_STATE_MASK & TPS65910_SUPPLY_STATE_OFF;
}
return pmic_clrsetbits(dev->parent, reg, clr, set);
}
static int buck_get_vdd1_vdd2_value(struct udevice *dev, int reg_vdd)
{
int gain;
int val = pmic_reg_read(dev, reg_vdd);
if (val < 0)
return val;
gain = (val & TPS65910_GAIN_SEL_MASK) >> 6;
gain = (gain == 0) ? 1 : gain;
val = pmic_reg_read(dev, reg_vdd + 1);
if (val < 0)
return val;
if (val & TPS65910_VDD_SR_MASK)
/* use smart reflex value instead */
val = pmic_reg_read(dev, reg_vdd + 2);
if (val < 0)
return val;
return (562500 + (val & TPS65910_VDD_SEL_MASK) * 12500) * gain;
}
static int tps65910_buck_get_value(struct udevice *dev)
{
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
switch (pdata->unit) {
case TPS65910_UNIT_VIO:
return tps65910_regulator_get_value(dev, &smps_props_vio);
case TPS65910_UNIT_VDD1:
return buck_get_vdd1_vdd2_value(dev->parent, TPS65910_REG_VDD1);
case TPS65910_UNIT_VDD2:
return buck_get_vdd1_vdd2_value(dev->parent, TPS65910_REG_VDD2);
default:
return 0;
}
}
static int buck_set_vdd1_vdd2_value(struct udevice *dev, int uV)
{
int ret, reg_vdd, gain;
int val;
struct dm_regulator_uclass_plat *uc_pdata;
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
switch (pdata->unit) {
case TPS65910_UNIT_VDD1:
reg_vdd = TPS65910_REG_VDD1;
break;
case TPS65910_UNIT_VDD2:
reg_vdd = TPS65910_REG_VDD2;
break;
default:
return -EINVAL;
}
uc_pdata = dev_get_uclass_plat(dev);
/* check setpoint is within limits */
if (uV < uc_pdata->min_uV) {
pr_err("voltage %duV for %s too low\n", uV, dev->name);
return -EINVAL;
}
if (uV > uc_pdata->max_uV) {
pr_err("voltage %duV for %s too high\n", uV, dev->name);
return -EINVAL;
}
val = pmic_reg_read(dev->parent, reg_vdd);
if (val < 0)
return val;
gain = (val & TPS65910_GAIN_SEL_MASK) >> 6;
gain = (gain == 0) ? 1 : gain;
val = ((uV / gain) - 562500) / 12500;
if (val < TPS65910_VDD_SEL_MIN || val > TPS65910_VDD_SEL_MAX)
/*
* Neither do we change the gain, nor do we allow shutdown or
* any approximate value (for now)
*/
return -EPERM;
val &= TPS65910_VDD_SEL_MASK;
ret = pmic_reg_write(dev->parent, reg_vdd + 1, val);
if (ret)
return ret;
return 0;
}
static int tps65910_buck_set_value(struct udevice *dev, int uV)
{
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
if (pdata->unit == TPS65910_UNIT_VIO)
return tps65910_regulator_set_value(dev, &smps_props_vio, uV);
return buck_set_vdd1_vdd2_value(dev, uV);
}
static int tps65910_boost_get_value(struct udevice *dev)
{
int vout;
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
vout = (pdata->supply >= 3000000) ? 5000000 : 0;
return vout;
}
static int tps65910_regulator_of_to_plat(struct udevice *dev)
{
struct udevice *supply;
int ret;
const char *supply_name;
struct tps65910_regulator_pdata *pdata = dev_get_plat(dev);
pdata->unit = dev_get_driver_data(dev);
if (pdata->unit > TPS65910_UNIT_VMMC)
return -EINVAL;
supply_name = supply_names[regulator_supplies[pdata->unit]];
debug("Looking up supply power %s\n", supply_name);
ret = device_get_supply_regulator(dev->parent, supply_name, &supply);
if (ret) {
debug(" missing supply power %s\n", supply_name);
return ret;
}
pdata->supply = regulator_get_value(supply);
if (pdata->supply < 0) {
debug(" invalid supply voltage for regulator %s\n",
supply->name);
return -EINVAL;
}
return 0;
}
static const struct dm_regulator_ops tps65910_boost_ops = {
.get_value = tps65910_boost_get_value,
.get_enable = tps65910_get_enable,
.set_enable = tps65910_set_enable,
};
U_BOOT_DRIVER(tps65910_boost) = {
.name = TPS65910_BOOST_DRIVER,
.id = UCLASS_REGULATOR,
.ops = &tps65910_boost_ops,
.plat_auto = sizeof(struct tps65910_regulator_pdata),
.of_to_plat = tps65910_regulator_of_to_plat,
};
static const struct dm_regulator_ops tps65910_buck_ops = {
.get_value = tps65910_buck_get_value,
.set_value = tps65910_buck_set_value,
.get_enable = tps65910_get_enable,
.set_enable = tps65910_set_enable,
};
U_BOOT_DRIVER(tps65910_buck) = {
.name = TPS65910_BUCK_DRIVER,
.id = UCLASS_REGULATOR,
.ops = &tps65910_buck_ops,
.plat_auto = sizeof(struct tps65910_regulator_pdata),
.of_to_plat = tps65910_regulator_of_to_plat,
};
static const struct dm_regulator_ops tps65910_ldo_ops = {
.get_value = tps65910_ldo_get_value,
.set_value = tps65910_ldo_set_value,
.get_enable = tps65910_get_enable,
.set_enable = tps65910_set_enable,
};
U_BOOT_DRIVER(tps65910_ldo) = {
.name = TPS65910_LDO_DRIVER,
.id = UCLASS_REGULATOR,
.ops = &tps65910_ldo_ops,
.plat_auto = sizeof(struct tps65910_regulator_pdata),
.of_to_plat = tps65910_regulator_of_to_plat,
};
Reference in a new issue View git blame Copy permalink