Unverified Commit be5295f8 authored by Fabrice Gasnier's avatar Fabrice Gasnier Committed by Mark Brown
Browse files

regulator: stm32-vrefbuf: add power management support 



Add support for suspend/resume and runtime PM to stm32-vrefbuf driver.

Signed-off-by: default avatarFabrice Gasnier <fabrice.gasnier@st.com>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 0e819b51

drivers/regulator/stm32-vrefbuf.c

+114 −7
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
#include <linux/platform_device.h>

#include <linux/regulator/driver.h>

#include <linux/regulator/of_regulator.h>

#include <linux/pm_runtime.h>



/* STM32 VREFBUF registers */

#define STM32_VREFBUF_CSR		0x00
@@ -25,9 +26,12 @@ 
#define STM32_HIZ			BIT(1)

#define STM32_ENVR			BIT(0)



#define STM32_VREFBUF_AUTO_SUSPEND_DELAY_MS	10



struct stm32_vrefbuf {

	void __iomem *base;

	struct clk *clk;

	struct device *dev;

};



static const unsigned int stm32_vrefbuf_voltages[] = {
@@ -38,9 +42,16 @@ static const unsigned int stm32_vrefbuf_voltages[] = { 
static int stm32_vrefbuf_enable(struct regulator_dev *rdev)

{

	struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);

	u32 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);

	u32 val;

	int ret;



	ret = pm_runtime_get_sync(priv->dev);

	if (ret < 0) {

		pm_runtime_put_noidle(priv->dev);

		return ret;

	}



	val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);

	val = (val & ~STM32_HIZ) | STM32_ENVR;

	writel_relaxed(val, priv->base + STM32_VREFBUF_CSR);
@@ -59,45 +70,95 @@ static int stm32_vrefbuf_enable(struct regulator_dev *rdev) 
		writel_relaxed(val, priv->base + STM32_VREFBUF_CSR);

	}



	pm_runtime_mark_last_busy(priv->dev);

	pm_runtime_put_autosuspend(priv->dev);



	return ret;

}



static int stm32_vrefbuf_disable(struct regulator_dev *rdev)

{

	struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);

	u32 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);

	u32 val;

	int ret;



	ret = pm_runtime_get_sync(priv->dev);

	if (ret < 0) {

		pm_runtime_put_noidle(priv->dev);

		return ret;

	}



	val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);

	val = (val & ~STM32_ENVR) | STM32_HIZ;

	writel_relaxed(val, priv->base + STM32_VREFBUF_CSR);



	pm_runtime_mark_last_busy(priv->dev);

	pm_runtime_put_autosuspend(priv->dev);



	return 0;

}



static int stm32_vrefbuf_is_enabled(struct regulator_dev *rdev)

{

	struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);

	int ret;



	return readl_relaxed(priv->base + STM32_VREFBUF_CSR) & STM32_ENVR;

	ret = pm_runtime_get_sync(priv->dev);

	if (ret < 0) {

		pm_runtime_put_noidle(priv->dev);

		return ret;

	}



	ret = readl_relaxed(priv->base + STM32_VREFBUF_CSR) & STM32_ENVR;



	pm_runtime_mark_last_busy(priv->dev);

	pm_runtime_put_autosuspend(priv->dev);



	return ret;

}



static int stm32_vrefbuf_set_voltage_sel(struct regulator_dev *rdev,

					 unsigned sel)

{

	struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);

	u32 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);

	u32 val;

	int ret;



	ret = pm_runtime_get_sync(priv->dev);

	if (ret < 0) {

		pm_runtime_put_noidle(priv->dev);

		return ret;

	}



	val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);

	val = (val & ~STM32_VRS) | FIELD_PREP(STM32_VRS, sel);

	writel_relaxed(val, priv->base + STM32_VREFBUF_CSR);



	pm_runtime_mark_last_busy(priv->dev);

	pm_runtime_put_autosuspend(priv->dev);



	return 0;

}



static int stm32_vrefbuf_get_voltage_sel(struct regulator_dev *rdev)

