diff options
Diffstat (limited to 'target/linux/bcm27xx/patches-5.15/950-0841-clk-tests-Add-tests-for-single-parent-mux.patch')
| -rw-r--r-- | target/linux/bcm27xx/patches-5.15/950-0841-clk-tests-Add-tests-for-single-parent-mux.patch | 234 |
1 files changed, 234 insertions, 0 deletions
diff --git a/target/linux/bcm27xx/patches-5.15/950-0841-clk-tests-Add-tests-for-single-parent-mux.patch b/target/linux/bcm27xx/patches-5.15/950-0841-clk-tests-Add-tests-for-single-parent-mux.patch new file mode 100644 index 0000000000..05c7ba3d2f --- /dev/null +++ b/target/linux/bcm27xx/patches-5.15/950-0841-clk-tests-Add-tests-for-single-parent-mux.patch @@ -0,0 +1,234 @@ +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"); |