* [PATCH v2 2/2] clk: Introduce 'critical-clocks' property
2022-03-16 12:30 [PATCH v2 1/2] dt-bindings: clk: Introduce 'critical-clocks' property Marek Vasut
@ 2022-03-16 12:30 ` Marek Vasut
0 siblings, 0 replies; 2+ messages in thread
From: Marek Vasut @ 2022-03-16 12:30 UTC (permalink / raw)
To: linux-clk
Cc: Marek Vasut, Michael Turquette, Rob Herring, Stephen Boyd,
devicetree
Some platforms require select clock to be always running, e.g. because
those clock supply vital devices which are not otherwise attached to
the system and thus do not have a matching DT node and clock consumer.
An example is a system where the SoC serves as a crystal oscillator
replacement for a programmable logic device. The "critical-clocks"
property of a clock controller allows listing clock which must never
be turned off.
Clock listed in the "critical-clocks" property may have other consumers
in DT, listing the clock in "critical-clocks" only assures those clock
are never turned off, and none of these optional additional consumers
can turn the clock off either. This is achieved by adding CLK_IS_CRITICAL
flag to these critical clock.
This flag has thus far been added to select clock by hard-coding it in
various clock drivers, this patch provides generic DT interface to add
the flag to arbitrary clock that may be critical.
The implementation is modeled after "protected-clocks", except the protected
clock property is currently driver specific. This patch attempts to provide
a generic implementation of "critical-clocks" instead.
Unlike "assigned-clocks", the "critical-clocks" must be parsed much earlier
in __clk_register() to assign CLK_IS_CRITICAL flag to clk_init_data .flags
field.
The new match_clkspec() callback is used to determine whether struct clk_hw
that is currently being registered matches the clock specifier in the DT
"critical-clocks" property, and if so, then the CLK_IS_CRITICAL is added to
these newly registered clock. This callback can only be driver specific.
Signed-off-by: Marek Vasut <marex@denx.de>
Cc: Michael Turquette <mturquette@baylibre.com>
Cc: Rob Herring <robh+dt@kernel.org>
Cc: Stephen Boyd <sboyd@kernel.org>
Cc: devicetree@vger.kernel.org
To: linux-clk@vger.kernel.org
---
V2: - Warn in case critical-clock field cannot be parsed and skip those clock
- Use match_clkspec() only for non-zero clock-cells controllers
- Pull the critical-clock code into __clk_register_critical_clock()
- Update commit message
---
drivers/clk/clk.c | 44 ++++++++++++++++++++++++++++++++++++
include/linux/clk-provider.h | 3 +++
2 files changed, 47 insertions(+)
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 6dc768a9674f4..8831c8f9e47c4 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -3896,6 +3896,48 @@ static void clk_core_free_parent_map(struct clk_core *core)
kfree(core->parents);
}
+static void
+__clk_register_critical_clock(struct device_node *np, struct clk_core *core,
+ struct clk_hw *hw)
+{
+ struct of_phandle_args clkspec;
+ u32 clksize, clktotal;
+ int ret, i, index;
+
+ if (!np)
+ return;
+
+ if (of_property_read_u32(np, "#clock-cells", &clksize))
+ return;
+
+ /* Clock node with #clock-cells = <0> uses critical-clocks; */
+ if (clksize == 0) {
+ if (of_property_read_bool(np, "critical-clocks"))
+ core->flags |= CLK_IS_CRITICAL;
+ return;
+ }
+
+ if (!core->ops->match_clkspec)
+ return;
+
+ clkspec.np = np;
+ clktotal = of_property_count_u32_elems(np, "critical-clocks");
+ clktotal /= clksize;
+ for (index = 0; index < clktotal; index++) {
+ for (i = 0; i < clksize; i++) {
+ ret = of_property_read_u32_index(np, "critical-clocks",
+ (index * clksize) + i,
+ &(clkspec.args[i]));
+ if (ret) {
+ pr_warn("Skipping critical-clocks index %d (ret=%d)\n",
+ i, ret);
+ }
+ }
+ if (!core->ops->match_clkspec(hw, &clkspec))
+ core->flags |= CLK_IS_CRITICAL;
+ }
+}
+
static struct clk *
__clk_register(struct device *dev, struct device_node *np, struct clk_hw *hw)
{
@@ -3940,6 +3982,8 @@ __clk_register(struct device *dev, struct device_node *np, struct clk_hw *hw)
core->min_rate = 0;
core->max_rate = ULONG_MAX;
+ __clk_register_critical_clock(np, core, hw);
+
ret = clk_core_populate_parent_map(core, init);
if (ret)
goto fail_parents;
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index 48d67574d4030..ad205d065c606 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -205,6 +205,8 @@ struct clk_duty {
* directory is provided as an argument. Called with
* prepare_lock held. Returns 0 on success, -EERROR otherwise.
*
+ * @match_clkspec: Check whether clk_hw matches DT clock specifier.
+ * Returns 0 on success, -EERROR otherwise.
*
* The clk_enable/clk_disable and clk_prepare/clk_unprepare pairs allow
* implementations to split any work between atomic (enable) and sleepable
@@ -252,6 +254,7 @@ struct clk_ops {
int (*init)(struct clk_hw *hw);
void (*terminate)(struct clk_hw *hw);
void (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
+ int (*match_clkspec)(struct clk_hw *hw, struct of_phandle_args *clkspec);
};
/**
--
2.35.1
^ permalink raw reply related [flat|nested] 2+ messages in thread