clk: add kunit tests and some documentation
v3 cover clk: add kunit tests and some documentation
Here's a series that adds various kunit tests to the clk framework, and documents the members of struct clk_core. These tests are centered around inconsistencies and limitations in the clock framework that may lead to some clocks unknowingly changing rates during a rate change of their siblings.
The intent of the clock framework is to keep the siblings clock rate stable during such an operation:
clk_set_rate(clk, MY_NEW_RATE);
However, it assumes that the sibling can generate that rate in the first place. In many situations, it can't, and it leads to numerous bugs and solutions over the years.
https://lore.kernel.org/lkml/[email protected]/
https://lore.kernel.org/linux-kernel/[email protected]/
https://lore.kernel.org/all/[email protected]/
https://lore.kernel.org/linux-clk/20241121-ge-ian-debug-imx8-clk-tree-v1-0-0f1b722588fe@bootlin.com/
We intend to fix these issues, but first we need to agree and document what these shortcomings are. These patches are meant to do that, even though some will be skipped as they are currently broken.
Changes since v2:
https://lore.kernel.org/linux-clk/[email protected]/
- I left out my patches for changing the rate change propagation in the clk core so that parent rate changes are negotiated with all of it's children (and below). I will post a new version of that logic at a later time once I finish some more cleanups. The changes that are coming will make it so that the skipped tests in patch 4 of this series (div_div_2 and div_div_3) pass.
- Make divider clocks one based (Maxime)
- Text updates to clk_core kernel docs (Maxime)
- Convert from KUNIT_ASSERT_xx to KUNIT_EXPECT_xx (Maxime)
- Minor documentation updates to tests
- Drop rate constants and introduce clk_dummy_rate_mhz().
---
Brian Masney (9):
clk: add kernel docs for struct clk_core
clk: test: introduce clk_dummy_rate_mhz()
clk: test: introduce clk_dummy_div for a mock divider
clk: test: introduce test suite for sibling rate changes on a divider
clk: test: introduce clk_dummy_gate for a mock gate
clk: test: introduce test suite for sibling rate changes on a gate
clk: test: introduce helper to create a mock mux
clk: test: introduce test variation for sibling rate changes on a mux
clk: test: introduce test variation for sibling rate changes on a gate/mux
drivers/clk/clk.c | 55 +++++ drivers/clk/clk_test.c | 611 +++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 575 insertions(+), 91 deletions(-)
---
base-commit: 8f5ae30d69d7543eee0d70083daf4de8fe15d585
change-id: 20250806-clk-tests-docs-3c398759e998
Best regards,
Signature · 1 line
Brian Masney <[email protected]>
PATCH v3 1/9 clk: add kernel docs for struct clk_core
Document all of the members of struct clk_core.
--- drivers/clk/clk.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+)
drivers/clk/clk.c +55 -0
@@ -57,6 +57,61 @@ struct clk_parent_map {int index; }; +/** +* struct clk_core - This structure represents the internal state of a clk +* within the kernel's clock tree. Drivers do not interact with this structure +* directly. The clk_core is manipulated by the framework to manage clock +* operations, parent/child relationships, rate, and other properties. +* +* @name: Unique name of the clk for identification. +* @ops: Pointer to hardware-specific operations for this clk. +* @hw: Pointer for traversing from a struct clk to its +* corresponding hardware-specific structure. +* @owner: Kernel module owning this clk (for reference counting). +* @dev: Device associated with this clk (optional) +* @rpm_node: Node for runtime power management list management. +* @of_node: Device tree node associated with this clk (if applicable) +* @parent: Pointer to the current parent in the clock tree. +* @parents: Array of possible parents (for muxes/selectable parents). +* @num_parents: Number of possible parents +* @new_parent_index: Index of the new parent during parent change. +* @rate: Current clock rate (Hz). This is effectively a cached +* value of what the hardware has been programmed with. It's +* initialized by reading the value at boot time, and will +* be updated every time an operation affects the rate. +* Clocks with the CLK_GET_RATE_NOCACHE flag should not use +* this value, as its rate is expected to change behind the +* kernel's back (because the firmware might change it, for +* example). Also, if the clock is orphan, it's set to 0 +* and updated when (and if) its parent is later loaded, so +* its content is only ever valid if clk_core->orphan is +* false. +* @req_rate: The last rate requested by a call to clk_set_rate. It's +* initialized to clk_core->rate. It's also updated to +* clk_core->rate every time the clock is reparented, and +* when we're doing the orphan -> !orphan transition. +* @new_rate: New rate to be set during a rate change operation. +* @new_parent: Pointer to new parent during parent change. +* @new_child: Pointer to new child during reparenting. +* @flags: Clock property and capability flags. +* @orphan: True if this clk is currently orphaned. +* @rpm_enabled: True if runtime power management is enabled for this clk. +* @enable_count: Reference count of enables. +* @prepare_count: Reference count of prepares. +* @protect_count: Protection reference count against disable. +* @min_rate: Minimum supported clock rate (Hz). +* @max_rate: Maximum supported clock rate (Hz). +* @accuracy: Accuracy of the clock rate (parts per billion). +* @phase: Current phase (degrees). +* @duty: Current duty cycle configuration. +* @children: All of the children of this clk. +* @child_node: Node for linking as a child in the parent's list. +* @clks: All of the clk consumers registered. +* @notifier_count: Number of notifiers registered for this clk. +* @dentry: DebugFS entry for this clk. +* @debug_node: DebugFS node for this clk. +* @ref: Reference count for structure lifetime management. +*/ struct clk_core {const char *name;const struct clk_ops *ops;
Signature · 1 line
2.50.1
Re: [PATCH v3 1/9] clk: add kernel docs for struct clk_core
Hi,
Quoted 41 lines · Brian Masney
Document all of the members of struct
clk_core.Signed-off-by Brian Masney <[email protected]>--- drivers/clk/clk.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+)drivers/clk/clk.c +26
-0@@ -57,6 +57,61 @@ struct clk_parent_map {int index; }; +/** +* struct clk_core - This structure represents the internal state of a clk +* within the kernel's clock tree. Drivers do not interact with this structure +* directly. The clk_core is manipulated by the framework to manage clock +* operations, parent/child relationships, rate, and other properties. +* +* @name: Unique name of the clk for identification. +* @ops: Pointer to hardware-specific operations for this clk. +* @hw: Pointer for traversing from a struct clk to its +* corresponding hardware-specific structure. +* @owner: Kernel module owning this clk (for reference counting). +* @dev: Device associated with this clk (optional) +* @rpm_node: Node for runtime power management list management. +* @of_node: Device tree node associated with this clk (if applicable) +* @parent: Pointer to the current parent in the clock tree. +* @parents: Array of possible parents (for muxes/selectable parents). +* @num_parents: Number of possible parents +* @new_parent_index: Index of the new parent during parent change. +* @rate: Current clock rate (Hz). This is effectively a cached +* value of what the hardware has been programmed with. It's +* initialized by reading the value at boot time, and will +* be updated every time an operation affects the rate. +* Clocks with the CLK_GET_RATE_NOCACHE flag should not use +* this value, as its rate is expected to change behind the +* kernel's back (because the firmware might change it, for +* example). Also, if the clock is orphan, it's set to 0
drivers/clk/clk.c struct clk_parent_map { · line 95
Quoted 10 lines
drivers/clk/clk.c +10
-0+* and updated when (and if) its parent is later loaded, so +* its content is only ever valid if clk_core->orphan is +* false. +* @req_rate: The last rate requested by a call to clk_set_rate. It's +* initialized to clk_core->rate. It's also updated to +* clk_core->rate every time the clock is reparented, and +* when we're doing the orphan -> !orphan transition. +* @new_rate: New rate to be set during a rate change operation. +* @new_parent: Pointer to new parent during parent change. +* @new_child: Pointer to new child during reparenting.
I think both can also be used during a rate change that affects the parenting, right?
drivers/clk/clk.c struct clk_parent_map { · line 106
Quoted 11 lines
drivers/clk/clk.c +11
-0+* @flags: Clock property and capability flags. +* @orphan: True if this clk is currently orphaned. +* @rpm_enabled: True if runtime power management is enabled for this clk. +* @enable_count: Reference count of enables. +* @prepare_count: Reference count of prepares. +* @protect_count: Protection reference count against disable. +* @min_rate: Minimum supported clock rate (Hz). +* @max_rate: Maximum supported clock rate (Hz). +* @accuracy: Accuracy of the clock rate (parts per billion). +* @phase: Current phase (degrees). +* @duty: Current duty cycle configuration.
We should probably mention the unit here too. I assume it's in percent?
Looks good otherwise. Once fixed,
Maxime
PATCH v3 2/9 clk: test: introduce clk_dummy_rate_mhz()
In reply to Brian MasneySome of the mock tests care about the relationship between two different rates to ensure that functionality in the clk core is exercised when the parent rate is negotiated by using specific rates. Introduce clk_dummy_rate_mhz() to improve readability. Change the DUMMY_CLOCK_* rate constants over to use this.
--- drivers/clk/clk_test.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
drivers/clk/clk_test.c +4 -3
@@ -21,9 +21,10 @@static const struct clk_ops empty_clk_ops = { }; -#define DUMMY_CLOCK_INIT_RATE (42 * 1000 * 1000) -#define DUMMY_CLOCK_RATE_1 (142 * 1000 * 1000) -#define DUMMY_CLOCK_RATE_2 (242 * 1000 * 1000) +#define clk_dummy_rate_mhz (rate) ((rate) * 1000 * 1000) +#define DUMMY_CLOCK_INIT_RATE clk_dummy_rate_mhz(42) +#define DUMMY_CLOCK_RATE_1 clk_dummy_rate_mhz(142) +#define DUMMY_CLOCK_RATE_2 clk_dummy_rate_mhz(242)struct clk_dummy_context {struct clk_hw hw;
Signature · 1 line
2.50.1
Re: [PATCH v3 2/9] clk: test: introduce clk_dummy_rate_mhz()
Quoted 16 lines · Brian Masney
Some of the mock tests care about the relationship between two different rates to ensure that functionality in the clk core is exercised when the parent rate is negotiated by using specific rates. Introduce
clk_dummy_rate_mhz()to improve readability. Change the DUMMY_CLOCK_* rate constants over to use this.Signed-off-by Brian Masney <[email protected]>--- drivers/clk/clk_test.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)drivers/clk/clk_test.c +0
-0
drivers/clk/clk_test.c line 24
Quoted 7 lines
drivers/clk/clk_test.c +1
-3@@ -21,9 +21,10 @@static const struct clk_ops empty_clk_ops = { }; -#define DUMMY_CLOCK_INIT_RATE (42 * 1000 * 1000) -#define DUMMY_CLOCK_RATE_1 (142 * 1000 * 1000) -#define DUMMY_CLOCK_RATE_2 (242 * 1000 * 1000) +#define clk_dummy_rate_mhz (rate) ((rate) * 1000 * 1000)
Macros are typically defined with uppercase names. Also, you can use HZ_PER_MHZ.
Maxime
PATCH v3 3/9 clk: test: introduce clk_dummy_div for a mock divider
In reply to Brian MasneyThis is used to mock up a divider in the clk kunit tests.
--- drivers/clk/clk_test.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+)
drivers/clk/clk_test.c +42 -0
@@ -137,6 +137,48 @@ static const struct clk_ops clk_dummy_single_parent_ops = { .get_parent = clk_dummy_single_get_parent, }; +// 4 ought to be enough for anybody +#define CLK_DUMMY_DIV_WIDTH 4 +#define CLK_DUMMY_DIV_FLAGS (CLK_DIVIDER_ONE_BASED | CLK_DIVIDER_ROUND_CLOSEST) + +struct clk_dummy_div { +struct clk_hw hw; +unsigned int div; +}; + +static unsigned long clk_dummy_div_recalc_rate (struct clk_hw *hw, +unsigned long parent_rate) +{ + struct clk_dummy_div *div = container_of(hw, struct clk_dummy_div, hw); + +return divider_recalc_rate (hw, parent_rate, div->div,NULL , +CLK_DUMMY_DIV_FLAGS ,CLK_DUMMY_DIV_WIDTH ); +} + +static long clk_dummy_div_round_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *parent_rate) +{ +return divider_round_rate (hw, rate, parent_rate,NULL , +CLK_DUMMY_DIV_WIDTH ,CLK_DUMMY_DIV_FLAGS ); +} + +static int clk_dummy_div_set_rate (struct clk_hw *hw,unsigned long rate, +unsigned long parent_rate) +{ + struct clk_dummy_div *div = container_of(hw, struct clk_dummy_div, hw); + + div->div =divider_get_val (rate, parent_rate,NULL ,CLK_DUMMY_DIV_WIDTH , +CLK_DUMMY_DIV_FLAGS ); + +return 0 ; +} + +static const struct clk_ops clk_dummy_div_ops = { + .recalc_rate = clk_dummy_div_recalc_rate, + .round_rate = clk_dummy_div_round_rate, + .set_rate = clk_dummy_div_set_rate, +}; +struct clk_multiple_parent_ctx {struct clk_dummy_context parents_ctx[2 ];struct clk_hw hw;
Signature · 1 line
2.50.1
Re: [PATCH v3 3/9] clk: test: introduce clk_dummy_div for a mock divider
drivers/clk/clk_test.c static const struct clk_ops clk_dummy_single_parent_ops = { · line 163
Quoted 6 lines · Brian Masney
drivers/clk/clk_test.c +6
-0+static long clk_dummy_div_round_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *parent_rate) +{ +return divider_round_rate (hw, rate, parent_rate,NULL , +CLK_DUMMY_DIV_WIDTH ,CLK_DUMMY_DIV_FLAGS ); +}
I sent the wrong version of this patch with the round_rate instead of the determine_rate implementation. Kind of ironic given that I posted various series across the kernel to get rid of round_rate!
Brian
PATCH v3 4/9 clk: test: introduce test suite for sibling rate changes on a divider
In reply to Brian MasneyIntroduce a test suite that creates a parent with two divider-only children, and ensure that changing the rate of one child does not affect the rate of the sibling. Some of the tests are disabled until the underlying issue is fixed in the clk core.
--- drivers/clk/clk_test.c | 145 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 145 insertions(+)
drivers/clk/clk_test.c +145 -0
@@ -651,6 +651,150 @@ clk_multiple_parents_mux_test_suite = { .test_cases = clk_multiple_parents_mux_test_cases, }; +struct clk_rate_change_sibling_div_div_context { +struct clk_dummy_context parent; +struct clk_dummy_div child1, child2; +struct clk *parent_clk, *child1_clk, *child2_clk; +}; + +static int clk_rate_change_sibling_div_div_test_init (struct kunit *test) +{ +struct clk_rate_change_sibling_div_div_context *ctx; +int ret; + + ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL ); +if (!ctx) +return -ENOMEM ; + test->priv = ctx; + + ctx->parent.hw.init =CLK_HW_INIT_NO_PARENT ("parent" , &clk_dummy_rate_ops,0 ); + ctx->parent.rate =clk_dummy_rate_mhz (24 ); + ret =clk_hw_register_kunit (test,NULL , &ctx->parent.hw); +if (ret) +return ret; + + ctx->child1.hw.init =CLK_HW_INIT_HW ("child1" , &ctx->parent.hw, &clk_dummy_div_ops, +CLK_SET_RATE_PARENT ); + ctx->child1.div =1 ; + ret =clk_hw_register_kunit (test,NULL , &ctx->child1.hw); +if (ret) +return ret; + + ctx->child2.hw.init =CLK_HW_INIT_HW ("child2" , &ctx->parent.hw, &clk_dummy_div_ops, +CLK_SET_RATE_PARENT ); + ctx->child2.div =1 ; + ret =clk_hw_register_kunit (test,NULL , &ctx->child2.hw); +if (ret) +return ret; + + ctx->parent_clk =clk_hw_get_clk (&ctx->parent.hw,NULL ); + ctx->child1_clk =clk_hw_get_clk (&ctx->child1.hw,NULL ); + ctx->child2_clk =clk_hw_get_clk (&ctx->child2.hw,NULL ); + +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->parent_clk),clk_dummy_rate_mhz (24 )); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child1_clk),clk_dummy_rate_mhz (24 )); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child2_clk),clk_dummy_rate_mhz (24 )); + +return 0 ; +} + +static void clk_rate_change_sibling_div_div_test_exit (struct kunit *test) +{ +struct clk_rate_change_sibling_div_div_context *ctx = test->priv; + +clk_put (ctx->parent_clk); +clk_put (ctx->child1_clk); +clk_put (ctx->child2_clk); +} + +/* +* Test that, for a parent with two divider-only children with CLK_SET_RATE_PARENT set +* and one requests a rate compatible with the existing parent rate, the parent and +* sibling rates are not affected. +*/ +static void clk_test_rate_change_sibling_div_div_1 (struct kunit *test) +{ +struct clk_rate_change_sibling_div_div_context *ctx = test->priv; +int ret; + + ret =clk_set_rate (ctx->child1_clk,clk_dummy_rate_mhz (6 )); +KUNIT_ASSERT_EQ (test, ret,0 ); + +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->parent_clk),clk_dummy_rate_mhz (24 )); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child1_clk),clk_dummy_rate_mhz (6 )); +KUNIT_EXPECT_EQ (test, ctx->child1.div,4 ); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child2_clk),clk_dummy_rate_mhz (24 )); +KUNIT_EXPECT_EQ (test, ctx->child2.div,1 ); +} + +/* +* Test that, for a parent with two divider-only children with CLK_SET_RATE_PARENT +* set and one requests a rate incompatible with the existing parent rate, the +* sibling rate is not affected. The requested child rate picks a parent rate +* that's compatible with both children. +*/ +static void clk_test_rate_change_sibling_div_div_2 (struct kunit *test) +{ +struct clk_rate_change_sibling_div_div_context *ctx = test->priv; +int ret; + +kunit_skip (test,"This needs to be fixed in the core." ); + + ret =clk_set_rate (ctx->child1_clk,clk_dummy_rate_mhz (48 )); +KUNIT_ASSERT_EQ (test, ret,0 ); + +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->parent_clk),clk_dummy_rate_mhz (48 )); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child1_clk),clk_dummy_rate_mhz (48 )); +KUNIT_EXPECT_EQ (test, ctx->child1.div,1 ); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child2_clk),clk_dummy_rate_mhz (24 )); +KUNIT_EXPECT_EQ (test, ctx->child1.div,2 ); +} + +/* +* Test that, for a parent with two divider-only children with CLK_SET_RATE_PARENT +* set and one requests a rate incompatible with the existing parent rate, the +* sibling rate is not affected. The requested child rates require a parent rate +* that neither child would initially pick. +*/ +static void clk_test_rate_change_sibling_div_div_3 (struct kunit *test) +{ +struct clk_rate_change_sibling_div_div_context *ctx = test->priv; +int ret; + +kunit_skip (test,"This needs to be fixed in the core." ); + + ret =clk_set_rate (ctx->child1_clk,clk_dummy_rate_mhz (32 )); +KUNIT_ASSERT_EQ (test, ret,0 ); + + ret =clk_set_rate (ctx->child2_clk,clk_dummy_rate_mhz (48 )); +KUNIT_ASSERT_EQ (test, ret,0 ); + +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->parent_clk),clk_dummy_rate_mhz (96 )); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child1_clk),clk_dummy_rate_mhz (32 )); +KUNIT_EXPECT_EQ (test, ctx->child1.div,3 ); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child2_clk),clk_dummy_rate_mhz (48 )); +KUNIT_EXPECT_EQ (test, ctx->child2.div,2 ); +} + +static struct kunit_case clk_rate_change_sibling_div_div_cases[] = { +KUNIT_CASE (clk_test_rate_change_sibling_div_div_1), +KUNIT_CASE (clk_test_rate_change_sibling_div_div_2), +KUNIT_CASE (clk_test_rate_change_sibling_div_div_3), + {} +}; + +/* +* Test suite that creates a parent with two divider-only children, and +* ensures that changing the rate of one child does not affect the rate +* of the other child. +*/ +static struct kunit_suite clk_rate_change_sibling_div_div_test_suite = { + .name ="clk-rate-change-sibling-div-div" , + .init = clk_rate_change_sibling_div_div_test_init, + .exit = clk_rate_change_sibling_div_div_test_exit, + .test_cases = clk_rate_change_sibling_div_div_cases, +}; +static int clk_orphan_transparent_multiple_parent_mux_test_init (struct kunit *test) {
@@ -3591,6 +3735,7 @@ kunit_test_suites( &clk_leaf_mux_set_rate_parent_test_suite, &clk_test_suite, &clk_multiple_parents_mux_test_suite, + &clk_rate_change_sibling_div_div_test_suite, &clk_mux_no_reparent_test_suite, &clk_mux_notifier_test_suite, &clk_orphan_transparent_multiple_parent_mux_test_suite,
Signature · 1 line
2.50.1
PATCH v3 5/9 clk: test: introduce clk_dummy_gate for a mock gate
In reply to Brian MasneyThis is used to mock up a gate in the clk kunit tests.
--- drivers/clk/clk_test.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+)
drivers/clk/clk_test.c +34 -0
@@ -179,6 +179,40 @@ static const struct clk_ops clk_dummy_div_ops = { .set_rate = clk_dummy_div_set_rate, }; +struct clk_dummy_gate { +struct clk_hw hw; +bool enabled; +}; + +static int clk_dummy_gate_enable (struct clk_hw *hw) +{ + struct clk_dummy_gate *gate = container_of(hw, struct clk_dummy_gate, hw); + + gate->enabled = true; + +return 0 ; +} + +static void clk_dummy_gate_disable (struct clk_hw *hw) +{ + struct clk_dummy_gate *gate = container_of(hw, struct clk_dummy_gate, hw); + + gate->enabled = false; +} + +static int clk_dummy_gate_is_enabled (struct clk_hw *hw) +{ + struct clk_dummy_gate *gate = container_of(hw, struct clk_dummy_gate, hw); + +return gate->enabled; +} + +static const struct clk_ops clk_dummy_gate_ops = { + .enable = clk_dummy_gate_enable, + .disable = clk_dummy_gate_disable, + .is_enabled = clk_dummy_gate_is_enabled, +}; +struct clk_multiple_parent_ctx {struct clk_dummy_context parents_ctx[2 ];struct clk_hw hw;
Signature · 1 line
2.50.1
PATCH v3 6/9 clk: test: introduce test suite for sibling rate changes on a gate
In reply to Brian MasneyIntroduce a test suite that creates a parent with two children: a divider and a gate. Ensure that changing the rate of one child does not affect the rate of the gate.
Some of the tests are disabled until the relevant issue(s) are fixed in the clk core. This is also implemented as a parameterized kunit test since additional test variations will be added.
--- drivers/clk/clk_test.c | 155 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 155 insertions(+)
drivers/clk/clk_test.c +155 -0
@@ -829,6 +829,160 @@ static struct kunit_suite clk_rate_change_sibling_div_div_test_suite = { .test_cases = clk_rate_change_sibling_div_div_cases, }; +struct clk_test_rate_change_sibling_clk_ctx { +struct clk *parent_clk, *child1_clk, *child2_clk; +}; + +static void +clk_test_rate_change_sibling_clk_ctx_put (struct clk_test_rate_change_sibling_clk_ctx *clk_ctx) +{ +clk_put (clk_ctx->parent_clk); +clk_put (clk_ctx->child1_clk); +clk_put (clk_ctx->child2_clk); +} + +struct clk_rate_change_sibling_div_gate_sibling_context { +struct clk_dummy_context parent; +struct clk_dummy_div child1; +struct clk_dummy_gate child2; +struct clk_test_rate_change_sibling_clk_ctx clk_ctx; +}; + +static struct clk_test_rate_change_sibling_clk_ctx * +clk_rate_change_sibling_div_gate_test_init (struct kunit *test) +{ +struct clk_rate_change_sibling_div_gate_sibling_context *ctx; +int ret; + + ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL ); +if (!ctx) +return ERR_PTR (-ENOMEM ); + test->priv = ctx; + + ctx->parent.hw.init =CLK_HW_INIT_NO_PARENT ("parent" , &clk_dummy_rate_ops,0 ); + ctx->parent.rate =clk_dummy_rate_mhz (24 ); + ret =clk_hw_register_kunit (test,NULL , &ctx->parent.hw); +if (ret) +return ERR_PTR (ret); + + ctx->child1.hw.init =CLK_HW_INIT_HW ("child1" , &ctx->parent.hw, &clk_dummy_div_ops, +CLK_SET_RATE_PARENT ); + ctx->child1.div =1 ; + ret =clk_hw_register_kunit (test,NULL , &ctx->child1.hw); +if (ret) +return ERR_PTR (ret); + + ctx->child2.hw.init =CLK_HW_INIT_HW ("child2" , &ctx->parent.hw, &clk_dummy_gate_ops, +CLK_SET_RATE_PARENT ); + ret =clk_hw_register_kunit (test,NULL , &ctx->child2.hw); +if (ret) +return ERR_PTR (ret); + + ctx->clk_ctx.parent_clk =clk_hw_get_clk (&ctx->parent.hw,NULL ); + ctx->clk_ctx.child1_clk =clk_hw_get_clk (&ctx->child1.hw,NULL ); + ctx->clk_ctx.child2_clk =clk_hw_get_clk (&ctx->child2.hw,NULL ); + +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->clk_ctx.parent_clk),clk_dummy_rate_mhz (24 )); + +return &ctx->clk_ctx; +} + +struct clk_test_rate_change_sibling_test_case { +const char *desc; +struct clk_test_rate_change_sibling_clk_ctx *(*init)(struct kunit *test); +}; + +static struct clk_test_rate_change_sibling_test_case clk_test_rate_change_sibling_test_cases[] = { + { + .desc ="div_gate" , + .init = clk_rate_change_sibling_div_gate_test_init, + }, +}; + +KUNIT_ARRAY_PARAM_DESC (clk_test_rate_change_sibling_test_case, + clk_test_rate_change_sibling_test_cases, desc); + +/* +* Test that, for a parent with two children with CLK_SET_RATE_PARENT set and +* one requests a rate change that requires a change to the parent rate, the +* sibling rates are not affected. +*/ +static void clk_test_rate_change_sibling_1 (struct kunit *test) +{ +struct clk_test_rate_change_sibling_test_case *testcase = + (struct clk_test_rate_change_sibling_test_case *) test->param_value; +struct clk_test_rate_change_sibling_clk_ctx *ctx; +int ret; + +kunit_skip (test,"This needs to be fixed in the core." ); + + ctx = testcase->init (test); +KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ctx); + +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child2_clk),clk_dummy_rate_mhz (24 )); + + ret =clk_set_rate (ctx->child1_clk,clk_dummy_rate_mhz (48 )); +KUNIT_ASSERT_EQ (test, ret,0 ); + +KUNIT_EXPECT_GE (test,clk_get_rate (ctx->parent_clk),clk_dummy_rate_mhz (48 )); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child1_clk),clk_dummy_rate_mhz (48 )); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child2_clk),clk_dummy_rate_mhz (24 )); + +clk_test_rate_change_sibling_clk_ctx_put (ctx); +} + +/* +* Test that, for a parent with two children with CLK_SET_RATE_PARENT set where +* one requests an exclusive rate and the other requests a rate change that +* requires a change to the parent rate, the sibling rates are not affected. +*/ +static void clk_test_rate_change_sibling_2 (struct kunit *test) +{ +struct clk_test_rate_change_sibling_test_case *testcase = + (struct clk_test_rate_change_sibling_test_case *)(test->param_value); +struct clk_test_rate_change_sibling_clk_ctx *ctx; +int ret; + + ctx = testcase->init (test); +KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ctx); + + ret =clk_rate_exclusive_get (ctx->child2_clk); +KUNIT_ASSERT_EQ (test, ret,0 ); + +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child2_clk),clk_dummy_rate_mhz (24 )); + + ret =clk_set_rate (ctx->child1_clk,clk_dummy_rate_mhz (48 )); +KUNIT_ASSERT_EQ (test, ret,0 ); + +KUNIT_EXPECT_GE (test,clk_get_rate (ctx->parent_clk),clk_dummy_rate_mhz (24 )); +/* child1 is rounded to the closest supported rate */ +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child1_clk),clk_dummy_rate_mhz (24 )); +KUNIT_EXPECT_EQ (test,clk_get_rate (ctx->child2_clk),clk_dummy_rate_mhz (24 )); + +clk_rate_exclusive_put (ctx->child2_clk); + +clk_test_rate_change_sibling_clk_ctx_put (ctx); +} + + +static struct kunit_case clk_rate_change_sibling_cases[] = { +KUNIT_CASE_PARAM (clk_test_rate_change_sibling_1, + clk_test_rate_change_sibling_test_case_gen_params), +KUNIT_CASE_PARAM (clk_test_rate_change_sibling_2, + clk_test_rate_change_sibling_test_case_gen_params), + {} +}; + +/* +* Test suite that creates a parent with two children, where the children can +* be combinations of a divider, gate, and a mux. Ensure that changing the rate +* of one child does affect the rate of the other child. +*/ +static struct kunit_suite clk_rate_change_sibling_test_suite = { + .name ="clk-rate-change-sibling" , + .test_cases = clk_rate_change_sibling_cases, +}; +static int clk_orphan_transparent_multiple_parent_mux_test_init (struct kunit *test) {
@@ -3770,6 +3924,7 @@ kunit_test_suites( &clk_test_suite, &clk_multiple_parents_mux_test_suite, &clk_rate_change_sibling_div_div_test_suite, + &clk_rate_change_sibling_test_suite, &clk_mux_no_reparent_test_suite, &clk_mux_notifier_test_suite, &clk_orphan_transparent_multiple_parent_mux_test_suite,
Signature · 1 line
2.50.1
PATCH v3 7/9 clk: test: introduce helper to create a mock mux
In reply to Brian MasneyIntroduce a helper to create a mock mux to reduce code duplication. This also changes it so that the relevant clk_hws are registered with the kunit framework.
--- drivers/clk/clk_test.c | 141 ++++++++++++++++++------------------------------- 1 file changed, 52 insertions(+), 89 deletions(-)
drivers/clk/clk_test.c +52 -89
@@ -536,45 +536,64 @@ static struct kunit_suite clk_uncached_test_suite = { .test_cases = clk_uncached_test_cases, }; -static int -clk_multiple_parents_mux_test_init (struct kunit *test) -{ -struct clk_multiple_parent_ctx *ctx; -const char *parents[2 ] = {"parent-0" ,"parent-1" }; +static int clk_init_multiple_parent_ctx (struct kunit *test, +struct clk_multiple_parent_ctx *ctx, +const char *parent0_name, +unsigned long parent0_rate, +const char *parent1_name, +unsigned long parent1_rate, +const char *mux_name,int mux_flags, +const struct clk_ops *mux_ops) +{ +const struct clk_hw *parents[2 ];int ret; - ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL ); -if (!ctx) -return -ENOMEM ; - test->priv = ctx; - - ctx->parents_ctx[0 ].hw.init =CLK_HW_INIT_NO_PARENT ("parent-0" , + ctx->parents_ctx[0 ].hw.init =CLK_HW_INIT_NO_PARENT (parent0_name, &clk_dummy_rate_ops,0 ); - ctx->parents_ctx[0 ].rate =DUMMY_CLOCK_RATE_1 ; + ctx->parents_ctx[0 ].rate = parent0_rate; ret =clk_hw_register_kunit (test,NULL , &ctx->parents_ctx[0 ].hw);if (ret)return ret; - ctx->parents_ctx[1 ].hw.init =CLK_HW_INIT_NO_PARENT ("parent-1" , + ctx->parents_ctx[1 ].hw.init =CLK_HW_INIT_NO_PARENT (parent1_name, &clk_dummy_rate_ops,0 ); - ctx->parents_ctx[1 ].rate =DUMMY_CLOCK_RATE_2 ; + ctx->parents_ctx[1 ].rate = parent1_rate; ret =clk_hw_register_kunit (test,NULL , &ctx->parents_ctx[1 ].hw);if (ret)return ret; - ctx->current_parent =0 ; - ctx->hw.init =CLK_HW_INIT_PARENTS ("test-mux" , parents, - &clk_multiple_parents_mux_ops, -CLK_SET_RATE_PARENT ); + parents[0 ] = &ctx->parents_ctx[0 ].hw; + parents[1 ] = &ctx->parents_ctx[1 ].hw; + ctx->hw.init =CLK_HW_INIT_PARENTS_HW (mux_name, parents, + mux_ops, mux_flags); ret =clk_hw_register_kunit (test,NULL , &ctx->hw);if (ret)return ret; + ctx->current_parent =0 ; +return 0 ; } +static int +clk_multiple_parents_mux_test_init (struct kunit *test) +{ +struct clk_multiple_parent_ctx *ctx; + + ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL ); +if (!ctx) +return -ENOMEM ; + test->priv = ctx; + +return clk_init_multiple_parent_ctx (test, ctx, +"parent-0" ,DUMMY_CLOCK_RATE_1 , +"parent-1" ,DUMMY_CLOCK_RATE_2 , +"test-mux" ,CLK_SET_RATE_PARENT , + &clk_multiple_parents_mux_ops); +} +/* * Test that for a clock with multiple parents, clk_get_parent() * actually returns the current one.
@@ -2539,7 +2558,6 @@ static int clk_leaf_mux_set_rate_parent_test_init(struct kunit *test) {struct clk_leaf_mux_ctx *ctx; -const char *top_parents[2 ] = {"parent-0" ,"parent-1" };int ret; ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL );
@@ -2547,27 +2565,11 @@ clk_leaf_mux_set_rate_parent_test_init(struct kunit *test)return -ENOMEM ; test->priv = ctx; - ctx->mux_ctx.parents_ctx[0 ].hw.init =CLK_HW_INIT_NO_PARENT ("parent-0" , - &clk_dummy_rate_ops, -0 ); - ctx->mux_ctx.parents_ctx[0 ].rate =DUMMY_CLOCK_RATE_1 ; - ret =clk_hw_register (NULL , &ctx->mux_ctx.parents_ctx[0 ].hw); -if (ret) -return ret; - - ctx->mux_ctx.parents_ctx[1 ].hw.init =CLK_HW_INIT_NO_PARENT ("parent-1" , - &clk_dummy_rate_ops, -0 ); - ctx->mux_ctx.parents_ctx[1 ].rate =DUMMY_CLOCK_RATE_2 ; - ret =clk_hw_register (NULL , &ctx->mux_ctx.parents_ctx[1 ].hw); -if (ret) -return ret; - - ctx->mux_ctx.current_parent =0 ; - ctx->mux_ctx.hw.init =CLK_HW_INIT_PARENTS ("test-mux" , top_parents, - &clk_multiple_parents_mux_ops, -0 ); - ret =clk_hw_register (NULL , &ctx->mux_ctx.hw); + ret =clk_init_multiple_parent_ctx (test, &ctx->mux_ctx, +"parent-0" ,DUMMY_CLOCK_RATE_1 , +"parent-1" ,DUMMY_CLOCK_RATE_2 , +"test-mux" ,0 , + &clk_multiple_parents_mux_ops);if (ret)return ret;
@@ -2755,7 +2757,6 @@ static int clk_mux_notifier_callback(struct notifier_block *nb,static int clk_mux_notifier_test_init (struct kunit *test) {struct clk_mux_notifier_ctx *ctx; -const char *top_parents[2 ] = {"parent-0" ,"parent-1" };int ret; ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL );
@@ -2766,27 +2767,11 @@ static int clk_mux_notifier_test_init(struct kunit *test)init_waitqueue_head (&ctx->pre_rate_change.wq);init_waitqueue_head (&ctx->post_rate_change.wq); - ctx->mux_ctx.parents_ctx[0 ].hw.init =CLK_HW_INIT_NO_PARENT ("parent-0" , - &clk_dummy_rate_ops, -0 ); - ctx->mux_ctx.parents_ctx[0 ].rate =DUMMY_CLOCK_RATE_1 ; - ret =clk_hw_register (NULL , &ctx->mux_ctx.parents_ctx[0 ].hw); -if (ret) -return ret; - - ctx->mux_ctx.parents_ctx[1 ].hw.init =CLK_HW_INIT_NO_PARENT ("parent-1" , - &clk_dummy_rate_ops, -0 ); - ctx->mux_ctx.parents_ctx[1 ].rate =DUMMY_CLOCK_RATE_2 ; - ret =clk_hw_register (NULL , &ctx->mux_ctx.parents_ctx[1 ].hw); -if (ret) -return ret; - - ctx->mux_ctx.current_parent =0 ; - ctx->mux_ctx.hw.init =CLK_HW_INIT_PARENTS ("test-mux" , top_parents, - &clk_multiple_parents_mux_ops, -0 ); - ret =clk_hw_register (NULL , &ctx->mux_ctx.hw); + ret =clk_init_multiple_parent_ctx (test, &ctx->mux_ctx, +"parent-0" ,DUMMY_CLOCK_RATE_1 , +"parent-1" ,DUMMY_CLOCK_RATE_2 , +"test-mux" ,0 , + &clk_multiple_parents_mux_ops);if (ret)return ret;
@@ -2869,39 +2854,17 @@ static int clk_mux_no_reparent_test_init(struct kunit *test) {struct clk_multiple_parent_ctx *ctx; -const char *parents[2 ] = {"parent-0" ,"parent-1" }; -int ret; ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL );if (!ctx)return -ENOMEM ; test->priv = ctx; - ctx->parents_ctx[0 ].hw.init =CLK_HW_INIT_NO_PARENT ("parent-0" , - &clk_dummy_rate_ops, -0 ); - ctx->parents_ctx[0 ].rate =DUMMY_CLOCK_RATE_1 ; - ret =clk_hw_register (NULL , &ctx->parents_ctx[0 ].hw); -if (ret) -return ret; - - ctx->parents_ctx[1 ].hw.init =CLK_HW_INIT_NO_PARENT ("parent-1" , - &clk_dummy_rate_ops, -0 ); - ctx->parents_ctx[1 ].rate =DUMMY_CLOCK_RATE_2 ; - ret =clk_hw_register (NULL , &ctx->parents_ctx[1 ].hw); -if (ret) -return ret; - - ctx->current_parent =0 ; - ctx->hw.init =CLK_HW_INIT_PARENTS ("test-mux" , parents, - &clk_multiple_parents_no_reparent_mux_ops, -0 ); - ret =clk_hw_register (NULL , &ctx->hw); -if (ret) -return ret; - -return 0 ; +return clk_init_multiple_parent_ctx (test, ctx, +"parent-0" ,DUMMY_CLOCK_RATE_1 , +"parent-1" ,DUMMY_CLOCK_RATE_2 , +"test-mux" ,0 , + &clk_multiple_parents_no_reparent_mux_ops); } static void
Signature · 1 line
2.50.1
PATCH v3 8/9 clk: test: introduce test variation for sibling rate changes on a mux
In reply to Brian MasneyIntroduce a test variation that creates a parent with two children: a divider and a mux. Ensure that changing the rate of the divider does not affect the rate of the mux.
--- drivers/clk/clk_test.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+)
drivers/clk/clk_test.c +45 -0
@@ -906,6 +906,47 @@ clk_rate_change_sibling_div_gate_test_init(struct kunit *test)return &ctx->clk_ctx; } +struct clk_rate_change_sibling_div_mux_sibling_context { +struct clk_dummy_div child1; +struct clk_multiple_parent_ctx child2_mux; +struct clk_test_rate_change_sibling_clk_ctx clk_ctx; +}; + +static struct clk_test_rate_change_sibling_clk_ctx * +clk_rate_change_sibling_div_mux_test_init (struct kunit *test) +{ +struct clk_rate_change_sibling_div_mux_sibling_context *ctx; +int ret; + + ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL ); +if (!ctx) +return ERR_PTR (-ENOMEM ); + test->priv = ctx; + + ret =clk_init_multiple_parent_ctx (test, &ctx->child2_mux, +"parent0" ,clk_dummy_rate_mhz (24 ), +"parent1" ,clk_dummy_rate_mhz (48 ), +"child2" ,CLK_SET_RATE_NO_REPARENT , + &clk_multiple_parents_mux_ops); +if (ret) +return ERR_PTR (ret); + + ctx->child1.hw.init =CLK_HW_INIT_HW ("child1" , &ctx->child2_mux.parents_ctx[0 ].hw, + &clk_dummy_div_ops,CLK_SET_RATE_PARENT ); + ctx->child1.div =1 ; + ret =clk_hw_register_kunit (test,NULL , &ctx->child1.hw); +if (ret) +return ERR_PTR (ret); + +KUNIT_ASSERT_EQ (test, ret,0 ); + + ctx->clk_ctx.parent_clk =clk_hw_get_clk (&ctx->child2_mux.parents_ctx[0 ].hw,NULL ); + ctx->clk_ctx.child1_clk =clk_hw_get_clk (&ctx->child1.hw,NULL ); + ctx->clk_ctx.child2_clk =clk_hw_get_clk (&ctx->child2_mux.hw,NULL ); + +return &ctx->clk_ctx; +} +struct clk_test_rate_change_sibling_test_case {const char *desc;struct clk_test_rate_change_sibling_clk_ctx *(*init)(struct kunit *test);
@@ -916,6 +957,10 @@ static struct clk_test_rate_change_sibling_test_case clk_test_rate_change_siblin .desc = "div_gate", .init = clk_rate_change_sibling_div_gate_test_init, }, + { + .desc = "div_mux", + .init = clk_rate_change_sibling_div_mux_test_init, + }, }; KUNIT_ARRAY_PARAM_DESC(clk_test_rate_change_sibling_test_case,
Signature · 1 line
2.50.1
PATCH v3 9/9 clk: test: introduce test variation for sibling rate changes on a gate/mux
In reply to Brian MasneyIntroduce a test variation that creates a parent with two children: a gate and a mux. Ensure that changing the rate of the gate does not affect the rate of the mux.
--- drivers/clk/clk_test.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+)
drivers/clk/clk_test.c +44 -0
@@ -947,6 +947,46 @@ clk_rate_change_sibling_div_mux_test_init(struct kunit *test)return &ctx->clk_ctx; } +struct clk_rate_change_sibling_gate_mux_sibling_context { +struct clk_dummy_gate child1; +struct clk_multiple_parent_ctx child2_mux; +struct clk_test_rate_change_sibling_clk_ctx clk_ctx; +}; + +static struct clk_test_rate_change_sibling_clk_ctx * +clk_rate_change_sibling_gate_mux_test_init (struct kunit *test) +{ +struct clk_rate_change_sibling_gate_mux_sibling_context *ctx; +int ret; + + ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL ); +if (!ctx) +return ERR_PTR (-ENOMEM ); + test->priv = ctx; + + ret =clk_init_multiple_parent_ctx (test, &ctx->child2_mux, +"parent0" ,clk_dummy_rate_mhz (24 ), +"parent1" ,clk_dummy_rate_mhz (48 ), +"child2" ,CLK_SET_RATE_NO_REPARENT , + &clk_multiple_parents_mux_ops); +if (ret) +return ERR_PTR (ret); + + ctx->child1.hw.init =CLK_HW_INIT_HW ("child1" , &ctx->child2_mux.parents_ctx[0 ].hw, + &clk_dummy_gate_ops,CLK_SET_RATE_PARENT ); + ret =clk_hw_register_kunit (test,NULL , &ctx->child1.hw); +if (ret) +return ERR_PTR (ret); + +KUNIT_ASSERT_EQ (test, ret,0 ); + + ctx->clk_ctx.parent_clk =clk_hw_get_clk (&ctx->child2_mux.parents_ctx[0 ].hw,NULL ); + ctx->clk_ctx.child1_clk =clk_hw_get_clk (&ctx->child1.hw,NULL ); + ctx->clk_ctx.child2_clk =clk_hw_get_clk (&ctx->child2_mux.hw,NULL ); + +return &ctx->clk_ctx; +} +struct clk_test_rate_change_sibling_test_case {const char *desc;struct clk_test_rate_change_sibling_clk_ctx *(*init)(struct kunit *test);
@@ -961,6 +1001,10 @@ static struct clk_test_rate_change_sibling_test_case clk_test_rate_change_siblin .desc = "div_mux", .init = clk_rate_change_sibling_div_mux_test_init, }, + { + .desc = "gate_mux", + .init = clk_rate_change_sibling_gate_mux_test_init, + }, }; KUNIT_ARRAY_PARAM_DESC(clk_test_rate_change_sibling_test_case,
Signature · 1 line
2.50.1