Skip to contentSkip to conversation

clk: gate: Add some kunit test suites

PATCH Superseded Stephen Boyd 2 participants 4 messages Jan 15, 2022 – Jan 19, 2022 Common clk

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Stephen Boyd

author maintainer
#0 lore raw

PATCH 1/1 clk: gate: Add some kunit test suites

Test various parts of the clk gate implementation with the kunit testing framework.

---

This is a resend of the RFC[1] from almost two years ago! It will be merged after the merge window closes.

[1] https://lore.kernel.org/r/[email protected]

 drivers/clk/Kconfig         |   8 +
 drivers/clk/Makefile        |   1 +
 drivers/clk/clk-gate-test.c | 481 ++++++++++++++++++++++++++++++++++++
 3 files changed, 490 insertions(+)
 create mode 100644 drivers/clk/clk-gate-test.c
drivers/clk/Kconfig +8 -0
index c5b3dc97396a..41e560249370 100644
@@ -421,4 +421,12 @@ source "drivers/clk/x86/Kconfig"
 source "drivers/clk/xilinx/Kconfig"
 source "drivers/clk/zynqmp/Kconfig"
 
+# Kunit test cases
+config CLK_GATE_TEST
+	tristate "Basic gate type Kunit test"
+	depends on KUNIT
+	default KUNIT
+	help
+	  Kunit test for the basic clk gate type.
+
 endif
drivers/clk/Makefile +1 -0
index e42312121e51..dcdb75712940 100644
@@ -6,6 +6,7 @@ obj-$(CONFIG_COMMON_CLK)	+= clk-divider.o
 obj-$(CONFIG_COMMON_CLK)	+= clk-fixed-factor.o
 obj-$(CONFIG_COMMON_CLK)	+= clk-fixed-rate.o
 obj-$(CONFIG_COMMON_CLK)	+= clk-gate.o
+obj-$(CONFIG_CLK_GATE_TEST)	+= clk-gate-test.o
 obj-$(CONFIG_COMMON_CLK)	+= clk-multiplier.o
 obj-$(CONFIG_COMMON_CLK)	+= clk-mux.o
 obj-$(CONFIG_COMMON_CLK)	+= clk-composite.o
drivers/clk/clk-gate-test.c new file +481 -0

481 lines not on this page · raw message

Signature · 2 lines
https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/
https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git
Acked-by on v1 1/1
#1 lore raw
Quoted 7 lines · Stephen Boyd

Test various parts of the clk gate implementation with the kunit testing framework.

Nice!
Some minor nits and suggestions re kunit usage below.

Quoted 18 lines

---

This is a resend of the RFC[1] from almost two years ago! It will be merged after the merge window closes.

[1] https://lore.kernel.org/r/[email protected]

 drivers/clk/Kconfig         |   8 +
 drivers/clk/Makefile        |   1 +
 drivers/clk/clk-gate-test.c | 481 ++++++++++++++++++++++++++++++++++++
 3 files changed, 490 insertions(+)
 create mode 100644 drivers/clk/clk-gate-test.c
drivers/clk/Kconfig +0 -0
index c5b3dc97396a..41e560249370 100644

drivers/clk/Kconfig source "drivers/clk/x86/Kconfig" · line 430

Quoted 10 lines
drivers/clk/Kconfig +7 -0
@@ -421,4 +421,12 @@ source "drivers/clk/x86/Kconfig"
 source "drivers/clk/xilinx/Kconfig"
 source "drivers/clk/zynqmp/Kconfig"
 
+# Kunit test cases
+config CLK_GATE_TEST
+       tristate "Basic gate type Kunit test"
+       depends on KUNIT
+       default KUNIT
+       help
+         Kunit test for the basic clk gate type.

minor nit: since the previous version, there is now
https://www.kernel.org/doc/html/latest/dev-tools/kunit/style.html#test-kconfig-entries

so something like:
config CLK_GATE_KUNIT_TEST
tristate "Basic gate type KUnit test" if !KUNIT_ALL_TESTS depends on KUNIT
default KUNIT_ALL_TESTS
...

would be the way to go.

On a related note, you could add a .kunitconfig file to make running this easier:

$ cat drivers/clk/.kunitconfig
CONFIG_KUNIT=y
CONFIG_COMMON_CLK=y
CONFIG_CLK_GATE_TEST=y
$ ./tools/testing/kunit/kunit.py run --kunitconfig=drivers/clk
...
Testing complete. Passed: 17, Failed: 0, Crashed: 0, Skipped: 0, Errors: 0

