[PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()

[PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()

[Uwe Kleine-König]

Several drivers manually register a devm handler to disable their clk.
Convert them to devm_clk_get_enabled().

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/hwmon/axi-fan-control.c | 15 +--------------
 drivers/hwmon/ltc2947-core.c    | 17 +----------------
 drivers/hwmon/mr75203.c         | 26 +-------------------------
 drivers/hwmon/sparx5-temp.c     | 19 +------------------
 4 files changed, 4 insertions(+), 73 deletions(-)

diff --git a/drivers/hwmon/axi-fan-control.c b/drivers/hwmon/axi-fan-control.c
index d2092c17d993..ce404ed9c53e 100644
--- a/drivers/hwmon/axi-fan-control.c
+++ b/drivers/hwmon/axi-fan-control.c
@@ -393,11 +393,6 @@ static int axi_fan_control_init(struct axi_fan_control_data *ctl,
 	return ret;
 }
 
-static void axi_fan_control_clk_disable(void *clk)
-{
-	clk_disable_unprepare(clk);
-}
-
 static const struct hwmon_channel_info *axi_fan_control_info[] = {
 	HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT),
 	HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_LABEL),
@@ -477,20 +472,12 @@ static int axi_fan_control_probe(struct platform_device *pdev)
 	if (IS_ERR(ctl->base))
 		return PTR_ERR(ctl->base);
 
-	clk = devm_clk_get(&pdev->dev, NULL);
+	clk = devm_clk_get_enabled(&pdev->dev, NULL);
 	if (IS_ERR(clk)) {
 		dev_err(&pdev->dev, "clk_get failed with %ld\n", PTR_ERR(clk));
 		return PTR_ERR(clk);
 	}
 
-	ret = clk_prepare_enable(clk);
-	if (ret)
-		return ret;
-
-	ret = devm_add_action_or_reset(&pdev->dev, axi_fan_control_clk_disable, clk);
-	if (ret)
-		return ret;
-
 	ctl->clk_rate = clk_get_rate(clk);
 	if (!ctl->clk_rate)
 		return -EINVAL;
diff --git a/drivers/hwmon/ltc2947-core.c b/drivers/hwmon/ltc2947-core.c
index 5423466de697..626f5bf2c9c7 100644
--- a/drivers/hwmon/ltc2947-core.c
+++ b/drivers/hwmon/ltc2947-core.c
@@ -956,13 +956,6 @@ static struct attribute *ltc2947_attrs[] = {
 };
 ATTRIBUTE_GROUPS(ltc2947);
 
-static void ltc2947_clk_disable(void *data)
-{
-	struct clk *extclk = data;
-
-	clk_disable_unprepare(extclk);
-}
-
 static int ltc2947_setup(struct ltc2947_data *st)
 {
 	int ret;
@@ -989,7 +982,7 @@ static int ltc2947_setup(struct ltc2947_data *st)
 		return ret;
 
 	/* check external clock presence */
-	extclk = devm_clk_get_optional(st->dev, NULL);
+	extclk = devm_clk_get_optional_enabled(st->dev, NULL);
 	if (IS_ERR(extclk))
 		return dev_err_probe(st->dev, PTR_ERR(extclk),
 				     "Failed to get external clock\n");
@@ -1007,14 +1000,6 @@ static int ltc2947_setup(struct ltc2947_data *st)
 			return -EINVAL;
 		}
 
-		ret = clk_prepare_enable(extclk);
-		if (ret)
-			return ret;
-
-		ret = devm_add_action_or_reset(st->dev, ltc2947_clk_disable,
-					       extclk);
-		if (ret)
-			return ret;
 		/* as in table 1 of the datasheet */
 		if (rate_hz >= LTC2947_CLK_MIN && rate_hz <= 1000000)
 			pre = 0;
diff --git a/drivers/hwmon/mr75203.c b/drivers/hwmon/mr75203.c
index 1ba1e3145969..0c691f291a64 100644
--- a/drivers/hwmon/mr75203.c
+++ b/drivers/hwmon/mr75203.c
@@ -461,24 +461,6 @@ static int pvt_get_regmap(struct platform_device *pdev, char *reg_name,
 	return 0;
 }
 
-static void pvt_clk_disable(void *data)
-{
-	struct pvt_device *pvt = data;
-
-	clk_disable_unprepare(pvt->clk);
-}
-
-static int pvt_clk_enable(struct device *dev, struct pvt_device *pvt)
-{
-	int ret;
-
-	ret = clk_prepare_enable(pvt->clk);
-	if (ret)
-		return ret;
-
-	return devm_add_action_or_reset(dev, pvt_clk_disable, pvt);
-}
-
 static void pvt_reset_control_assert(void *data)
 {
 	struct pvt_device *pvt = data;
@@ -515,16 +497,10 @@ static int mr75203_probe(struct platform_device *pdev)
 	if (ret)
 		return ret;
 
-	pvt->clk = devm_clk_get(dev, NULL);
+	pvt->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(pvt->clk))
 		return dev_err_probe(dev, PTR_ERR(pvt->clk), "failed to get clock\n");
 
-	ret = pvt_clk_enable(dev, pvt);
-	if (ret) {
-		dev_err(dev, "failed to enable clock\n");
-		return ret;
-	}
-
 	pvt->rst = devm_reset_control_get_exclusive(dev, NULL);
 	if (IS_ERR(pvt->rst))
 		return dev_err_probe(dev, PTR_ERR(pvt->rst),
diff --git a/drivers/hwmon/sparx5-temp.c b/drivers/hwmon/sparx5-temp.c
index 98be48e3a22a..04fd8505e5d6 100644
--- a/drivers/hwmon/sparx5-temp.c
+++ b/drivers/hwmon/sparx5-temp.c
@@ -26,13 +26,6 @@ struct s5_hwmon {
 	struct clk *clk;
 };
 
-static void s5_temp_clk_disable(void *data)
-{
-	struct clk *clk = data;
-
-	clk_disable_unprepare(clk);
-}
-
 static void s5_temp_enable(struct s5_hwmon *hwmon)
 {
 	u32 val = readl(hwmon->base + TEMP_CFG);
@@ -113,7 +106,6 @@ static int s5_temp_probe(struct platform_device *pdev)
 {
 	struct device *hwmon_dev;
 	struct s5_hwmon *hwmon;
-	int ret;
 
 	hwmon = devm_kzalloc(&pdev->dev, sizeof(*hwmon), GFP_KERNEL);
 	if (!hwmon)
@@ -123,19 +115,10 @@ static int s5_temp_probe(struct platform_device *pdev)
 	if (IS_ERR(hwmon->base))
 		return PTR_ERR(hwmon->base);
 
-	hwmon->clk = devm_clk_get(&pdev->dev, NULL);
+	hwmon->clk = devm_clk_get_enabled(&pdev->dev, NULL);
 	if (IS_ERR(hwmon->clk))
 		return PTR_ERR(hwmon->clk);
 
-	ret = clk_prepare_enable(hwmon->clk);
-	if (ret)
-		return ret;
-
-	ret = devm_add_action_or_reset(&pdev->dev, s5_temp_clk_disable,
-				       hwmon->clk);
-	if (ret)
-		return ret;
-
 	s5_temp_enable(hwmon);
 
 	hwmon_dev = devm_hwmon_device_register_with_info(&pdev->dev,
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()

[Guenter Roeck]

On 3/14/22 07:16, Uwe Kleine-König wrote:
> Several drivers manually register a devm handler to disable their clk.
> Convert them to devm_clk_get_enabled().
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>

Let's see if it goes anywhere this time.

Acked-by: Guenter Roeck <linux@roeck-us.net>

> ---
>   drivers/hwmon/axi-fan-control.c | 15 +--------------
>   drivers/hwmon/ltc2947-core.c    | 17 +----------------
>   drivers/hwmon/mr75203.c         | 26 +-------------------------
>   drivers/hwmon/sparx5-temp.c     | 19 +------------------
>   4 files changed, 4 insertions(+), 73 deletions(-)
> 
> diff --git a/drivers/hwmon/axi-fan-control.c b/drivers/hwmon/axi-fan-control.c
> index d2092c17d993..ce404ed9c53e 100644
> --- a/drivers/hwmon/axi-fan-control.c
> +++ b/drivers/hwmon/axi-fan-control.c
> @@ -393,11 +393,6 @@ static int axi_fan_control_init(struct axi_fan_control_data *ctl,
>   	return ret;
>   }
>   
> -static void axi_fan_control_clk_disable(void *clk)
> -{
> -	clk_disable_unprepare(clk);
> -}
> -
>   static const struct hwmon_channel_info *axi_fan_control_info[] = {
>   	HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT),
>   	HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_LABEL),
> @@ -477,20 +472,12 @@ static int axi_fan_control_probe(struct platform_device *pdev)
>   	if (IS_ERR(ctl->base))
>   		return PTR_ERR(ctl->base);
>   
> -	clk = devm_clk_get(&pdev->dev, NULL);
> +	clk = devm_clk_get_enabled(&pdev->dev, NULL);
>   	if (IS_ERR(clk)) {
>   		dev_err(&pdev->dev, "clk_get failed with %ld\n", PTR_ERR(clk));
>   		return PTR_ERR(clk);
>   	}
>   
> -	ret = clk_prepare_enable(clk);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&pdev->dev, axi_fan_control_clk_disable, clk);
> -	if (ret)
> -		return ret;
> -
>   	ctl->clk_rate = clk_get_rate(clk);
>   	if (!ctl->clk_rate)
>   		return -EINVAL;
> diff --git a/drivers/hwmon/ltc2947-core.c b/drivers/hwmon/ltc2947-core.c
> index 5423466de697..626f5bf2c9c7 100644
> --- a/drivers/hwmon/ltc2947-core.c
> +++ b/drivers/hwmon/ltc2947-core.c
> @@ -956,13 +956,6 @@ static struct attribute *ltc2947_attrs[] = {
>   };
>   ATTRIBUTE_GROUPS(ltc2947);
>   
> -static void ltc2947_clk_disable(void *data)
> -{
> -	struct clk *extclk = data;
> -
> -	clk_disable_unprepare(extclk);
> -}
> -
>   static int ltc2947_setup(struct ltc2947_data *st)
>   {
>   	int ret;
> @@ -989,7 +982,7 @@ static int ltc2947_setup(struct ltc2947_data *st)
>   		return ret;
>   
>   	/* check external clock presence */
> -	extclk = devm_clk_get_optional(st->dev, NULL);
> +	extclk = devm_clk_get_optional_enabled(st->dev, NULL);
>   	if (IS_ERR(extclk))
>   		return dev_err_probe(st->dev, PTR_ERR(extclk),
>   				     "Failed to get external clock\n");
> @@ -1007,14 +1000,6 @@ static int ltc2947_setup(struct ltc2947_data *st)
>   			return -EINVAL;
>   		}
>   
> -		ret = clk_prepare_enable(extclk);
> -		if (ret)
> -			return ret;
> -
> -		ret = devm_add_action_or_reset(st->dev, ltc2947_clk_disable,
> -					       extclk);
> -		if (ret)
> -			return ret;
>   		/* as in table 1 of the datasheet */
>   		if (rate_hz >= LTC2947_CLK_MIN && rate_hz <= 1000000)
>   			pre = 0;
> diff --git a/drivers/hwmon/mr75203.c b/drivers/hwmon/mr75203.c
> index 1ba1e3145969..0c691f291a64 100644
> --- a/drivers/hwmon/mr75203.c
> +++ b/drivers/hwmon/mr75203.c
> @@ -461,24 +461,6 @@ static int pvt_get_regmap(struct platform_device *pdev, char *reg_name,
>   	return 0;
>   }
>   
> -static void pvt_clk_disable(void *data)
> -{
> -	struct pvt_device *pvt = data;
> -
> -	clk_disable_unprepare(pvt->clk);
> -}
> -
> -static int pvt_clk_enable(struct device *dev, struct pvt_device *pvt)
> -{
> -	int ret;
> -
> -	ret = clk_prepare_enable(pvt->clk);
> -	if (ret)
> -		return ret;
> -
> -	return devm_add_action_or_reset(dev, pvt_clk_disable, pvt);
> -}
> -
>   static void pvt_reset_control_assert(void *data)
>   {
>   	struct pvt_device *pvt = data;
> @@ -515,16 +497,10 @@ static int mr75203_probe(struct platform_device *pdev)
>   	if (ret)
>   		return ret;
>   
> -	pvt->clk = devm_clk_get(dev, NULL);
> +	pvt->clk = devm_clk_get_enabled(dev, NULL);
>   	if (IS_ERR(pvt->clk))
>   		return dev_err_probe(dev, PTR_ERR(pvt->clk), "failed to get clock\n");
>   
> -	ret = pvt_clk_enable(dev, pvt);
> -	if (ret) {
> -		dev_err(dev, "failed to enable clock\n");
> -		return ret;
> -	}
> -
>   	pvt->rst = devm_reset_control_get_exclusive(dev, NULL);
>   	if (IS_ERR(pvt->rst))
>   		return dev_err_probe(dev, PTR_ERR(pvt->rst),
> diff --git a/drivers/hwmon/sparx5-temp.c b/drivers/hwmon/sparx5-temp.c
> index 98be48e3a22a..04fd8505e5d6 100644
> --- a/drivers/hwmon/sparx5-temp.c
> +++ b/drivers/hwmon/sparx5-temp.c
> @@ -26,13 +26,6 @@ struct s5_hwmon {
>   	struct clk *clk;
>   };
>   
> -static void s5_temp_clk_disable(void *data)
> -{
> -	struct clk *clk = data;
> -
> -	clk_disable_unprepare(clk);
> -}
> -
>   static void s5_temp_enable(struct s5_hwmon *hwmon)
>   {
>   	u32 val = readl(hwmon->base + TEMP_CFG);
> @@ -113,7 +106,6 @@ static int s5_temp_probe(struct platform_device *pdev)
>   {
>   	struct device *hwmon_dev;
>   	struct s5_hwmon *hwmon;
> -	int ret;
>   
>   	hwmon = devm_kzalloc(&pdev->dev, sizeof(*hwmon), GFP_KERNEL);
>   	if (!hwmon)
> @@ -123,19 +115,10 @@ static int s5_temp_probe(struct platform_device *pdev)
>   	if (IS_ERR(hwmon->base))
>   		return PTR_ERR(hwmon->base);
>   
> -	hwmon->clk = devm_clk_get(&pdev->dev, NULL);
> +	hwmon->clk = devm_clk_get_enabled(&pdev->dev, NULL);
>   	if (IS_ERR(hwmon->clk))
>   		return PTR_ERR(hwmon->clk);
>   
> -	ret = clk_prepare_enable(hwmon->clk);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&pdev->dev, s5_temp_clk_disable,
> -				       hwmon->clk);
> -	if (ret)
> -		return ret;
> -
>   	s5_temp_enable(hwmon);
>   
>   	hwmon_dev = devm_hwmon_device_register_with_info(&pdev->dev,


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()

[Uwe Kleine-König]

Several drivers manually register a devm handler to disable their clk.
Convert them to devm_clk_get_enabled().

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/iio/adc/ad7124.c           | 15 +---------
 drivers/iio/adc/ad7768-1.c         | 17 +-----------
 drivers/iio/adc/ad9467.c           | 17 +-----------
 drivers/iio/adc/ingenic-adc.c      | 15 ++--------
 drivers/iio/adc/lpc18xx_adc.c      | 18 +-----------
 drivers/iio/adc/rockchip_saradc.c  | 44 ++----------------------------
 drivers/iio/adc/ti-ads131e08.c     | 19 +------------
 drivers/iio/adc/xilinx-ams.c       | 15 +---------
 drivers/iio/adc/xilinx-xadc-core.c | 18 +-----------
 drivers/iio/frequency/adf4371.c    | 17 +-----------
 drivers/iio/frequency/admv1013.c   | 15 +---------
 drivers/iio/frequency/adrf6780.c   | 16 +----------
 drivers/iio/imu/adis16475.c        | 15 +---------
 13 files changed, 15 insertions(+), 226 deletions(-)

diff --git a/drivers/iio/adc/ad7124.c b/drivers/iio/adc/ad7124.c
index b400bbe291aa..fcfa4e0b41fb 100644
--- a/drivers/iio/adc/ad7124.c
+++ b/drivers/iio/adc/ad7124.c
@@ -862,11 +862,6 @@ static void ad7124_reg_disable(void *r)
 	regulator_disable(r);
 }
 
-static void ad7124_clk_disable(void *c)
-{
-	clk_disable_unprepare(c);
-}
-
 static int ad7124_probe(struct spi_device *spi)
 {
 	const struct ad7124_chip_info *info;
@@ -917,18 +912,10 @@ static int ad7124_probe(struct spi_device *spi)
 			return ret;
 	}
 
-	st->mclk = devm_clk_get(&spi->dev, "mclk");
+	st->mclk = devm_clk_get_enabled(&spi->dev, "mclk");
 	if (IS_ERR(st->mclk))
 		return PTR_ERR(st->mclk);
 
-	ret = clk_prepare_enable(st->mclk);
-	if (ret < 0)
-		return ret;
-
-	ret = devm_add_action_or_reset(&spi->dev, ad7124_clk_disable, st->mclk);
-	if (ret)
-		return ret;
-
 	ret = ad7124_soft_reset(st);
 	if (ret < 0)
 		return ret;
diff --git a/drivers/iio/adc/ad7768-1.c b/drivers/iio/adc/ad7768-1.c
index aa42ba759fa1..8ae34ed8fabd 100644
--- a/drivers/iio/adc/ad7768-1.c
+++ b/drivers/iio/adc/ad7768-1.c
@@ -539,13 +539,6 @@ static void ad7768_regulator_disable(void *data)
 	regulator_disable(st->vref);
 }
 
-static void ad7768_clk_disable(void *data)
-{
-	struct ad7768_state *st = data;
-
-	clk_disable_unprepare(st->mclk);
-}
-
 static int ad7768_set_channel_label(struct iio_dev *indio_dev,
 						int num_channels)
 {
@@ -600,18 +593,10 @@ static int ad7768_probe(struct spi_device *spi)
 	if (ret)
 		return ret;
 
-	st->mclk = devm_clk_get(&spi->dev, "mclk");
+	st->mclk = devm_clk_get_enabled(&spi->dev, "mclk");
 	if (IS_ERR(st->mclk))
 		return PTR_ERR(st->mclk);
 
-	ret = clk_prepare_enable(st->mclk);
-	if (ret < 0)
-		return ret;
-
-	ret = devm_add_action_or_reset(&spi->dev, ad7768_clk_disable, st);
-	if (ret)
-		return ret;
-
 	st->mclk_freq = clk_get_rate(st->mclk);
 
 	mutex_init(&st->lock);
diff --git a/drivers/iio/adc/ad9467.c b/drivers/iio/adc/ad9467.c
index dbfc8517cb8a..a07df0fd3329 100644
--- a/drivers/iio/adc/ad9467.c
+++ b/drivers/iio/adc/ad9467.c
@@ -378,13 +378,6 @@ static int ad9467_preenable_setup(struct adi_axi_adc_conv *conv)
 	return ad9467_outputmode_set(st->spi, st->output_mode);
 }
 
-static void ad9467_clk_disable(void *data)
-{
-	struct ad9467_state *st = data;
-
-	clk_disable_unprepare(st->clk);
-}
-
 static int ad9467_probe(struct spi_device *spi)
 {
 	const struct ad9467_chip_info *info;
@@ -404,18 +397,10 @@ static int ad9467_probe(struct spi_device *spi)
 	st = adi_axi_adc_conv_priv(conv);
 	st->spi = spi;
 
-	st->clk = devm_clk_get(&spi->dev, "adc-clk");
+	st->clk = devm_clk_get_enabled(&spi->dev, "adc-clk");
 	if (IS_ERR(st->clk))
 		return PTR_ERR(st->clk);
 
-	ret = clk_prepare_enable(st->clk);
-	if (ret < 0)
-		return ret;
-
-	ret = devm_add_action_or_reset(&spi->dev, ad9467_clk_disable, st);
-	if (ret)
-		return ret;
-
 	st->pwrdown_gpio = devm_gpiod_get_optional(&spi->dev, "powerdown",
 						   GPIOD_OUT_LOW);
 	if (IS_ERR(st->pwrdown_gpio))
diff --git a/drivers/iio/adc/ingenic-adc.c b/drivers/iio/adc/ingenic-adc.c
index 2b3912c6ca6b..b6433bcd53f5 100644
--- a/drivers/iio/adc/ingenic-adc.c
+++ b/drivers/iio/adc/ingenic-adc.c
@@ -732,11 +732,6 @@ static int ingenic_adc_of_xlate(struct iio_dev *iio_dev,
 	return -EINVAL;
 }
 
-static void ingenic_adc_clk_cleanup(void *data)
-{
-	clk_unprepare(data);
-}
-
 static const struct iio_info ingenic_adc_info = {
 	.write_raw = ingenic_adc_write_raw,
 	.read_raw = ingenic_adc_read_raw,
@@ -856,13 +851,13 @@ static int ingenic_adc_probe(struct platform_device *pdev)
 	if (IS_ERR(adc->base))
 		return PTR_ERR(adc->base);
 
-	adc->clk = devm_clk_get(dev, "adc");
+	adc->clk = devm_clk_get_prepared(dev, "adc");
 	if (IS_ERR(adc->clk)) {
 		dev_err(dev, "Unable to get clock\n");
 		return PTR_ERR(adc->clk);
 	}
 
-	ret = clk_prepare_enable(adc->clk);
+	ret = clk_enable(adc->clk);
 	if (ret) {
 		dev_err(dev, "Failed to enable clock\n");
 		return ret;
@@ -891,12 +886,6 @@ static int ingenic_adc_probe(struct platform_device *pdev)
 	usleep_range(2000, 3000); /* Must wait at least 2ms. */
 	clk_disable(adc->clk);
 
-	ret = devm_add_action_or_reset(dev, ingenic_adc_clk_cleanup, adc->clk);
-	if (ret) {
-		dev_err(dev, "Unable to add action\n");
-		return ret;
-	}
-
 	iio_dev->name = "jz-adc";
 	iio_dev->modes = INDIO_DIRECT_MODE | INDIO_BUFFER_SOFTWARE;
 	iio_dev->setup_ops = &ingenic_buffer_setup_ops;
diff --git a/drivers/iio/adc/lpc18xx_adc.c b/drivers/iio/adc/lpc18xx_adc.c
index ae9c9384f23e..8bbc18aaa474 100644
--- a/drivers/iio/adc/lpc18xx_adc.c
+++ b/drivers/iio/adc/lpc18xx_adc.c
@@ -122,11 +122,6 @@ static void lpc18xx_clear_cr_reg(void *data)
 	writel(0, adc->base + LPC18XX_ADC_CR);
 }
 
-static void lpc18xx_clk_disable(void *clk)
-{
-	clk_disable_unprepare(clk);
-}
-
 static void lpc18xx_regulator_disable(void *vref)
 {
 	regulator_disable(vref);
@@ -152,7 +147,7 @@ static int lpc18xx_adc_probe(struct platform_device *pdev)
 	if (IS_ERR(adc->base))
 		return PTR_ERR(adc->base);
 
-	adc->clk = devm_clk_get(&pdev->dev, NULL);
+	adc->clk = devm_clk_get_enabled(&pdev->dev, NULL);
 	if (IS_ERR(adc->clk))
 		return dev_err_probe(&pdev->dev, PTR_ERR(adc->clk),
 				     "error getting clock\n");
@@ -178,17 +173,6 @@ static int lpc18xx_adc_probe(struct platform_device *pdev)
 	if (ret)
 		return ret;
 
-	ret = clk_prepare_enable(adc->clk);
-	if (ret) {
-		dev_err(&pdev->dev, "unable to enable clock\n");
-		return ret;
-	}
-
-	ret = devm_add_action_or_reset(&pdev->dev, lpc18xx_clk_disable,
-				       adc->clk);
-	if (ret)
-		return ret;
-
 	rate = clk_get_rate(adc->clk);
 	clkdiv = DIV_ROUND_UP(rate, LPC18XX_ADC_CLK_TARGET);
 
diff --git a/drivers/iio/adc/rockchip_saradc.c b/drivers/iio/adc/rockchip_saradc.c
index 14b8df4ca9c8..0a053e8b2483 100644
--- a/drivers/iio/adc/rockchip_saradc.c
+++ b/drivers/iio/adc/rockchip_saradc.c
@@ -233,20 +233,6 @@ static void rockchip_saradc_reset_controller(struct reset_control *reset)
 	reset_control_deassert(reset);
 }
 
-static void rockchip_saradc_clk_disable(void *data)
-{
-	struct rockchip_saradc *info = data;
-
-	clk_disable_unprepare(info->clk);
-}
-
-static void rockchip_saradc_pclk_disable(void *data)
-{
-	struct rockchip_saradc *info = data;
-
-	clk_disable_unprepare(info->pclk);
-}
-
 static void rockchip_saradc_regulator_disable(void *data)
 {
 	struct rockchip_saradc *info = data;
@@ -380,12 +366,12 @@ static int rockchip_saradc_probe(struct platform_device *pdev)
 		return ret;
 	}
 
-	info->pclk = devm_clk_get(&pdev->dev, "apb_pclk");
+	info->pclk = devm_clk_get_enabled(&pdev->dev, "apb_pclk");
 	if (IS_ERR(info->pclk))
 		return dev_err_probe(&pdev->dev, PTR_ERR(info->pclk),
 				     "failed to get pclk\n");
 
-	info->clk = devm_clk_get(&pdev->dev, "saradc");
+	info->clk = devm_clk_get_enabled(&pdev->dev, "saradc");
 	if (IS_ERR(info->clk))
 		return dev_err_probe(&pdev->dev, PTR_ERR(info->clk),
 				     "failed to get adc clock\n");
@@ -427,32 +413,6 @@ static int rockchip_saradc_probe(struct platform_device *pdev)
 
 	info->uv_vref = ret;
 
-	ret = clk_prepare_enable(info->pclk);
-	if (ret < 0) {
-		dev_err(&pdev->dev, "failed to enable pclk\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(&pdev->dev,
-				       rockchip_saradc_pclk_disable, info);
-	if (ret) {
-		dev_err(&pdev->dev, "failed to register devm action, %d\n",
-			ret);
-		return ret;
-	}
-
-	ret = clk_prepare_enable(info->clk);
-	if (ret < 0) {
-		dev_err(&pdev->dev, "failed to enable converter clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(&pdev->dev,
-				       rockchip_saradc_clk_disable, info);
-	if (ret) {
-		dev_err(&pdev->dev, "failed to register devm action, %d\n",
-			ret);
-		return ret;
-	}
-
 	platform_set_drvdata(pdev, indio_dev);
 
 	indio_dev->name = dev_name(&pdev->dev);
diff --git a/drivers/iio/adc/ti-ads131e08.c b/drivers/iio/adc/ti-ads131e08.c
index 0c2025a22575..7d7a8f0d3ab5 100644
--- a/drivers/iio/adc/ti-ads131e08.c
+++ b/drivers/iio/adc/ti-ads131e08.c
@@ -793,13 +793,6 @@ static void ads131e08_regulator_disable(void *data)
 	regulator_disable(st->vref_reg);
 }
 
-static void ads131e08_clk_disable(void *data)
-{
-	struct ads131e08_state *st = data;
-
-	clk_disable_unprepare(st->adc_clk);
-}
-
 static int ads131e08_probe(struct spi_device *spi)
 {
 	const struct ads131e08_info *info;
@@ -892,21 +885,11 @@ static int ads131e08_probe(struct spi_device *spi)
 		st->vref_reg = NULL;
 	}
 
-	st->adc_clk = devm_clk_get(&spi->dev, "adc-clk");
+	st->adc_clk = devm_clk_get_enabled(&spi->dev, "adc-clk");
 	if (IS_ERR(st->adc_clk))
 		return dev_err_probe(&spi->dev, PTR_ERR(st->adc_clk),
 				     "failed to get the ADC clock\n");
 
-	ret = clk_prepare_enable(st->adc_clk);
-	if (ret) {
-		dev_err(&spi->dev, "failed to prepare/enable the ADC clock\n");
-		return ret;
-	}
-
-	ret = devm_add_action_or_reset(&spi->dev, ads131e08_clk_disable, st);
-	if (ret)
-		return ret;
-
 	adc_clk_hz = clk_get_rate(st->adc_clk);
 	if (!adc_clk_hz) {
 		dev_err(&spi->dev, "failed to get the ADC clock rate\n");
diff --git a/drivers/iio/adc/xilinx-ams.c b/drivers/iio/adc/xilinx-ams.c
index 8343c5f74121..4e4f0c80db54 100644
--- a/drivers/iio/adc/xilinx-ams.c
+++ b/drivers/iio/adc/xilinx-ams.c
@@ -1343,11 +1343,6 @@ static const struct of_device_id ams_of_match_table[] = {
 };
 MODULE_DEVICE_TABLE(of, ams_of_match_table);
 
-static void ams_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static void ams_cancel_delayed_work(void *data)
 {
 	cancel_delayed_work(data);
@@ -1377,18 +1372,10 @@ static int ams_probe(struct platform_device *pdev)
 	if (IS_ERR(ams->base))
 		return PTR_ERR(ams->base);
 
-	ams->clk = devm_clk_get(&pdev->dev, NULL);
+	ams->clk = devm_clk_get_enabled(&pdev->dev, NULL);
 	if (IS_ERR(ams->clk))
 		return PTR_ERR(ams->clk);
 
-	ret = clk_prepare_enable(ams->clk);
-	if (ret < 0)
-		return ret;
-
-	ret = devm_add_action_or_reset(&pdev->dev, ams_clk_disable_unprepare, ams->clk);
-	if (ret < 0)
-		return ret;
-
 	INIT_DELAYED_WORK(&ams->ams_unmask_work, ams_unmask_worker);
 	ret = devm_add_action_or_reset(&pdev->dev, ams_cancel_delayed_work,
 				       &ams->ams_unmask_work);
diff --git a/drivers/iio/adc/xilinx-xadc-core.c b/drivers/iio/adc/xilinx-xadc-core.c
index 823c8e5f9809..a520e07e4e08 100644
--- a/drivers/iio/adc/xilinx-xadc-core.c
+++ b/drivers/iio/adc/xilinx-xadc-core.c
@@ -1299,13 +1299,6 @@ static const char * const xadc_type_names[] = {
 	[XADC_TYPE_US] = "xilinx-system-monitor",
 };
 
-static void xadc_clk_disable_unprepare(void *data)
-{
-	struct clk *clk = data;
-
-	clk_disable_unprepare(clk);
-}
-
 static void xadc_cancel_delayed_work(void *data)
 {
 	struct delayed_work *work = data;
@@ -1383,19 +1376,10 @@ static int xadc_probe(struct platform_device *pdev)
 		}
 	}
 
-	xadc->clk = devm_clk_get(dev, NULL);
+	xadc->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(xadc->clk))
 		return PTR_ERR(xadc->clk);
 
-	ret = clk_prepare_enable(xadc->clk);
-	if (ret)
-		return ret;
-
-	ret = devm_add_action_or_reset(dev,
-				       xadc_clk_disable_unprepare, xadc->clk);
-	if (ret)
-		return ret;
-
 	/*
 	 * Make sure not to exceed the maximum samplerate since otherwise the
 	 * resulting interrupt storm will soft-lock the system.
diff --git a/drivers/iio/frequency/adf4371.c b/drivers/iio/frequency/adf4371.c
index ecd5e18995ad..54040b5fded0 100644
--- a/drivers/iio/frequency/adf4371.c
+++ b/drivers/iio/frequency/adf4371.c
@@ -540,13 +540,6 @@ static int adf4371_setup(struct adf4371_state *st)
 	return regmap_bulk_write(st->regmap, ADF4371_REG(0x30), st->buf, 5);
 }
 
-static void adf4371_clk_disable(void *data)
-{
-	struct adf4371_state *st = data;
-
-	clk_disable_unprepare(st->clkin);
-}
-
 static int adf4371_probe(struct spi_device *spi)
 {
 	const struct spi_device_id *id = spi_get_device_id(spi);
@@ -579,18 +572,10 @@ static int adf4371_probe(struct spi_device *spi)
 	indio_dev->channels = st->chip_info->channels;
 	indio_dev->num_channels = st->chip_info->num_channels;
 
-	st->clkin = devm_clk_get(&spi->dev, "clkin");
+	st->clkin = devm_clk_get_enabled(&spi->dev, "clkin");
 	if (IS_ERR(st->clkin))
 		return PTR_ERR(st->clkin);
 
-	ret = clk_prepare_enable(st->clkin);
-	if (ret < 0)
-		return ret;
-
-	ret = devm_add_action_or_reset(&spi->dev, adf4371_clk_disable, st);
-	if (ret)
-		return ret;
-
 	st->clkin_freq = clk_get_rate(st->clkin);
 
 	ret = adf4371_setup(st);
diff --git a/drivers/iio/frequency/admv1013.c b/drivers/iio/frequency/admv1013.c
index 3f3c478e9baa..b3e7eb322ade 100644
--- a/drivers/iio/frequency/admv1013.c
+++ b/drivers/iio/frequency/admv1013.c
@@ -490,11 +490,6 @@ static int admv1013_init(struct admv1013_state *st)
 					  st->input_mode);
 }
 
-static void admv1013_clk_disable(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static void admv1013_reg_disable(void *data)
 {
 	regulator_disable(data);
@@ -559,7 +554,7 @@ static int admv1013_properties_parse(struct admv1013_state *st)
 		return dev_err_probe(&spi->dev, PTR_ERR(st->reg),
 				     "failed to get the common-mode voltage\n");
 
-	st->clkin = devm_clk_get(&spi->dev, "lo_in");
+	st->clkin = devm_clk_get_enabled(&spi->dev, "lo_in");
 	if (IS_ERR(st->clkin))
 		return dev_err_probe(&spi->dev, PTR_ERR(st->clkin),
 				     "failed to get the LO input clock\n");
@@ -601,14 +596,6 @@ static int admv1013_probe(struct spi_device *spi)
 	if (ret)
 		return ret;
 
-	ret = clk_prepare_enable(st->clkin);
-	if (ret)
-		return ret;
-
-	ret = devm_add_action_or_reset(&spi->dev, admv1013_clk_disable, st->clkin);
-	if (ret)
-		return ret;
-
 	st->nb.notifier_call = admv1013_freq_change;
 	ret = devm_clk_notifier_register(&spi->dev, st->clkin, &st->nb);
 	if (ret)
diff --git a/drivers/iio/frequency/adrf6780.c b/drivers/iio/frequency/adrf6780.c
index 8255ffd174f6..d7bf34ceedd8 100644
--- a/drivers/iio/frequency/adrf6780.c
+++ b/drivers/iio/frequency/adrf6780.c
@@ -441,11 +441,6 @@ static void adrf6780_properties_parse(struct adrf6780_state *st)
 	st->vdet_out_en = device_property_read_bool(&spi->dev, "adi,vdet-out-en");
 }
 
-static void adrf6780_clk_disable(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static void adrf6780_powerdown(void *data)
 {
 	/* Disable all components in the Enable Register */
@@ -473,20 +468,11 @@ static int adrf6780_probe(struct spi_device *spi)
 
 	adrf6780_properties_parse(st);
 
-	st->clkin = devm_clk_get(&spi->dev, "lo_in");
+	st->clkin = devm_clk_get_enabled(&spi->dev, "lo_in");
 	if (IS_ERR(st->clkin))
 		return dev_err_probe(&spi->dev, PTR_ERR(st->clkin),
 				     "failed to get the LO input clock\n");
 
-	ret = clk_prepare_enable(st->clkin);
-	if (ret)
-		return ret;
-
-	ret = devm_add_action_or_reset(&spi->dev, adrf6780_clk_disable,
-				       st->clkin);
-	if (ret)
-		return ret;
-
 	mutex_init(&st->lock);
 
 	ret = adrf6780_init(st);
diff --git a/drivers/iio/imu/adis16475.c b/drivers/iio/imu/adis16475.c
index ea91d127077d..45a8765d7c16 100644
--- a/drivers/iio/imu/adis16475.c
+++ b/drivers/iio/imu/adis16475.c
@@ -1120,11 +1120,6 @@ static irqreturn_t adis16475_trigger_handler(int irq, void *p)
 	return IRQ_HANDLED;
 }
 
-static void adis16475_disable_clk(void *data)
-{
-	clk_disable_unprepare((struct clk *)data);
-}
-
 static int adis16475_config_sync_mode(struct adis16475 *st)
 {
 	int ret;
@@ -1150,19 +1145,11 @@ static int adis16475_config_sync_mode(struct adis16475 *st)
 
 	/* All the other modes require external input signal */
 	if (sync->sync_mode != ADIS16475_SYNC_OUTPUT) {
-		struct clk *clk = devm_clk_get(dev, NULL);
+		struct clk *clk = devm_clk_get_enabled(dev, NULL);
 
 		if (IS_ERR(clk))
 			return PTR_ERR(clk);
 
-		ret = clk_prepare_enable(clk);
-		if (ret)
-			return ret;
-
-		ret = devm_add_action_or_reset(dev, adis16475_disable_clk, clk);
-		if (ret)
-			return ret;
-
 		st->clk_freq = clk_get_rate(clk);
 		if (st->clk_freq < sync->min_rate ||
 		    st->clk_freq > sync->max_rate) {
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

RE: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()

[Sa, Nuno]

> From: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> Sent: Monday, March 14, 2022 3:17 PM
> To: Michael Turquette <mturquette@baylibre.com>; Stephen Boyd
> <sboyd@kernel.org>; Russell King <linux@armlinux.org.uk>; Lars-
> Peter Clausen <lars@metafoo.de>; Hennerich, Michael
> <Michael.Hennerich@analog.com>; Jonathan Cameron
> <jic23@kernel.org>
> Cc: linux-clk@vger.kernel.org; kernel@pengutronix.de; Paul Cercueil
> <paul@crapouillou.net>; Vladimir Zapolskiy <vz@mleia.com>; Heiko
> Stuebner <heiko@sntech.de>; Tomislav Denis
> <tomislav.denis@avl.com>; Anand Ashok Dumbre
> <anand.ashok.dumbre@xilinx.com>; Michal Simek
> <michal.simek@xilinx.com>; Sa, Nuno <Nuno.Sa@analog.com>; André
> Gustavo Nakagomi Lopez <andregnl@usp.br>; Cai Huoqing
> <caihuoqing@baidu.com>; linux-iio@vger.kernel.org; linux-arm-
> kernel@lists.infradead.org
> Subject: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
> 
> [External]
> 
> Several drivers manually register a devm handler to disable their clk.
> Convert them to devm_clk_get_enabled().
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> ---

I do think this is a very nice cleanup. I can see the same thing being
done for, say, regulators (maybe)...

Reviewed-by: Nuno Sá <nuno.sa@analog.com>

>  drivers/iio/adc/ad7124.c           | 15 +---------
>  drivers/iio/adc/ad7768-1.c         | 17 +-----------
>  drivers/iio/adc/ad9467.c           | 17 +-----------
>  drivers/iio/adc/ingenic-adc.c      | 15 ++--------
>  drivers/iio/adc/lpc18xx_adc.c      | 18 +-----------
>  drivers/iio/adc/rockchip_saradc.c  | 44 ++----------------------------
>  drivers/iio/adc/ti-ads131e08.c     | 19 +------------
>  drivers/iio/adc/xilinx-ams.c       | 15 +---------
>  drivers/iio/adc/xilinx-xadc-core.c | 18 +-----------
>  drivers/iio/frequency/adf4371.c    | 17 +-----------
>  drivers/iio/frequency/admv1013.c   | 15 +---------
>  drivers/iio/frequency/adrf6780.c   | 16 +----------
>  drivers/iio/imu/adis16475.c        | 15 +---------
>  13 files changed, 15 insertions(+), 226 deletions(-)
> 
> diff --git a/drivers/iio/adc/ad7124.c b/drivers/iio/adc/ad7124.c
> index b400bbe291aa..fcfa4e0b41fb 100644
> --- a/drivers/iio/adc/ad7124.c
> +++ b/drivers/iio/adc/ad7124.c
> @@ -862,11 +862,6 @@ static void ad7124_reg_disable(void *r)
>  	regulator_disable(r);
>  }
> 
> -static void ad7124_clk_disable(void *c)
> -{
> -	clk_disable_unprepare(c);
> -}
> -
>  static int ad7124_probe(struct spi_device *spi)
>  {
>  	const struct ad7124_chip_info *info;
> @@ -917,18 +912,10 @@ static int ad7124_probe(struct spi_device
> *spi)
>  			return ret;
>  	}
> 
> -	st->mclk = devm_clk_get(&spi->dev, "mclk");
> +	st->mclk = devm_clk_get_enabled(&spi->dev, "mclk");
>  	if (IS_ERR(st->mclk))
>  		return PTR_ERR(st->mclk);
> 
> -	ret = clk_prepare_enable(st->mclk);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev,
> ad7124_clk_disable, st->mclk);
> -	if (ret)
> -		return ret;
> -
>  	ret = ad7124_soft_reset(st);
>  	if (ret < 0)
>  		return ret;
> diff --git a/drivers/iio/adc/ad7768-1.c b/drivers/iio/adc/ad7768-1.c
> index aa42ba759fa1..8ae34ed8fabd 100644
> --- a/drivers/iio/adc/ad7768-1.c
> +++ b/drivers/iio/adc/ad7768-1.c
> @@ -539,13 +539,6 @@ static void ad7768_regulator_disable(void
> *data)
>  	regulator_disable(st->vref);
>  }
> 
> -static void ad7768_clk_disable(void *data)
> -{
> -	struct ad7768_state *st = data;
> -
> -	clk_disable_unprepare(st->mclk);
> -}
> -
>  static int ad7768_set_channel_label(struct iio_dev *indio_dev,
>  						int num_channels)
>  {
> @@ -600,18 +593,10 @@ static int ad7768_probe(struct spi_device
> *spi)
>  	if (ret)
>  		return ret;
> 
> -	st->mclk = devm_clk_get(&spi->dev, "mclk");
> +	st->mclk = devm_clk_get_enabled(&spi->dev, "mclk");
>  	if (IS_ERR(st->mclk))
>  		return PTR_ERR(st->mclk);
> 
> -	ret = clk_prepare_enable(st->mclk);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev,
> ad7768_clk_disable, st);
> -	if (ret)
> -		return ret;
> -
>  	st->mclk_freq = clk_get_rate(st->mclk);
> 
>  	mutex_init(&st->lock);
> diff --git a/drivers/iio/adc/ad9467.c b/drivers/iio/adc/ad9467.c
> index dbfc8517cb8a..a07df0fd3329 100644
> --- a/drivers/iio/adc/ad9467.c
> +++ b/drivers/iio/adc/ad9467.c
> @@ -378,13 +378,6 @@ static int ad9467_preenable_setup(struct
> adi_axi_adc_conv *conv)
>  	return ad9467_outputmode_set(st->spi, st->output_mode);
>  }
> 
> -static void ad9467_clk_disable(void *data)
> -{
> -	struct ad9467_state *st = data;
> -
> -	clk_disable_unprepare(st->clk);
> -}
> -
>  static int ad9467_probe(struct spi_device *spi)
>  {
>  	const struct ad9467_chip_info *info;
> @@ -404,18 +397,10 @@ static int ad9467_probe(struct spi_device
> *spi)
>  	st = adi_axi_adc_conv_priv(conv);
>  	st->spi = spi;
> 
> -	st->clk = devm_clk_get(&spi->dev, "adc-clk");
> +	st->clk = devm_clk_get_enabled(&spi->dev, "adc-clk");
>  	if (IS_ERR(st->clk))
>  		return PTR_ERR(st->clk);
> 
> -	ret = clk_prepare_enable(st->clk);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev,
> ad9467_clk_disable, st);
> -	if (ret)
> -		return ret;
> -
>  	st->pwrdown_gpio = devm_gpiod_get_optional(&spi->dev,
> "powerdown",
>  						   GPIOD_OUT_LOW);
>  	if (IS_ERR(st->pwrdown_gpio))
> diff --git a/drivers/iio/adc/ingenic-adc.c b/drivers/iio/adc/ingenic-adc.c
> index 2b3912c6ca6b..b6433bcd53f5 100644
> --- a/drivers/iio/adc/ingenic-adc.c
> +++ b/drivers/iio/adc/ingenic-adc.c
> @@ -732,11 +732,6 @@ static int ingenic_adc_of_xlate(struct iio_dev
> *iio_dev,
>  	return -EINVAL;
>  }
> 
> -static void ingenic_adc_clk_cleanup(void *data)
> -{
> -	clk_unprepare(data);
> -}
> -
>  static const struct iio_info ingenic_adc_info = {
>  	.write_raw = ingenic_adc_write_raw,
>  	.read_raw = ingenic_adc_read_raw,
> @@ -856,13 +851,13 @@ static int ingenic_adc_probe(struct
> platform_device *pdev)
>  	if (IS_ERR(adc->base))
>  		return PTR_ERR(adc->base);
> 
> -	adc->clk = devm_clk_get(dev, "adc");
> +	adc->clk = devm_clk_get_prepared(dev, "adc");
>  	if (IS_ERR(adc->clk)) {
>  		dev_err(dev, "Unable to get clock\n");
>  		return PTR_ERR(adc->clk);
>  	}
> 
> -	ret = clk_prepare_enable(adc->clk);
> +	ret = clk_enable(adc->clk);
>  	if (ret) {
>  		dev_err(dev, "Failed to enable clock\n");
>  		return ret;
> @@ -891,12 +886,6 @@ static int ingenic_adc_probe(struct
> platform_device *pdev)
>  	usleep_range(2000, 3000); /* Must wait at least 2ms. */
>  	clk_disable(adc->clk);
> 
> -	ret = devm_add_action_or_reset(dev,
> ingenic_adc_clk_cleanup, adc->clk);
> -	if (ret) {
> -		dev_err(dev, "Unable to add action\n");
> -		return ret;
> -	}
> -
>  	iio_dev->name = "jz-adc";
>  	iio_dev->modes = INDIO_DIRECT_MODE |
> INDIO_BUFFER_SOFTWARE;
>  	iio_dev->setup_ops = &ingenic_buffer_setup_ops;
> diff --git a/drivers/iio/adc/lpc18xx_adc.c
> b/drivers/iio/adc/lpc18xx_adc.c
> index ae9c9384f23e..8bbc18aaa474 100644
> --- a/drivers/iio/adc/lpc18xx_adc.c
> +++ b/drivers/iio/adc/lpc18xx_adc.c
> @@ -122,11 +122,6 @@ static void lpc18xx_clear_cr_reg(void *data)
>  	writel(0, adc->base + LPC18XX_ADC_CR);
>  }
> 
> -static void lpc18xx_clk_disable(void *clk)
> -{
> -	clk_disable_unprepare(clk);
> -}
> -
>  static void lpc18xx_regulator_disable(void *vref)
>  {
>  	regulator_disable(vref);
> @@ -152,7 +147,7 @@ static int lpc18xx_adc_probe(struct
> platform_device *pdev)
>  	if (IS_ERR(adc->base))
>  		return PTR_ERR(adc->base);
> 
> -	adc->clk = devm_clk_get(&pdev->dev, NULL);
> +	adc->clk = devm_clk_get_enabled(&pdev->dev, NULL);
>  	if (IS_ERR(adc->clk))
>  		return dev_err_probe(&pdev->dev, PTR_ERR(adc-
> >clk),
>  				     "error getting clock\n");
> @@ -178,17 +173,6 @@ static int lpc18xx_adc_probe(struct
> platform_device *pdev)
>  	if (ret)
>  		return ret;
> 
> -	ret = clk_prepare_enable(adc->clk);
> -	if (ret) {
> -		dev_err(&pdev->dev, "unable to enable clock\n");
> -		return ret;
> -	}
> -
> -	ret = devm_add_action_or_reset(&pdev->dev,
> lpc18xx_clk_disable,
> -				       adc->clk);
> -	if (ret)
> -		return ret;
> -
>  	rate = clk_get_rate(adc->clk);
>  	clkdiv = DIV_ROUND_UP(rate, LPC18XX_ADC_CLK_TARGET);
> 
> diff --git a/drivers/iio/adc/rockchip_saradc.c
> b/drivers/iio/adc/rockchip_saradc.c
> index 14b8df4ca9c8..0a053e8b2483 100644
> --- a/drivers/iio/adc/rockchip_saradc.c
> +++ b/drivers/iio/adc/rockchip_saradc.c
> @@ -233,20 +233,6 @@ static void
> rockchip_saradc_reset_controller(struct reset_control *reset)
>  	reset_control_deassert(reset);
>  }
> 
> -static void rockchip_saradc_clk_disable(void *data)
> -{
> -	struct rockchip_saradc *info = data;
> -
> -	clk_disable_unprepare(info->clk);
> -}
> -
> -static void rockchip_saradc_pclk_disable(void *data)
> -{
> -	struct rockchip_saradc *info = data;
> -
> -	clk_disable_unprepare(info->pclk);
> -}
> -
>  static void rockchip_saradc_regulator_disable(void *data)
>  {
>  	struct rockchip_saradc *info = data;
> @@ -380,12 +366,12 @@ static int rockchip_saradc_probe(struct
> platform_device *pdev)
>  		return ret;
>  	}
> 
> -	info->pclk = devm_clk_get(&pdev->dev, "apb_pclk");
> +	info->pclk = devm_clk_get_enabled(&pdev->dev, "apb_pclk");
>  	if (IS_ERR(info->pclk))
>  		return dev_err_probe(&pdev->dev, PTR_ERR(info-
> >pclk),
>  				     "failed to get pclk\n");
> 
> -	info->clk = devm_clk_get(&pdev->dev, "saradc");
> +	info->clk = devm_clk_get_enabled(&pdev->dev, "saradc");
>  	if (IS_ERR(info->clk))
>  		return dev_err_probe(&pdev->dev, PTR_ERR(info-
> >clk),
>  				     "failed to get adc clock\n");
> @@ -427,32 +413,6 @@ static int rockchip_saradc_probe(struct
> platform_device *pdev)
> 
>  	info->uv_vref = ret;
> 
> -	ret = clk_prepare_enable(info->pclk);
> -	if (ret < 0) {
> -		dev_err(&pdev->dev, "failed to enable pclk\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(&pdev->dev,
> -				       rockchip_saradc_pclk_disable, info);
> -	if (ret) {
> -		dev_err(&pdev->dev, "failed to register devm action,
> %d\n",
> -			ret);
> -		return ret;
> -	}
> -
> -	ret = clk_prepare_enable(info->clk);
> -	if (ret < 0) {
> -		dev_err(&pdev->dev, "failed to enable converter
> clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(&pdev->dev,
> -				       rockchip_saradc_clk_disable, info);
> -	if (ret) {
> -		dev_err(&pdev->dev, "failed to register devm action,
> %d\n",
> -			ret);
> -		return ret;
> -	}
> -
>  	platform_set_drvdata(pdev, indio_dev);
> 
>  	indio_dev->name = dev_name(&pdev->dev);
> diff --git a/drivers/iio/adc/ti-ads131e08.c b/drivers/iio/adc/ti-
> ads131e08.c
> index 0c2025a22575..7d7a8f0d3ab5 100644
> --- a/drivers/iio/adc/ti-ads131e08.c
> +++ b/drivers/iio/adc/ti-ads131e08.c
> @@ -793,13 +793,6 @@ static void ads131e08_regulator_disable(void
> *data)
>  	regulator_disable(st->vref_reg);
>  }
> 
> -static void ads131e08_clk_disable(void *data)
> -{
> -	struct ads131e08_state *st = data;
> -
> -	clk_disable_unprepare(st->adc_clk);
> -}
> -
>  static int ads131e08_probe(struct spi_device *spi)
>  {
>  	const struct ads131e08_info *info;
> @@ -892,21 +885,11 @@ static int ads131e08_probe(struct spi_device
> *spi)
>  		st->vref_reg = NULL;
>  	}
> 
> -	st->adc_clk = devm_clk_get(&spi->dev, "adc-clk");
> +	st->adc_clk = devm_clk_get_enabled(&spi->dev, "adc-clk");
>  	if (IS_ERR(st->adc_clk))
>  		return dev_err_probe(&spi->dev, PTR_ERR(st-
> >adc_clk),
>  				     "failed to get the ADC clock\n");
> 
> -	ret = clk_prepare_enable(st->adc_clk);
> -	if (ret) {
> -		dev_err(&spi->dev, "failed to prepare/enable the ADC
> clock\n");
> -		return ret;
> -	}
> -
> -	ret = devm_add_action_or_reset(&spi->dev,
> ads131e08_clk_disable, st);
> -	if (ret)
> -		return ret;
> -
>  	adc_clk_hz = clk_get_rate(st->adc_clk);
>  	if (!adc_clk_hz) {
>  		dev_err(&spi->dev, "failed to get the ADC clock
> rate\n");
> diff --git a/drivers/iio/adc/xilinx-ams.c b/drivers/iio/adc/xilinx-ams.c
> index 8343c5f74121..4e4f0c80db54 100644
> --- a/drivers/iio/adc/xilinx-ams.c
> +++ b/drivers/iio/adc/xilinx-ams.c
> @@ -1343,11 +1343,6 @@ static const struct of_device_id
> ams_of_match_table[] = {
>  };
>  MODULE_DEVICE_TABLE(of, ams_of_match_table);
> 
> -static void ams_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static void ams_cancel_delayed_work(void *data)
>  {
>  	cancel_delayed_work(data);
> @@ -1377,18 +1372,10 @@ static int ams_probe(struct
> platform_device *pdev)
>  	if (IS_ERR(ams->base))
>  		return PTR_ERR(ams->base);
> 
> -	ams->clk = devm_clk_get(&pdev->dev, NULL);
> +	ams->clk = devm_clk_get_enabled(&pdev->dev, NULL);
>  	if (IS_ERR(ams->clk))
>  		return PTR_ERR(ams->clk);
> 
> -	ret = clk_prepare_enable(ams->clk);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&pdev->dev,
> ams_clk_disable_unprepare, ams->clk);
> -	if (ret < 0)
> -		return ret;
> -
>  	INIT_DELAYED_WORK(&ams->ams_unmask_work,
> ams_unmask_worker);
>  	ret = devm_add_action_or_reset(&pdev->dev,
> ams_cancel_delayed_work,
>  				       &ams->ams_unmask_work);
> diff --git a/drivers/iio/adc/xilinx-xadc-core.c b/drivers/iio/adc/xilinx-
> xadc-core.c
> index 823c8e5f9809..a520e07e4e08 100644
> --- a/drivers/iio/adc/xilinx-xadc-core.c
> +++ b/drivers/iio/adc/xilinx-xadc-core.c
> @@ -1299,13 +1299,6 @@ static const char * const xadc_type_names[]
> = {
>  	[XADC_TYPE_US] = "xilinx-system-monitor",
>  };
> 
> -static void xadc_clk_disable_unprepare(void *data)
> -{
> -	struct clk *clk = data;
> -
> -	clk_disable_unprepare(clk);
> -}
> -
>  static void xadc_cancel_delayed_work(void *data)
>  {
>  	struct delayed_work *work = data;
> @@ -1383,19 +1376,10 @@ static int xadc_probe(struct
> platform_device *pdev)
>  		}
>  	}
> 
> -	xadc->clk = devm_clk_get(dev, NULL);
> +	xadc->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(xadc->clk))
>  		return PTR_ERR(xadc->clk);
> 
> -	ret = clk_prepare_enable(xadc->clk);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(dev,
> -				       xadc_clk_disable_unprepare, xadc-
> >clk);
> -	if (ret)
> -		return ret;
> -
>  	/*
>  	 * Make sure not to exceed the maximum samplerate since
> otherwise the
>  	 * resulting interrupt storm will soft-lock the system.
> diff --git a/drivers/iio/frequency/adf4371.c
> b/drivers/iio/frequency/adf4371.c
> index ecd5e18995ad..54040b5fded0 100644
> --- a/drivers/iio/frequency/adf4371.c
> +++ b/drivers/iio/frequency/adf4371.c
> @@ -540,13 +540,6 @@ static int adf4371_setup(struct adf4371_state
> *st)
>  	return regmap_bulk_write(st->regmap, ADF4371_REG(0x30),
> st->buf, 5);
>  }
> 
> -static void adf4371_clk_disable(void *data)
> -{
> -	struct adf4371_state *st = data;
> -
> -	clk_disable_unprepare(st->clkin);
> -}
> -
>  static int adf4371_probe(struct spi_device *spi)
>  {
>  	const struct spi_device_id *id = spi_get_device_id(spi);
> @@ -579,18 +572,10 @@ static int adf4371_probe(struct spi_device
> *spi)
>  	indio_dev->channels = st->chip_info->channels;
>  	indio_dev->num_channels = st->chip_info->num_channels;
> 
> -	st->clkin = devm_clk_get(&spi->dev, "clkin");
> +	st->clkin = devm_clk_get_enabled(&spi->dev, "clkin");
>  	if (IS_ERR(st->clkin))
>  		return PTR_ERR(st->clkin);
> 
> -	ret = clk_prepare_enable(st->clkin);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev,
> adf4371_clk_disable, st);
> -	if (ret)
> -		return ret;
> -
>  	st->clkin_freq = clk_get_rate(st->clkin);
> 
>  	ret = adf4371_setup(st);
> diff --git a/drivers/iio/frequency/admv1013.c
> b/drivers/iio/frequency/admv1013.c
> index 3f3c478e9baa..b3e7eb322ade 100644
> --- a/drivers/iio/frequency/admv1013.c
> +++ b/drivers/iio/frequency/admv1013.c
> @@ -490,11 +490,6 @@ static int admv1013_init(struct
> admv1013_state *st)
>  					  st->input_mode);
>  }
> 
> -static void admv1013_clk_disable(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static void admv1013_reg_disable(void *data)
>  {
>  	regulator_disable(data);
> @@ -559,7 +554,7 @@ static int admv1013_properties_parse(struct
> admv1013_state *st)
>  		return dev_err_probe(&spi->dev, PTR_ERR(st->reg),
>  				     "failed to get the common-mode
> voltage\n");
> 
> -	st->clkin = devm_clk_get(&spi->dev, "lo_in");
> +	st->clkin = devm_clk_get_enabled(&spi->dev, "lo_in");
>  	if (IS_ERR(st->clkin))
>  		return dev_err_probe(&spi->dev, PTR_ERR(st->clkin),
>  				     "failed to get the LO input clock\n");
> @@ -601,14 +596,6 @@ static int admv1013_probe(struct spi_device
> *spi)
>  	if (ret)
>  		return ret;
> 
> -	ret = clk_prepare_enable(st->clkin);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev,
> admv1013_clk_disable, st->clkin);
> -	if (ret)
> -		return ret;
> -
>  	st->nb.notifier_call = admv1013_freq_change;
>  	ret = devm_clk_notifier_register(&spi->dev, st->clkin, &st-
> >nb);
>  	if (ret)
> diff --git a/drivers/iio/frequency/adrf6780.c
> b/drivers/iio/frequency/adrf6780.c
> index 8255ffd174f6..d7bf34ceedd8 100644
> --- a/drivers/iio/frequency/adrf6780.c
> +++ b/drivers/iio/frequency/adrf6780.c
> @@ -441,11 +441,6 @@ static void adrf6780_properties_parse(struct
> adrf6780_state *st)
>  	st->vdet_out_en = device_property_read_bool(&spi->dev,
> "adi,vdet-out-en");
>  }
> 
> -static void adrf6780_clk_disable(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static void adrf6780_powerdown(void *data)
>  {
>  	/* Disable all components in the Enable Register */
> @@ -473,20 +468,11 @@ static int adrf6780_probe(struct spi_device
> *spi)
> 
>  	adrf6780_properties_parse(st);
> 
> -	st->clkin = devm_clk_get(&spi->dev, "lo_in");
> +	st->clkin = devm_clk_get_enabled(&spi->dev, "lo_in");
>  	if (IS_ERR(st->clkin))
>  		return dev_err_probe(&spi->dev, PTR_ERR(st->clkin),
>  				     "failed to get the LO input clock\n");
> 
> -	ret = clk_prepare_enable(st->clkin);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev,
> adrf6780_clk_disable,
> -				       st->clkin);
> -	if (ret)
> -		return ret;
> -
>  	mutex_init(&st->lock);
> 
>  	ret = adrf6780_init(st);
> diff --git a/drivers/iio/imu/adis16475.c b/drivers/iio/imu/adis16475.c
> index ea91d127077d..45a8765d7c16 100644
> --- a/drivers/iio/imu/adis16475.c
> +++ b/drivers/iio/imu/adis16475.c
> @@ -1120,11 +1120,6 @@ static irqreturn_t
> adis16475_trigger_handler(int irq, void *p)
>  	return IRQ_HANDLED;
>  }
> 
> -static void adis16475_disable_clk(void *data)
> -{
> -	clk_disable_unprepare((struct clk *)data);
> -}
> -
>  static int adis16475_config_sync_mode(struct adis16475 *st)
>  {
>  	int ret;
> @@ -1150,19 +1145,11 @@ static int
> adis16475_config_sync_mode(struct adis16475 *st)
> 
>  	/* All the other modes require external input signal */
>  	if (sync->sync_mode != ADIS16475_SYNC_OUTPUT) {
> -		struct clk *clk = devm_clk_get(dev, NULL);
> +		struct clk *clk = devm_clk_get_enabled(dev, NULL);
> 
>  		if (IS_ERR(clk))
>  			return PTR_ERR(clk);
> 
> -		ret = clk_prepare_enable(clk);
> -		if (ret)
> -			return ret;
> -
> -		ret = devm_add_action_or_reset(dev,
> adis16475_disable_clk, clk);
> -		if (ret)
> -			return ret;
> -
>  		st->clk_freq = clk_get_rate(clk);
>  		if (st->clk_freq < sync->min_rate ||
>  		    st->clk_freq > sync->max_rate) {
> --
> 2.35.1

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()

[Jonathan Cameron]

On Mon, 14 Mar 2022 15:16:31 +0100
Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:

> Several drivers manually register a devm handler to disable their clk.
> Convert them to devm_clk_get_enabled().
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>

Acked-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

If this does get picked up, can who ever does it please provide
an immutable branch. With some many drivers cleaned up, it's very
likely to cause some merge fun somewhere otherwise.

Thanks,

Jonathan

> ---
>  drivers/iio/adc/ad7124.c           | 15 +---------
>  drivers/iio/adc/ad7768-1.c         | 17 +-----------
>  drivers/iio/adc/ad9467.c           | 17 +-----------
>  drivers/iio/adc/ingenic-adc.c      | 15 ++--------
>  drivers/iio/adc/lpc18xx_adc.c      | 18 +-----------
>  drivers/iio/adc/rockchip_saradc.c  | 44 ++----------------------------
>  drivers/iio/adc/ti-ads131e08.c     | 19 +------------
>  drivers/iio/adc/xilinx-ams.c       | 15 +---------
>  drivers/iio/adc/xilinx-xadc-core.c | 18 +-----------
>  drivers/iio/frequency/adf4371.c    | 17 +-----------
>  drivers/iio/frequency/admv1013.c   | 15 +---------
>  drivers/iio/frequency/adrf6780.c   | 16 +----------
>  drivers/iio/imu/adis16475.c        | 15 +---------
>  13 files changed, 15 insertions(+), 226 deletions(-)
> 
> diff --git a/drivers/iio/adc/ad7124.c b/drivers/iio/adc/ad7124.c
> index b400bbe291aa..fcfa4e0b41fb 100644
> --- a/drivers/iio/adc/ad7124.c
> +++ b/drivers/iio/adc/ad7124.c
> @@ -862,11 +862,6 @@ static void ad7124_reg_disable(void *r)
>  	regulator_disable(r);
>  }
>  
> -static void ad7124_clk_disable(void *c)
> -{
> -	clk_disable_unprepare(c);
> -}
> -
>  static int ad7124_probe(struct spi_device *spi)
>  {
>  	const struct ad7124_chip_info *info;
> @@ -917,18 +912,10 @@ static int ad7124_probe(struct spi_device *spi)
>  			return ret;
>  	}
>  
> -	st->mclk = devm_clk_get(&spi->dev, "mclk");
> +	st->mclk = devm_clk_get_enabled(&spi->dev, "mclk");
>  	if (IS_ERR(st->mclk))
>  		return PTR_ERR(st->mclk);
>  
> -	ret = clk_prepare_enable(st->mclk);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev, ad7124_clk_disable, st->mclk);
> -	if (ret)
> -		return ret;
> -
>  	ret = ad7124_soft_reset(st);
>  	if (ret < 0)
>  		return ret;
> diff --git a/drivers/iio/adc/ad7768-1.c b/drivers/iio/adc/ad7768-1.c
> index aa42ba759fa1..8ae34ed8fabd 100644
> --- a/drivers/iio/adc/ad7768-1.c
> +++ b/drivers/iio/adc/ad7768-1.c
> @@ -539,13 +539,6 @@ static void ad7768_regulator_disable(void *data)
>  	regulator_disable(st->vref);
>  }
>  
> -static void ad7768_clk_disable(void *data)
> -{
> -	struct ad7768_state *st = data;
> -
> -	clk_disable_unprepare(st->mclk);
> -}
> -
>  static int ad7768_set_channel_label(struct iio_dev *indio_dev,
>  						int num_channels)
>  {
> @@ -600,18 +593,10 @@ static int ad7768_probe(struct spi_device *spi)
>  	if (ret)
>  		return ret;
>  
> -	st->mclk = devm_clk_get(&spi->dev, "mclk");
> +	st->mclk = devm_clk_get_enabled(&spi->dev, "mclk");
>  	if (IS_ERR(st->mclk))
>  		return PTR_ERR(st->mclk);
>  
> -	ret = clk_prepare_enable(st->mclk);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev, ad7768_clk_disable, st);
> -	if (ret)
> -		return ret;
> -
>  	st->mclk_freq = clk_get_rate(st->mclk);
>  
>  	mutex_init(&st->lock);
> diff --git a/drivers/iio/adc/ad9467.c b/drivers/iio/adc/ad9467.c
> index dbfc8517cb8a..a07df0fd3329 100644
> --- a/drivers/iio/adc/ad9467.c
> +++ b/drivers/iio/adc/ad9467.c
> @@ -378,13 +378,6 @@ static int ad9467_preenable_setup(struct adi_axi_adc_conv *conv)
>  	return ad9467_outputmode_set(st->spi, st->output_mode);
>  }
>  
> -static void ad9467_clk_disable(void *data)
> -{
> -	struct ad9467_state *st = data;
> -
> -	clk_disable_unprepare(st->clk);
> -}
> -
>  static int ad9467_probe(struct spi_device *spi)
>  {
>  	const struct ad9467_chip_info *info;
> @@ -404,18 +397,10 @@ static int ad9467_probe(struct spi_device *spi)
>  	st = adi_axi_adc_conv_priv(conv);
>  	st->spi = spi;
>  
> -	st->clk = devm_clk_get(&spi->dev, "adc-clk");
> +	st->clk = devm_clk_get_enabled(&spi->dev, "adc-clk");
>  	if (IS_ERR(st->clk))
>  		return PTR_ERR(st->clk);
>  
> -	ret = clk_prepare_enable(st->clk);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev, ad9467_clk_disable, st);
> -	if (ret)
> -		return ret;
> -
>  	st->pwrdown_gpio = devm_gpiod_get_optional(&spi->dev, "powerdown",
>  						   GPIOD_OUT_LOW);
>  	if (IS_ERR(st->pwrdown_gpio))
> diff --git a/drivers/iio/adc/ingenic-adc.c b/drivers/iio/adc/ingenic-adc.c
> index 2b3912c6ca6b..b6433bcd53f5 100644
> --- a/drivers/iio/adc/ingenic-adc.c
> +++ b/drivers/iio/adc/ingenic-adc.c
> @@ -732,11 +732,6 @@ static int ingenic_adc_of_xlate(struct iio_dev *iio_dev,
>  	return -EINVAL;
>  }
>  
> -static void ingenic_adc_clk_cleanup(void *data)
> -{
> -	clk_unprepare(data);
> -}
> -
>  static const struct iio_info ingenic_adc_info = {
>  	.write_raw = ingenic_adc_write_raw,
>  	.read_raw = ingenic_adc_read_raw,
> @@ -856,13 +851,13 @@ static int ingenic_adc_probe(struct platform_device *pdev)
>  	if (IS_ERR(adc->base))
>  		return PTR_ERR(adc->base);
>  
> -	adc->clk = devm_clk_get(dev, "adc");
> +	adc->clk = devm_clk_get_prepared(dev, "adc");
>  	if (IS_ERR(adc->clk)) {
>  		dev_err(dev, "Unable to get clock\n");
>  		return PTR_ERR(adc->clk);
>  	}
>  
> -	ret = clk_prepare_enable(adc->clk);
> +	ret = clk_enable(adc->clk);
>  	if (ret) {
>  		dev_err(dev, "Failed to enable clock\n");
>  		return ret;
> @@ -891,12 +886,6 @@ static int ingenic_adc_probe(struct platform_device *pdev)
>  	usleep_range(2000, 3000); /* Must wait at least 2ms. */
>  	clk_disable(adc->clk);
>  
> -	ret = devm_add_action_or_reset(dev, ingenic_adc_clk_cleanup, adc->clk);
> -	if (ret) {
> -		dev_err(dev, "Unable to add action\n");
> -		return ret;
> -	}
> -
>  	iio_dev->name = "jz-adc";
>  	iio_dev->modes = INDIO_DIRECT_MODE | INDIO_BUFFER_SOFTWARE;
>  	iio_dev->setup_ops = &ingenic_buffer_setup_ops;
> diff --git a/drivers/iio/adc/lpc18xx_adc.c b/drivers/iio/adc/lpc18xx_adc.c
> index ae9c9384f23e..8bbc18aaa474 100644
> --- a/drivers/iio/adc/lpc18xx_adc.c
> +++ b/drivers/iio/adc/lpc18xx_adc.c
> @@ -122,11 +122,6 @@ static void lpc18xx_clear_cr_reg(void *data)
>  	writel(0, adc->base + LPC18XX_ADC_CR);
>  }
>  
> -static void lpc18xx_clk_disable(void *clk)
> -{
> -	clk_disable_unprepare(clk);
> -}
> -
>  static void lpc18xx_regulator_disable(void *vref)
>  {
>  	regulator_disable(vref);
> @@ -152,7 +147,7 @@ static int lpc18xx_adc_probe(struct platform_device *pdev)
>  	if (IS_ERR(adc->base))
>  		return PTR_ERR(adc->base);
>  
> -	adc->clk = devm_clk_get(&pdev->dev, NULL);
> +	adc->clk = devm_clk_get_enabled(&pdev->dev, NULL);
>  	if (IS_ERR(adc->clk))
>  		return dev_err_probe(&pdev->dev, PTR_ERR(adc->clk),
>  				     "error getting clock\n");
> @@ -178,17 +173,6 @@ static int lpc18xx_adc_probe(struct platform_device *pdev)
>  	if (ret)
>  		return ret;
>  
> -	ret = clk_prepare_enable(adc->clk);
> -	if (ret) {
> -		dev_err(&pdev->dev, "unable to enable clock\n");
> -		return ret;
> -	}
> -
> -	ret = devm_add_action_or_reset(&pdev->dev, lpc18xx_clk_disable,
> -				       adc->clk);
> -	if (ret)
> -		return ret;
> -
>  	rate = clk_get_rate(adc->clk);
>  	clkdiv = DIV_ROUND_UP(rate, LPC18XX_ADC_CLK_TARGET);
>  
> diff --git a/drivers/iio/adc/rockchip_saradc.c b/drivers/iio/adc/rockchip_saradc.c
> index 14b8df4ca9c8..0a053e8b2483 100644
> --- a/drivers/iio/adc/rockchip_saradc.c
> +++ b/drivers/iio/adc/rockchip_saradc.c
> @@ -233,20 +233,6 @@ static void rockchip_saradc_reset_controller(struct reset_control *reset)
>  	reset_control_deassert(reset);
>  }
>  
> -static void rockchip_saradc_clk_disable(void *data)
> -{
> -	struct rockchip_saradc *info = data;
> -
> -	clk_disable_unprepare(info->clk);
> -}
> -
> -static void rockchip_saradc_pclk_disable(void *data)
> -{
> -	struct rockchip_saradc *info = data;
> -
> -	clk_disable_unprepare(info->pclk);
> -}
> -
>  static void rockchip_saradc_regulator_disable(void *data)
>  {
>  	struct rockchip_saradc *info = data;
> @@ -380,12 +366,12 @@ static int rockchip_saradc_probe(struct platform_device *pdev)
>  		return ret;
>  	}
>  
> -	info->pclk = devm_clk_get(&pdev->dev, "apb_pclk");
> +	info->pclk = devm_clk_get_enabled(&pdev->dev, "apb_pclk");
>  	if (IS_ERR(info->pclk))
>  		return dev_err_probe(&pdev->dev, PTR_ERR(info->pclk),
>  				     "failed to get pclk\n");
>  
> -	info->clk = devm_clk_get(&pdev->dev, "saradc");
> +	info->clk = devm_clk_get_enabled(&pdev->dev, "saradc");
>  	if (IS_ERR(info->clk))
>  		return dev_err_probe(&pdev->dev, PTR_ERR(info->clk),
>  				     "failed to get adc clock\n");
> @@ -427,32 +413,6 @@ static int rockchip_saradc_probe(struct platform_device *pdev)
>  
>  	info->uv_vref = ret;
>  
> -	ret = clk_prepare_enable(info->pclk);
> -	if (ret < 0) {
> -		dev_err(&pdev->dev, "failed to enable pclk\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(&pdev->dev,
> -				       rockchip_saradc_pclk_disable, info);
> -	if (ret) {
> -		dev_err(&pdev->dev, "failed to register devm action, %d\n",
> -			ret);
> -		return ret;
> -	}
> -
> -	ret = clk_prepare_enable(info->clk);
> -	if (ret < 0) {
> -		dev_err(&pdev->dev, "failed to enable converter clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(&pdev->dev,
> -				       rockchip_saradc_clk_disable, info);
> -	if (ret) {
> -		dev_err(&pdev->dev, "failed to register devm action, %d\n",
> -			ret);
> -		return ret;
> -	}
> -
>  	platform_set_drvdata(pdev, indio_dev);
>  
>  	indio_dev->name = dev_name(&pdev->dev);
> diff --git a/drivers/iio/adc/ti-ads131e08.c b/drivers/iio/adc/ti-ads131e08.c
> index 0c2025a22575..7d7a8f0d3ab5 100644
> --- a/drivers/iio/adc/ti-ads131e08.c
> +++ b/drivers/iio/adc/ti-ads131e08.c
> @@ -793,13 +793,6 @@ static void ads131e08_regulator_disable(void *data)
>  	regulator_disable(st->vref_reg);
>  }
>  
> -static void ads131e08_clk_disable(void *data)
> -{
> -	struct ads131e08_state *st = data;
> -
> -	clk_disable_unprepare(st->adc_clk);
> -}
> -
>  static int ads131e08_probe(struct spi_device *spi)
>  {
>  	const struct ads131e08_info *info;
> @@ -892,21 +885,11 @@ static int ads131e08_probe(struct spi_device *spi)
>  		st->vref_reg = NULL;
>  	}
>  
> -	st->adc_clk = devm_clk_get(&spi->dev, "adc-clk");
> +	st->adc_clk = devm_clk_get_enabled(&spi->dev, "adc-clk");
>  	if (IS_ERR(st->adc_clk))
>  		return dev_err_probe(&spi->dev, PTR_ERR(st->adc_clk),
>  				     "failed to get the ADC clock\n");
>  
> -	ret = clk_prepare_enable(st->adc_clk);
> -	if (ret) {
> -		dev_err(&spi->dev, "failed to prepare/enable the ADC clock\n");
> -		return ret;
> -	}
> -
> -	ret = devm_add_action_or_reset(&spi->dev, ads131e08_clk_disable, st);
> -	if (ret)
> -		return ret;
> -
>  	adc_clk_hz = clk_get_rate(st->adc_clk);
>  	if (!adc_clk_hz) {
>  		dev_err(&spi->dev, "failed to get the ADC clock rate\n");
> diff --git a/drivers/iio/adc/xilinx-ams.c b/drivers/iio/adc/xilinx-ams.c
> index 8343c5f74121..4e4f0c80db54 100644
> --- a/drivers/iio/adc/xilinx-ams.c
> +++ b/drivers/iio/adc/xilinx-ams.c
> @@ -1343,11 +1343,6 @@ static const struct of_device_id ams_of_match_table[] = {
>  };
>  MODULE_DEVICE_TABLE(of, ams_of_match_table);
>  
> -static void ams_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static void ams_cancel_delayed_work(void *data)
>  {
>  	cancel_delayed_work(data);
> @@ -1377,18 +1372,10 @@ static int ams_probe(struct platform_device *pdev)
>  	if (IS_ERR(ams->base))
>  		return PTR_ERR(ams->base);
>  
> -	ams->clk = devm_clk_get(&pdev->dev, NULL);
> +	ams->clk = devm_clk_get_enabled(&pdev->dev, NULL);
>  	if (IS_ERR(ams->clk))
>  		return PTR_ERR(ams->clk);
>  
> -	ret = clk_prepare_enable(ams->clk);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&pdev->dev, ams_clk_disable_unprepare, ams->clk);
> -	if (ret < 0)
> -		return ret;
> -
>  	INIT_DELAYED_WORK(&ams->ams_unmask_work, ams_unmask_worker);
>  	ret = devm_add_action_or_reset(&pdev->dev, ams_cancel_delayed_work,
>  				       &ams->ams_unmask_work);
> diff --git a/drivers/iio/adc/xilinx-xadc-core.c b/drivers/iio/adc/xilinx-xadc-core.c
> index 823c8e5f9809..a520e07e4e08 100644
> --- a/drivers/iio/adc/xilinx-xadc-core.c
> +++ b/drivers/iio/adc/xilinx-xadc-core.c
> @@ -1299,13 +1299,6 @@ static const char * const xadc_type_names[] = {
>  	[XADC_TYPE_US] = "xilinx-system-monitor",
>  };
>  
> -static void xadc_clk_disable_unprepare(void *data)
> -{
> -	struct clk *clk = data;
> -
> -	clk_disable_unprepare(clk);
> -}
> -
>  static void xadc_cancel_delayed_work(void *data)
>  {
>  	struct delayed_work *work = data;
> @@ -1383,19 +1376,10 @@ static int xadc_probe(struct platform_device *pdev)
>  		}
>  	}
>  
> -	xadc->clk = devm_clk_get(dev, NULL);
> +	xadc->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(xadc->clk))
>  		return PTR_ERR(xadc->clk);
>  
> -	ret = clk_prepare_enable(xadc->clk);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(dev,
> -				       xadc_clk_disable_unprepare, xadc->clk);
> -	if (ret)
> -		return ret;
> -
>  	/*
>  	 * Make sure not to exceed the maximum samplerate since otherwise the
>  	 * resulting interrupt storm will soft-lock the system.
> diff --git a/drivers/iio/frequency/adf4371.c b/drivers/iio/frequency/adf4371.c
> index ecd5e18995ad..54040b5fded0 100644
> --- a/drivers/iio/frequency/adf4371.c
> +++ b/drivers/iio/frequency/adf4371.c
> @@ -540,13 +540,6 @@ static int adf4371_setup(struct adf4371_state *st)
>  	return regmap_bulk_write(st->regmap, ADF4371_REG(0x30), st->buf, 5);
>  }
>  
> -static void adf4371_clk_disable(void *data)
> -{
> -	struct adf4371_state *st = data;
> -
> -	clk_disable_unprepare(st->clkin);
> -}
> -
>  static int adf4371_probe(struct spi_device *spi)
>  {
>  	const struct spi_device_id *id = spi_get_device_id(spi);
> @@ -579,18 +572,10 @@ static int adf4371_probe(struct spi_device *spi)
>  	indio_dev->channels = st->chip_info->channels;
>  	indio_dev->num_channels = st->chip_info->num_channels;
>  
> -	st->clkin = devm_clk_get(&spi->dev, "clkin");
> +	st->clkin = devm_clk_get_enabled(&spi->dev, "clkin");
>  	if (IS_ERR(st->clkin))
>  		return PTR_ERR(st->clkin);
>  
> -	ret = clk_prepare_enable(st->clkin);
> -	if (ret < 0)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev, adf4371_clk_disable, st);
> -	if (ret)
> -		return ret;
> -
>  	st->clkin_freq = clk_get_rate(st->clkin);
>  
>  	ret = adf4371_setup(st);
> diff --git a/drivers/iio/frequency/admv1013.c b/drivers/iio/frequency/admv1013.c
> index 3f3c478e9baa..b3e7eb322ade 100644
> --- a/drivers/iio/frequency/admv1013.c
> +++ b/drivers/iio/frequency/admv1013.c
> @@ -490,11 +490,6 @@ static int admv1013_init(struct admv1013_state *st)
>  					  st->input_mode);
>  }
>  
> -static void admv1013_clk_disable(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static void admv1013_reg_disable(void *data)
>  {
>  	regulator_disable(data);
> @@ -559,7 +554,7 @@ static int admv1013_properties_parse(struct admv1013_state *st)
>  		return dev_err_probe(&spi->dev, PTR_ERR(st->reg),
>  				     "failed to get the common-mode voltage\n");
>  
> -	st->clkin = devm_clk_get(&spi->dev, "lo_in");
> +	st->clkin = devm_clk_get_enabled(&spi->dev, "lo_in");
>  	if (IS_ERR(st->clkin))
>  		return dev_err_probe(&spi->dev, PTR_ERR(st->clkin),
>  				     "failed to get the LO input clock\n");
> @@ -601,14 +596,6 @@ static int admv1013_probe(struct spi_device *spi)
>  	if (ret)
>  		return ret;
>  
> -	ret = clk_prepare_enable(st->clkin);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev, admv1013_clk_disable, st->clkin);
> -	if (ret)
> -		return ret;
> -
>  	st->nb.notifier_call = admv1013_freq_change;
>  	ret = devm_clk_notifier_register(&spi->dev, st->clkin, &st->nb);
>  	if (ret)
> diff --git a/drivers/iio/frequency/adrf6780.c b/drivers/iio/frequency/adrf6780.c
> index 8255ffd174f6..d7bf34ceedd8 100644
> --- a/drivers/iio/frequency/adrf6780.c
> +++ b/drivers/iio/frequency/adrf6780.c
> @@ -441,11 +441,6 @@ static void adrf6780_properties_parse(struct adrf6780_state *st)
>  	st->vdet_out_en = device_property_read_bool(&spi->dev, "adi,vdet-out-en");
>  }
>  
> -static void adrf6780_clk_disable(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static void adrf6780_powerdown(void *data)
>  {
>  	/* Disable all components in the Enable Register */
> @@ -473,20 +468,11 @@ static int adrf6780_probe(struct spi_device *spi)
>  
>  	adrf6780_properties_parse(st);
>  
> -	st->clkin = devm_clk_get(&spi->dev, "lo_in");
> +	st->clkin = devm_clk_get_enabled(&spi->dev, "lo_in");
>  	if (IS_ERR(st->clkin))
>  		return dev_err_probe(&spi->dev, PTR_ERR(st->clkin),
>  				     "failed to get the LO input clock\n");
>  
> -	ret = clk_prepare_enable(st->clkin);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(&spi->dev, adrf6780_clk_disable,
> -				       st->clkin);
> -	if (ret)
> -		return ret;
> -
>  	mutex_init(&st->lock);
>  
>  	ret = adrf6780_init(st);
> diff --git a/drivers/iio/imu/adis16475.c b/drivers/iio/imu/adis16475.c
> index ea91d127077d..45a8765d7c16 100644
> --- a/drivers/iio/imu/adis16475.c
> +++ b/drivers/iio/imu/adis16475.c
> @@ -1120,11 +1120,6 @@ static irqreturn_t adis16475_trigger_handler(int irq, void *p)
>  	return IRQ_HANDLED;
>  }
>  
> -static void adis16475_disable_clk(void *data)
> -{
> -	clk_disable_unprepare((struct clk *)data);
> -}
> -
>  static int adis16475_config_sync_mode(struct adis16475 *st)
>  {
>  	int ret;
> @@ -1150,19 +1145,11 @@ static int adis16475_config_sync_mode(struct adis16475 *st)
>  
>  	/* All the other modes require external input signal */
>  	if (sync->sync_mode != ADIS16475_SYNC_OUTPUT) {
> -		struct clk *clk = devm_clk_get(dev, NULL);
> +		struct clk *clk = devm_clk_get_enabled(dev, NULL);
>  
>  		if (IS_ERR(clk))
>  			return PTR_ERR(clk);
>  
> -		ret = clk_prepare_enable(clk);
> -		if (ret)
> -			return ret;
> -
> -		ret = devm_add_action_or_reset(dev, adis16475_disable_clk, clk);
> -		if (ret)
> -			return ret;
> -
>  		st->clk_freq = clk_get_rate(clk);
>  		if (st->clk_freq < sync->min_rate ||
>  		    st->clk_freq > sync->max_rate) {


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()

[Uwe Kleine-König]

[-- Attachment #1.1: Type: text/plain, Size: 1042 bytes --]

Hello,

On Sat, Mar 19, 2022 at 06:22:40PM +0000, Jonathan Cameron wrote:
> On Mon, 14 Mar 2022 15:16:31 +0100
> Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:
> 
> > Several drivers manually register a devm handler to disable their clk.
> > Convert them to devm_clk_get_enabled().
> > 
> > Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> 
> Acked-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> 
> If this does get picked up, can who ever does it please provide
> an immutable branch. With some many drivers cleaned up, it's very
> likely to cause some merge fun somewhere otherwise.

That would be good, indeed. If only the first two patches go in via clk
tree, it would however also be OK for me if the other patches go in only
after the clk changes are in an -rc1. I can care about rebasing if need
be.

Best regards
Uwe

-- 
Pengutronix e.K.                           | Uwe Kleine-König            |
Industrial Linux Solutions                 | https://www.pengutronix.de/ |

[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

[-- Attachment #2: Type: text/plain, Size: 176 bytes --]

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()

[Jonathan Cameron]

On Mon, 21 Mar 2022 08:41:54 +0100
Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:

> Hello,
> 
> On Sat, Mar 19, 2022 at 06:22:40PM +0000, Jonathan Cameron wrote:
> > On Mon, 14 Mar 2022 15:16:31 +0100
> > Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:
> >   
> > > Several drivers manually register a devm handler to disable their clk.
> > > Convert them to devm_clk_get_enabled().
> > > 
> > > Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>  
> > 
> > Acked-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> > 
> > If this does get picked up, can who ever does it please provide
> > an immutable branch. With some many drivers cleaned up, it's very
> > likely to cause some merge fun somewhere otherwise.  
> 
> That would be good, indeed. If only the first two patches go in via clk
> tree, it would however also be OK for me if the other patches go in only
> after the clk changes are in an -rc1. I can care about rebasing if need
> be.

That works to, but so slow!!! :)

Jonathan

> 
> Best regards
> Uwe
> 


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v8 05/16] hwrng: meson - Don't open-code devm_clk_get_optional_enabled()

[Uwe Kleine-König]

devm_clk_get_enabled() returns a clock prepared and enabled and already
registers a devm exit handler to disable (and unprepare) the clock.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/char/hw_random/meson-rng.c | 20 ++------------------
 1 file changed, 2 insertions(+), 18 deletions(-)

diff --git a/drivers/char/hw_random/meson-rng.c b/drivers/char/hw_random/meson-rng.c
index 8bb30282ca46..06db5a93e257 100644
--- a/drivers/char/hw_random/meson-rng.c
+++ b/drivers/char/hw_random/meson-rng.c
@@ -33,16 +33,10 @@ static int meson_rng_read(struct hwrng *rng, void *buf, size_t max, bool wait)
 	return sizeof(u32);
 }
 
-static void meson_rng_clk_disable(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int meson_rng_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
 	struct meson_rng_data *data;
-	int ret;
 
 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 	if (!data)
@@ -54,20 +48,10 @@ static int meson_rng_probe(struct platform_device *pdev)
 	if (IS_ERR(data->base))
 		return PTR_ERR(data->base);
 
-	data->core_clk = devm_clk_get_optional(dev, "core");
+	data->core_clk = devm_clk_get_optional_enabled(dev, "core");
 	if (IS_ERR(data->core_clk))
 		return dev_err_probe(dev, PTR_ERR(data->core_clk),
-				     "Failed to get core clock\n");
-
-	if (data->core_clk) {
-		ret = clk_prepare_enable(data->core_clk);
-		if (ret)
-			return ret;
-		ret = devm_add_action_or_reset(dev, meson_rng_clk_disable,
-					       data->core_clk);
-		if (ret)
-			return ret;
-	}
+				     "Failed to get enabled core clock\n");
 
 	data->rng.name = pdev->name;
 	data->rng.read = meson_rng_read;
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v8 05/16] hwrng: meson - Don't open-code devm_clk_get_optional_enabled()

[Neil Armstrong]

On 14/03/2022 15:16, Uwe Kleine-König wrote:
> devm_clk_get_enabled() returns a clock prepared and enabled and already
> registers a devm exit handler to disable (and unprepare) the clock.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> ---
>   drivers/char/hw_random/meson-rng.c | 20 ++------------------
>   1 file changed, 2 insertions(+), 18 deletions(-)
> 
> diff --git a/drivers/char/hw_random/meson-rng.c b/drivers/char/hw_random/meson-rng.c
> index 8bb30282ca46..06db5a93e257 100644
> --- a/drivers/char/hw_random/meson-rng.c
> +++ b/drivers/char/hw_random/meson-rng.c
> @@ -33,16 +33,10 @@ static int meson_rng_read(struct hwrng *rng, void *buf, size_t max, bool wait)
>   	return sizeof(u32);
>   }
>   
> -static void meson_rng_clk_disable(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>   static int meson_rng_probe(struct platform_device *pdev)
>   {
>   	struct device *dev = &pdev->dev;
>   	struct meson_rng_data *data;
> -	int ret;
>   
>   	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
>   	if (!data)
> @@ -54,20 +48,10 @@ static int meson_rng_probe(struct platform_device *pdev)
>   	if (IS_ERR(data->base))
>   		return PTR_ERR(data->base);
>   
> -	data->core_clk = devm_clk_get_optional(dev, "core");
> +	data->core_clk = devm_clk_get_optional_enabled(dev, "core");
>   	if (IS_ERR(data->core_clk))
>   		return dev_err_probe(dev, PTR_ERR(data->core_clk),
> -				     "Failed to get core clock\n");
> -
> -	if (data->core_clk) {
> -		ret = clk_prepare_enable(data->core_clk);
> -		if (ret)
> -			return ret;
> -		ret = devm_add_action_or_reset(dev, meson_rng_clk_disable,
> -					       data->core_clk);
> -		if (ret)
> -			return ret;
> -	}
> +				     "Failed to get enabled core clock\n");
>   
>   	data->rng.name = pdev->name;
>   	data->rng.read = meson_rng_read;

Acked-by: Neil Armstrong <narmstrong@baylibre.com>

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()

[Uwe Kleine-König]

devm_clk_get_enabled() returns a clock prepared and enabled and already
registers a devm exit handler to disable (and unprepare) the clock.

There is slight change in behavior as a failure to enable the clock
now results in an error message, too. Also the actual error code is added
to the message.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/gpu/drm/meson/meson_dw_hdmi.c | 48 +++++++++------------------
 1 file changed, 16 insertions(+), 32 deletions(-)

diff --git a/drivers/gpu/drm/meson/meson_dw_hdmi.c b/drivers/gpu/drm/meson/meson_dw_hdmi.c
index 5cd2b2ebbbd3..6034e80c5b2e 100644
--- a/drivers/gpu/drm/meson/meson_dw_hdmi.c
+++ b/drivers/gpu/drm/meson/meson_dw_hdmi.c
@@ -670,29 +670,6 @@ static void meson_disable_regulator(void *data)
 	regulator_disable(data);
 }
 
-static void meson_disable_clk(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
-static int meson_enable_clk(struct device *dev, char *name)
-{
-	struct clk *clk;
-	int ret;
-
-	clk = devm_clk_get(dev, name);
-	if (IS_ERR(clk)) {
-		dev_err(dev, "Unable to get %s pclk\n", name);
-		return PTR_ERR(clk);
-	}
-
-	ret = clk_prepare_enable(clk);
-	if (!ret)
-		ret = devm_add_action_or_reset(dev, meson_disable_clk, clk);
-
-	return ret;
-}
-
 static int meson_dw_hdmi_bind(struct device *dev, struct device *master,
 				void *data)
 {
@@ -702,6 +679,7 @@ static int meson_dw_hdmi_bind(struct device *dev, struct device *master,
 	struct drm_device *drm = data;
 	struct meson_drm *priv = drm->dev_private;
 	struct dw_hdmi_plat_data *dw_plat_data;
+	struct clk *clk;
 	int irq;
 	int ret;
 
@@ -763,17 +741,23 @@ static int meson_dw_hdmi_bind(struct device *dev, struct device *master,
 	if (IS_ERR(meson_dw_hdmi->hdmitx))
 		return PTR_ERR(meson_dw_hdmi->hdmitx);
 
-	ret = meson_enable_clk(dev, "isfr");
-	if (ret)
-		return ret;
+	clk = devm_clk_get_enabled(dev, "isfr");
+	if (IS_ERR(clk)) {
+		dev_err(dev, "Failed to get enabled isfr pclk (%pe)\n", clk);
+		return PTR_ERR(clk);
+	}
 
-	ret = meson_enable_clk(dev, "iahb");
-	if (ret)
-		return ret;
+	clk = devm_clk_get_enabled(dev, "iahb");
+	if (IS_ERR(clk)) {
+		dev_err(dev, "Failed to get enabled iahb pclk (%pe)\n", clk);
+		return PTR_ERR(clk);
+	}
 
-	ret = meson_enable_clk(dev, "venci");
-	if (ret)
-		return ret;
+	clk = devm_clk_get_enabled(dev, "venci");
+	if (IS_ERR(clk)) {
+		dev_err(dev, "Failed to get enabled venci pclk (%pe)\n", clk);
+		return PTR_ERR(clk);
+	}
 
 	dw_plat_data->regm = devm_regmap_init(dev, NULL, meson_dw_hdmi,
 					      &meson_dw_hdmi_regmap_config);
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()

[Neil Armstrong]

On 14/03/2022 15:16, Uwe Kleine-König wrote:
> devm_clk_get_enabled() returns a clock prepared and enabled and already
> registers a devm exit handler to disable (and unprepare) the clock.
> 
> There is slight change in behavior as a failure to enable the clock
> now results in an error message, too. Also the actual error code is added
> to the message.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> ---
>   drivers/gpu/drm/meson/meson_dw_hdmi.c | 48 +++++++++------------------
>   1 file changed, 16 insertions(+), 32 deletions(-)
> 
> diff --git a/drivers/gpu/drm/meson/meson_dw_hdmi.c b/drivers/gpu/drm/meson/meson_dw_hdmi.c
> index 5cd2b2ebbbd3..6034e80c5b2e 100644
> --- a/drivers/gpu/drm/meson/meson_dw_hdmi.c
> +++ b/drivers/gpu/drm/meson/meson_dw_hdmi.c
> @@ -670,29 +670,6 @@ static void meson_disable_regulator(void *data)
>   	regulator_disable(data);
>   }
>   
> -static void meson_disable_clk(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
> -static int meson_enable_clk(struct device *dev, char *name)
> -{
> -	struct clk *clk;
> -	int ret;
> -
> -	clk = devm_clk_get(dev, name);
> -	if (IS_ERR(clk)) {
> -		dev_err(dev, "Unable to get %s pclk\n", name);
> -		return PTR_ERR(clk);
> -	}
> -
> -	ret = clk_prepare_enable(clk);
> -	if (!ret)
> -		ret = devm_add_action_or_reset(dev, meson_disable_clk, clk);
> -
> -	return ret;
> -}
> -
>   static int meson_dw_hdmi_bind(struct device *dev, struct device *master,
>   				void *data)
>   {
> @@ -702,6 +679,7 @@ static int meson_dw_hdmi_bind(struct device *dev, struct device *master,
>   	struct drm_device *drm = data;
>   	struct meson_drm *priv = drm->dev_private;
>   	struct dw_hdmi_plat_data *dw_plat_data;
> +	struct clk *clk;
>   	int irq;
>   	int ret;
>   
> @@ -763,17 +741,23 @@ static int meson_dw_hdmi_bind(struct device *dev, struct device *master,
>   	if (IS_ERR(meson_dw_hdmi->hdmitx))
>   		return PTR_ERR(meson_dw_hdmi->hdmitx);
>   
> -	ret = meson_enable_clk(dev, "isfr");
> -	if (ret)
> -		return ret;
> +	clk = devm_clk_get_enabled(dev, "isfr");
> +	if (IS_ERR(clk)) {
> +		dev_err(dev, "Failed to get enabled isfr pclk (%pe)\n", clk);
> +		return PTR_ERR(clk);
> +	}
>   
> -	ret = meson_enable_clk(dev, "iahb");
> -	if (ret)
> -		return ret;
> +	clk = devm_clk_get_enabled(dev, "iahb");
> +	if (IS_ERR(clk)) {
> +		dev_err(dev, "Failed to get enabled iahb pclk (%pe)\n", clk);
> +		return PTR_ERR(clk);
> +	}
>   
> -	ret = meson_enable_clk(dev, "venci");
> -	if (ret)
> -		return ret;
> +	clk = devm_clk_get_enabled(dev, "venci");
> +	if (IS_ERR(clk)) {
> +		dev_err(dev, "Failed to get enabled venci pclk (%pe)\n", clk);
> +		return PTR_ERR(clk);
> +	}
>   
>   	dw_plat_data->regm = devm_regmap_init(dev, NULL, meson_dw_hdmi,
>   					      &meson_dw_hdmi_regmap_config);

Acked-by: Neil Armstrong <narmstrong@baylibre.com>

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v8 10/16] clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()

[Uwe Kleine-König]

The clk API recently got a function with a slightly different name and
the same functionality. Remove the duplication.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/clk/meson/axg-audio.c | 36 ++++-------------------------------
 1 file changed, 4 insertions(+), 32 deletions(-)

diff --git a/drivers/clk/meson/axg-audio.c b/drivers/clk/meson/axg-audio.c
index bfe36bd41339..5016682e47c8 100644
--- a/drivers/clk/meson/axg-audio.c
+++ b/drivers/clk/meson/axg-audio.c
@@ -1657,35 +1657,6 @@ static struct clk_regmap *const sm1_clk_regmaps[] = {
 	&sm1_sysclk_b_en,
 };
 
-static int devm_clk_get_enable(struct device *dev, char *id)
-{
-	struct clk *clk;
-	int ret;
-
-	clk = devm_clk_get(dev, id);
-	if (IS_ERR(clk)) {
-		ret = PTR_ERR(clk);
-		dev_err_probe(dev, ret, "failed to get %s", id);
-		return ret;
-	}
-
-	ret = clk_prepare_enable(clk);
-	if (ret) {
-		dev_err(dev, "failed to enable %s", id);
-		return ret;
-	}
-
-	ret = devm_add_action_or_reset(dev,
-				       (void(*)(void *))clk_disable_unprepare,
-				       clk);
-	if (ret) {
-		dev_err(dev, "failed to add reset action on %s", id);
-		return ret;
-	}
-
-	return 0;
-}
-
 struct axg_audio_reset_data {
 	struct reset_controller_dev rstc;
 	struct regmap *map;
@@ -1787,6 +1758,7 @@ static int axg_audio_clkc_probe(struct platform_device *pdev)
 	struct regmap *map;
 	void __iomem *regs;
 	struct clk_hw *hw;
+	struct clk *clk;
 	int ret, i;
 
 	data = of_device_get_match_data(dev);
@@ -1804,9 +1776,9 @@ static int axg_audio_clkc_probe(struct platform_device *pdev)
 	}
 
 	/* Get the mandatory peripheral clock */
-	ret = devm_clk_get_enable(dev, "pclk");
-	if (ret)
-		return ret;
+	clk = devm_clk_get_enabled(dev, "pclk");
+	if (IS_ERR(clk))
+		return PTR_ERR(clk);
 
 	ret = device_reset(dev);
 	if (ret) {
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v8 11/16] watchdog: Make use of devm_clk_get_enabled()

[Uwe Kleine-König]

Several drivers manually register a devm handler to disable their clk.
Convert them to devm_clk_get_enabled().

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/watchdog/cadence_wdt.c    | 17 +----------------
 drivers/watchdog/davinci_wdt.c    | 18 +-----------------
 drivers/watchdog/imgpdc_wdt.c     | 31 +++----------------------------
 drivers/watchdog/imx2_wdt.c       | 15 +--------------
 drivers/watchdog/imx7ulp_wdt.c    | 15 +--------------
 drivers/watchdog/loongson1_wdt.c  | 17 +----------------
 drivers/watchdog/lpc18xx_wdt.c    | 30 ++----------------------------
 drivers/watchdog/meson_gxbb_wdt.c | 16 +---------------
 drivers/watchdog/of_xilinx_wdt.c  | 16 +---------------
 drivers/watchdog/pic32-dmt.c      | 15 +--------------
 drivers/watchdog/pic32-wdt.c      | 17 +----------------
 drivers/watchdog/pnx4008_wdt.c    | 15 +--------------
 drivers/watchdog/qcom-wdt.c       | 16 +---------------
 drivers/watchdog/rtd119x_wdt.c    | 16 +---------------
 drivers/watchdog/st_lpc_wdt.c     | 16 +---------------
 drivers/watchdog/stm32_iwdg.c     | 31 ++-----------------------------
 drivers/watchdog/visconti_wdt.c   | 18 +-----------------
 17 files changed, 21 insertions(+), 298 deletions(-)

diff --git a/drivers/watchdog/cadence_wdt.c b/drivers/watchdog/cadence_wdt.c
index bc99e9164930..23d41043863f 100644
--- a/drivers/watchdog/cadence_wdt.c
+++ b/drivers/watchdog/cadence_wdt.c
@@ -274,11 +274,6 @@ static const struct watchdog_ops cdns_wdt_ops = {
 	.set_timeout = cdns_wdt_settimeout,
 };
 
-static void cdns_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 /************************Platform Operations*****************************/
 /**
  * cdns_wdt_probe - Probe call for the device.
@@ -333,21 +328,11 @@ static int cdns_wdt_probe(struct platform_device *pdev)
 	watchdog_stop_on_reboot(cdns_wdt_device);
 	watchdog_set_drvdata(cdns_wdt_device, wdt);
 
-	wdt->clk = devm_clk_get(dev, NULL);
+	wdt->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(wdt->clk))
 		return dev_err_probe(dev, PTR_ERR(wdt->clk),
 				     "input clock not found\n");
 
-	ret = clk_prepare_enable(wdt->clk);
-	if (ret) {
-		dev_err(dev, "unable to enable clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, cdns_clk_disable_unprepare,
-				       wdt->clk);
-	if (ret)
-		return ret;
-
 	clock_f = clk_get_rate(wdt->clk);
 	if (clock_f <= CDNS_WDT_CLK_75MHZ) {
 		wdt->prescaler = CDNS_WDT_PRESCALE_512;
diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
index 584a56893b81..5f2184bda7b2 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -189,14 +189,8 @@ static const struct watchdog_ops davinci_wdt_ops = {
 	.restart	= davinci_wdt_restart,
 };
 
-static void davinci_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int davinci_wdt_probe(struct platform_device *pdev)
 {
-	int ret = 0;
 	struct device *dev = &pdev->dev;
 	struct watchdog_device *wdd;
 	struct davinci_wdt_device *davinci_wdt;
@@ -205,21 +199,11 @@ static int davinci_wdt_probe(struct platform_device *pdev)
 	if (!davinci_wdt)
 		return -ENOMEM;
 
-	davinci_wdt->clk = devm_clk_get(dev, NULL);
+	davinci_wdt->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(davinci_wdt->clk))
 		return dev_err_probe(dev, PTR_ERR(davinci_wdt->clk),
 				     "failed to get clock node\n");
 
-	ret = clk_prepare_enable(davinci_wdt->clk);
-	if (ret) {
-		dev_err(dev, "failed to prepare clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, davinci_clk_disable_unprepare,
-				       davinci_wdt->clk);
-	if (ret)
-		return ret;
-
 	platform_set_drvdata(pdev, davinci_wdt);
 
 	wdd			= &davinci_wdt->wdd;
diff --git a/drivers/watchdog/imgpdc_wdt.c b/drivers/watchdog/imgpdc_wdt.c
index b57ff3787052..a55f801895d4 100644
--- a/drivers/watchdog/imgpdc_wdt.c
+++ b/drivers/watchdog/imgpdc_wdt.c
@@ -175,16 +175,11 @@ static const struct watchdog_ops pdc_wdt_ops = {
 	.restart        = pdc_wdt_restart,
 };
 
-static void pdc_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int pdc_wdt_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
 	u64 div;
-	int ret, val;
+	int val;
 	unsigned long clk_rate;
 	struct pdc_wdt_dev *pdc_wdt;
 
@@ -196,38 +191,18 @@ static int pdc_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(pdc_wdt->base))
 		return PTR_ERR(pdc_wdt->base);
 
-	pdc_wdt->sys_clk = devm_clk_get(dev, "sys");
+	pdc_wdt->sys_clk = devm_clk_get_enabled(dev, "sys");
 	if (IS_ERR(pdc_wdt->sys_clk)) {
 		dev_err(dev, "failed to get the sys clock\n");
 		return PTR_ERR(pdc_wdt->sys_clk);
 	}
 
-	pdc_wdt->wdt_clk = devm_clk_get(dev, "wdt");
+	pdc_wdt->wdt_clk = devm_clk_get_enabled(dev, "wdt");
 	if (IS_ERR(pdc_wdt->wdt_clk)) {
 		dev_err(dev, "failed to get the wdt clock\n");
 		return PTR_ERR(pdc_wdt->wdt_clk);
 	}
 
-	ret = clk_prepare_enable(pdc_wdt->sys_clk);
-	if (ret) {
-		dev_err(dev, "could not prepare or enable sys clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, pdc_clk_disable_unprepare,
-				       pdc_wdt->sys_clk);
-	if (ret)
-		return ret;
-
-	ret = clk_prepare_enable(pdc_wdt->wdt_clk);
-	if (ret) {
-		dev_err(dev, "could not prepare or enable wdt clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, pdc_clk_disable_unprepare,
-				       pdc_wdt->wdt_clk);
-	if (ret)
-		return ret;
-
 	/* We use the clock rate to calculate the max timeout */
 	clk_rate = clk_get_rate(pdc_wdt->wdt_clk);
 	if (clk_rate == 0) {
diff --git a/drivers/watchdog/imx2_wdt.c b/drivers/watchdog/imx2_wdt.c
index 51bfb796898b..273d720588bf 100644
--- a/drivers/watchdog/imx2_wdt.c
+++ b/drivers/watchdog/imx2_wdt.c
@@ -248,11 +248,6 @@ static const struct regmap_config imx2_wdt_regmap_config = {
 	.max_register = 0x8,
 };
 
-static void imx2_wdt_action(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int __init imx2_wdt_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -277,7 +272,7 @@ static int __init imx2_wdt_probe(struct platform_device *pdev)
 		return PTR_ERR(wdev->regmap);
 	}
 
-	wdev->clk = devm_clk_get(dev, NULL);
+	wdev->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(wdev->clk)) {
 		dev_err(dev, "can't get Watchdog clock\n");
 		return PTR_ERR(wdev->clk);
@@ -297,14 +292,6 @@ static int __init imx2_wdt_probe(struct platform_device *pdev)
 				      dev_name(dev), wdog))
 			wdog->info = &imx2_wdt_pretimeout_info;
 
-	ret = clk_prepare_enable(wdev->clk);
-	if (ret)
-		return ret;
-
-	ret = devm_add_action_or_reset(dev, imx2_wdt_action, wdev->clk);
-	if (ret)
-		return ret;
-
 	wdev->clk_is_on = true;
 
 	regmap_read(wdev->regmap, IMX2_WDT_WRSR, &val);
diff --git a/drivers/watchdog/imx7ulp_wdt.c b/drivers/watchdog/imx7ulp_wdt.c
index 922b60374295..61517abf2dba 100644
--- a/drivers/watchdog/imx7ulp_wdt.c
+++ b/drivers/watchdog/imx7ulp_wdt.c
@@ -200,11 +200,6 @@ static int imx7ulp_wdt_init(void __iomem *base, unsigned int timeout)
 	return ret;
 }
 
-static void imx7ulp_wdt_action(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int imx7ulp_wdt_probe(struct platform_device *pdev)
 {
 	struct imx7ulp_wdt_device *imx7ulp_wdt;
@@ -222,20 +217,12 @@ static int imx7ulp_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(imx7ulp_wdt->base))
 		return PTR_ERR(imx7ulp_wdt->base);
 
-	imx7ulp_wdt->clk = devm_clk_get(dev, NULL);
+	imx7ulp_wdt->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(imx7ulp_wdt->clk)) {
 		dev_err(dev, "Failed to get watchdog clock\n");
 		return PTR_ERR(imx7ulp_wdt->clk);
 	}
 
-	ret = clk_prepare_enable(imx7ulp_wdt->clk);
-	if (ret)
-		return ret;
-
-	ret = devm_add_action_or_reset(dev, imx7ulp_wdt_action, imx7ulp_wdt->clk);
-	if (ret)
-		return ret;
-
 	wdog = &imx7ulp_wdt->wdd;
 	wdog->info = &imx7ulp_wdt_info;
 	wdog->ops = &imx7ulp_wdt_ops;
diff --git a/drivers/watchdog/loongson1_wdt.c b/drivers/watchdog/loongson1_wdt.c
index bb3d075c0633..c55656cfb403 100644
--- a/drivers/watchdog/loongson1_wdt.c
+++ b/drivers/watchdog/loongson1_wdt.c
@@ -79,11 +79,6 @@ static const struct watchdog_ops ls1x_wdt_ops = {
 	.set_timeout = ls1x_wdt_set_timeout,
 };
 
-static void ls1x_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int ls1x_wdt_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -100,20 +95,10 @@ static int ls1x_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(drvdata->base))
 		return PTR_ERR(drvdata->base);
 
-	drvdata->clk = devm_clk_get(dev, pdev->name);
+	drvdata->clk = devm_clk_get_enabled(dev, pdev->name);
 	if (IS_ERR(drvdata->clk))
 		return PTR_ERR(drvdata->clk);
 
-	err = clk_prepare_enable(drvdata->clk);
-	if (err) {
-		dev_err(dev, "clk enable failed\n");
-		return err;
-	}
-	err = devm_add_action_or_reset(dev, ls1x_clk_disable_unprepare,
-				       drvdata->clk);
-	if (err)
-		return err;
-
 	clk_rate = clk_get_rate(drvdata->clk);
 	if (!clk_rate)
 		return -EINVAL;
diff --git a/drivers/watchdog/lpc18xx_wdt.c b/drivers/watchdog/lpc18xx_wdt.c
index 60b6d74f267d..1b9b5f21a0df 100644
--- a/drivers/watchdog/lpc18xx_wdt.c
+++ b/drivers/watchdog/lpc18xx_wdt.c
@@ -197,16 +197,10 @@ static const struct watchdog_ops lpc18xx_wdt_ops = {
 	.restart        = lpc18xx_wdt_restart,
 };
 
-static void lpc18xx_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int lpc18xx_wdt_probe(struct platform_device *pdev)
 {
 	struct lpc18xx_wdt_dev *lpc18xx_wdt;
 	struct device *dev = &pdev->dev;
-	int ret;
 
 	lpc18xx_wdt = devm_kzalloc(dev, sizeof(*lpc18xx_wdt), GFP_KERNEL);
 	if (!lpc18xx_wdt)
@@ -216,38 +210,18 @@ static int lpc18xx_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(lpc18xx_wdt->base))
 		return PTR_ERR(lpc18xx_wdt->base);
 
-	lpc18xx_wdt->reg_clk = devm_clk_get(dev, "reg");
+	lpc18xx_wdt->reg_clk = devm_clk_get_enabled(dev, "reg");
 	if (IS_ERR(lpc18xx_wdt->reg_clk)) {
 		dev_err(dev, "failed to get the reg clock\n");
 		return PTR_ERR(lpc18xx_wdt->reg_clk);
 	}
 
-	lpc18xx_wdt->wdt_clk = devm_clk_get(dev, "wdtclk");
+	lpc18xx_wdt->wdt_clk = devm_clk_get_enabled(dev, "wdtclk");
 	if (IS_ERR(lpc18xx_wdt->wdt_clk)) {
 		dev_err(dev, "failed to get the wdt clock\n");
 		return PTR_ERR(lpc18xx_wdt->wdt_clk);
 	}
 
-	ret = clk_prepare_enable(lpc18xx_wdt->reg_clk);
-	if (ret) {
-		dev_err(dev, "could not prepare or enable sys clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, lpc18xx_clk_disable_unprepare,
-				       lpc18xx_wdt->reg_clk);
-	if (ret)
-		return ret;
-
-	ret = clk_prepare_enable(lpc18xx_wdt->wdt_clk);
-	if (ret) {
-		dev_err(dev, "could not prepare or enable wdt clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, lpc18xx_clk_disable_unprepare,
-				       lpc18xx_wdt->wdt_clk);
-	if (ret)
-		return ret;
-
 	/* We use the clock rate to calculate timeouts */
 	lpc18xx_wdt->clk_rate = clk_get_rate(lpc18xx_wdt->wdt_clk);
 	if (lpc18xx_wdt->clk_rate == 0) {
diff --git a/drivers/watchdog/meson_gxbb_wdt.c b/drivers/watchdog/meson_gxbb_wdt.c
index d3c9e2f6e63b..cf65d096f3c0 100644
--- a/drivers/watchdog/meson_gxbb_wdt.c
+++ b/drivers/watchdog/meson_gxbb_wdt.c
@@ -146,16 +146,10 @@ static const struct of_device_id meson_gxbb_wdt_dt_ids[] = {
 };
 MODULE_DEVICE_TABLE(of, meson_gxbb_wdt_dt_ids);
 
-static void meson_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int meson_gxbb_wdt_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
 	struct meson_gxbb_wdt *data;
-	int ret;
 
 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 	if (!data)
@@ -165,18 +159,10 @@ static int meson_gxbb_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(data->reg_base))
 		return PTR_ERR(data->reg_base);
 
-	data->clk = devm_clk_get(dev, NULL);
+	data->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(data->clk))
 		return PTR_ERR(data->clk);
 
-	ret = clk_prepare_enable(data->clk);
-	if (ret)
-		return ret;
-	ret = devm_add_action_or_reset(dev, meson_clk_disable_unprepare,
-				       data->clk);
-	if (ret)
-		return ret;
-
 	platform_set_drvdata(pdev, data);
 
 	data->wdt_dev.parent = dev;
diff --git a/drivers/watchdog/of_xilinx_wdt.c b/drivers/watchdog/of_xilinx_wdt.c
index 3318544366b8..2a079ca04aa3 100644
--- a/drivers/watchdog/of_xilinx_wdt.c
+++ b/drivers/watchdog/of_xilinx_wdt.c
@@ -154,11 +154,6 @@ static u32 xwdt_selftest(struct xwdt_device *xdev)
 		return XWT_TIMER_FAILED;
 }
 
-static void xwdt_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int xwdt_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -193,7 +188,7 @@ static int xwdt_probe(struct platform_device *pdev)
 
 	watchdog_set_nowayout(xilinx_wdt_wdd, enable_once);
 
-	xdev->clk = devm_clk_get(dev, NULL);
+	xdev->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(xdev->clk)) {
 		if (PTR_ERR(xdev->clk) != -ENOENT)
 			return PTR_ERR(xdev->clk);
@@ -211,15 +206,6 @@ static int xwdt_probe(struct platform_device *pdev)
 				 "The watchdog clock freq cannot be obtained\n");
 	} else {
 		pfreq = clk_get_rate(xdev->clk);
-		rc = clk_prepare_enable(xdev->clk);
-		if (rc) {
-			dev_err(dev, "unable to enable clock\n");
-			return rc;
-		}
-		rc = devm_add_action_or_reset(dev, xwdt_clk_disable_unprepare,
-					      xdev->clk);
-		if (rc)
-			return rc;
 	}
 
 	/*
diff --git a/drivers/watchdog/pic32-dmt.c b/drivers/watchdog/pic32-dmt.c
index f43062b3c4c8..bc4ccddc75a3 100644
--- a/drivers/watchdog/pic32-dmt.c
+++ b/drivers/watchdog/pic32-dmt.c
@@ -164,11 +164,6 @@ static struct watchdog_device pic32_dmt_wdd = {
 	.ops		= &pic32_dmt_fops,
 };
 
-static void pic32_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int pic32_dmt_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -184,20 +179,12 @@ static int pic32_dmt_probe(struct platform_device *pdev)
 	if (IS_ERR(dmt->regs))
 		return PTR_ERR(dmt->regs);
 
-	dmt->clk = devm_clk_get(dev, NULL);
+	dmt->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(dmt->clk)) {
 		dev_err(dev, "clk not found\n");
 		return PTR_ERR(dmt->clk);
 	}
 
-	ret = clk_prepare_enable(dmt->clk);
-	if (ret)
-		return ret;
-	ret = devm_add_action_or_reset(dev, pic32_clk_disable_unprepare,
-				       dmt->clk);
-	if (ret)
-		return ret;
-
 	wdd->timeout = pic32_dmt_get_timeout_secs(dmt);
 	if (!wdd->timeout) {
 		dev_err(dev, "failed to read watchdog register timeout\n");
diff --git a/drivers/watchdog/pic32-wdt.c b/drivers/watchdog/pic32-wdt.c
index 41715d68d9e9..6d1a00222991 100644
--- a/drivers/watchdog/pic32-wdt.c
+++ b/drivers/watchdog/pic32-wdt.c
@@ -162,11 +162,6 @@ static const struct of_device_id pic32_wdt_dt_ids[] = {
 };
 MODULE_DEVICE_TABLE(of, pic32_wdt_dt_ids);
 
-static void pic32_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int pic32_wdt_drv_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -186,22 +181,12 @@ static int pic32_wdt_drv_probe(struct platform_device *pdev)
 	if (!wdt->rst_base)
 		return -ENOMEM;
 
-	wdt->clk = devm_clk_get(dev, NULL);
+	wdt->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(wdt->clk)) {
 		dev_err(dev, "clk not found\n");
 		return PTR_ERR(wdt->clk);
 	}
 
-	ret = clk_prepare_enable(wdt->clk);
-	if (ret) {
-		dev_err(dev, "clk enable failed\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, pic32_clk_disable_unprepare,
-				       wdt->clk);
-	if (ret)
-		return ret;
-
 	if (pic32_wdt_is_win_enabled(wdt)) {
 		dev_err(dev, "windowed-clear mode is not supported.\n");
 		return -ENODEV;
diff --git a/drivers/watchdog/pnx4008_wdt.c b/drivers/watchdog/pnx4008_wdt.c
index e0ea133c1690..87a44a5675a1 100644
--- a/drivers/watchdog/pnx4008_wdt.c
+++ b/drivers/watchdog/pnx4008_wdt.c
@@ -179,11 +179,6 @@ static struct watchdog_device pnx4008_wdd = {
 	.max_timeout = MAX_HEARTBEAT,
 };
 
-static void pnx4008_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int pnx4008_wdt_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -195,18 +190,10 @@ static int pnx4008_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(wdt_base))
 		return PTR_ERR(wdt_base);
 
-	wdt_clk = devm_clk_get(dev, NULL);
+	wdt_clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(wdt_clk))
 		return PTR_ERR(wdt_clk);
 
-	ret = clk_prepare_enable(wdt_clk);
-	if (ret)
-		return ret;
-	ret = devm_add_action_or_reset(dev, pnx4008_clk_disable_unprepare,
-				       wdt_clk);
-	if (ret)
-		return ret;
-
 	pnx4008_wdd.bootstatus = (readl(WDTIM_RES(wdt_base)) & WDOG_RESET) ?
 			WDIOF_CARDRESET : 0;
 	pnx4008_wdd.parent = dev;
diff --git a/drivers/watchdog/qcom-wdt.c b/drivers/watchdog/qcom-wdt.c
index 0d2209c5eaca..d776474dcdf3 100644
--- a/drivers/watchdog/qcom-wdt.c
+++ b/drivers/watchdog/qcom-wdt.c
@@ -175,11 +175,6 @@ static const struct watchdog_info qcom_wdt_pt_info = {
 	.identity	= KBUILD_MODNAME,
 };
 
-static void qcom_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static const struct qcom_wdt_match_data match_data_apcs_tmr = {
 	.offset = reg_offset_data_apcs_tmr,
 	.pretimeout = false,
@@ -226,21 +221,12 @@ static int qcom_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(wdt->base))
 		return PTR_ERR(wdt->base);
 
-	clk = devm_clk_get(dev, NULL);
+	clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(clk)) {
 		dev_err(dev, "failed to get input clock\n");
 		return PTR_ERR(clk);
 	}
 
-	ret = clk_prepare_enable(clk);
-	if (ret) {
-		dev_err(dev, "failed to setup clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, qcom_clk_disable_unprepare, clk);
-	if (ret)
-		return ret;
-
 	/*
 	 * We use the clock rate to calculate the max timeout, so ensure it's
 	 * not zero to avoid a divide-by-zero exception.
diff --git a/drivers/watchdog/rtd119x_wdt.c b/drivers/watchdog/rtd119x_wdt.c
index 834b94ff3f90..95c8d7abce42 100644
--- a/drivers/watchdog/rtd119x_wdt.c
+++ b/drivers/watchdog/rtd119x_wdt.c
@@ -94,16 +94,10 @@ static const struct of_device_id rtd119x_wdt_dt_ids[] = {
 	 { }
 };
 
-static void rtd119x_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int rtd119x_wdt_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
 	struct rtd119x_watchdog_device *data;
-	int ret;
 
 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 	if (!data)
@@ -113,18 +107,10 @@ static int rtd119x_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(data->base))
 		return PTR_ERR(data->base);
 
-	data->clk = devm_clk_get(dev, NULL);
+	data->clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(data->clk))
 		return PTR_ERR(data->clk);
 
-	ret = clk_prepare_enable(data->clk);
-	if (ret)
-		return ret;
-	ret = devm_add_action_or_reset(dev, rtd119x_clk_disable_unprepare,
-				       data->clk);
-	if (ret)
-		return ret;
-
 	data->wdt_dev.info = &rtd119x_wdt_info;
 	data->wdt_dev.ops = &rtd119x_wdt_ops;
 	data->wdt_dev.timeout = 120;
diff --git a/drivers/watchdog/st_lpc_wdt.c b/drivers/watchdog/st_lpc_wdt.c
index 14ab6559c748..d79823e1b07e 100644
--- a/drivers/watchdog/st_lpc_wdt.c
+++ b/drivers/watchdog/st_lpc_wdt.c
@@ -142,11 +142,6 @@ static struct watchdog_device st_wdog_dev = {
 	.ops		= &st_wdog_ops,
 };
 
-static void st_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int st_wdog_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -190,7 +185,7 @@ static int st_wdog_probe(struct platform_device *pdev)
 		return PTR_ERR(regmap);
 	}
 
-	clk = devm_clk_get(dev, NULL);
+	clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(clk)) {
 		dev_err(dev, "Unable to request clock\n");
 		return PTR_ERR(clk);
@@ -210,15 +205,6 @@ static int st_wdog_probe(struct platform_device *pdev)
 	st_wdog_dev.max_timeout = 0xFFFFFFFF / st_wdog->clkrate;
 	st_wdog_dev.parent = dev;
 
-	ret = clk_prepare_enable(clk);
-	if (ret) {
-		dev_err(dev, "Unable to enable clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, st_clk_disable_unprepare, clk);
-	if (ret)
-		return ret;
-
 	watchdog_set_drvdata(&st_wdog_dev, st_wdog);
 	watchdog_set_nowayout(&st_wdog_dev, WATCHDOG_NOWAYOUT);
 
diff --git a/drivers/watchdog/stm32_iwdg.c b/drivers/watchdog/stm32_iwdg.c
index 570a71509d2a..01849720310d 100644
--- a/drivers/watchdog/stm32_iwdg.c
+++ b/drivers/watchdog/stm32_iwdg.c
@@ -150,50 +150,23 @@ static int stm32_iwdg_set_timeout(struct watchdog_device *wdd,
 	return 0;
 }
 
-static void stm32_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int stm32_iwdg_clk_init(struct platform_device *pdev,
 			       struct stm32_iwdg *wdt)
 {
 	struct device *dev = &pdev->dev;
-	u32 ret;
 
-	wdt->clk_lsi = devm_clk_get(dev, "lsi");
+	wdt->clk_lsi = devm_clk_get_enabled(dev, "lsi");
 	if (IS_ERR(wdt->clk_lsi))
 		return dev_err_probe(dev, PTR_ERR(wdt->clk_lsi), "Unable to get lsi clock\n");
 
 	/* optional peripheral clock */
 	if (wdt->data->has_pclk) {
-		wdt->clk_pclk = devm_clk_get(dev, "pclk");
+		wdt->clk_pclk = devm_clk_get_enabled(dev, "pclk");
 		if (IS_ERR(wdt->clk_pclk))
 			return dev_err_probe(dev, PTR_ERR(wdt->clk_pclk),
 					     "Unable to get pclk clock\n");
-
-		ret = clk_prepare_enable(wdt->clk_pclk);
-		if (ret) {
-			dev_err(dev, "Unable to prepare pclk clock\n");
-			return ret;
-		}
-		ret = devm_add_action_or_reset(dev,
-					       stm32_clk_disable_unprepare,
-					       wdt->clk_pclk);
-		if (ret)
-			return ret;
 	}
 
-	ret = clk_prepare_enable(wdt->clk_lsi);
-	if (ret) {
-		dev_err(dev, "Unable to prepare lsi clock\n");
-		return ret;
-	}
-	ret = devm_add_action_or_reset(dev, stm32_clk_disable_unprepare,
-				       wdt->clk_lsi);
-	if (ret)
-		return ret;
-
 	wdt->rate = clk_get_rate(wdt->clk_lsi);
 
 	return 0;
diff --git a/drivers/watchdog/visconti_wdt.c b/drivers/watchdog/visconti_wdt.c
index 83ef55e66ca8..1127e42734f4 100644
--- a/drivers/watchdog/visconti_wdt.c
+++ b/drivers/watchdog/visconti_wdt.c
@@ -112,11 +112,6 @@ static const struct watchdog_ops visconti_wdt_ops = {
 	.set_timeout	= visconti_wdt_set_timeout,
 };
 
-static void visconti_clk_disable_unprepare(void *data)
-{
-	clk_disable_unprepare(data);
-}
-
 static int visconti_wdt_probe(struct platform_device *pdev)
 {
 	struct watchdog_device *wdev;
@@ -134,20 +129,9 @@ static int visconti_wdt_probe(struct platform_device *pdev)
 	if (IS_ERR(priv->base))
 		return PTR_ERR(priv->base);
 
-	clk = devm_clk_get(dev, NULL);
+	clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(clk))
 		return dev_err_probe(dev, PTR_ERR(clk), "Could not get clock\n");
-
-	ret = clk_prepare_enable(clk);
-	if (ret) {
-		dev_err(dev, "Could not enable clock\n");
-		return ret;
-	}
-
-	ret = devm_add_action_or_reset(dev, visconti_clk_disable_unprepare, clk);
-	if (ret)
-		return ret;
-
 	clk_freq = clk_get_rate(clk);
 	if (!clk_freq)
 		return -EINVAL;
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v8 11/16] watchdog: Make use of devm_clk_get_enabled()

[Guenter Roeck]

On Mon, Mar 14, 2022 at 03:16:38PM +0100, Uwe Kleine-König wrote:
> Several drivers manually register a devm handler to disable their clk.
> Convert them to devm_clk_get_enabled().
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>

Acked-by: Guenter Roeck <linux@roeck-us.net>

> ---
>  drivers/watchdog/cadence_wdt.c    | 17 +----------------
>  drivers/watchdog/davinci_wdt.c    | 18 +-----------------
>  drivers/watchdog/imgpdc_wdt.c     | 31 +++----------------------------
>  drivers/watchdog/imx2_wdt.c       | 15 +--------------
>  drivers/watchdog/imx7ulp_wdt.c    | 15 +--------------
>  drivers/watchdog/loongson1_wdt.c  | 17 +----------------
>  drivers/watchdog/lpc18xx_wdt.c    | 30 ++----------------------------
>  drivers/watchdog/meson_gxbb_wdt.c | 16 +---------------
>  drivers/watchdog/of_xilinx_wdt.c  | 16 +---------------
>  drivers/watchdog/pic32-dmt.c      | 15 +--------------
>  drivers/watchdog/pic32-wdt.c      | 17 +----------------
>  drivers/watchdog/pnx4008_wdt.c    | 15 +--------------
>  drivers/watchdog/qcom-wdt.c       | 16 +---------------
>  drivers/watchdog/rtd119x_wdt.c    | 16 +---------------
>  drivers/watchdog/st_lpc_wdt.c     | 16 +---------------
>  drivers/watchdog/stm32_iwdg.c     | 31 ++-----------------------------
>  drivers/watchdog/visconti_wdt.c   | 18 +-----------------
>  17 files changed, 21 insertions(+), 298 deletions(-)
> 
> diff --git a/drivers/watchdog/cadence_wdt.c b/drivers/watchdog/cadence_wdt.c
> index bc99e9164930..23d41043863f 100644
> --- a/drivers/watchdog/cadence_wdt.c
> +++ b/drivers/watchdog/cadence_wdt.c
> @@ -274,11 +274,6 @@ static const struct watchdog_ops cdns_wdt_ops = {
>  	.set_timeout = cdns_wdt_settimeout,
>  };
>  
> -static void cdns_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  /************************Platform Operations*****************************/
>  /**
>   * cdns_wdt_probe - Probe call for the device.
> @@ -333,21 +328,11 @@ static int cdns_wdt_probe(struct platform_device *pdev)
>  	watchdog_stop_on_reboot(cdns_wdt_device);
>  	watchdog_set_drvdata(cdns_wdt_device, wdt);
>  
> -	wdt->clk = devm_clk_get(dev, NULL);
> +	wdt->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(wdt->clk))
>  		return dev_err_probe(dev, PTR_ERR(wdt->clk),
>  				     "input clock not found\n");
>  
> -	ret = clk_prepare_enable(wdt->clk);
> -	if (ret) {
> -		dev_err(dev, "unable to enable clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, cdns_clk_disable_unprepare,
> -				       wdt->clk);
> -	if (ret)
> -		return ret;
> -
>  	clock_f = clk_get_rate(wdt->clk);
>  	if (clock_f <= CDNS_WDT_CLK_75MHZ) {
>  		wdt->prescaler = CDNS_WDT_PRESCALE_512;
> diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
> index 584a56893b81..5f2184bda7b2 100644
> --- a/drivers/watchdog/davinci_wdt.c
> +++ b/drivers/watchdog/davinci_wdt.c
> @@ -189,14 +189,8 @@ static const struct watchdog_ops davinci_wdt_ops = {
>  	.restart	= davinci_wdt_restart,
>  };
>  
> -static void davinci_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int davinci_wdt_probe(struct platform_device *pdev)
>  {
> -	int ret = 0;
>  	struct device *dev = &pdev->dev;
>  	struct watchdog_device *wdd;
>  	struct davinci_wdt_device *davinci_wdt;
> @@ -205,21 +199,11 @@ static int davinci_wdt_probe(struct platform_device *pdev)
>  	if (!davinci_wdt)
>  		return -ENOMEM;
>  
> -	davinci_wdt->clk = devm_clk_get(dev, NULL);
> +	davinci_wdt->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(davinci_wdt->clk))
>  		return dev_err_probe(dev, PTR_ERR(davinci_wdt->clk),
>  				     "failed to get clock node\n");
>  
> -	ret = clk_prepare_enable(davinci_wdt->clk);
> -	if (ret) {
> -		dev_err(dev, "failed to prepare clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, davinci_clk_disable_unprepare,
> -				       davinci_wdt->clk);
> -	if (ret)
> -		return ret;
> -
>  	platform_set_drvdata(pdev, davinci_wdt);
>  
>  	wdd			= &davinci_wdt->wdd;
> diff --git a/drivers/watchdog/imgpdc_wdt.c b/drivers/watchdog/imgpdc_wdt.c
> index b57ff3787052..a55f801895d4 100644
> --- a/drivers/watchdog/imgpdc_wdt.c
> +++ b/drivers/watchdog/imgpdc_wdt.c
> @@ -175,16 +175,11 @@ static const struct watchdog_ops pdc_wdt_ops = {
>  	.restart        = pdc_wdt_restart,
>  };
>  
> -static void pdc_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int pdc_wdt_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
>  	u64 div;
> -	int ret, val;
> +	int val;
>  	unsigned long clk_rate;
>  	struct pdc_wdt_dev *pdc_wdt;
>  
> @@ -196,38 +191,18 @@ static int pdc_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(pdc_wdt->base))
>  		return PTR_ERR(pdc_wdt->base);
>  
> -	pdc_wdt->sys_clk = devm_clk_get(dev, "sys");
> +	pdc_wdt->sys_clk = devm_clk_get_enabled(dev, "sys");
>  	if (IS_ERR(pdc_wdt->sys_clk)) {
>  		dev_err(dev, "failed to get the sys clock\n");
>  		return PTR_ERR(pdc_wdt->sys_clk);
>  	}
>  
> -	pdc_wdt->wdt_clk = devm_clk_get(dev, "wdt");
> +	pdc_wdt->wdt_clk = devm_clk_get_enabled(dev, "wdt");
>  	if (IS_ERR(pdc_wdt->wdt_clk)) {
>  		dev_err(dev, "failed to get the wdt clock\n");
>  		return PTR_ERR(pdc_wdt->wdt_clk);
>  	}
>  
> -	ret = clk_prepare_enable(pdc_wdt->sys_clk);
> -	if (ret) {
> -		dev_err(dev, "could not prepare or enable sys clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, pdc_clk_disable_unprepare,
> -				       pdc_wdt->sys_clk);
> -	if (ret)
> -		return ret;
> -
> -	ret = clk_prepare_enable(pdc_wdt->wdt_clk);
> -	if (ret) {
> -		dev_err(dev, "could not prepare or enable wdt clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, pdc_clk_disable_unprepare,
> -				       pdc_wdt->wdt_clk);
> -	if (ret)
> -		return ret;
> -
>  	/* We use the clock rate to calculate the max timeout */
>  	clk_rate = clk_get_rate(pdc_wdt->wdt_clk);
>  	if (clk_rate == 0) {
> diff --git a/drivers/watchdog/imx2_wdt.c b/drivers/watchdog/imx2_wdt.c
> index 51bfb796898b..273d720588bf 100644
> --- a/drivers/watchdog/imx2_wdt.c
> +++ b/drivers/watchdog/imx2_wdt.c
> @@ -248,11 +248,6 @@ static const struct regmap_config imx2_wdt_regmap_config = {
>  	.max_register = 0x8,
>  };
>  
> -static void imx2_wdt_action(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int __init imx2_wdt_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
> @@ -277,7 +272,7 @@ static int __init imx2_wdt_probe(struct platform_device *pdev)
>  		return PTR_ERR(wdev->regmap);
>  	}
>  
> -	wdev->clk = devm_clk_get(dev, NULL);
> +	wdev->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(wdev->clk)) {
>  		dev_err(dev, "can't get Watchdog clock\n");
>  		return PTR_ERR(wdev->clk);
> @@ -297,14 +292,6 @@ static int __init imx2_wdt_probe(struct platform_device *pdev)
>  				      dev_name(dev), wdog))
>  			wdog->info = &imx2_wdt_pretimeout_info;
>  
> -	ret = clk_prepare_enable(wdev->clk);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(dev, imx2_wdt_action, wdev->clk);
> -	if (ret)
> -		return ret;
> -
>  	wdev->clk_is_on = true;
>  
>  	regmap_read(wdev->regmap, IMX2_WDT_WRSR, &val);
> diff --git a/drivers/watchdog/imx7ulp_wdt.c b/drivers/watchdog/imx7ulp_wdt.c
> index 922b60374295..61517abf2dba 100644
> --- a/drivers/watchdog/imx7ulp_wdt.c
> +++ b/drivers/watchdog/imx7ulp_wdt.c
> @@ -200,11 +200,6 @@ static int imx7ulp_wdt_init(void __iomem *base, unsigned int timeout)
>  	return ret;
>  }
>  
> -static void imx7ulp_wdt_action(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int imx7ulp_wdt_probe(struct platform_device *pdev)
>  {
>  	struct imx7ulp_wdt_device *imx7ulp_wdt;
> @@ -222,20 +217,12 @@ static int imx7ulp_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(imx7ulp_wdt->base))
>  		return PTR_ERR(imx7ulp_wdt->base);
>  
> -	imx7ulp_wdt->clk = devm_clk_get(dev, NULL);
> +	imx7ulp_wdt->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(imx7ulp_wdt->clk)) {
>  		dev_err(dev, "Failed to get watchdog clock\n");
>  		return PTR_ERR(imx7ulp_wdt->clk);
>  	}
>  
> -	ret = clk_prepare_enable(imx7ulp_wdt->clk);
> -	if (ret)
> -		return ret;
> -
> -	ret = devm_add_action_or_reset(dev, imx7ulp_wdt_action, imx7ulp_wdt->clk);
> -	if (ret)
> -		return ret;
> -
>  	wdog = &imx7ulp_wdt->wdd;
>  	wdog->info = &imx7ulp_wdt_info;
>  	wdog->ops = &imx7ulp_wdt_ops;
> diff --git a/drivers/watchdog/loongson1_wdt.c b/drivers/watchdog/loongson1_wdt.c
> index bb3d075c0633..c55656cfb403 100644
> --- a/drivers/watchdog/loongson1_wdt.c
> +++ b/drivers/watchdog/loongson1_wdt.c
> @@ -79,11 +79,6 @@ static const struct watchdog_ops ls1x_wdt_ops = {
>  	.set_timeout = ls1x_wdt_set_timeout,
>  };
>  
> -static void ls1x_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int ls1x_wdt_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
> @@ -100,20 +95,10 @@ static int ls1x_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(drvdata->base))
>  		return PTR_ERR(drvdata->base);
>  
> -	drvdata->clk = devm_clk_get(dev, pdev->name);
> +	drvdata->clk = devm_clk_get_enabled(dev, pdev->name);
>  	if (IS_ERR(drvdata->clk))
>  		return PTR_ERR(drvdata->clk);
>  
> -	err = clk_prepare_enable(drvdata->clk);
> -	if (err) {
> -		dev_err(dev, "clk enable failed\n");
> -		return err;
> -	}
> -	err = devm_add_action_or_reset(dev, ls1x_clk_disable_unprepare,
> -				       drvdata->clk);
> -	if (err)
> -		return err;
> -
>  	clk_rate = clk_get_rate(drvdata->clk);
>  	if (!clk_rate)
>  		return -EINVAL;
> diff --git a/drivers/watchdog/lpc18xx_wdt.c b/drivers/watchdog/lpc18xx_wdt.c
> index 60b6d74f267d..1b9b5f21a0df 100644
> --- a/drivers/watchdog/lpc18xx_wdt.c
> +++ b/drivers/watchdog/lpc18xx_wdt.c
> @@ -197,16 +197,10 @@ static const struct watchdog_ops lpc18xx_wdt_ops = {
>  	.restart        = lpc18xx_wdt_restart,
>  };
>  
> -static void lpc18xx_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int lpc18xx_wdt_probe(struct platform_device *pdev)
>  {
>  	struct lpc18xx_wdt_dev *lpc18xx_wdt;
>  	struct device *dev = &pdev->dev;
> -	int ret;
>  
>  	lpc18xx_wdt = devm_kzalloc(dev, sizeof(*lpc18xx_wdt), GFP_KERNEL);
>  	if (!lpc18xx_wdt)
> @@ -216,38 +210,18 @@ static int lpc18xx_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(lpc18xx_wdt->base))
>  		return PTR_ERR(lpc18xx_wdt->base);
>  
> -	lpc18xx_wdt->reg_clk = devm_clk_get(dev, "reg");
> +	lpc18xx_wdt->reg_clk = devm_clk_get_enabled(dev, "reg");
>  	if (IS_ERR(lpc18xx_wdt->reg_clk)) {
>  		dev_err(dev, "failed to get the reg clock\n");
>  		return PTR_ERR(lpc18xx_wdt->reg_clk);
>  	}
>  
> -	lpc18xx_wdt->wdt_clk = devm_clk_get(dev, "wdtclk");
> +	lpc18xx_wdt->wdt_clk = devm_clk_get_enabled(dev, "wdtclk");
>  	if (IS_ERR(lpc18xx_wdt->wdt_clk)) {
>  		dev_err(dev, "failed to get the wdt clock\n");
>  		return PTR_ERR(lpc18xx_wdt->wdt_clk);
>  	}
>  
> -	ret = clk_prepare_enable(lpc18xx_wdt->reg_clk);
> -	if (ret) {
> -		dev_err(dev, "could not prepare or enable sys clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, lpc18xx_clk_disable_unprepare,
> -				       lpc18xx_wdt->reg_clk);
> -	if (ret)
> -		return ret;
> -
> -	ret = clk_prepare_enable(lpc18xx_wdt->wdt_clk);
> -	if (ret) {
> -		dev_err(dev, "could not prepare or enable wdt clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, lpc18xx_clk_disable_unprepare,
> -				       lpc18xx_wdt->wdt_clk);
> -	if (ret)
> -		return ret;
> -
>  	/* We use the clock rate to calculate timeouts */
>  	lpc18xx_wdt->clk_rate = clk_get_rate(lpc18xx_wdt->wdt_clk);
>  	if (lpc18xx_wdt->clk_rate == 0) {
> diff --git a/drivers/watchdog/meson_gxbb_wdt.c b/drivers/watchdog/meson_gxbb_wdt.c
> index d3c9e2f6e63b..cf65d096f3c0 100644
> --- a/drivers/watchdog/meson_gxbb_wdt.c
> +++ b/drivers/watchdog/meson_gxbb_wdt.c
> @@ -146,16 +146,10 @@ static const struct of_device_id meson_gxbb_wdt_dt_ids[] = {
>  };
>  MODULE_DEVICE_TABLE(of, meson_gxbb_wdt_dt_ids);
>  
> -static void meson_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int meson_gxbb_wdt_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
>  	struct meson_gxbb_wdt *data;
> -	int ret;
>  
>  	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
>  	if (!data)
> @@ -165,18 +159,10 @@ static int meson_gxbb_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(data->reg_base))
>  		return PTR_ERR(data->reg_base);
>  
> -	data->clk = devm_clk_get(dev, NULL);
> +	data->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(data->clk))
>  		return PTR_ERR(data->clk);
>  
> -	ret = clk_prepare_enable(data->clk);
> -	if (ret)
> -		return ret;
> -	ret = devm_add_action_or_reset(dev, meson_clk_disable_unprepare,
> -				       data->clk);
> -	if (ret)
> -		return ret;
> -
>  	platform_set_drvdata(pdev, data);
>  
>  	data->wdt_dev.parent = dev;
> diff --git a/drivers/watchdog/of_xilinx_wdt.c b/drivers/watchdog/of_xilinx_wdt.c
> index 3318544366b8..2a079ca04aa3 100644
> --- a/drivers/watchdog/of_xilinx_wdt.c
> +++ b/drivers/watchdog/of_xilinx_wdt.c
> @@ -154,11 +154,6 @@ static u32 xwdt_selftest(struct xwdt_device *xdev)
>  		return XWT_TIMER_FAILED;
>  }
>  
> -static void xwdt_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int xwdt_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
> @@ -193,7 +188,7 @@ static int xwdt_probe(struct platform_device *pdev)
>  
>  	watchdog_set_nowayout(xilinx_wdt_wdd, enable_once);
>  
> -	xdev->clk = devm_clk_get(dev, NULL);
> +	xdev->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(xdev->clk)) {
>  		if (PTR_ERR(xdev->clk) != -ENOENT)
>  			return PTR_ERR(xdev->clk);
> @@ -211,15 +206,6 @@ static int xwdt_probe(struct platform_device *pdev)
>  				 "The watchdog clock freq cannot be obtained\n");
>  	} else {
>  		pfreq = clk_get_rate(xdev->clk);
> -		rc = clk_prepare_enable(xdev->clk);
> -		if (rc) {
> -			dev_err(dev, "unable to enable clock\n");
> -			return rc;
> -		}
> -		rc = devm_add_action_or_reset(dev, xwdt_clk_disable_unprepare,
> -					      xdev->clk);
> -		if (rc)
> -			return rc;
>  	}
>  
>  	/*
> diff --git a/drivers/watchdog/pic32-dmt.c b/drivers/watchdog/pic32-dmt.c
> index f43062b3c4c8..bc4ccddc75a3 100644
> --- a/drivers/watchdog/pic32-dmt.c
> +++ b/drivers/watchdog/pic32-dmt.c
> @@ -164,11 +164,6 @@ static struct watchdog_device pic32_dmt_wdd = {
>  	.ops		= &pic32_dmt_fops,
>  };
>  
> -static void pic32_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int pic32_dmt_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
> @@ -184,20 +179,12 @@ static int pic32_dmt_probe(struct platform_device *pdev)
>  	if (IS_ERR(dmt->regs))
>  		return PTR_ERR(dmt->regs);
>  
> -	dmt->clk = devm_clk_get(dev, NULL);
> +	dmt->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(dmt->clk)) {
>  		dev_err(dev, "clk not found\n");
>  		return PTR_ERR(dmt->clk);
>  	}
>  
> -	ret = clk_prepare_enable(dmt->clk);
> -	if (ret)
> -		return ret;
> -	ret = devm_add_action_or_reset(dev, pic32_clk_disable_unprepare,
> -				       dmt->clk);
> -	if (ret)
> -		return ret;
> -
>  	wdd->timeout = pic32_dmt_get_timeout_secs(dmt);
>  	if (!wdd->timeout) {
>  		dev_err(dev, "failed to read watchdog register timeout\n");
> diff --git a/drivers/watchdog/pic32-wdt.c b/drivers/watchdog/pic32-wdt.c
> index 41715d68d9e9..6d1a00222991 100644
> --- a/drivers/watchdog/pic32-wdt.c
> +++ b/drivers/watchdog/pic32-wdt.c
> @@ -162,11 +162,6 @@ static const struct of_device_id pic32_wdt_dt_ids[] = {
>  };
>  MODULE_DEVICE_TABLE(of, pic32_wdt_dt_ids);
>  
> -static void pic32_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int pic32_wdt_drv_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
> @@ -186,22 +181,12 @@ static int pic32_wdt_drv_probe(struct platform_device *pdev)
>  	if (!wdt->rst_base)
>  		return -ENOMEM;
>  
> -	wdt->clk = devm_clk_get(dev, NULL);
> +	wdt->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(wdt->clk)) {
>  		dev_err(dev, "clk not found\n");
>  		return PTR_ERR(wdt->clk);
>  	}
>  
> -	ret = clk_prepare_enable(wdt->clk);
> -	if (ret) {
> -		dev_err(dev, "clk enable failed\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, pic32_clk_disable_unprepare,
> -				       wdt->clk);
> -	if (ret)
> -		return ret;
> -
>  	if (pic32_wdt_is_win_enabled(wdt)) {
>  		dev_err(dev, "windowed-clear mode is not supported.\n");
>  		return -ENODEV;
> diff --git a/drivers/watchdog/pnx4008_wdt.c b/drivers/watchdog/pnx4008_wdt.c
> index e0ea133c1690..87a44a5675a1 100644
> --- a/drivers/watchdog/pnx4008_wdt.c
> +++ b/drivers/watchdog/pnx4008_wdt.c
> @@ -179,11 +179,6 @@ static struct watchdog_device pnx4008_wdd = {
>  	.max_timeout = MAX_HEARTBEAT,
>  };
>  
> -static void pnx4008_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int pnx4008_wdt_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
> @@ -195,18 +190,10 @@ static int pnx4008_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(wdt_base))
>  		return PTR_ERR(wdt_base);
>  
> -	wdt_clk = devm_clk_get(dev, NULL);
> +	wdt_clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(wdt_clk))
>  		return PTR_ERR(wdt_clk);
>  
> -	ret = clk_prepare_enable(wdt_clk);
> -	if (ret)
> -		return ret;
> -	ret = devm_add_action_or_reset(dev, pnx4008_clk_disable_unprepare,
> -				       wdt_clk);
> -	if (ret)
> -		return ret;
> -
>  	pnx4008_wdd.bootstatus = (readl(WDTIM_RES(wdt_base)) & WDOG_RESET) ?
>  			WDIOF_CARDRESET : 0;
>  	pnx4008_wdd.parent = dev;
> diff --git a/drivers/watchdog/qcom-wdt.c b/drivers/watchdog/qcom-wdt.c
> index 0d2209c5eaca..d776474dcdf3 100644
> --- a/drivers/watchdog/qcom-wdt.c
> +++ b/drivers/watchdog/qcom-wdt.c
> @@ -175,11 +175,6 @@ static const struct watchdog_info qcom_wdt_pt_info = {
>  	.identity	= KBUILD_MODNAME,
>  };
>  
> -static void qcom_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static const struct qcom_wdt_match_data match_data_apcs_tmr = {
>  	.offset = reg_offset_data_apcs_tmr,
>  	.pretimeout = false,
> @@ -226,21 +221,12 @@ static int qcom_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(wdt->base))
>  		return PTR_ERR(wdt->base);
>  
> -	clk = devm_clk_get(dev, NULL);
> +	clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(clk)) {
>  		dev_err(dev, "failed to get input clock\n");
>  		return PTR_ERR(clk);
>  	}
>  
> -	ret = clk_prepare_enable(clk);
> -	if (ret) {
> -		dev_err(dev, "failed to setup clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, qcom_clk_disable_unprepare, clk);
> -	if (ret)
> -		return ret;
> -
>  	/*
>  	 * We use the clock rate to calculate the max timeout, so ensure it's
>  	 * not zero to avoid a divide-by-zero exception.
> diff --git a/drivers/watchdog/rtd119x_wdt.c b/drivers/watchdog/rtd119x_wdt.c
> index 834b94ff3f90..95c8d7abce42 100644
> --- a/drivers/watchdog/rtd119x_wdt.c
> +++ b/drivers/watchdog/rtd119x_wdt.c
> @@ -94,16 +94,10 @@ static const struct of_device_id rtd119x_wdt_dt_ids[] = {
>  	 { }
>  };
>  
> -static void rtd119x_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int rtd119x_wdt_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
>  	struct rtd119x_watchdog_device *data;
> -	int ret;
>  
>  	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
>  	if (!data)
> @@ -113,18 +107,10 @@ static int rtd119x_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(data->base))
>  		return PTR_ERR(data->base);
>  
> -	data->clk = devm_clk_get(dev, NULL);
> +	data->clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(data->clk))
>  		return PTR_ERR(data->clk);
>  
> -	ret = clk_prepare_enable(data->clk);
> -	if (ret)
> -		return ret;
> -	ret = devm_add_action_or_reset(dev, rtd119x_clk_disable_unprepare,
> -				       data->clk);
> -	if (ret)
> -		return ret;
> -
>  	data->wdt_dev.info = &rtd119x_wdt_info;
>  	data->wdt_dev.ops = &rtd119x_wdt_ops;
>  	data->wdt_dev.timeout = 120;
> diff --git a/drivers/watchdog/st_lpc_wdt.c b/drivers/watchdog/st_lpc_wdt.c
> index 14ab6559c748..d79823e1b07e 100644
> --- a/drivers/watchdog/st_lpc_wdt.c
> +++ b/drivers/watchdog/st_lpc_wdt.c
> @@ -142,11 +142,6 @@ static struct watchdog_device st_wdog_dev = {
>  	.ops		= &st_wdog_ops,
>  };
>  
> -static void st_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int st_wdog_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
> @@ -190,7 +185,7 @@ static int st_wdog_probe(struct platform_device *pdev)
>  		return PTR_ERR(regmap);
>  	}
>  
> -	clk = devm_clk_get(dev, NULL);
> +	clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(clk)) {
>  		dev_err(dev, "Unable to request clock\n");
>  		return PTR_ERR(clk);
> @@ -210,15 +205,6 @@ static int st_wdog_probe(struct platform_device *pdev)
>  	st_wdog_dev.max_timeout = 0xFFFFFFFF / st_wdog->clkrate;
>  	st_wdog_dev.parent = dev;
>  
> -	ret = clk_prepare_enable(clk);
> -	if (ret) {
> -		dev_err(dev, "Unable to enable clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, st_clk_disable_unprepare, clk);
> -	if (ret)
> -		return ret;
> -
>  	watchdog_set_drvdata(&st_wdog_dev, st_wdog);
>  	watchdog_set_nowayout(&st_wdog_dev, WATCHDOG_NOWAYOUT);
>  
> diff --git a/drivers/watchdog/stm32_iwdg.c b/drivers/watchdog/stm32_iwdg.c
> index 570a71509d2a..01849720310d 100644
> --- a/drivers/watchdog/stm32_iwdg.c
> +++ b/drivers/watchdog/stm32_iwdg.c
> @@ -150,50 +150,23 @@ static int stm32_iwdg_set_timeout(struct watchdog_device *wdd,
>  	return 0;
>  }
>  
> -static void stm32_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int stm32_iwdg_clk_init(struct platform_device *pdev,
>  			       struct stm32_iwdg *wdt)
>  {
>  	struct device *dev = &pdev->dev;
> -	u32 ret;
>  
> -	wdt->clk_lsi = devm_clk_get(dev, "lsi");
> +	wdt->clk_lsi = devm_clk_get_enabled(dev, "lsi");
>  	if (IS_ERR(wdt->clk_lsi))
>  		return dev_err_probe(dev, PTR_ERR(wdt->clk_lsi), "Unable to get lsi clock\n");
>  
>  	/* optional peripheral clock */
>  	if (wdt->data->has_pclk) {
> -		wdt->clk_pclk = devm_clk_get(dev, "pclk");
> +		wdt->clk_pclk = devm_clk_get_enabled(dev, "pclk");
>  		if (IS_ERR(wdt->clk_pclk))
>  			return dev_err_probe(dev, PTR_ERR(wdt->clk_pclk),
>  					     "Unable to get pclk clock\n");
> -
> -		ret = clk_prepare_enable(wdt->clk_pclk);
> -		if (ret) {
> -			dev_err(dev, "Unable to prepare pclk clock\n");
> -			return ret;
> -		}
> -		ret = devm_add_action_or_reset(dev,
> -					       stm32_clk_disable_unprepare,
> -					       wdt->clk_pclk);
> -		if (ret)
> -			return ret;
>  	}
>  
> -	ret = clk_prepare_enable(wdt->clk_lsi);
> -	if (ret) {
> -		dev_err(dev, "Unable to prepare lsi clock\n");
> -		return ret;
> -	}
> -	ret = devm_add_action_or_reset(dev, stm32_clk_disable_unprepare,
> -				       wdt->clk_lsi);
> -	if (ret)
> -		return ret;
> -
>  	wdt->rate = clk_get_rate(wdt->clk_lsi);
>  
>  	return 0;
> diff --git a/drivers/watchdog/visconti_wdt.c b/drivers/watchdog/visconti_wdt.c
> index 83ef55e66ca8..1127e42734f4 100644
> --- a/drivers/watchdog/visconti_wdt.c
> +++ b/drivers/watchdog/visconti_wdt.c
> @@ -112,11 +112,6 @@ static const struct watchdog_ops visconti_wdt_ops = {
>  	.set_timeout	= visconti_wdt_set_timeout,
>  };
>  
> -static void visconti_clk_disable_unprepare(void *data)
> -{
> -	clk_disable_unprepare(data);
> -}
> -
>  static int visconti_wdt_probe(struct platform_device *pdev)
>  {
>  	struct watchdog_device *wdev;
> @@ -134,20 +129,9 @@ static int visconti_wdt_probe(struct platform_device *pdev)
>  	if (IS_ERR(priv->base))
>  		return PTR_ERR(priv->base);
>  
> -	clk = devm_clk_get(dev, NULL);
> +	clk = devm_clk_get_enabled(dev, NULL);
>  	if (IS_ERR(clk))
>  		return dev_err_probe(dev, PTR_ERR(clk), "Could not get clock\n");
> -
> -	ret = clk_prepare_enable(clk);
> -	if (ret) {
> -		dev_err(dev, "Could not enable clock\n");
> -		return ret;
> -	}
> -
> -	ret = devm_add_action_or_reset(dev, visconti_clk_disable_unprepare, clk);
> -	if (ret)
> -		return ret;
> -
>  	clk_freq = clk_get_rate(clk);
>  	if (!clk_freq)
>  		return -EINVAL;
> -- 
> 2.35.1
> 

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v8 12/16] pwm: atmel: Simplify using devm_clk_get_prepared()

[Uwe Kleine-König]

With devm_clk_get_prepared() caring to unprepare the clock the error
path and remove callback can be simplified accordingly.

Acked-by: Nicolas Ferre <nicolas.ferre@microchip.com>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/pwm/pwm-atmel.c | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/drivers/pwm/pwm-atmel.c b/drivers/pwm/pwm-atmel.c
index 98b34ea9f38e..309c31e40ce4 100644
--- a/drivers/pwm/pwm-atmel.c
+++ b/drivers/pwm/pwm-atmel.c
@@ -480,16 +480,10 @@ static int atmel_pwm_probe(struct platform_device *pdev)
 	if (IS_ERR(atmel_pwm->base))
 		return PTR_ERR(atmel_pwm->base);
 
-	atmel_pwm->clk = devm_clk_get(&pdev->dev, NULL);
+	atmel_pwm->clk = devm_clk_get_prepared(&pdev->dev, NULL);
 	if (IS_ERR(atmel_pwm->clk))
 		return PTR_ERR(atmel_pwm->clk);
 
-	ret = clk_prepare(atmel_pwm->clk);
-	if (ret) {
-		dev_err(&pdev->dev, "failed to prepare PWM clock\n");
-		return ret;
-	}
-
 	atmel_pwm->chip.dev = &pdev->dev;
 	atmel_pwm->chip.ops = &atmel_pwm_ops;
 	atmel_pwm->chip.npwm = 4;
@@ -497,16 +491,12 @@ static int atmel_pwm_probe(struct platform_device *pdev)
 	ret = pwmchip_add(&atmel_pwm->chip);
 	if (ret < 0) {
 		dev_err(&pdev->dev, "failed to add PWM chip %d\n", ret);
-		goto unprepare_clk;
+		return ret;
 	}
 
 	platform_set_drvdata(pdev, atmel_pwm);
 
 	return ret;
-
-unprepare_clk:
-	clk_unprepare(atmel_pwm->clk);
-	return ret;
 }
 
 static int atmel_pwm_remove(struct platform_device *pdev)
@@ -515,8 +505,6 @@ static int atmel_pwm_remove(struct platform_device *pdev)
 
 	pwmchip_remove(&atmel_pwm->chip);
 
-	clk_unprepare(atmel_pwm->clk);
-
 	return 0;
 }
 
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v8 12/16] pwm: atmel: Simplify using devm_clk_get_prepared()

