[openwrt/staging/hauke.git] /

From b50545c05484be6c9326377e03c69d165d3552f6 Mon Sep 17 00:00:00 2001
From: Maxime Ripard <maxime@cerno.tech>
Date: Sat, 2 Apr 2022 17:27:40 +0200
Subject: [PATCH] clk: tests: Add some tests for orphan with multiple
 parents

Let's leverage the dummy mux with multiple parents we have to create a
mux whose default parent will never be registered, and thus will always
be orphan by default.

We can then create some tests to make sure that the clock API behaves
properly in such a case, and that the transition to a non-orphan clock
when we change the parent is done properly.

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_test.c | 173 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 173 insertions(+)

--- a/drivers/clk/clk_test.c
+++ b/drivers/clk/clk_test.c
@@ -465,6 +465,178 @@ clk_multiple_parents_mux_test_suite = {
        .test_cases = clk_multiple_parents_mux_test_cases,
 };
 
+static int
+clk_orphan_transparent_multiple_parent_mux_test_init(struct kunit *test)
+{
+       struct clk_multiple_parent_ctx *ctx;
+       const char *parents[2] = { "missing-parent", "proper-parent"};
+       int ret;
+
+       ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
+       if (!ctx)
+               return -ENOMEM;
+       test->priv = ctx;
+
+       ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("proper-parent",
+                                                           &clk_dummy_rate_ops,
+                                                           0);
+       ctx->parents_ctx[1].rate = DUMMY_CLOCK_INIT_RATE;
+       ret = clk_hw_register(NULL, &ctx->parents_ctx[1].hw);
+       if (ret)
+               return ret;
+
+       ctx->hw.init = CLK_HW_INIT_PARENTS("test-orphan-mux", parents,
+                                          &clk_multiple_parents_mux_ops,
+                                          CLK_SET_RATE_PARENT);
+       ret = clk_hw_register(NULL, &ctx->hw);
+       if (ret)
+               return ret;
+
+       return 0;
+}
+
+static void
+clk_orphan_transparent_multiple_parent_mux_test_exit(struct kunit *test)
+{
+       struct clk_multiple_parent_ctx *ctx = test->priv;
+
+       clk_hw_unregister(&ctx->hw);
+       clk_hw_unregister(&ctx->parents_ctx[1].hw);
+}
+
+/*
+ * Test that, for a mux whose current parent hasn't been registered yet,
+ * calling clk_set_parent() to a valid parent will properly update the
+ * mux parent and its orphan status.
+ */
+static void
+clk_test_orphan_transparent_multiple_parent_mux_set_parent(struct kunit *test)
+{
+       struct clk_multiple_parent_ctx *ctx = test->priv;
+       struct clk_hw *hw = &ctx->hw;
+       struct clk *clk = hw->clk;
+       struct clk *parent, *new_parent;
+       int ret;
+
+       parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+
+       ret = clk_set_parent(clk, parent);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+
+       new_parent = clk_get_parent(clk);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+       KUNIT_EXPECT_TRUE(test, clk_is_match(parent, new_parent));
+
+       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
+clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate(struct kunit *test)
+{
+       struct clk_multiple_parent_ctx *ctx = test->priv;
+       struct clk_hw *hw = &ctx->hw;
+       struct clk *clk = hw->clk;
+       struct clk *parent;
+       unsigned long parent_rate, 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);
+
+       rate = clk_get_rate(clk);
+       KUNIT_ASSERT_GT(test, rate, 0);
+       KUNIT_EXPECT_EQ(test, parent_rate, rate);
+}
+
+/*
+ * 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.
+ */
+static void
+clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified(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 rate;
+       int ret;
+
+       parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+
+       ret = clk_set_parent(clk, parent);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+
+       ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+
+       rate = clk_get_rate(clk);
+       KUNIT_ASSERT_GT(test, rate, 0);
+       KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
+       KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
+
+       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.
+ */
+static void
+clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate(struct kunit *test)
+{
+       struct clk_multiple_parent_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_RATE_1, DUMMY_CLOCK_RATE_2);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+
+       rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
+       KUNIT_ASSERT_GT(test, rate, 0);
+       KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
+       KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
+}
+
+static struct kunit_case clk_orphan_transparent_multiple_parent_mux_test_cases[] = {
+       KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent),
+       KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate),
+       KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified),
+       KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate),
+       {}
+};
+
+/*
+ * Test suite for a basic mux clock with two parents. The default parent
+ * isn't registered, only the second parent is. By default, the clock
+ * will thus be orphan.
+ *
+ * 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_transparent_multiple_parent_mux_test_suite = {
+       .name = "clk-orphan-transparent-multiple-parent-mux-test",
+       .init = clk_orphan_transparent_multiple_parent_mux_test_init,
+       .exit = clk_orphan_transparent_multiple_parent_mux_test_exit,
+       .test_cases = clk_orphan_transparent_multiple_parent_mux_test_cases,
+};
+
 struct clk_single_parent_ctx {
        struct clk_dummy_context parent_ctx;
        struct clk_hw hw;
@@ -1410,6 +1582,7 @@ static struct kunit_suite clk_range_mini
 kunit_test_suites(
        &clk_test_suite,
        &clk_multiple_parents_mux_test_suite,
+       &clk_orphan_transparent_multiple_parent_mux_test_suite,
        &clk_orphan_transparent_single_parent_test_suite,
        &clk_range_test_suite,
        &clk_range_maximize_test_suite,