There's not much in the way of dependencies here so it doesn't help that much. But it is an option if you want a one-liner way to be able to run the test.

drivers/clk/clk-gate-test.c

Quoted 19 lines
drivers/clk/Kconfig +1 -0
+
 endif
drivers/clk/Makefile +1 -0
index e42312121e51..dcdb75712940 100644
@@ -6,6 +6,7 @@ obj-$(CONFIG_COMMON_CLK)        += clk-divider.o
 obj-$(CONFIG_COMMON_CLK)       += clk-fixed-factor.o
 obj-$(CONFIG_COMMON_CLK)       += clk-fixed-rate.o
 obj-$(CONFIG_COMMON_CLK)       += clk-gate.o
+obj-$(CONFIG_CLK_GATE_TEST)    += clk-gate-test.o
 obj-$(CONFIG_COMMON_CLK)       += clk-multiplier.o
 obj-$(CONFIG_COMMON_CLK)       += clk-mux.o
 obj-$(CONFIG_COMMON_CLK)       += clk-composite.o
drivers/clk/clk-gate-test.c new file +0 -0
new file mode 100644
index 000000000000..b499c2ffa815

again a minor nit: clk_gate_test.c or clk_gate_kunit.c would be the preferred names now:
https://www.kernel.org/doc/html/latest/dev-tools/kunit/style.html#test-kconfig-entries

Note that KUnit itself doesn't follow its own naming guidelines unfortunately.

Quoted 12 lines
drivers/clk/clk-gate-test.c new file +11 -0
@@ -0,0 +1,481 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Kunit test for clk gate basic type
+ */
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/platform_device.h>
+
+#include <kunit/test.h>
+
+static void clk_gate_register_test_dev(struct kunit *test)

drivers/clk/clk-gate-test.c line 21

Quoted 10 lines
drivers/clk/clk-gate-test.c new file +10 -0
+{
+       struct clk_hw *ret;
+       struct platform_device *pdev;
+
+       pdev = platform_device_register_simple("test_gate_device", -1, NULL, 0);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
+
+       ret = clk_hw_register_gate(&pdev->dev, "test_gate", NULL, 0, NULL,
+                                  0, 0, NULL);
+       KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ret);

I think we want ASSERT here, otherwise we segfault below.

Quoted 110 lines
drivers/clk/clk-gate-test.c new file +110 -0
+       KUNIT_EXPECT_STREQ(test, "test_gate", clk_hw_get_name(ret));
+       KUNIT_EXPECT_EQ(test, 0UL, clk_hw_get_flags(ret));
+
+       clk_hw_unregister_gate(ret);
+       platform_device_put(pdev);
+}
+
+static void clk_gate_register_test_parent_names(struct kunit *test)
+{
+       struct clk_hw *parent;
+       struct clk_hw *ret;
+
+       parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, 0,
+                                           1000000);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+
+       ret = clk_hw_register_gate(NULL, "test_gate", "test_parent", 0, NULL,
+                                  0, 0, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret);
+       KUNIT_EXPECT_PTR_EQ(test, parent, clk_hw_get_parent(ret));
+
+       clk_hw_unregister_gate(ret);
+       clk_hw_unregister_fixed_rate(parent);
+}
+
+static void clk_gate_register_test_parent_data(struct kunit *test)
+{
+       struct clk_hw *parent;
+       struct clk_hw *ret;
+       struct clk_parent_data pdata = { };
+
+       parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, 0,
+                                           1000000);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+       pdata.hw = parent;
+
+       ret = clk_hw_register_gate_parent_data(NULL, "test_gate", &pdata, 0,
+                                              NULL, 0, 0, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret);
+       KUNIT_EXPECT_PTR_EQ(test, parent, clk_hw_get_parent(ret));
+
+       clk_hw_unregister_gate(ret);
+       clk_hw_unregister_fixed_rate(parent);
+}
+
+static void clk_gate_register_test_parent_data_legacy(struct kunit *test)
+{
+       struct clk_hw *parent;
+       struct clk_hw *ret;
+       struct clk_parent_data pdata = { };
+
+       parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, 0,
+                                           1000000);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+       pdata.name = "test_parent";
+
+       ret = clk_hw_register_gate_parent_data(NULL, "test_gate", &pdata, 0,
+                                              NULL, 0, 0, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret);
+       KUNIT_EXPECT_PTR_EQ(test, parent, clk_hw_get_parent(ret));
+
+       clk_hw_unregister_gate(ret);
+       clk_hw_unregister_fixed_rate(parent);
+}
+
+static void clk_gate_register_test_parent_hw(struct kunit *test)
+{
+       struct clk_hw *parent;
+       struct clk_hw *ret;
+
+       parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, 0,
+                                           1000000);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+
+       ret = clk_hw_register_gate_parent_hw(NULL, "test_gate", parent, 0, NULL,
+                                            0, 0, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret);
+       KUNIT_EXPECT_PTR_EQ(test, parent, clk_hw_get_parent(ret));
+
+       clk_hw_unregister_gate(ret);
+       clk_hw_unregister_fixed_rate(parent);
+}
+
+static void clk_gate_register_test_hiword_invalid(struct kunit *test)
+{
+       struct clk_hw *ret;
+
+       ret = clk_hw_register_gate(NULL, "test_gate", NULL, 0, NULL,
+                                  20, CLK_GATE_HIWORD_MASK, NULL);
+
+       KUNIT_EXPECT_TRUE(test, IS_ERR(ret));
+}
+
+static struct kunit_case clk_gate_register_test_cases[] = {
+       KUNIT_CASE(clk_gate_register_test_dev),
+       KUNIT_CASE(clk_gate_register_test_parent_names),
+       KUNIT_CASE(clk_gate_register_test_parent_data),
+       KUNIT_CASE(clk_gate_register_test_parent_data_legacy),
+       KUNIT_CASE(clk_gate_register_test_parent_hw),
+       KUNIT_CASE(clk_gate_register_test_hiword_invalid),
+       {}
+};
+
+static struct kunit_suite clk_gate_register_test_suite = {
+       .name = "clk-gate-register-test",
+       .test_cases = clk_gate_register_test_cases,
+};
+
+struct clk_gate_test_context {
+       void __iomem *fake_mem;

drivers/clk/clk-gate-test.c line 141

Quoted 10 lines
drivers/clk/clk-gate-test.c new file +10 -0
+       struct clk_hw *hw;
+       struct clk_hw *parent;
+       u32 fake_reg; /* Keep at end, KASAN can detect out of bounds */
+};
+
+static struct clk_gate_test_context *clk_gate_test_alloc_ctx(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx;
+
+       test->priv = ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);

