335 lines
10 KiB
Diff
335 lines
10 KiB
Diff
From 36595ef49aac284d386e1f9e8ac0910451ef40d6 Mon Sep 17 00:00:00 2001
|
|
From: Maxime Ripard <maxime@cerno.tech>
|
|
Date: Fri, 1 Apr 2022 15:26:46 +0200
|
|
Subject: [PATCH] clk: Set req_rate on reparenting
|
|
|
|
If a non-rate clock started by default with a parent that never
|
|
registered, core->req_rate will be 0. The expectation is that whenever
|
|
the parent will be registered, req_rate will be updated with the new
|
|
value that has just been computed.
|
|
|
|
However, if that clock is a mux, clk_set_parent() can also make that
|
|
clock no longer orphan. In this case however, we never update req_rate.
|
|
Let's make sure it's the case for the newly unorphan clock and all its
|
|
children.
|
|
|
|
Tested-by: Alexander Stein <alexander.stein@ew.tq-group.com> # imx8mp
|
|
Tested-by: Marek Szyprowski <m.szyprowski@samsung.com> # exynos4210, meson g12b
|
|
Signed-off-by: Maxime Ripard <maxime@cerno.tech>
|
|
---
|
|
drivers/clk/clk.c | 18 ++++
|
|
drivers/clk/clk_test.c | 231 +++++++++++++++++++++++++++++++++++++++++
|
|
2 files changed, 249 insertions(+)
|
|
|
|
--- a/drivers/clk/clk.c
|
|
+++ b/drivers/clk/clk.c
|
|
@@ -1757,6 +1757,23 @@ static void clk_core_update_orphan_statu
|
|
clk_core_update_orphan_status(child, is_orphan);
|
|
}
|
|
|
|
+/*
|
|
+ * Update the orphan rate and req_rate of @core and all its children.
|
|
+ */
|
|
+static void clk_core_update_orphan_child_rates(struct clk_core *core)
|
|
+{
|
|
+ struct clk_core *child;
|
|
+ unsigned long parent_rate = 0;
|
|
+
|
|
+ if (core->parent)
|
|
+ parent_rate = core->parent->rate;
|
|
+
|
|
+ core->rate = core->req_rate = clk_recalc(core, parent_rate);
|
|
+
|
|
+ hlist_for_each_entry(child, &core->children, child_node)
|
|
+ clk_core_update_orphan_child_rates(child);
|
|
+}
|
|
+
|
|
static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)
|
|
{
|
|
bool was_orphan = core->orphan;
|
|
@@ -1781,6 +1798,7 @@ static void clk_reparent(struct clk_core
|
|
}
|
|
|
|
core->parent = new_parent;
|
|
+ clk_core_update_orphan_child_rates(core);
|
|
}
|
|
|
|
static struct clk_core *__clk_set_parent_before(struct clk_core *core,
|
|
--- a/drivers/clk/clk_test.c
|
|
+++ b/drivers/clk/clk_test.c
|
|
@@ -577,6 +577,39 @@ clk_test_orphan_transparent_multiple_par
|
|
|
|
/*
|
|
* Test that, for a mux that started orphan but got switched to a valid
|
|
+ * parent, calling clk_drop_range() on the mux won't affect the parent
|
|
+ * rate.
|
|
+ */
|
|
+static void
|
|
+clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range(struct kunit *test)
|
|
+{
|
|
+ struct clk_multiple_parent_ctx *ctx = test->priv;
|
|
+ struct clk_hw *hw = &ctx->hw;
|
|
+ struct clk *clk = hw->clk, *parent;
|
|
+ unsigned long parent_rate, new_parent_rate;
|
|
+ int ret;
|
|
+
|
|
+ parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
|
|
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
|
|
+
|
|
+ parent_rate = clk_get_rate(parent);
|
|
+ KUNIT_ASSERT_GT(test, parent_rate, 0);
|
|
+
|
|
+ ret = clk_set_parent(clk, parent);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ ret = clk_drop_range(clk);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ new_parent_rate = clk_get_rate(clk);
|
|
+ KUNIT_ASSERT_GT(test, new_parent_rate, 0);
|
|
+ KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
|
|
+
|
|
+ clk_put(parent);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Test that, for a mux that started orphan but got switched to a valid
|
|
* parent, the rate of the mux and its new parent are consistent.
|
|
*/
|
|
static void
|
|
@@ -605,6 +638,39 @@ clk_test_orphan_transparent_multiple_par
|
|
|
|
/*
|
|
* Test that, for a mux that started orphan but got switched to a valid
|
|
+ * parent, calling clk_put() on the mux won't affect the parent rate.
|
|
+ */
|
|
+static void
|
|
+clk_test_orphan_transparent_multiple_parent_mux_set_parent_put(struct kunit *test)
|
|
+{
|
|
+ struct clk_multiple_parent_ctx *ctx = test->priv;
|
|
+ struct clk *clk, *parent;
|
|
+ unsigned long parent_rate, new_parent_rate;
|
|
+ int ret;
|
|
+
|
|
+ parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
|
|
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
|
|
+
|
|
+ clk = clk_hw_get_clk(&ctx->hw, NULL);
|
|
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk);
|
|
+
|
|
+ parent_rate = clk_get_rate(parent);
|
|
+ KUNIT_ASSERT_GT(test, parent_rate, 0);
|
|
+
|
|
+ ret = clk_set_parent(clk, parent);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ clk_put(clk);
|
|
+
|
|
+ new_parent_rate = clk_get_rate(parent);
|
|
+ KUNIT_ASSERT_GT(test, new_parent_rate, 0);
|
|
+ KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
|
|
+
|
|
+ clk_put(parent);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Test that, for a mux that started orphan but got switched to a valid
|
|
* parent, calling clk_set_rate_range() will affect the parent state if
|
|
* its rate is out of range.
|
|
*/
|
|
@@ -635,6 +701,41 @@ clk_test_orphan_transparent_multiple_par
|
|
}
|
|
|
|
/*
|
|
+ * Test that, for a mux that started orphan but got switched to a valid
|
|
+ * parent, calling clk_set_rate_range() won't affect the parent state if
|
|
+ * its rate is within range.
|
|
+ */
|
|
+static void
|
|
+clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched(struct kunit *test)
|
|
+{
|
|
+ struct clk_multiple_parent_ctx *ctx = test->priv;
|
|
+ struct clk_hw *hw = &ctx->hw;
|
|
+ struct clk *clk = hw->clk, *parent;
|
|
+ unsigned long parent_rate, new_parent_rate;
|
|
+ int ret;
|
|
+
|
|
+ parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
|
|
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
|
|
+
|
|
+ parent_rate = clk_get_rate(parent);
|
|
+ KUNIT_ASSERT_GT(test, parent_rate, 0);
|
|
+
|
|
+ ret = clk_set_parent(clk, parent);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ ret = clk_set_rate_range(clk,
|
|
+ DUMMY_CLOCK_INIT_RATE - 1000,
|
|
+ DUMMY_CLOCK_INIT_RATE + 1000);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ new_parent_rate = clk_get_rate(parent);
|
|
+ KUNIT_ASSERT_GT(test, new_parent_rate, 0);
|
|
+ KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
|
|
+
|
|
+ clk_put(parent);
|
|
+}
|
|
+
|
|
+/*
|
|
* Test that, for a mux whose current parent hasn't been registered yet,
|
|
* calling clk_set_rate_range() will succeed, and will be taken into
|
|
* account when rounding a rate.
|
|
@@ -660,8 +761,11 @@ clk_test_orphan_transparent_multiple_par
|
|
static struct kunit_case clk_orphan_transparent_multiple_parent_mux_test_cases[] = {
|
|
KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_get_parent),
|
|
KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent),
|
|
+ KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range),
|
|
KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate),
|
|
+ KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_put),
|
|
KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified),
|
|
+ KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched),
|
|
KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate),
|
|
{}
|
|
};
|
|
@@ -946,6 +1050,132 @@ static struct kunit_suite clk_orphan_tra
|
|
.test_cases = clk_orphan_transparent_single_parent_mux_test_cases,
|
|
};
|
|
|
|
+struct clk_single_parent_two_lvl_ctx {
|
|
+ struct clk_dummy_context parent_parent_ctx;
|
|
+ struct clk_dummy_context parent_ctx;
|
|
+ struct clk_hw hw;
|
|
+};
|
|
+
|
|
+static int
|
|
+clk_orphan_two_level_root_last_test_init(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_two_lvl_ctx *ctx;
|
|
+ int ret;
|
|
+
|
|
+ ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
|
|
+ if (!ctx)
|
|
+ return -ENOMEM;
|
|
+ test->priv = ctx;
|
|
+
|
|
+ ctx->parent_ctx.hw.init =
|
|
+ CLK_HW_INIT("intermediate-parent",
|
|
+ "root-parent",
|
|
+ &clk_dummy_single_parent_ops,
|
|
+ CLK_SET_RATE_PARENT);
|
|
+ ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
|
|
+ if (ret)
|
|
+ return ret;
|
|
+
|
|
+ ctx->hw.init =
|
|
+ CLK_HW_INIT("test-clk", "intermediate-parent",
|
|
+ &clk_dummy_single_parent_ops,
|
|
+ CLK_SET_RATE_PARENT);
|
|
+ ret = clk_hw_register(NULL, &ctx->hw);
|
|
+ if (ret)
|
|
+ return ret;
|
|
+
|
|
+ ctx->parent_parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
|
|
+ ctx->parent_parent_ctx.hw.init =
|
|
+ CLK_HW_INIT_NO_PARENT("root-parent",
|
|
+ &clk_dummy_rate_ops,
|
|
+ 0);
|
|
+ ret = clk_hw_register(NULL, &ctx->parent_parent_ctx.hw);
|
|
+ if (ret)
|
|
+ return ret;
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static void
|
|
+clk_orphan_two_level_root_last_test_exit(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
|
|
+
|
|
+ clk_hw_unregister(&ctx->hw);
|
|
+ clk_hw_unregister(&ctx->parent_ctx.hw);
|
|
+ clk_hw_unregister(&ctx->parent_parent_ctx.hw);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Test that, for a clock whose parent used to be orphan, clk_get_rate()
|
|
+ * will return the proper rate.
|
|
+ */
|
|
+static void
|
|
+clk_orphan_two_level_root_last_test_get_rate(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
|
|
+ struct clk_hw *hw = &ctx->hw;
|
|
+ struct clk *clk = hw->clk;
|
|
+ unsigned long rate;
|
|
+
|
|
+ rate = clk_get_rate(clk);
|
|
+ KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Test that, for a clock whose parent used to be orphan,
|
|
+ * clk_set_rate_range() won't affect its rate if it is already within
|
|
+ * range.
|
|
+ *
|
|
+ * See (for Exynos 4210):
|
|
+ * https://lore.kernel.org/linux-clk/366a0232-bb4a-c357-6aa8-636e398e05eb@samsung.com/
|
|
+ */
|
|
+static void
|
|
+clk_orphan_two_level_root_last_test_set_range(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
|
|
+ struct clk_hw *hw = &ctx->hw;
|
|
+ struct clk *clk = hw->clk;
|
|
+ unsigned long rate;
|
|
+ int ret;
|
|
+
|
|
+ ret = clk_set_rate_range(clk,
|
|
+ DUMMY_CLOCK_INIT_RATE - 1000,
|
|
+ DUMMY_CLOCK_INIT_RATE + 1000);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ rate = clk_get_rate(clk);
|
|
+ KUNIT_ASSERT_GT(test, rate, 0);
|
|
+ KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
|
|
+}
|
|
+
|
|
+static struct kunit_case
|
|
+clk_orphan_two_level_root_last_test_cases[] = {
|
|
+ KUNIT_CASE(clk_orphan_two_level_root_last_test_get_rate),
|
|
+ KUNIT_CASE(clk_orphan_two_level_root_last_test_set_range),
|
|
+ {}
|
|
+};
|
|
+
|
|
+/*
|
|
+ * Test suite for a basic, transparent, clock with a parent that is also
|
|
+ * such a clock. The parent's parent is registered last, while the
|
|
+ * parent and its child are registered in that order. The intermediate
|
|
+ * and leaf clocks will thus be orphan when registered, but the leaf
|
|
+ * clock itself will always have its parent and will never be
|
|
+ * reparented. Indeed, it's only orphan because its parent is.
|
|
+ *
|
|
+ * These tests are supposed to exercise the behaviour of the consumer
|
|
+ * API when dealing with an orphan clock, and how we deal with the
|
|
+ * transition to a valid parent.
|
|
+ */
|
|
+static struct kunit_suite
|
|
+clk_orphan_two_level_root_last_test_suite = {
|
|
+ .name = "clk-orphan-two-level-root-last-test",
|
|
+ .init = clk_orphan_two_level_root_last_test_init,
|
|
+ .exit = clk_orphan_two_level_root_last_test_exit,
|
|
+ .test_cases = clk_orphan_two_level_root_last_test_cases,
|
|
+};
|
|
+
|
|
/*
|
|
* Test that clk_set_rate_range won't return an error for a valid range
|
|
* and that it will make sure the rate of the clock is within the
|
|
@@ -1629,6 +1859,7 @@ kunit_test_suites(
|
|
&clk_multiple_parents_mux_test_suite,
|
|
&clk_orphan_transparent_multiple_parent_mux_test_suite,
|
|
&clk_orphan_transparent_single_parent_test_suite,
|
|
+ &clk_orphan_two_level_root_last_test_suite,
|
|
&clk_range_test_suite,
|
|
&clk_range_maximize_test_suite,
|
|
&clk_range_minimize_test_suite,
|