{

	struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);

	u32 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);

	u32 val;

	int ret;



	return FIELD_GET(STM32_VRS, val);

	ret = pm_runtime_get_sync(priv->dev);

	if (ret < 0) {

		pm_runtime_put_noidle(priv->dev);

		return ret;

	}



	val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);

	ret = FIELD_GET(STM32_VRS, val);



	pm_runtime_mark_last_busy(priv->dev);

	pm_runtime_put_autosuspend(priv->dev);



	return ret;

}



static const struct regulator_ops stm32_vrefbuf_volt_ops = {
@@ -130,6 +191,7 @@ static int stm32_vrefbuf_probe(struct platform_device *pdev) 
	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;

	priv->dev = &pdev->dev;



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	priv->base = devm_ioremap_resource(&pdev->dev, res);
@@ -140,10 +202,17 @@ static int stm32_vrefbuf_probe(struct platform_device *pdev) 
	if (IS_ERR(priv->clk))

		return PTR_ERR(priv->clk);



	pm_runtime_get_noresume(&pdev->dev);

	pm_runtime_set_active(&pdev->dev);

	pm_runtime_set_autosuspend_delay(&pdev->dev,

					 STM32_VREFBUF_AUTO_SUSPEND_DELAY_MS);

	pm_runtime_use_autosuspend(&pdev->dev);

	pm_runtime_enable(&pdev->dev);



	ret = clk_prepare_enable(priv->clk);

	if (ret) {

		dev_err(&pdev->dev, "clk prepare failed with error %d\n", ret);

		return ret;

		goto err_pm_stop;

	}



	config.dev = &pdev->dev;
@@ -161,10 +230,17 @@ static int stm32_vrefbuf_probe(struct platform_device *pdev) 
	}

	platform_set_drvdata(pdev, rdev);



	pm_runtime_mark_last_busy(&pdev->dev);

	pm_runtime_put_autosuspend(&pdev->dev);



	return 0;



err_clk_dis:

	clk_disable_unprepare(priv->clk);

err_pm_stop:

	pm_runtime_disable(&pdev->dev);

	pm_runtime_set_suspended(&pdev->dev);

	pm_runtime_put_noidle(&pdev->dev);



	return ret;

}
@@ -174,12 +250,42 @@ static int stm32_vrefbuf_remove(struct platform_device *pdev) 
	struct regulator_dev *rdev = platform_get_drvdata(pdev);

	struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);



	pm_runtime_get_sync(&pdev->dev);

	regulator_unregister(rdev);

	clk_disable_unprepare(priv->clk);

	pm_runtime_disable(&pdev->dev);

	pm_runtime_set_suspended(&pdev->dev);

	pm_runtime_put_noidle(&pdev->dev);



	return 0;

};



static int __maybe_unused stm32_vrefbuf_runtime_suspend(struct device *dev)

{

	struct regulator_dev *rdev = dev_get_drvdata(dev);

	struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);



	clk_disable_unprepare(priv->clk);



	return 0;

}



static int __maybe_unused stm32_vrefbuf_runtime_resume(struct device *dev)

{

	struct regulator_dev *rdev = dev_get_drvdata(dev);

	struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);



	return clk_prepare_enable(priv->clk);

}



static const struct dev_pm_ops stm32_vrefbuf_pm_ops = {

	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,

				pm_runtime_force_resume)

	SET_RUNTIME_PM_OPS(stm32_vrefbuf_runtime_suspend,

			   stm32_vrefbuf_runtime_resume,

			   NULL)

};



static const struct of_device_id stm32_vrefbuf_of_match[] = {

	{ .compatible = "st,stm32-vrefbuf", },

	{},
@@ -192,6 +298,7 @@ static struct platform_driver stm32_vrefbuf_driver = { 
	.driver = {

		.name  = "stm32-vrefbuf",

		.of_match_table = of_match_ptr(stm32_vrefbuf_of_match),

		.pm = &stm32_vrefbuf_pm_ops,

	},

};

module_platform_driver(stm32_vrefbuf_driver);

CRA Git | Maintained and supported by SUSTech CRA and CCSE