[Claudiu.Beznea]

On 14.03.2022 16:16, Uwe Kleine-König wrote:
> EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe
> 
> With devm_clk_get_prepared() caring to unprepare the clock the error
> path and remove callback can be simplified accordingly.
> 
> Acked-by: Nicolas Ferre <nicolas.ferre@microchip.com>
> Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Reviewed-by: Claudiu Beznea <claudiu.beznea@microchip.com>

> ---
>  drivers/pwm/pwm-atmel.c | 16 ++--------------
>  1 file changed, 2 insertions(+), 14 deletions(-)
> 
> diff --git a/drivers/pwm/pwm-atmel.c b/drivers/pwm/pwm-atmel.c
> index 98b34ea9f38e..309c31e40ce4 100644
> --- a/drivers/pwm/pwm-atmel.c
> +++ b/drivers/pwm/pwm-atmel.c
> @@ -480,16 +480,10 @@ static int atmel_pwm_probe(struct platform_device *pdev)
>         if (IS_ERR(atmel_pwm->base))
>                 return PTR_ERR(atmel_pwm->base);
> 
> -       atmel_pwm->clk = devm_clk_get(&pdev->dev, NULL);
> +       atmel_pwm->clk = devm_clk_get_prepared(&pdev->dev, NULL);
>         if (IS_ERR(atmel_pwm->clk))
>                 return PTR_ERR(atmel_pwm->clk);
> 
> -       ret = clk_prepare(atmel_pwm->clk);
> -       if (ret) {
> -               dev_err(&pdev->dev, "failed to prepare PWM clock\n");
> -               return ret;
> -       }
> -
>         atmel_pwm->chip.dev = &pdev->dev;
>         atmel_pwm->chip.ops = &atmel_pwm_ops;
>         atmel_pwm->chip.npwm = 4;
> @@ -497,16 +491,12 @@ static int atmel_pwm_probe(struct platform_device *pdev)
>         ret = pwmchip_add(&atmel_pwm->chip);
>         if (ret < 0) {
>                 dev_err(&pdev->dev, "failed to add PWM chip %d\n", ret);
> -               goto unprepare_clk;
> +               return ret;
>         }
> 
>         platform_set_drvdata(pdev, atmel_pwm);
> 
>         return ret;
> -
> -unprepare_clk:
> -       clk_unprepare(atmel_pwm->clk);
> -       return ret;
>  }
> 
>  static int atmel_pwm_remove(struct platform_device *pdev)
> @@ -515,8 +505,6 @@ static int atmel_pwm_remove(struct platform_device *pdev)
> 
>         pwmchip_remove(&atmel_pwm->chip);
> 
> -       clk_unprepare(atmel_pwm->clk);
> -
>         return 0;
>  }
> 
> --
> 2.35.1
> 

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v8 13/16] rtc: at91sam9: Simplify using devm_clk_get_enabled()