It looks like kunit_kzalloc() here would work as well. It should also be a bit safer, i.e. we won't leak ctx if clk_hw_register_fixed_rate() errors out in the init func.

Quoted 18 lines
drivers/clk/clk-gate-test.c new file +18 -0
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
+       ctx->fake_mem = (void __force __iomem *)&ctx->fake_reg;
+
+       return ctx;
+}
+
+static void clk_gate_test_parent_rate(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       unsigned long prate = clk_hw_get_rate(parent);
+       unsigned long rate = clk_hw_get_rate(hw);
+
+       KUNIT_EXPECT_EQ(test, prate, rate);
+}
+
+static void clk_gate_test_enable(struct kunit *test)

drivers/clk/clk-gate-test.c line 169

Quoted 10 lines
drivers/clk/clk-gate-test.c new file +10 -0
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       struct clk *clk = hw->clk;
+       int ret;
+       u32 enable_val = BIT(5);
+
+       ret = clk_prepare_enable(clk);
+       KUNIT_ASSERT_EQ(test, ret, 0);

optional: in the cases where it's short enough, I'd personally favor KUNIT_ASSERT_EQ(test, clk_prepare_enable(clk), 0);

That way we get more context in the assertion failure messages.

Quoted 320 lines
drivers/clk/clk-gate-test.c new file +312 -1
+
+       KUNIT_EXPECT_EQ(test, enable_val, ctx->fake_reg);
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(hw));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(hw));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(parent));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(parent));
+}
+
+static void clk_gate_test_disable(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       struct clk *clk = hw->clk;
+       int ret;
+       u32 enable_val = BIT(5);
+       u32 disable_val = 0;
+
+       ret = clk_prepare_enable(clk);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+       KUNIT_ASSERT_EQ(test, enable_val, ctx->fake_reg);
+
+       clk_disable_unprepare(clk);
+       KUNIT_EXPECT_EQ(test, disable_val, ctx->fake_reg);
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(hw));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(hw));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(parent));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(parent));
+}
+
+static struct kunit_case clk_gate_test_cases[] = {
+       KUNIT_CASE(clk_gate_test_parent_rate),
+       KUNIT_CASE(clk_gate_test_enable),
+       KUNIT_CASE(clk_gate_test_disable),
+       {}
+};
+
+static int clk_gate_test_init(struct kunit *test)
+{
+       struct clk_hw *parent;
+       struct clk_hw *hw;
+       struct clk_gate_test_context *ctx;
+
+       ctx = clk_gate_test_alloc_ctx(test);
+       parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, 0,
+                                           2000000);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+
+       hw = clk_hw_register_gate_parent_hw(NULL, "test_gate", parent, 0,
+                                           ctx->fake_mem, 5, 0, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
+
+       ctx->hw = hw;
+       ctx->parent = parent;
+
+       return 0;
+}
+
+static void clk_gate_test_exit(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+
+       clk_hw_unregister_gate(ctx->hw);
+       clk_hw_unregister_fixed_rate(ctx->parent);
+       kfree(ctx);
+}
+
+static struct kunit_suite clk_gate_test_suite = {
+       .name = "clk-gate-test",
+       .init = clk_gate_test_init,
+       .exit = clk_gate_test_exit,
+       .test_cases = clk_gate_test_cases,
+};
+
+static void clk_gate_test_invert_enable(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       struct clk *clk = hw->clk;
+       int ret;
+       u32 enable_val = 0;
+
+       ret = clk_prepare_enable(clk);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+
+       KUNIT_EXPECT_EQ(test, enable_val, ctx->fake_reg);
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(hw));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(hw));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(parent));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(parent));
+}
+
+static void clk_gate_test_invert_disable(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       struct clk *clk = hw->clk;
+       int ret;
+       u32 enable_val = 0;
+       u32 disable_val = BIT(15);
+
+       ret = clk_prepare_enable(clk);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+       KUNIT_ASSERT_EQ(test, enable_val, ctx->fake_reg);
+
+       clk_disable_unprepare(clk);
+       KUNIT_EXPECT_EQ(test, disable_val, ctx->fake_reg);
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(hw));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(hw));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(parent));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(parent));
+}
+
+static struct kunit_case clk_gate_test_invert_cases[] = {
+       KUNIT_CASE(clk_gate_test_invert_enable),
+       KUNIT_CASE(clk_gate_test_invert_disable),
+       {}
+};
+
+static int clk_gate_test_invert_init(struct kunit *test)
+{
+       struct clk_hw *parent;
+       struct clk_hw *hw;
+       struct clk_gate_test_context *ctx;
+
+       ctx = clk_gate_test_alloc_ctx(test);
+       parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, 0,
+                                           2000000);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+
+       ctx->fake_reg = BIT(15); /* Default to off */
+       hw = clk_hw_register_gate_parent_hw(NULL, "test_gate", parent, 0,
+                                           ctx->fake_mem, 15,
+                                           CLK_GATE_SET_TO_DISABLE, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
+
+       ctx->hw = hw;
+       ctx->parent = parent;
+
+       return 0;
+}
+
+static struct kunit_suite clk_gate_test_invert_suite = {
+       .name = "clk-gate-invert-test",
+       .init = clk_gate_test_invert_init,
+       .exit = clk_gate_test_exit,
+       .test_cases = clk_gate_test_invert_cases,
+};
+
+static void clk_gate_test_hiword_enable(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       struct clk *clk = hw->clk;
+       int ret;
+       u32 enable_val = BIT(9) | BIT(9 + 16);
+
+       ret = clk_prepare_enable(clk);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+
+       KUNIT_EXPECT_EQ(test, enable_val, ctx->fake_reg);
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(hw));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(hw));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(parent));
+       KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(parent));
+}
+
+static void clk_gate_test_hiword_disable(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       struct clk *clk = hw->clk;
+       int ret;
+       u32 enable_val = BIT(9) | BIT(9 + 16);
+       u32 disable_val = BIT(9 + 16);
+
+       ret = clk_prepare_enable(clk);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+       KUNIT_ASSERT_EQ(test, enable_val, ctx->fake_reg);
+
+       clk_disable_unprepare(clk);
+       KUNIT_EXPECT_EQ(test, disable_val, ctx->fake_reg);
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(hw));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(hw));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(parent));
+       KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(parent));
+}
+
+static struct kunit_case clk_gate_test_hiword_cases[] = {
+       KUNIT_CASE(clk_gate_test_hiword_enable),
+       KUNIT_CASE(clk_gate_test_hiword_disable),
+       {}
+};
+
+static int clk_gate_test_hiword_init(struct kunit *test)
+{
+       struct clk_hw *parent;
+       struct clk_hw *hw;
+       struct clk_gate_test_context *ctx;
+
+       ctx = clk_gate_test_alloc_ctx(test);
+       parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, 0,
+                                           2000000);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
+
+       hw = clk_hw_register_gate_parent_hw(NULL, "test_gate", parent, 0,
+                                           ctx->fake_mem, 9,
+                                           CLK_GATE_HIWORD_MASK, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
+
+       ctx->hw = hw;
+       ctx->parent = parent;
+
+       return 0;
+}
+
+static struct kunit_suite clk_gate_test_hiword_suite = {
+       .name = "clk-gate-hiword-test",
+       .init = clk_gate_test_hiword_init,
+       .exit = clk_gate_test_exit,
+       .test_cases = clk_gate_test_hiword_cases,
+};
+
+static void clk_gate_test_is_enabled(struct kunit *test)
+{
+       struct clk_hw *hw;
+       struct clk_gate_test_context *ctx;
+
+       ctx = clk_gate_test_alloc_ctx(test);
+       ctx->fake_reg = BIT(7);
+       hw = clk_hw_register_gate(NULL, "test_gate", NULL, 0, ctx->fake_mem, 7,
+                                 0, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
+       KUNIT_ASSERT_TRUE(test, clk_hw_is_enabled(hw));
+
+       clk_hw_unregister_gate(hw);
+       kfree(ctx);
+}
+
+static void clk_gate_test_is_disabled(struct kunit *test)
+{
+       struct clk_hw *hw;
+       struct clk_gate_test_context *ctx;
+
+       ctx = clk_gate_test_alloc_ctx(test);
+       ctx->fake_reg = BIT(4);
+       hw = clk_hw_register_gate(NULL, "test_gate", NULL, 0, ctx->fake_mem, 7,
+                                 0, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
+       KUNIT_ASSERT_FALSE(test, clk_hw_is_enabled(hw));
+
+       clk_hw_unregister_gate(hw);
+       kfree(ctx);
+}
+
+static void clk_gate_test_is_enabled_inverted(struct kunit *test)
+{
+       struct clk_hw *hw;
+       struct clk_gate_test_context *ctx;
+
+       ctx = clk_gate_test_alloc_ctx(test);
+       ctx->fake_reg = BIT(31);
+       hw = clk_hw_register_gate(NULL, "test_gate", NULL, 0, ctx->fake_mem, 2,
+                                 CLK_GATE_SET_TO_DISABLE, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
+       KUNIT_ASSERT_TRUE(test, clk_hw_is_enabled(hw));
+
+       clk_hw_unregister_gate(hw);
+       kfree(ctx);
+}
+
+static void clk_gate_test_is_disabled_inverted(struct kunit *test)
+{
+       struct clk_hw *hw;
+       struct clk_gate_test_context *ctx;
+
+       ctx = clk_gate_test_alloc_ctx(test);
+       ctx->fake_reg = BIT(29);
+       hw = clk_hw_register_gate(NULL, "test_gate", NULL, 0, ctx->fake_mem, 29,
+                                 CLK_GATE_SET_TO_DISABLE, NULL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
+       KUNIT_ASSERT_FALSE(test, clk_hw_is_enabled(hw));
+
+       clk_hw_unregister_gate(hw);
+       kfree(ctx);
+}
+
+static struct kunit_case clk_gate_test_enabled_cases[] = {
+       KUNIT_CASE(clk_gate_test_is_enabled),
+       KUNIT_CASE(clk_gate_test_is_disabled),
+       KUNIT_CASE(clk_gate_test_is_enabled_inverted),
+       KUNIT_CASE(clk_gate_test_is_disabled_inverted),
+       {}
+};
+
+static struct kunit_suite clk_gate_test_enabled_suite = {
+       .name = "clk-gate-is_enabled-test",
+       .test_cases = clk_gate_test_enabled_cases,
+};
+
+kunit_test_suites(
+       &clk_gate_register_test_suite,
+       &clk_gate_test_suite,
+       &clk_gate_test_invert_suite,
+       &clk_gate_test_hiword_suite,
+       &clk_gate_test_enabled_suite
+);
+MODULE_LICENSE("GPL v2");
--

https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/
https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git

--
You received this message because you are subscribed to the Google Groups "KUnit Development" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To view this discussion on the web visit https://groups.google.com/d/msgid/kunit-dev/20220115080657.2780989-1-sboyd%40kernel.org.

author maintainer
#2 lore raw

Quoting Daniel Latypov (2022-01-15 13:48:42)

Quoted 46 lines · Stephen Boyd
Quoted 7 lines

Test various parts of the clk gate implementation with the kunit testing framework.

Nice!
Some minor nits and suggestions re kunit usage below.

Quoted 18 lines

---

This is a resend of the RFC[1] from almost two years ago! It will be merged after the merge window closes.

[1] https://lore.kernel.org/r/[email protected]

 drivers/clk/Kconfig         |   8 +
 drivers/clk/Makefile        |   1 +
 drivers/clk/clk-gate-test.c | 481 ++++++++++++++++++++++++++++++++++++
 3 files changed, 490 insertions(+)
 create mode 100644 drivers/clk/clk-gate-test.c
drivers/clk/Kconfig +0 -0
index c5b3dc97396a..41e560249370 100644

drivers/clk/Kconfig source "drivers/clk/x86/Kconfig" · line 430

Quoted 10 lines
drivers/clk/Kconfig +7 -0
@@ -421,4 +421,12 @@ source "drivers/clk/x86/Kconfig"
 source "drivers/clk/xilinx/Kconfig"
 source "drivers/clk/zynqmp/Kconfig"
 
+# Kunit test cases
+config CLK_GATE_TEST
+       tristate "Basic gate type Kunit test"
+       depends on KUNIT
+       default KUNIT
+       help
+         Kunit test for the basic clk gate type.

minor nit: since the previous version, there is now
https://www.kernel.org/doc/html/latest/dev-tools/kunit/style.html#test-kconfig-entries

Quoted 8 lines

so something like:
config CLK_GATE_KUNIT_TEST
tristate "Basic gate type KUnit test" if !KUNIT_ALL_TESTS depends on KUNIT
default KUNIT_ALL_TESTS
...

would be the way to go.

Got it. Thanks!

Quoted 7 lines

On a related note, you could add a .kunitconfig file to make running this easier:

$ cat drivers/clk/.kunitconfig
CONFIG_KUNIT=y
CONFIG_COMMON_CLK=y
CONFIG_CLK_GATE_TEST=y

Sure that works for me. I was using my own kunitconfig file and then running all 'clk*' tests. This would make it easier I suppose. Too bad the pattern match can't figure out what dependencies to enable.

Quoted 32 lines
$ ./tools/testing/kunit/kunit.py run --kunitconfig=drivers/clk
...
Testing complete. Passed: 17, Failed: 0, Crashed: 0, Skipped: 0, Errors: 0

There's not much in the way of dependencies here so it doesn't help that much. But it is an option if you want a one-liner way to be able to run the test.

drivers/clk/clk-gate-test.c

Quoted 19 lines
drivers/clk/Kconfig +1 -0
+
 endif
drivers/clk/Makefile +1 -0
index e42312121e51..dcdb75712940 100644
@@ -6,6 +6,7 @@ obj-$(CONFIG_COMMON_CLK)        += clk-divider.o
 obj-$(CONFIG_COMMON_CLK)       += clk-fixed-factor.o
 obj-$(CONFIG_COMMON_CLK)       += clk-fixed-rate.o
 obj-$(CONFIG_COMMON_CLK)       += clk-gate.o
+obj-$(CONFIG_CLK_GATE_TEST)    += clk-gate-test.o
 obj-$(CONFIG_COMMON_CLK)       += clk-multiplier.o
 obj-$(CONFIG_COMMON_CLK)       += clk-mux.o
 obj-$(CONFIG_COMMON_CLK)       += clk-composite.o
drivers/clk/clk-gate-test.c new file +0 -0
new file mode 100644
index 000000000000..b499c2ffa815

again a minor nit: clk_gate_test.c or clk_gate_kunit.c would be the preferred names now:
https://www.kernel.org/doc/html/latest/dev-tools/kunit/style.html#test-kconfig-entries

Quoted 1 line

Note that KUnit itself doesn't follow its own naming guidelines unfortunately.

How about clk-gate_test.c then? I'd like it to match the clk-gate.c file but can support the _test suffix.

Quoted 17 lines
Quoted 17 lines
drivers/clk/clk-gate-test.c new file +15 -0
@@ -0,0 +1,481 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Kunit test for clk gate basic type
+ */
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/platform_device.h>
+
+#include <kunit/test.h>
+
+static void clk_gate_register_test_dev(struct kunit *test)
+{
+       struct clk_hw *ret;
+       struct platform_device *pdev;
+
Quoted 8 lines

drivers/clk/clk-gate-test.c line 21

Quoted 6 lines
drivers/clk/clk-gate-test.c new file +6 -0
+       pdev = platform_device_register_simple("test_gate_device", -1, NULL, 0);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
+
+       ret = clk_hw_register_gate(&pdev->dev, "test_gate", NULL, 0, NULL,
+                                  0, 0, NULL);
+       KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ret);

I think we want ASSERT here, otherwise we segfault below.

Fixed.

Quoted 4 lines
Quoted 4 lines
drivers/clk/clk-gate-test.c new file +3 -0
+       KUNIT_EXPECT_STREQ(test, "test_gate", clk_hw_get_name(ret));
+       KUNIT_EXPECT_EQ(test, 0UL, clk_hw_get_flags(ret));
+

[...]

Quoted 10 lines

drivers/clk/clk-gate-test.c line 141

Quoted 6 lines
drivers/clk/clk-gate-test.c new file +6 -0
+
+static struct clk_gate_test_context *clk_gate_test_alloc_ctx(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx;
+
+       test->priv = ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);

It looks like kunit_kzalloc() here would work as well. It should also be a bit safer, i.e. we won't leak ctx if clk_hw_register_fixed_rate() errors out in the init func.

Ok.

Quoted 33 lines
Quoted 19 lines
drivers/clk/clk-gate-test.c new file +18 -0
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
+       ctx->fake_mem = (void __force __iomem *)&ctx->fake_reg;
+
+       return ctx;
+}
+
+static void clk_gate_test_parent_rate(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       unsigned long prate = clk_hw_get_rate(parent);
+       unsigned long rate = clk_hw_get_rate(hw);
+
+       KUNIT_EXPECT_EQ(test, prate, rate);
+}
+
+static void clk_gate_test_enable(struct kunit *test)

drivers/clk/clk-gate-test.c line 169

Quoted 10 lines
drivers/clk/clk-gate-test.c new file +10 -0
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       struct clk *clk = hw->clk;
+       int ret;
+       u32 enable_val = BIT(5);
+
+       ret = clk_prepare_enable(clk);
+       KUNIT_ASSERT_EQ(test, ret, 0);

optional: in the cases where it's short enough, I'd personally favor KUNIT_ASSERT_EQ(test, clk_prepare_enable(clk), 0);

Quoted 1 line

That way we get more context in the assertion failure messages.

Makes sense.

#3 lore raw
Quoted 103 lines · Stephen Boyd

Quoting Daniel Latypov (2022-01-15 13:48:42)

Quoted 46 lines · Stephen Boyd
Quoted 7 lines

Test various parts of the clk gate implementation with the kunit testing framework.

Nice!
Some minor nits and suggestions re kunit usage below.

Quoted 18 lines

---

This is a resend of the RFC[1] from almost two years ago! It will be merged after the merge window closes.

[1] https://lore.kernel.org/r/[email protected]

 drivers/clk/Kconfig         |   8 +
 drivers/clk/Makefile        |   1 +
 drivers/clk/clk-gate-test.c | 481 ++++++++++++++++++++++++++++++++++++
 3 files changed, 490 insertions(+)
 create mode 100644 drivers/clk/clk-gate-test.c
drivers/clk/Kconfig +0 -0
index c5b3dc97396a..41e560249370 100644

drivers/clk/Kconfig source "drivers/clk/x86/Kconfig" · line 430

Quoted 10 lines
drivers/clk/Kconfig +7 -0
@@ -421,4 +421,12 @@ source "drivers/clk/x86/Kconfig"
 source "drivers/clk/xilinx/Kconfig"
 source "drivers/clk/zynqmp/Kconfig"
 
+# Kunit test cases
+config CLK_GATE_TEST
+       tristate "Basic gate type Kunit test"
+       depends on KUNIT
+       default KUNIT
+       help
+         Kunit test for the basic clk gate type.

minor nit: since the previous version, there is now
https://www.kernel.org/doc/html/latest/dev-tools/kunit/style.html#test-kconfig-entries

Quoted 8 lines

so something like:
config CLK_GATE_KUNIT_TEST
tristate "Basic gate type KUnit test" if !KUNIT_ALL_TESTS depends on KUNIT
default KUNIT_ALL_TESTS
...

would be the way to go.

Got it. Thanks!

Quoted 7 lines

On a related note, you could add a .kunitconfig file to make running this easier:

$ cat drivers/clk/.kunitconfig
CONFIG_KUNIT=y
CONFIG_COMMON_CLK=y
CONFIG_CLK_GATE_TEST=y

Sure that works for me. I was using my own kunitconfig file and then running all 'clk*' tests. This would make it easier I suppose. Too bad the pattern match can't figure out what dependencies to enable.

Quoted 32 lines
$ ./tools/testing/kunit/kunit.py run --kunitconfig=drivers/clk
...
Testing complete. Passed: 17, Failed: 0, Crashed: 0, Skipped: 0, Errors: 0

There's not much in the way of dependencies here so it doesn't help that much. But it is an option if you want a one-liner way to be able to run the test.

drivers/clk/clk-gate-test.c

Quoted 19 lines
drivers/clk/Kconfig +1 -0
+
 endif
drivers/clk/Makefile +1 -0
index e42312121e51..dcdb75712940 100644
@@ -6,6 +6,7 @@ obj-$(CONFIG_COMMON_CLK)        += clk-divider.o
 obj-$(CONFIG_COMMON_CLK)       += clk-fixed-factor.o
 obj-$(CONFIG_COMMON_CLK)       += clk-fixed-rate.o
 obj-$(CONFIG_COMMON_CLK)       += clk-gate.o
+obj-$(CONFIG_CLK_GATE_TEST)    += clk-gate-test.o
 obj-$(CONFIG_COMMON_CLK)       += clk-multiplier.o
 obj-$(CONFIG_COMMON_CLK)       += clk-mux.o
 obj-$(CONFIG_COMMON_CLK)       += clk-composite.o
drivers/clk/clk-gate-test.c new file +0 -0
new file mode 100644
index 000000000000..b499c2ffa815

again a minor nit: clk_gate_test.c or clk_gate_kunit.c would be the preferred names now:
https://www.kernel.org/doc/html/latest/dev-tools/kunit/style.html#test-kconfig-entries

Quoted 4 lines
Quoted 1 line

Note that KUnit itself doesn't follow its own naming guidelines unfortunately.

How about clk-gate_test.c then? I'd like it to match the clk-gate.c file but can support the _test suffix.

That sounds completely reasonable to me.
I'd say go for it, if no one chimes in w/ any objections.

Quoted 83 lines
Quoted 18 lines
Quoted 18 lines
drivers/clk/clk-gate-test.c new file +15 -0
@@ -0,0 +1,481 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Kunit test for clk gate basic type
+ */
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/platform_device.h>
+
+#include <kunit/test.h>
+
+static void clk_gate_register_test_dev(struct kunit *test)
+{
+       struct clk_hw *ret;
+       struct platform_device *pdev;
+
Quoted 8 lines

drivers/clk/clk-gate-test.c line 21

Quoted 6 lines
drivers/clk/clk-gate-test.c new file +6 -0
+       pdev = platform_device_register_simple("test_gate_device", -1, NULL, 0);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
+
+       ret = clk_hw_register_gate(&pdev->dev, "test_gate", NULL, 0, NULL,
+                                  0, 0, NULL);
+       KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ret);

I think we want ASSERT here, otherwise we segfault below.

Fixed.

Quoted 4 lines
Quoted 4 lines
drivers/clk/clk-gate-test.c new file +3 -0
+       KUNIT_EXPECT_STREQ(test, "test_gate", clk_hw_get_name(ret));
+       KUNIT_EXPECT_EQ(test, 0UL, clk_hw_get_flags(ret));
+

[...]

Quoted 10 lines

drivers/clk/clk-gate-test.c line 141

Quoted 6 lines
drivers/clk/clk-gate-test.c new file +6 -0
+
+static struct clk_gate_test_context *clk_gate_test_alloc_ctx(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx;
+
+       test->priv = ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);

It looks like kunit_kzalloc() here would work as well. It should also be a bit safer, i.e. we won't leak ctx if clk_hw_register_fixed_rate() errors out in the init func.

Ok.

Quoted 33 lines
Quoted 19 lines
drivers/clk/clk-gate-test.c new file +18 -0
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
+       ctx->fake_mem = (void __force __iomem *)&ctx->fake_reg;
+
+       return ctx;
+}
+
+static void clk_gate_test_parent_rate(struct kunit *test)
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       unsigned long prate = clk_hw_get_rate(parent);
+       unsigned long rate = clk_hw_get_rate(hw);
+
+       KUNIT_EXPECT_EQ(test, prate, rate);
+}
+
+static void clk_gate_test_enable(struct kunit *test)

drivers/clk/clk-gate-test.c line 169

Quoted 10 lines
drivers/clk/clk-gate-test.c new file +10 -0
+{
+       struct clk_gate_test_context *ctx = test->priv;
+       struct clk_hw *parent = ctx->parent;
+       struct clk_hw *hw = ctx->hw;
+       struct clk *clk = hw->clk;
+       int ret;
+       u32 enable_val = BIT(5);
+
+       ret = clk_prepare_enable(clk);
+       KUNIT_ASSERT_EQ(test, ret, 0);

optional: in the cases where it's short enough, I'd personally favor KUNIT_ASSERT_EQ(test, clk_prepare_enable(clk), 0);

Quoted 1 line

That way we get more context in the assertion failure messages.

Makes sense.