* [PATCH v8 00/16] clk: provide new devm helpers for prepared and enabled clocks
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: linux-clk, kernel, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine
Hello,
this is another try to convince the relevant people that
devm_clk_get_enabled() is a nice idea. Compared to v7 (back in May 2021) this
series is rebased to v5.17-rc8 and converts quite some drivers that open code
devm_clk_get_enabled() up to now (patches #3 - #11).
A concern about devm_clk_get_enabled() in v7 was that it helps people to be
lazy and I agree that in some situations when devm_clk_get_enabled() is used it
would be more efficient and sensible to care to only enable the clk when really
needed.
On the other hand, the function is right for some users, e.g. the watchdog
drivers. For the others it's not so simple to judge. Given that there are a
lot of drivers that are lazy even if doing so is some effort (i.e. calling
clk_prepare_enable() and devm_add_action()) convinces me, that introducing the
function family is sensible. (And if you want to work on these drivers,
grepping for devm_clk_get_enabled gives you a few candidates once the
series is in :-)
Otherwise looking at the diffstat of this series:
48 files changed, 257 insertions(+), 851 deletions(-)
is quite convincing. Just the first two patches (which introduce the new
functions) account for
2 files changed, 169 insertions(+), 17 deletions(-)
. A rough third of the added lines is documentation. The rest is driver
updates which then has:
46 files changed, 88 insertions(+), 834 deletions(-)
which makes a really nice cleanup.
The series is build-tested on arm64, m68k, powerpc, riscv, s390, sparc64
and x86_64 using an allmodconfig.
Best regards
Uwe
Uwe Kleine-König (16):
clk: generalize devm_clk_get() a bit
clk: Provide new devm_clk helpers for prepared and enabled clocks
hwmon: Make use of devm_clk_get_enabled()
iio: Make use of devm_clk_get_enabled()
hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
bus: bt1: Don't open code devm_clk_get_enabled()
gpio: vf610: Simplify error handling in probe
drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
rtc: ingenic: Simplify using devm_clk_get_enabled()
clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()
watchdog: Make use of devm_clk_get_enabled()
pwm: atmel: Simplify using devm_clk_get_prepared()
rtc: at91sam9: Simplify using devm_clk_get_enabled()
i2c: imx: Simplify using devm_clk_get_enabled()
spi: davinci: Simplify using devm_clk_get_enabled()
dmaengine: lgm: Fix error handling
drivers/bus/bt1-apb.c | 23 +------
drivers/bus/bt1-axi.c | 23 +------
drivers/char/hw_random/meson-rng.c | 20 +-----
drivers/clk/clk-devres.c | 96 ++++++++++++++++++++++-----
drivers/clk/meson/axg-audio.c | 36 ++--------
drivers/dma/lgm/lgm-dma.c | 8 +--
drivers/gpio/gpio-vf610.c | 45 +++----------
drivers/gpu/drm/meson/meson_dw_hdmi.c | 48 +++++---------
drivers/hwmon/axi-fan-control.c | 15 +----
drivers/hwmon/ltc2947-core.c | 17 +----
drivers/hwmon/mr75203.c | 26 +-------
drivers/hwmon/sparx5-temp.c | 19 +-----
drivers/i2c/busses/i2c-imx.c | 12 +---
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 +----
drivers/pwm/pwm-atmel.c | 16 +----
drivers/rtc/rtc-at91sam9.c | 22 ++----
drivers/rtc/rtc-jz4740.c | 21 +-----
drivers/spi/spi-davinci.c | 11 +--
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 +----
include/linux/clk.h | 90 ++++++++++++++++++++++++-
48 files changed, 257 insertions(+), 851 deletions(-)
base-commit: 09688c0166e76ce2fb85e86b9d99be8b0084cdf9
--
2.35.1
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 00/16] clk: provide new devm helpers for prepared and enabled clocks
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: linux-clk, kernel, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine
Hello,
this is another try to convince the relevant people that
devm_clk_get_enabled() is a nice idea. Compared to v7 (back in May 2021) this
series is rebased to v5.17-rc8 and converts quite some drivers that open code
devm_clk_get_enabled() up to now (patches #3 - #11).
A concern about devm_clk_get_enabled() in v7 was that it helps people to be
lazy and I agree that in some situations when devm_clk_get_enabled() is used it
would be more efficient and sensible to care to only enable the clk when really
needed.
On the other hand, the function is right for some users, e.g. the watchdog
drivers. For the others it's not so simple to judge. Given that there are a
lot of drivers that are lazy even if doing so is some effort (i.e. calling
clk_prepare_enable() and devm_add_action()) convinces me, that introducing the
function family is sensible. (And if you want to work on these drivers,
grepping for devm_clk_get_enabled gives you a few candidates once the
series is in :-)
Otherwise looking at the diffstat of this series:
48 files changed, 257 insertions(+), 851 deletions(-)
is quite convincing. Just the first two patches (which introduce the new
functions) account for
2 files changed, 169 insertions(+), 17 deletions(-)
. A rough third of the added lines is documentation. The rest is driver
updates which then has:
46 files changed, 88 insertions(+), 834 deletions(-)
which makes a really nice cleanup.
The series is build-tested on arm64, m68k, powerpc, riscv, s390, sparc64
and x86_64 using an allmodconfig.
Best regards
Uwe
Uwe Kleine-König (16):
clk: generalize devm_clk_get() a bit
clk: Provide new devm_clk helpers for prepared and enabled clocks
hwmon: Make use of devm_clk_get_enabled()
iio: Make use of devm_clk_get_enabled()
hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
bus: bt1: Don't open code devm_clk_get_enabled()
gpio: vf610: Simplify error handling in probe
drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
rtc: ingenic: Simplify using devm_clk_get_enabled()
clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()
watchdog: Make use of devm_clk_get_enabled()
pwm: atmel: Simplify using devm_clk_get_prepared()
rtc: at91sam9: Simplify using devm_clk_get_enabled()
i2c: imx: Simplify using devm_clk_get_enabled()
spi: davinci: Simplify using devm_clk_get_enabled()
dmaengine: lgm: Fix error handling
drivers/bus/bt1-apb.c | 23 +------
drivers/bus/bt1-axi.c | 23 +------
drivers/char/hw_random/meson-rng.c | 20 +-----
drivers/clk/clk-devres.c | 96 ++++++++++++++++++++++-----
drivers/clk/meson/axg-audio.c | 36 ++--------
drivers/dma/lgm/lgm-dma.c | 8 +--
drivers/gpio/gpio-vf610.c | 45 +++----------
drivers/gpu/drm/meson/meson_dw_hdmi.c | 48 +++++---------
drivers/hwmon/axi-fan-control.c | 15 +----
drivers/hwmon/ltc2947-core.c | 17 +----
drivers/hwmon/mr75203.c | 26 +-------
drivers/hwmon/sparx5-temp.c | 19 +-----
drivers/i2c/busses/i2c-imx.c | 12 +---
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 +----
drivers/pwm/pwm-atmel.c | 16 +----
drivers/rtc/rtc-at91sam9.c | 22 ++----
drivers/rtc/rtc-jz4740.c | 21 +-----
drivers/spi/spi-davinci.c | 11 +--
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 +----
include/linux/clk.h | 90 ++++++++++++++++++++++++-
48 files changed, 257 insertions(+), 851 deletions(-)
base-commit: 09688c0166e76ce2fb85e86b9d99be8b0084cdf9
--
2.35.1
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: Tomislav Denis, linux-iio, Alexandre Torgue, dri-devel,
Bjorn Andersson, linux-i2c, Nobuhiro Iwamatsu, linux-clk,
linux-watchdog, linux-rtc, Michal Simek, linux-stm32, Andy Gross,
Alexandru Ardelean, Keguang Zhang, Patrice Chotard, linux-pwm,
kernel, linux-arm-msm, Anand Ashok Dumbre, Vladimir Zapolskiy,
linux-gpio, André Gustavo Nakagomi Lopez, Jonathan Cameron,
linux-amlogic, Amireddy Mallikarjuna reddy, linux-mips,
linux-spi, Cai Huoqing, linux-crypto, Maxime Coquelin, dmaengine
Allow to add an exit hook to devm managed clocks. Also use
clk_get_optional() in devm_clk_get_optional instead of open coding it.
The generalisation will be used in the next commit to add some more
devm_clk helpers.
Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/clk/clk-devres.c | 67 ++++++++++++++++++++++++++++++----------
1 file changed, 50 insertions(+), 17 deletions(-)
diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
index f9d5b7334341..fb7761888b30 100644
--- a/drivers/clk/clk-devres.c
+++ b/drivers/clk/clk-devres.c
@@ -4,39 +4,72 @@
#include <linux/export.h>
#include <linux/gfp.h>
+struct devm_clk_state {
+ struct clk *clk;
+ void (*exit)(struct clk *clk);
+};
+
static void devm_clk_release(struct device *dev, void *res)
{
- clk_put(*(struct clk **)res);
+ struct devm_clk_state *state = *(struct devm_clk_state **)res;
+
+ if (state->exit)
+ state->exit(state->clk);
+
+ clk_put(state->clk);
}
-struct clk *devm_clk_get(struct device *dev, const char *id)
+static struct clk *__devm_clk_get(struct device *dev, const char *id,
+ struct clk *(*get)(struct device *dev, const char *id),
+ int (*init)(struct clk *clk),
+ void (*exit)(struct clk *clk))
{
- struct clk **ptr, *clk;
+ struct devm_clk_state *state;
+ struct clk *clk;
+ int ret;
- ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
- if (!ptr)
+ state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
+ if (!state)
return ERR_PTR(-ENOMEM);
- clk = clk_get(dev, id);
- if (!IS_ERR(clk)) {
- *ptr = clk;
- devres_add(dev, ptr);
- } else {
- devres_free(ptr);
+ clk = get(dev, id);
+ if (IS_ERR(clk)) {
+ ret = PTR_ERR(clk);
+ goto err_clk_get;
}
+ if (init) {
+ ret = init(clk);
+ if (ret)
+ goto err_clk_init;
+ }
+
+ state->clk = clk;
+ state->exit = exit;
+
+ devres_add(dev, state);
+
return clk;
+
+err_clk_init:
+
+ clk_put(clk);
+err_clk_get:
+
+ devres_free(state);
+ return ERR_PTR(ret);
}
-EXPORT_SYMBOL(devm_clk_get);
-struct clk *devm_clk_get_optional(struct device *dev, const char *id)
+struct clk *devm_clk_get(struct device *dev, const char *id)
{
- struct clk *clk = devm_clk_get(dev, id);
+ return __devm_clk_get(dev, id, clk_get, NULL, NULL);
- if (clk == ERR_PTR(-ENOENT))
- return NULL;
+}
+EXPORT_SYMBOL(devm_clk_get);
- return clk;
+struct clk *devm_clk_get_optional(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
}
EXPORT_SYMBOL(devm_clk_get_optional);
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: linux-clk, kernel, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine, Jonathan Cameron, Alexandru Ardelean
Allow to add an exit hook to devm managed clocks. Also use
clk_get_optional() in devm_clk_get_optional instead of open coding it.
The generalisation will be used in the next commit to add some more
devm_clk helpers.
Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/clk/clk-devres.c | 67 ++++++++++++++++++++++++++++++----------
1 file changed, 50 insertions(+), 17 deletions(-)
diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
index f9d5b7334341..fb7761888b30 100644
--- a/drivers/clk/clk-devres.c
+++ b/drivers/clk/clk-devres.c
@@ -4,39 +4,72 @@
#include <linux/export.h>
#include <linux/gfp.h>
+struct devm_clk_state {
+ struct clk *clk;
+ void (*exit)(struct clk *clk);
+};
+
static void devm_clk_release(struct device *dev, void *res)
{
- clk_put(*(struct clk **)res);
+ struct devm_clk_state *state = *(struct devm_clk_state **)res;
+
+ if (state->exit)
+ state->exit(state->clk);
+
+ clk_put(state->clk);
}
-struct clk *devm_clk_get(struct device *dev, const char *id)
+static struct clk *__devm_clk_get(struct device *dev, const char *id,
+ struct clk *(*get)(struct device *dev, const char *id),
+ int (*init)(struct clk *clk),
+ void (*exit)(struct clk *clk))
{
- struct clk **ptr, *clk;
+ struct devm_clk_state *state;
+ struct clk *clk;
+ int ret;
- ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
- if (!ptr)
+ state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
+ if (!state)
return ERR_PTR(-ENOMEM);
- clk = clk_get(dev, id);
- if (!IS_ERR(clk)) {
- *ptr = clk;
- devres_add(dev, ptr);
- } else {
- devres_free(ptr);
+ clk = get(dev, id);
+ if (IS_ERR(clk)) {
+ ret = PTR_ERR(clk);
+ goto err_clk_get;
}
+ if (init) {
+ ret = init(clk);
+ if (ret)
+ goto err_clk_init;
+ }
+
+ state->clk = clk;
+ state->exit = exit;
+
+ devres_add(dev, state);
+
return clk;
+
+err_clk_init:
+
+ clk_put(clk);
+err_clk_get:
+
+ devres_free(state);
+ return ERR_PTR(ret);
}
-EXPORT_SYMBOL(devm_clk_get);
-struct clk *devm_clk_get_optional(struct device *dev, const char *id)
+struct clk *devm_clk_get(struct device *dev, const char *id)
{
- struct clk *clk = devm_clk_get(dev, id);
+ return __devm_clk_get(dev, id, clk_get, NULL, NULL);
- if (clk == ERR_PTR(-ENOENT))
- return NULL;
+}
+EXPORT_SYMBOL(devm_clk_get);
- return clk;
+struct clk *devm_clk_get_optional(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
}
EXPORT_SYMBOL(devm_clk_get_optional);
--
2.35.1
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: linux-clk, kernel, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine, Jonathan Cameron, Alexandru Ardelean
Allow to add an exit hook to devm managed clocks. Also use
clk_get_optional() in devm_clk_get_optional instead of open coding it.
The generalisation will be used in the next commit to add some more
devm_clk helpers.
Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/clk/clk-devres.c | 67 ++++++++++++++++++++++++++++++----------
1 file changed, 50 insertions(+), 17 deletions(-)
diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
index f9d5b7334341..fb7761888b30 100644
--- a/drivers/clk/clk-devres.c
+++ b/drivers/clk/clk-devres.c
@@ -4,39 +4,72 @@
#include <linux/export.h>
#include <linux/gfp.h>
+struct devm_clk_state {
+ struct clk *clk;
+ void (*exit)(struct clk *clk);
+};
+
static void devm_clk_release(struct device *dev, void *res)
{
- clk_put(*(struct clk **)res);
+ struct devm_clk_state *state = *(struct devm_clk_state **)res;
+
+ if (state->exit)
+ state->exit(state->clk);
+
+ clk_put(state->clk);
}
-struct clk *devm_clk_get(struct device *dev, const char *id)
+static struct clk *__devm_clk_get(struct device *dev, const char *id,
+ struct clk *(*get)(struct device *dev, const char *id),
+ int (*init)(struct clk *clk),
+ void (*exit)(struct clk *clk))
{
- struct clk **ptr, *clk;
+ struct devm_clk_state *state;
+ struct clk *clk;
+ int ret;
- ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
- if (!ptr)
+ state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
+ if (!state)
return ERR_PTR(-ENOMEM);
- clk = clk_get(dev, id);
- if (!IS_ERR(clk)) {
- *ptr = clk;
- devres_add(dev, ptr);
- } else {
- devres_free(ptr);
+ clk = get(dev, id);
+ if (IS_ERR(clk)) {
+ ret = PTR_ERR(clk);
+ goto err_clk_get;
}
+ if (init) {
+ ret = init(clk);
+ if (ret)
+ goto err_clk_init;
+ }
+
+ state->clk = clk;
+ state->exit = exit;
+
+ devres_add(dev, state);
+
return clk;
+
+err_clk_init:
+
+ clk_put(clk);
+err_clk_get:
+
+ devres_free(state);
+ return ERR_PTR(ret);
}
-EXPORT_SYMBOL(devm_clk_get);
-struct clk *devm_clk_get_optional(struct device *dev, const char *id)
+struct clk *devm_clk_get(struct device *dev, const char *id)
{
- struct clk *clk = devm_clk_get(dev, id);
+ return __devm_clk_get(dev, id, clk_get, NULL, NULL);
- if (clk == ERR_PTR(-ENOENT))
- return NULL;
+}
+EXPORT_SYMBOL(devm_clk_get);
- return clk;
+struct clk *devm_clk_get_optional(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
}
EXPORT_SYMBOL(devm_clk_get_optional);
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-06-21 19:57 ` Jon Hunter
-1 siblings, 0 replies; 88+ messages in thread
From: Jon Hunter @ 2022-06-21 19:57 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: linux-clk, kernel, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine, Jonathan Cameron, Alexandru Ardelean, linux-tegra
Hi Uwe,
On 14/03/2022 14:16, Uwe Kleine-König wrote:
> Allow to add an exit hook to devm managed clocks. Also use
> clk_get_optional() in devm_clk_get_optional instead of open coding it.
> The generalisation will be used in the next commit to add some more
> devm_clk helpers.
>
> Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> ---
> drivers/clk/clk-devres.c | 67 ++++++++++++++++++++++++++++++----------
> 1 file changed, 50 insertions(+), 17 deletions(-)
>
> diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> index f9d5b7334341..fb7761888b30 100644
> --- a/drivers/clk/clk-devres.c
> +++ b/drivers/clk/clk-devres.c
> @@ -4,39 +4,72 @@
> #include <linux/export.h>
> #include <linux/gfp.h>
>
> +struct devm_clk_state {
> + struct clk *clk;
> + void (*exit)(struct clk *clk);
> +};
> +
> static void devm_clk_release(struct device *dev, void *res)
> {
> - clk_put(*(struct clk **)res);
> + struct devm_clk_state *state = *(struct devm_clk_state **)res;
> +
> + if (state->exit)
> + state->exit(state->clk);
> +
> + clk_put(state->clk);
> }
>
> -struct clk *devm_clk_get(struct device *dev, const char *id)
> +static struct clk *__devm_clk_get(struct device *dev, const char *id,
> + struct clk *(*get)(struct device *dev, const char *id),
> + int (*init)(struct clk *clk),
> + void (*exit)(struct clk *clk))
> {
> - struct clk **ptr, *clk;
> + struct devm_clk_state *state;
> + struct clk *clk;
> + int ret;
>
> - ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
> - if (!ptr)
> + state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
> + if (!state)
> return ERR_PTR(-ENOMEM);
>
> - clk = clk_get(dev, id);
> - if (!IS_ERR(clk)) {
> - *ptr = clk;
> - devres_add(dev, ptr);
> - } else {
> - devres_free(ptr);
> + clk = get(dev, id);
> + if (IS_ERR(clk)) {
> + ret = PTR_ERR(clk);
> + goto err_clk_get;
> }
>
> + if (init) {
> + ret = init(clk);
> + if (ret)
> + goto err_clk_init;
> + }
> +
> + state->clk = clk;
> + state->exit = exit;
> +
> + devres_add(dev, state);
> +
> return clk;
> +
> +err_clk_init:
> +
> + clk_put(clk);
> +err_clk_get:
> +
> + devres_free(state);
> + return ERR_PTR(ret);
> }
> -EXPORT_SYMBOL(devm_clk_get);
>
> -struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> +struct clk *devm_clk_get(struct device *dev, const char *id)
> {
> - struct clk *clk = devm_clk_get(dev, id);
> + return __devm_clk_get(dev, id, clk_get, NULL, NULL);
>
> - if (clk == ERR_PTR(-ENOENT))
> - return NULL;
> +}
> +EXPORT_SYMBOL(devm_clk_get);
>
> - return clk;
> +struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
> }
> EXPORT_SYMBOL(devm_clk_get_optional);
>
Some of our Tegra boards are not booting with the current -next and
bisect is pointing to this commit. Looking at the boot log I am
seeing the following panic ...
[ 2.097048] 8<--- cut here ---
[ 2.097053] Unable to handle kernel paging request at virtual address c216c810
[ 2.097060] [c216c810] *pgd=0201141e(bad)
[ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
[ 2.097088] Modules linked in:
[ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
[ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
[ 2.097113] PC is at 0xc216c810
[ 2.097123] LR is at devm_clk_release+0x18/0x24
[ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
[ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
[ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
[ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
[ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
[ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
[ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
[ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
[ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
[ 2.097236] Register r2 information: NULL pointer
[ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
[ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
[ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
[ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
[ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
[ 2.097341] Register r8 information: non-slab/vmalloc memory
[ 2.097348] Register r9 information: non-slab/vmalloc memory
[ 2.097355] Register r10 information: non-slab/vmalloc memory
[ 2.097362] Register r11 information: non-slab/vmalloc memory
[ 2.097369] Register r12 information: non-paged memory
[ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
[ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
[ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
[ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
[ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
[ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
[ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
[ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
[ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
[ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
[ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
[ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
[ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
[ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
[ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
[ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
[ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
[ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
[ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
[ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
[ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
[ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
[ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
[ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
[ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
[ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
[ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
[ 2.097749] bus_add_driver from driver_register+0x7c/0x118
[ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
[ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
[ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
[ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
[ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
[ 2.097839] dfa0: 00000000 00000000 00000000 00000000
[ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
[ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
[ 2.097872] ---[ end trace 0000000000000000 ]---
Let me know if you have any thoughts.
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-21 19:57 ` Jon Hunter
0 siblings, 0 replies; 88+ messages in thread
From: Jon Hunter @ 2022-06-21 19:57 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: linux-clk, kernel, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine, Jonathan Cameron, Alexandru Ardelean, linux-tegra
Hi Uwe,
On 14/03/2022 14:16, Uwe Kleine-König wrote:
> Allow to add an exit hook to devm managed clocks. Also use
> clk_get_optional() in devm_clk_get_optional instead of open coding it.
> The generalisation will be used in the next commit to add some more
> devm_clk helpers.
>
> Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> ---
> drivers/clk/clk-devres.c | 67 ++++++++++++++++++++++++++++++----------
> 1 file changed, 50 insertions(+), 17 deletions(-)
>
> diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> index f9d5b7334341..fb7761888b30 100644
> --- a/drivers/clk/clk-devres.c
> +++ b/drivers/clk/clk-devres.c
> @@ -4,39 +4,72 @@
> #include <linux/export.h>
> #include <linux/gfp.h>
>
> +struct devm_clk_state {
> + struct clk *clk;
> + void (*exit)(struct clk *clk);
> +};
> +
> static void devm_clk_release(struct device *dev, void *res)
> {
> - clk_put(*(struct clk **)res);
> + struct devm_clk_state *state = *(struct devm_clk_state **)res;
> +
> + if (state->exit)
> + state->exit(state->clk);
> +
> + clk_put(state->clk);
> }
>
> -struct clk *devm_clk_get(struct device *dev, const char *id)
> +static struct clk *__devm_clk_get(struct device *dev, const char *id,
> + struct clk *(*get)(struct device *dev, const char *id),
> + int (*init)(struct clk *clk),
> + void (*exit)(struct clk *clk))
> {
> - struct clk **ptr, *clk;
> + struct devm_clk_state *state;
> + struct clk *clk;
> + int ret;
>
> - ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
> - if (!ptr)
> + state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
> + if (!state)
> return ERR_PTR(-ENOMEM);
>
> - clk = clk_get(dev, id);
> - if (!IS_ERR(clk)) {
> - *ptr = clk;
> - devres_add(dev, ptr);
> - } else {
> - devres_free(ptr);
> + clk = get(dev, id);
> + if (IS_ERR(clk)) {
> + ret = PTR_ERR(clk);
> + goto err_clk_get;
> }
>
> + if (init) {
> + ret = init(clk);
> + if (ret)
> + goto err_clk_init;
> + }
> +
> + state->clk = clk;
> + state->exit = exit;
> +
> + devres_add(dev, state);
> +
> return clk;
> +
> +err_clk_init:
> +
> + clk_put(clk);
> +err_clk_get:
> +
> + devres_free(state);
> + return ERR_PTR(ret);
> }
> -EXPORT_SYMBOL(devm_clk_get);
>
> -struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> +struct clk *devm_clk_get(struct device *dev, const char *id)
> {
> - struct clk *clk = devm_clk_get(dev, id);
> + return __devm_clk_get(dev, id, clk_get, NULL, NULL);
>
> - if (clk == ERR_PTR(-ENOENT))
> - return NULL;
> +}
> +EXPORT_SYMBOL(devm_clk_get);
>
> - return clk;
> +struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
> }
> EXPORT_SYMBOL(devm_clk_get_optional);
>
Some of our Tegra boards are not booting with the current -next and
bisect is pointing to this commit. Looking at the boot log I am
seeing the following panic ...
[ 2.097048] 8<--- cut here ---
[ 2.097053] Unable to handle kernel paging request at virtual address c216c810
[ 2.097060] [c216c810] *pgd=0201141e(bad)
[ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
[ 2.097088] Modules linked in:
[ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
[ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
[ 2.097113] PC is at 0xc216c810
[ 2.097123] LR is at devm_clk_release+0x18/0x24
[ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
[ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
[ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
[ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
[ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
[ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
[ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
[ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
[ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
[ 2.097236] Register r2 information: NULL pointer
[ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
[ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
[ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
[ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
[ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
[ 2.097341] Register r8 information: non-slab/vmalloc memory
[ 2.097348] Register r9 information: non-slab/vmalloc memory
[ 2.097355] Register r10 information: non-slab/vmalloc memory
[ 2.097362] Register r11 information: non-slab/vmalloc memory
[ 2.097369] Register r12 information: non-paged memory
[ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
[ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
[ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
[ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
[ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
[ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
[ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
[ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
[ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
[ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
[ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
[ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
[ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
[ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
[ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
[ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
[ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
[ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
[ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
[ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
[ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
[ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
[ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
[ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
[ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
[ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
[ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
[ 2.097749] bus_add_driver from driver_register+0x7c/0x118
[ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
[ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
[ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
[ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
[ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
[ 2.097839] dfa0: 00000000 00000000 00000000 00000000
[ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
[ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
[ 2.097872] ---[ end trace 0000000000000000 ]---
Let me know if you have any thoughts.
Cheers
Jon
--
nvpublic
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-21 19:57 ` Jon Hunter
0 siblings, 0 replies; 88+ messages in thread
From: Jon Hunter @ 2022-06-21 19:57 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: Tomislav Denis, linux-iio, Alexandre Torgue, dri-devel,
Bjorn Andersson, linux-i2c, Nobuhiro Iwamatsu, linux-clk,
linux-watchdog, linux-rtc, Michal Simek, linux-stm32, Andy Gross,
Alexandru Ardelean, Keguang Zhang, Patrice Chotard, linux-pwm,
kernel, linux-arm-msm, Anand Ashok Dumbre, Vladimir Zapolskiy,
linux-gpio, André Gustavo Nakagomi Lopez, Jonathan Cameron,
linux-tegra, linux-amlogic, Amireddy Mallikarjuna reddy,
linux-mips, linux-spi, Cai Huoqing, linux-crypto,
Maxime Coquelin, dmaengine
Hi Uwe,
On 14/03/2022 14:16, Uwe Kleine-König wrote:
> Allow to add an exit hook to devm managed clocks. Also use
> clk_get_optional() in devm_clk_get_optional instead of open coding it.
> The generalisation will be used in the next commit to add some more
> devm_clk helpers.
>
> Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> ---
> drivers/clk/clk-devres.c | 67 ++++++++++++++++++++++++++++++----------
> 1 file changed, 50 insertions(+), 17 deletions(-)
>
> diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> index f9d5b7334341..fb7761888b30 100644
> --- a/drivers/clk/clk-devres.c
> +++ b/drivers/clk/clk-devres.c
> @@ -4,39 +4,72 @@
> #include <linux/export.h>
> #include <linux/gfp.h>
>
> +struct devm_clk_state {
> + struct clk *clk;
> + void (*exit)(struct clk *clk);
> +};
> +
> static void devm_clk_release(struct device *dev, void *res)
> {
> - clk_put(*(struct clk **)res);
> + struct devm_clk_state *state = *(struct devm_clk_state **)res;
> +
> + if (state->exit)
> + state->exit(state->clk);
> +
> + clk_put(state->clk);
> }
>
> -struct clk *devm_clk_get(struct device *dev, const char *id)
> +static struct clk *__devm_clk_get(struct device *dev, const char *id,
> + struct clk *(*get)(struct device *dev, const char *id),
> + int (*init)(struct clk *clk),
> + void (*exit)(struct clk *clk))
> {
> - struct clk **ptr, *clk;
> + struct devm_clk_state *state;
> + struct clk *clk;
> + int ret;
>
> - ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
> - if (!ptr)
> + state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
> + if (!state)
> return ERR_PTR(-ENOMEM);
>
> - clk = clk_get(dev, id);
> - if (!IS_ERR(clk)) {
> - *ptr = clk;
> - devres_add(dev, ptr);
> - } else {
> - devres_free(ptr);
> + clk = get(dev, id);
> + if (IS_ERR(clk)) {
> + ret = PTR_ERR(clk);
> + goto err_clk_get;
> }
>
> + if (init) {
> + ret = init(clk);
> + if (ret)
> + goto err_clk_init;
> + }
> +
> + state->clk = clk;
> + state->exit = exit;
> +
> + devres_add(dev, state);
> +
> return clk;
> +
> +err_clk_init:
> +
> + clk_put(clk);
> +err_clk_get:
> +
> + devres_free(state);
> + return ERR_PTR(ret);
> }
> -EXPORT_SYMBOL(devm_clk_get);
>
> -struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> +struct clk *devm_clk_get(struct device *dev, const char *id)
> {
> - struct clk *clk = devm_clk_get(dev, id);
> + return __devm_clk_get(dev, id, clk_get, NULL, NULL);
>
> - if (clk == ERR_PTR(-ENOENT))
> - return NULL;
> +}
> +EXPORT_SYMBOL(devm_clk_get);
>
> - return clk;
> +struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
> }
> EXPORT_SYMBOL(devm_clk_get_optional);
>
Some of our Tegra boards are not booting with the current -next and
bisect is pointing to this commit. Looking at the boot log I am
seeing the following panic ...
[ 2.097048] 8<--- cut here ---
[ 2.097053] Unable to handle kernel paging request at virtual address c216c810
[ 2.097060] [c216c810] *pgd=0201141e(bad)
[ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
[ 2.097088] Modules linked in:
[ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
[ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
[ 2.097113] PC is at 0xc216c810
[ 2.097123] LR is at devm_clk_release+0x18/0x24
[ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
[ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
[ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
[ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
[ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
[ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
[ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
[ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
[ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
[ 2.097236] Register r2 information: NULL pointer
[ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
[ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
[ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
[ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
[ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
[ 2.097341] Register r8 information: non-slab/vmalloc memory
[ 2.097348] Register r9 information: non-slab/vmalloc memory
[ 2.097355] Register r10 information: non-slab/vmalloc memory
[ 2.097362] Register r11 information: non-slab/vmalloc memory
[ 2.097369] Register r12 information: non-paged memory
[ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
[ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
[ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
[ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
[ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
[ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
[ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
[ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
[ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
[ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
[ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
[ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
[ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
[ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
[ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
[ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
[ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
[ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
[ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
[ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
[ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
[ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
[ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
[ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
[ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
[ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
[ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
[ 2.097749] bus_add_driver from driver_register+0x7c/0x118
[ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
[ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
[ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
[ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
[ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
[ 2.097839] dfa0: 00000000 00000000 00000000 00000000
[ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
[ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
[ 2.097872] ---[ end trace 0000000000000000 ]---
Let me know if you have any thoughts.
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
2022-06-21 19:57 ` Jon Hunter
(?)
@ 2022-06-21 20:49 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-06-21 20:49 UTC (permalink / raw)
To: Jon Hunter, Stephen Boyd
Cc: Alexandre Belloni, Neil Armstrong, David Airlie,
Alexandru Ardelean, Tomislav Denis, dri-devel, Nuno Sá,
Paul Cercueil, Vladimir Zapolskiy, Thierry Reding, linux-i2c,
Nobuhiro Iwamatsu, Oleksij Rempel, Lee Jones, linux-clk,
Jerome Brunet, linux-rtc, Herbert Xu,
André Gustavo Nakagomi Lopez, Kevin Hilman,
Bartosz Golaszewski, Russell King, Claudiu Beznea, linux-iio,
Andy Gross, linux-arm-kernel, Maxime Coquelin, Cai Huoqing,
linux-mips, Keguang Zhang, Michael Turquette, Guenter Roeck,
NXP Linux Team, linux-pwm, Jean Delvare, Michal Simek,
linux-watchdog, Michael Hennerich, Martin Blumenstingl,
linux-arm-msm, linux-spi, Anand Ashok Dumbre, Alexandre Torgue,
linux-gpio, Mark Brown, Patrice Chotard, Jonathan Cameron,
linux-tegra, linux-amlogic, Wim Van Sebroeck, kernel,
Lars Povlsen, linux-hwmon, Alessandro Zummo, Greg Kroah-Hartman,
dmaengine, linux-stm32, Nicolas Ferre, UNGLinuxDriver,
Vinod Koul, Bjorn Andersson, Amireddy Mallikarjuna reddy,
linux-crypto, Shawn Guo, Steen Hegelund, Jonathan Cameron
[-- Attachment #1: Type: text/plain, Size: 6190 bytes --]
On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
> Some of our Tegra boards are not booting with the current -next and
> bisect is pointing to this commit. Looking at the boot log I am
> seeing the following panic ...
>
> [ 2.097048] 8<--- cut here ---
> [ 2.097053] Unable to handle kernel paging request at virtual address c216c810
> [ 2.097060] [c216c810] *pgd=0201141e(bad)
> [ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
> [ 2.097088] Modules linked in:
> [ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
> [ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
> [ 2.097113] PC is at 0xc216c810
> [ 2.097123] LR is at devm_clk_release+0x18/0x24
> [ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
> [ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
> [ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
> [ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
> [ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
> [ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
> [ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
> [ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
> [ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
> [ 2.097236] Register r2 information: NULL pointer
> [ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
> [ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
> [ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
> [ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
> [ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
> [ 2.097341] Register r8 information: non-slab/vmalloc memory
> [ 2.097348] Register r9 information: non-slab/vmalloc memory
> [ 2.097355] Register r10 information: non-slab/vmalloc memory
> [ 2.097362] Register r11 information: non-slab/vmalloc memory
> [ 2.097369] Register r12 information: non-paged memory
> [ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
> [ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
> [ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
> [ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
> [ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
> [ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
> [ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
> [ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
> [ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
> [ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
> [ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
> [ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
> [ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
> [ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
> [ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
> [ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
> [ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
> [ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
> [ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
> [ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
> [ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
> [ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
> [ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
> [ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
> [ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
> [ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
> [ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
> [ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
> [ 2.097749] bus_add_driver from driver_register+0x7c/0x118
> [ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
> [ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
> [ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
> [ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
> [ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
> [ 2.097839] dfa0: 00000000 00000000 00000000 00000000
> [ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
> [ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
> [ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
> [ 2.097872] ---[ end trace 0000000000000000 ]---
>
>
> Let me know if you have any thoughts.
Yeah, sorry, there is already a fix at
https://lore.kernel.org/linux-clk/20220620171815.114212-1-u.kleine-koenig@pengutronix.de
(Pro tipp: The commit in next has a Link: footer. If you follow the
link, you find the thread that was actually applied (i.e. v9) and where
the fix is also contained.)
@Stephen: It would be a great favour to our testers if you could apply
the fix ...
Best regards
Uwe
--
Pengutronix e.K. | Uwe Kleine-König |
Industrial Linux Solutions | https://www.pengutronix.de/ |
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-21 20:49 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-06-21 20:49 UTC (permalink / raw)
To: Jon Hunter, Stephen Boyd
Cc: Michael Turquette, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, Tomislav Denis, Heiko Stuebner,
linux-iio, Alexandre Torgue, dri-devel, Bjorn Andersson,
linux-i2c, Nobuhiro Iwamatsu, linux-clk, linux-watchdog,
linux-rtc, Michal Simek, linux-stm32, Andy Gross,
Alexandru Ardelean, Keguang Zhang, Patrice Chotard, linux-pwm,
kernel, linux-arm-msm, Anand Ashok Dumbre, Vladimir Zapolskiy,
linux-gpio, André Gustavo Nakagomi Lopez, Jonathan Cameron,
linux-tegra, linux-amlogic, Amireddy Mallikarjuna reddy,
linux-mips, linux-spi, Cai Huoqing, linux-crypto,
Maxime Coquelin, dmaengine
[-- Attachment #1: Type: text/plain, Size: 6190 bytes --]
On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
> Some of our Tegra boards are not booting with the current -next and
> bisect is pointing to this commit. Looking at the boot log I am
> seeing the following panic ...
>
> [ 2.097048] 8<--- cut here ---
> [ 2.097053] Unable to handle kernel paging request at virtual address c216c810
> [ 2.097060] [c216c810] *pgd=0201141e(bad)
> [ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
> [ 2.097088] Modules linked in:
> [ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
> [ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
> [ 2.097113] PC is at 0xc216c810
> [ 2.097123] LR is at devm_clk_release+0x18/0x24
> [ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
> [ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
> [ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
> [ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
> [ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
> [ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
> [ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
> [ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
> [ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
> [ 2.097236] Register r2 information: NULL pointer
> [ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
> [ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
> [ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
> [ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
> [ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
> [ 2.097341] Register r8 information: non-slab/vmalloc memory
> [ 2.097348] Register r9 information: non-slab/vmalloc memory
> [ 2.097355] Register r10 information: non-slab/vmalloc memory
> [ 2.097362] Register r11 information: non-slab/vmalloc memory
> [ 2.097369] Register r12 information: non-paged memory
> [ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
> [ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
> [ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
> [ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
> [ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
> [ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
> [ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
> [ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
> [ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
> [ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
> [ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
> [ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
> [ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
> [ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
> [ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
> [ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
> [ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
> [ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
> [ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
> [ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
> [ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
> [ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
> [ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
> [ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
> [ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
> [ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
> [ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
> [ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
> [ 2.097749] bus_add_driver from driver_register+0x7c/0x118
> [ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
> [ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
> [ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
> [ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
> [ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
> [ 2.097839] dfa0: 00000000 00000000 00000000 00000000
> [ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
> [ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
> [ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
> [ 2.097872] ---[ end trace 0000000000000000 ]---
>
>
> Let me know if you have any thoughts.
Yeah, sorry, there is already a fix at
https://lore.kernel.org/linux-clk/20220620171815.114212-1-u.kleine-koenig@pengutronix.de
(Pro tipp: The commit in next has a Link: footer. If you follow the
link, you find the thread that was actually applied (i.e. v9) and where
the fix is also contained.)
@Stephen: It would be a great favour to our testers if you could apply
the fix ...
Best regards
Uwe
--
Pengutronix e.K. | Uwe Kleine-König |
Industrial Linux Solutions | https://www.pengutronix.de/ |
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-21 20:49 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-06-21 20:49 UTC (permalink / raw)
To: Jon Hunter, Stephen Boyd
Cc: Michael Turquette, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, Tomislav Denis, Heiko Stuebner,
linux-iio, Alexandre Torgue, dri-devel, Bjorn Andersson,
linux-i2c, Nobuhiro Iwamatsu, linux-clk, linux-watchdog,
linux-rtc, Michal Simek, linux-stm32, Andy Gross,
Alexandru Ardelean, Keguang Zhang, Patrice Chotard, linux-pwm,
kernel, linux-arm-msm, Anand Ashok Dumbre, Vladimir Zapolskiy,
linux-gpio, André Gustavo Nakagomi Lopez, Jonathan Cameron,
linux-tegra, linux-amlogic, Amireddy Mallikarjuna reddy,
linux-mips, linux-spi, Cai Huoqing, linux-crypto,
Maxime Coquelin, dmaengine
[-- Attachment #1.1: Type: text/plain, Size: 6190 bytes --]
On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
> Some of our Tegra boards are not booting with the current -next and
> bisect is pointing to this commit. Looking at the boot log I am
> seeing the following panic ...
>
> [ 2.097048] 8<--- cut here ---
> [ 2.097053] Unable to handle kernel paging request at virtual address c216c810
> [ 2.097060] [c216c810] *pgd=0201141e(bad)
> [ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
> [ 2.097088] Modules linked in:
> [ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
> [ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
> [ 2.097113] PC is at 0xc216c810
> [ 2.097123] LR is at devm_clk_release+0x18/0x24
> [ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
> [ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
> [ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
> [ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
> [ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
> [ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
> [ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
> [ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
> [ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
> [ 2.097236] Register r2 information: NULL pointer
> [ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
> [ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
> [ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
> [ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
> [ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
> [ 2.097341] Register r8 information: non-slab/vmalloc memory
> [ 2.097348] Register r9 information: non-slab/vmalloc memory
> [ 2.097355] Register r10 information: non-slab/vmalloc memory
> [ 2.097362] Register r11 information: non-slab/vmalloc memory
> [ 2.097369] Register r12 information: non-paged memory
> [ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
> [ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
> [ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
> [ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
> [ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
> [ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
> [ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
> [ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
> [ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
> [ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
> [ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
> [ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
> [ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
> [ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
> [ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
> [ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
> [ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
> [ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
> [ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
> [ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
> [ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
> [ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
> [ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
> [ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
> [ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
> [ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
> [ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
> [ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
> [ 2.097749] bus_add_driver from driver_register+0x7c/0x118
> [ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
> [ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
> [ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
> [ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
> [ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
> [ 2.097839] dfa0: 00000000 00000000 00000000 00000000
> [ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
> [ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
> [ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
> [ 2.097872] ---[ end trace 0000000000000000 ]---
>
>
> Let me know if you have any thoughts.
Yeah, sorry, there is already a fix at
https://lore.kernel.org/linux-clk/20220620171815.114212-1-u.kleine-koenig@pengutronix.de
(Pro tipp: The commit in next has a Link: footer. If you follow the
link, you find the thread that was actually applied (i.e. v9) and where
the fix is also contained.)
@Stephen: It would be a great favour to our testers if you could apply
the fix ...
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: 167 bytes --]
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
2022-06-21 20:49 ` Uwe Kleine-König
(?)
@ 2022-06-22 10:36 ` Andy Shevchenko
-1 siblings, 0 replies; 88+ messages in thread
From: Andy Shevchenko @ 2022-06-22 10:36 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Jon Hunter, Stephen Boyd, Michael Turquette, Russell King,
Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
Microchip Linux Driver Support, linux-hwmon,
linux-arm Mailing List, Lars-Peter Clausen, Michael Hennerich,
Jonathan Cameron, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, Tomislav Denis, Heiko Stuebner,
linux-iio, Alexandre Torgue, dri-devel, Bjorn Andersson,
linux-i2c, Nobuhiro Iwamatsu, linux-clk, LINUXWATCHDOG,
open list:REAL TIME CLOCK (RTC) SUBSYSTEM, Michal Simek,
linux-stm32, Andy Gross, Alexandru Ardelean, Keguang Zhang,
Patrice Chotard, linux-pwm, Sascha Hauer, linux-arm-msm,
Anand Ashok Dumbre, Vladimir Zapolskiy, open list:GPIO SUBSYSTEM,
André Gustavo Nakagomi Lopez, Jonathan Cameron, linux-tegra,
linux-amlogic, Amireddy Mallikarjuna reddy,
open list:BROADCOM NVRAM DRIVER, linux-spi, Cai Huoqing,
linux-crypto, Maxime Coquelin, dmaengine
On Tue, Jun 21, 2022 at 11:01 PM Uwe Kleine-König
<u.kleine-koenig@pengutronix.de> wrote:
> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
...
> (Pro tipp: The commit in next has a Link: footer. If you follow the
> link, you find the thread that was actually applied (i.e. v9) and where
> the fix is also contained.)
Even easier, you may take a message-id from the Link and supply to `b4`:
b4 mbox ${message-id}
mutt -f ${message-id}.mbx # or whatever MUA that handles mboxes
Dunno if `b4` has capability to parse Link instead of message-id.
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-22 10:36 ` Andy Shevchenko
0 siblings, 0 replies; 88+ messages in thread
From: Andy Shevchenko @ 2022-06-22 10:36 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Jon Hunter, Stephen Boyd, Michael Turquette, Russell King,
Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
Microchip Linux Driver Support, linux-hwmon,
linux-arm Mailing List, Lars-Peter Clausen, Michael Hennerich,
Jonathan Cameron, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, Tomislav Denis, Heiko Stuebner,
linux-iio, Alexandre Torgue, dri-devel, Bjorn Andersson,
linux-i2c, Nobuhiro Iwamatsu, linux-clk, LINUXWATCHDOG,
open list:REAL TIME CLOCK (RTC) SUBSYSTEM, Michal Simek,
linux-stm32, Andy Gross, Alexandru Ardelean, Keguang Zhang,
Patrice Chotard, linux-pwm, Sascha Hauer, linux-arm-msm,
Anand Ashok Dumbre, Vladimir Zapolskiy, open list:GPIO SUBSYSTEM,
André Gustavo Nakagomi Lopez, Jonathan Cameron, linux-tegra,
linux-amlogic, Amireddy Mallikarjuna reddy,
open list:BROADCOM NVRAM DRIVER, linux-spi, Cai Huoqing,
linux-crypto, Maxime Coquelin, dmaengine
On Tue, Jun 21, 2022 at 11:01 PM Uwe Kleine-König
<u.kleine-koenig@pengutronix.de> wrote:
> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
...
> (Pro tipp: The commit in next has a Link: footer. If you follow the
> link, you find the thread that was actually applied (i.e. v9) and where
> the fix is also contained.)
Even easier, you may take a message-id from the Link and supply to `b4`:
b4 mbox ${message-id}
mutt -f ${message-id}.mbx # or whatever MUA that handles mboxes
Dunno if `b4` has capability to parse Link instead of message-id.
--
With Best Regards,
Andy Shevchenko
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-22 10:36 ` Andy Shevchenko
0 siblings, 0 replies; 88+ messages in thread
From: Andy Shevchenko @ 2022-06-22 10:36 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Alexandre Belloni, Neil Armstrong, David Airlie,
Alexandru Ardelean, Tomislav Denis, dri-devel, Nuno Sá,
Paul Cercueil, Vladimir Zapolskiy, Thierry Reding, linux-i2c,
Nobuhiro Iwamatsu, Oleksij Rempel, Lee Jones, linux-clk,
Jerome Brunet, open list:REAL TIME CLOCK (RTC) SUBSYSTEM,
Herbert Xu, André Gustavo Nakagomi Lopez, Kevin Hilman,
Bartosz Golaszewski, Russell King, Jon Hunter, linux-iio,
Andy Gross, linux-arm Mailing List, Maxime Coquelin, Cai Huoqing,
open list:BROADCOM NVRAM DRIVER, Claudiu Beznea,
Michael Turquette, Guenter Roeck, NXP Linux Team, linux-pwm,
Jean Delvare, Michal Simek, LINUXWATCHDOG, Michael Hennerich,
Martin Blumenstingl, linux-arm-msm, linux-spi,
Anand Ashok Dumbre, Alexandre Torgue, open list:GPIO SUBSYSTEM,
Mark Brown, Patrice Chotard, Jonathan Cameron, linux-tegra,
linux-amlogic, Wim Van Sebroeck, Sascha Hauer, Lars Povlsen,
linux-hwmon, Alessandro Zummo, Keguang Zhang, Stephen Boyd,
Greg Kroah-Hartman, dmaengine, linux-stm32, Nicolas Ferre,
Microchip Linux Driver Support, Vinod Koul, Bjorn Andersson,
Amireddy Mallikarjuna reddy, linux-crypto, Shawn Guo,
Steen Hegelund, Jonathan Cameron
On Tue, Jun 21, 2022 at 11:01 PM Uwe Kleine-König
<u.kleine-koenig@pengutronix.de> wrote:
> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
...
> (Pro tipp: The commit in next has a Link: footer. If you follow the
> link, you find the thread that was actually applied (i.e. v9) and where
> the fix is also contained.)
Even easier, you may take a message-id from the Link and supply to `b4`:
b4 mbox ${message-id}
mutt -f ${message-id}.mbx # or whatever MUA that handles mboxes
Dunno if `b4` has capability to parse Link instead of message-id.
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
2022-06-22 10:36 ` Andy Shevchenko
(?)
@ 2022-06-22 11:14 ` Neil Armstrong
-1 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-06-22 11:14 UTC (permalink / raw)
To: Andy Shevchenko, Uwe Kleine-König
Cc: Jon Hunter, Stephen Boyd, Michael Turquette, Russell King,
Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
Microchip Linux Driver Support, linux-hwmon,
linux-arm Mailing List, Lars-Peter Clausen, Michael Hennerich,
Jonathan Cameron, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, David Airlie, Daniel Vetter, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, Tomislav Denis, Heiko Stuebner,
linux-iio, Alexandre Torgue, dri-devel, Bjorn Andersson,
linux-i2c, Nobuhiro Iwamatsu, linux-clk, LINUXWATCHDOG,
open list:REAL TIME CLOCK (RTC) SUBSYSTEM, Michal Simek,
linux-stm32, Andy Gross, Alexandru Ardelean, Keguang Zhang,
Patrice Chotard, linux-pwm, Sascha Hauer, linux-arm-msm,
Anand Ashok Dumbre, Vladimir Zapolskiy, open list:GPIO SUBSYSTEM,
André Gustavo Nakagomi Lopez, Jonathan Cameron, linux-tegra,
linux-amlogic, Amireddy Mallikarjuna reddy,
open list:BROADCOM NVRAM DRIVER, linux-spi, Cai Huoqing,
linux-crypto, Maxime Coquelin, dmaengine
On 22/06/2022 12:36, Andy Shevchenko wrote:
> On Tue, Jun 21, 2022 at 11:01 PM Uwe Kleine-König
> <u.kleine-koenig@pengutronix.de> wrote:
>> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
>
> ...
>
>> (Pro tipp: The commit in next has a Link: footer. If you follow the
>> link, you find the thread that was actually applied (i.e. v9) and where
>> the fix is also contained.)
>
> Even easier, you may take a message-id from the Link and supply to `b4`:
>
> b4 mbox ${message-id}
> mutt -f ${message-id}.mbx # or whatever MUA that handles mboxes
>
>
> Dunno if `b4` has capability to parse Link instead of message-id.
>
It does:
$ b4 mbox https://lore.kernel.org/r/20220616144915.3988071-1-windhl@126.com
Looking up https://lore.kernel.org/r/20220616144915.3988071-1-windhl%40126.com
Grabbing thread from lore.kernel.org/all/20220616144915.3988071-1-windhl%40126.com/t.mbox.gz
5 messages in the thread
Saved ./20220616144915.3988071-1-windhl@126.com.mbx
Neil
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-22 11:14 ` Neil Armstrong
0 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-06-22 11:14 UTC (permalink / raw)
To: Andy Shevchenko, Uwe Kleine-König
Cc: Jon Hunter, Stephen Boyd, Michael Turquette, Russell King,
Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
Microchip Linux Driver Support, linux-hwmon,
linux-arm Mailing List, Lars-Peter Clausen, Michael Hennerich,
Jonathan Cameron, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, David Airlie, Daniel Vetter, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, Tomislav Denis, Heiko Stuebner,
linux-iio, Alexandre Torgue, dri-devel, Bjorn Andersson,
linux-i2c, Nobuhiro Iwamatsu, linux-clk, LINUXWATCHDOG,
open list:REAL TIME CLOCK (RTC) SUBSYSTEM, Michal Simek,
linux-stm32, Andy Gross, Alexandru Ardelean, Keguang Zhang,
Patrice Chotard, linux-pwm, Sascha Hauer, linux-arm-msm,
Anand Ashok Dumbre, Vladimir Zapolskiy, open list:GPIO SUBSYSTEM,
André Gustavo Nakagomi Lopez, Jonathan Cameron, linux-tegra,
linux-amlogic, Amireddy Mallikarjuna reddy,
open list:BROADCOM NVRAM DRIVER, linux-spi, Cai Huoqing,
linux-crypto, Maxime Coquelin, dmaengine
On 22/06/2022 12:36, Andy Shevchenko wrote:
> On Tue, Jun 21, 2022 at 11:01 PM Uwe Kleine-König
> <u.kleine-koenig@pengutronix.de> wrote:
>> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
>
> ...
>
>> (Pro tipp: The commit in next has a Link: footer. If you follow the
>> link, you find the thread that was actually applied (i.e. v9) and where
>> the fix is also contained.)
>
> Even easier, you may take a message-id from the Link and supply to `b4`:
>
> b4 mbox ${message-id}
> mutt -f ${message-id}.mbx # or whatever MUA that handles mboxes
>
>
> Dunno if `b4` has capability to parse Link instead of message-id.
>
It does:
$ b4 mbox https://lore.kernel.org/r/20220616144915.3988071-1-windhl@126.com
Looking up https://lore.kernel.org/r/20220616144915.3988071-1-windhl%40126.com
Grabbing thread from lore.kernel.org/all/20220616144915.3988071-1-windhl%40126.com/t.mbox.gz
5 messages in the thread
Saved ./20220616144915.3988071-1-windhl@126.com.mbx
Neil
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-22 11:14 ` Neil Armstrong
0 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-06-22 11:14 UTC (permalink / raw)
To: Andy Shevchenko, Uwe Kleine-König
Cc: Alexandre Belloni, David Airlie, Alexandru Ardelean,
Tomislav Denis, dri-devel, Nuno Sá,
Paul Cercueil, Vladimir Zapolskiy, Thierry Reding, linux-i2c,
Nobuhiro Iwamatsu, Oleksij Rempel, Lee Jones, linux-clk,
Jerome Brunet, open list:REAL TIME CLOCK (RTC) SUBSYSTEM,
Herbert Xu, André Gustavo Nakagomi Lopez, Kevin Hilman,
Bartosz Golaszewski, Russell King, Jon Hunter, linux-iio,
Andy Gross, linux-arm Mailing List, Maxime Coquelin, Cai Huoqing,
open list:BROADCOM NVRAM DRIVER, Claudiu Beznea,
Michael Turquette, Guenter Roeck, NXP Linux Team, linux-pwm,
Jean Delvare, Michal Simek, LINUXWATCHDOG, Michael Hennerich,
Martin Blumenstingl, linux-arm-msm, linux-spi,
Anand Ashok Dumbre, Alexandre Torgue, open list:GPIO SUBSYSTEM,
Mark Brown, Patrice Chotard, Jonathan Cameron, linux-tegra,
linux-amlogic, Wim Van Sebroeck, Sascha Hauer, Lars Povlsen,
linux-hwmon, Alessandro Zummo, Keguang Zhang, Stephen Boyd,
Greg Kroah-Hartman, dmaengine, linux-stm32, Nicolas Ferre,
Microchip Linux Driver Support, Vinod Koul, Bjorn Andersson,
Amireddy Mallikarjuna reddy, linux-crypto, Shawn Guo,
Steen Hegelund, Jonathan Cameron
On 22/06/2022 12:36, Andy Shevchenko wrote:
> On Tue, Jun 21, 2022 at 11:01 PM Uwe Kleine-König
> <u.kleine-koenig@pengutronix.de> wrote:
>> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
>
> ...
>
>> (Pro tipp: The commit in next has a Link: footer. If you follow the
>> link, you find the thread that was actually applied (i.e. v9) and where
>> the fix is also contained.)
>
> Even easier, you may take a message-id from the Link and supply to `b4`:
>
> b4 mbox ${message-id}
> mutt -f ${message-id}.mbx # or whatever MUA that handles mboxes
>
>
> Dunno if `b4` has capability to parse Link instead of message-id.
>
It does:
$ b4 mbox https://lore.kernel.org/r/20220616144915.3988071-1-windhl@126.com
Looking up https://lore.kernel.org/r/20220616144915.3988071-1-windhl%40126.com
Grabbing thread from lore.kernel.org/all/20220616144915.3988071-1-windhl%40126.com/t.mbox.gz
5 messages in the thread
Saved ./20220616144915.3988071-1-windhl@126.com.mbx
Neil
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
2022-06-21 20:49 ` Uwe Kleine-König
(?)
@ 2022-06-22 15:28 ` Jon Hunter
-1 siblings, 0 replies; 88+ messages in thread
From: Jon Hunter @ 2022-06-22 15:28 UTC (permalink / raw)
To: Uwe Kleine-König, Stephen Boyd
Cc: Michael Turquette, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, Tomislav Denis, Heiko Stuebner,
linux-iio, Alexandre Torgue, dri-devel, Bjorn Andersson,
linux-i2c, Nobuhiro Iwamatsu, linux-clk, linux-watchdog,
linux-rtc, Michal Simek, linux-stm32, Andy Gross,
Alexandru Ardelean, Keguang Zhang, Patrice Chotard, linux-pwm,
kernel, linux-arm-msm, Anand Ashok Dumbre, Vladimir Zapolskiy,
linux-gpio, André Gustavo Nakagomi Lopez, Jonathan Cameron,
linux-tegra, linux-amlogic, Amireddy Mallikarjuna reddy,
linux-mips, linux-spi, Cai Huoqing, linux-crypto,
Maxime Coquelin, dmaengine
On 21/06/2022 21:49, Uwe Kleine-König wrote:
> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
>> Some of our Tegra boards are not booting with the current -next and
>> bisect is pointing to this commit. Looking at the boot log I am
>> seeing the following panic ...
>>
>> [ 2.097048] 8<--- cut here ---
>> [ 2.097053] Unable to handle kernel paging request at virtual address c216c810
>> [ 2.097060] [c216c810] *pgd=0201141e(bad)
>> [ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
>> [ 2.097088] Modules linked in:
>> [ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
>> [ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
>> [ 2.097113] PC is at 0xc216c810
>> [ 2.097123] LR is at devm_clk_release+0x18/0x24
>> [ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
>> [ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
>> [ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
>> [ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
>> [ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
>> [ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
>> [ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
>> [ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
>> [ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
>> [ 2.097236] Register r2 information: NULL pointer
>> [ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
>> [ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
>> [ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
>> [ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
>> [ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
>> [ 2.097341] Register r8 information: non-slab/vmalloc memory
>> [ 2.097348] Register r9 information: non-slab/vmalloc memory
>> [ 2.097355] Register r10 information: non-slab/vmalloc memory
>> [ 2.097362] Register r11 information: non-slab/vmalloc memory
>> [ 2.097369] Register r12 information: non-paged memory
>> [ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
>> [ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
>> [ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
>> [ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
>> [ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
>> [ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
>> [ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
>> [ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
>> [ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
>> [ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
>> [ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
>> [ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
>> [ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
>> [ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
>> [ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
>> [ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
>> [ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
>> [ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
>> [ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
>> [ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
>> [ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
>> [ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
>> [ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
>> [ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
>> [ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
>> [ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
>> [ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
>> [ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
>> [ 2.097749] bus_add_driver from driver_register+0x7c/0x118
>> [ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
>> [ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
>> [ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
>> [ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
>> [ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
>> [ 2.097839] dfa0: 00000000 00000000 00000000 00000000
>> [ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
>> [ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
>> [ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
>> [ 2.097872] ---[ end trace 0000000000000000 ]---
>>
>>
>> Let me know if you have any thoughts.
>
> Yeah, sorry, there is already a fix at
> https://lore.kernel.org/linux-clk/20220620171815.114212-1-u.kleine-koenig@pengutronix.de
Thanks! Works for me.
Tested-by: Jon Hunter <jonathanh@nvidia.com>
> (Pro tipp: The commit in next has a Link: footer. If you follow the
> link, you find the thread that was actually applied (i.e. v9) and where
> the fix is also contained.
Thanks for the tip!
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-22 15:28 ` Jon Hunter
0 siblings, 0 replies; 88+ messages in thread
From: Jon Hunter @ 2022-06-22 15:28 UTC (permalink / raw)
To: Uwe Kleine-König, Stephen Boyd
Cc: Michael Turquette, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, Tomislav Denis, Heiko Stuebner,
linux-iio, Alexandre Torgue, dri-devel, Bjorn Andersson,
linux-i2c, Nobuhiro Iwamatsu, linux-clk, linux-watchdog,
linux-rtc, Michal Simek, linux-stm32, Andy Gross,
Alexandru Ardelean, Keguang Zhang, Patrice Chotard, linux-pwm,
kernel, linux-arm-msm, Anand Ashok Dumbre, Vladimir Zapolskiy,
linux-gpio, André Gustavo Nakagomi Lopez, Jonathan Cameron,
linux-tegra, linux-amlogic, Amireddy Mallikarjuna reddy,
linux-mips, linux-spi, Cai Huoqing, linux-crypto,
Maxime Coquelin, dmaengine
On 21/06/2022 21:49, Uwe Kleine-König wrote:
> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
>> Some of our Tegra boards are not booting with the current -next and
>> bisect is pointing to this commit. Looking at the boot log I am
>> seeing the following panic ...
>>
>> [ 2.097048] 8<--- cut here ---
>> [ 2.097053] Unable to handle kernel paging request at virtual address c216c810
>> [ 2.097060] [c216c810] *pgd=0201141e(bad)
>> [ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
>> [ 2.097088] Modules linked in:
>> [ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
>> [ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
>> [ 2.097113] PC is at 0xc216c810
>> [ 2.097123] LR is at devm_clk_release+0x18/0x24
>> [ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
>> [ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
>> [ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
>> [ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
>> [ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
>> [ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
>> [ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
>> [ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
>> [ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
>> [ 2.097236] Register r2 information: NULL pointer
>> [ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
>> [ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
>> [ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
>> [ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
>> [ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
>> [ 2.097341] Register r8 information: non-slab/vmalloc memory
>> [ 2.097348] Register r9 information: non-slab/vmalloc memory
>> [ 2.097355] Register r10 information: non-slab/vmalloc memory
>> [ 2.097362] Register r11 information: non-slab/vmalloc memory
>> [ 2.097369] Register r12 information: non-paged memory
>> [ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
>> [ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
>> [ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
>> [ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
>> [ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
>> [ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
>> [ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
>> [ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
>> [ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
>> [ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
>> [ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
>> [ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
>> [ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
>> [ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
>> [ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
>> [ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
>> [ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
>> [ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
>> [ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
>> [ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
>> [ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
>> [ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
>> [ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
>> [ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
>> [ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
>> [ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
>> [ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
>> [ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
>> [ 2.097749] bus_add_driver from driver_register+0x7c/0x118
>> [ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
>> [ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
>> [ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
>> [ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
>> [ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
>> [ 2.097839] dfa0: 00000000 00000000 00000000 00000000
>> [ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
>> [ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
>> [ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
>> [ 2.097872] ---[ end trace 0000000000000000 ]---
>>
>>
>> Let me know if you have any thoughts.
>
> Yeah, sorry, there is already a fix at
> https://lore.kernel.org/linux-clk/20220620171815.114212-1-u.kleine-koenig@pengutronix.de
Thanks! Works for me.
Tested-by: Jon Hunter <jonathanh@nvidia.com>
> (Pro tipp: The commit in next has a Link: footer. If you follow the
> link, you find the thread that was actually applied (i.e. v9) and where
> the fix is also contained.
Thanks for the tip!
Jon
--
nvpublic
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 01/16] clk: generalize devm_clk_get() a bit
@ 2022-06-22 15:28 ` Jon Hunter
0 siblings, 0 replies; 88+ messages in thread
From: Jon Hunter @ 2022-06-22 15:28 UTC (permalink / raw)
To: Uwe Kleine-König, Stephen Boyd
Cc: Alexandre Belloni, Neil Armstrong, David Airlie,
Alexandru Ardelean, Tomislav Denis, dri-devel, Nuno Sá,
Paul Cercueil, Vladimir Zapolskiy, Thierry Reding, linux-i2c,
Nobuhiro Iwamatsu, Oleksij Rempel, Lee Jones, linux-clk,
Jerome Brunet, linux-rtc, Herbert Xu,
André Gustavo Nakagomi Lopez, Kevin Hilman,
Bartosz Golaszewski, Russell King, Claudiu Beznea, linux-iio,
Andy Gross, linux-arm-kernel, Maxime Coquelin, Cai Huoqing,
linux-mips, Keguang Zhang, Michael Turquette, Guenter Roeck,
NXP Linux Team, linux-pwm, Jean Delvare, Michal Simek,
linux-watchdog, Michael Hennerich, Martin Blumenstingl,
linux-arm-msm, linux-spi, Anand Ashok Dumbre, Alexandre Torgue,
linux-gpio, Mark Brown, Patrice Chotard, Jonathan Cameron,
linux-tegra, linux-amlogic, Wim Van Sebroeck, kernel,
Lars Povlsen, linux-hwmon, Alessandro Zummo, Greg Kroah-Hartman,
dmaengine, linux-stm32, Nicolas Ferre, UNGLinuxDriver,
Vinod Koul, Bjorn Andersson, Amireddy Mallikarjuna reddy,
linux-crypto, Shawn Guo, Steen Hegelund, Jonathan Cameron
On 21/06/2022 21:49, Uwe Kleine-König wrote:
> On Tue, Jun 21, 2022 at 08:57:00PM +0100, Jon Hunter wrote:
>> Some of our Tegra boards are not booting with the current -next and
>> bisect is pointing to this commit. Looking at the boot log I am
>> seeing the following panic ...
>>
>> [ 2.097048] 8<--- cut here ---
>> [ 2.097053] Unable to handle kernel paging request at virtual address c216c810
>> [ 2.097060] [c216c810] *pgd=0201141e(bad)
>> [ 2.097079] Internal error: Oops: 8000000d [#1] SMP ARM
>> [ 2.097088] Modules linked in:
>> [ 2.097097] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.19.0-rc3-next-20220621-g34d1d36073ea #1
>> [ 2.097107] Hardware name: NVIDIA Tegra SoC (Flattened Device Tree)
>> [ 2.097113] PC is at 0xc216c810
>> [ 2.097123] LR is at devm_clk_release+0x18/0x24
>> [ 2.097150] pc : [<c216c810>] lr : [<c088cb04>] psr: a0000013
>> [ 2.097155] sp : f080dde8 ip : 000006cf fp : c18d4854
>> [ 2.097161] r10: c1501850 r9 : c1a04d10 r8 : c1c4efa0
>> [ 2.097166] r7 : c216c810 r6 : f080de1c r5 : c2737680 r4 : c26a9680
>> [ 2.097172] r3 : c216c810 r2 : 00000000 r1 : c2737840 r0 : c2082840
>> [ 2.097179] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment none
>> [ 2.097187] Control: 10c5387d Table: 0020404a DAC: 00000051
>> [ 2.097191] Register r0 information: slab kmalloc-192 start c2082840 pointer offset 0 size 192
>> [ 2.097216] Register r1 information: slab kmalloc-128 start c2737800 pointer offset 64 size 128
>> [ 2.097236] Register r2 information: NULL pointer
>> [ 2.097244] Register r3 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
>> [ 2.097263] Register r4 information: slab kmalloc-64 start c26a9680 pointer offset 0 size 64
>> [ 2.097282] Register r5 information: slab kmalloc-128 start c2737680 pointer offset 0 size 128
>> [ 2.097301] Register r6 information: 2-page vmalloc region starting at 0xf080c000 allocated at kernel_clone+0xb4/0x3e8
>> [ 2.097321] Register r7 information: slab kmalloc-1k start c216c800 pointer offset 16 size 1024
>> [ 2.097341] Register r8 information: non-slab/vmalloc memory
>> [ 2.097348] Register r9 information: non-slab/vmalloc memory
>> [ 2.097355] Register r10 information: non-slab/vmalloc memory
>> [ 2.097362] Register r11 information: non-slab/vmalloc memory
>> [ 2.097369] Register r12 information: non-paged memory
>> [ 2.097375] Process swapper/0 (pid: 1, stack limit = 0x(ptrval))
>> [ 2.097384] Stack: (0xf080dde8 to 0xf080e000)
>> [ 2.097394] dde0: c2737800 c0a72d38 c18d4854 c0530490 c216c810 f080de1c
>> [ 2.097404] de00: c2120000 00000005 c216c9c0 80000013 0000017e c0a73d68 00000008 c2629e00
>> [ 2.097413] de20: c2737880 5640e141 c216c810 c216c810 00000205 c1c09dd4 00000000 c27375b8
>> [ 2.097422] de40: c2091700 c0a6e9a0 c216c810 c0a6f288 c216c810 c1c09dd4 c216c810 00000000
>> [ 2.097430] de60: c27375b8 c0a6f3c0 c1caa8e0 c216c810 c216c810 c0a6f450 00000000 c216c810
>> [ 2.097439] de80: c1c09dd4 c2120000 c27375b8 c0a6f850 00000000 c1c09dd4 c0a6f7c4 c0a6d4c0
>> [ 2.097447] dea0: 00000000 c2091458 c2286434 5640e141 c1be7f08 c1c09dd4 c2737580 c1be7f08
>> [ 2.097455] dec0: 00000000 c0a6e484 c1615714 c1be7c50 c1c09dd4 c2120000 c189a99c 00000000
>> [ 2.097464] dee0: c2120000 c0a701a0 c1c494e0 c2120000 c189a99c c0302144 0000017d c0364438
>> [ 2.097472] df00: c16da8bc c1626700 00000000 00000006 00000006 c16554c8 00000000 c2120000
>> [ 2.097480] df20: c15105bc c14f9778 c2091700 c20917d9 00000000 5640e141 c1a88930 c16da8bc
>> [ 2.097488] df40: c1c59000 5640e141 c16da8bc c1c59000 c1953b4c c18d4834 00000007 c1801340
>> [ 2.097497] df60: 00000006 00000006 00000000 c18004dc c2120000 c18004dc f080df74 c1a04cc0
>> [ 2.097505] df80: c106bbf0 00000000 00000000 00000000 00000000 00000000 00000000 c106bc08
>> [ 2.097513] dfa0: 00000000 c106bbf0 00000000 c03001a8 00000000 00000000 00000000 00000000
>> [ 2.097520] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
>> [ 2.097528] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000 00000000 00000000
>> [ 2.097542] devm_clk_release from release_nodes+0x58/0xc0
>> [ 2.097575] release_nodes from devres_release_all+0x7c/0xc0
>> [ 2.097596] devres_release_all from device_unbind_cleanup+0xc/0x60
>> [ 2.097626] device_unbind_cleanup from really_probe+0x1f4/0x2a8
>> [ 2.097650] really_probe from __driver_probe_device+0x84/0xe4
>> [ 2.097673] __driver_probe_device from driver_probe_device+0x30/0xd0
>> [ 2.097696] driver_probe_device from __driver_attach+0x8c/0xf0
>> [ 2.097713] __driver_attach from bus_for_each_dev+0x70/0xb0
>> [ 2.097729] bus_for_each_dev from bus_add_driver+0x168/0x1f4
>> [ 2.097749] bus_add_driver from driver_register+0x7c/0x118
>> [ 2.097766] driver_register from do_one_initcall+0x44/0x1ec
>> [ 2.097784] do_one_initcall from kernel_init_freeable+0x1d4/0x224
>> [ 2.097803] kernel_init_freeable from kernel_init+0x18/0x12c
>> [ 2.097820] kernel_init from ret_from_fork+0x14/0x2c
>> [ 2.097831] Exception stack(0xf080dfb0 to 0xf080dff8)
>> [ 2.097839] dfa0: 00000000 00000000 00000000 00000000
>> [ 2.097847] dfc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
>> [ 2.097854] dfe0: 00000000 00000000 00000000 00000000 00000013 00000000
>> [ 2.097862] Code: c2288680 ffffffff 00000000 00000000 (c2288680)
>> [ 2.097872] ---[ end trace 0000000000000000 ]---
>>
>>
>> Let me know if you have any thoughts.
>
> Yeah, sorry, there is already a fix at
> https://lore.kernel.org/linux-clk/20220620171815.114212-1-u.kleine-koenig@pengutronix.de
Thanks! Works for me.
Tested-by: Jon Hunter <jonathanh@nvidia.com>
> (Pro tipp: The commit in next has a Link: footer. If you follow the
> link, you find the thread that was actually applied (i.e. v9) and where
> the fix is also contained.
Thanks for the tip!
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: Tomislav Denis, linux-iio, Alexandre Torgue, dri-devel,
Bjorn Andersson, linux-i2c, Nobuhiro Iwamatsu, linux-clk,
linux-watchdog, linux-rtc, Michal Simek, linux-stm32, Andy Gross,
Alexandru Ardelean, Keguang Zhang, Patrice Chotard, linux-pwm,
kernel, linux-arm-msm, Anand Ashok Dumbre, Vladimir Zapolskiy,
linux-gpio, André Gustavo Nakagomi Lopez, Jonathan Cameron,
linux-amlogic, Amireddy Mallikarjuna reddy, linux-mips,
linux-spi, Cai Huoqing, linux-crypto, Maxime Coquelin, dmaengine
When a driver keeps a clock prepared (or enabled) during the whole
lifetime of the driver, these helpers allow to simplify the drivers.
Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/clk/clk-devres.c | 31 ++++++++++++++
include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
2 files changed, 120 insertions(+), 1 deletion(-)
diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
index fb7761888b30..4707fe718f0b 100644
--- a/drivers/clk/clk-devres.c
+++ b/drivers/clk/clk-devres.c
@@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
}
EXPORT_SYMBOL(devm_clk_get);
+struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_prepared);
+
+struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get,
+ clk_prepare_enable, clk_disable_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_enabled);
+
struct clk *devm_clk_get_optional(struct device *dev, const char *id)
{
return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
}
EXPORT_SYMBOL(devm_clk_get_optional);
+struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional,
+ clk_prepare, clk_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_optional_prepared);
+
+struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional,
+ clk_prepare_enable, clk_disable_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_optional_enabled);
+
struct clk_bulk_devres {
struct clk_bulk_data *clks;
int num_clks;
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 266e8de3cb51..b011dbba7109 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -449,7 +449,7 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
* the clock producer. (IOW, @id may be identical strings, but
* clk_get may return different clock producers depending on @dev.)
*
- * Drivers must assume that the clock source is not enabled.
+ * Drivers must assume that the clock source is neither prepared nor enabled.
*
* devm_clk_get should not be called from within interrupt context.
*
@@ -458,6 +458,47 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
*/
struct clk *devm_clk_get(struct device *dev, const char *id);
+/**
+ * devm_clk_get_prepared - devm_clk_get() + clk_prepare()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Returns a struct clk corresponding to the clock producer, or
+ * valid IS_ERR() condition containing errno. The implementation
+ * uses @dev and @id to determine the clock consumer, and thereby
+ * the clock producer. (IOW, @id may be identical strings, but
+ * clk_get may return different clock producers depending on @dev.)
+ *
+ * The returned clk (if valid) is prepared. Drivers must however assume that the
+ * clock is not enabled.
+ *
+ * devm_clk_get_prepared should not be called from within interrupt context.
+ *
+ * The clock will automatically be unprepared and freed when the
+ * device is unbound from the bus.
+ */
+struct clk *devm_clk_get_prepared(struct device *dev, const char *id);
+
+/**
+ * devm_clk_get_enabled - devm_clk_get() + clk_prepare_enable()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Returns a struct clk corresponding to the clock producer, or valid IS_ERR()
+ * condition containing errno. The implementation uses @dev and @id to
+ * determine the clock consumer, and thereby the clock producer. (IOW, @id may
+ * be identical strings, but clk_get may return different clock producers
+ * depending on @dev.)
+ *
+ * The returned clk (if valid) is prepared and enabled.
+ *
+ * devm_clk_get_prepared should not be called from within interrupt context.
+ *
+ * The clock will automatically be disabled, unprepared and freed when the
+ * device is unbound from the bus.
+ */
+struct clk *devm_clk_get_enabled(struct device *dev, const char *id);
+
/**
* devm_clk_get_optional - lookup and obtain a managed reference to an optional
* clock producer.
@@ -469,6 +510,29 @@ struct clk *devm_clk_get(struct device *dev, const char *id);
*/
struct clk *devm_clk_get_optional(struct device *dev, const char *id);
+/**
+ * devm_clk_get_optional_prepared - devm_clk_get_optional() + clk_prepare()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Behaves the same as devm_clk_get_prepared() except where there is no clock
+ * producer. In this case, instead of returning -ENOENT, the function returns
+ * NULL.
+ */
+struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id);
+
+/**
+ * devm_clk_get_optional_enabled - devm_clk_get_optional() +
+ * clk_prepare_enable()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Behaves the same as devm_clk_get_enabled() except where there is no clock
+ * producer. In this case, instead of returning -ENOENT, the function returns
+ * NULL.
+ */
+struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id);
+
/**
* devm_get_clk_from_child - lookup and obtain a managed reference to a
* clock producer from child node.
@@ -813,12 +877,36 @@ static inline struct clk *devm_clk_get(struct device *dev, const char *id)
return NULL;
}
+static inline struct clk *devm_clk_get_prepared(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
+static inline struct clk *devm_clk_get_enabled(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
static inline struct clk *devm_clk_get_optional(struct device *dev,
const char *id)
{
return NULL;
}
+static inline struct clk *devm_clk_get_optional_prepared(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
+static inline struct clk *devm_clk_get_optional_enabled(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
struct clk_bulk_data *clks)
{
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: linux-clk, kernel, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine, Jonathan Cameron, Alexandru Ardelean
When a driver keeps a clock prepared (or enabled) during the whole
lifetime of the driver, these helpers allow to simplify the drivers.
Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/clk/clk-devres.c | 31 ++++++++++++++
include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
2 files changed, 120 insertions(+), 1 deletion(-)
diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
index fb7761888b30..4707fe718f0b 100644
--- a/drivers/clk/clk-devres.c
+++ b/drivers/clk/clk-devres.c
@@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
}
EXPORT_SYMBOL(devm_clk_get);
+struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_prepared);
+
+struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get,
+ clk_prepare_enable, clk_disable_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_enabled);
+
struct clk *devm_clk_get_optional(struct device *dev, const char *id)
{
return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
}
EXPORT_SYMBOL(devm_clk_get_optional);
+struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional,
+ clk_prepare, clk_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_optional_prepared);
+
+struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional,
+ clk_prepare_enable, clk_disable_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_optional_enabled);
+
struct clk_bulk_devres {
struct clk_bulk_data *clks;
int num_clks;
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 266e8de3cb51..b011dbba7109 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -449,7 +449,7 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
* the clock producer. (IOW, @id may be identical strings, but
* clk_get may return different clock producers depending on @dev.)
*
- * Drivers must assume that the clock source is not enabled.
+ * Drivers must assume that the clock source is neither prepared nor enabled.
*
* devm_clk_get should not be called from within interrupt context.
*
@@ -458,6 +458,47 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
*/
struct clk *devm_clk_get(struct device *dev, const char *id);
+/**
+ * devm_clk_get_prepared - devm_clk_get() + clk_prepare()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Returns a struct clk corresponding to the clock producer, or
+ * valid IS_ERR() condition containing errno. The implementation
+ * uses @dev and @id to determine the clock consumer, and thereby
+ * the clock producer. (IOW, @id may be identical strings, but
+ * clk_get may return different clock producers depending on @dev.)
+ *
+ * The returned clk (if valid) is prepared. Drivers must however assume that the
+ * clock is not enabled.
+ *
+ * devm_clk_get_prepared should not be called from within interrupt context.
+ *
+ * The clock will automatically be unprepared and freed when the
+ * device is unbound from the bus.
+ */
+struct clk *devm_clk_get_prepared(struct device *dev, const char *id);
+
+/**
+ * devm_clk_get_enabled - devm_clk_get() + clk_prepare_enable()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Returns a struct clk corresponding to the clock producer, or valid IS_ERR()
+ * condition containing errno. The implementation uses @dev and @id to
+ * determine the clock consumer, and thereby the clock producer. (IOW, @id may
+ * be identical strings, but clk_get may return different clock producers
+ * depending on @dev.)
+ *
+ * The returned clk (if valid) is prepared and enabled.
+ *
+ * devm_clk_get_prepared should not be called from within interrupt context.
+ *
+ * The clock will automatically be disabled, unprepared and freed when the
+ * device is unbound from the bus.
+ */
+struct clk *devm_clk_get_enabled(struct device *dev, const char *id);
+
/**
* devm_clk_get_optional - lookup and obtain a managed reference to an optional
* clock producer.
@@ -469,6 +510,29 @@ struct clk *devm_clk_get(struct device *dev, const char *id);
*/
struct clk *devm_clk_get_optional(struct device *dev, const char *id);
+/**
+ * devm_clk_get_optional_prepared - devm_clk_get_optional() + clk_prepare()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Behaves the same as devm_clk_get_prepared() except where there is no clock
+ * producer. In this case, instead of returning -ENOENT, the function returns
+ * NULL.
+ */
+struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id);
+
+/**
+ * devm_clk_get_optional_enabled - devm_clk_get_optional() +
+ * clk_prepare_enable()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Behaves the same as devm_clk_get_enabled() except where there is no clock
+ * producer. In this case, instead of returning -ENOENT, the function returns
+ * NULL.
+ */
+struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id);
+
/**
* devm_get_clk_from_child - lookup and obtain a managed reference to a
* clock producer from child node.
@@ -813,12 +877,36 @@ static inline struct clk *devm_clk_get(struct device *dev, const char *id)
return NULL;
}
+static inline struct clk *devm_clk_get_prepared(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
+static inline struct clk *devm_clk_get_enabled(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
static inline struct clk *devm_clk_get_optional(struct device *dev,
const char *id)
{
return NULL;
}
+static inline struct clk *devm_clk_get_optional_prepared(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
+static inline struct clk *devm_clk_get_optional_enabled(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
struct clk_bulk_data *clks)
{
--
2.35.1
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu, Greg Kroah-Hartman, Linus Walleij,
Bartosz Golaszewski, Neil Armstrong, David Airlie, Daniel Vetter,
Kevin Hilman, Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul
Cc: linux-clk, kernel, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine, Jonathan Cameron, Alexandru Ardelean
When a driver keeps a clock prepared (or enabled) during the whole
lifetime of the driver, these helpers allow to simplify the drivers.
Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/clk/clk-devres.c | 31 ++++++++++++++
include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
2 files changed, 120 insertions(+), 1 deletion(-)
diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
index fb7761888b30..4707fe718f0b 100644
--- a/drivers/clk/clk-devres.c
+++ b/drivers/clk/clk-devres.c
@@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
}
EXPORT_SYMBOL(devm_clk_get);
+struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_prepared);
+
+struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get,
+ clk_prepare_enable, clk_disable_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_enabled);
+
struct clk *devm_clk_get_optional(struct device *dev, const char *id)
{
return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
}
EXPORT_SYMBOL(devm_clk_get_optional);
+struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional,
+ clk_prepare, clk_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_optional_prepared);
+
+struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
+{
+ return __devm_clk_get(dev, id, clk_get_optional,
+ clk_prepare_enable, clk_disable_unprepare);
+
+}
+EXPORT_SYMBOL(devm_clk_get_optional_enabled);
+
struct clk_bulk_devres {
struct clk_bulk_data *clks;
int num_clks;
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 266e8de3cb51..b011dbba7109 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -449,7 +449,7 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
* the clock producer. (IOW, @id may be identical strings, but
* clk_get may return different clock producers depending on @dev.)
*
- * Drivers must assume that the clock source is not enabled.
+ * Drivers must assume that the clock source is neither prepared nor enabled.
*
* devm_clk_get should not be called from within interrupt context.
*
@@ -458,6 +458,47 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
*/
struct clk *devm_clk_get(struct device *dev, const char *id);
+/**
+ * devm_clk_get_prepared - devm_clk_get() + clk_prepare()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Returns a struct clk corresponding to the clock producer, or
+ * valid IS_ERR() condition containing errno. The implementation
+ * uses @dev and @id to determine the clock consumer, and thereby
+ * the clock producer. (IOW, @id may be identical strings, but
+ * clk_get may return different clock producers depending on @dev.)
+ *
+ * The returned clk (if valid) is prepared. Drivers must however assume that the
+ * clock is not enabled.
+ *
+ * devm_clk_get_prepared should not be called from within interrupt context.
+ *
+ * The clock will automatically be unprepared and freed when the
+ * device is unbound from the bus.
+ */
+struct clk *devm_clk_get_prepared(struct device *dev, const char *id);
+
+/**
+ * devm_clk_get_enabled - devm_clk_get() + clk_prepare_enable()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Returns a struct clk corresponding to the clock producer, or valid IS_ERR()
+ * condition containing errno. The implementation uses @dev and @id to
+ * determine the clock consumer, and thereby the clock producer. (IOW, @id may
+ * be identical strings, but clk_get may return different clock producers
+ * depending on @dev.)
+ *
+ * The returned clk (if valid) is prepared and enabled.
+ *
+ * devm_clk_get_prepared should not be called from within interrupt context.
+ *
+ * The clock will automatically be disabled, unprepared and freed when the
+ * device is unbound from the bus.
+ */
+struct clk *devm_clk_get_enabled(struct device *dev, const char *id);
+
/**
* devm_clk_get_optional - lookup and obtain a managed reference to an optional
* clock producer.
@@ -469,6 +510,29 @@ struct clk *devm_clk_get(struct device *dev, const char *id);
*/
struct clk *devm_clk_get_optional(struct device *dev, const char *id);
+/**
+ * devm_clk_get_optional_prepared - devm_clk_get_optional() + clk_prepare()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Behaves the same as devm_clk_get_prepared() except where there is no clock
+ * producer. In this case, instead of returning -ENOENT, the function returns
+ * NULL.
+ */
+struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id);
+
+/**
+ * devm_clk_get_optional_enabled - devm_clk_get_optional() +
+ * clk_prepare_enable()
+ * @dev: device for clock "consumer"
+ * @id: clock consumer ID
+ *
+ * Behaves the same as devm_clk_get_enabled() except where there is no clock
+ * producer. In this case, instead of returning -ENOENT, the function returns
+ * NULL.
+ */
+struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id);
+
/**
* devm_get_clk_from_child - lookup and obtain a managed reference to a
* clock producer from child node.
@@ -813,12 +877,36 @@ static inline struct clk *devm_clk_get(struct device *dev, const char *id)
return NULL;
}
+static inline struct clk *devm_clk_get_prepared(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
+static inline struct clk *devm_clk_get_enabled(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
static inline struct clk *devm_clk_get_optional(struct device *dev,
const char *id)
{
return NULL;
}
+static inline struct clk *devm_clk_get_optional_prepared(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
+static inline struct clk *devm_clk_get_optional_enabled(struct device *dev,
+ const char *id)
+{
+ return NULL;
+}
+
static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
struct clk_bulk_data *clks)
{
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-19 18:29 ` Jonathan Cameron
-1 siblings, 0 replies; 88+ messages in thread
From: Jonathan Cameron @ 2022-03-19 18:29 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Matt Mackall, Herbert Xu,
Greg Kroah-Hartman, Linus Walleij, Bartosz Golaszewski,
Neil Armstrong, David Airlie, Daniel Vetter, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, linux-clk, kernel, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine, Jonathan Cameron, Alexandru Ardelean
On Mon, 14 Mar 2022 15:16:29 +0100
Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:
> When a driver keeps a clock prepared (or enabled) during the whole
> lifetime of the driver, these helpers allow to simplify the drivers.
>
> Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
One trivial thing below.
> ---
> drivers/clk/clk-devres.c | 31 ++++++++++++++
> include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
> 2 files changed, 120 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> index fb7761888b30..4707fe718f0b 100644
> --- a/drivers/clk/clk-devres.c
> +++ b/drivers/clk/clk-devres.c
> @@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
> }
> EXPORT_SYMBOL(devm_clk_get);
>
> +struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
Nitpick but this spacing before } in functions is rather unusual and not
in keeping with the existing code in this file.
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_prepared);
> +
> +struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get,
> + clk_prepare_enable, clk_disable_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_enabled);
> +
> struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> {
> return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
> }
> EXPORT_SYMBOL(devm_clk_get_optional);
>
> +struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional,
> + clk_prepare, clk_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_optional_prepared);
> +
> +struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional,
> + clk_prepare_enable, clk_disable_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_optional_enabled);
> +
> struct clk_bulk_devres {
> struct clk_bulk_data *clks;
> int num_clks;
> diff --git a/include/linux/clk.h b/include/linux/clk.h
> index 266e8de3cb51..b011dbba7109 100644
> --- a/include/linux/clk.h
> +++ b/include/linux/clk.h
> @@ -449,7 +449,7 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
> * the clock producer. (IOW, @id may be identical strings, but
> * clk_get may return different clock producers depending on @dev.)
> *
> - * Drivers must assume that the clock source is not enabled.
> + * Drivers must assume that the clock source is neither prepared nor enabled.
> *
> * devm_clk_get should not be called from within interrupt context.
> *
> @@ -458,6 +458,47 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
> */
> struct clk *devm_clk_get(struct device *dev, const char *id);
>
> +/**
> + * devm_clk_get_prepared - devm_clk_get() + clk_prepare()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Returns a struct clk corresponding to the clock producer, or
> + * valid IS_ERR() condition containing errno. The implementation
> + * uses @dev and @id to determine the clock consumer, and thereby
> + * the clock producer. (IOW, @id may be identical strings, but
> + * clk_get may return different clock producers depending on @dev.)
> + *
> + * The returned clk (if valid) is prepared. Drivers must however assume that the
> + * clock is not enabled.
> + *
> + * devm_clk_get_prepared should not be called from within interrupt context.
> + *
> + * The clock will automatically be unprepared and freed when the
> + * device is unbound from the bus.
> + */
> +struct clk *devm_clk_get_prepared(struct device *dev, const char *id);
> +
> +/**
> + * devm_clk_get_enabled - devm_clk_get() + clk_prepare_enable()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Returns a struct clk corresponding to the clock producer, or valid IS_ERR()
> + * condition containing errno. The implementation uses @dev and @id to
> + * determine the clock consumer, and thereby the clock producer. (IOW, @id may
> + * be identical strings, but clk_get may return different clock producers
> + * depending on @dev.)
> + *
> + * The returned clk (if valid) is prepared and enabled.
> + *
> + * devm_clk_get_prepared should not be called from within interrupt context.
> + *
> + * The clock will automatically be disabled, unprepared and freed when the
> + * device is unbound from the bus.
> + */
> +struct clk *devm_clk_get_enabled(struct device *dev, const char *id);
> +
> /**
> * devm_clk_get_optional - lookup and obtain a managed reference to an optional
> * clock producer.
> @@ -469,6 +510,29 @@ struct clk *devm_clk_get(struct device *dev, const char *id);
> */
> struct clk *devm_clk_get_optional(struct device *dev, const char *id);
>
> +/**
> + * devm_clk_get_optional_prepared - devm_clk_get_optional() + clk_prepare()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Behaves the same as devm_clk_get_prepared() except where there is no clock
> + * producer. In this case, instead of returning -ENOENT, the function returns
> + * NULL.
> + */
> +struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id);
> +
> +/**
> + * devm_clk_get_optional_enabled - devm_clk_get_optional() +
> + * clk_prepare_enable()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Behaves the same as devm_clk_get_enabled() except where there is no clock
> + * producer. In this case, instead of returning -ENOENT, the function returns
> + * NULL.
> + */
> +struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id);
> +
> /**
> * devm_get_clk_from_child - lookup and obtain a managed reference to a
> * clock producer from child node.
> @@ -813,12 +877,36 @@ static inline struct clk *devm_clk_get(struct device *dev, const char *id)
> return NULL;
> }
>
> +static inline struct clk *devm_clk_get_prepared(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> +static inline struct clk *devm_clk_get_enabled(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> static inline struct clk *devm_clk_get_optional(struct device *dev,
> const char *id)
> {
> return NULL;
> }
>
> +static inline struct clk *devm_clk_get_optional_prepared(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> +static inline struct clk *devm_clk_get_optional_enabled(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
> struct clk_bulk_data *clks)
> {
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
@ 2022-03-19 18:29 ` Jonathan Cameron
0 siblings, 0 replies; 88+ messages in thread
From: Jonathan Cameron @ 2022-03-19 18:29 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Matt Mackall, Herbert Xu,
Greg Kroah-Hartman, Linus Walleij, Bartosz Golaszewski,
Neil Armstrong, David Airlie, Daniel Vetter, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni, Wim Van Sebroeck,
Claudiu Beznea, Thierry Reding, Lee Jones, Nicolas Ferre,
Oleksij Rempel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Mark Brown, Vinod Koul, linux-clk, kernel, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, linux-gpio, dri-devel, linux-mips,
linux-rtc, Keguang Zhang, Andy Gross, Bjorn Andersson,
Patrice Chotard, Maxime Coquelin, Alexandre Torgue,
Nobuhiro Iwamatsu, linux-watchdog, linux-arm-msm, linux-stm32,
linux-pwm, linux-i2c, linux-spi, Amireddy Mallikarjuna reddy,
dmaengine, Jonathan Cameron, Alexandru Ardelean
On Mon, 14 Mar 2022 15:16:29 +0100
Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:
> When a driver keeps a clock prepared (or enabled) during the whole
> lifetime of the driver, these helpers allow to simplify the drivers.
>
> Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
One trivial thing below.
> ---
> drivers/clk/clk-devres.c | 31 ++++++++++++++
> include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
> 2 files changed, 120 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> index fb7761888b30..4707fe718f0b 100644
> --- a/drivers/clk/clk-devres.c
> +++ b/drivers/clk/clk-devres.c
> @@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
> }
> EXPORT_SYMBOL(devm_clk_get);
>
> +struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
Nitpick but this spacing before } in functions is rather unusual and not
in keeping with the existing code in this file.
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_prepared);
> +
> +struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get,
> + clk_prepare_enable, clk_disable_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_enabled);
> +
> struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> {
> return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
> }
> EXPORT_SYMBOL(devm_clk_get_optional);
>
> +struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional,
> + clk_prepare, clk_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_optional_prepared);
> +
> +struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional,
> + clk_prepare_enable, clk_disable_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_optional_enabled);
> +
> struct clk_bulk_devres {
> struct clk_bulk_data *clks;
> int num_clks;
> diff --git a/include/linux/clk.h b/include/linux/clk.h
> index 266e8de3cb51..b011dbba7109 100644
> --- a/include/linux/clk.h
> +++ b/include/linux/clk.h
> @@ -449,7 +449,7 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
> * the clock producer. (IOW, @id may be identical strings, but
> * clk_get may return different clock producers depending on @dev.)
> *
> - * Drivers must assume that the clock source is not enabled.
> + * Drivers must assume that the clock source is neither prepared nor enabled.
> *
> * devm_clk_get should not be called from within interrupt context.
> *
> @@ -458,6 +458,47 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
> */
> struct clk *devm_clk_get(struct device *dev, const char *id);
>
> +/**
> + * devm_clk_get_prepared - devm_clk_get() + clk_prepare()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Returns a struct clk corresponding to the clock producer, or
> + * valid IS_ERR() condition containing errno. The implementation
> + * uses @dev and @id to determine the clock consumer, and thereby
> + * the clock producer. (IOW, @id may be identical strings, but
> + * clk_get may return different clock producers depending on @dev.)
> + *
> + * The returned clk (if valid) is prepared. Drivers must however assume that the
> + * clock is not enabled.
> + *
> + * devm_clk_get_prepared should not be called from within interrupt context.
> + *
> + * The clock will automatically be unprepared and freed when the
> + * device is unbound from the bus.
> + */
> +struct clk *devm_clk_get_prepared(struct device *dev, const char *id);
> +
> +/**
> + * devm_clk_get_enabled - devm_clk_get() + clk_prepare_enable()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Returns a struct clk corresponding to the clock producer, or valid IS_ERR()
> + * condition containing errno. The implementation uses @dev and @id to
> + * determine the clock consumer, and thereby the clock producer. (IOW, @id may
> + * be identical strings, but clk_get may return different clock producers
> + * depending on @dev.)
> + *
> + * The returned clk (if valid) is prepared and enabled.
> + *
> + * devm_clk_get_prepared should not be called from within interrupt context.
> + *
> + * The clock will automatically be disabled, unprepared and freed when the
> + * device is unbound from the bus.
> + */
> +struct clk *devm_clk_get_enabled(struct device *dev, const char *id);
> +
> /**
> * devm_clk_get_optional - lookup and obtain a managed reference to an optional
> * clock producer.
> @@ -469,6 +510,29 @@ struct clk *devm_clk_get(struct device *dev, const char *id);
> */
> struct clk *devm_clk_get_optional(struct device *dev, const char *id);
>
> +/**
> + * devm_clk_get_optional_prepared - devm_clk_get_optional() + clk_prepare()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Behaves the same as devm_clk_get_prepared() except where there is no clock
> + * producer. In this case, instead of returning -ENOENT, the function returns
> + * NULL.
> + */
> +struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id);
> +
> +/**
> + * devm_clk_get_optional_enabled - devm_clk_get_optional() +
> + * clk_prepare_enable()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Behaves the same as devm_clk_get_enabled() except where there is no clock
> + * producer. In this case, instead of returning -ENOENT, the function returns
> + * NULL.
> + */
> +struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id);
> +
> /**
> * devm_get_clk_from_child - lookup and obtain a managed reference to a
> * clock producer from child node.
> @@ -813,12 +877,36 @@ static inline struct clk *devm_clk_get(struct device *dev, const char *id)
> return NULL;
> }
>
> +static inline struct clk *devm_clk_get_prepared(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> +static inline struct clk *devm_clk_get_enabled(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> static inline struct clk *devm_clk_get_optional(struct device *dev,
> const char *id)
> {
> return NULL;
> }
>
> +static inline struct clk *devm_clk_get_optional_prepared(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> +static inline struct clk *devm_clk_get_optional_enabled(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
> struct clk_bulk_data *clks)
> {
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
@ 2022-03-19 18:29 ` Jonathan Cameron
0 siblings, 0 replies; 88+ messages in thread
From: Jonathan Cameron @ 2022-03-19 18:29 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Alexandre Belloni, Neil Armstrong, David Airlie,
Alexandru Ardelean, Jonathan Cameron, Tomislav Denis,
André Gustavo Nakagomi Lopez, Nuno Sá,
Paul Cercueil, Thierry Reding, linux-i2c, Nobuhiro Iwamatsu,
Oleksij Rempel, Lee Jones, linux-clk, Jerome Brunet, linux-rtc,
Herbert Xu, Alexandre Torgue, Kevin Hilman, Bartosz Golaszewski,
Russell King, linux-pwm, Claudiu Beznea, linux-iio, Andy Gross,
linux-arm-kernel, linux-mips, Keguang Zhang, Michael Turquette,
Guenter Roeck, NXP Linux Team, Maxime Coquelin, Bjorn Andersson,
Jean Delvare, Michal Simek, kernel, Michael Hennerich,
Martin Blumenstingl, linux-arm-msm, linux-spi,
Anand Ashok Dumbre, Vladimir Zapolskiy, linux-gpio, Mark Brown,
dri-devel, Matt Mackall, linux-amlogic, Wim Van Sebroeck,
Lars Povlsen, linux-hwmon, Alessandro Zummo, linux-watchdog,
Stephen Boyd, Greg Kroah-Hartman, Patrice Chotard, linux-stm32,
Nicolas Ferre, UNGLinuxDriver, Vinod Koul, Cai Huoqing,
linux-crypto, dmaengine, Amireddy Mallikarjuna reddy, Shawn Guo,
Steen Hegelund
On Mon, 14 Mar 2022 15:16:29 +0100
Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:
> When a driver keeps a clock prepared (or enabled) during the whole
> lifetime of the driver, these helpers allow to simplify the drivers.
>
> Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
One trivial thing below.
> ---
> drivers/clk/clk-devres.c | 31 ++++++++++++++
> include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
> 2 files changed, 120 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> index fb7761888b30..4707fe718f0b 100644
> --- a/drivers/clk/clk-devres.c
> +++ b/drivers/clk/clk-devres.c
> @@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
> }
> EXPORT_SYMBOL(devm_clk_get);
>
> +struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
Nitpick but this spacing before } in functions is rather unusual and not
in keeping with the existing code in this file.
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_prepared);
> +
> +struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get,
> + clk_prepare_enable, clk_disable_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_enabled);
> +
> struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> {
> return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
> }
> EXPORT_SYMBOL(devm_clk_get_optional);
>
> +struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional,
> + clk_prepare, clk_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_optional_prepared);
> +
> +struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional,
> + clk_prepare_enable, clk_disable_unprepare);
> +
> +}
> +EXPORT_SYMBOL(devm_clk_get_optional_enabled);
> +
> struct clk_bulk_devres {
> struct clk_bulk_data *clks;
> int num_clks;
> diff --git a/include/linux/clk.h b/include/linux/clk.h
> index 266e8de3cb51..b011dbba7109 100644
> --- a/include/linux/clk.h
> +++ b/include/linux/clk.h
> @@ -449,7 +449,7 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
> * the clock producer. (IOW, @id may be identical strings, but
> * clk_get may return different clock producers depending on @dev.)
> *
> - * Drivers must assume that the clock source is not enabled.
> + * Drivers must assume that the clock source is neither prepared nor enabled.
> *
> * devm_clk_get should not be called from within interrupt context.
> *
> @@ -458,6 +458,47 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
> */
> struct clk *devm_clk_get(struct device *dev, const char *id);
>
> +/**
> + * devm_clk_get_prepared - devm_clk_get() + clk_prepare()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Returns a struct clk corresponding to the clock producer, or
> + * valid IS_ERR() condition containing errno. The implementation
> + * uses @dev and @id to determine the clock consumer, and thereby
> + * the clock producer. (IOW, @id may be identical strings, but
> + * clk_get may return different clock producers depending on @dev.)
> + *
> + * The returned clk (if valid) is prepared. Drivers must however assume that the
> + * clock is not enabled.
> + *
> + * devm_clk_get_prepared should not be called from within interrupt context.
> + *
> + * The clock will automatically be unprepared and freed when the
> + * device is unbound from the bus.
> + */
> +struct clk *devm_clk_get_prepared(struct device *dev, const char *id);
> +
> +/**
> + * devm_clk_get_enabled - devm_clk_get() + clk_prepare_enable()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Returns a struct clk corresponding to the clock producer, or valid IS_ERR()
> + * condition containing errno. The implementation uses @dev and @id to
> + * determine the clock consumer, and thereby the clock producer. (IOW, @id may
> + * be identical strings, but clk_get may return different clock producers
> + * depending on @dev.)
> + *
> + * The returned clk (if valid) is prepared and enabled.
> + *
> + * devm_clk_get_prepared should not be called from within interrupt context.
> + *
> + * The clock will automatically be disabled, unprepared and freed when the
> + * device is unbound from the bus.
> + */
> +struct clk *devm_clk_get_enabled(struct device *dev, const char *id);
> +
> /**
> * devm_clk_get_optional - lookup and obtain a managed reference to an optional
> * clock producer.
> @@ -469,6 +510,29 @@ struct clk *devm_clk_get(struct device *dev, const char *id);
> */
> struct clk *devm_clk_get_optional(struct device *dev, const char *id);
>
> +/**
> + * devm_clk_get_optional_prepared - devm_clk_get_optional() + clk_prepare()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Behaves the same as devm_clk_get_prepared() except where there is no clock
> + * producer. In this case, instead of returning -ENOENT, the function returns
> + * NULL.
> + */
> +struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id);
> +
> +/**
> + * devm_clk_get_optional_enabled - devm_clk_get_optional() +
> + * clk_prepare_enable()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Behaves the same as devm_clk_get_enabled() except where there is no clock
> + * producer. In this case, instead of returning -ENOENT, the function returns
> + * NULL.
> + */
> +struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id);
> +
> /**
> * devm_get_clk_from_child - lookup and obtain a managed reference to a
> * clock producer from child node.
> @@ -813,12 +877,36 @@ static inline struct clk *devm_clk_get(struct device *dev, const char *id)
> return NULL;
> }
>
> +static inline struct clk *devm_clk_get_prepared(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> +static inline struct clk *devm_clk_get_enabled(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> static inline struct clk *devm_clk_get_optional(struct device *dev,
> const char *id)
> {
> return NULL;
> }
>
> +static inline struct clk *devm_clk_get_optional_prepared(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> +static inline struct clk *devm_clk_get_optional_enabled(struct device *dev,
> + const char *id)
> +{
> + return NULL;
> +}
> +
> static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
> struct clk_bulk_data *clks)
> {
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
2022-03-19 18:29 ` Jonathan Cameron
(?)
@ 2022-03-21 7:22 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-21 7:22 UTC (permalink / raw)
To: Jonathan Cameron
Cc: Alexandre Belloni, Neil Armstrong, David Airlie, Matt Mackall,
Tomislav Denis, André Gustavo Nakagomi Lopez, Nuno Sá,
Paul Cercueil, UNGLinuxDriver, Thierry Reding, linux-i2c,
Steen Hegelund, Nobuhiro Iwamatsu, linux-spi, Lee Jones,
linux-clk, Jerome Brunet, linux-rtc, Herbert Xu, Kevin Hilman,
Bartosz Golaszewski, Russell King, linux-stm32, linux-iio,
Andy Gross, Alexandru Ardelean, Lars Povlsen, Keguang Zhang,
Michael Turquette, Guenter Roeck, NXP Linux Team, linux-pwm,
Jean Delvare, Michal Simek, kernel, Michael Hennerich,
Vinod Koul, Martin Blumenstingl, linux-arm-msm, Nicolas Ferre,
Anand Ashok Dumbre, Alexandre Torgue, linux-gpio, Mark Brown,
dri-devel, Jonathan Cameron, linux-amlogic, Bjorn Andersson,
linux-arm-kernel, linux-hwmon, Alessandro Zummo, linux-watchdog,
Stephen Boyd, Greg Kroah-Hartman, dmaengine, Patrice Chotard,
linux-mips, Oleksij Rempel, Vladimir Zapolskiy, Cai Huoqing,
Wim Van Sebroeck, Maxime Coquelin, linux-crypto,
Amireddy Mallikarjuna reddy, Shawn Guo, Claudiu Beznea
[-- Attachment #1: Type: text/plain, Size: 1759 bytes --]
On Sat, Mar 19, 2022 at 06:29:36PM +0000, Jonathan Cameron wrote:
> On Mon, 14 Mar 2022 15:16:29 +0100
> Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:
>
> > When a driver keeps a clock prepared (or enabled) during the whole
> > lifetime of the driver, these helpers allow to simplify the drivers.
> >
> > Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> > Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> > Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
>
> One trivial thing below.
>
> > ---
> > drivers/clk/clk-devres.c | 31 ++++++++++++++
> > include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
> > 2 files changed, 120 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> > index fb7761888b30..4707fe718f0b 100644
> > --- a/drivers/clk/clk-devres.c
> > +++ b/drivers/clk/clk-devres.c
> > @@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
> > }
> > EXPORT_SYMBOL(devm_clk_get);
> >
> > +struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
> > +{
> > + return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
>
> Nitpick but this spacing before } in functions is rather unusual and not
> in keeping with the existing code in this file.
>
> > +
> > +}
ack, I fixed that in my tree, so this will be part of an v9. I won't
send it just for this change, though. I fixed three further functions
that had a similar empty line, too.
Thanks for looking
Uwe
--
Pengutronix e.K. | Uwe Kleine-König |
Industrial Linux Solutions | https://www.pengutronix.de/ |
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
@ 2022-03-21 7:22 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-21 7:22 UTC (permalink / raw)
To: Jonathan Cameron
Cc: Alexandre Belloni, Heiko Stuebner, Neil Armstrong, David Airlie,
Alexandru Ardelean, Linus Walleij, Jonathan Cameron,
Tomislav Denis, André Gustavo Nakagomi Lopez, Nuno Sá,
Paul Cercueil, Thierry Reding, linux-i2c, Nobuhiro Iwamatsu,
Oleksij Rempel, Lee Jones, linux-clk, Jerome Brunet, linux-rtc,
Lars-Peter Clausen, Herbert Xu, Alexandre Torgue, Kevin Hilman,
Bartosz Golaszewski, Russell King, linux-pwm, Claudiu Beznea,
linux-iio, Andy Gross, linux-arm-kernel, linux-mips,
Keguang Zhang, Michael Turquette, Guenter Roeck, NXP Linux Team,
Maxime Coquelin, Bjorn Andersson, Jean Delvare, Michal Simek,
kernel, Michael Hennerich, Martin Blumenstingl, linux-arm-msm,
linux-spi, Anand Ashok Dumbre, Vladimir Zapolskiy, linux-gpio,
Mark Brown, dri-devel, Fabio Estevam, Matt Mackall,
linux-amlogic, Wim Van Sebroeck, Lars Povlsen, linux-hwmon,
Alessandro Zummo, linux-watchdog, Stephen Boyd,
Greg Kroah-Hartman, Patrice Chotard, linux-stm32, Nicolas Ferre,
UNGLinuxDriver, Vinod Koul, Cai Huoqing, linux-crypto,
Daniel Vetter, dmaengine, Amireddy Mallikarjuna reddy, Shawn Guo,
Steen Hegelund
[-- Attachment #1.1: Type: text/plain, Size: 1759 bytes --]
On Sat, Mar 19, 2022 at 06:29:36PM +0000, Jonathan Cameron wrote:
> On Mon, 14 Mar 2022 15:16:29 +0100
> Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:
>
> > When a driver keeps a clock prepared (or enabled) during the whole
> > lifetime of the driver, these helpers allow to simplify the drivers.
> >
> > Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> > Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> > Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
>
> One trivial thing below.
>
> > ---
> > drivers/clk/clk-devres.c | 31 ++++++++++++++
> > include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
> > 2 files changed, 120 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> > index fb7761888b30..4707fe718f0b 100644
> > --- a/drivers/clk/clk-devres.c
> > +++ b/drivers/clk/clk-devres.c
> > @@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
> > }
> > EXPORT_SYMBOL(devm_clk_get);
> >
> > +struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
> > +{
> > + return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
>
> Nitpick but this spacing before } in functions is rather unusual and not
> in keeping with the existing code in this file.
>
> > +
> > +}
ack, I fixed that in my tree, so this will be part of an v9. I won't
send it just for this change, though. I fixed three further functions
that had a similar empty line, too.
Thanks for looking
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: 167 bytes --]
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
@ 2022-03-21 7:22 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-21 7:22 UTC (permalink / raw)
To: Jonathan Cameron
Cc: Alexandre Belloni, Heiko Stuebner, Neil Armstrong, David Airlie,
Alexandru Ardelean, Linus Walleij, Jonathan Cameron,
Tomislav Denis, André Gustavo Nakagomi Lopez, Nuno Sá,
Paul Cercueil, Thierry Reding, linux-i2c, Nobuhiro Iwamatsu,
Oleksij Rempel, Lee Jones, linux-clk, Jerome Brunet, linux-rtc,
Lars-Peter Clausen, Herbert Xu, Alexandre Torgue, Kevin Hilman,
Bartosz Golaszewski, Russell King, linux-pwm, Claudiu Beznea,
linux-iio, Andy Gross, linux-arm-kernel, linux-mips,
Keguang Zhang, Michael Turquette, Guenter Roeck, NXP Linux Team,
Maxime Coquelin, Bjorn Andersson, Jean Delvare, Michal Simek,
kernel, Michael Hennerich, Martin Blumenstingl, linux-arm-msm,
linux-spi, Anand Ashok Dumbre, Vladimir Zapolskiy, linux-gpio,
Mark Brown, dri-devel, Fabio Estevam, Matt Mackall,
linux-amlogic, Wim Van Sebroeck, Lars Povlsen, linux-hwmon,
Alessandro Zummo, linux-watchdog, Stephen Boyd,
Greg Kroah-Hartman, Patrice Chotard, linux-stm32, Nicolas Ferre,
UNGLinuxDriver, Vinod Koul, Cai Huoqing, linux-crypto,
Daniel Vetter, dmaengine, Amireddy Mallikarjuna reddy, Shawn Guo,
Steen Hegelund
[-- Attachment #1: Type: text/plain, Size: 1759 bytes --]
On Sat, Mar 19, 2022 at 06:29:36PM +0000, Jonathan Cameron wrote:
> On Mon, 14 Mar 2022 15:16:29 +0100
> Uwe Kleine-König <u.kleine-koenig@pengutronix.de> wrote:
>
> > When a driver keeps a clock prepared (or enabled) during the whole
> > lifetime of the driver, these helpers allow to simplify the drivers.
> >
> > Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> > Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> > Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
>
> One trivial thing below.
>
> > ---
> > drivers/clk/clk-devres.c | 31 ++++++++++++++
> > include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
> > 2 files changed, 120 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> > index fb7761888b30..4707fe718f0b 100644
> > --- a/drivers/clk/clk-devres.c
> > +++ b/drivers/clk/clk-devres.c
> > @@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
> > }
> > EXPORT_SYMBOL(devm_clk_get);
> >
> > +struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
> > +{
> > + return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
>
> Nitpick but this spacing before } in functions is rather unusual and not
> in keeping with the existing code in this file.
>
> > +
> > +}
ack, I fixed that in my tree, so this will be part of an v9. I won't
send it just for this change, though. I fixed three further functions
that had a similar empty line, too.
Thanks for looking
Uwe
--
Pengutronix e.K. | Uwe Kleine-König |
Industrial Linux Solutions | https://www.pengutronix.de/ |
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 02/16] clk: Provide new devm_clk helpers for prepared and enabled clocks
2022-03-14 14:16 ` Uwe Kleine-König
` (2 preceding siblings ...)
(?)
@ 2022-05-19 23:45 ` Stephen Boyd
-1 siblings, 0 replies; 88+ messages in thread
From: Stephen Boyd @ 2022-05-19 23:45 UTC (permalink / raw)
To: Alessandro Zummo, Alexandre Belloni, Bartosz Golaszewski,
Claudiu Beznea, Daniel Vetter, David Airlie, Fabio Estevam,
Greg Kroah-Hartman, Guenter Roeck, Herbert Xu, Jean Delvare,
Jerome Brunet, Jonathan Cameron, Kevin Hilman, Lars Povlsen,
Lars-Peter Clausen, Lee Jones, Linus Walleij, Mark Brown,
Martin Blumenstingl, Matt Mackall, Michael Hennerich,
Michael Turquette, NXP Linux Team, Neil Armstrong
Cc: Tomislav Denis, linux-iio, Alexandre Torgue, dri-devel,
Bjorn Andersson, linux-i2c, Nobuhiro Iwamatsu, linux-clk,
linux-watchdog, linux-rtc, Michal Simek, linux-stm32,
.kernel.org, Andy Gross, Alexandru Ardelean, Keguang Zhang,
Patrice Chotard, kernel, linux-arm-msm, Anand Ashok Dumbre,
Vladimir Zapolskiy, linux-gpio,
André Gustavo Nakagomi Lopez, Jonathan Cameron,
linux-amlogic, linux-pwm, Amireddy Mallikarjuna reddy,
linux-mips, linux-spi, Cai Huoqing, linux-crypto,
Maxime Coquelin, dmaengine
The Cc list is huge. Here it goes!
Quoting Uwe Kleine-König (2022-03-14 07:16:29)
> When a driver keeps a clock prepared (or enabled) during the whole
> lifetime of the driver, these helpers allow to simplify the drivers.
>
> Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
> Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> ---
I'm ready to merge it! I'm largely waiting for Russell to ack the clk.h
change, but if that doesn't happen then I think we'll have to merge it
anyway. Can you resend with collected acks, maybe just the ones you want
me to merge through clk tree? Then I'll go ahead and stage it. Some
nitpicks below.
> drivers/clk/clk-devres.c | 31 ++++++++++++++
> include/linux/clk.h | 90 +++++++++++++++++++++++++++++++++++++++-
> 2 files changed, 120 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c
> index fb7761888b30..4707fe718f0b 100644
> --- a/drivers/clk/clk-devres.c
> +++ b/drivers/clk/clk-devres.c
> @@ -67,12 +67,43 @@ struct clk *devm_clk_get(struct device *dev, const char *id)
> }
> EXPORT_SYMBOL(devm_clk_get);
>
> +struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
> +
Nitpick: Remove newline
> +}
> +EXPORT_SYMBOL(devm_clk_get_prepared);
> +
> +struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get,
> + clk_prepare_enable, clk_disable_unprepare);
> +
Nitpick: Remove newline
> +}
> +EXPORT_SYMBOL(devm_clk_get_enabled);
> +
> struct clk *devm_clk_get_optional(struct device *dev, const char *id)
> {
> return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
> }
> EXPORT_SYMBOL(devm_clk_get_optional);
>
> +struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional,
> + clk_prepare, clk_unprepare);
> +
Nitpick: Remove newline
> +}
> +EXPORT_SYMBOL(devm_clk_get_optional_prepared);
> +
> +struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
> +{
> + return __devm_clk_get(dev, id, clk_get_optional,
> + clk_prepare_enable, clk_disable_unprepare);
> +
Nitpick: Remove newline
> +}
> +EXPORT_SYMBOL(devm_clk_get_optional_enabled);
EXPORT_SYMBOL_GPL for all of these? Or make them macros and cut down on
the number of symbols.
> +
> struct clk_bulk_devres {
> struct clk_bulk_data *clks;
> int num_clks;
> diff --git a/include/linux/clk.h b/include/linux/clk.h
> index 266e8de3cb51..b011dbba7109 100644
> --- a/include/linux/clk.h
> +++ b/include/linux/clk.h
> @@ -449,7 +449,7 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
> * the clock producer. (IOW, @id may be identical strings, but
> * clk_get may return different clock producers depending on @dev.)
> *
> - * Drivers must assume that the clock source is not enabled.
> + * Drivers must assume that the clock source is neither prepared nor enabled.
> *
> * devm_clk_get should not be called from within interrupt context.
> *
Can you split this off to another patch? It's updating the doc to
clarify the assumed state of a clk returned from this API.
> @@ -458,6 +458,47 @@ int __must_check devm_clk_bulk_get_all(struct device *dev,
> */
> struct clk *devm_clk_get(struct device *dev, const char *id);
>
> +/**
> + * devm_clk_get_prepared - devm_clk_get() + clk_prepare()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Returns a struct clk corresponding to the clock producer, or
> + * valid IS_ERR() condition containing errno. The implementation
> + * uses @dev and @id to determine the clock consumer, and thereby
> + * the clock producer. (IOW, @id may be identical strings, but
> + * clk_get may return different clock producers depending on @dev.)
> + *
> + * The returned clk (if valid) is prepared. Drivers must however assume that the
> + * clock is not enabled.
> + *
> + * devm_clk_get_prepared should not be called from within interrupt context.
There's 'Context:' for this. Please use it.
> + *
> + * The clock will automatically be unprepared and freed when the
> + * device is unbound from the bus.
> + */
> +struct clk *devm_clk_get_prepared(struct device *dev, const char *id);
> +
> +/**
> + * devm_clk_get_enabled - devm_clk_get() + clk_prepare_enable()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Returns a struct clk corresponding to the clock producer, or valid IS_ERR()
There's 'Return:' for this. Please use it.
> + * condition containing errno. The implementation uses @dev and @id to
> + * determine the clock consumer, and thereby the clock producer. (IOW, @id may
> + * be identical strings, but clk_get may return different clock producers
> + * depending on @dev.)
> + *
> + * The returned clk (if valid) is prepared and enabled.
> + *
> + * devm_clk_get_prepared should not be called from within interrupt context.
> + *
> + * The clock will automatically be disabled, unprepared and freed when the
> + * device is unbound from the bus.
> + */
> +struct clk *devm_clk_get_enabled(struct device *dev, const char *id);
> +
> /**
> * devm_clk_get_optional - lookup and obtain a managed reference to an optional
> * clock producer.
> @@ -469,6 +510,29 @@ struct clk *devm_clk_get(struct device *dev, const char *id);
> */
> struct clk *devm_clk_get_optional(struct device *dev, const char *id);
>
> +/**
> + * devm_clk_get_optional_prepared - devm_clk_get_optional() + clk_prepare()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Behaves the same as devm_clk_get_prepared() except where there is no clock
> + * producer. In this case, instead of returning -ENOENT, the function returns
> + * NULL.
When it comes to kernel-doc I think the DRY principle should not apply.
I don't want to have to jump to one doc block to jump to another doc
block while holding the previous verbage in my head to understand what
the difference is. Please be repetitive with documentation for APIs :)
> + */
> +struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id);
> +
> +/**
> + * devm_clk_get_optional_enabled - devm_clk_get_optional() +
> + * clk_prepare_enable()
> + * @dev: device for clock "consumer"
> + * @id: clock consumer ID
> + *
> + * Behaves the same as devm_clk_get_enabled() except where there is no clock
> + * producer. In this case, instead of returning -ENOENT, the function returns
> + * NULL.
> + */
> +struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id);
> +
> /**
> * devm_get_clk_from_child - lookup and obtain a managed reference to a
> * clock producer from child node.
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
Neil Armstrong, Kevin Hilman, Jerome Brunet, Martin Blumenstingl,
linux-crypto, linux-amlogic
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
Neil Armstrong, Kevin Hilman, Jerome Brunet, Martin Blumenstingl,
linux-crypto, linux-amlogic
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
UNGLinuxDriver, linux-hwmon, linux-arm-kernel,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron,
Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
Neil Armstrong, Kevin Hilman, Jerome Brunet, Martin Blumenstingl,
linux-crypto, linux-amlogic
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-15 23:26 ` Guenter Roeck
-1 siblings, 0 replies; 88+ messages in thread
From: Guenter Roeck @ 2022-03-15 23:26 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Nuno Sá,
Jean Delvare, Lars Povlsen, Steen Hegelund, UNGLinuxDriver,
linux-hwmon, linux-arm-kernel, Lars-Peter Clausen,
Michael Hennerich, Jonathan Cameron, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
Neil Armstrong, Kevin Hilman, Jerome Brunet, Martin Blumenstingl,
linux-crypto, linux-amlogic
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()
@ 2022-03-15 23:26 ` Guenter Roeck
0 siblings, 0 replies; 88+ messages in thread
From: Guenter Roeck @ 2022-03-15 23:26 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Nuno Sá,
Jean Delvare, Lars Povlsen, Steen Hegelund, UNGLinuxDriver,
linux-hwmon, linux-arm-kernel, Lars-Peter Clausen,
Michael Hennerich, Jonathan Cameron, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
Neil Armstrong, Kevin Hilman, Jerome Brunet, Martin Blumenstingl,
linux-crypto, linux-amlogic
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,
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 03/16] hwmon: Make use of devm_clk_get_enabled()
@ 2022-03-15 23:26 ` Guenter Roeck
0 siblings, 0 replies; 88+ messages in thread
From: Guenter Roeck @ 2022-03-15 23:26 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Nuno Sá,
Jean Delvare, Lars Povlsen, Steen Hegelund, UNGLinuxDriver,
linux-hwmon, linux-arm-kernel, Lars-Peter Clausen,
Michael Hennerich, Jonathan Cameron, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
Neil Armstrong, Kevin Hilman, Jerome Brunet, Martin Blumenstingl,
linux-crypto, linux-amlogic
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
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
Nuno Sa, André Gustavo Nakagomi Lopez, Cai Huoqing,
linux-iio, linux-arm-kernel
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King,
Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
Nuno Sa, André Gustavo Nakagomi Lopez, Cai Huoqing,
linux-iio, linux-arm-kernel
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* RE: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
@ 2022-03-14 15:01 ` Sa, Nuno
-1 siblings, 0 replies; 88+ messages in thread
From: Sa, Nuno @ 2022-03-14 15:01 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Lars-Peter Clausen, Hennerich, Michael,
Jonathan Cameron
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-arm-kernel
> 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
^ permalink raw reply [flat|nested] 88+ messages in thread* RE: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
@ 2022-03-14 15:01 ` Sa, Nuno
0 siblings, 0 replies; 88+ messages in thread
From: Sa, Nuno @ 2022-03-14 15:01 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Lars-Peter Clausen, Hennerich, Michael,
Jonathan Cameron
Cc: linux-clk, kernel, Paul Cercueil, Vladimir Zapolskiy,
Heiko Stuebner, Tomislav Denis, Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-arm-kernel
> 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
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
@ 2022-03-19 18:22 ` Jonathan Cameron
-1 siblings, 0 replies; 88+ messages in thread
From: Jonathan Cameron @ 2022-03-19 18:22 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King,
Lars-Peter Clausen, Michael Hennerich, linux-clk, kernel,
Paul Cercueil, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek, Nuno Sa,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-arm-kernel
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) {
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
@ 2022-03-19 18:22 ` Jonathan Cameron
0 siblings, 0 replies; 88+ messages in thread
From: Jonathan Cameron @ 2022-03-19 18:22 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King,
Lars-Peter Clausen, Michael Hennerich, linux-clk, kernel,
Paul Cercueil, Vladimir Zapolskiy, Heiko Stuebner,
Tomislav Denis, Anand Ashok Dumbre, Michal Simek, Nuno Sa,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-arm-kernel
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
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
2022-03-19 18:22 ` Jonathan Cameron
@ 2022-03-21 7:41 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-21 7:41 UTC (permalink / raw)
To: Jonathan Cameron
Cc: Tomislav Denis, Lars-Peter Clausen, Michal Simek, Heiko Stuebner,
Michael Hennerich, Stephen Boyd, Michael Turquette,
Anand Ashok Dumbre, Russell King,
André Gustavo Nakagomi Lopez, Vladimir Zapolskiy,
Paul Cercueil, linux-iio, Cai Huoqing, kernel, Nuno Sa,
linux-clk, linux-arm-kernel
[-- Attachment #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 #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
@ 2022-03-21 7:41 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-21 7:41 UTC (permalink / raw)
To: Jonathan Cameron
Cc: Tomislav Denis, Lars-Peter Clausen, Michal Simek, Heiko Stuebner,
Michael Hennerich, Stephen Boyd, Michael Turquette,
Anand Ashok Dumbre, Russell King,
André Gustavo Nakagomi Lopez, Vladimir Zapolskiy,
Paul Cercueil, linux-iio, Cai Huoqing, kernel, Nuno Sa,
linux-clk, linux-arm-kernel
[-- 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
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
2022-03-21 7:41 ` Uwe Kleine-König
@ 2022-03-22 20:34 ` Jonathan Cameron
-1 siblings, 0 replies; 88+ messages in thread
From: Jonathan Cameron @ 2022-03-22 20:34 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Jonathan Cameron, Tomislav Denis, Lars-Peter Clausen,
Michal Simek, Heiko Stuebner, Michael Hennerich, Stephen Boyd,
Michael Turquette, Anand Ashok Dumbre, Russell King,
André Gustavo Nakagomi Lopez, Vladimir Zapolskiy,
Paul Cercueil, linux-iio, Cai Huoqing, kernel, Nuno Sa,
linux-clk, linux-arm-kernel
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
>
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 04/16] iio: Make use of devm_clk_get_enabled()
@ 2022-03-22 20:34 ` Jonathan Cameron
0 siblings, 0 replies; 88+ messages in thread
From: Jonathan Cameron @ 2022-03-22 20:34 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Jonathan Cameron, Tomislav Denis, Lars-Peter Clausen,
Michal Simek, Heiko Stuebner, Michael Hennerich, Stephen Boyd,
Michael Turquette, Anand Ashok Dumbre, Russell King,
André Gustavo Nakagomi Lopez, Vladimir Zapolskiy,
Paul Cercueil, linux-iio, Cai Huoqing, kernel, Nuno Sa,
linux-clk, linux-arm-kernel
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
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 05/16] hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Neil Armstrong, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl, linux-crypto, linux-arm-kernel,
linux-amlogic
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 05/16] hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Neil Armstrong, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl, linux-crypto, linux-arm-kernel,
linux-amlogic
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 05/16] hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Neil Armstrong, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl, linux-crypto, linux-arm-kernel,
linux-amlogic
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 05/16] hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-16 8:32 ` Neil Armstrong
-1 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-03-16 8:32 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl, linux-crypto, linux-arm-kernel,
linux-amlogic
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>
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 05/16] hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
@ 2022-03-16 8:32 ` Neil Armstrong
0 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-03-16 8:32 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl, linux-crypto, linux-arm-kernel,
linux-amlogic
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
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 05/16] hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
@ 2022-03-16 8:32 ` Neil Armstrong
0 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-03-16 8:32 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, Matt Mackall, Herbert Xu
Cc: linux-clk, kernel, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl, linux-crypto, linux-arm-kernel,
linux-amlogic
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 06/16] bus: bt1: Don't open code devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
` (6 preceding siblings ...)
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Greg Kroah-Hartman
Cc: linux-clk, kernel
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/bus/bt1-apb.c | 23 +----------------------
drivers/bus/bt1-axi.c | 23 ++---------------------
2 files changed, 3 insertions(+), 43 deletions(-)
diff --git a/drivers/bus/bt1-apb.c b/drivers/bus/bt1-apb.c
index b25ff941e7c7..2fa135f1097b 100644
--- a/drivers/bus/bt1-apb.c
+++ b/drivers/bus/bt1-apb.c
@@ -187,35 +187,14 @@ static int bt1_apb_request_rst(struct bt1_apb *apb)
return ret;
}
-static void bt1_apb_disable_clk(void *data)
-{
- struct bt1_apb *apb = data;
-
- clk_disable_unprepare(apb->pclk);
-}
-
static int bt1_apb_request_clk(struct bt1_apb *apb)
{
- int ret;
-
- apb->pclk = devm_clk_get(apb->dev, "pclk");
+ apb->pclk = devm_clk_get_enabled(apb->dev, "pclk");
if (IS_ERR(apb->pclk)) {
dev_err(apb->dev, "Couldn't get APB clock descriptor\n");
return PTR_ERR(apb->pclk);
}
- ret = clk_prepare_enable(apb->pclk);
- if (ret) {
- dev_err(apb->dev, "Couldn't enable the APB clock\n");
- return ret;
- }
-
- ret = devm_add_action_or_reset(apb->dev, bt1_apb_disable_clk, apb);
- if (ret) {
- dev_err(apb->dev, "Can't add APB EHB clocks disable action\n");
- return ret;
- }
-
apb->rate = clk_get_rate(apb->pclk);
if (!apb->rate) {
dev_err(apb->dev, "Invalid clock rate\n");
diff --git a/drivers/bus/bt1-axi.c b/drivers/bus/bt1-axi.c
index e7a6744acc7b..e96a2c0df890 100644
--- a/drivers/bus/bt1-axi.c
+++ b/drivers/bus/bt1-axi.c
@@ -147,34 +147,15 @@ static int bt1_axi_request_rst(struct bt1_axi *axi)
return ret;
}
-static void bt1_axi_disable_clk(void *data)
-{
- struct bt1_axi *axi = data;
-
- clk_disable_unprepare(axi->aclk);
-}
-
static int bt1_axi_request_clk(struct bt1_axi *axi)
{
- int ret;
-
- axi->aclk = devm_clk_get(axi->dev, "aclk");
+ axi->aclk = devm_clk_get_enabled(axi->dev, "aclk");
if (IS_ERR(axi->aclk)) {
dev_err(axi->dev, "Couldn't get AXI Interconnect clock\n");
return PTR_ERR(axi->aclk);
}
- ret = clk_prepare_enable(axi->aclk);
- if (ret) {
- dev_err(axi->dev, "Couldn't enable the AXI clock\n");
- return ret;
- }
-
- ret = devm_add_action_or_reset(axi->dev, bt1_axi_disable_clk, axi);
- if (ret)
- dev_err(axi->dev, "Can't add AXI clock disable action\n");
-
- return ret;
+ return 0;
}
static int bt1_axi_request_irq(struct bt1_axi *axi)
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 07/16] gpio: vf610: Simplify error handling in probe
2022-03-14 14:16 ` Uwe Kleine-König
` (7 preceding siblings ...)
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
2022-03-14 15:01 ` Bartosz Golaszewski
-1 siblings, 1 reply; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Linus Walleij,
Bartosz Golaszewski
Cc: linux-clk, kernel, linux-gpio
Instead of manually enabling and registering a devm cleanup handler that
disables the clock, use devm_clk_get_enabled(). Also replace the handling
of the optional clocks by using a variant of clk_get_optional().
The resulting code is a tad stricter than the previous code as errors from
clk_get() (apart from -ENOENT) make vf610_gpio_probe() return an error.
This is however an improvement.
Also make the clock pointers local variables instead of a member of driver
data, as they are only used in .probe().
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/gpio/gpio-vf610.c | 45 +++++++--------------------------------
1 file changed, 8 insertions(+), 37 deletions(-)
diff --git a/drivers/gpio/gpio-vf610.c b/drivers/gpio/gpio-vf610.c
index 20780c35da1b..4a6ad2e8d1a1 100644
--- a/drivers/gpio/gpio-vf610.c
+++ b/drivers/gpio/gpio-vf610.c
@@ -34,8 +34,6 @@ struct vf610_gpio_port {
void __iomem *gpio_base;
const struct fsl_gpio_soc_data *sdata;
u8 irqc[VF610_GPIO_PER_PORT];
- struct clk *clk_port;
- struct clk *clk_gpio;
int irq;
};
@@ -232,11 +230,6 @@ static int vf610_gpio_irq_set_wake(struct irq_data *d, u32 enable)
return 0;
}
-static void vf610_gpio_disable_clk(void *data)
-{
- clk_disable_unprepare(data);
-}
-
static int vf610_gpio_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
@@ -245,6 +238,8 @@ static int vf610_gpio_probe(struct platform_device *pdev)
struct gpio_chip *gc;
struct gpio_irq_chip *girq;
struct irq_chip *ic;
+ struct clk *clk_port;
+ struct clk *clk_gpio;
int i;
int ret;
@@ -265,37 +260,13 @@ static int vf610_gpio_probe(struct platform_device *pdev)
if (port->irq < 0)
return port->irq;
- port->clk_port = devm_clk_get(dev, "port");
- ret = PTR_ERR_OR_ZERO(port->clk_port);
- if (!ret) {
- ret = clk_prepare_enable(port->clk_port);
- if (ret)
- return ret;
- ret = devm_add_action_or_reset(dev, vf610_gpio_disable_clk,
- port->clk_port);
- if (ret)
- return ret;
- } else if (ret == -EPROBE_DEFER) {
- /*
- * Percolate deferrals, for anything else,
- * just live without the clocking.
- */
- return ret;
- }
+ clk_port = devm_clk_get_optional_enabled(dev, "port");
+ if (IS_ERR(clk_port))
+ return PTR_ERR(clk_port);
- port->clk_gpio = devm_clk_get(dev, "gpio");
- ret = PTR_ERR_OR_ZERO(port->clk_gpio);
- if (!ret) {
- ret = clk_prepare_enable(port->clk_gpio);
- if (ret)
- return ret;
- ret = devm_add_action_or_reset(dev, vf610_gpio_disable_clk,
- port->clk_gpio);
- if (ret)
- return ret;
- } else if (ret == -EPROBE_DEFER) {
- return ret;
- }
+ clk_gpio = devm_clk_get_optional_enabled(dev, "gpio");
+ if (IS_ERR(clk_gpio))
+ return PTR_ERR(clk_gpio);
gc = &port->gc;
gc->parent = dev;
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 07/16] gpio: vf610: Simplify error handling in probe
2022-03-14 14:16 ` [PATCH v8 07/16] gpio: vf610: Simplify error handling in probe Uwe Kleine-König
@ 2022-03-14 15:01 ` Bartosz Golaszewski
0 siblings, 0 replies; 88+ messages in thread
From: Bartosz Golaszewski @ 2022-03-14 15:01 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Linus Walleij,
linux-clk, Sascha Hauer, open list:GPIO SUBSYSTEM
On Mon, Mar 14, 2022 at 3:17 PM Uwe Kleine-König
<u.kleine-koenig@pengutronix.de> wrote:
>
> Instead of manually enabling and registering a devm cleanup handler that
> disables the clock, use devm_clk_get_enabled(). Also replace the handling
> of the optional clocks by using a variant of clk_get_optional().
>
> The resulting code is a tad stricter than the previous code as errors from
> clk_get() (apart from -ENOENT) make vf610_gpio_probe() return an error.
> This is however an improvement.
>
> Also make the clock pointers local variables instead of a member of driver
> data, as they are only used in .probe().
>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
> ---
> drivers/gpio/gpio-vf610.c | 45 +++++++--------------------------------
> 1 file changed, 8 insertions(+), 37 deletions(-)
>
> diff --git a/drivers/gpio/gpio-vf610.c b/drivers/gpio/gpio-vf610.c
> index 20780c35da1b..4a6ad2e8d1a1 100644
> --- a/drivers/gpio/gpio-vf610.c
> +++ b/drivers/gpio/gpio-vf610.c
> @@ -34,8 +34,6 @@ struct vf610_gpio_port {
> void __iomem *gpio_base;
> const struct fsl_gpio_soc_data *sdata;
> u8 irqc[VF610_GPIO_PER_PORT];
> - struct clk *clk_port;
> - struct clk *clk_gpio;
> int irq;
> };
>
> @@ -232,11 +230,6 @@ static int vf610_gpio_irq_set_wake(struct irq_data *d, u32 enable)
> return 0;
> }
>
> -static void vf610_gpio_disable_clk(void *data)
> -{
> - clk_disable_unprepare(data);
> -}
> -
> static int vf610_gpio_probe(struct platform_device *pdev)
> {
> struct device *dev = &pdev->dev;
> @@ -245,6 +238,8 @@ static int vf610_gpio_probe(struct platform_device *pdev)
> struct gpio_chip *gc;
> struct gpio_irq_chip *girq;
> struct irq_chip *ic;
> + struct clk *clk_port;
> + struct clk *clk_gpio;
> int i;
> int ret;
>
> @@ -265,37 +260,13 @@ static int vf610_gpio_probe(struct platform_device *pdev)
> if (port->irq < 0)
> return port->irq;
>
> - port->clk_port = devm_clk_get(dev, "port");
> - ret = PTR_ERR_OR_ZERO(port->clk_port);
> - if (!ret) {
> - ret = clk_prepare_enable(port->clk_port);
> - if (ret)
> - return ret;
> - ret = devm_add_action_or_reset(dev, vf610_gpio_disable_clk,
> - port->clk_port);
> - if (ret)
> - return ret;
> - } else if (ret == -EPROBE_DEFER) {
> - /*
> - * Percolate deferrals, for anything else,
> - * just live without the clocking.
> - */
> - return ret;
> - }
> + clk_port = devm_clk_get_optional_enabled(dev, "port");
> + if (IS_ERR(clk_port))
> + return PTR_ERR(clk_port);
>
> - port->clk_gpio = devm_clk_get(dev, "gpio");
> - ret = PTR_ERR_OR_ZERO(port->clk_gpio);
> - if (!ret) {
> - ret = clk_prepare_enable(port->clk_gpio);
> - if (ret)
> - return ret;
> - ret = devm_add_action_or_reset(dev, vf610_gpio_disable_clk,
> - port->clk_gpio);
> - if (ret)
> - return ret;
> - } else if (ret == -EPROBE_DEFER) {
> - return ret;
> - }
> + clk_gpio = devm_clk_get_optional_enabled(dev, "gpio");
> + if (IS_ERR(clk_gpio))
> + return PTR_ERR(clk_gpio);
>
> gc = &port->gc;
> gc->parent = dev;
> --
> 2.35.1
>
Acked-by: Bartosz Golaszewski <brgl@bgdev.pl>
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Neil Armstrong,
David Airlie, Daniel Vetter, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl
Cc: linux-clk, kernel, dri-devel, linux-amlogic, linux-arm-kernel
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Neil Armstrong,
David Airlie, Daniel Vetter, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl
Cc: linux-clk, kernel, dri-devel, linux-amlogic, linux-arm-kernel
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Neil Armstrong,
David Airlie, Daniel Vetter, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl
Cc: linux-clk, kernel, dri-devel, linux-amlogic, linux-arm-kernel
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Neil Armstrong,
David Airlie, Daniel Vetter, Kevin Hilman, Jerome Brunet,
Martin Blumenstingl
Cc: linux-arm-kernel, linux-amlogic, dri-devel, linux-clk, kernel
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
(?)
@ 2022-03-16 8:33 ` Neil Armstrong
-1 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-03-16 8:33 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, David Airlie, Daniel Vetter, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl
Cc: linux-clk, kernel, dri-devel, linux-amlogic, linux-arm-kernel
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>
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
@ 2022-03-16 8:33 ` Neil Armstrong
0 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-03-16 8:33 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, David Airlie, Daniel Vetter, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl
Cc: linux-clk, kernel, dri-devel, linux-amlogic, linux-arm-kernel
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
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
@ 2022-03-16 8:33 ` Neil Armstrong
0 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-03-16 8:33 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, David Airlie, Daniel Vetter, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl
Cc: linux-clk, kernel, dri-devel, linux-amlogic, linux-arm-kernel
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 08/16] drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
@ 2022-03-16 8:33 ` Neil Armstrong
0 siblings, 0 replies; 88+ messages in thread
From: Neil Armstrong @ 2022-03-16 8:33 UTC (permalink / raw)
To: Uwe Kleine-König, Michael Turquette, Stephen Boyd,
Russell King, David Airlie, Daniel Vetter, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl
Cc: linux-arm-kernel, linux-amlogic, dri-devel, linux-clk, kernel
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>
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 09/16] rtc: ingenic: Simplify using devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
` (9 preceding siblings ...)
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
2022-03-15 22:47 ` Paul Cercueil
-1 siblings, 1 reply; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Paul Cercueil,
Alessandro Zummo, Alexandre Belloni
Cc: linux-clk, kernel, linux-mips, linux-rtc
With devm_clk_get_enabled() caring to disable (and unprepare) the clock,
the probe function can be simplified accordingly.
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/rtc/rtc-jz4740.c | 21 ++-------------------
1 file changed, 2 insertions(+), 19 deletions(-)
diff --git a/drivers/rtc/rtc-jz4740.c b/drivers/rtc/rtc-jz4740.c
index 6e51df72fd65..9b7bb6ce93ee 100644
--- a/drivers/rtc/rtc-jz4740.c
+++ b/drivers/rtc/rtc-jz4740.c
@@ -257,11 +257,6 @@ static void jz4740_rtc_power_off(void)
kernel_halt();
}
-static void jz4740_rtc_clk_disable(void *data)
-{
- clk_disable_unprepare(data);
-}
-
static const struct of_device_id jz4740_rtc_of_match[] = {
{ .compatible = "ingenic,jz4740-rtc", .data = (void *)ID_JZ4740 },
{ .compatible = "ingenic,jz4760-rtc", .data = (void *)ID_JZ4760 },
@@ -329,24 +324,12 @@ static int jz4740_rtc_probe(struct platform_device *pdev)
if (IS_ERR(rtc->base))
return PTR_ERR(rtc->base);
- clk = devm_clk_get(dev, "rtc");
+ clk = devm_clk_get_enabled(dev, "rtc");
if (IS_ERR(clk)) {
- dev_err(dev, "Failed to get RTC clock\n");
+ dev_err(dev, "Failed to get enabled RTC clock\n");
return PTR_ERR(clk);
}
- ret = clk_prepare_enable(clk);
- if (ret) {
- dev_err(dev, "Failed to enable clock\n");
- return ret;
- }
-
- ret = devm_add_action_or_reset(dev, jz4740_rtc_clk_disable, clk);
- if (ret) {
- dev_err(dev, "Failed to register devm action\n");
- return ret;
- }
-
spin_lock_init(&rtc->lock);
platform_set_drvdata(pdev, rtc);
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 09/16] rtc: ingenic: Simplify using devm_clk_get_enabled()
2022-03-14 14:16 ` [PATCH v8 09/16] rtc: ingenic: Simplify using devm_clk_get_enabled() Uwe Kleine-König
@ 2022-03-15 22:47 ` Paul Cercueil
0 siblings, 0 replies; 88+ messages in thread
From: Paul Cercueil @ 2022-03-15 22:47 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Alessandro Zummo,
Alexandre Belloni, linux-clk, kernel, linux-mips, linux-rtc
Hi Uwe,
Le lun., mars 14 2022 at 15:16:36 +0100, Uwe Kleine-König
<u.kleine-koenig@pengutronix.de> a écrit :
> With devm_clk_get_enabled() caring to disable (and unprepare) the
> clock,
> the probe function can be simplified accordingly.
>
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Reviewed-by: Paul Cercueil <paul@crapouillou.net>
Thanks!
-Paul
> ---
> drivers/rtc/rtc-jz4740.c | 21 ++-------------------
> 1 file changed, 2 insertions(+), 19 deletions(-)
>
> diff --git a/drivers/rtc/rtc-jz4740.c b/drivers/rtc/rtc-jz4740.c
> index 6e51df72fd65..9b7bb6ce93ee 100644
> --- a/drivers/rtc/rtc-jz4740.c
> +++ b/drivers/rtc/rtc-jz4740.c
> @@ -257,11 +257,6 @@ static void jz4740_rtc_power_off(void)
> kernel_halt();
> }
>
> -static void jz4740_rtc_clk_disable(void *data)
> -{
> - clk_disable_unprepare(data);
> -}
> -
> static const struct of_device_id jz4740_rtc_of_match[] = {
> { .compatible = "ingenic,jz4740-rtc", .data = (void *)ID_JZ4740 },
> { .compatible = "ingenic,jz4760-rtc", .data = (void *)ID_JZ4760 },
> @@ -329,24 +324,12 @@ static int jz4740_rtc_probe(struct
> platform_device *pdev)
> if (IS_ERR(rtc->base))
> return PTR_ERR(rtc->base);
>
> - clk = devm_clk_get(dev, "rtc");
> + clk = devm_clk_get_enabled(dev, "rtc");
> if (IS_ERR(clk)) {
> - dev_err(dev, "Failed to get RTC clock\n");
> + dev_err(dev, "Failed to get enabled RTC clock\n");
> return PTR_ERR(clk);
> }
>
> - ret = clk_prepare_enable(clk);
> - if (ret) {
> - dev_err(dev, "Failed to enable clock\n");
> - return ret;
> - }
> -
> - ret = devm_add_action_or_reset(dev, jz4740_rtc_clk_disable, clk);
> - if (ret) {
> - dev_err(dev, "Failed to register devm action\n");
> - return ret;
> - }
> -
> spin_lock_init(&rtc->lock);
>
> platform_set_drvdata(pdev, rtc);
> --
> 2.35.1
>
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 10/16] clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Neil Armstrong,
Jerome Brunet, Kevin Hilman, Martin Blumenstingl
Cc: linux-clk, kernel, linux-amlogic, linux-arm-kernel
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 10/16] clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Neil Armstrong,
Jerome Brunet, Kevin Hilman, Martin Blumenstingl
Cc: linux-clk, kernel, linux-amlogic, linux-arm-kernel
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 10/16] clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Neil Armstrong,
Jerome Brunet, Kevin Hilman, Martin Blumenstingl
Cc: linux-clk, kernel, linux-amlogic, linux-arm-kernel
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply related [flat|nested] 88+ messages in thread
* [PATCH v8 11/16] watchdog: Make use of devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Wim Van Sebroeck,
Guenter Roeck
Cc: linux-clk, kernel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Keguang Zhang, Vladimir Zapolskiy, Neil Armstrong, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Michal Simek, Andy Gross,
Bjorn Andersson, Patrice Chotard, Maxime Coquelin,
Alexandre Torgue, Nobuhiro Iwamatsu, linux-watchdog,
linux-arm-kernel, linux-mips, linux-amlogic, linux-arm-msm,
linux-stm32
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 11/16] watchdog: Make use of devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Wim Van Sebroeck,
Guenter Roeck
Cc: linux-clk, kernel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Keguang Zhang, Vladimir Zapolskiy, Neil Armstrong, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Michal Simek, Andy Gross,
Bjorn Andersson, Patrice Chotard, Maxime Coquelin,
Alexandre Torgue, Nobuhiro Iwamatsu, linux-watchdog,
linux-arm-kernel, linux-mips, linux-amlogic, linux-arm-msm,
linux-stm32
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 11/16] watchdog: Make use of devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Wim Van Sebroeck,
Guenter Roeck
Cc: linux-clk, kernel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Keguang Zhang, Vladimir Zapolskiy, Neil Armstrong, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Michal Simek, Andy Gross,
Bjorn Andersson, Patrice Chotard, Maxime Coquelin,
Alexandre Torgue, Nobuhiro Iwamatsu, linux-watchdog,
linux-arm-kernel, linux-mips, linux-amlogic, linux-arm-msm,
linux-stm32
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 11/16] watchdog: Make use of devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-16 1:29 ` Guenter Roeck
-1 siblings, 0 replies; 88+ messages in thread
From: Guenter Roeck @ 2022-03-16 1:29 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Wim Van Sebroeck,
linux-clk, kernel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Keguang Zhang, Vladimir Zapolskiy, Neil Armstrong, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Michal Simek, Andy Gross,
Bjorn Andersson, Patrice Chotard, Maxime Coquelin,
Alexandre Torgue, Nobuhiro Iwamatsu, linux-watchdog,
linux-arm-kernel, linux-mips, linux-amlogic, linux-arm-msm,
linux-stm32
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-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 11/16] watchdog: Make use of devm_clk_get_enabled()
@ 2022-03-16 1:29 ` Guenter Roeck
0 siblings, 0 replies; 88+ messages in thread
From: Guenter Roeck @ 2022-03-16 1:29 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Wim Van Sebroeck,
linux-clk, kernel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Keguang Zhang, Vladimir Zapolskiy, Neil Armstrong, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Michal Simek, Andy Gross,
Bjorn Andersson, Patrice Chotard, Maxime Coquelin,
Alexandre Torgue, Nobuhiro Iwamatsu, linux-watchdog,
linux-arm-kernel, linux-mips, linux-amlogic, linux-arm-msm,
linux-stm32
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
>
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 11/16] watchdog: Make use of devm_clk_get_enabled()
@ 2022-03-16 1:29 ` Guenter Roeck
0 siblings, 0 replies; 88+ messages in thread
From: Guenter Roeck @ 2022-03-16 1:29 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Wim Van Sebroeck,
linux-clk, kernel, Shawn Guo, Fabio Estevam, NXP Linux Team,
Keguang Zhang, Vladimir Zapolskiy, Neil Armstrong, Kevin Hilman,
Jerome Brunet, Martin Blumenstingl, Michal Simek, Andy Gross,
Bjorn Andersson, Patrice Chotard, Maxime Coquelin,
Alexandre Torgue, Nobuhiro Iwamatsu, linux-watchdog,
linux-arm-kernel, linux-mips, linux-amlogic, linux-arm-msm,
linux-stm32
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
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 12/16] pwm: atmel: Simplify using devm_clk_get_prepared()
2022-03-14 14:16 ` Uwe Kleine-König
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Claudiu Beznea,
Thierry Reding, Lee Jones, Nicolas Ferre, Alexandre Belloni
Cc: linux-clk, kernel, linux-arm-kernel, linux-pwm, Alexandru Ardelean
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 12/16] pwm: atmel: Simplify using devm_clk_get_prepared()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Claudiu Beznea,
Thierry Reding, Lee Jones, Nicolas Ferre, Alexandre Belloni
Cc: linux-clk, kernel, linux-arm-kernel, linux-pwm, Alexandru Ardelean
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 12/16] pwm: atmel: Simplify using devm_clk_get_prepared()
2022-03-14 14:16 ` Uwe Kleine-König
@ 2022-03-15 9:33 ` Claudiu.Beznea
-1 siblings, 0 replies; 88+ messages in thread
From: Claudiu.Beznea @ 2022-03-15 9:33 UTC (permalink / raw)
To: u.kleine-koenig, mturquette, sboyd, linux, thierry.reding,
lee.jones, Nicolas.Ferre, alexandre.belloni
Cc: linux-clk, kernel, linux-arm-kernel, linux-pwm, aardelean
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
>
^ permalink raw reply [flat|nested] 88+ messages in thread* Re: [PATCH v8 12/16] pwm: atmel: Simplify using devm_clk_get_prepared()
@ 2022-03-15 9:33 ` Claudiu.Beznea
0 siblings, 0 replies; 88+ messages in thread
From: Claudiu.Beznea @ 2022-03-15 9:33 UTC (permalink / raw)
To: u.kleine-koenig, mturquette, sboyd, linux, thierry.reding,
lee.jones, Nicolas.Ferre, alexandre.belloni
Cc: linux-clk, kernel, linux-arm-kernel, linux-pwm, aardelean
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
^ permalink raw reply [flat|nested] 88+ messages in thread
* [PATCH v8 13/16] rtc: at91sam9: Simplify using devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Alessandro Zummo,
Alexandre Belloni, Nicolas Ferre, Claudiu Beznea
Cc: linux-clk, kernel, linux-rtc, linux-arm-kernel, Alexandru Ardelean
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 13/16] rtc: at91sam9: Simplify using devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Alessandro Zummo,
Alexandre Belloni, Nicolas Ferre, Claudiu Beznea
Cc: linux-clk, kernel, linux-rtc, linux-arm-kernel, Alexandru Ardelean
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
^ permalink raw reply related [flat|nested] 88+ messages in thread
* [PATCH v8 14/16] i2c: imx: Simplify using devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Oleksij Rempel,
Shawn Guo, Fabio Estevam, NXP Linux Team
Cc: linux-clk, kernel, linux-i2c, linux-arm-kernel, Oleksij Rempel,
Wolfram Sang, Alexandru Ardelean
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
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 14/16] i2c: imx: Simplify using devm_clk_get_enabled()
@ 2022-03-14 14:16 ` Uwe Kleine-König
0 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Oleksij Rempel,
Shawn Guo, Fabio Estevam, NXP Linux Team
Cc: linux-clk, kernel, linux-i2c, linux-arm-kernel, Oleksij Rempel,
Wolfram Sang, Alexandru Ardelean
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
^ permalink raw reply related [flat|nested] 88+ messages in thread
* [PATCH v8 15/16] spi: davinci: Simplify using devm_clk_get_enabled()
2022-03-14 14:16 ` Uwe Kleine-König
` (15 preceding siblings ...)
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Mark Brown
Cc: linux-clk, kernel, linux-spi, Alexandru Ardelean
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: Mark Brown <broonie@kernel.org>
Reviewed-by: Alexandru Ardelean <aardelean@deviqon.com>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/spi/spi-davinci.c | 11 ++---------
1 file changed, 2 insertions(+), 9 deletions(-)
diff --git a/drivers/spi/spi-davinci.c b/drivers/spi/spi-davinci.c
index d112c2cac042..5448510c285f 100644
--- a/drivers/spi/spi-davinci.c
+++ b/drivers/spi/spi-davinci.c
@@ -925,14 +925,11 @@ static int davinci_spi_probe(struct platform_device *pdev)
dspi->bitbang.master = master;
- dspi->clk = devm_clk_get(&pdev->dev, NULL);
+ dspi->clk = devm_clk_get_enabled(&pdev->dev, NULL);
if (IS_ERR(dspi->clk)) {
ret = -ENODEV;
goto free_master;
}
- ret = clk_prepare_enable(dspi->clk);
- if (ret)
- goto free_master;
master->use_gpio_descriptors = true;
master->dev.of_node = pdev->dev.of_node;
@@ -957,7 +954,7 @@ static int davinci_spi_probe(struct platform_device *pdev)
ret = davinci_spi_request_dma(dspi);
if (ret == -EPROBE_DEFER) {
- goto free_clk;
+ goto free_master;
} else if (ret) {
dev_info(&pdev->dev, "DMA is not supported (%d)\n", ret);
dspi->dma_rx = NULL;
@@ -1001,8 +998,6 @@ static int davinci_spi_probe(struct platform_device *pdev)
dma_release_channel(dspi->dma_rx);
dma_release_channel(dspi->dma_tx);
}
-free_clk:
- clk_disable_unprepare(dspi->clk);
free_master:
spi_master_put(master);
err:
@@ -1028,8 +1023,6 @@ static int davinci_spi_remove(struct platform_device *pdev)
spi_bitbang_stop(&dspi->bitbang);
- clk_disable_unprepare(dspi->clk);
-
if (dspi->dma_rx) {
dma_release_channel(dspi->dma_rx);
dma_release_channel(dspi->dma_tx);
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* [PATCH v8 16/16] dmaengine: lgm: Fix error handling
2022-03-14 14:16 ` Uwe Kleine-König
` (16 preceding siblings ...)
(?)
@ 2022-03-14 14:16 ` Uwe Kleine-König
-1 siblings, 0 replies; 88+ messages in thread
From: Uwe Kleine-König @ 2022-03-14 14:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Russell King, Vinod Koul
Cc: linux-clk, kernel, Amireddy Mallikarjuna reddy, dmaengine
It's an invalid approach to use only a single devm cleanup handler for
two resources (without further error handling at least). In this case the
core clk isn't disabled if getting the reset control fails.
This also fixes the problem that the return value of clk_prepare_enable()
wasn't checked before.
Fixes: 32d31c79a1a4 ("dmaengine: Add Intel LGM SoC DMA support.")
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
---
drivers/dma/lgm/lgm-dma.c | 8 +++-----
1 file changed, 3 insertions(+), 5 deletions(-)
diff --git a/drivers/dma/lgm/lgm-dma.c b/drivers/dma/lgm/lgm-dma.c
index efe8bd3a0e2a..f8904cf2d832 100644
--- a/drivers/dma/lgm/lgm-dma.c
+++ b/drivers/dma/lgm/lgm-dma.c
@@ -1463,11 +1463,10 @@ static int ldma_init_v22(struct ldma_dev *d, struct platform_device *pdev)
return 0;
}
-static void ldma_clk_disable(void *data)
+static void ldma_reset(void *data)
{
struct ldma_dev *d = data;
- clk_disable_unprepare(d->core_clk);
reset_control_assert(d->rst);
}
@@ -1590,17 +1589,16 @@ static int intel_ldma_probe(struct platform_device *pdev)
return PTR_ERR(d->base);
/* Power up and reset the dma engine, some DMAs always on?? */
- d->core_clk = devm_clk_get_optional(dev, NULL);
+ d->core_clk = devm_clk_get_optional_enabled(dev, NULL);
if (IS_ERR(d->core_clk))
return PTR_ERR(d->core_clk);
- clk_prepare_enable(d->core_clk);
d->rst = devm_reset_control_get_optional(dev, NULL);
if (IS_ERR(d->rst))
return PTR_ERR(d->rst);
reset_control_deassert(d->rst);
- ret = devm_add_action_or_reset(dev, ldma_clk_disable, d);
+ ret = devm_add_action_or_reset(dev, ldma_reset, d);
if (ret) {
dev_err(dev, "Failed to devm_add_action_or_reset, %d\n", ret);
return ret;
--
2.35.1
^ permalink raw reply related [flat|nested] 88+ messages in thread* Re: [PATCH v8 00/16] clk: provide new devm helpers for prepared and enabled clocks
2022-03-14 14:16 ` Uwe Kleine-König
(?)
@ 2022-03-15 18:03 ` Andy Shevchenko
-1 siblings, 0 replies; 88+ messages in thread
From: Andy Shevchenko @ 2022-03-15 18:03 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
Microchip Linux Driver Support, linux-hwmon,
linux-arm Mailing List, Lars-Peter Clausen, Michael Hennerich,
Jonathan Cameron, Matt Mackall, Herbert Xu, Greg Kroah-Hartman,
Linus Walleij, Bartosz Golaszewski, Neil Armstrong, David Airlie,
Daniel Vetter, Kevin Hilman, Jerome Brunet, Martin Blumenstingl,
Paul Cercueil, Alessandro Zummo, Alexandre Belloni,
Wim Van Sebroeck, Claudiu Beznea, Thierry Reding, Lee Jones,
Nicolas Ferre, Oleksij Rempel, Shawn Guo, Fabio Estevam,
NXP Linux Team, Mark Brown, Vinod Koul, linux-clk, Sascha Hauer,
Vladimir Zapolskiy, Heiko Stuebner, Tomislav Denis,
Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, open list:GPIO SUBSYSTEM, dri-devel,
open list:BROADCOM NVRAM DRIVER,
open list:REAL TIME CLOCK (RTC) SUBSYSTEM, Keguang Zhang,
Andy Gross, Bjorn Andersson, Patrice Chotard, Maxime Coquelin,
Alexandre Torgue, Nobuhiro Iwamatsu, linux-watchdog,
linux-arm-msm, linux-stm32, linux-pwm, linux-i2c, linux-spi,
Amireddy Mallikarjuna reddy, dmaengine
On Mon, Mar 14, 2022 at 5:14 PM Uwe Kleine-König
<u.kleine-koenig@pengutronix.de> wrote:
>
> Hello,
>
> this is another try to convince the relevant people that
> devm_clk_get_enabled() is a nice idea. Compared to v7 (back in May 2021) this
> series is rebased to v5.17-rc8 and converts quite some drivers that open code
> devm_clk_get_enabled() up to now (patches #3 - #11).
>
> A concern about devm_clk_get_enabled() in v7 was that it helps people to be
> lazy and I agree that in some situations when devm_clk_get_enabled() is used it
> would be more efficient and sensible to care to only enable the clk when really
> needed.
>
> On the other hand, the function is right for some users, e.g. the watchdog
> drivers. For the others it's not so simple to judge. Given that there are a
> lot of drivers that are lazy even if doing so is some effort (i.e. calling
> clk_prepare_enable() and devm_add_action()) convinces me, that introducing the
> function family is sensible. (And if you want to work on these drivers,
> grepping for devm_clk_get_enabled gives you a few candidates once the
> series is in :-)
FWIW,
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
for drivers/iio
Thanks for doing this!
> Otherwise looking at the diffstat of this series:
>
> 48 files changed, 257 insertions(+), 851 deletions(-)
>
> is quite convincing. Just the first two patches (which introduce the new
> functions) account for
>
> 2 files changed, 169 insertions(+), 17 deletions(-)
>
> . A rough third of the added lines is documentation. The rest is driver
> updates which then has:
>
> 46 files changed, 88 insertions(+), 834 deletions(-)
>
> which makes a really nice cleanup.
>
> The series is build-tested on arm64, m68k, powerpc, riscv, s390, sparc64
> and x86_64 using an allmodconfig.
>
> Best regards
> Uwe
>
> Uwe Kleine-König (16):
> clk: generalize devm_clk_get() a bit
> clk: Provide new devm_clk helpers for prepared and enabled clocks
> hwmon: Make use of devm_clk_get_enabled()
> iio: Make use of devm_clk_get_enabled()
> hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
> bus: bt1: Don't open code devm_clk_get_enabled()
> gpio: vf610: Simplify error handling in probe
> drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
> rtc: ingenic: Simplify using devm_clk_get_enabled()
> clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()
> watchdog: Make use of devm_clk_get_enabled()
> pwm: atmel: Simplify using devm_clk_get_prepared()
> rtc: at91sam9: Simplify using devm_clk_get_enabled()
> i2c: imx: Simplify using devm_clk_get_enabled()
> spi: davinci: Simplify using devm_clk_get_enabled()
> dmaengine: lgm: Fix error handling
>
> drivers/bus/bt1-apb.c | 23 +------
> drivers/bus/bt1-axi.c | 23 +------
> drivers/char/hw_random/meson-rng.c | 20 +-----
> drivers/clk/clk-devres.c | 96 ++++++++++++++++++++++-----
> drivers/clk/meson/axg-audio.c | 36 ++--------
> drivers/dma/lgm/lgm-dma.c | 8 +--
> drivers/gpio/gpio-vf610.c | 45 +++----------
> drivers/gpu/drm/meson/meson_dw_hdmi.c | 48 +++++---------
> drivers/hwmon/axi-fan-control.c | 15 +----
> drivers/hwmon/ltc2947-core.c | 17 +----
> drivers/hwmon/mr75203.c | 26 +-------
> drivers/hwmon/sparx5-temp.c | 19 +-----
> drivers/i2c/busses/i2c-imx.c | 12 +---
> 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 +----
> drivers/pwm/pwm-atmel.c | 16 +----
> drivers/rtc/rtc-at91sam9.c | 22 ++----
> drivers/rtc/rtc-jz4740.c | 21 +-----
> drivers/spi/spi-davinci.c | 11 +--
> 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 +----
> include/linux/clk.h | 90 ++++++++++++++++++++++++-
> 48 files changed, 257 insertions(+), 851 deletions(-)
>
>
> base-commit: 09688c0166e76ce2fb85e86b9d99be8b0084cdf9
> --
> 2.35.1
>
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 00/16] clk: provide new devm helpers for prepared and enabled clocks
@ 2022-03-15 18:03 ` Andy Shevchenko
0 siblings, 0 replies; 88+ messages in thread
From: Andy Shevchenko @ 2022-03-15 18:03 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Michael Turquette, Stephen Boyd, Russell King, Nuno Sá,
Jean Delvare, Guenter Roeck, Lars Povlsen, Steen Hegelund,
Microchip Linux Driver Support, linux-hwmon,
linux-arm Mailing List, Lars-Peter Clausen, Michael Hennerich,
Jonathan Cameron, Matt Mackall, Herbert Xu, Greg Kroah-Hartman,
Linus Walleij, Bartosz Golaszewski, Neil Armstrong, David Airlie,
Daniel Vetter, Kevin Hilman, Jerome Brunet, Martin Blumenstingl,
Paul Cercueil, Alessandro Zummo, Alexandre Belloni,
Wim Van Sebroeck, Claudiu Beznea, Thierry Reding, Lee Jones,
Nicolas Ferre, Oleksij Rempel, Shawn Guo, Fabio Estevam,
NXP Linux Team, Mark Brown, Vinod Koul, linux-clk, Sascha Hauer,
Vladimir Zapolskiy, Heiko Stuebner, Tomislav Denis,
Anand Ashok Dumbre, Michal Simek,
André Gustavo Nakagomi Lopez, Cai Huoqing, linux-iio,
linux-crypto, linux-amlogic, open list:GPIO SUBSYSTEM, dri-devel,
open list:BROADCOM NVRAM DRIVER,
open list:REAL TIME CLOCK (RTC) SUBSYSTEM, Keguang Zhang,
Andy Gross, Bjorn Andersson, Patrice Chotard, Maxime Coquelin,
Alexandre Torgue, Nobuhiro Iwamatsu, linux-watchdog,
linux-arm-msm, linux-stm32, linux-pwm, linux-i2c, linux-spi,
Amireddy Mallikarjuna reddy, dmaengine
On Mon, Mar 14, 2022 at 5:14 PM Uwe Kleine-König
<u.kleine-koenig@pengutronix.de> wrote:
>
> Hello,
>
> this is another try to convince the relevant people that
> devm_clk_get_enabled() is a nice idea. Compared to v7 (back in May 2021) this
> series is rebased to v5.17-rc8 and converts quite some drivers that open code
> devm_clk_get_enabled() up to now (patches #3 - #11).
>
> A concern about devm_clk_get_enabled() in v7 was that it helps people to be
> lazy and I agree that in some situations when devm_clk_get_enabled() is used it
> would be more efficient and sensible to care to only enable the clk when really
> needed.
>
> On the other hand, the function is right for some users, e.g. the watchdog
> drivers. For the others it's not so simple to judge. Given that there are a
> lot of drivers that are lazy even if doing so is some effort (i.e. calling
> clk_prepare_enable() and devm_add_action()) convinces me, that introducing the
> function family is sensible. (And if you want to work on these drivers,
> grepping for devm_clk_get_enabled gives you a few candidates once the
> series is in :-)
FWIW,
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
for drivers/iio
Thanks for doing this!
> Otherwise looking at the diffstat of this series:
>
> 48 files changed, 257 insertions(+), 851 deletions(-)
>
> is quite convincing. Just the first two patches (which introduce the new
> functions) account for
>
> 2 files changed, 169 insertions(+), 17 deletions(-)
>
> . A rough third of the added lines is documentation. The rest is driver
> updates which then has:
>
> 46 files changed, 88 insertions(+), 834 deletions(-)
>
> which makes a really nice cleanup.
>
> The series is build-tested on arm64, m68k, powerpc, riscv, s390, sparc64
> and x86_64 using an allmodconfig.
>
> Best regards
> Uwe
>
> Uwe Kleine-König (16):
> clk: generalize devm_clk_get() a bit
> clk: Provide new devm_clk helpers for prepared and enabled clocks
> hwmon: Make use of devm_clk_get_enabled()
> iio: Make use of devm_clk_get_enabled()
> hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
> bus: bt1: Don't open code devm_clk_get_enabled()
> gpio: vf610: Simplify error handling in probe
> drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
> rtc: ingenic: Simplify using devm_clk_get_enabled()
> clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()
> watchdog: Make use of devm_clk_get_enabled()
> pwm: atmel: Simplify using devm_clk_get_prepared()
> rtc: at91sam9: Simplify using devm_clk_get_enabled()
> i2c: imx: Simplify using devm_clk_get_enabled()
> spi: davinci: Simplify using devm_clk_get_enabled()
> dmaengine: lgm: Fix error handling
>
> drivers/bus/bt1-apb.c | 23 +------
> drivers/bus/bt1-axi.c | 23 +------
> drivers/char/hw_random/meson-rng.c | 20 +-----
> drivers/clk/clk-devres.c | 96 ++++++++++++++++++++++-----
> drivers/clk/meson/axg-audio.c | 36 ++--------
> drivers/dma/lgm/lgm-dma.c | 8 +--
> drivers/gpio/gpio-vf610.c | 45 +++----------
> drivers/gpu/drm/meson/meson_dw_hdmi.c | 48 +++++---------
> drivers/hwmon/axi-fan-control.c | 15 +----
> drivers/hwmon/ltc2947-core.c | 17 +----
> drivers/hwmon/mr75203.c | 26 +-------
> drivers/hwmon/sparx5-temp.c | 19 +-----
> drivers/i2c/busses/i2c-imx.c | 12 +---
> 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 +----
> drivers/pwm/pwm-atmel.c | 16 +----
> drivers/rtc/rtc-at91sam9.c | 22 ++----
> drivers/rtc/rtc-jz4740.c | 21 +-----
> drivers/spi/spi-davinci.c | 11 +--
> 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 +----
> include/linux/clk.h | 90 ++++++++++++++++++++++++-
> 48 files changed, 257 insertions(+), 851 deletions(-)
>
>
> base-commit: 09688c0166e76ce2fb85e86b9d99be8b0084cdf9
> --
> 2.35.1
>
--
With Best Regards,
Andy Shevchenko
_______________________________________________
linux-amlogic mailing list
linux-amlogic@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-amlogic
^ permalink raw reply [flat|nested] 88+ messages in thread
* Re: [PATCH v8 00/16] clk: provide new devm helpers for prepared and enabled clocks
@ 2022-03-15 18:03 ` Andy Shevchenko
0 siblings, 0 replies; 88+ messages in thread
From: Andy Shevchenko @ 2022-03-15 18:03 UTC (permalink / raw)
To: Uwe Kleine-König
Cc: Alexandre Belloni, Neil Armstrong, David Airlie, Tomislav Denis,
André Gustavo Nakagomi Lopez, Nuno Sá,
Paul Cercueil, Thierry Reding, linux-i2c, Nobuhiro Iwamatsu,
Oleksij Rempel, Lee Jones, linux-clk, Jerome Brunet,
open list:REAL TIME CLOCK (RTC) SUBSYSTEM, Herbert Xu,
Alexandre Torgue, Kevin Hilman, Bartosz Golaszewski,
Russell King, linux-pwm, Claudiu Beznea, linux-iio, Andy Gross,
linux-arm Mailing List, open list:BROADCOM NVRAM DRIVER,
Keguang Zhang, Michael Turquette, Guenter Roeck, NXP Linux Team,
Maxime Coquelin, Bjorn Andersson, Jean Delvare, Michal Simek,
Sascha Hauer, Michael Hennerich, Martin Blumenstingl,
linux-arm-msm, linux-spi, Anand Ashok Dumbre, Vladimir Zapolskiy,
open list:GPIO SUBSYSTEM, Mark Brown, dri-devel, Matt Mackall,
linux-amlogic, Wim Van Sebroeck, Lars Povlsen, linux-hwmon,
Alessandro Zummo, linux-watchdog, Stephen Boyd,
Greg Kroah-Hartman, Patrice Chotard, linux-stm32, Nicolas Ferre,
Microchip Linux Driver Support, Vinod Koul, Cai Huoqing,
linux-crypto, dmaengine, Amireddy Mallikarjuna reddy, Shawn Guo,
Steen Hegelund, Jonathan Cameron
On Mon, Mar 14, 2022 at 5:14 PM Uwe Kleine-König
<u.kleine-koenig@pengutronix.de> wrote:
>
> Hello,
>
> this is another try to convince the relevant people that
> devm_clk_get_enabled() is a nice idea. Compared to v7 (back in May 2021) this
> series is rebased to v5.17-rc8 and converts quite some drivers that open code
> devm_clk_get_enabled() up to now (patches #3 - #11).
>
> A concern about devm_clk_get_enabled() in v7 was that it helps people to be
> lazy and I agree that in some situations when devm_clk_get_enabled() is used it
> would be more efficient and sensible to care to only enable the clk when really
> needed.
>
> On the other hand, the function is right for some users, e.g. the watchdog
> drivers. For the others it's not so simple to judge. Given that there are a
> lot of drivers that are lazy even if doing so is some effort (i.e. calling
> clk_prepare_enable() and devm_add_action()) convinces me, that introducing the
> function family is sensible. (And if you want to work on these drivers,
> grepping for devm_clk_get_enabled gives you a few candidates once the
> series is in :-)
FWIW,
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
for drivers/iio
Thanks for doing this!
> Otherwise looking at the diffstat of this series:
>
> 48 files changed, 257 insertions(+), 851 deletions(-)
>
> is quite convincing. Just the first two patches (which introduce the new
> functions) account for
>
> 2 files changed, 169 insertions(+), 17 deletions(-)
>
> . A rough third of the added lines is documentation. The rest is driver
> updates which then has:
>
> 46 files changed, 88 insertions(+), 834 deletions(-)
>
> which makes a really nice cleanup.
>
> The series is build-tested on arm64, m68k, powerpc, riscv, s390, sparc64
> and x86_64 using an allmodconfig.
>
> Best regards
> Uwe
>
> Uwe Kleine-König (16):
> clk: generalize devm_clk_get() a bit
> clk: Provide new devm_clk helpers for prepared and enabled clocks
> hwmon: Make use of devm_clk_get_enabled()
> iio: Make use of devm_clk_get_enabled()
> hwrng: meson - Don't open-code devm_clk_get_optional_enabled()
> bus: bt1: Don't open code devm_clk_get_enabled()
> gpio: vf610: Simplify error handling in probe
> drm/meson: dw-hdmi: Don't open code devm_clk_get_enabled()
> rtc: ingenic: Simplify using devm_clk_get_enabled()
> clk: meson: axg-audio: Don't duplicate devm_clk_get_enabled()
> watchdog: Make use of devm_clk_get_enabled()
> pwm: atmel: Simplify using devm_clk_get_prepared()
> rtc: at91sam9: Simplify using devm_clk_get_enabled()
> i2c: imx: Simplify using devm_clk_get_enabled()
> spi: davinci: Simplify using devm_clk_get_enabled()
> dmaengine: lgm: Fix error handling
>
> drivers/bus/bt1-apb.c | 23 +------
> drivers/bus/bt1-axi.c | 23 +------
> drivers/char/hw_random/meson-rng.c | 20 +-----
> drivers/clk/clk-devres.c | 96 ++++++++++++++++++++++-----
> drivers/clk/meson/axg-audio.c | 36 ++--------
> drivers/dma/lgm/lgm-dma.c | 8 +--
> drivers/gpio/gpio-vf610.c | 45 +++----------
> drivers/gpu/drm/meson/meson_dw_hdmi.c | 48 +++++---------
> drivers/hwmon/axi-fan-control.c | 15 +----
> drivers/hwmon/ltc2947-core.c | 17 +----
> drivers/hwmon/mr75203.c | 26 +-------
> drivers/hwmon/sparx5-temp.c | 19 +-----
> drivers/i2c/busses/i2c-imx.c | 12 +---
> 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 +----
> drivers/pwm/pwm-atmel.c | 16 +----
> drivers/rtc/rtc-at91sam9.c | 22 ++----
> drivers/rtc/rtc-jz4740.c | 21 +-----
> drivers/spi/spi-davinci.c | 11 +--
> 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 +----
> include/linux/clk.h | 90 ++++++++++++++++++++++++-
> 48 files changed, 257 insertions(+), 851 deletions(-)
>
>
> base-commit: 09688c0166e76ce2fb85e86b9d99be8b0084cdf9
> --
> 2.35.1
>
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 88+ messages in thread