Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-12-25 04:23:46 +00:00
Code Issues Projects Releases Packages Wiki Activity
u-boot/drivers/power/regulator/tps65910_regulator.c
Tom Rini 83d290c56f SPDX: Convert all of our single license tags to Linux Kernel style 
When U-Boot started using SPDX tags we were among the early adopters and
there weren't a lot of other examples to borrow from.  So we picked the
area of the file that usually had a full license text and replaced it
with an appropriate SPDX-License-Identifier: entry.  Since then, the
Linux Kernel has adopted SPDX tags and they place it as the very first
line in a file (except where shebangs are used, then it's second line)
and with slightly different comment styles than us.

In part due to community overlap, in part due to better tag visibility
and in part for other minor reasons, switch over to that style.

This commit changes all instances where we have a single declared
license in the tag as both the before and after are identical in tag
contents.  There's also a few places where I found we did not have a tag
and have introduced one.

Signed-off-by: Tom Rini <trini@konsulko.com>
2018-05-07 09:34:12 -04:00

458 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 <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_platdata(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_platdata(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_platdata(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_platdata(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_platdata(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_platdata(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_platdata(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_platdata *uc_pdata;
struct tps65910_regulator_pdata *pdata = dev_get_platdata(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_platdata(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_platdata(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_platdata(dev);
vout = (pdata->supply >= 3000000) ? 5000000 : 0;
return vout;
}
static int tps65910_regulator_ofdata_to_platdata(struct udevice *dev)
{
struct udevice *supply;
int ret;
const char *supply_name;
struct tps65910_regulator_pdata *pdata = dev_get_platdata(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,
.platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
.ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
};
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,
.platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
.ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
};
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,
.platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
.ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
};
Reference in a new issue View git blame Copy permalink