[Uwe Kleine-König]

devm_clk_get_enabled() returns the clk already (prepared and) enabled
and the automatically called cleanup cares for disabling (and
unpreparing). So simplify .probe() and .remove() accordingly.

Acked-by: Nicolas Ferre <nicolas.ferre@microchip.com>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/rtc/rtc-at91sam9.c | 22 ++++------------------
 1 file changed, 4 insertions(+), 18 deletions(-)

diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index b7b5ea1a4e67..d54127aba1e9 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -374,21 +374,14 @@ static int at91_rtc_probe(struct platform_device *pdev)
 		return -ENOMEM;
 	}
 
-	rtc->sclk = devm_clk_get(&pdev->dev, NULL);
+	rtc->sclk = devm_clk_get_enabled(&pdev->dev, NULL);
 	if (IS_ERR(rtc->sclk))
 		return PTR_ERR(rtc->sclk);
 
-	ret = clk_prepare_enable(rtc->sclk);
-	if (ret) {
-		dev_err(&pdev->dev, "Could not enable slow clock\n");
-		return ret;
-	}
-
 	sclk_rate = clk_get_rate(rtc->sclk);
 	if (!sclk_rate || sclk_rate > AT91_RTT_RTPRES) {
 		dev_err(&pdev->dev, "Invalid slow clock rate\n");
-		ret = -EINVAL;
-		goto err_clk;
+		return -EINVAL;
 	}
 
 	mr = rtt_readl(rtc, MR);
