From mboxrd@z Thu Jan 1 00:00:00 1970 From: Simon Glass Date: Mon, 16 Sep 2019 22:47:58 -0700 Subject: [U-Boot] [PATCH v1 1/7] dm: regulator: support regulator more state In-Reply-To: <1567580907-9561-2-git-send-email-zhangqing@rock-chips.com> References: <1567580907-9561-1-git-send-email-zhangqing@rock-chips.com> <1567580907-9561-2-git-send-email-zhangqing@rock-chips.com> Message-ID: List-Id: MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: u-boot@lists.denx.de Hi Elaine, On Wed, 4 Sep 2019 at 01:09, Elaine Zhang wrote: > > From: Joseph Chen > > support parse regulator standard property: > regulator-off-in-suspend; > regulator-init-microvolt; > regulator-suspend-microvolt: > regulator_get_suspend_enable > regulator_set_suspend_enable > regulator_get_suspend_value > regulator_set_suspend_value > > Signed-off-by: Joseph Chen > Signed-off-by: Elaine Zhang > --- > drivers/power/regulator/regulator-uclass.c | 67 ++++++++++++++++++++++++++++++ > include/power/regulator.h | 42 +++++++++++++++++++ > 2 files changed, 109 insertions(+) > > diff --git a/drivers/power/regulator/regulator-uclass.c b/drivers/power/regulator/regulator-uclass.c > index 76be95bcd159..972a5b210c3c 100644 > --- a/drivers/power/regulator/regulator-uclass.c > +++ b/drivers/power/regulator/regulator-uclass.c > @@ -77,6 +77,33 @@ int regulator_set_value(struct udevice *dev, int uV) > return ret; > } > > +int regulator_set_suspend_value(struct udevice *dev, int uV) > +{ > + const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); > + struct dm_regulator_uclass_platdata *uc_pdata; > + > + uc_pdata = dev_get_uclass_platdata(dev); > + if (uc_pdata->min_uV != -ENODATA && uV < uc_pdata->min_uV) > + return -EINVAL; > + if (uc_pdata->max_uV != -ENODATA && uV > uc_pdata->max_uV) > + return -EINVAL; > + > + if (!ops || !ops->set_suspend_value) We don't need the !ops - that would be a bug. > + return -ENOSYS; > + > + return ops->set_suspend_value(dev, uV); > +} > + > +int regulator_get_suspend_value(struct udevice *dev) > +{ > + const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); > + > + if (!ops || !ops->get_suspend_value) > + return -ENOSYS; > + > + return ops->get_suspend_value(dev); > +} > + > /* > * To be called with at most caution as there is no check > * before setting the actual voltage value. > @@ -170,6 +197,26 @@ int regulator_set_enable_if_allowed(struct udevice *dev, bool enable) > return ret; > } > > +int regulator_set_suspend_enable(struct udevice *dev, bool enable) > +{ > + const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); > + > + if (!ops || !ops->set_suspend_enable) > + return -ENOSYS; > + > + return ops->set_suspend_enable(dev, enable); > +} > + > +int regulator_get_suspend_enable(struct udevice *dev) > +{ > + const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); > + > + if (!ops || !ops->get_suspend_enable) > + return -ENOSYS; > + > + return ops->get_suspend_enable(dev); > +} > + > int regulator_get_mode(struct udevice *dev) > { > const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); > @@ -235,6 +282,11 @@ int regulator_autoset(struct udevice *dev) > int ret = 0; > > uc_pdata = dev_get_uclass_platdata(dev); > + > + ret = regulator_set_suspend_enable(dev, uc_pdata->suspend_on); > + if (!ret && uc_pdata->suspend_on) > + ret = regulator_set_suspend_value(dev, uc_pdata->suspend_uV); Where are the return values being checked? > + > if (!uc_pdata->always_on && !uc_pdata->boot_on) > return -EMEDIUMTYPE; > > @@ -243,6 +295,8 @@ int regulator_autoset(struct udevice *dev) > > if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV) > ret = regulator_set_value(dev, uc_pdata->min_uV); > + if (uc_pdata->init_uV > 0) > + ret = regulator_set_value(dev, uc_pdata->init_uV); > if (!ret && (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA)) > ret = regulator_set_current(dev, uc_pdata->min_uA); > > @@ -363,6 +417,7 @@ static int regulator_post_bind(struct udevice *dev) > static int regulator_pre_probe(struct udevice *dev) > { > struct dm_regulator_uclass_platdata *uc_pdata; > + ofnode node; > > uc_pdata = dev_get_uclass_platdata(dev); > if (!uc_pdata) > @@ -373,6 +428,8 @@ static int regulator_pre_probe(struct udevice *dev) > -ENODATA); > uc_pdata->max_uV = dev_read_u32_default(dev, "regulator-max-microvolt", > -ENODATA); > + uc_pdata->init_uV = dev_read_u32_default(dev, "regulator-init-microvolt", > + -ENODATA); > uc_pdata->min_uA = dev_read_u32_default(dev, "regulator-min-microamp", > -ENODATA); > uc_pdata->max_uA = dev_read_u32_default(dev, "regulator-max-microamp", > @@ -382,6 +439,16 @@ static int regulator_pre_probe(struct udevice *dev) > uc_pdata->ramp_delay = dev_read_u32_default(dev, "regulator-ramp-delay", > 0); > > + node = dev_read_subnode(dev, "regulator-state-mem"); > + if (ofnode_valid(node)) { > + uc_pdata->suspend_on = !ofnode_read_bool(node, "regulator-off-in-suspend"); > + if (ofnode_read_u32(node, "regulator-suspend-microvolt", &uc_pdata->suspend_uV)) > + uc_pdata->suspend_uV = uc_pdata->max_uA; > + } else { > + uc_pdata->suspend_on = true; > + uc_pdata->suspend_uV = uc_pdata->max_uA; > + } > + > /* Those values are optional (-ENODATA if unset) */ > if ((uc_pdata->min_uV != -ENODATA) && > (uc_pdata->max_uV != -ENODATA) && > diff --git a/include/power/regulator.h b/include/power/regulator.h > index 6c6e2cd4f996..64c5108950a0 100644 > --- a/include/power/regulator.h > +++ b/include/power/regulator.h > @@ -168,6 +168,7 @@ struct dm_regulator_uclass_platdata { > int mode_count; > int min_uV; > int max_uV; > + int init_uV; Please add docs for this in comment above! > int min_uA; > int max_uA; > unsigned int ramp_delay; > @@ -177,6 +178,8 @@ struct dm_regulator_uclass_platdata { > int flags; > u8 ctrl_reg; > u8 volt_reg; > + bool suspend_on; > + u32 suspend_uV; > }; > > /* Regulator device operations */ > @@ -192,6 +195,8 @@ struct dm_regulator_ops { > */ > int (*get_value)(struct udevice *dev); > int (*set_value)(struct udevice *dev, int uV); > + int (*set_suspend_value)(struct udevice *dev, int uV); > + int (*get_suspend_value)(struct udevice *dev); Please add documentation as to what these do. You can copy it from what you have below. > > /** > * The regulator output current function calls operates on a micro Amps. > @@ -216,6 +221,8 @@ struct dm_regulator_ops { > */ > int (*get_enable)(struct udevice *dev); > int (*set_enable)(struct udevice *dev, bool enable); > + int (*set_suspend_enable)(struct udevice *dev, bool enable); > + int (*get_suspend_enable)(struct udevice *dev); > > /** > * The 'get/set_mode()' function calls should operate on a driver- > @@ -262,6 +269,23 @@ int regulator_get_value(struct udevice *dev); > int regulator_set_value(struct udevice *dev, int uV); > > /** > + * regulator_set_suspend_value: set the suspend microvoltage value of a given regulator. > + * > + * @dev - pointer to the regulator device > + * @uV - the output suspend value to set [micro Volts] > + * @return - 0 on success or -errno val if fails > + */ > +int regulator_set_suspend_value(struct udevice *dev, int uV); > + > +/** > + * regulator_get_suspend_value: get the suspend microvoltage value of a given regulator. > + * > + * @dev - pointer to the regulator device > + * @return - positive output value [uV] on success or negative errno if fail. > + */ > +int regulator_get_suspend_value(struct udevice *dev); > + > +/** > * regulator_set_value_force: set the microvoltage value of a given regulator > * without any min-,max condition check > * > @@ -317,6 +341,24 @@ int regulator_set_enable(struct udevice *dev, bool enable); > int regulator_set_enable_if_allowed(struct udevice *dev, bool enable); > > /** > + * regulator_set_suspend_enable: set regulator suspend enable state > + * > + * @dev - pointer to the regulator device > + * @enable - set true or false > + * @return - 0 on success or -errno val if fails > + */ > +int regulator_set_suspend_enable(struct udevice *dev, bool enable); > + > + > +/** > + * regulator_get_suspend_enable: get regulator suspend enable state > + * > + * @dev - pointer to the regulator device > + * @return - 0 on success or -errno val if fails So how does it return the the stage? I would expect this to return 0 or 1. > + */ > +int regulator_get_suspend_enable(struct udevice *dev); > + > +/** > * regulator_get_mode: get active operation mode id of a given regulator > * > * @dev - pointer to the regulator device > -- > 1.9.1 > > > Please add to the regulator.c tests to cover the above functions. Regards, Simon