235 lines
7.1 KiB
Diff
235 lines
7.1 KiB
Diff
From 2ef4d6383803ef0b5b4b1efa5b7577a7970f2669 Mon Sep 17 00:00:00 2001
|
|
From: Maxime Ripard <maxime@cerno.tech>
|
|
Date: Thu, 7 Apr 2022 14:21:55 +0200
|
|
Subject: [PATCH] clk: tests: Add tests for single parent mux
|
|
|
|
We have a few tests for a mux with a single parent, testing the case
|
|
where it used to be orphan.
|
|
|
|
Let's leverage most of the code but register the clock properly to test
|
|
a few trivial things.
|
|
|
|
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 | 186 +++++++++++++++++++++++++++++++++++++++--
|
|
1 file changed, 177 insertions(+), 9 deletions(-)
|
|
|
|
--- a/drivers/clk/clk_test.c
|
|
+++ b/drivers/clk/clk_test.c
|
|
@@ -352,6 +352,181 @@ struct clk_single_parent_ctx {
|
|
struct clk_hw hw;
|
|
};
|
|
|
|
+static int clk_single_parent_mux_test_init(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_ctx *ctx;
|
|
+ int ret;
|
|
+
|
|
+ ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
|
|
+ if (!ctx)
|
|
+ return -ENOMEM;
|
|
+ test->priv = ctx;
|
|
+
|
|
+ ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
|
|
+ ctx->parent_ctx.hw.init =
|
|
+ CLK_HW_INIT_NO_PARENT("parent-clk",
|
|
+ &clk_dummy_rate_ops,
|
|
+ 0);
|
|
+
|
|
+ ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
|
|
+ if (ret)
|
|
+ return ret;
|
|
+
|
|
+ ctx->hw.init = CLK_HW_INIT("test-clk", "parent-clk",
|
|
+ &clk_dummy_single_parent_ops,
|
|
+ CLK_SET_RATE_PARENT);
|
|
+
|
|
+ ret = clk_hw_register(NULL, &ctx->hw);
|
|
+ if (ret)
|
|
+ return ret;
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static void
|
|
+clk_single_parent_mux_test_exit(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_ctx *ctx = test->priv;
|
|
+
|
|
+ clk_hw_unregister(&ctx->hw);
|
|
+ clk_hw_unregister(&ctx->parent_ctx.hw);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Test that for a clock with a single parent, clk_get_parent() actually
|
|
+ * returns the parent.
|
|
+ */
|
|
+static void
|
|
+clk_test_single_parent_mux_get_parent(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_ctx *ctx = test->priv;
|
|
+ struct clk_hw *hw = &ctx->hw;
|
|
+ struct clk *clk = hw->clk;
|
|
+ struct clk *parent;
|
|
+
|
|
+ parent = clk_get_parent(clk);
|
|
+ KUNIT_EXPECT_TRUE(test, clk_is_match(parent, ctx->parent_ctx.hw.clk));
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Test that for a clock that can't modify its rate and with a single
|
|
+ * parent, if we set disjoints range on the parent and then the child,
|
|
+ * the second will return an error.
|
|
+ *
|
|
+ * FIXME: clk_set_rate_range() only considers the current clock when
|
|
+ * evaluating whether ranges are disjoints and not the upstream clocks
|
|
+ * ranges.
|
|
+ */
|
|
+static void
|
|
+clk_test_single_parent_mux_set_range_disjoint_child_last(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_ctx *ctx = test->priv;
|
|
+ struct clk_hw *hw = &ctx->hw;
|
|
+ struct clk *clk = hw->clk;
|
|
+ struct clk *parent;
|
|
+ int ret;
|
|
+
|
|
+ kunit_skip(test, "This needs to be fixed in the core.");
|
|
+
|
|
+ parent = clk_get_parent(clk);
|
|
+ KUNIT_ASSERT_PTR_NE(test, parent, NULL);
|
|
+
|
|
+ ret = clk_set_rate_range(parent, 1000, 2000);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ ret = clk_set_rate_range(clk, 3000, 4000);
|
|
+ KUNIT_EXPECT_LT(test, ret, 0);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Test that for a clock that can't modify its rate and with a single
|
|
+ * parent, if we set disjoints range on the child and then the parent,
|
|
+ * the second will return an error.
|
|
+ *
|
|
+ * FIXME: clk_set_rate_range() only considers the current clock when
|
|
+ * evaluating whether ranges are disjoints and not the downstream clocks
|
|
+ * ranges.
|
|
+ */
|
|
+static void
|
|
+clk_test_single_parent_mux_set_range_disjoint_parent_last(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_ctx *ctx = test->priv;
|
|
+ struct clk_hw *hw = &ctx->hw;
|
|
+ struct clk *clk = hw->clk;
|
|
+ struct clk *parent;
|
|
+ int ret;
|
|
+
|
|
+ kunit_skip(test, "This needs to be fixed in the core.");
|
|
+
|
|
+ parent = clk_get_parent(clk);
|
|
+ KUNIT_ASSERT_PTR_NE(test, parent, NULL);
|
|
+
|
|
+ ret = clk_set_rate_range(clk, 1000, 2000);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ ret = clk_set_rate_range(parent, 3000, 4000);
|
|
+ KUNIT_EXPECT_LT(test, ret, 0);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Test that for a clock that can't modify its rate and with a single
|
|
+ * parent, if we set a range on the parent and a more restrictive one on
|
|
+ * the child, and then call clk_round_rate(), the boundaries of the
|
|
+ * two clocks are taken into account.
|
|
+ */
|
|
+static void
|
|
+clk_test_single_parent_mux_set_range_round_rate_child_smaller(struct kunit *test)
|
|
+{
|
|
+ struct clk_single_parent_ctx *ctx = test->priv;
|
|
+ struct clk_hw *hw = &ctx->hw;
|
|
+ struct clk *clk = hw->clk;
|
|
+ struct clk *parent;
|
|
+ unsigned long rate;
|
|
+ int ret;
|
|
+
|
|
+ parent = clk_get_parent(clk);
|
|
+ KUNIT_ASSERT_PTR_NE(test, parent, NULL);
|
|
+
|
|
+ ret = clk_set_rate_range(parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
|
|
+ KUNIT_ASSERT_EQ(test, ret, 0);
|
|
+
|
|
+ ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
|
|
+ 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 + 1000);
|
|
+ KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
|
|
+
|
|
+ rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
|
|
+ KUNIT_ASSERT_GT(test, rate, 0);
|
|
+ KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
|
|
+ KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
|
|
+}
|
|
+
|
|
+static struct kunit_case clk_single_parent_mux_test_cases[] = {
|
|
+ KUNIT_CASE(clk_test_single_parent_mux_get_parent),
|
|
+ KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_child_last),
|
|
+ KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_parent_last),
|
|
+ KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_child_smaller),
|
|
+ {}
|
|
+};
|
|
+
|
|
+/*
|
|
+ * Test suite for a basic mux clock with one parent, with
|
|
+ * CLK_SET_RATE_PARENT on the child.
|
|
+ *
|
|
+ * These tests are supposed to exercise the consumer API and check that
|
|
+ * the state of the child and parent are sane and consistent.
|
|
+ */
|
|
+static struct kunit_suite
|
|
+clk_single_parent_mux_test_suite = {
|
|
+ .name = "clk-single-parent-mux-test",
|
|
+ .init = clk_single_parent_mux_test_init,
|
|
+ .exit = clk_single_parent_mux_test_exit,
|
|
+ .test_cases = clk_single_parent_mux_test_cases,
|
|
+};
|
|
+
|
|
static int clk_orphan_transparent_single_parent_mux_test_init(struct kunit *test)
|
|
{
|
|
struct clk_single_parent_ctx *ctx;
|
|
@@ -388,14 +563,6 @@ static int clk_orphan_transparent_single
|
|
return 0;
|
|
}
|
|
|
|
-static void clk_orphan_transparent_single_parent_mux_test_exit(struct kunit *test)
|
|
-{
|
|
- struct clk_single_parent_ctx *ctx = test->priv;
|
|
-
|
|
- clk_hw_unregister(&ctx->hw);
|
|
- clk_hw_unregister(&ctx->parent_ctx.hw);
|
|
-}
|
|
-
|
|
/*
|
|
* Test that a mux-only clock, with an initial rate within a range,
|
|
* will still have the same rate after the range has been enforced.
|
|
@@ -440,7 +607,7 @@ static struct kunit_case clk_orphan_tran
|
|
static struct kunit_suite clk_orphan_transparent_single_parent_test_suite = {
|
|
.name = "clk-orphan-transparent-single-parent-test",
|
|
.init = clk_orphan_transparent_single_parent_mux_test_init,
|
|
- .exit = clk_orphan_transparent_single_parent_mux_test_exit,
|
|
+ .exit = clk_single_parent_mux_test_exit,
|
|
.test_cases = clk_orphan_transparent_single_parent_mux_test_cases,
|
|
};
|
|
|
|
@@ -1128,6 +1295,7 @@ kunit_test_suites(
|
|
&clk_range_test_suite,
|
|
&clk_range_maximize_test_suite,
|
|
&clk_range_minimize_test_suite,
|
|
+ &clk_single_parent_mux_test_suite,
|
|
&clk_uncached_test_suite
|
|
);
|
|
MODULE_LICENSE("GPL v2");
|