@@ -406,7 +399,7 @@ static int at91_rtc_probe(struct platform_device *pdev)
 	rtc->rtcdev = devm_rtc_allocate_device(&pdev->dev);
 	if (IS_ERR(rtc->rtcdev)) {
 		ret = PTR_ERR(rtc->rtcdev);
-		goto err_clk;
+		return ret;
 	}
 
 	rtc->rtcdev->ops = &at91_rtc_ops;
@@ -418,7 +411,7 @@ static int at91_rtc_probe(struct platform_device *pdev)
 			       dev_name(&rtc->rtcdev->dev), rtc);
 	if (ret) {
 		dev_dbg(&pdev->dev, "can't share IRQ %d?\n", rtc->irq);
-		goto err_clk;
+		return ret;
 	}
 
 	/* NOTE:  sam9260 rev A silicon has a ROM bug which resets the
@@ -432,11 +425,6 @@ static int at91_rtc_probe(struct platform_device *pdev)
 			 dev_name(&rtc->rtcdev->dev));
 
 	return devm_rtc_register_device(rtc->rtcdev);
-
-err_clk:
-	clk_disable_unprepare(rtc->sclk);
-
-	return ret;
 }
 
 /*
@@ -450,8 +438,6 @@ static int at91_rtc_remove(struct platform_device *pdev)
 	/* disable all interrupts */
 	rtt_writel(rtc, MR, mr & ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN));
 
