* [PATCH v10 0/2] A proposal to add a gpio-enabled clock driver.
@ 2026-11-21 13:16 Vyacheslav Yurkov via B4 Relay
2026-11-21 13:16 ` [PATCH v10 1/2] dt-bindings: clock: Add gpio-enabled-clock Vyacheslav Yurkov via B4 Relay
2026-11-21 13:16 ` [PATCH v10 2/2] clk: gpio: Add driver for GPIO-signalled clocks Vyacheslav Yurkov via B4 Relay
0 siblings, 2 replies; 5+ messages in thread
From: Vyacheslav Yurkov via B4 Relay @ 2026-11-21 13:16 UTC (permalink / raw)
To: Michael Turquette, Stephen Boyd, Rob Herring, Krzysztof Kozlowski,
Conor Dooley, Brian Masney, Brian Masney, Jerome Brunet,
Jyri Sarha
Cc: linux-kernel, linux-clk, devicetree, Vyacheslav Yurkov,
Vyacheslav Yurkov
A gpio-enabled clock represents an input clock, which state is determined
by a GPIO signal. It's similar to a gated-fixed-clock, but GPIO direction
is inverted. Consumers can use the output clock to wait until the clock
is ready and only then initialize / access dependent peripherals.
The usage example for such a driver is when peripherals depend on PLLs in
a FPGA, which can't be directly accessed by the CPU, but need a GPIO pin
to check whether clock is actually usable. E.g. some of the IPs might not
have a proper split between registers and IP core, which means that if an
external clock and/or PLL lock is missing and one tries to access the
registers, the response never comes, thus the CPU stalls.
Signed-off-by: Vyacheslav Yurkov <uvv.mail@gmail.com>
Signed-off-by: Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com>
---
Changes in v10:
- Use only sleep capable ops
- Make commit messages more generic
- Improve error handling for clock_prepare
- Link to v9: https://lore.kernel.org/r/20261015-feature-clock-guard-v9-0-c1c05a498d9a@bruker.com
Changes in v9:
- Changed wordking from "locked" to "enabled" to be more generic
- Use a separate DT schema file similar to other clock drivers
- Add a timeout for polling in enable()/prepare()
- Depending on whether GPIO can sleep or not use prepare() or enable()
set of ops respectively.
- Decouple the implementation from exisiting drivers
- Link to v8: https://lore.kernel.org/r/20260927-feature-clock-guard-v8-0-630938e302a1@bruker.com
Changes in v8:
- Fix return value of clk_gpio_locked_prepare()
- Link to v7: https://lore.kernel.org/r/20260927-feature-clock-guard-v7-0-8dd19568d9a2@bruker.com
Changes in v7:
- Fix compatibility strings and schema errors.
- Update GPIO pin name
- Link to v6: https://lore.kernel.org/r/20260927-feature-clock-guard-v6-0-007983b13ec2@bruker.com
Changes in v6:
- Debug messages dropped.
- The new driver is now an extension of exising clk-gpio drivers.
- The controller doesn't enable the parent clock, the consumer is
supposed to do that instead.
- Link to v5: https://lore.kernel.org/r/20260915-feature-clock-guard-v5-0-42ab5dc3a6aa@bruker.com
Changes in v5:
- Use existing DT binding with an additional property instead of adding
a new one
- The driver is simplified in a way that it represents the actual HW
desgin without additional unrelated constructs
- Aggregation is removed, now it's one clock input, one clock output
- Link to v4: https://lore.kernel.org/r/20260726-feature-clock-guard-v4-0-e9c8b372b71c@bruker.com
Changes in v4:
- Removed driver specifics from DT binding
- Link to v3: https://lore.kernel.org/r/20260603-feature-clock-guard-v3-0-01cca0aa04a5@bruker.com
Changes in v3:
- Removed unnecessary dt bindings
- Improved HW description and commit messages
- Link to v2: https://lore.kernel.org/r/20260510-feature-clock-guard-v2-0-6c25458d5340@bruker.com
Changes in v2:
- Renamed to clk-gpio-locked to express intent.
- Provide enable() / is_enabled() operations so the clock behaves as
expected
- Fixed DTS errors / warnings
- Link to v1: https://lore.kernel.org/r/20260318-feature-clock-guard-v1-0-6137cb4084b7@bruker.com
---
Vyacheslav Yurkov (2):
dt-bindings: clock: Add gpio-enabled-clock
clk: gpio: Add driver for GPIO-signalled clocks
.../bindings/clock/gpio-enabled-clock.yaml | 55 +++++++++++
drivers/clk/clk-gpio.c | 107 +++++++++++++++++++++
2 files changed, 162 insertions(+)
---
base-commit: 65e4fd942f72a9dba0e4e257290c4fa1aa756854
change-id: 20260318-feature-clock-guard-f20a2c35b965
Best regards,
--
Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com>
^ permalink raw reply [flat|nested] 5+ messages in thread* [PATCH v10 1/2] dt-bindings: clock: Add gpio-enabled-clock 2026-11-21 13:16 [PATCH v10 0/2] A proposal to add a gpio-enabled clock driver Vyacheslav Yurkov via B4 Relay @ 2026-11-21 13:16 ` Vyacheslav Yurkov via B4 Relay 2026-11-21 13:24 ` sashiko-bot 2026-11-21 13:16 ` [PATCH v10 2/2] clk: gpio: Add driver for GPIO-signalled clocks Vyacheslav Yurkov via B4 Relay 1 sibling, 1 reply; 5+ messages in thread From: Vyacheslav Yurkov via B4 Relay @ 2026-11-21 13:16 UTC (permalink / raw) To: Michael Turquette, Stephen Boyd, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Brian Masney, Brian Masney, Jerome Brunet, Jyri Sarha Cc: linux-kernel, linux-clk, devicetree, Vyacheslav Yurkov, Vyacheslav Yurkov From: Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com> Some clocks are switched on and off by hardware outside software control, which reports through a GPIO whether the clock is currently running. Software cannot enable such a clock, but its consumers must not use it before the GPIO indicates that it is running. Add a binding for a clock that passes its parent clock through unchanged and is considered enabled only while a GPIO signal is asserted. The parent clock determines the rate. The status GPIO is given by enabled-gpios, and poll-timeout-us bounds how long a consumer waits for the clock to become available. Signed-off-by: Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com> --- Our use case: peripheral clocks generated by FPGA PLLs, with the PLL-lock signals routed to GPIOs of the SoC. --- .../bindings/clock/gpio-enabled-clock.yaml | 55 ++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/Documentation/devicetree/bindings/clock/gpio-enabled-clock.yaml b/Documentation/devicetree/bindings/clock/gpio-enabled-clock.yaml new file mode 100644 index 000000000000..76c1425931d2 --- /dev/null +++ b/Documentation/devicetree/bindings/clock/gpio-enabled-clock.yaml @@ -0,0 +1,55 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/clock/gpio-enabled-clock.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: GPIO Enabled Clock + +maintainers: + - Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com> + +properties: + compatible: + const: gpio-enabled-clock + + clocks: + maxItems: 1 + + "#clock-cells": + const: 0 + + clock-output-names: + maxItems: 1 + + enabled-gpios: + description: GPIO that indicates whether the clock is enabled or disabled. + maxItems: 1 + + poll-timeout-us: + description: Timeout in microseconds for waiting for a GPIO signal. + default: 10 + minimum: 10 + maximum: 1000 + +required: + - compatible + - clocks + - "#clock-cells" + - enabled-gpios + - clock-output-names + +additionalProperties: false + +examples: + - | + #include <dt-bindings/gpio/gpio.h> + + clock { + compatible = "gpio-enabled-clock"; + #clock-cells = <0>; + clocks = <&pll>; + clock-output-names = "gpio-enabled-clock"; + enabled-gpios = <&gpio0 4 GPIO_ACTIVE_HIGH>; + poll-timeout-us = <20>; + }; -- 2.34.1 ^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH v10 1/2] dt-bindings: clock: Add gpio-enabled-clock 2026-11-21 13:16 ` [PATCH v10 1/2] dt-bindings: clock: Add gpio-enabled-clock Vyacheslav Yurkov via B4 Relay @ 2026-11-21 13:24 ` sashiko-bot 0 siblings, 0 replies; 5+ messages in thread From: sashiko-bot @ 2026-11-21 13:24 UTC (permalink / raw) To: Vyacheslav Yurkov; +Cc: linux-clk, devicetree, robh, conor+dt Thank you for your contribution! Sashiko AI review found 3 potential issues to consider: - [Medium] dt-bindings: clock: poll-timeout-us encodes software policy and bounds - [Low] dt-bindings: clock: clock-output-names required for single-output clock - [Low] dt-bindings: clock: inconsistent property order in gpio-enabled-clock -- commit af456b3694509e900f2e04e650b48e34c1d34c06 Author: Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com> dt-bindings: clock: Add gpio-enabled-clock This commit adds a Device Tree binding schema for a clock that passes its parent clock rate through and reports its enabled state via a GPIO line. > diff --git a/Documentation/devicetree/bindings/clock/gpio-enabled-clock.yaml b/Documentation/devicetree/bindings/clock/gpio-enabled-clock.yaml > new file mode 100644 > index 0000000000000..76c1425931d28 > --- /dev/null > +++ b/Documentation/devicetree/bindings/clock/gpio-enabled-clock.yaml > @@ -0,0 +1,55 @@ > +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) > +%YAML 1.2 > +--- > +$id: http://devicetree.org/schemas/clock/gpio-enabled-clock.yaml# > +$schema: http://devicetree.org/meta-schemas/core.yaml# > + > +title: GPIO Enabled Clock > + > +maintainers: > + - Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com> > + > +properties: > + compatible: > + const: gpio-enabled-clock > + > + clocks: > + maxItems: 1 > + > + "#clock-cells": > + const: 0 > + > + clock-output-names: > + maxItems: 1 > + > + enabled-gpios: > + description: GPIO that indicates whether the clock is enabled or disabled. > + maxItems: 1 > + > + poll-timeout-us: > + description: Timeout in microseconds for waiting for a GPIO signal. > + default: 10 > + minimum: 10 > + maximum: 1000 [Severity: Medium] Does poll-timeout-us encode OS driver polling policy rather than a hardware property? How long a consumer polls a GPIO (as opposed to waiting on a GPIO interrupt or describing a hardware lock or startup time) is software policy, and bounding it to 10..1000 us rejects hardware clocks and PLLs whose stabilization time falls outside that window. Also, should the status GPIO be described directly on the clock provider node rather than requiring a parent clocks property on a separate pass-through wrapper node? Modelling this as a wrapper forces a single hardware clock source with a lock GPIO to be split across two Device Tree nodes. > + > +required: > + - compatible > + - clocks > + - "#clock-cells" > + - enabled-gpios > + - clock-output-names [Severity: Low] Should clock-output-names be optional here? Because #clock-cells is 0, consumers reference this single-output clock provider directly by phandle and the clock name can fall back to the Device Tree node name, matching other single-output clock bindings such as fixed-clock.yaml and gpio-gate-clock.yaml. > + > +additionalProperties: false > + > +examples: > + - | > + #include <dt-bindings/gpio/gpio.h> > + > + clock { > + compatible = "gpio-enabled-clock"; > + #clock-cells = <0>; > + clocks = <&pll>; > + clock-output-names = "gpio-enabled-clock"; > + enabled-gpios = <&gpio0 4 GPIO_ACTIVE_HIGH>; > + poll-timeout-us = <20>; > + }; [Severity: Low] This isn't a bug, but the property order differs across properties, required, and examples: required lists enabled-gpios before clock-output-names, while the example lists #clock-cells before clocks. -- Sashiko AI review · https://sashiko.dev/#/patchset/20261121-feature-clock-guard-v10-0-5d449739bb8c@bruker.com?part=1 ^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v10 2/2] clk: gpio: Add driver for GPIO-signalled clocks 2026-11-21 13:16 [PATCH v10 0/2] A proposal to add a gpio-enabled clock driver Vyacheslav Yurkov via B4 Relay 2026-11-21 13:16 ` [PATCH v10 1/2] dt-bindings: clock: Add gpio-enabled-clock Vyacheslav Yurkov via B4 Relay @ 2026-11-21 13:16 ` Vyacheslav Yurkov via B4 Relay 2026-11-21 13:21 ` sashiko-bot 1 sibling, 1 reply; 5+ messages in thread From: Vyacheslav Yurkov via B4 Relay @ 2026-11-21 13:16 UTC (permalink / raw) To: Michael Turquette, Stephen Boyd, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Brian Masney, Brian Masney, Jerome Brunet, Jyri Sarha Cc: linux-kernel, linux-clk, devicetree, Vyacheslav Yurkov, Vyacheslav Yurkov From: Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com> Some clocks are not under CPU control: they are generated and enabled by external hardware, which only reports through a GPIO whether the clock is running. There is currently no way to describe such a clock, so consumers either initialize too early or rely on ad-hoc delays. Add a "gpio-enabled-clock" provider for this case. Its prepare callback polls the GPIO until it is asserted or a timeout expires, so a consumer's clk_prepare_enable() succeeds only once the clock is actually running, and fails otherwise. is_prepared reports the current state of the GPIO. Signed-off-by: Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com> --- Our use case: peripheral clocks generated by FPGA PLLs, with the PLL-lock signals routed to GPIOs of the SoC. --- drivers/clk/clk-gpio.c | 107 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 107 insertions(+) diff --git a/drivers/clk/clk-gpio.c b/drivers/clk/clk-gpio.c index df0856a39c8d..33f251b209a0 100644 --- a/drivers/clk/clk-gpio.c +++ b/drivers/clk/clk-gpio.c @@ -15,6 +15,7 @@ #include <linux/gpio/consumer.h> #include <linux/err.h> #include <linux/device.h> +#include <linux/iopoll.h> #include <linux/of.h> #include <linux/platform_device.h> #include <linux/regulator/consumer.h> @@ -241,6 +242,112 @@ static struct platform_driver gpio_clk_driver = { }; builtin_platform_driver(gpio_clk_driver); +/** + * struct clk_gpio_enabled - gpio enabled clock + * + * @hw: handle between common and hardware-specific interfaces + * @gpiod: gpio descriptor + * @timeout_us: timeout that is used to get a GPIO value + * + * Clock whose status is determined by a GPIO signal. + * + * Implements .prepare and .is_prepared + */ +struct clk_gpio_enabled { + struct clk_hw hw; + struct gpio_desc *gpiod; + u32 timeout_us; +}; + +#define to_clk_gpio_enabled(_hw) container_of(_hw, struct clk_gpio_enabled, hw) +#define GPIO_ENABLED_TIMEOUT_MIN 10 +#define GPIO_ENABLED_TIMEOUT_MAX 1000 +#define GPIO_ENABLED_TIMEOUT_DEFAULT 10 + +static int clk_gpio_enabled_is_prepared(struct clk_hw *hw) +{ + struct clk_gpio_enabled *clk = to_clk_gpio_enabled(hw); + + return gpiod_get_value_cansleep(clk->gpiod) > 0; +} + +/* The clock cannot be turned on, only waited for. */ +static int clk_gpio_enabled_prepare(struct clk_hw *hw) +{ + struct clk_gpio_enabled *clk = to_clk_gpio_enabled(hw); + int value, ret; + + ret = readx_poll_timeout(gpiod_get_value_cansleep, clk->gpiod, value, + value != 0, 10, clk->timeout_us); + if (ret) + return ret; + + return value < 0 ? value : 0; +} + +static const struct clk_ops clk_gpio_enabled_ops = { + .prepare = clk_gpio_enabled_prepare, + .is_prepared = clk_gpio_enabled_is_prepared, +}; + +static int gpio_enabled_clk_driver_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct clk_gpio_enabled *clk; + const char *clk_name; + const struct clk_parent_data gpio_parent_data[] = { + { .index = 0 }, + }; + u32 timeout_us = GPIO_ENABLED_TIMEOUT_DEFAULT; + int ret; + + clk = devm_kzalloc(dev, sizeof(*clk), GFP_KERNEL); + if (!clk) + return -ENOMEM; + + clk->gpiod = devm_gpiod_get(dev, "enabled", GPIOD_IN); + if (IS_ERR(clk->gpiod)) + return dev_err_probe(dev, PTR_ERR(clk->gpiod), + "Can't get enabled GPIO property\n"); + + ret = device_property_read_string(dev, "clock-output-names", &clk_name); + if (ret) + return dev_err_probe(dev, ret, "missing clock-output-names\n"); + + device_property_read_u32(dev, "poll-timeout-us", &timeout_us); + if (timeout_us < GPIO_ENABLED_TIMEOUT_MIN || + timeout_us > GPIO_ENABLED_TIMEOUT_MAX) + return dev_err_probe(dev, -EINVAL, + "poll-timeout-us is out of range [%u, %u]\n", + GPIO_ENABLED_TIMEOUT_MIN, + GPIO_ENABLED_TIMEOUT_MAX); + clk->timeout_us = timeout_us; + + clk->hw.init = CLK_HW_INIT_PARENTS_DATA(clk_name, gpio_parent_data, + clk_gpio_enabled_ops, CLK_SET_RATE_PARENT); + + ret = devm_clk_hw_register(dev, &clk->hw); + if (ret) + return dev_err_probe(dev, ret, + "Failed to register clock\n"); + + return devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get, &clk->hw); +} + +static const struct of_device_id gpio_enabled_clk_match_table[] = { + { .compatible = "gpio-enabled-clock" }, + { } +}; + +static struct platform_driver gpio_enabled_clk_driver = { + .probe = gpio_enabled_clk_driver_probe, + .driver = { + .name = "gpio-enabled-clk", + .of_match_table = gpio_enabled_clk_match_table, + }, +}; +builtin_platform_driver(gpio_enabled_clk_driver); + /** * DOC: gated fixed clock, controlled with a gpio output and a regulator * Traits of this clock: -- 2.34.1 ^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH v10 2/2] clk: gpio: Add driver for GPIO-signalled clocks 2026-11-21 13:16 ` [PATCH v10 2/2] clk: gpio: Add driver for GPIO-signalled clocks Vyacheslav Yurkov via B4 Relay @ 2026-11-21 13:21 ` sashiko-bot 0 siblings, 0 replies; 5+ messages in thread From: sashiko-bot @ 2026-11-21 13:21 UTC (permalink / raw) To: Vyacheslav Yurkov; +Cc: linux-clk, devicetree, robh, conor+dt Thank you for your contribution! Sashiko AI review found 1 potential issue to consider: - [High] clk: gpio: pass pointer to clk_gpio_enabled_ops in CLK_HW_INIT_PARENTS_DATA() -- commit 89b7f5ec0fd3e779dce65c804661263ec21d8ca2 Author: Vyacheslav Yurkov <V.Yurkov.EXT@bruker.com> clk: gpio: Add driver for GPIO-signalled clocks This commit adds a "gpio-enabled-clock" driver for clocks controlled by external hardware whose running status is reported through a GPIO line. > diff --git a/drivers/clk/clk-gpio.c b/drivers/clk/clk-gpio.c > index df0856a39c8d2..33f251b209a01 100644 > --- a/drivers/clk/clk-gpio.c > +++ b/drivers/clk/clk-gpio.c [ ... ] > @@ -241,6 +242,112 @@ static struct platform_driver gpio_clk_driver = { > }; > builtin_platform_driver(gpio_clk_driver); > [ ... ] > +static const struct clk_ops clk_gpio_enabled_ops = { > + .prepare = clk_gpio_enabled_prepare, > + .is_prepared = clk_gpio_enabled_is_prepared, > +}; > + > +static int gpio_enabled_clk_driver_probe(struct platform_device *pdev) > +{ [ ... ] > + clk->hw.init = CLK_HW_INIT_PARENTS_DATA(clk_name, gpio_parent_data, > + clk_gpio_enabled_ops, CLK_SET_RATE_PARENT); [Severity: High] Should this pass &clk_gpio_enabled_ops instead of clk_gpio_enabled_ops? CLK_HW_INIT_PARENTS_DATA() initializes struct clk_init_data.ops (const struct clk_ops *), so passing the struct by value fails to compile. -- Sashiko AI review · https://sashiko.dev/#/patchset/20261121-feature-clock-guard-v10-0-5d449739bb8c@bruker.com?part=2 ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2026-11-21 13:24 UTC | newest] Thread overview: 5+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2026-11-21 13:16 [PATCH v10 0/2] A proposal to add a gpio-enabled clock driver Vyacheslav Yurkov via B4 Relay 2026-11-21 13:16 ` [PATCH v10 1/2] dt-bindings: clock: Add gpio-enabled-clock Vyacheslav Yurkov via B4 Relay 2026-11-21 13:24 ` sashiko-bot 2026-11-21 13:16 ` [PATCH v10 2/2] clk: gpio: Add driver for GPIO-signalled clocks Vyacheslav Yurkov via B4 Relay 2026-11-21 13:21 ` sashiko-bot
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox