[U-Boot] [PATCH v3 2/8] power: regulator: rk8xx: update the driver for rk808 and rk818
Kever Yang
kever.yang at rock-chips.com
Thu Sep 19 08:36:31 UTC 2019
On 2019/9/19 下午4:08, Elaine Zhang wrote:
> In order to adapt the following pmics, make the interface more compatible.
> Support buck and ldo suspend voltage setting and getting.
> Supprot buck and ldo suspend enable/disable setting and getting.
>
> Signed-off-by: Elaine Zhang <zhangqing at rock-chips.com>
Reviewed-by: Kever Yang<kever.yang at rock-chips.com>
Thanks,
- Kever
> ---
> drivers/power/regulator/rk8xx.c | 547 ++++++++++++++++++++++++++++++++++------
> 1 file changed, 465 insertions(+), 82 deletions(-)
>
> diff --git a/drivers/power/regulator/rk8xx.c b/drivers/power/regulator/rk8xx.c
> index aa4f3a161c47..ef83f66c8b6e 100644
> --- a/drivers/power/regulator/rk8xx.c
> +++ b/drivers/power/regulator/rk8xx.c
> @@ -19,6 +19,9 @@
> #define ENABLE_DRIVER
> #endif
>
> +/* Not used or exisit register and configure */
> +#define NA -1
> +
> /* Field Definitions */
> #define RK808_BUCK_VSEL_MASK 0x3f
> #define RK808_BUCK4_VSEL_MASK 0xf
> @@ -32,49 +35,61 @@
> #define RK818_USB_ILIM_SEL_MASK 0x0f
> #define RK818_USB_CHG_SD_VSEL_MASK 0x70
>
> +/*
> + * Ramp delay
> + */
> +#define RK808_RAMP_RATE_OFFSET 3
> +#define RK808_RAMP_RATE_MASK (3 << RK808_RAMP_RATE_OFFSET)
> +#define RK808_RAMP_RATE_2MV_PER_US (0 << RK808_RAMP_RATE_OFFSET)
> +#define RK808_RAMP_RATE_4MV_PER_US (1 << RK808_RAMP_RATE_OFFSET)
> +#define RK808_RAMP_RATE_6MV_PER_US (2 << RK808_RAMP_RATE_OFFSET)
> +#define RK808_RAMP_RATE_10MV_PER_US (3 << RK808_RAMP_RATE_OFFSET)
>
> struct rk8xx_reg_info {
> uint min_uv;
> uint step_uv;
> - s8 vsel_reg;
> + u8 vsel_reg;
> + u8 vsel_sleep_reg;
> + u8 config_reg;
> u8 vsel_mask;
> + u8 min_sel;
> };
>
> static const struct rk8xx_reg_info rk808_buck[] = {
> - { 712500, 12500, REG_BUCK1_ON_VSEL, RK808_BUCK_VSEL_MASK, },
> - { 712500, 12500, REG_BUCK2_ON_VSEL, RK808_BUCK_VSEL_MASK, },
> - { 712500, 12500, -1, RK808_BUCK_VSEL_MASK, },
> - { 1800000, 100000, REG_BUCK4_ON_VSEL, RK808_BUCK4_VSEL_MASK, },
> + { 712500, 12500, REG_BUCK1_ON_VSEL, REG_BUCK1_SLP_VSEL, REG_BUCK1_CONFIG, RK808_BUCK_VSEL_MASK, },
> + { 712500, 12500, REG_BUCK2_ON_VSEL, REG_BUCK2_SLP_VSEL, REG_BUCK2_CONFIG, RK808_BUCK_VSEL_MASK, },
> + { 712500, 12500, NA, NA, REG_BUCK3_CONFIG, RK808_BUCK_VSEL_MASK, },
> + { 1800000, 100000, REG_BUCK4_ON_VSEL, REG_BUCK4_SLP_VSEL, REG_BUCK4_CONFIG, RK808_BUCK4_VSEL_MASK, },
> };
>
> static const struct rk8xx_reg_info rk818_buck[] = {
> - { 712500, 12500, REG_BUCK1_ON_VSEL, RK818_BUCK_VSEL_MASK, },
> - { 712500, 12500, REG_BUCK2_ON_VSEL, RK818_BUCK_VSEL_MASK, },
> - { 712500, 12500, -1, RK818_BUCK_VSEL_MASK, },
> - { 1800000, 100000, REG_BUCK4_ON_VSEL, RK818_BUCK4_VSEL_MASK, },
> + { 712500, 12500, REG_BUCK1_ON_VSEL, REG_BUCK1_SLP_VSEL, REG_BUCK1_CONFIG, RK818_BUCK_VSEL_MASK, },
> + { 712500, 12500, REG_BUCK2_ON_VSEL, REG_BUCK2_SLP_VSEL, REG_BUCK2_CONFIG, RK818_BUCK_VSEL_MASK, },
> + { 712500, 12500, NA, NA, REG_BUCK3_CONFIG, RK818_BUCK_VSEL_MASK, },
> + { 1800000, 100000, REG_BUCK4_ON_VSEL, REG_BUCK4_SLP_VSEL, REG_BUCK4_CONFIG, RK818_BUCK4_VSEL_MASK, },
> };
>
> #ifdef ENABLE_DRIVER
> static const struct rk8xx_reg_info rk808_ldo[] = {
> - { 1800000, 100000, REG_LDO1_ON_VSEL, RK808_LDO_VSEL_MASK, },
> - { 1800000, 100000, REG_LDO2_ON_VSEL, RK808_LDO_VSEL_MASK, },
> - { 800000, 100000, REG_LDO3_ON_VSEL, RK808_BUCK4_VSEL_MASK, },
> - { 1800000, 100000, REG_LDO4_ON_VSEL, RK808_LDO_VSEL_MASK, },
> - { 1800000, 100000, REG_LDO5_ON_VSEL, RK808_LDO_VSEL_MASK, },
> - { 800000, 100000, REG_LDO6_ON_VSEL, RK808_LDO_VSEL_MASK, },
> - { 800000, 100000, REG_LDO7_ON_VSEL, RK808_LDO_VSEL_MASK, },
> - { 1800000, 100000, REG_LDO8_ON_VSEL, RK808_LDO_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO1_ON_VSEL, REG_LDO1_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO2_ON_VSEL, REG_LDO2_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
> + { 800000, 100000, REG_LDO3_ON_VSEL, REG_LDO3_SLP_VSEL, NA, RK808_BUCK4_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO4_ON_VSEL, REG_LDO4_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO5_ON_VSEL, REG_LDO5_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
> + { 800000, 100000, REG_LDO6_ON_VSEL, REG_LDO6_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
> + { 800000, 100000, REG_LDO7_ON_VSEL, REG_LDO7_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO8_ON_VSEL, REG_LDO8_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
> };
>
> static const struct rk8xx_reg_info rk818_ldo[] = {
> - { 1800000, 100000, REG_LDO1_ON_VSEL, RK818_LDO_VSEL_MASK, },
> - { 1800000, 100000, REG_LDO2_ON_VSEL, RK818_LDO_VSEL_MASK, },
> - { 800000, 100000, REG_LDO3_ON_VSEL, RK818_LDO3_ON_VSEL_MASK, },
> - { 1800000, 100000, REG_LDO4_ON_VSEL, RK818_LDO_VSEL_MASK, },
> - { 1800000, 100000, REG_LDO5_ON_VSEL, RK818_LDO_VSEL_MASK, },
> - { 800000, 100000, REG_LDO6_ON_VSEL, RK818_LDO_VSEL_MASK, },
> - { 800000, 100000, REG_LDO7_ON_VSEL, RK818_LDO_VSEL_MASK, },
> - { 1800000, 100000, REG_LDO8_ON_VSEL, RK818_LDO_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO1_ON_VSEL, REG_LDO1_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO2_ON_VSEL, REG_LDO2_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
> + { 800000, 100000, REG_LDO3_ON_VSEL, REG_LDO3_SLP_VSEL, NA, RK818_LDO3_ON_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO4_ON_VSEL, REG_LDO4_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO5_ON_VSEL, REG_LDO5_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
> + { 800000, 100000, REG_LDO6_ON_VSEL, REG_LDO6_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
> + { 800000, 100000, REG_LDO7_ON_VSEL, REG_LDO7_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
> + { 1800000, 100000, REG_LDO8_ON_VSEL, REG_LDO8_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
> };
> #endif
>
> @@ -87,7 +102,7 @@ static const uint rk818_chrg_shutdown_vsel_array[] = {
> };
>
> static const struct rk8xx_reg_info *get_buck_reg(struct udevice *pmic,
> - int num)
> + int num, int uvolt)
> {
> struct rk8xx_priv *priv = dev_get_priv(pmic);
> switch (priv->variant) {
> @@ -100,15 +115,20 @@ static const struct rk8xx_reg_info *get_buck_reg(struct udevice *pmic,
>
> static int _buck_set_value(struct udevice *pmic, int buck, int uvolt)
> {
> - const struct rk8xx_reg_info *info = get_buck_reg(pmic, buck - 1);
> + const struct rk8xx_reg_info *info = get_buck_reg(pmic, buck, uvolt);
> int mask = info->vsel_mask;
> int val;
>
> - if (info->vsel_reg == -1)
> + if (info->vsel_reg == NA)
> return -ENOSYS;
> - val = (uvolt - info->min_uv) / info->step_uv;
> - debug("%s: reg=%x, mask=%x, val=%x\n", __func__, info->vsel_reg, mask,
> - val);
> + if (info->step_uv == 0) /* Fixed voltage */
> + val = info->min_sel;
> + else
> + val = ((uvolt - info->min_uv) / info->step_uv) + info->min_sel;
> +
> + debug("%s: volt=%d, buck=%d, reg=0x%x, mask=0x%x, val=0x%x\n",
> + __func__, uvolt, buck + 1, info->vsel_reg, mask, val);
> +
>
> return pmic_clrsetbits(pmic, info->vsel_reg, mask, val);
> }
> @@ -117,24 +137,115 @@ static int _buck_set_enable(struct udevice *pmic, int buck, bool enable)
> {
> uint mask;
> int ret;
> + struct rk8xx_priv *priv = dev_get_priv(pmic);
>
> - buck--;
> - mask = 1 << buck;
> - if (enable) {
> - ret = pmic_clrsetbits(pmic, REG_DCDC_ILMAX, 0, 3 << (buck * 2));
> - if (ret)
> - return ret;
> - ret = pmic_clrsetbits(pmic, REG_DCDC_UV_ACT, 1 << buck, 0);
> - if (ret)
> - return ret;
> + switch (priv->variant) {
> + case RK808_ID:
> + case RK818_ID:
> + mask = 1 << buck;
> + if (enable) {
> + ret = pmic_clrsetbits(pmic, REG_DCDC_ILMAX,
> + 0, 3 << (buck * 2));
> + if (ret)
> + return ret;
> + }
> + ret = pmic_clrsetbits(pmic, REG_DCDC_EN, mask,
> + enable ? mask : 0);
> + break;
> + default:
> + ret = -EINVAL;
> }
>
> - return pmic_clrsetbits(pmic, REG_DCDC_EN, mask, enable ? mask : 0);
> + return ret;
> }
>
> #ifdef ENABLE_DRIVER
> +static int _buck_set_suspend_value(struct udevice *pmic, int buck, int uvolt)
> +{
> + const struct rk8xx_reg_info *info = get_buck_reg(pmic, buck, uvolt);
> + int mask = info->vsel_mask;
> + int val;
> +
> + if (info->vsel_sleep_reg == NA)
> + return -ENOSYS;
> +
> + if (info->step_uv == 0)
> + val = info->min_sel;
> + else
> + val = ((uvolt - info->min_uv) / info->step_uv) + info->min_sel;
> +
> + debug("%s: volt=%d, buck=%d, reg=0x%x, mask=0x%x, val=0x%x\n",
> + __func__, uvolt, buck + 1, info->vsel_sleep_reg, mask, val);
> +
> + return pmic_clrsetbits(pmic, info->vsel_sleep_reg, mask, val);
> +}
> +
> +static int _buck_get_enable(struct udevice *pmic, int buck)
> +{
> + struct rk8xx_priv *priv = dev_get_priv(pmic);
> + uint mask = 0;
> + int ret = 0;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + case RK818_ID:
> + mask = 1 << buck;
> + ret = pmic_reg_read(pmic, REG_DCDC_EN);
> + if (ret < 0)
> + return ret;
> + break;
> + }
> +
> + if (ret < 0)
> + return ret;
> +
> + return ret & mask ? true : false;
> +}
> +
> +static int _buck_set_suspend_enable(struct udevice *pmic, int buck, bool enable)
> +{
> + uint mask;
> + int ret;
> + struct rk8xx_priv *priv = dev_get_priv(pmic);
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + case RK818_ID:
> + mask = 1 << buck;
> + ret = pmic_clrsetbits(pmic, REG_SLEEP_SET_OFF1, mask,
> + enable ? 0 : mask);
> + break;
> + default:
> + ret = -EINVAL;
> + }
> +
> + return ret;
> +}
> +
> +static int _buck_get_suspend_enable(struct udevice *pmic, int buck)
> +{
> + struct rk8xx_priv *priv = dev_get_priv(pmic);
> + int ret, val;
> + uint mask;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + case RK818_ID:
> + mask = 1 << buck;
> + val = pmic_reg_read(pmic, REG_SLEEP_SET_OFF1);
> + if (val < 0)
> + return val;
> + ret = val & mask ? 0 : 1;
> + break;
> + default:
> + ret = -EINVAL;
> + }
> +
> + return ret;
> +}
> +
> static const struct rk8xx_reg_info *get_ldo_reg(struct udevice *pmic,
> - int num)
> + int num, int uvolt)
> {
> struct rk8xx_priv *priv = dev_get_priv(pmic);
> switch (priv->variant) {
> @@ -145,14 +256,93 @@ static const struct rk8xx_reg_info *get_ldo_reg(struct udevice *pmic,
> }
> }
>
> +static int _ldo_get_enable(struct udevice *pmic, int ldo)
> +{
> + struct rk8xx_priv *priv = dev_get_priv(pmic);
> + uint mask = 0;
> + int ret = 0;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + case RK818_ID:
> + mask = 1 << ldo;
> + ret = pmic_reg_read(pmic, REG_LDO_EN);
> + if (ret < 0)
> + return ret;
> + break;
> + }
> +
> + if (ret < 0)
> + return ret;
> +
> + return ret & mask ? true : false;
> +}
> +
> +static int _ldo_set_enable(struct udevice *pmic, int ldo, bool enable)
> +{
> + struct rk8xx_priv *priv = dev_get_priv(pmic);
> + uint mask;
> + int ret = 0;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + case RK818_ID:
> + mask = 1 << ldo;
> + ret = pmic_clrsetbits(pmic, REG_LDO_EN, mask,
> + enable ? mask : 0);
> + break;
> + }
> +
> + return ret;
> +}
> +
> +static int _ldo_set_suspend_enable(struct udevice *pmic, int ldo, bool enable)
> +{
> + struct rk8xx_priv *priv = dev_get_priv(pmic);
> + uint mask;
> + int ret = 0;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + case RK818_ID:
> + mask = 1 << ldo;
> + ret = pmic_clrsetbits(pmic, REG_SLEEP_SET_OFF2, mask,
> + enable ? 0 : mask);
> + break;
> + }
> +
> + return ret;
> +}
> +
> +static int _ldo_get_suspend_enable(struct udevice *pmic, int ldo)
> +{
> + struct rk8xx_priv *priv = dev_get_priv(pmic);
> + int val, ret = 0;
> + uint mask;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + case RK818_ID:
> + mask = 1 << ldo;
> + val = pmic_reg_read(pmic, REG_SLEEP_SET_OFF2);
> + if (val < 0)
> + return val;
> + ret = val & mask ? 0 : 1;
> + break;
> + }
> +
> + return ret;
> +}
> +
> static int buck_get_value(struct udevice *dev)
> {
> int buck = dev->driver_data - 1;
> - const struct rk8xx_reg_info *info = get_buck_reg(dev->parent, buck);
> + /* We assume level-1 voltage is enough for usage in U-Boot */
> + const struct rk8xx_reg_info *info = get_buck_reg(dev->parent, buck, 0);
> int mask = info->vsel_mask;
> int ret, val;
>
> - if (info->vsel_reg == -1)
> + if (info->vsel_reg == NA)
> return -ENOSYS;
> ret = pmic_reg_read(dev->parent, info->vsel_reg);
> if (ret < 0)
> @@ -164,41 +354,74 @@ static int buck_get_value(struct udevice *dev)
>
> static int buck_set_value(struct udevice *dev, int uvolt)
> {
> - int buck = dev->driver_data;
> + int buck = dev->driver_data - 1;
>
> return _buck_set_value(dev->parent, buck, uvolt);
> }
>
> +static int buck_get_suspend_value(struct udevice *dev)
> +{
> + int buck = dev->driver_data - 1;
> + /* We assume level-1 voltage is enough for usage in U-Boot */
> + const struct rk8xx_reg_info *info = get_buck_reg(dev->parent, buck, 0);
> + int mask = info->vsel_mask;
> + int ret, val;
> +
> + if (info->vsel_sleep_reg == NA)
> + return -ENOSYS;
> +
> + ret = pmic_reg_read(dev->parent, info->vsel_sleep_reg);
> + if (ret < 0)
> + return ret;
> +
> + val = ret & mask;
> +
> + return info->min_uv + val * info->step_uv;
> +}
> +
> +static int buck_set_suspend_value(struct udevice *dev, int uvolt)
> +{
> + int buck = dev->driver_data - 1;
> +
> + return _buck_set_suspend_value(dev->parent, buck, uvolt);
> +}
> +
> static int buck_set_enable(struct udevice *dev, bool enable)
> {
> - int buck = dev->driver_data;
> + int buck = dev->driver_data - 1;
>
> return _buck_set_enable(dev->parent, buck, enable);
> }
>
> -static int buck_get_enable(struct udevice *dev)
> +static int buck_set_suspend_enable(struct udevice *dev, bool enable)
> {
> int buck = dev->driver_data - 1;
> - int ret;
> - uint mask;
>
> - mask = 1 << buck;
> + return _buck_set_suspend_enable(dev->parent, buck, enable);
> +}
>
> - ret = pmic_reg_read(dev->parent, REG_DCDC_EN);
> - if (ret < 0)
> - return ret;
> +static int buck_get_suspend_enable(struct udevice *dev)
> +{
> + int buck = dev->driver_data - 1;
>
> - return ret & mask ? true : false;
> + return _buck_get_suspend_enable(dev->parent, buck);
> +}
> +
> +static int buck_get_enable(struct udevice *dev)
> +{
> + int buck = dev->driver_data - 1;
> +
> + return _buck_get_enable(dev->parent, buck);
> }
>
> static int ldo_get_value(struct udevice *dev)
> {
> int ldo = dev->driver_data - 1;
> - const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo);
> + const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo, 0);
> int mask = info->vsel_mask;
> int ret, val;
>
> - if (info->vsel_reg == -1)
> + if (info->vsel_reg == NA)
> return -ENOSYS;
> ret = pmic_reg_read(dev->parent, info->vsel_reg);
> if (ret < 0)
> @@ -211,71 +434,217 @@ static int ldo_get_value(struct udevice *dev)
> static int ldo_set_value(struct udevice *dev, int uvolt)
> {
> int ldo = dev->driver_data - 1;
> - const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo);
> + const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo, uvolt);
> int mask = info->vsel_mask;
> int val;
>
> - if (info->vsel_reg == -1)
> + if (info->vsel_reg == NA)
> return -ENOSYS;
> - val = (uvolt - info->min_uv) / info->step_uv;
> - debug("%s: reg=%x, mask=%x, val=%x\n", __func__, info->vsel_reg, mask,
> - val);
> +
> + if (info->step_uv == 0)
> + val = info->min_sel;
> + else
> + val = ((uvolt - info->min_uv) / info->step_uv) + info->min_sel;
> +
> + debug("%s: volt=%d, ldo=%d, reg=0x%x, mask=0x%x, val=0x%x\n",
> + __func__, uvolt, ldo + 1, info->vsel_reg, mask, val);
>
> return pmic_clrsetbits(dev->parent, info->vsel_reg, mask, val);
> }
>
> -static int ldo_set_enable(struct udevice *dev, bool enable)
> +static int ldo_set_suspend_value(struct udevice *dev, int uvolt)
> {
> int ldo = dev->driver_data - 1;
> - uint mask;
> + const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo, uvolt);
> + int mask = info->vsel_mask;
> + int val;
> +
> + if (info->vsel_sleep_reg == NA)
> + return -ENOSYS;
>
> - mask = 1 << ldo;
> + if (info->step_uv == 0)
> + val = info->min_sel;
> + else
> + val = ((uvolt - info->min_uv) / info->step_uv) + info->min_sel;
>
> - return pmic_clrsetbits(dev->parent, REG_LDO_EN, mask,
> - enable ? mask : 0);
> + debug("%s: volt=%d, ldo=%d, reg=0x%x, mask=0x%x, val=0x%x\n",
> + __func__, uvolt, ldo + 1, info->vsel_sleep_reg, mask, val);
> +
> + return pmic_clrsetbits(dev->parent, info->vsel_sleep_reg, mask, val);
> }
>
> -static int ldo_get_enable(struct udevice *dev)
> +static int ldo_get_suspend_value(struct udevice *dev)
> {
> int ldo = dev->driver_data - 1;
> - int ret;
> - uint mask;
> + const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo, 0);
> + int mask = info->vsel_mask;
> + int val, ret;
>
> - mask = 1 << ldo;
> + if (info->vsel_sleep_reg == NA)
> + return -ENOSYS;
>
> - ret = pmic_reg_read(dev->parent, REG_LDO_EN);
> + ret = pmic_reg_read(dev->parent, info->vsel_sleep_reg);
> if (ret < 0)
> return ret;
>
> - return ret & mask ? true : false;
> + val = ret & mask;
> +
> + return info->min_uv + val * info->step_uv;
> +}
> +
> +static int ldo_set_enable(struct udevice *dev, bool enable)
> +{
> + int ldo = dev->driver_data - 1;
> +
> + return _ldo_set_enable(dev->parent, ldo, enable);
> +}
> +
> +static int ldo_set_suspend_enable(struct udevice *dev, bool enable)
> +{
> + int ldo = dev->driver_data - 1;
> +
> + return _ldo_set_suspend_enable(dev->parent, ldo, enable);
> +}
> +
> +static int ldo_get_suspend_enable(struct udevice *dev)
> +{
> + int ldo = dev->driver_data - 1;
> +
> + return _ldo_get_suspend_enable(dev->parent, ldo);
> +}
> +
> +static int ldo_get_enable(struct udevice *dev)
> +{
> + int ldo = dev->driver_data - 1;
> +
> + return _ldo_get_enable(dev->parent, ldo);
> }
>
> static int switch_set_enable(struct udevice *dev, bool enable)
> {
> - int sw = dev->driver_data - 1;
> - uint mask;
> + struct rk8xx_priv *priv = dev_get_priv(dev->parent);
> + int ret = 0, sw = dev->driver_data - 1;
> + uint mask = 0;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + mask = 1 << (sw + 5);
> + ret = pmic_clrsetbits(dev->parent, REG_DCDC_EN, mask,
> + enable ? mask : 0);
> + break;
> + case RK818_ID:
> + mask = 1 << 6;
> + ret = pmic_clrsetbits(dev->parent, REG_DCDC_EN, mask,
> + enable ? mask : 0);
> + break;
> + }
>
> - mask = 1 << (sw + 5);
> + debug("%s: switch%d, enable=%d, mask=0x%x\n",
> + __func__, sw + 1, enable, mask);
>
> - return pmic_clrsetbits(dev->parent, REG_DCDC_EN, mask,
> - enable ? mask : 0);
> + return ret;
> }
>
> static int switch_get_enable(struct udevice *dev)
> {
> - int sw = dev->driver_data - 1;
> - int ret;
> - uint mask;
> + struct rk8xx_priv *priv = dev_get_priv(dev->parent);
> + int ret = 0, sw = dev->driver_data - 1;
> + uint mask = 0;
>
> - mask = 1 << (sw + 5);
> + switch (priv->variant) {
> + case RK808_ID:
> + mask = 1 << (sw + 5);
> + ret = pmic_reg_read(dev->parent, REG_DCDC_EN);
> + break;
> + case RK818_ID:
> + mask = 1 << 6;
> + ret = pmic_reg_read(dev->parent, REG_DCDC_EN);
> + break;
> + }
>
> - ret = pmic_reg_read(dev->parent, REG_DCDC_EN);
> if (ret < 0)
> return ret;
>
> return ret & mask ? true : false;
> }
>
> +static int switch_set_suspend_value(struct udevice *dev, int uvolt)
> +{
> + return 0;
> +}
> +
> +static int switch_get_suspend_value(struct udevice *dev)
> +{
> + return 0;
> +}
> +
> +static int switch_set_suspend_enable(struct udevice *dev, bool enable)
> +{
> + struct rk8xx_priv *priv = dev_get_priv(dev->parent);
> + int ret = 0, sw = dev->driver_data - 1;
> + uint mask = 0;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + mask = 1 << (sw + 5);
> + ret = pmic_clrsetbits(dev->parent, REG_SLEEP_SET_OFF1, mask,
> + enable ? 0 : mask);
> + break;
> + case RK818_ID:
> + mask = 1 << 6;
> + ret = pmic_clrsetbits(dev->parent, REG_SLEEP_SET_OFF1, mask,
> + enable ? 0 : mask);
> + break;
> + }
> +
> + debug("%s: switch%d, enable=%d, mask=0x%x\n",
> + __func__, sw + 1, enable, mask);
> +
> + return ret;
> +}
> +
> +static int switch_get_suspend_enable(struct udevice *dev)
> +{
> + struct rk8xx_priv *priv = dev_get_priv(dev->parent);
> + int val, ret = 0, sw = dev->driver_data - 1;
> + uint mask = 0;
> +
> + switch (priv->variant) {
> + case RK808_ID:
> + mask = 1 << (sw + 5);
> + val = pmic_reg_read(dev->parent, REG_SLEEP_SET_OFF1);
> + if (val < 0)
> + return val;
> + ret = val & mask ? 0 : 1;
> + break;
> + case RK818_ID:
> + mask = 1 << 6;
> + val = pmic_reg_read(dev->parent, REG_SLEEP_SET_OFF1);
> + if (val < 0)
> + return val;
> + ret = val & mask ? 0 : 1;
> + break;
> + }
> +
> + return ret;
> +}
> +
> +/*
> + * RK8xx switch does not need to set the voltage,
> + * but if dts set regulator-min-microvolt/regulator-max-microvolt,
> + * will cause regulator set value fail and not to enable this switch.
> + * So add an empty function to return success.
> + */
> +static int switch_get_value(struct udevice *dev)
> +{
> + return 0;
> +}
> +
> +static int switch_set_value(struct udevice *dev, int uvolt)
> +{
> + return 0;
> +}
> +
> static int rk8xx_buck_probe(struct udevice *dev)
> {
> struct dm_regulator_uclass_platdata *uc_pdata;
> @@ -315,20 +684,34 @@ static int rk8xx_switch_probe(struct udevice *dev)
> static const struct dm_regulator_ops rk8xx_buck_ops = {
> .get_value = buck_get_value,
> .set_value = buck_set_value,
> + .set_suspend_value = buck_set_suspend_value,
> + .get_suspend_value = buck_get_suspend_value,
> .get_enable = buck_get_enable,
> .set_enable = buck_set_enable,
> + .set_suspend_enable = buck_set_suspend_enable,
> + .get_suspend_enable = buck_get_suspend_enable,
> };
>
> static const struct dm_regulator_ops rk8xx_ldo_ops = {
> .get_value = ldo_get_value,
> .set_value = ldo_set_value,
> + .set_suspend_value = ldo_set_suspend_value,
> + .get_suspend_value = ldo_get_suspend_value,
> .get_enable = ldo_get_enable,
> .set_enable = ldo_set_enable,
> + .set_suspend_enable = ldo_set_suspend_enable,
> + .get_suspend_enable = ldo_get_suspend_enable,
> };
>
> static const struct dm_regulator_ops rk8xx_switch_ops = {
> + .get_value = switch_get_value,
> + .set_value = switch_set_value,
> .get_enable = switch_get_enable,
> .set_enable = switch_set_enable,
> + .set_suspend_enable = switch_set_suspend_enable,
> + .get_suspend_enable = switch_get_suspend_enable,
> + .set_suspend_value = switch_set_suspend_value,
> + .get_suspend_value = switch_get_suspend_value,
> };
>
> U_BOOT_DRIVER(rk8xx_buck) = {
More information about the U-Boot
mailing list