-	clk_disable_unprepare(rtc->sclk);
-
 	return 0;
 }
 
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v8 14/16] i2c: imx: Simplify using devm_clk_get_enabled()

[Uwe Kleine-König]

devm_clk_get_enabled() returns the clk already (prepared and) enabled
and the automatically called cleanup cares for disabling (and
unpreparing). So simplify .probe() and .remove() accordingly.

Acked-by: Oleksij Rempel <o.rempel@pengutronix.de>
Acked-by: Wolfram Sang <wsa@kernel.org>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
 drivers/i2c/busses/i2c-imx.c | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c
index 27f969b3dc07..6c346b0bec8b 100644
--- a/drivers/i2c/busses/i2c-imx.c
+++ b/drivers/i2c/busses/i2c-imx.c
@@ -1448,16 +1448,10 @@ static int i2c_imx_probe(struct platform_device *pdev)
 	ACPI_COMPANION_SET(&i2c_imx->adapter.dev, ACPI_COMPANION(&pdev->dev));
 
 	/* Get I2C clock */
-	i2c_imx->clk = devm_clk_get(&pdev->dev, NULL);
+	i2c_imx->clk = devm_clk_get_enabled(&pdev->dev, NULL);
 	if (IS_ERR(i2c_imx->clk))
 		return dev_err_probe(&pdev->dev, PTR_ERR(i2c_imx->clk),
-				     "can't get I2C clock\n");
-
-	ret = clk_prepare_enable(i2c_imx->clk);
-	if (ret) {
-		dev_err(&pdev->dev, "can't enable I2C clock, ret=%d\n", ret);
-		return ret;
-	}
+				     "can't get prepared I2C clock\n");
 
 	/* Init queue */
 	init_waitqueue_head(&i2c_imx->queue);
@@ -1530,7 +1524,6 @@ static int i2c_imx_probe(struct platform_device *pdev)
 	pm_runtime_disable(&pdev->dev);
 	pm_runtime_set_suspended(&pdev->dev);
 	pm_runtime_dont_use_autosuspend(&pdev->dev);
-	clk_disable_unprepare(i2c_imx->clk);
 	return ret;
 }
 
@@ -1562,7 +1555,6 @@ static int i2c_imx_remove(struct platform_device *pdev)
 	irq = platform_get_irq(pdev, 0);
 	if (irq >= 0)
 		free_irq(irq, i2c_imx);
-	clk_disable_unprepare(i2c_imx->clk);
 
 	pm_runtime_put_noidle(&pdev->dev);
 	pm_runtime_disable(&pdev->dev);
-- 
2.35.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel