This patch series adds unit tests for the clk fixed rate basic type and the clk registration functions that use struct clk_parent_data. To get there, we add support for loading device tree overlays onto the live DTB along with probing platform drivers to bind to device nodes in the overlays. With this series, we're able to exercise some of the code in the common clk framework that uses devicetree lookups to find parents and the fixed rate clk code that scans device tree directly and creates clks. Please review.
I Cced everyone to all the patches so they get the full context. I'm hoping I can take the whole pile through the clk tree as they all build upon each other. Or the DT part can be merged through the DT tree to reduce the dependencies.
Changes from v4: https://lore.kernel.org/r/20240422232404.213174-1-sboyd@kernel.org * Picked up reviewed-by tags * Check for non-NULL device pointers before calling put_device() * Fix CFI issues with kunit actions * Introduce platform_device_prepare_wait_for_probe() helper to wait for a platform device to probe * Move platform code to lib/kunit and rename functions to have kunit prefix * Fix issue with platform wrappers messing up reference counting because they used kunit actions * New patch to populate overlay devices on root node for powerpc * Make fixed-rate binding generic single clk consumer binding
Changes from v3: https://lore.kernel.org/r/20230327222159.3509818-1-sboyd@kernel.org * No longer depend on Frank's series[1] because it was merged upstream[2] * Use kunit_add_action_or_reset() to shorten code * Skip tests properly when CONFIG_OF_OVERLAY isn't set
Changes from v2: https://lore.kernel.org/r/20230315183729.2376178-1-sboyd@kernel.org * Overlays don't depend on __symbols__ node * Depend on Frank's always create root node if CONFIG_OF series[1] * Added kernel-doc to KUnit API doc * Fixed some kernel-doc on functions * More test cases for fixed rate clk
Changes from v1: https://lore.kernel.org/r/20230302013822.1808711-1-sboyd@kernel.org * Don't depend on UML, use unittest data approach to attach nodes * Introduce overlay loading API for KUnit * Move platform_device KUnit code to drivers/base/test * Use #define macros for constants shared between unit tests and overlays * Settle on "test" as a vendor prefix * Make KUnit wrappers have "_kunit" postfix
[1] https://lore.kernel.org/r/20230317053415.2254616-1-frowand.list@gmail.com [2] https://lore.kernel.org/r/20240308195737.GA1174908-robh@kernel.org
Stephen Boyd (11): of/platform: Allow overlays to create platform devices from the root node of: Add test managed wrappers for of_overlay_apply()/of_node_put() dt-bindings: vendor-prefixes: Add "test" vendor for KUnit and friends dt-bindings: test: Add KUnit empty node binding of: Add a KUnit test for overlays and test managed APIs platform: Add test managed platform_device/driver APIs dt-bindings: test: Add single clk consumer clk: Add test managed clk provider/consumer APIs clk: Add KUnit tests for clk fixed rate basic type dt-bindings: clk: Add clk_parent_data test clk: Add KUnit tests for clks registered with struct clk_parent_data
Documentation/dev-tools/kunit/api/clk.rst | 10 + Documentation/dev-tools/kunit/api/index.rst | 21 + Documentation/dev-tools/kunit/api/of.rst | 13 + .../dev-tools/kunit/api/platformdevice.rst | 10 + .../bindings/clock/test,clk-parent-data.yaml | 47 ++ .../devicetree/bindings/test/test,empty.yaml | 30 ++ .../test/test,single-clk-consumer.yaml | 34 ++ .../devicetree/bindings/vendor-prefixes.yaml | 2 + drivers/clk/.kunitconfig | 2 + drivers/clk/Kconfig | 9 + drivers/clk/Makefile | 9 +- drivers/clk/clk-fixed-rate_test.c | 379 +++++++++++++++ drivers/clk/clk-fixed-rate_test.h | 8 + drivers/clk/clk_kunit_helpers.c | 204 ++++++++ drivers/clk/clk_parent_data_test.h | 10 + drivers/clk/clk_test.c | 451 +++++++++++++++++- drivers/clk/kunit_clk_fixed_rate_test.dtso | 19 + drivers/clk/kunit_clk_parent_data_test.dtso | 28 ++ drivers/of/.kunitconfig | 1 + drivers/of/Kconfig | 10 + drivers/of/Makefile | 2 + drivers/of/kunit_overlay_test.dtso | 9 + drivers/of/of_kunit_helpers.c | 74 +++ drivers/of/overlay_test.c | 116 +++++ drivers/of/platform.c | 9 +- include/kunit/clk.h | 28 ++ include/kunit/of.h | 115 +++++ include/kunit/platform_device.h | 20 + lib/kunit/Makefile | 4 +- lib/kunit/platform-test.c | 223 +++++++++ lib/kunit/platform.c | 302 ++++++++++++ 31 files changed, 2193 insertions(+), 6 deletions(-) create mode 100644 Documentation/dev-tools/kunit/api/clk.rst create mode 100644 Documentation/dev-tools/kunit/api/of.rst create mode 100644 Documentation/dev-tools/kunit/api/platformdevice.rst create mode 100644 Documentation/devicetree/bindings/clock/test,clk-parent-data.yaml create mode 100644 Documentation/devicetree/bindings/test/test,empty.yaml create mode 100644 Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml create mode 100644 drivers/clk/clk-fixed-rate_test.c create mode 100644 drivers/clk/clk-fixed-rate_test.h create mode 100644 drivers/clk/clk_kunit_helpers.c create mode 100644 drivers/clk/clk_parent_data_test.h create mode 100644 drivers/clk/kunit_clk_fixed_rate_test.dtso create mode 100644 drivers/clk/kunit_clk_parent_data_test.dtso create mode 100644 drivers/of/kunit_overlay_test.dtso create mode 100644 drivers/of/of_kunit_helpers.c create mode 100644 drivers/of/overlay_test.c create mode 100644 include/kunit/clk.h create mode 100644 include/kunit/of.h create mode 100644 include/kunit/platform_device.h create mode 100644 lib/kunit/platform-test.c create mode 100644 lib/kunit/platform.c
base-commit: 1613e604df0cd359cf2a7fbd9be7a0bcfacfabd0
We'd like to apply overlays to the root node in KUnit so we can test platform devices created as children of the root node.
On some architectures (powerpc), the root node isn't marked with OF_POPULATED_BUS. If an overlay tries to modify the root node on these platforms it will fail, while on other platforms, such as ARM, it will succeed. This is because the root node is marked with OF_POPULATED_BUS by of_platform_default_populate_init() calling of_platform_default_populate() with NULL as the first argument.
Loosen the requirement here so that platform devices can be created for nodes created as children of the root node via DT overlays even if the platform bus wasn't populated for the root node.
Cc: Rob Herring robh@kernel.org Cc: Saravana Kannan saravanak@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org --- drivers/of/platform.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
diff --git a/drivers/of/platform.c b/drivers/of/platform.c index 389d4ea6bfc1..bda6da866cc8 100644 --- a/drivers/of/platform.c +++ b/drivers/of/platform.c @@ -732,11 +732,14 @@ static int of_platform_notify(struct notifier_block *nb, struct of_reconfig_data *rd = arg; struct platform_device *pdev_parent, *pdev; bool children_left; + struct device_node *parent;
switch (of_reconfig_get_state_change(action, rd)) { case OF_RECONFIG_CHANGE_ADD: - /* verify that the parent is a bus */ - if (!of_node_check_flag(rd->dn->parent, OF_POPULATED_BUS)) + parent = rd->dn->parent; + /* verify that the parent is a bus (or the root node) */ + if (!of_node_is_root(parent) && + of_node_check_flag(parent, OF_POPULATED_BUS)) return NOTIFY_OK; /* not for us */
/* already populated? (driver using of_populate manually) */ @@ -749,7 +752,7 @@ static int of_platform_notify(struct notifier_block *nb, */ rd->dn->fwnode.flags &= ~FWNODE_FLAG_NOT_DEVICE; /* pdev_parent may be NULL when no bus platform device */ - pdev_parent = of_find_device_by_node(rd->dn->parent); + pdev_parent = of_find_device_by_node(parent); pdev = of_platform_device_create(rd->dn, NULL, pdev_parent ? &pdev_parent->dev : NULL); platform_device_put(pdev_parent);
On Mon, 03 Jun 2024 15:37:58 -0700, Stephen Boyd wrote:
We'd like to apply overlays to the root node in KUnit so we can test platform devices created as children of the root node.
On some architectures (powerpc), the root node isn't marked with OF_POPULATED_BUS. If an overlay tries to modify the root node on these platforms it will fail, while on other platforms, such as ARM, it will succeed. This is because the root node is marked with OF_POPULATED_BUS by of_platform_default_populate_init() calling of_platform_default_populate() with NULL as the first argument.
Loosen the requirement here so that platform devices can be created for nodes created as children of the root node via DT overlays even if the platform bus wasn't populated for the root node.
Cc: Rob Herring robh@kernel.org Cc: Saravana Kannan saravanak@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org
drivers/of/platform.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
Reviewed-by: Rob Herring (Arm) robh@kernel.org
Add test managed wrappers for of_overlay_apply() that automatically removes the overlay when the test is finished. This API is intended for use by KUnit tests that test code which relies on 'struct device_node's and of_*() APIs.
KUnit tests will call of_overlay_apply_kunit() to load an overlay that's been built into the kernel image. When the test is complete, the overlay will be removed.
This has a few benefits:
1) It keeps the tests hermetic because the overlay is removed when the test is complete. Tests won't even be aware that an overlay was loaded in another test.
2) The overlay code can live right next to the unit test that loads it. The overlay and the unit test can be compiled into one kernel module if desired.
3) We can test different device tree configurations by loading different overlays. The overlays can be written for a specific test, and there can be many of them loaded per-test without needing to jam all possible combinations into one DTB.
4) It also allows KUnit to test device tree dependent code on any architecture, not just UML. This allows KUnit tests to test architecture specific device tree code.
There are some potential pitfalls though. Test authors need to be careful to not overwrite properties in the live tree. The easiest way to do this is to add and remove nodes with a 'kunit-' prefix, almost guaranteeing that the same node won't be present in the tree loaded at boot.
Suggested-by: Rob Herring robh@kernel.org Cc: Rob Herring robh@kernel.org Cc: Saravana Kannan saravanak@google.com Reviewed-by: Rob Herring (Arm) robh@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org --- Documentation/dev-tools/kunit/api/index.rst | 11 ++ Documentation/dev-tools/kunit/api/of.rst | 13 +++ drivers/of/Makefile | 1 + drivers/of/of_kunit_helpers.c | 74 +++++++++++++ include/kunit/of.h | 115 ++++++++++++++++++++ 5 files changed, 214 insertions(+) create mode 100644 Documentation/dev-tools/kunit/api/of.rst create mode 100644 drivers/of/of_kunit_helpers.c create mode 100644 include/kunit/of.h
diff --git a/Documentation/dev-tools/kunit/api/index.rst b/Documentation/dev-tools/kunit/api/index.rst index 2d8f756aab56..282befa17edf 100644 --- a/Documentation/dev-tools/kunit/api/index.rst +++ b/Documentation/dev-tools/kunit/api/index.rst @@ -9,11 +9,15 @@ API Reference test resource functionredirection + of
This page documents the KUnit kernel testing API. It is divided into the following sections:
+Core KUnit API +============== + Documentation/dev-tools/kunit/api/test.rst
- Documents all of the standard testing API @@ -25,3 +29,10 @@ Documentation/dev-tools/kunit/api/resource.rst Documentation/dev-tools/kunit/api/functionredirection.rst
- Documents the KUnit Function Redirection API + +Driver KUnit API +================ + +Documentation/dev-tools/kunit/api/of.rst + + - Documents the KUnit device tree (OF) API diff --git a/Documentation/dev-tools/kunit/api/of.rst b/Documentation/dev-tools/kunit/api/of.rst new file mode 100644 index 000000000000..cb4193dcddbb --- /dev/null +++ b/Documentation/dev-tools/kunit/api/of.rst @@ -0,0 +1,13 @@ +.. SPDX-License-Identifier: GPL-2.0 + +==================== +Device Tree (OF) API +==================== + +The KUnit device tree API is used to test device tree (of_*) dependent code. + +.. kernel-doc:: include/kunit/of.h + :internal: + +.. kernel-doc:: drivers/of/of_kunit_helpers.c + :export: diff --git a/drivers/of/Makefile b/drivers/of/Makefile index 251d33532148..2ae909adde49 100644 --- a/drivers/of/Makefile +++ b/drivers/of/Makefile @@ -19,6 +19,7 @@ obj-y += kexec.o endif endif
+obj-$(CONFIG_KUNIT) += of_kunit_helpers.o obj-$(CONFIG_OF_KUNIT_TEST) += of_test.o
obj-$(CONFIG_OF_UNITTEST) += unittest-data/ diff --git a/drivers/of/of_kunit_helpers.c b/drivers/of/of_kunit_helpers.c new file mode 100644 index 000000000000..8a09132e32a8 --- /dev/null +++ b/drivers/of/of_kunit_helpers.c @@ -0,0 +1,74 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Test managed device tree APIs + */ + +#include <linux/of.h> +#include <linux/of_fdt.h> + +#include <kunit/of.h> +#include <kunit/test.h> +#include <kunit/resource.h> + +#if defined(CONFIG_OF_OVERLAY) && defined(CONFIG_OF_EARLY_FLATTREE) + +static void of_overlay_fdt_apply_kunit_exit(void *ovcs_id) +{ + of_overlay_remove(ovcs_id); +} + +/** + * of_overlay_fdt_apply_kunit() - Test managed of_overlay_fdt_apply() + * @test: test context + * @overlay_fdt: device tree overlay to apply + * @overlay_fdt_size: size in bytes of @overlay_fdt + * @ovcs_id: identifier of overlay, used to remove the overlay + * + * Just like of_overlay_fdt_apply(), except the overlay is managed by the test + * case and is automatically removed with of_overlay_remove() after the test + * case concludes. + * + * Return: 0 on success, negative errno on failure + */ +int of_overlay_fdt_apply_kunit(struct kunit *test, void *overlay_fdt, + u32 overlay_fdt_size, int *ovcs_id) +{ + int ret; + int *copy_id; + + copy_id = kunit_kmalloc(test, sizeof(*copy_id), GFP_KERNEL); + if (!copy_id) + return -ENOMEM; + + ret = of_overlay_fdt_apply(overlay_fdt, overlay_fdt_size, + ovcs_id, NULL); + if (ret) + return ret; + + *copy_id = *ovcs_id; + + return kunit_add_action_or_reset(test, of_overlay_fdt_apply_kunit_exit, + copy_id); +} +EXPORT_SYMBOL_GPL(of_overlay_fdt_apply_kunit); + +#endif + +KUNIT_DEFINE_ACTION_WRAPPER(of_node_put_wrapper, of_node_put, struct device_node *); + +/** + * of_node_put_kunit() - Test managed of_node_put() + * @test: test context + * @node: node to pass to `of_node_put()` + * + * Just like of_node_put(), except the node is managed by the test case and is + * automatically put with of_node_put() after the test case concludes. + */ +void of_node_put_kunit(struct kunit *test, struct device_node *node) +{ + if (kunit_add_action(test, of_node_put_wrapper, node)) { + KUNIT_FAIL(test, + "Can't allocate a kunit resource to put of_node\n"); + } +} +EXPORT_SYMBOL_GPL(of_node_put_kunit); diff --git a/include/kunit/of.h b/include/kunit/of.h new file mode 100644 index 000000000000..48d4e70c9666 --- /dev/null +++ b/include/kunit/of.h @@ -0,0 +1,115 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _KUNIT_OF_H +#define _KUNIT_OF_H + +#include <kunit/test.h> + +struct device_node; + +#ifdef CONFIG_OF + +void of_node_put_kunit(struct kunit *test, struct device_node *node); + +#else + +static inline +void of_node_put_kunit(struct kunit *test, struct device_node *node) +{ + kunit_skip(test, "requires CONFIG_OF"); +} + +#endif /* !CONFIG_OF */ + +#if defined(CONFIG_OF) && defined(CONFIG_OF_OVERLAY) && defined(CONFIG_OF_EARLY_FLATTREE) + +int of_overlay_fdt_apply_kunit(struct kunit *test, void *overlay_fdt, + u32 overlay_fdt_size, int *ovcs_id); +#else + +static inline int +of_overlay_fdt_apply_kunit(struct kunit *test, void *overlay_fdt, + u32 overlay_fdt_size, int *ovcs_id) +{ + kunit_skip(test, "requires CONFIG_OF and CONFIG_OF_OVERLAY and CONFIG_OF_EARLY_FLATTREE for root node"); + return -EINVAL; +} + +#endif + +/** + * __of_overlay_apply_kunit() - Test managed of_overlay_fdt_apply() variant + * @test: test context + * @overlay_begin: start address of overlay to apply + * @overlay_end: end address of overlay to apply + * + * This is mostly internal API. See of_overlay_apply_kunit() for the wrapper + * that makes this easier to use. + * + * Similar to of_overlay_fdt_apply(), except the overlay is managed by the test + * case and is automatically removed with of_overlay_remove() after the test + * case concludes. + * + * Return: 0 on success, negative errno on failure + */ +static inline int __of_overlay_apply_kunit(struct kunit *test, + u8 *overlay_begin, + const u8 *overlay_end) +{ + int unused; + + return of_overlay_fdt_apply_kunit(test, overlay_begin, + overlay_end - overlay_begin, + &unused); +} + +/** + * of_overlay_apply_kunit() - Test managed of_overlay_fdt_apply() for built-in overlays + * @test: test context + * @overlay_name: name of overlay to apply + * + * This macro is used to apply a device tree overlay built with the + * cmd_dt_S_dtbo rule in scripts/Makefile.lib that has been compiled into the + * kernel image or KUnit test module. The overlay is automatically removed when + * the test is finished. + * + * Unit tests that need device tree nodes should compile an overlay file with + * @overlay_name.dtbo.o in their Makefile along with their unit test and then + * load the overlay during their test. The @overlay_name matches the filename + * of the overlay without the dtbo filename extension. If CONFIG_OF_OVERLAY is + * not enabled, the @test will be skipped. + * + * In the Makefile + * + * .. code-block:: none + * + * obj-$(CONFIG_OF_OVERLAY_KUNIT_TEST) += overlay_test.o kunit_overlay_test.dtbo.o + * + * In the test + * + * .. code-block:: c + * + * static void of_overlay_kunit_of_overlay_apply(struct kunit *test) + * { + * struct device_node *np; + * + * KUNIT_ASSERT_EQ(test, 0, + * of_overlay_apply_kunit(test, kunit_overlay_test)); + * + * np = of_find_node_by_name(NULL, "test-kunit"); + * KUNIT_EXPECT_NOT_ERR_OR_NULL(test, np); + * of_node_put(np); + * } + * + * Return: 0 on success, negative errno on failure. + */ +#define of_overlay_apply_kunit(test, overlay_name) \ +({ \ + extern uint8_t __dtbo_##overlay_name##_begin[]; \ + extern uint8_t __dtbo_##overlay_name##_end[]; \ + \ + __of_overlay_apply_kunit((test), \ + __dtbo_##overlay_name##_begin, \ + __dtbo_##overlay_name##_end); \ +}) + +#endif
On Tue, 4 Jun 2024 at 06:38, Stephen Boyd sboyd@kernel.org wrote:
Add test managed wrappers for of_overlay_apply() that automatically removes the overlay when the test is finished. This API is intended for use by KUnit tests that test code which relies on 'struct device_node's and of_*() APIs.
KUnit tests will call of_overlay_apply_kunit() to load an overlay that's been built into the kernel image. When the test is complete, the overlay will be removed.
This has a few benefits:
It keeps the tests hermetic because the overlay is removed when the test is complete. Tests won't even be aware that an overlay was loaded in another test.
The overlay code can live right next to the unit test that loads it. The overlay and the unit test can be compiled into one kernel module if desired.
We can test different device tree configurations by loading different overlays. The overlays can be written for a specific test, and there can be many of them loaded per-test without needing to jam all possible combinations into one DTB.
It also allows KUnit to test device tree dependent code on any architecture, not just UML. This allows KUnit tests to test architecture specific device tree code.
There are some potential pitfalls though. Test authors need to be careful to not overwrite properties in the live tree. The easiest way to do this is to add and remove nodes with a 'kunit-' prefix, almost guaranteeing that the same node won't be present in the tree loaded at boot.
Suggested-by: Rob Herring robh@kernel.org Cc: Rob Herring robh@kernel.org Cc: Saravana Kannan saravanak@google.com Reviewed-by: Rob Herring (Arm) robh@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org
This looks good to me.
I was a little confused at first by some of the wrapper names: in particular that of_overlay_fdt_apply_kunit() is applying the overlay immediately, and deferring a cleanup action, but of_node_put_kunit() is not doing anything immediately, and deferring the put action. My feeling is that the ideal thing would be to have wrappers for all of the of_* functions which return a node which needs to be 'put', and have those wrappers add an of_node_put() action. You could then have of_node_put_kunit() provide a way to trigger that action early. But that seems like it'd be a lot of work and generate a lot of wrappers we otherwise wouldn't need, so this seems an okay compromise to be able to keep using the existing of_ functions. The documentation / comments help make this more clear, too.
So, no actual problems. (Assuming you don't want to put the documentation under the devicetree rather than under KUnit -- it can go either way.)
Reviewed-by: David Gow davidgow@google.com
Thanks, -- David
Documentation/dev-tools/kunit/api/index.rst | 11 ++ Documentation/dev-tools/kunit/api/of.rst | 13 +++ drivers/of/Makefile | 1 + drivers/of/of_kunit_helpers.c | 74 +++++++++++++ include/kunit/of.h | 115 ++++++++++++++++++++ 5 files changed, 214 insertions(+) create mode 100644 Documentation/dev-tools/kunit/api/of.rst create mode 100644 drivers/of/of_kunit_helpers.c create mode 100644 include/kunit/of.h
diff --git a/Documentation/dev-tools/kunit/api/index.rst b/Documentation/dev-tools/kunit/api/index.rst index 2d8f756aab56..282befa17edf 100644 --- a/Documentation/dev-tools/kunit/api/index.rst +++ b/Documentation/dev-tools/kunit/api/index.rst @@ -9,11 +9,15 @@ API Reference test resource functionredirection
ofThis page documents the KUnit kernel testing API. It is divided into the following sections:
+Core KUnit API +==============
Documentation/dev-tools/kunit/api/test.rst
- Documents all of the standard testing API
@@ -25,3 +29,10 @@ Documentation/dev-tools/kunit/api/resource.rst Documentation/dev-tools/kunit/api/functionredirection.rst
- Documents the KUnit Function Redirection API
+Driver KUnit API +================
+Documentation/dev-tools/kunit/api/of.rst
- Documents the KUnit device tree (OF) API
diff --git a/Documentation/dev-tools/kunit/api/of.rst b/Documentation/dev-tools/kunit/api/of.rst new file mode 100644 index 000000000000..cb4193dcddbb --- /dev/null +++ b/Documentation/dev-tools/kunit/api/of.rst @@ -0,0 +1,13 @@ +.. SPDX-License-Identifier: GPL-2.0
+==================== +Device Tree (OF) API +====================
+The KUnit device tree API is used to test device tree (of_*) dependent code.
+.. kernel-doc:: include/kunit/of.h
- :internal:
+.. kernel-doc:: drivers/of/of_kunit_helpers.c
- :export:
diff --git a/drivers/of/Makefile b/drivers/of/Makefile index 251d33532148..2ae909adde49 100644 --- a/drivers/of/Makefile +++ b/drivers/of/Makefile @@ -19,6 +19,7 @@ obj-y += kexec.o endif endif
+obj-$(CONFIG_KUNIT) += of_kunit_helpers.o obj-$(CONFIG_OF_KUNIT_TEST) += of_test.o
obj-$(CONFIG_OF_UNITTEST) += unittest-data/ diff --git a/drivers/of/of_kunit_helpers.c b/drivers/of/of_kunit_helpers.c new file mode 100644 index 000000000000..8a09132e32a8 --- /dev/null +++ b/drivers/of/of_kunit_helpers.c @@ -0,0 +1,74 @@ +// SPDX-License-Identifier: GPL-2.0 +/*
- Test managed device tree APIs
- */
+#include <linux/of.h> +#include <linux/of_fdt.h>
+#include <kunit/of.h> +#include <kunit/test.h> +#include <kunit/resource.h>
+#if defined(CONFIG_OF_OVERLAY) && defined(CONFIG_OF_EARLY_FLATTREE)
+static void of_overlay_fdt_apply_kunit_exit(void *ovcs_id) +{
of_overlay_remove(ovcs_id);+}
+/**
- of_overlay_fdt_apply_kunit() - Test managed of_overlay_fdt_apply()
- @test: test context
- @overlay_fdt: device tree overlay to apply
- @overlay_fdt_size: size in bytes of @overlay_fdt
- @ovcs_id: identifier of overlay, used to remove the overlay
- Just like of_overlay_fdt_apply(), except the overlay is managed by the test
- case and is automatically removed with of_overlay_remove() after the test
- case concludes.
- Return: 0 on success, negative errno on failure
- */
+int of_overlay_fdt_apply_kunit(struct kunit *test, void *overlay_fdt,
u32 overlay_fdt_size, int *ovcs_id)+{
int ret;int *copy_id;copy_id = kunit_kmalloc(test, sizeof(*copy_id), GFP_KERNEL);if (!copy_id)return -ENOMEM;ret = of_overlay_fdt_apply(overlay_fdt, overlay_fdt_size,ovcs_id, NULL);if (ret)return ret;*copy_id = *ovcs_id;return kunit_add_action_or_reset(test, of_overlay_fdt_apply_kunit_exit,copy_id);+} +EXPORT_SYMBOL_GPL(of_overlay_fdt_apply_kunit);
+#endif
+KUNIT_DEFINE_ACTION_WRAPPER(of_node_put_wrapper, of_node_put, struct device_node *);
+/**
- of_node_put_kunit() - Test managed of_node_put()
- @test: test context
- @node: node to pass to `of_node_put()`
- Just like of_node_put(), except the node is managed by the test case and is
- automatically put with of_node_put() after the test case concludes.
- */
+void of_node_put_kunit(struct kunit *test, struct device_node *node) +{
if (kunit_add_action(test, of_node_put_wrapper, node)) {KUNIT_FAIL(test,"Can't allocate a kunit resource to put of_node\n");}+} +EXPORT_SYMBOL_GPL(of_node_put_kunit); diff --git a/include/kunit/of.h b/include/kunit/of.h new file mode 100644 index 000000000000..48d4e70c9666 --- /dev/null +++ b/include/kunit/of.h @@ -0,0 +1,115 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _KUNIT_OF_H +#define _KUNIT_OF_H
+#include <kunit/test.h>
+struct device_node;
+#ifdef CONFIG_OF
+void of_node_put_kunit(struct kunit *test, struct device_node *node);
+#else
+static inline +void of_node_put_kunit(struct kunit *test, struct device_node *node) +{
kunit_skip(test, "requires CONFIG_OF");+}
+#endif /* !CONFIG_OF */
+#if defined(CONFIG_OF) && defined(CONFIG_OF_OVERLAY) && defined(CONFIG_OF_EARLY_FLATTREE)
+int of_overlay_fdt_apply_kunit(struct kunit *test, void *overlay_fdt,
u32 overlay_fdt_size, int *ovcs_id);+#else
+static inline int +of_overlay_fdt_apply_kunit(struct kunit *test, void *overlay_fdt,
u32 overlay_fdt_size, int *ovcs_id)+{
kunit_skip(test, "requires CONFIG_OF and CONFIG_OF_OVERLAY and CONFIG_OF_EARLY_FLATTREE for root node");return -EINVAL;+}
+#endif
+/**
- __of_overlay_apply_kunit() - Test managed of_overlay_fdt_apply() variant
- @test: test context
- @overlay_begin: start address of overlay to apply
- @overlay_end: end address of overlay to apply
- This is mostly internal API. See of_overlay_apply_kunit() for the wrapper
- that makes this easier to use.
- Similar to of_overlay_fdt_apply(), except the overlay is managed by the test
- case and is automatically removed with of_overlay_remove() after the test
- case concludes.
- Return: 0 on success, negative errno on failure
- */
+static inline int __of_overlay_apply_kunit(struct kunit *test,
u8 *overlay_begin,const u8 *overlay_end)+{
int unused;return of_overlay_fdt_apply_kunit(test, overlay_begin,overlay_end - overlay_begin,&unused);+}
+/**
- of_overlay_apply_kunit() - Test managed of_overlay_fdt_apply() for built-in overlays
- @test: test context
- @overlay_name: name of overlay to apply
- This macro is used to apply a device tree overlay built with the
- cmd_dt_S_dtbo rule in scripts/Makefile.lib that has been compiled into the
- kernel image or KUnit test module. The overlay is automatically removed when
- the test is finished.
- Unit tests that need device tree nodes should compile an overlay file with
- @overlay_name.dtbo.o in their Makefile along with their unit test and then
- load the overlay during their test. The @overlay_name matches the filename
- of the overlay without the dtbo filename extension. If CONFIG_OF_OVERLAY is
- not enabled, the @test will be skipped.
- In the Makefile
- .. code-block:: none
obj-$(CONFIG_OF_OVERLAY_KUNIT_TEST) += overlay_test.o kunit_overlay_test.dtbo.o
- In the test
- .. code-block:: c
static void of_overlay_kunit_of_overlay_apply(struct kunit *test)
{
struct device_node *np;
KUNIT_ASSERT_EQ(test, 0,
of_overlay_apply_kunit(test, kunit_overlay_test));
np = of_find_node_by_name(NULL, "test-kunit");
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, np);
of_node_put(np);
}
- Return: 0 on success, negative errno on failure.
- */
+#define of_overlay_apply_kunit(test, overlay_name) \ +({ \
extern uint8_t __dtbo_##overlay_name##_begin[]; \extern uint8_t __dtbo_##overlay_name##_end[]; \\__of_overlay_apply_kunit((test), \__dtbo_##overlay_name##_begin, \__dtbo_##overlay_name##_end); \+})
+#endif
https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/ https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git
Quoting David Gow (2024-06-13 00:48:54)
This looks good to me.
I was a little confused at first by some of the wrapper names: in particular that of_overlay_fdt_apply_kunit() is applying the overlay immediately, and deferring a cleanup action, but of_node_put_kunit() is not doing anything immediately, and deferring the put action. My feeling is that the ideal thing would be to have wrappers for all of the of_* functions which return a node which needs to be 'put', and have those wrappers add an of_node_put() action. You could then have of_node_put_kunit() provide a way to trigger that action early. But that seems like it'd be a lot of work and generate a lot of wrappers we otherwise wouldn't need, so this seems an okay compromise to be able to keep using the existing of_ functions. The documentation / comments help make this more clear, too.
So, no actual problems. (Assuming you don't want to put the documentation under the devicetree rather than under KUnit -- it can go either way.)
Reviewed-by: David Gow davidgow@google.com
Thanks. I'll just leave this alone as I feel like the kunit postfix means "do stuff when test is done".
Add the vendor prefix "test" to reserve a vendor prefix for bindings that are purely for testing device tree code. This allows test code to write bindings that can be checked by the schema validator.
Reviewed-by: Rob Herring robh@kernel.org Reviewed-by: David Gow davidgow@google.com Cc: Krzysztof Kozlowski krzysztof.kozlowski+dt@linaro.org Cc: Conor Dooley conor+dt@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org --- Documentation/devicetree/bindings/vendor-prefixes.yaml | 2 ++ 1 file changed, 2 insertions(+)
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.yaml b/Documentation/devicetree/bindings/vendor-prefixes.yaml index fbf47f0bacf1..02a22c2722ec 100644 --- a/Documentation/devicetree/bindings/vendor-prefixes.yaml +++ b/Documentation/devicetree/bindings/vendor-prefixes.yaml @@ -1456,6 +1456,8 @@ patternProperties: description: Terasic Inc. "^tesla,.*": description: Tesla, Inc. + "^test,.*": + description: Reserved for use by tests. For example, KUnit. "^tfc,.*": description: Three Five Corp "^thead,.*":
Describe a binding for an empty device node used by KUnit tests to confirm overlays load properly.
Reviewed-by: Rob Herring robh@kernel.org Reviewed-by: David Gow davidgow@google.com Reviewed-by: Brendan Higgins brendanhiggins@google.com Cc: Krzysztof Kozlowski krzysztof.kozlowski+dt@linaro.org Cc: Conor Dooley conor+dt@kernel.org Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org --- .../devicetree/bindings/test/test,empty.yaml | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Documentation/devicetree/bindings/test/test,empty.yaml
diff --git a/Documentation/devicetree/bindings/test/test,empty.yaml b/Documentation/devicetree/bindings/test/test,empty.yaml new file mode 100644 index 000000000000..030df7123af1 --- /dev/null +++ b/Documentation/devicetree/bindings/test/test,empty.yaml @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/test/test,empty.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Empty node + +maintainers: + - David Gow davidgow@google.com + - Brendan Higgins brendan.higgins@linux.dev + +description: + An empty node to confirm tests can load device tree overlays. + +properties: + compatible: + const: test,empty + +required: + - compatible + +additionalProperties: false + +examples: + - | + kunit-node { + compatible = "test,empty"; + }; +...
Test the KUnit test managed overlay APIs. Confirm that platform devices are created and destroyed properly. This provides us confidence that the test managed APIs work correctly and can be relied upon to provide tests with fake platform devices and device nodes via overlays compiled into the kernel image.
Cc: Rob Herring robh@kernel.org Cc: Saravana Kannan saravanak@google.com Cc: Daniel Latypov dlatypov@google.com Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Reviewed-by: Rob Herring (Arm) robh@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org --- drivers/of/.kunitconfig | 1 + drivers/of/Kconfig | 10 +++ drivers/of/Makefile | 1 + drivers/of/kunit_overlay_test.dtso | 9 +++ drivers/of/overlay_test.c | 116 +++++++++++++++++++++++++++++ 5 files changed, 137 insertions(+) create mode 100644 drivers/of/kunit_overlay_test.dtso create mode 100644 drivers/of/overlay_test.c
diff --git a/drivers/of/.kunitconfig b/drivers/of/.kunitconfig index 5a8fee11978c..4c53d2c7a275 100644 --- a/drivers/of/.kunitconfig +++ b/drivers/of/.kunitconfig @@ -1,3 +1,4 @@ CONFIG_KUNIT=y CONFIG_OF=y CONFIG_OF_KUNIT_TEST=y +CONFIG_OF_OVERLAY_KUNIT_TEST=y diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig index dd726c7056bf..0e2d608c3e20 100644 --- a/drivers/of/Kconfig +++ b/drivers/of/Kconfig @@ -107,6 +107,16 @@ config OF_OVERLAY While this option is selected automatically when needed, you can enable it manually to improve device tree unit test coverage.
+config OF_OVERLAY_KUNIT_TEST + tristate "Device Tree overlay KUnit tests" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS + select OF_OVERLAY + help + This option builds KUnit unit tests for the device tree overlay code. + + If unsure, say N here, but this option is safe to enable. + config OF_NUMA bool
diff --git a/drivers/of/Makefile b/drivers/of/Makefile index 2ae909adde49..abd9c578343b 100644 --- a/drivers/of/Makefile +++ b/drivers/of/Makefile @@ -21,5 +21,6 @@ endif
obj-$(CONFIG_KUNIT) += of_kunit_helpers.o obj-$(CONFIG_OF_KUNIT_TEST) += of_test.o +obj-$(CONFIG_OF_OVERLAY_KUNIT_TEST) += overlay_test.o kunit_overlay_test.dtbo.o
obj-$(CONFIG_OF_UNITTEST) += unittest-data/ diff --git a/drivers/of/kunit_overlay_test.dtso b/drivers/of/kunit_overlay_test.dtso new file mode 100644 index 000000000000..85f20b4b4c16 --- /dev/null +++ b/drivers/of/kunit_overlay_test.dtso @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0 +/dts-v1/; +/plugin/; + +&{/} { + kunit-test { + compatible = "test,empty"; + }; +}; diff --git a/drivers/of/overlay_test.c b/drivers/of/overlay_test.c new file mode 100644 index 000000000000..9a8083c3a659 --- /dev/null +++ b/drivers/of/overlay_test.c @@ -0,0 +1,116 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit tests for device tree overlays + */ +#include <linux/device/bus.h> +#include <linux/kconfig.h> +#include <linux/of.h> +#include <linux/of_platform.h> +#include <linux/platform_device.h> + +#include <kunit/of.h> +#include <kunit/test.h> + +static const char * const kunit_node_name = "kunit-test"; +static const char * const kunit_compatible = "test,empty"; + +/* Test that of_overlay_apply_kunit() adds a node to the live tree */ +static void of_overlay_apply_kunit_apply(struct kunit *test) +{ + struct device_node *np; + + KUNIT_ASSERT_EQ(test, 0, + of_overlay_apply_kunit(test, kunit_overlay_test)); + + np = of_find_node_by_name(NULL, kunit_node_name); + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, np); + of_node_put(np); +} + +/* + * Test that of_overlay_apply_kunit() creates platform devices with the + * expected device_node + */ +static void of_overlay_apply_kunit_platform_device(struct kunit *test) +{ + struct platform_device *pdev; + struct device_node *np; + + KUNIT_ASSERT_EQ(test, 0, + of_overlay_apply_kunit(test, kunit_overlay_test)); + + np = of_find_node_by_name(NULL, kunit_node_name); + of_node_put_kunit(test, np); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np); + + pdev = of_find_device_by_node(np); + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, pdev); + if (pdev) + put_device(&pdev->dev); +} + +static int of_overlay_bus_match_compatible(struct device *dev, const void *data) +{ + return of_device_is_compatible(dev->of_node, data); +} + +/* Test that of_overlay_apply_kunit() cleans up after the test is finished */ +static void of_overlay_apply_kunit_cleanup(struct kunit *test) +{ + struct kunit fake; + struct platform_device *pdev; + struct device *dev; + struct device_node *np; + + if (!IS_ENABLED(CONFIG_OF_OVERLAY)) + kunit_skip(test, "requires CONFIG_OF_OVERLAY"); + if (!IS_ENABLED(CONFIG_OF_EARLY_FLATTREE)) + kunit_skip(test, "requires CONFIG_OF_EARLY_FLATTREE for root node"); + + kunit_init_test(&fake, "fake test", NULL); + KUNIT_ASSERT_EQ(test, fake.status, KUNIT_SUCCESS); + + KUNIT_ASSERT_EQ(test, 0, + of_overlay_apply_kunit(&fake, kunit_overlay_test)); + + np = of_find_node_by_name(NULL, kunit_node_name); + of_node_put(np); /* Not derefing 'np' after this */ + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np); + + pdev = of_find_device_by_node(np); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); + put_device(&pdev->dev); /* Not derefing 'pdev' after this */ + + /* Remove overlay */ + kunit_cleanup(&fake); + + /* The node and device should be removed */ + np = of_find_node_by_name(NULL, kunit_node_name); + KUNIT_EXPECT_PTR_EQ(test, NULL, np); + of_node_put(np); + + dev = bus_find_device(&platform_bus_type, NULL, kunit_compatible, + of_overlay_bus_match_compatible); + KUNIT_EXPECT_PTR_EQ(test, NULL, dev); + put_device(dev); +} + +static struct kunit_case of_overlay_apply_kunit_test_cases[] = { + KUNIT_CASE(of_overlay_apply_kunit_apply), + KUNIT_CASE(of_overlay_apply_kunit_platform_device), + KUNIT_CASE(of_overlay_apply_kunit_cleanup), + {} +}; + +/* + * Test suite for test managed device tree overlays. + */ +static struct kunit_suite of_overlay_apply_kunit_suite = { + .name = "of_overlay_apply_kunit", + .test_cases = of_overlay_apply_kunit_test_cases, +}; + +kunit_test_suites( + &of_overlay_apply_kunit_suite, +); +MODULE_LICENSE("GPL");
On Mon, Jun 03, 2024 at 03:38:02PM -0700, Stephen Boyd wrote:
Test the KUnit test managed overlay APIs. Confirm that platform devices are created and destroyed properly. This provides us confidence that the test managed APIs work correctly and can be relied upon to provide tests with fake platform devices and device nodes via overlays compiled into the kernel image.
Cc: Rob Herring robh@kernel.org Cc: Saravana Kannan saravanak@google.com Cc: Daniel Latypov dlatypov@google.com Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Reviewed-by: Rob Herring (Arm) robh@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org
drivers/of/.kunitconfig | 1 + drivers/of/Kconfig | 10 +++ drivers/of/Makefile | 1 + drivers/of/kunit_overlay_test.dtso | 9 +++ drivers/of/overlay_test.c | 116 +++++++++++++++++++++++++++++ 5 files changed, 137 insertions(+) create mode 100644 drivers/of/kunit_overlay_test.dtso create mode 100644 drivers/of/overlay_test.c
diff --git a/drivers/of/.kunitconfig b/drivers/of/.kunitconfig index 5a8fee11978c..4c53d2c7a275 100644 --- a/drivers/of/.kunitconfig +++ b/drivers/of/.kunitconfig @@ -1,3 +1,4 @@ CONFIG_KUNIT=y CONFIG_OF=y CONFIG_OF_KUNIT_TEST=y +CONFIG_OF_OVERLAY_KUNIT_TEST=y diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig index dd726c7056bf..0e2d608c3e20 100644 --- a/drivers/of/Kconfig +++ b/drivers/of/Kconfig @@ -107,6 +107,16 @@ config OF_OVERLAY While this option is selected automatically when needed, you can enable it manually to improve device tree unit test coverage. +config OF_OVERLAY_KUNIT_TEST
- tristate "Device Tree overlay KUnit tests" if !KUNIT_ALL_TESTS
- depends on KUNIT
- default KUNIT_ALL_TESTS
- select OF_OVERLAY
- help
This option builds KUnit unit tests for the device tree overlay code.If unsure, say N here, but this option is safe to enable.config OF_NUMA bool diff --git a/drivers/of/Makefile b/drivers/of/Makefile index 2ae909adde49..abd9c578343b 100644 --- a/drivers/of/Makefile +++ b/drivers/of/Makefile @@ -21,5 +21,6 @@ endif obj-$(CONFIG_KUNIT) += of_kunit_helpers.o obj-$(CONFIG_OF_KUNIT_TEST) += of_test.o +obj-$(CONFIG_OF_OVERLAY_KUNIT_TEST) += overlay_test.o kunit_overlay_test.dtbo.o obj-$(CONFIG_OF_UNITTEST) += unittest-data/ diff --git a/drivers/of/kunit_overlay_test.dtso b/drivers/of/kunit_overlay_test.dtso new file mode 100644 index 000000000000..85f20b4b4c16 --- /dev/null +++ b/drivers/of/kunit_overlay_test.dtso @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0 +/dts-v1/; +/plugin/;
+&{/} {
- kunit-test {
compatible = "test,empty";- };
+}; diff --git a/drivers/of/overlay_test.c b/drivers/of/overlay_test.c new file mode 100644 index 000000000000..9a8083c3a659 --- /dev/null +++ b/drivers/of/overlay_test.c @@ -0,0 +1,116 @@ +// SPDX-License-Identifier: GPL-2.0 +/*
- KUnit tests for device tree overlays
- */
+#include <linux/device/bus.h> +#include <linux/kconfig.h> +#include <linux/of.h> +#include <linux/of_platform.h> +#include <linux/platform_device.h>
+#include <kunit/of.h> +#include <kunit/test.h>
+static const char * const kunit_node_name = "kunit-test"; +static const char * const kunit_compatible = "test,empty";
+/* Test that of_overlay_apply_kunit() adds a node to the live tree */ +static void of_overlay_apply_kunit_apply(struct kunit *test) +{
- struct device_node *np;
- KUNIT_ASSERT_EQ(test, 0,
of_overlay_apply_kunit(test, kunit_overlay_test));- np = of_find_node_by_name(NULL, kunit_node_name);
- KUNIT_EXPECT_NOT_ERR_OR_NULL(test, np);
- of_node_put(np);
+}
+/*
- Test that of_overlay_apply_kunit() creates platform devices with the
- expected device_node
- */
+static void of_overlay_apply_kunit_platform_device(struct kunit *test) +{
- struct platform_device *pdev;
- struct device_node *np;
- KUNIT_ASSERT_EQ(test, 0,
of_overlay_apply_kunit(test, kunit_overlay_test));- np = of_find_node_by_name(NULL, kunit_node_name);
- of_node_put_kunit(test, np);
Moving target, but we now have of_node_put() cleanups. Would that work here instead?
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
- pdev = of_find_device_by_node(np);
- KUNIT_EXPECT_NOT_ERR_OR_NULL(test, pdev);
- if (pdev)
put_device(&pdev->dev);+}
+static int of_overlay_bus_match_compatible(struct device *dev, const void *data) +{
- return of_device_is_compatible(dev->of_node, data);
+}
+/* Test that of_overlay_apply_kunit() cleans up after the test is finished */ +static void of_overlay_apply_kunit_cleanup(struct kunit *test) +{
- struct kunit fake;
- struct platform_device *pdev;
- struct device *dev;
- struct device_node *np;
- if (!IS_ENABLED(CONFIG_OF_OVERLAY))
kunit_skip(test, "requires CONFIG_OF_OVERLAY");- if (!IS_ENABLED(CONFIG_OF_EARLY_FLATTREE))
kunit_skip(test, "requires CONFIG_OF_EARLY_FLATTREE for root node");- kunit_init_test(&fake, "fake test", NULL);
- KUNIT_ASSERT_EQ(test, fake.status, KUNIT_SUCCESS);
- KUNIT_ASSERT_EQ(test, 0,
of_overlay_apply_kunit(&fake, kunit_overlay_test));- np = of_find_node_by_name(NULL, kunit_node_name);
- of_node_put(np); /* Not derefing 'np' after this */
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
- pdev = of_find_device_by_node(np);
Don't you need to hold a ref on np until here?
- KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
- put_device(&pdev->dev); /* Not derefing 'pdev' after this */
- /* Remove overlay */
- kunit_cleanup(&fake);
- /* The node and device should be removed */
- np = of_find_node_by_name(NULL, kunit_node_name);
- KUNIT_EXPECT_PTR_EQ(test, NULL, np);
- of_node_put(np);
- dev = bus_find_device(&platform_bus_type, NULL, kunit_compatible,
of_overlay_bus_match_compatible);- KUNIT_EXPECT_PTR_EQ(test, NULL, dev);
- put_device(dev);
+}
+static struct kunit_case of_overlay_apply_kunit_test_cases[] = {
- KUNIT_CASE(of_overlay_apply_kunit_apply),
- KUNIT_CASE(of_overlay_apply_kunit_platform_device),
- KUNIT_CASE(of_overlay_apply_kunit_cleanup),
- {}
+};
+/*
- Test suite for test managed device tree overlays.
- */
+static struct kunit_suite of_overlay_apply_kunit_suite = {
- .name = "of_overlay_apply_kunit",
- .test_cases = of_overlay_apply_kunit_test_cases,
+};
+kunit_test_suites(
- &of_overlay_apply_kunit_suite,
+);
+MODULE_LICENSE("GPL");
https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/ https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git
Quoting Rob Herring (2024-06-05 16:47:20)
On Mon, Jun 03, 2024 at 03:38:02PM -0700, Stephen Boyd wrote:
diff --git a/drivers/of/Makefile b/drivers/of/Makefile index 2ae909adde49..abd9c578343b 100644 diff --git a/drivers/of/overlay_test.c b/drivers/of/overlay_test.c new file mode 100644 index 000000000000..9a8083c3a659 --- /dev/null +++ b/drivers/of/overlay_test.c @@ -0,0 +1,116 @@ +// SPDX-License-Identifier: GPL-2.0 +/*
- KUnit tests for device tree overlays
- */
+#include <linux/device/bus.h> +#include <linux/kconfig.h> +#include <linux/of.h> +#include <linux/of_platform.h> +#include <linux/platform_device.h>
+#include <kunit/of.h> +#include <kunit/test.h>
+static const char * const kunit_node_name = "kunit-test"; +static const char * const kunit_compatible = "test,empty";
+/* Test that of_overlay_apply_kunit() adds a node to the live tree */ +static void of_overlay_apply_kunit_apply(struct kunit *test) +{
struct device_node *np;KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(test, kunit_overlay_test));np = of_find_node_by_name(NULL, kunit_node_name);KUNIT_EXPECT_NOT_ERR_OR_NULL(test, np);of_node_put(np);+}
+/*
- Test that of_overlay_apply_kunit() creates platform devices with the
- expected device_node
- */
+static void of_overlay_apply_kunit_platform_device(struct kunit *test) +{
struct platform_device *pdev;struct device_node *np;KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(test, kunit_overlay_test));np = of_find_node_by_name(NULL, kunit_node_name);of_node_put_kunit(test, np);Moving target, but we now have of_node_put() cleanups. Would that work here instead?
Do you mean cleanup.h? I don't think it will work. The assert logic is like an exception handler. If the assertion fails we basically jump out of the test and run any test exit code, including kunit resource exits. I could introduce another kunit wrapper for of_find_node_by_name() and use that here so that the reference is dropped when the test exits.
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);pdev = of_find_device_by_node(np);KUNIT_EXPECT_NOT_ERR_OR_NULL(test, pdev);if (pdev)put_device(&pdev->dev);+}
+static int of_overlay_bus_match_compatible(struct device *dev, const void *data) +{
return of_device_is_compatible(dev->of_node, data);+}
+/* Test that of_overlay_apply_kunit() cleans up after the test is finished */ +static void of_overlay_apply_kunit_cleanup(struct kunit *test) +{
struct kunit fake;struct platform_device *pdev;struct device *dev;struct device_node *np;if (!IS_ENABLED(CONFIG_OF_OVERLAY))kunit_skip(test, "requires CONFIG_OF_OVERLAY");if (!IS_ENABLED(CONFIG_OF_EARLY_FLATTREE))kunit_skip(test, "requires CONFIG_OF_EARLY_FLATTREE for root node");kunit_init_test(&fake, "fake test", NULL);KUNIT_ASSERT_EQ(test, fake.status, KUNIT_SUCCESS);KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(&fake, kunit_overlay_test));np = of_find_node_by_name(NULL, kunit_node_name);of_node_put(np); /* Not derefing 'np' after this */KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);pdev = of_find_device_by_node(np);Don't you need to hold a ref on np until here?
Oh, good catch. We need an of_find_node_by_name_kunit() wrapper then.
On Tue, 4 Jun 2024 at 06:38, Stephen Boyd sboyd@kernel.org wrote:
Test the KUnit test managed overlay APIs. Confirm that platform devices are created and destroyed properly. This provides us confidence that the test managed APIs work correctly and can be relied upon to provide tests with fake platform devices and device nodes via overlays compiled into the kernel image.
Cc: Rob Herring robh@kernel.org Cc: Saravana Kannan saravanak@google.com Cc: Daniel Latypov dlatypov@google.com Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Reviewed-by: Rob Herring (Arm) robh@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org
This is looking good from my point of view, and passes on my test setup. One minor question (do we need both to select OF_OVERLAY and skip if it's not enabled?), but otherwise:
Reviewed-by: David Gow davidgow@google.com
-- David
-- David
drivers/of/.kunitconfig | 1 + drivers/of/Kconfig | 10 +++ drivers/of/Makefile | 1 + drivers/of/kunit_overlay_test.dtso | 9 +++ drivers/of/overlay_test.c | 116 +++++++++++++++++++++++++++++ 5 files changed, 137 insertions(+) create mode 100644 drivers/of/kunit_overlay_test.dtso create mode 100644 drivers/of/overlay_test.c
diff --git a/drivers/of/.kunitconfig b/drivers/of/.kunitconfig index 5a8fee11978c..4c53d2c7a275 100644 --- a/drivers/of/.kunitconfig +++ b/drivers/of/.kunitconfig @@ -1,3 +1,4 @@ CONFIG_KUNIT=y CONFIG_OF=y CONFIG_OF_KUNIT_TEST=y +CONFIG_OF_OVERLAY_KUNIT_TEST=y diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig index dd726c7056bf..0e2d608c3e20 100644 --- a/drivers/of/Kconfig +++ b/drivers/of/Kconfig @@ -107,6 +107,16 @@ config OF_OVERLAY While this option is selected automatically when needed, you can enable it manually to improve device tree unit test coverage.
+config OF_OVERLAY_KUNIT_TEST
tristate "Device Tree overlay KUnit tests" if !KUNIT_ALL_TESTSdepends on KUNITdefault KUNIT_ALL_TESTSselect OF_OVERLAYhelpThis option builds KUnit unit tests for the device tree overlay code.If unsure, say N here, but this option is safe to enable.config OF_NUMA bool
diff --git a/drivers/of/Makefile b/drivers/of/Makefile index 2ae909adde49..abd9c578343b 100644 --- a/drivers/of/Makefile +++ b/drivers/of/Makefile @@ -21,5 +21,6 @@ endif
obj-$(CONFIG_KUNIT) += of_kunit_helpers.o obj-$(CONFIG_OF_KUNIT_TEST) += of_test.o +obj-$(CONFIG_OF_OVERLAY_KUNIT_TEST) += overlay_test.o kunit_overlay_test.dtbo.o
obj-$(CONFIG_OF_UNITTEST) += unittest-data/ diff --git a/drivers/of/kunit_overlay_test.dtso b/drivers/of/kunit_overlay_test.dtso new file mode 100644 index 000000000000..85f20b4b4c16 --- /dev/null +++ b/drivers/of/kunit_overlay_test.dtso @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0 +/dts-v1/; +/plugin/;
+&{/} {
kunit-test {compatible = "test,empty";};+}; diff --git a/drivers/of/overlay_test.c b/drivers/of/overlay_test.c new file mode 100644 index 000000000000..9a8083c3a659 --- /dev/null +++ b/drivers/of/overlay_test.c @@ -0,0 +1,116 @@ +// SPDX-License-Identifier: GPL-2.0 +/*
- KUnit tests for device tree overlays
- */
+#include <linux/device/bus.h> +#include <linux/kconfig.h> +#include <linux/of.h> +#include <linux/of_platform.h> +#include <linux/platform_device.h>
+#include <kunit/of.h> +#include <kunit/test.h>
+static const char * const kunit_node_name = "kunit-test"; +static const char * const kunit_compatible = "test,empty";
+/* Test that of_overlay_apply_kunit() adds a node to the live tree */ +static void of_overlay_apply_kunit_apply(struct kunit *test) +{
struct device_node *np;KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(test, kunit_overlay_test));np = of_find_node_by_name(NULL, kunit_node_name);KUNIT_EXPECT_NOT_ERR_OR_NULL(test, np);of_node_put(np);+}
+/*
- Test that of_overlay_apply_kunit() creates platform devices with the
- expected device_node
- */
+static void of_overlay_apply_kunit_platform_device(struct kunit *test) +{
struct platform_device *pdev;struct device_node *np;KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(test, kunit_overlay_test));np = of_find_node_by_name(NULL, kunit_node_name);of_node_put_kunit(test, np);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);pdev = of_find_device_by_node(np);KUNIT_EXPECT_NOT_ERR_OR_NULL(test, pdev);if (pdev)put_device(&pdev->dev);+}
+static int of_overlay_bus_match_compatible(struct device *dev, const void *data) +{
return of_device_is_compatible(dev->of_node, data);+}
+/* Test that of_overlay_apply_kunit() cleans up after the test is finished */ +static void of_overlay_apply_kunit_cleanup(struct kunit *test) +{
struct kunit fake;struct platform_device *pdev;struct device *dev;struct device_node *np;if (!IS_ENABLED(CONFIG_OF_OVERLAY))kunit_skip(test, "requires CONFIG_OF_OVERLAY");if (!IS_ENABLED(CONFIG_OF_EARLY_FLATTREE))kunit_skip(test, "requires CONFIG_OF_EARLY_FLATTREE for root node");kunit_init_test(&fake, "fake test", NULL);KUNIT_ASSERT_EQ(test, fake.status, KUNIT_SUCCESS);KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(&fake, kunit_overlay_test));np = of_find_node_by_name(NULL, kunit_node_name);of_node_put(np); /* Not derefing 'np' after this */KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);pdev = of_find_device_by_node(np);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);put_device(&pdev->dev); /* Not derefing 'pdev' after this *//* Remove overlay */kunit_cleanup(&fake);/* The node and device should be removed */np = of_find_node_by_name(NULL, kunit_node_name);KUNIT_EXPECT_PTR_EQ(test, NULL, np);of_node_put(np);dev = bus_find_device(&platform_bus_type, NULL, kunit_compatible,of_overlay_bus_match_compatible);KUNIT_EXPECT_PTR_EQ(test, NULL, dev);put_device(dev);+}
+static struct kunit_case of_overlay_apply_kunit_test_cases[] = {
KUNIT_CASE(of_overlay_apply_kunit_apply),KUNIT_CASE(of_overlay_apply_kunit_platform_device),KUNIT_CASE(of_overlay_apply_kunit_cleanup),{}+};
+/*
- Test suite for test managed device tree overlays.
- */
+static struct kunit_suite of_overlay_apply_kunit_suite = {
.name = "of_overlay_apply_kunit",.test_cases = of_overlay_apply_kunit_test_cases,+};
+kunit_test_suites(
&of_overlay_apply_kunit_suite,+);
+MODULE_LICENSE("GPL");
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 kunit-dev+unsubscribe@googlegroups.com. To view this discussion on the web visit https://groups.google.com/d/msgid/kunit-dev/20240603223811.3815762-6-sboyd%4....
Quoting David Gow (2024-06-13 00:50:10)
On Tue, 4 Jun 2024 at 06:38, Stephen Boyd sboyd@kernel.org wrote:
Test the KUnit test managed overlay APIs. Confirm that platform devices are created and destroyed properly. This provides us confidence that the test managed APIs work correctly and can be relied upon to provide tests with fake platform devices and device nodes via overlays compiled into the kernel image.
Cc: Rob Herring robh@kernel.org Cc: Saravana Kannan saravanak@google.com Cc: Daniel Latypov dlatypov@google.com Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Reviewed-by: Rob Herring (Arm) robh@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org
This is looking good from my point of view, and passes on my test setup. One minor question (do we need both to select OF_OVERLAY and skip if it's not enabled?), but otherwise:
We don't need to skip if OF_OVERLAY isn't set because it's forced on for the test. I'll remove it, thanks.
Introduce KUnit resource wrappers around platform_driver_register(), platform_device_alloc(), and platform_device_add() so that test authors can register platform drivers/devices from their tests and have the drivers/devices automatically be unregistered when the test is done.
This makes test setup code simpler when a platform driver or platform device is needed. Add a few test cases at the same time to make sure the APIs work as intended.
Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Cc: Greg Kroah-Hartman gregkh@linuxfoundation.org Cc: "Rafael J. Wysocki" rafael@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org --- Documentation/dev-tools/kunit/api/index.rst | 5 + .../dev-tools/kunit/api/platformdevice.rst | 10 + include/kunit/platform_device.h | 20 ++ lib/kunit/Makefile | 4 +- lib/kunit/platform-test.c | 223 +++++++++++++ lib/kunit/platform.c | 302 ++++++++++++++++++ 6 files changed, 563 insertions(+), 1 deletion(-) create mode 100644 Documentation/dev-tools/kunit/api/platformdevice.rst create mode 100644 include/kunit/platform_device.h create mode 100644 lib/kunit/platform-test.c create mode 100644 lib/kunit/platform.c
diff --git a/Documentation/dev-tools/kunit/api/index.rst b/Documentation/dev-tools/kunit/api/index.rst index 282befa17edf..02b26f5e8750 100644 --- a/Documentation/dev-tools/kunit/api/index.rst +++ b/Documentation/dev-tools/kunit/api/index.rst @@ -10,6 +10,7 @@ API Reference resource functionredirection of + platformdevice
This page documents the KUnit kernel testing API. It is divided into the @@ -36,3 +37,7 @@ Driver KUnit API Documentation/dev-tools/kunit/api/of.rst
- Documents the KUnit device tree (OF) API + +Documentation/dev-tools/kunit/api/platformdevice.rst + + - Documents the KUnit platform device API diff --git a/Documentation/dev-tools/kunit/api/platformdevice.rst b/Documentation/dev-tools/kunit/api/platformdevice.rst new file mode 100644 index 000000000000..49ddd5729003 --- /dev/null +++ b/Documentation/dev-tools/kunit/api/platformdevice.rst @@ -0,0 +1,10 @@ +.. SPDX-License-Identifier: GPL-2.0 + +=================== +Platform Device API +=================== + +The KUnit platform device API is used to test platform devices. + +.. kernel-doc:: lib/kunit/platform.c + :export: diff --git a/include/kunit/platform_device.h b/include/kunit/platform_device.h new file mode 100644 index 000000000000..0fc0999d2420 --- /dev/null +++ b/include/kunit/platform_device.h @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _KUNIT_PLATFORM_DRIVER_H +#define _KUNIT_PLATFORM_DRIVER_H + +struct kunit; +struct platform_device; +struct platform_driver; + +struct platform_device * +kunit_platform_device_alloc(struct kunit *test, const char *name, int id); +int kunit_platform_device_add(struct kunit *test, struct platform_device *pdev); + +int kunit_platform_device_prepare_wait_for_probe(struct kunit *test, + struct platform_device *pdev, + struct completion *x); + +int kunit_platform_driver_register(struct kunit *test, + struct platform_driver *drv); + +#endif diff --git a/lib/kunit/Makefile b/lib/kunit/Makefile index 309659a32a78..a980ae62eff6 100644 --- a/lib/kunit/Makefile +++ b/lib/kunit/Makefile @@ -8,7 +8,8 @@ kunit-objs += test.o \ try-catch.o \ executor.o \ attributes.o \ - device.o + device.o \ + platform.o
ifeq ($(CONFIG_KUNIT_DEBUGFS),y) kunit-objs += debugfs.o @@ -18,6 +19,7 @@ endif obj-y += hooks.o
obj-$(CONFIG_KUNIT_TEST) += kunit-test.o +obj-$(CONFIG_KUNIT_TEST) += platform-test.o
# string-stream-test compiles built-in only. ifeq ($(CONFIG_KUNIT_TEST),y) diff --git a/lib/kunit/platform-test.c b/lib/kunit/platform-test.c new file mode 100644 index 000000000000..b4fbedadc55e --- /dev/null +++ b/lib/kunit/platform-test.c @@ -0,0 +1,223 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit test for platform driver infrastructure. + */ + +#include <linux/platform_device.h> + +#include <kunit/platform_device.h> +#include <kunit/test.h> + +/* + * Test that kunit_platform_device_alloc() creates a platform device. + */ +static void kunit_platform_device_alloc_test(struct kunit *test) +{ + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, + kunit_platform_device_alloc(test, "kunit-platform", 1)); +} + +/* + * Test that kunit_platform_device_add() registers a platform device on the + * platform bus with the proper name and id. + */ +static void kunit_platform_device_add_test(struct kunit *test) +{ + struct platform_device *pdev; + const char *name = "kunit-platform-add"; + const int id = -1; + + pdev = kunit_platform_device_alloc(test, name, id); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); + + KUNIT_EXPECT_EQ(test, 0, kunit_platform_device_add(test, pdev)); + KUNIT_EXPECT_TRUE(test, dev_is_platform(&pdev->dev)); + KUNIT_EXPECT_STREQ(test, pdev->name, name); + KUNIT_EXPECT_EQ(test, pdev->id, id); +} + +/* + * Test that kunit_platform_device_add() called twice with the same device name + * and id fails the second time and properly cleans up. + */ +static void kunit_platform_device_add_twice_fails_test(struct kunit *test) +{ + struct platform_device *pdev; + const char *name = "kunit-platform-add-2"; + const int id = -1; + + pdev = kunit_platform_device_alloc(test, name, id); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); + KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev)); + + pdev = kunit_platform_device_alloc(test, name, id); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); + + KUNIT_EXPECT_NE(test, 0, kunit_platform_device_add(test, pdev)); +} + +static int kunit_platform_device_find_by_name(struct device *dev, const void *data) +{ + return strcmp(dev_name(dev), data) == 0; +} + +/* + * Test that kunit_platform_device_add() cleans up by removing the platform + * device when the test finishes. */ +static void kunit_platform_device_add_cleans_up(struct kunit *test) +{ + struct platform_device *pdev; + const char *name = "kunit-platform-clean"; + const int id = -1; + struct kunit fake; + struct device *dev; + + kunit_init_test(&fake, "kunit_platform_device_add_fake_test", NULL); + KUNIT_ASSERT_EQ(test, fake.status, KUNIT_SUCCESS); + + pdev = kunit_platform_device_alloc(&fake, name, id); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); + KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(&fake, pdev)); + dev = bus_find_device(&platform_bus_type, NULL, name, + kunit_platform_device_find_by_name); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); + put_device(dev); + + /* Remove pdev */ + kunit_cleanup(&fake); + + /* + * Failing to migrate the kunit_resource would lead to an extra + * put_device() call on the platform device. The best we can do here is + * make sure the device no longer exists on the bus, but if something + * is wrong we'll see a refcount underflow here. We can't test for a + * refcount underflow because the kref matches the lifetime of the + * device which should already be freed and could be used by something + * else. + */ + dev = bus_find_device(&platform_bus_type, NULL, name, + kunit_platform_device_find_by_name); + KUNIT_EXPECT_PTR_EQ(test, NULL, dev); + put_device(dev); +} + +/* + * Test suite for struct platform_device kunit APIs + */ +static struct kunit_case kunit_platform_device_test_cases[] = { + KUNIT_CASE(kunit_platform_device_alloc_test), + KUNIT_CASE(kunit_platform_device_add_test), + KUNIT_CASE(kunit_platform_device_add_twice_fails_test), + KUNIT_CASE(kunit_platform_device_add_cleans_up), + {} +}; + +static struct kunit_suite kunit_platform_device_suite = { + .name = "kunit_platform_device", + .test_cases = kunit_platform_device_test_cases, +}; + +struct kunit_platform_driver_test_context { + struct platform_driver pdrv; + const char *data; +}; + +static const char * const test_data = "test data"; + +static inline struct kunit_platform_driver_test_context * +to_test_context(struct platform_device *pdev) +{ + return container_of(to_platform_driver(pdev->dev.driver), + struct kunit_platform_driver_test_context, + pdrv); +} + +static int kunit_platform_driver_probe(struct platform_device *pdev) +{ + struct kunit_platform_driver_test_context *ctx; + + ctx = to_test_context(pdev); + ctx->data = test_data; + + return 0; +} + +/* Test that kunit_platform_driver_register() registers a driver that probes. */ +static void kunit_platform_driver_register_test(struct kunit *test) +{ + struct platform_device *pdev; + struct kunit_platform_driver_test_context *ctx; + DECLARE_COMPLETION_ONSTACK(comp); + const char *name = "kunit-platform-register"; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); + + pdev = kunit_platform_device_alloc(test, name, -1); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); + KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev)); + + ctx->pdrv.probe = kunit_platform_driver_probe; + ctx->pdrv.driver.name = name; + ctx->pdrv.driver.owner = THIS_MODULE; + + KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp)); + + KUNIT_EXPECT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv)); + KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ)); + KUNIT_EXPECT_STREQ(test, ctx->data, test_data); +} + +/* + * Test that kunit_platform_device_prepare_wait_for_probe() completes the completion + * when the device is already probed. + */ +static void kunit_platform_device_prepare_wait_for_probe_completes_when_already_probed(struct kunit *test) +{ + struct platform_device *pdev; + struct kunit_platform_driver_test_context *ctx; + DECLARE_COMPLETION_ONSTACK(comp); + const char *name = "kunit-platform-wait"; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); + + pdev = kunit_platform_device_alloc(test, name, -1); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); + KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev)); + + ctx->pdrv.probe = kunit_platform_driver_probe; + ctx->pdrv.driver.name = name; + ctx->pdrv.driver.owner = THIS_MODULE; + + /* Make sure driver has actually probed */ + KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp)); + KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv)); + KUNIT_ASSERT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ)); + + reinit_completion(&comp); + KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp)); + + KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, HZ)); +} + +static struct kunit_case kunit_platform_driver_test_cases[] = { + KUNIT_CASE(kunit_platform_driver_register_test), + KUNIT_CASE(kunit_platform_device_prepare_wait_for_probe_completes_when_already_probed), + {} +}; + +/* + * Test suite for struct platform_driver kunit APIs + */ +static struct kunit_suite kunit_platform_driver_suite = { + .name = "kunit_platform_driver", + .test_cases = kunit_platform_driver_test_cases, +}; + +kunit_test_suites( + &kunit_platform_device_suite, + &kunit_platform_driver_suite, +); + +MODULE_LICENSE("GPL"); diff --git a/lib/kunit/platform.c b/lib/kunit/platform.c new file mode 100644 index 000000000000..ba1b0006dc45 --- /dev/null +++ b/lib/kunit/platform.c @@ -0,0 +1,302 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Test managed platform driver + */ + +#include <linux/completion.h> +#include <linux/device/bus.h> +#include <linux/device/driver.h> +#include <linux/platform_device.h> + +#include <kunit/platform_device.h> +#include <kunit/resource.h> + +struct kunit_platform_device_alloc_params { + const char *name; + int id; +}; + +static int kunit_platform_device_alloc_init(struct kunit_resource *res, void *context) +{ + struct kunit_platform_device_alloc_params *params = context; + struct platform_device *pdev; + + pdev = platform_device_alloc(params->name, params->id); + if (!pdev) + return -ENOMEM; + + res->data = pdev; + + return 0; +} + +static void kunit_platform_device_alloc_exit(struct kunit_resource *res) +{ + struct platform_device *pdev = res->data; + + platform_device_put(pdev); +} + +/** + * kunit_platform_device_alloc() - Allocate a KUnit test managed platform device + * @test: test context + * @name: device name of platform device to alloc + * @id: identifier of platform device to alloc. + * + * Allocate a test managed platform device. The device is put when the test completes. + * + * Return: Allocated platform device on success, NULL on failure. + */ +struct platform_device * +kunit_platform_device_alloc(struct kunit *test, const char *name, int id) +{ + struct kunit_platform_device_alloc_params params = { + .name = name, + .id = id, + }; + + return kunit_alloc_resource(test, + kunit_platform_device_alloc_init, + kunit_platform_device_alloc_exit, + GFP_KERNEL, ¶ms); +} +EXPORT_SYMBOL_GPL(kunit_platform_device_alloc); + +static void kunit_platform_device_add_exit(struct kunit_resource *res) +{ + struct platform_device *pdev = res->data; + + platform_device_unregister(pdev); +} + +static bool +kunit_platform_device_alloc_match(struct kunit *test, + struct kunit_resource *res, void *match_data) +{ + struct platform_device *pdev = match_data; + + return res->data == pdev && res->free != kunit_platform_device_alloc_exit; +} + +KUNIT_DEFINE_ACTION_WRAPPER(platform_device_unregister_wrapper, + platform_device_unregister, struct platform_device *); +/** + * kunit_platform_device_add() - Register a KUnit test managed platform device + * @test: test context + * @pdev: platform device to add + * + * Register a test managed platform device. The device is unregistered when the + * test completes. + * + * Return: 0 on success, negative errno on failure. + */ +int kunit_platform_device_add(struct kunit *test, struct platform_device *pdev) +{ + struct kunit_resource *res; + int ret; + + ret = platform_device_add(pdev); + if (ret) + return ret; + + res = kunit_find_resource(test, kunit_platform_device_alloc_match, pdev); + if (res) { + /* + * Transfer the reference count of the platform device if it + * was allocated with kunit_platform_device_alloc(). In this + * case, calling platform_device_put() when the test exits from + * kunit_platform_device_alloc_exit() would lead to reference + * count underflow because platform_device_unregister_wrapper() + * calls platform_device_unregister() which also calls + * platform_device_put(). + * + * Usually callers transfer the refcount initialized in + * platform_device_alloc() to platform_device_add() by calling + * platform_device_unregister() when platform_device_add() + * succeeds or platform_device_put() when it fails. KUnit has to + * keep this straight by redirecting the free routine for the + * resource to the right function. Luckily this only has to + * account for the success scenario. + */ + res->free = kunit_platform_device_add_exit; + kunit_put_resource(res); + } else { + ret = kunit_add_action_or_reset(test, platform_device_unregister_wrapper, pdev); + if (ret) + return ret; + } + + return 0; +} +EXPORT_SYMBOL_GPL(kunit_platform_device_add); + +struct kunit_platform_device_probe_nb { + struct completion *x; + struct device *dev; + struct notifier_block nb; +}; + +static int kunit_platform_device_probe_notify(struct notifier_block *nb, + unsigned long event, void *data) +{ + struct kunit_platform_device_probe_nb *knb; + struct device *dev = data; + + knb = container_of(nb, struct kunit_platform_device_probe_nb, nb); + if (event != BUS_NOTIFY_BOUND_DRIVER || knb->dev != dev) + return NOTIFY_DONE; + + complete(knb->x); + + return NOTIFY_OK; +} + +static void kunit_platform_device_probe_nb_remove(void *nb) +{ + bus_unregister_notifier(&platform_bus_type, nb); +} + +/** + * kunit_platform_device_prepare_wait_for_probe() - Prepare a completion + * variable to wait for a platform device to probe + * @test: test context + * @pdev: platform device to prepare to wait for probe of + * @x: completion variable completed when @dev has probed + * + * Prepare a completion variable @x to wait for @pdev to probe. Waiting on the + * completion forces a preemption, allowing the platform driver to probe. + * + * Example + * + * .. code-block:: c + * + * static int kunit_platform_driver_probe(struct platform_device *pdev) + * { + * return 0; + * } + * + * static void kunit_platform_driver_test(struct kunit *test) + * { + * struct platform_device *pdev; + * struct platform_driver *pdrv; + * DECLARE_COMPLETION_ONSTACK(comp); + * + * pdev = kunit_platform_device_alloc(test, "kunit-platform", -1); + * KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); + * KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev)); + * + * pdrv = kunit_kzalloc(test, sizeof(*pdrv), GFP_KERNEL); + * KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdrv); + * + * pdrv->probe = kunit_platform_driver_probe; + * pdrv->driver.name = "kunit-platform"; + * pdrv->driver.owner = THIS_MODULE; + * + * KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp)); + * KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, pdrv)); + * + * KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ)); + * } + * + * Return: 0 on success, negative errno on failure. + */ +int kunit_platform_device_prepare_wait_for_probe(struct kunit *test, + struct platform_device *pdev, + struct completion *x) +{ + struct device *dev = &pdev->dev; + struct kunit_platform_device_probe_nb *knb; + bool bound; + + knb = kunit_kzalloc(test, sizeof(*knb), GFP_KERNEL); + if (!knb) + return -ENOMEM; + + knb->nb.notifier_call = kunit_platform_device_probe_notify; + knb->dev = dev; + knb->x = x; + + device_lock(dev); + bound = device_is_bound(dev); + if (bound) { + device_unlock(dev); + complete(x); + kunit_kfree(test, knb); + return 0; + } + + bus_register_notifier(&platform_bus_type, &knb->nb); + device_unlock(&pdev->dev); + + return kunit_add_action_or_reset(test, kunit_platform_device_probe_nb_remove, &knb->nb); +} +EXPORT_SYMBOL_GPL(kunit_platform_device_prepare_wait_for_probe); + +KUNIT_DEFINE_ACTION_WRAPPER(platform_driver_unregister_wrapper, + platform_driver_unregister, struct platform_driver *); +/** + * kunit_platform_driver_register() - Register a KUnit test managed platform driver + * @test: test context + * @drv: platform driver to register + * + * Register a test managed platform driver. This allows callers to embed the + * @drv in a container structure and use container_of() in the probe function + * to pass information to KUnit tests. + * + * Example + * + * .. code-block:: c + * + * struct kunit_test_context { + * struct platform_driver pdrv; + * const char *data; + * }; + * + * static inline struct kunit_test_context * + * to_test_context(struct platform_device *pdev) + * { + * return container_of(to_platform_driver(pdev->dev.driver), + * struct kunit_test_context, + * pdrv); + * } + * + * static int kunit_platform_driver_probe(struct platform_device *pdev) + * { + * struct kunit_test_context *ctx; + * + * ctx = to_test_context(pdev); + * ctx->data = "test data"; + * + * return 0; + * } + * + * static void kunit_platform_driver_test(struct kunit *test) + * { + * struct kunit_test_context *ctx; + * + * ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + * KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); + * + * ctx->pdrv.probe = kunit_platform_driver_probe; + * ctx->pdrv.driver.name = "kunit-platform"; + * ctx->pdrv.driver.owner = THIS_MODULE; + * + * KUNIT_EXPECT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv)); + * <... wait for driver to probe ...> + * KUNIT_EXPECT_STREQ(test, ctx->data, "test data"); + * } + * + * Return: 0 on success, negative errno on failure. + */ +int kunit_platform_driver_register(struct kunit *test, + struct platform_driver *drv) +{ + int ret; + + ret = platform_driver_register(drv); + if (ret) + return ret; + + return kunit_add_action_or_reset(test, platform_driver_unregister_wrapper, drv); +} +EXPORT_SYMBOL_GPL(kunit_platform_driver_register);
On Mon, Jun 03, 2024 at 03:38:03PM -0700, Stephen Boyd wrote:
Introduce KUnit resource wrappers around platform_driver_register(), platform_device_alloc(), and platform_device_add() so that test authors can register platform drivers/devices from their tests and have the drivers/devices automatically be unregistered when the test is done.
This makes test setup code simpler when a platform driver or platform device is needed. Add a few test cases at the same time to make sure the APIs work as intended.
Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Cc: Greg Kroah-Hartman gregkh@linuxfoundation.org Cc: "Rafael J. Wysocki" rafael@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org
Documentation/dev-tools/kunit/api/index.rst | 5 + .../dev-tools/kunit/api/platformdevice.rst | 10 + include/kunit/platform_device.h | 20 ++ lib/kunit/Makefile | 4 +- lib/kunit/platform-test.c | 223 +++++++++++++ lib/kunit/platform.c | 302 ++++++++++++++++++ 6 files changed, 563 insertions(+), 1 deletion(-) create mode 100644 Documentation/dev-tools/kunit/api/platformdevice.rst create mode 100644 include/kunit/platform_device.h create mode 100644 lib/kunit/platform-test.c create mode 100644 lib/kunit/platform.c
Reviewed-by: Greg Kroah-Hartman gregkh@linuxfoundation.org
On Tue, 4 Jun 2024 at 06:38, Stephen Boyd sboyd@kernel.org wrote:
Introduce KUnit resource wrappers around platform_driver_register(), platform_device_alloc(), and platform_device_add() so that test authors can register platform drivers/devices from their tests and have the drivers/devices automatically be unregistered when the test is done.
This makes test setup code simpler when a platform driver or platform device is needed. Add a few test cases at the same time to make sure the APIs work as intended.
Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Cc: Greg Kroah-Hartman gregkh@linuxfoundation.org Cc: "Rafael J. Wysocki" rafael@kernel.org Signed-off-by: Stephen Boyd sboyd@kernel.org
This looks great, thanks!
Reviewed-by: David Gow davidgow@google.com
Cheers, -- David
Documentation/dev-tools/kunit/api/index.rst | 5 + .../dev-tools/kunit/api/platformdevice.rst | 10 + include/kunit/platform_device.h | 20 ++ lib/kunit/Makefile | 4 +- lib/kunit/platform-test.c | 223 +++++++++++++ lib/kunit/platform.c | 302 ++++++++++++++++++ 6 files changed, 563 insertions(+), 1 deletion(-) create mode 100644 Documentation/dev-tools/kunit/api/platformdevice.rst create mode 100644 include/kunit/platform_device.h create mode 100644 lib/kunit/platform-test.c create mode 100644 lib/kunit/platform.c
diff --git a/Documentation/dev-tools/kunit/api/index.rst b/Documentation/dev-tools/kunit/api/index.rst index 282befa17edf..02b26f5e8750 100644 --- a/Documentation/dev-tools/kunit/api/index.rst +++ b/Documentation/dev-tools/kunit/api/index.rst @@ -10,6 +10,7 @@ API Reference resource functionredirection of
platformdeviceThis page documents the KUnit kernel testing API. It is divided into the @@ -36,3 +37,7 @@ Driver KUnit API Documentation/dev-tools/kunit/api/of.rst
- Documents the KUnit device tree (OF) API
+Documentation/dev-tools/kunit/api/platformdevice.rst
- Documents the KUnit platform device API
diff --git a/Documentation/dev-tools/kunit/api/platformdevice.rst b/Documentation/dev-tools/kunit/api/platformdevice.rst new file mode 100644 index 000000000000..49ddd5729003 --- /dev/null +++ b/Documentation/dev-tools/kunit/api/platformdevice.rst @@ -0,0 +1,10 @@ +.. SPDX-License-Identifier: GPL-2.0
+=================== +Platform Device API +===================
+The KUnit platform device API is used to test platform devices.
+.. kernel-doc:: lib/kunit/platform.c
- :export:
diff --git a/include/kunit/platform_device.h b/include/kunit/platform_device.h new file mode 100644 index 000000000000..0fc0999d2420 --- /dev/null +++ b/include/kunit/platform_device.h @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _KUNIT_PLATFORM_DRIVER_H +#define _KUNIT_PLATFORM_DRIVER_H
+struct kunit; +struct platform_device; +struct platform_driver;
+struct platform_device * +kunit_platform_device_alloc(struct kunit *test, const char *name, int id); +int kunit_platform_device_add(struct kunit *test, struct platform_device *pdev);
+int kunit_platform_device_prepare_wait_for_probe(struct kunit *test,
struct platform_device *pdev,struct completion *x);+int kunit_platform_driver_register(struct kunit *test,
struct platform_driver *drv);+#endif diff --git a/lib/kunit/Makefile b/lib/kunit/Makefile index 309659a32a78..a980ae62eff6 100644 --- a/lib/kunit/Makefile +++ b/lib/kunit/Makefile @@ -8,7 +8,8 @@ kunit-objs += test.o \ try-catch.o \ executor.o \ attributes.o \
device.o
device.o \platform.oifeq ($(CONFIG_KUNIT_DEBUGFS),y) kunit-objs += debugfs.o @@ -18,6 +19,7 @@ endif obj-y += hooks.o
obj-$(CONFIG_KUNIT_TEST) += kunit-test.o +obj-$(CONFIG_KUNIT_TEST) += platform-test.o
# string-stream-test compiles built-in only. ifeq ($(CONFIG_KUNIT_TEST),y) diff --git a/lib/kunit/platform-test.c b/lib/kunit/platform-test.c new file mode 100644 index 000000000000..b4fbedadc55e --- /dev/null +++ b/lib/kunit/platform-test.c @@ -0,0 +1,223 @@ +// SPDX-License-Identifier: GPL-2.0 +/*
- KUnit test for platform driver infrastructure.
- */
+#include <linux/platform_device.h>
+#include <kunit/platform_device.h> +#include <kunit/test.h>
+/*
- Test that kunit_platform_device_alloc() creates a platform device.
- */
+static void kunit_platform_device_alloc_test(struct kunit *test) +{
KUNIT_EXPECT_NOT_ERR_OR_NULL(test,kunit_platform_device_alloc(test, "kunit-platform", 1));+}
+/*
- Test that kunit_platform_device_add() registers a platform device on the
- platform bus with the proper name and id.
- */
+static void kunit_platform_device_add_test(struct kunit *test) +{
struct platform_device *pdev;const char *name = "kunit-platform-add";const int id = -1;pdev = kunit_platform_device_alloc(test, name, id);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);KUNIT_EXPECT_EQ(test, 0, kunit_platform_device_add(test, pdev));KUNIT_EXPECT_TRUE(test, dev_is_platform(&pdev->dev));KUNIT_EXPECT_STREQ(test, pdev->name, name);KUNIT_EXPECT_EQ(test, pdev->id, id);+}
+/*
- Test that kunit_platform_device_add() called twice with the same device name
- and id fails the second time and properly cleans up.
- */
+static void kunit_platform_device_add_twice_fails_test(struct kunit *test) +{
struct platform_device *pdev;const char *name = "kunit-platform-add-2";const int id = -1;pdev = kunit_platform_device_alloc(test, name, id);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));pdev = kunit_platform_device_alloc(test, name, id);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);KUNIT_EXPECT_NE(test, 0, kunit_platform_device_add(test, pdev));+}
+static int kunit_platform_device_find_by_name(struct device *dev, const void *data) +{
return strcmp(dev_name(dev), data) == 0;+}
+/*
- Test that kunit_platform_device_add() cleans up by removing the platform
- device when the test finishes. */
+static void kunit_platform_device_add_cleans_up(struct kunit *test) +{
struct platform_device *pdev;const char *name = "kunit-platform-clean";const int id = -1;struct kunit fake;struct device *dev;kunit_init_test(&fake, "kunit_platform_device_add_fake_test", NULL);KUNIT_ASSERT_EQ(test, fake.status, KUNIT_SUCCESS);pdev = kunit_platform_device_alloc(&fake, name, id);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(&fake, pdev));dev = bus_find_device(&platform_bus_type, NULL, name,kunit_platform_device_find_by_name);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);put_device(dev);/* Remove pdev */kunit_cleanup(&fake);/** Failing to migrate the kunit_resource would lead to an extra* put_device() call on the platform device. The best we can do here is* make sure the device no longer exists on the bus, but if something* is wrong we'll see a refcount underflow here. We can't test for a* refcount underflow because the kref matches the lifetime of the* device which should already be freed and could be used by something* else.*/dev = bus_find_device(&platform_bus_type, NULL, name,kunit_platform_device_find_by_name);KUNIT_EXPECT_PTR_EQ(test, NULL, dev);put_device(dev);+}
+/*
- Test suite for struct platform_device kunit APIs
- */
+static struct kunit_case kunit_platform_device_test_cases[] = {
KUNIT_CASE(kunit_platform_device_alloc_test),KUNIT_CASE(kunit_platform_device_add_test),KUNIT_CASE(kunit_platform_device_add_twice_fails_test),KUNIT_CASE(kunit_platform_device_add_cleans_up),{}+};
+static struct kunit_suite kunit_platform_device_suite = {
.name = "kunit_platform_device",.test_cases = kunit_platform_device_test_cases,+};
+struct kunit_platform_driver_test_context {
struct platform_driver pdrv;const char *data;+};
+static const char * const test_data = "test data";
+static inline struct kunit_platform_driver_test_context * +to_test_context(struct platform_device *pdev) +{
return container_of(to_platform_driver(pdev->dev.driver),struct kunit_platform_driver_test_context,pdrv);+}
+static int kunit_platform_driver_probe(struct platform_device *pdev) +{
struct kunit_platform_driver_test_context *ctx;ctx = to_test_context(pdev);ctx->data = test_data;return 0;+}
+/* Test that kunit_platform_driver_register() registers a driver that probes. */ +static void kunit_platform_driver_register_test(struct kunit *test) +{
struct platform_device *pdev;struct kunit_platform_driver_test_context *ctx;DECLARE_COMPLETION_ONSTACK(comp);const char *name = "kunit-platform-register";ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);pdev = kunit_platform_device_alloc(test, name, -1);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));ctx->pdrv.probe = kunit_platform_driver_probe;ctx->pdrv.driver.name = name;ctx->pdrv.driver.owner = THIS_MODULE;KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));KUNIT_EXPECT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ));KUNIT_EXPECT_STREQ(test, ctx->data, test_data);+}
+/*
- Test that kunit_platform_device_prepare_wait_for_probe() completes the completion
- when the device is already probed.
- */
+static void kunit_platform_device_prepare_wait_for_probe_completes_when_already_probed(struct kunit *test) +{
struct platform_device *pdev;struct kunit_platform_driver_test_context *ctx;DECLARE_COMPLETION_ONSTACK(comp);const char *name = "kunit-platform-wait";ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);pdev = kunit_platform_device_alloc(test, name, -1);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));ctx->pdrv.probe = kunit_platform_driver_probe;ctx->pdrv.driver.name = name;ctx->pdrv.driver.owner = THIS_MODULE;/* Make sure driver has actually probed */KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));KUNIT_ASSERT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ));reinit_completion(&comp);KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, HZ));+}
+static struct kunit_case kunit_platform_driver_test_cases[] = {
KUNIT_CASE(kunit_platform_driver_register_test),KUNIT_CASE(kunit_platform_device_prepare_wait_for_probe_completes_when_already_probed),{}+};
+/*
- Test suite for struct platform_driver kunit APIs
- */
+static struct kunit_suite kunit_platform_driver_suite = {
.name = "kunit_platform_driver",.test_cases = kunit_platform_driver_test_cases,+};
+kunit_test_suites(
&kunit_platform_device_suite,&kunit_platform_driver_suite,+);
+MODULE_LICENSE("GPL"); diff --git a/lib/kunit/platform.c b/lib/kunit/platform.c new file mode 100644 index 000000000000..ba1b0006dc45 --- /dev/null +++ b/lib/kunit/platform.c @@ -0,0 +1,302 @@ +// SPDX-License-Identifier: GPL-2.0 +/*
- Test managed platform driver
- */
+#include <linux/completion.h> +#include <linux/device/bus.h> +#include <linux/device/driver.h> +#include <linux/platform_device.h>
+#include <kunit/platform_device.h> +#include <kunit/resource.h>
+struct kunit_platform_device_alloc_params {
const char *name;int id;+};
+static int kunit_platform_device_alloc_init(struct kunit_resource *res, void *context) +{
struct kunit_platform_device_alloc_params *params = context;struct platform_device *pdev;pdev = platform_device_alloc(params->name, params->id);if (!pdev)return -ENOMEM;res->data = pdev;return 0;+}
+static void kunit_platform_device_alloc_exit(struct kunit_resource *res) +{
struct platform_device *pdev = res->data;platform_device_put(pdev);+}
+/**
- kunit_platform_device_alloc() - Allocate a KUnit test managed platform device
- @test: test context
- @name: device name of platform device to alloc
- @id: identifier of platform device to alloc.
- Allocate a test managed platform device. The device is put when the test completes.
- Return: Allocated platform device on success, NULL on failure.
- */
+struct platform_device * +kunit_platform_device_alloc(struct kunit *test, const char *name, int id) +{
struct kunit_platform_device_alloc_params params = {.name = name,.id = id,};return kunit_alloc_resource(test,kunit_platform_device_alloc_init,kunit_platform_device_alloc_exit,GFP_KERNEL, ¶ms);+} +EXPORT_SYMBOL_GPL(kunit_platform_device_alloc);
+static void kunit_platform_device_add_exit(struct kunit_resource *res) +{
struct platform_device *pdev = res->data;platform_device_unregister(pdev);+}
+static bool +kunit_platform_device_alloc_match(struct kunit *test,
struct kunit_resource *res, void *match_data)+{
struct platform_device *pdev = match_data;return res->data == pdev && res->free != kunit_platform_device_alloc_exit;+}
+KUNIT_DEFINE_ACTION_WRAPPER(platform_device_unregister_wrapper,
platform_device_unregister, struct platform_device *);+/**
- kunit_platform_device_add() - Register a KUnit test managed platform device
- @test: test context
- @pdev: platform device to add
- Register a test managed platform device. The device is unregistered when the
- test completes.
- Return: 0 on success, negative errno on failure.
- */
+int kunit_platform_device_add(struct kunit *test, struct platform_device *pdev) +{
struct kunit_resource *res;int ret;ret = platform_device_add(pdev);if (ret)return ret;res = kunit_find_resource(test, kunit_platform_device_alloc_match, pdev);if (res) {/** Transfer the reference count of the platform device if it* was allocated with kunit_platform_device_alloc(). In this* case, calling platform_device_put() when the test exits from* kunit_platform_device_alloc_exit() would lead to reference* count underflow because platform_device_unregister_wrapper()* calls platform_device_unregister() which also calls* platform_device_put().** Usually callers transfer the refcount initialized in* platform_device_alloc() to platform_device_add() by calling* platform_device_unregister() when platform_device_add()* succeeds or platform_device_put() when it fails. KUnit has to* keep this straight by redirecting the free routine for the* resource to the right function. Luckily this only has to* account for the success scenario.*/res->free = kunit_platform_device_add_exit;kunit_put_resource(res);} else {ret = kunit_add_action_or_reset(test, platform_device_unregister_wrapper, pdev);if (ret)return ret;}return 0;+} +EXPORT_SYMBOL_GPL(kunit_platform_device_add);
+struct kunit_platform_device_probe_nb {
struct completion *x;struct device *dev;struct notifier_block nb;+};
+static int kunit_platform_device_probe_notify(struct notifier_block *nb,
unsigned long event, void *data)+{
struct kunit_platform_device_probe_nb *knb;struct device *dev = data;knb = container_of(nb, struct kunit_platform_device_probe_nb, nb);if (event != BUS_NOTIFY_BOUND_DRIVER || knb->dev != dev)return NOTIFY_DONE;complete(knb->x);return NOTIFY_OK;+}
+static void kunit_platform_device_probe_nb_remove(void *nb) +{
bus_unregister_notifier(&platform_bus_type, nb);+}
+/**
- kunit_platform_device_prepare_wait_for_probe() - Prepare a completion
- variable to wait for a platform device to probe
- @test: test context
- @pdev: platform device to prepare to wait for probe of
- @x: completion variable completed when @dev has probed
- Prepare a completion variable @x to wait for @pdev to probe. Waiting on the
- completion forces a preemption, allowing the platform driver to probe.
- Example
- .. code-block:: c
static int kunit_platform_driver_probe(struct platform_device *pdev)
{
return 0;
}
static void kunit_platform_driver_test(struct kunit *test)
{
struct platform_device *pdev;
struct platform_driver *pdrv;
DECLARE_COMPLETION_ONSTACK(comp);
pdev = kunit_platform_device_alloc(test, "kunit-platform", -1);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));
pdrv = kunit_kzalloc(test, sizeof(*pdrv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdrv);
pdrv->probe = kunit_platform_driver_probe;
pdrv->driver.name = "kunit-platform";
pdrv->driver.owner = THIS_MODULE;
KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));
KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, pdrv));
KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ));
}
- Return: 0 on success, negative errno on failure.
- */
+int kunit_platform_device_prepare_wait_for_probe(struct kunit *test,
struct platform_device *pdev,struct completion *x)+{
struct device *dev = &pdev->dev;struct kunit_platform_device_probe_nb *knb;bool bound;knb = kunit_kzalloc(test, sizeof(*knb), GFP_KERNEL);if (!knb)return -ENOMEM;knb->nb.notifier_call = kunit_platform_device_probe_notify;knb->dev = dev;knb->x = x;device_lock(dev);bound = device_is_bound(dev);if (bound) {device_unlock(dev);complete(x);kunit_kfree(test, knb);return 0;}bus_register_notifier(&platform_bus_type, &knb->nb);device_unlock(&pdev->dev);return kunit_add_action_or_reset(test, kunit_platform_device_probe_nb_remove, &knb->nb);+} +EXPORT_SYMBOL_GPL(kunit_platform_device_prepare_wait_for_probe);
+KUNIT_DEFINE_ACTION_WRAPPER(platform_driver_unregister_wrapper,
platform_driver_unregister, struct platform_driver *);+/**
- kunit_platform_driver_register() - Register a KUnit test managed platform driver
- @test: test context
- @drv: platform driver to register
- Register a test managed platform driver. This allows callers to embed the
- @drv in a container structure and use container_of() in the probe function
- to pass information to KUnit tests.
- Example
- .. code-block:: c
struct kunit_test_context {
struct platform_driver pdrv;
const char *data;
};
static inline struct kunit_test_context *
to_test_context(struct platform_device *pdev)
{
return container_of(to_platform_driver(pdev->dev.driver),
struct kunit_test_context,
pdrv);
}
static int kunit_platform_driver_probe(struct platform_device *pdev)
{
struct kunit_test_context *ctx;
ctx = to_test_context(pdev);
ctx->data = "test data";
return 0;
}
static void kunit_platform_driver_test(struct kunit *test)
{
struct kunit_test_context *ctx;
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
ctx->pdrv.probe = kunit_platform_driver_probe;
ctx->pdrv.driver.name = "kunit-platform";
ctx->pdrv.driver.owner = THIS_MODULE;
KUNIT_EXPECT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));
<... wait for driver to probe ...>
KUNIT_EXPECT_STREQ(test, ctx->data, "test data");
}
- Return: 0 on success, negative errno on failure.
- */
+int kunit_platform_driver_register(struct kunit *test,
struct platform_driver *drv)+{
int ret;ret = platform_driver_register(drv);if (ret)return ret;return kunit_add_action_or_reset(test, platform_driver_unregister_wrapper, drv);+}
+EXPORT_SYMBOL_GPL(kunit_platform_driver_register);
https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/ https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git
Describe a binding for a device that consumes a single clk in DT. This will initially be used by a KUnit test to clk_get() the clk registered by of_fixed_clk_setup() and test that it is setup properly.
Cc: Rob Herring robh@kernel.org Cc: Krzysztof Kozlowski krzysztof.kozlowski+dt@linaro.org Cc: Conor Dooley conor+dt@kernel.org Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org --- .../test/test,single-clk-consumer.yaml | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml
diff --git a/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml b/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml new file mode 100644 index 000000000000..8c384c48707d --- /dev/null +++ b/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml @@ -0,0 +1,34 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/test/test,single-clk-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Test consumer of a single clock + +maintainers: + - Stephen Boyd sboyd@kernel.org + +description: + A consumer of a single clock used in tests. + +properties: + compatible: + const: test,single-clk-consumer + + clocks: + maxItems: 1 + +required: + - compatible + - clocks + +additionalProperties: false + +examples: + - | + clock-consumer { + compatible = "test,clk-fixed-rate"; + clocks = <&fixed_clk>; + }; +...
On Mon, 03 Jun 2024 15:38:04 -0700, Stephen Boyd wrote:
Describe a binding for a device that consumes a single clk in DT. This will initially be used by a KUnit test to clk_get() the clk registered by of_fixed_clk_setup() and test that it is setup properly.
Cc: Rob Herring robh@kernel.org Cc: Krzysztof Kozlowski krzysztof.kozlowski+dt@linaro.org Cc: Conor Dooley conor+dt@kernel.org Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org
.../test/test,single-clk-consumer.yaml | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml
My bot found errors running 'make dt_binding_check' on your patch:
yamllint warnings/errors:
dtschema/dtc warnings/errors: Documentation/devicetree/bindings/test/test,single-clk-consumer.example.dtb: /example-0/clock-consumer: failed to match any schema with compatible: ['test,clk-fixed-rate']
doc reference errors (make refcheckdocs):
See https://patchwork.ozlabs.org/project/devicetree-bindings/patch/2024060322381...
The base for the series is generally the latest rc1. A different dependency should be noted in *this* patch.
If you already ran 'make dt_binding_check' and didn't see the above error(s), then make sure 'yamllint' is installed and dt-schema is up to date:
pip3 install dtschema --upgrade
Please check and re-submit after running the above command yourself. Note that DT_SCHEMA_FILES can be set to your schema file to speed up checking your schema. However, it must be unset to test all examples with your schema.
On Mon, Jun 03, 2024 at 03:38:04PM -0700, Stephen Boyd wrote:
Describe a binding for a device that consumes a single clk in DT. This will initially be used by a KUnit test to clk_get() the clk registered by of_fixed_clk_setup() and test that it is setup properly.
Cc: Rob Herring robh@kernel.org Cc: Krzysztof Kozlowski krzysztof.kozlowski+dt@linaro.org Cc: Conor Dooley conor+dt@kernel.org Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org
.../test/test,single-clk-consumer.yaml | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml
diff --git a/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml b/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml new file mode 100644 index 000000000000..8c384c48707d --- /dev/null +++ b/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml @@ -0,0 +1,34 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/test/test,single-clk-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml#
+title: Test consumer of a single clock
+maintainers:
- Stephen Boyd sboyd@kernel.org
+description:
- A consumer of a single clock used in tests.
+properties:
- compatible:
- const: test,single-clk-consumer
I don't know if there's much value in defining bindings for tests. We could alternatively make 'test,' opt out of everything. There's already some support in dtschema for this with 'foo,'.
I need something for the DT unittest as well.
Rob
Quoting Rob Herring (2024-06-04 06:05:26)
On Mon, Jun 03, 2024 at 03:38:04PM -0700, Stephen Boyd wrote:
Describe a binding for a device that consumes a single clk in DT. This will initially be used by a KUnit test to clk_get() the clk registered by of_fixed_clk_setup() and test that it is setup properly.
Cc: Rob Herring robh@kernel.org Cc: Krzysztof Kozlowski krzysztof.kozlowski+dt@linaro.org Cc: Conor Dooley conor+dt@kernel.org Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org
.../test/test,single-clk-consumer.yaml | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml
diff --git a/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml b/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml new file mode 100644 index 000000000000..8c384c48707d --- /dev/null +++ b/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml @@ -0,0 +1,34 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/test/test,single-clk-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml#
+title: Test consumer of a single clock
+maintainers:
- Stephen Boyd sboyd@kernel.org
+description:
- A consumer of a single clock used in tests.
+properties:
- compatible:
- const: test,single-clk-consumer
I don't know if there's much value in defining bindings for tests. We could alternatively make 'test,' opt out of everything. There's already some support in dtschema for this with 'foo,'.
I need something for the DT unittest as well.
Ok. So I should drop this patch and the other one that adds a binding for the fake clock provider? And replace it with something that makes the test vendor prefix opt out of all checking? How is that done? Some patch to dtschema directly?
On Tue, Jun 4, 2024 at 1:28 PM Stephen Boyd sboyd@kernel.org wrote:
Quoting Rob Herring (2024-06-04 06:05:26)
On Mon, Jun 03, 2024 at 03:38:04PM -0700, Stephen Boyd wrote:
Describe a binding for a device that consumes a single clk in DT. This will initially be used by a KUnit test to clk_get() the clk registered by of_fixed_clk_setup() and test that it is setup properly.
Cc: Rob Herring robh@kernel.org Cc: Krzysztof Kozlowski krzysztof.kozlowski+dt@linaro.org Cc: Conor Dooley conor+dt@kernel.org Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org
.../test/test,single-clk-consumer.yaml | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml
diff --git a/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml b/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml new file mode 100644 index 000000000000..8c384c48707d --- /dev/null +++ b/Documentation/devicetree/bindings/test/test,single-clk-consumer.yaml @@ -0,0 +1,34 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/test/test,single-clk-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml#
+title: Test consumer of a single clock
+maintainers:
- Stephen Boyd sboyd@kernel.org
+description:
- A consumer of a single clock used in tests.
+properties:
- compatible:
- const: test,single-clk-consumer
I don't know if there's much value in defining bindings for tests. We could alternatively make 'test,' opt out of everything. There's already some support in dtschema for this with 'foo,'.
I need something for the DT unittest as well.
Ok. So I should drop this patch and the other one that adds a binding for the fake clock provider?
Yes.
And replace it with something that makes the test vendor prefix opt out of all checking? How is that done? Some patch to dtschema directly?
Yes, but I just added it for you.
Rob
Quoting Rob Herring (2024-06-04 13:19:18)
On Tue, Jun 4, 2024 at 1:28 PM Stephen Boyd sboyd@kernel.org wrote:
And replace it with something that makes the test vendor prefix opt out of all checking? How is that done? Some patch to dtschema directly?
Yes, but I just added it for you.
Thanks! I'll wait another day or two before resending then.
Unit tests are more ergonomic and simpler to understand if they don't have to hoist a bunch of code into the test harness init and exit functions. Add some test managed wrappers for the clk APIs so that clk unit tests can write more code in the actual test and less code in the harness.
Only add APIs that are used for now. More wrappers can be added in the future as necessary.
Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org --- Documentation/dev-tools/kunit/api/clk.rst | 10 + Documentation/dev-tools/kunit/api/index.rst | 5 + drivers/clk/Makefile | 5 + drivers/clk/clk_kunit_helpers.c | 204 ++++++++++++++++++++ include/kunit/clk.h | 28 +++ 5 files changed, 252 insertions(+) create mode 100644 Documentation/dev-tools/kunit/api/clk.rst create mode 100644 drivers/clk/clk_kunit_helpers.c create mode 100644 include/kunit/clk.h
diff --git a/Documentation/dev-tools/kunit/api/clk.rst b/Documentation/dev-tools/kunit/api/clk.rst new file mode 100644 index 000000000000..eeaa50089453 --- /dev/null +++ b/Documentation/dev-tools/kunit/api/clk.rst @@ -0,0 +1,10 @@ +.. SPDX-License-Identifier: GPL-2.0 + +======== +Clk API +======== + +The KUnit clk API is used to test clk providers and clk consumers. + +.. kernel-doc:: drivers/clk/clk_kunit_helpers.c + :export: diff --git a/Documentation/dev-tools/kunit/api/index.rst b/Documentation/dev-tools/kunit/api/index.rst index 02b26f5e8750..5cdb552a0808 100644 --- a/Documentation/dev-tools/kunit/api/index.rst +++ b/Documentation/dev-tools/kunit/api/index.rst @@ -9,6 +9,7 @@ API Reference test resource functionredirection + clk of platformdevice
@@ -34,6 +35,10 @@ Documentation/dev-tools/kunit/api/functionredirection.rst Driver KUnit API ================
+Documentation/dev-tools/kunit/api/clk.rst + + - Documents the KUnit clk API + Documentation/dev-tools/kunit/api/of.rst
- Documents the KUnit device tree (OF) API diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index 4abe16c8ccdf..8bb63f1ddd98 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -18,6 +18,11 @@ ifeq ($(CONFIG_OF), y) obj-$(CONFIG_COMMON_CLK) += clk-conf.o endif
+# KUnit specific helpers +ifeq ($(CONFIG_COMMON_CLK), y) +obj-$(CONFIG_KUNIT) += clk_kunit_helpers.o +endif + # hardware specific clock types # please keep this section sorted lexicographically by file path name obj-$(CONFIG_COMMON_CLK_APPLE_NCO) += clk-apple-nco.o diff --git a/drivers/clk/clk_kunit_helpers.c b/drivers/clk/clk_kunit_helpers.c new file mode 100644 index 000000000000..c4287d20214c --- /dev/null +++ b/drivers/clk/clk_kunit_helpers.c @@ -0,0 +1,204 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit helpers for clk providers and consumers + */ +#include <linux/clk.h> +#include <linux/clk-provider.h> +#include <linux/err.h> +#include <linux/kernel.h> +#include <linux/slab.h> + +#include <kunit/clk.h> +#include <kunit/resource.h> + +KUNIT_DEFINE_ACTION_WRAPPER(clk_disable_unprepare_wrapper, + clk_disable_unprepare, struct clk *); +/** + * clk_prepare_enable_kunit() - Test managed clk_prepare_enable() + * @test: The test context + * @clk: clk to prepare and enable + * + * Return: 0 on success, or negative errno on failure. + */ +int clk_prepare_enable_kunit(struct kunit *test, struct clk *clk) +{ + int ret; + + ret = clk_prepare_enable(clk); + if (ret) + return ret; + + return kunit_add_action_or_reset(test, clk_disable_unprepare_wrapper, + clk); +} +EXPORT_SYMBOL_GPL(clk_prepare_enable_kunit); + +KUNIT_DEFINE_ACTION_WRAPPER(clk_put_wrapper, clk_put, struct clk *); + +static struct clk *__clk_get_kunit(struct kunit *test, struct clk *clk) +{ + int ret; + + if (IS_ERR(clk)) + return clk; + + ret = kunit_add_action_or_reset(test, clk_put_wrapper, clk); + if (ret) + return ERR_PTR(ret); + + return clk; +} + +/** + * clk_get_kunit() - Test managed clk_get() + * @test: The test context + * @dev: device for clock "consumer" + * @con_id: clock consumer ID + * + * Just like clk_get(), except the clk is managed by the test case and is + * automatically put with clk_put() after the test case concludes. + * + * Return: new clk consumer or ERR_PTR on failure. + */ +struct clk * +clk_get_kunit(struct kunit *test, struct device *dev, const char *con_id) +{ + struct clk *clk; + + clk = clk_get(dev, con_id); + + return __clk_get_kunit(test, clk); +} +EXPORT_SYMBOL_GPL(clk_get_kunit); + +/** + * of_clk_get_kunit() - Test managed of_clk_get() + * @test: The test context + * @np: device_node for clock "consumer" + * @index: index in 'clocks' property of @np + * + * Just like of_clk_get(), except the clk is managed by the test case and is + * automatically put with clk_put() after the test case concludes. + * + * Return: new clk consumer or ERR_PTR on failure. + */ +struct clk * +of_clk_get_kunit(struct kunit *test, struct device_node *np, int index) +{ + struct clk *clk; + + clk = of_clk_get(np, index); + + return __clk_get_kunit(test, clk); +} +EXPORT_SYMBOL_GPL(of_clk_get_kunit); + +/** + * clk_hw_get_clk_kunit() - Test managed clk_hw_get_clk() + * @test: The test context + * @hw: clk_hw associated with the clk being consumed + * @con_id: connection ID string on device + * + * Just like clk_hw_get_clk(), except the clk is managed by the test case and + * is automatically put with clk_put() after the test case concludes. + * + * Return: new clk consumer or ERR_PTR on failure. + */ +struct clk * +clk_hw_get_clk_kunit(struct kunit *test, struct clk_hw *hw, const char *con_id) +{ + struct clk *clk; + + clk = clk_hw_get_clk(hw, con_id); + + return __clk_get_kunit(test, clk); +} +EXPORT_SYMBOL_GPL(clk_hw_get_clk_kunit); + +/** + * clk_hw_get_clk_prepared_enabled_kunit() - Test managed clk_hw_get_clk() + clk_prepare_enable() + * @test: The test context + * @hw: clk_hw associated with the clk being consumed + * @con_id: connection ID string on device + * + * Just like + * + * .. code-block:: c + * + * struct clk *clk = clk_hw_get_clk(...); + * clk_prepare_enable(clk); + * + * except the clk is managed by the test case and is automatically disabled and + * unprepared with clk_disable_unprepare() and put with clk_put() after the + * test case concludes. + * + * Return: new clk consumer that is prepared and enabled or ERR_PTR on failure. + */ +struct clk * +clk_hw_get_clk_prepared_enabled_kunit(struct kunit *test, struct clk_hw *hw, + const char *con_id) +{ + int ret; + struct clk *clk; + + clk = clk_hw_get_clk_kunit(test, hw, con_id); + if (IS_ERR(clk)) + return clk; + + ret = clk_prepare_enable_kunit(test, clk); + if (ret) + return ERR_PTR(ret); + + return clk; +} +EXPORT_SYMBOL_GPL(clk_hw_get_clk_prepared_enabled_kunit); + +KUNIT_DEFINE_ACTION_WRAPPER(clk_hw_unregister_wrapper, + clk_hw_unregister, struct clk_hw *); + +/** + * clk_hw_register_kunit() - Test managed clk_hw_register() + * @test: The test context + * @dev: device that is registering this clock + * @hw: link to hardware-specific clock data + * + * Just like clk_hw_register(), except the clk registration is managed by the + * test case and is automatically unregistered after the test case concludes. + * + * Return: 0 on success or a negative errno value on failure. + */ +int clk_hw_register_kunit(struct kunit *test, struct device *dev, struct clk_hw *hw) +{ + int ret; + + ret = clk_hw_register(dev, hw); + if (ret) + return ret; + + return kunit_add_action_or_reset(test, clk_hw_unregister_wrapper, hw); +} +EXPORT_SYMBOL_GPL(clk_hw_register_kunit); + +/** + * of_clk_hw_register_kunit() - Test managed of_clk_hw_register() + * @test: The test context + * @node: device_node of device that is registering this clock + * @hw: link to hardware-specific clock data + * + * Just like of_clk_hw_register(), except the clk registration is managed by + * the test case and is automatically unregistered after the test case + * concludes. + * + * Return: 0 on success or a negative errno value on failure. + */ +int of_clk_hw_register_kunit(struct kunit *test, struct device_node *node, struct clk_hw *hw) +{ + int ret; + + ret = of_clk_hw_register(node, hw); + if (ret) + return ret; + + return kunit_add_action_or_reset(test, clk_hw_unregister_wrapper, hw); +} +EXPORT_SYMBOL_GPL(of_clk_hw_register_kunit); diff --git a/include/kunit/clk.h b/include/kunit/clk.h new file mode 100644 index 000000000000..73bc99cefe7b --- /dev/null +++ b/include/kunit/clk.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _CLK_KUNIT_H +#define _CLK_KUNIT_H + +struct clk; +struct clk_hw; +struct device; +struct device_node; +struct kunit; + +struct clk * +clk_get_kunit(struct kunit *test, struct device *dev, const char *con_id); +struct clk * +of_clk_get_kunit(struct kunit *test, struct device_node *np, int index); + +struct clk * +clk_hw_get_clk_kunit(struct kunit *test, struct clk_hw *hw, const char *con_id); +struct clk * +clk_hw_get_clk_prepared_enabled_kunit(struct kunit *test, struct clk_hw *hw, + const char *con_id); + +int clk_prepare_enable_kunit(struct kunit *test, struct clk *clk); + +int clk_hw_register_kunit(struct kunit *test, struct device *dev, struct clk_hw *hw); +int of_clk_hw_register_kunit(struct kunit *test, struct device_node *node, + struct clk_hw *hw); + +#endif
Test that the fixed rate basic type clk works as intended.
Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org --- drivers/clk/.kunitconfig | 2 + drivers/clk/Kconfig | 8 + drivers/clk/Makefile | 1 + drivers/clk/clk-fixed-rate_test.c | 379 +++++++++++++++++++++ drivers/clk/clk-fixed-rate_test.h | 8 + drivers/clk/kunit_clk_fixed_rate_test.dtso | 19 ++ 6 files changed, 417 insertions(+) create mode 100644 drivers/clk/clk-fixed-rate_test.c create mode 100644 drivers/clk/clk-fixed-rate_test.h create mode 100644 drivers/clk/kunit_clk_fixed_rate_test.dtso
diff --git a/drivers/clk/.kunitconfig b/drivers/clk/.kunitconfig index efa12ac2b3f2..54ece9207055 100644 --- a/drivers/clk/.kunitconfig +++ b/drivers/clk/.kunitconfig @@ -1,6 +1,8 @@ CONFIG_KUNIT=y +CONFIG_OF=y CONFIG_COMMON_CLK=y CONFIG_CLK_KUNIT_TEST=y +CONFIG_CLK_FIXED_RATE_KUNIT_TEST=y CONFIG_CLK_GATE_KUNIT_TEST=y CONFIG_CLK_FD_KUNIT_TEST=y CONFIG_UML_PCI_OVER_VIRTIO=n diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig index 3e9099504fad..f649f2a0279c 100644 --- a/drivers/clk/Kconfig +++ b/drivers/clk/Kconfig @@ -511,6 +511,14 @@ config CLK_KUNIT_TEST help Kunit tests for the common clock framework.
+config CLK_FIXED_RATE_KUNIT_TEST + tristate "Basic fixed rate clk type KUnit test" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS + select OF_OVERLAY if OF + help + KUnit tests for the basic fixed rate clk type. + config CLK_GATE_KUNIT_TEST tristate "Basic gate type Kunit test" if !KUNIT_ALL_TESTS depends on KUNIT diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index 8bb63f1ddd98..7b57e3d22cee 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -6,6 +6,7 @@ obj-$(CONFIG_CLK_KUNIT_TEST) += clk_test.o 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_CLK_FIXED_RATE_KUNIT_TEST) += clk-fixed-rate_test.o kunit_clk_fixed_rate_test.dtbo.o obj-$(CONFIG_COMMON_CLK) += clk-gate.o obj-$(CONFIG_CLK_GATE_KUNIT_TEST) += clk-gate_test.o obj-$(CONFIG_COMMON_CLK) += clk-multiplier.o diff --git a/drivers/clk/clk-fixed-rate_test.c b/drivers/clk/clk-fixed-rate_test.c new file mode 100644 index 000000000000..799be9f2d1de --- /dev/null +++ b/drivers/clk/clk-fixed-rate_test.c @@ -0,0 +1,379 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit test for clk fixed rate basic type + */ +#include <linux/clk.h> +#include <linux/clk-provider.h> +#include <linux/completion.h> +#include <linux/of.h> +#include <linux/platform_device.h> + +#include <kunit/clk.h> +#include <kunit/of.h> +#include <kunit/platform_device.h> +#include <kunit/resource.h> +#include <kunit/test.h> + +#include "clk-fixed-rate_test.h" + +/** + * struct clk_hw_fixed_rate_kunit_params - Parameters to pass to __clk_hw_register_fixed_rate() + * @dev: device registering clk + * @np: device_node of device registering clk + * @name: name of clk + * @parent_name: parent name of clk + * @parent_hw: clk_hw pointer to parent of clk + * @parent_data: parent_data describing parent of clk + * @flags: clk framework flags + * @fixed_rate: frequency of clk + * @fixed_accuracy: accuracy of clk + * @clk_fixed_flags: fixed rate specific clk flags + */ +struct clk_hw_fixed_rate_kunit_params { + struct device *dev; + struct device_node *np; + const char *name; + const char *parent_name; + const struct clk_hw *parent_hw; + const struct clk_parent_data *parent_data; + unsigned long flags; + unsigned long fixed_rate; + unsigned long fixed_accuracy; + unsigned long clk_fixed_flags; +}; + +static int +clk_hw_register_fixed_rate_kunit_init(struct kunit_resource *res, void *context) +{ + struct clk_hw_fixed_rate_kunit_params *params = context; + struct clk_hw *hw; + + hw = __clk_hw_register_fixed_rate(params->dev, params->np, + params->name, + params->parent_name, + params->parent_hw, + params->parent_data, + params->flags, + params->fixed_rate, + params->fixed_accuracy, + params->clk_fixed_flags, + false); + if (IS_ERR(hw)) + return PTR_ERR(hw); + + res->data = hw; + + return 0; +} + +static void clk_hw_register_fixed_rate_kunit_exit(struct kunit_resource *res) +{ + struct clk_hw *hw = res->data; + + clk_hw_unregister_fixed_rate(hw); +} + +/** + * clk_hw_register_fixed_rate_kunit() - Test managed __clk_hw_register_fixed_rate() + * @test: The test context + * @params: Arguments to __clk_hw_register_fixed_rate() + * + * Return: Registered fixed rate clk_hw or ERR_PTR on failure + */ +static struct clk_hw * +clk_hw_register_fixed_rate_kunit(struct kunit *test, + struct clk_hw_fixed_rate_kunit_params *params) +{ + struct clk_hw *hw; + + hw = kunit_alloc_resource(test, + clk_hw_register_fixed_rate_kunit_init, + clk_hw_register_fixed_rate_kunit_exit, + GFP_KERNEL, params); + if (!hw) + return ERR_PTR(-EINVAL); + + return hw; +} + +/** + * clk_hw_unregister_fixed_rate_kunit() - Test managed clk_hw_unregister_fixed_rate() + * @test: The test context + * @hw: fixed rate clk to unregister upon test completion + * + * Automatically unregister @hw when @test is complete via + * clk_hw_unregister_fixed_rate(). + * + * Return: 0 on success or negative errno on failure + */ +static int clk_hw_unregister_fixed_rate_kunit(struct kunit *test, struct clk_hw *hw) +{ + if (!kunit_alloc_resource(test, NULL, + clk_hw_register_fixed_rate_kunit_exit, + GFP_KERNEL, hw)) + return -ENOMEM; + + return 0; +} + +/* + * Test that clk_get_rate() on a fixed rate clk registered with + * clk_hw_register_fixed_rate() gets the proper frequency. + */ +static void clk_fixed_rate_rate_test(struct kunit *test) +{ + struct clk_hw *hw; + struct clk *clk; + const unsigned long fixed_rate = 230000; + + hw = clk_hw_register_fixed_rate(NULL, "test-fixed-rate", NULL, 0, fixed_rate); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); + KUNIT_ASSERT_EQ(test, 0, clk_hw_unregister_fixed_rate_kunit(test, hw)); + + clk = clk_hw_get_clk_prepared_enabled_kunit(test, hw, __func__); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk); + + KUNIT_EXPECT_EQ(test, fixed_rate, clk_get_rate(clk)); +} + +/* + * Test that clk_get_accuracy() on a fixed rate clk registered via + * clk_hw_register_fixed_rate_with_accuracy() gets the proper accuracy. + */ +static void clk_fixed_rate_accuracy_test(struct kunit *test) +{ + struct clk_hw *hw; + struct clk *clk; + const unsigned long fixed_accuracy = 5000; + + hw = clk_hw_register_fixed_rate_with_accuracy(NULL, "test-fixed-rate", + NULL, 0, 0, + fixed_accuracy); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); + KUNIT_ASSERT_EQ(test, 0, clk_hw_unregister_fixed_rate_kunit(test, hw)); + + clk = clk_hw_get_clk_kunit(test, hw, __func__); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk); + + KUNIT_EXPECT_EQ(test, fixed_accuracy, clk_get_accuracy(clk)); +} + +/* Test suite for a fixed rate clk without any parent */ +static struct kunit_case clk_fixed_rate_test_cases[] = { + KUNIT_CASE(clk_fixed_rate_rate_test), + KUNIT_CASE(clk_fixed_rate_accuracy_test), + {} +}; + +static struct kunit_suite clk_fixed_rate_suite = { + .name = "clk_fixed_rate", + .test_cases = clk_fixed_rate_test_cases, +}; + +/* + * Test that clk_get_parent() on a fixed rate clk gets the proper parent. + */ +static void clk_fixed_rate_parent_test(struct kunit *test) +{ + struct clk_hw *hw, *parent_hw; + struct clk *expected_parent, *actual_parent; + struct clk *clk; + const char *parent_name = "test-fixed-rate-parent"; + struct clk_hw_fixed_rate_kunit_params parent_params = { + .name = parent_name, + }; + + parent_hw = clk_hw_register_fixed_rate_kunit(test, &parent_params); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw); + KUNIT_ASSERT_STREQ(test, parent_name, clk_hw_get_name(parent_hw)); + + expected_parent = clk_hw_get_clk_kunit(test, parent_hw, __func__); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_parent); + + hw = clk_hw_register_fixed_rate(NULL, "test-fixed-rate", parent_name, 0, 0); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); + KUNIT_ASSERT_EQ(test, 0, clk_hw_unregister_fixed_rate_kunit(test, hw)); + + clk = clk_hw_get_clk_kunit(test, hw, __func__); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk); + + actual_parent = clk_get_parent(clk); + KUNIT_EXPECT_TRUE(test, clk_is_match(expected_parent, actual_parent)); +} + +/* + * Test that clk_get_rate() on a fixed rate clk ignores the parent rate. + */ +static void clk_fixed_rate_parent_rate_test(struct kunit *test) +{ + struct clk_hw *hw, *parent_hw; + struct clk *clk; + const unsigned long expected_rate = 1405; + const unsigned long parent_rate = 90402; + const char *parent_name = "test-fixed-rate-parent"; + struct clk_hw_fixed_rate_kunit_params parent_params = { + .name = parent_name, + .fixed_rate = parent_rate, + }; + + parent_hw = clk_hw_register_fixed_rate_kunit(test, &parent_params); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw); + KUNIT_ASSERT_STREQ(test, parent_name, clk_hw_get_name(parent_hw)); + + hw = clk_hw_register_fixed_rate(NULL, "test-fixed-rate", parent_name, 0, + expected_rate); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); + KUNIT_ASSERT_EQ(test, 0, clk_hw_unregister_fixed_rate_kunit(test, hw)); + + clk = clk_hw_get_clk_prepared_enabled_kunit(test, hw, __func__); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk); + + KUNIT_EXPECT_EQ(test, expected_rate, clk_get_rate(clk)); +} + +/* + * Test that clk_get_accuracy() on a fixed rate clk ignores the parent accuracy. + */ +static void clk_fixed_rate_parent_accuracy_test(struct kunit *test) +{ + struct clk_hw *hw, *parent_hw; + struct clk *clk; + const unsigned long expected_accuracy = 900; + const unsigned long parent_accuracy = 24000; + const char *parent_name = "test-fixed-rate-parent"; + struct clk_hw_fixed_rate_kunit_params parent_params = { + .name = parent_name, + .fixed_accuracy = parent_accuracy, + }; + + parent_hw = clk_hw_register_fixed_rate_kunit(test, &parent_params); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw); + KUNIT_ASSERT_STREQ(test, parent_name, clk_hw_get_name(parent_hw)); + + hw = clk_hw_register_fixed_rate_with_accuracy(NULL, "test-fixed-rate", + parent_name, 0, 0, + expected_accuracy); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); + KUNIT_ASSERT_EQ(test, 0, clk_hw_unregister_fixed_rate_kunit(test, hw)); + + clk = clk_hw_get_clk_kunit(test, hw, __func__); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk); + + KUNIT_EXPECT_EQ(test, expected_accuracy, clk_get_accuracy(clk)); +} + +/* Test suite for a fixed rate clk with a parent */ +static struct kunit_case clk_fixed_rate_parent_test_cases[] = { + KUNIT_CASE(clk_fixed_rate_parent_test), + KUNIT_CASE(clk_fixed_rate_parent_rate_test), + KUNIT_CASE(clk_fixed_rate_parent_accuracy_test), + {} +}; + +static struct kunit_suite clk_fixed_rate_parent_suite = { + .name = "clk_fixed_rate_parent", + .test_cases = clk_fixed_rate_parent_test_cases, +}; + +struct clk_fixed_rate_of_test_context { + struct device *dev; + struct platform_driver pdrv; + struct completion probed; +}; + +static inline struct clk_fixed_rate_of_test_context * +pdev_to_clk_fixed_rate_of_test_context(struct platform_device *pdev) +{ + return container_of(to_platform_driver(pdev->dev.driver), + struct clk_fixed_rate_of_test_context, + pdrv); +} + +/* + * Test that of_fixed_clk_setup() registers a fixed rate clk with the proper + * rate. + */ +static void clk_fixed_rate_of_probe_test(struct kunit *test) +{ + struct clk_fixed_rate_of_test_context *ctx = test->priv; + struct device *dev = ctx->dev; + struct clk *clk; + + clk = clk_get_kunit(test, dev, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk); + + KUNIT_ASSERT_EQ(test, 0, clk_prepare_enable_kunit(test, clk)); + KUNIT_EXPECT_EQ(test, TEST_FIXED_FREQUENCY, clk_get_rate(clk)); +} + +/* + * Test that of_fixed_clk_setup() registers a fixed rate clk with the proper + * accuracy. + */ +static void clk_fixed_rate_of_accuracy_test(struct kunit *test) +{ + struct clk_fixed_rate_of_test_context *ctx = test->priv; + struct device *dev = ctx->dev; + struct clk *clk; + + clk = clk_get_kunit(test, dev, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk); + + KUNIT_EXPECT_EQ(test, TEST_FIXED_ACCURACY, clk_get_accuracy(clk)); +} + +static struct kunit_case clk_fixed_rate_of_cases[] = { + KUNIT_CASE(clk_fixed_rate_of_probe_test), + KUNIT_CASE(clk_fixed_rate_of_accuracy_test), + {} +}; + +static int clk_fixed_rate_of_test_probe(struct platform_device *pdev) +{ + struct clk_fixed_rate_of_test_context *ctx; + + ctx = pdev_to_clk_fixed_rate_of_test_context(pdev); + ctx->dev = &pdev->dev; + complete(&ctx->probed); + + return 0; +} + +static int clk_fixed_rate_of_init(struct kunit *test) +{ + struct clk_fixed_rate_of_test_context *ctx; + static const struct of_device_id match_table[] = { + { .compatible = "test,single-clk-consumer" }, + { } + }; + + KUNIT_ASSERT_EQ(test, 0, of_overlay_apply_kunit(test, kunit_clk_fixed_rate_test)); + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); + test->priv = ctx; + + ctx->pdrv.probe = clk_fixed_rate_of_test_probe; + ctx->pdrv.driver.of_match_table = match_table; + ctx->pdrv.driver.name = __func__; + ctx->pdrv.driver.owner = THIS_MODULE; + init_completion(&ctx->probed); + + KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv)); + KUNIT_ASSERT_NE(test, 0, wait_for_completion_timeout(&ctx->probed, HZ)); + + return 0; +} + +static struct kunit_suite clk_fixed_rate_of_suite = { + .name = "clk_fixed_rate_of", + .init = clk_fixed_rate_of_init, + .test_cases = clk_fixed_rate_of_cases, +}; + +kunit_test_suites( + &clk_fixed_rate_suite, + &clk_fixed_rate_of_suite, + &clk_fixed_rate_parent_suite, +); +MODULE_LICENSE("GPL"); diff --git a/drivers/clk/clk-fixed-rate_test.h b/drivers/clk/clk-fixed-rate_test.h new file mode 100644 index 000000000000..e0d28e5b6081 --- /dev/null +++ b/drivers/clk/clk-fixed-rate_test.h @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _CLK_FIXED_RATE_TEST_H +#define _CLK_FIXED_RATE_TEST_H + +#define TEST_FIXED_FREQUENCY 50000000 +#define TEST_FIXED_ACCURACY 300 + +#endif diff --git a/drivers/clk/kunit_clk_fixed_rate_test.dtso b/drivers/clk/kunit_clk_fixed_rate_test.dtso new file mode 100644 index 000000000000..d838ce766fa2 --- /dev/null +++ b/drivers/clk/kunit_clk_fixed_rate_test.dtso @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: GPL-2.0 +/dts-v1/; +/plugin/; + +#include "clk-fixed-rate_test.h" + +&{/} { + fixed_50MHz: kunit-clock { + compatible = "fixed-clock"; + #clock-cells = <0>; + clock-frequency = <TEST_FIXED_FREQUENCY>; + clock-accuracy = <TEST_FIXED_ACCURACY>; + }; + + kunit-clock-consumer { + compatible = "test,single-clk-consumer"; + clocks = <&fixed_50MHz>; + }; +};
Describe a binding for a device that provides and consumes clks in DT so that a KUnit test can register clks based on the device node and test clk_hw_register() with struct clk_parent_data.
Reviewed-by: Rob Herring robh@kernel.org Cc: Krzysztof Kozlowski krzysztof.kozlowski+dt@linaro.org Cc: Conor Dooley conor+dt@kernel.org Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org --- .../bindings/clock/test,clk-parent-data.yaml | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 Documentation/devicetree/bindings/clock/test,clk-parent-data.yaml
diff --git a/Documentation/devicetree/bindings/clock/test,clk-parent-data.yaml b/Documentation/devicetree/bindings/clock/test,clk-parent-data.yaml new file mode 100644 index 000000000000..a2f927526405 --- /dev/null +++ b/Documentation/devicetree/bindings/clock/test,clk-parent-data.yaml @@ -0,0 +1,47 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/clock/test,clk-parent-data.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Fake clk provider for clk_parent_data unit tests + +maintainers: + - Stephen Boyd sboyd@kernel.org + +description: + A clk provider to test the struct clk_parent_data implementation in the Linux + kernel. + +properties: + compatible: + const: test,clk-parent-data + + clocks: + items: + - description: Fixed parent + - description: 50 MHz fixed parent + + clock-names: + items: + - const: parent_fwname + - const: "50" + + "#clock-cells": + const: 1 + +required: + - compatible + - "#clock-cells" + +additionalProperties: false + +examples: + - | + clock-controller { + compatible = "test,clk-parent-data"; + #clock-cells = <1>; + clocks = <&fixed_parent>, <&fixed_50MHz>; + clock-names = "parent_fwname", "50"; + }; +...
Test that clks registered with 'struct clk_parent_data' work as intended and can find their parents.
Cc: Christian Marangi ansuelsmth@gmail.com Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org --- drivers/clk/Kconfig | 1 + drivers/clk/Makefile | 3 +- drivers/clk/clk_parent_data_test.h | 10 + drivers/clk/clk_test.c | 451 +++++++++++++++++++- drivers/clk/kunit_clk_parent_data_test.dtso | 28 ++ 5 files changed, 491 insertions(+), 2 deletions(-) create mode 100644 drivers/clk/clk_parent_data_test.h create mode 100644 drivers/clk/kunit_clk_parent_data_test.dtso
diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig index f649f2a0279c..c33fdf9fdcd6 100644 --- a/drivers/clk/Kconfig +++ b/drivers/clk/Kconfig @@ -508,6 +508,7 @@ config CLK_KUNIT_TEST tristate "Basic Clock Framework Kunit Tests" if !KUNIT_ALL_TESTS depends on KUNIT default KUNIT_ALL_TESTS + select OF_OVERLAY if OF help Kunit tests for the common clock framework.
diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index 7b57e3d22cee..ed4e1a0e6943 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -2,7 +2,8 @@ # common clock types obj-$(CONFIG_HAVE_CLK) += clk-devres.o clk-bulk.o clkdev.o obj-$(CONFIG_COMMON_CLK) += clk.o -obj-$(CONFIG_CLK_KUNIT_TEST) += clk_test.o +obj-$(CONFIG_CLK_KUNIT_TEST) += clk_test.o \ + kunit_clk_parent_data_test.dtbo.o obj-$(CONFIG_COMMON_CLK) += clk-divider.o obj-$(CONFIG_COMMON_CLK) += clk-fixed-factor.o obj-$(CONFIG_COMMON_CLK) += clk-fixed-rate.o diff --git a/drivers/clk/clk_parent_data_test.h b/drivers/clk/clk_parent_data_test.h new file mode 100644 index 000000000000..eedd53ae910d --- /dev/null +++ b/drivers/clk/clk_parent_data_test.h @@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _CLK_PARENT_DATA_TEST_H +#define _CLK_PARENT_DATA_TEST_H + +#define CLK_PARENT_DATA_1MHZ_NAME "1mhz_fixed_legacy" +#define CLK_PARENT_DATA_PARENT1 "parent_fwname" +#define CLK_PARENT_DATA_PARENT2 "50" +#define CLK_PARENT_DATA_50MHZ_NAME "50_clk" + +#endif diff --git a/drivers/clk/clk_test.c b/drivers/clk/clk_test.c index 39e2b5ff4f51..bdf3c4bb2243 100644 --- a/drivers/clk/clk_test.c +++ b/drivers/clk/clk_test.c @@ -4,12 +4,19 @@ */ #include <linux/clk.h> #include <linux/clk-provider.h> +#include <linux/of.h> +#include <linux/platform_device.h>
/* Needed for clk_hw_get_clk() */ #include "clk.h"
+#include <kunit/clk.h> +#include <kunit/of.h> +#include <kunit/platform_device.h> #include <kunit/test.h>
+#include "clk_parent_data_test.h" + static const struct clk_ops empty_clk_ops = { };
#define DUMMY_CLOCK_INIT_RATE (42 * 1000 * 1000) @@ -2659,6 +2666,446 @@ static struct kunit_suite clk_mux_no_reparent_test_suite = { .test_cases = clk_mux_no_reparent_test_cases, };
+struct clk_register_clk_parent_data_test_case { + const char *desc; + struct clk_parent_data pdata; +}; + +static void +clk_register_clk_parent_data_test_case_to_desc( + const struct clk_register_clk_parent_data_test_case *t, char *desc) +{ + strcpy(desc, t->desc); +} + +static const struct clk_register_clk_parent_data_test_case +clk_register_clk_parent_data_of_cases[] = { + { + /* + * Test that a clk registered with a struct device_node can + * find a parent based on struct clk_parent_data::index. + */ + .desc = "clk_parent_data_of_index_test", + .pdata.index = 0, + }, + { + /* + * Test that a clk registered with a struct device_node can + * find a parent based on struct clk_parent_data::fwname. + */ + .desc = "clk_parent_data_of_fwname_test", + .pdata.fw_name = CLK_PARENT_DATA_PARENT1, + }, + { + /* + * Test that a clk registered with a struct device_node can + * find a parent based on struct clk_parent_data::name. + */ + .desc = "clk_parent_data_of_name_test", + /* The index must be negative to indicate firmware not used */ + .pdata.index = -1, + .pdata.name = CLK_PARENT_DATA_1MHZ_NAME, + }, + { + /* + * Test that a clk registered with a struct device_node can + * find a parent based on struct + * clk_parent_data::{fw_name,name}. + */ + .desc = "clk_parent_data_of_fwname_name_test", + .pdata.fw_name = CLK_PARENT_DATA_PARENT1, + .pdata.name = "not_matching", + }, + { + /* + * Test that a clk registered with a struct device_node can + * find a parent based on struct clk_parent_data::{index,name}. + * Index takes priority. + */ + .desc = "clk_parent_data_of_index_name_priority_test", + .pdata.index = 0, + .pdata.name = "not_matching", + }, + { + /* + * Test that a clk registered with a struct device_node can + * find a parent based on struct + * clk_parent_data::{index,fwname,name}. The fw_name takes + * priority over index and name. + */ + .desc = "clk_parent_data_of_index_fwname_name_priority_test", + .pdata.index = 1, + .pdata.fw_name = CLK_PARENT_DATA_PARENT1, + .pdata.name = "not_matching", + }, +}; + +KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_of_test, clk_register_clk_parent_data_of_cases, + clk_register_clk_parent_data_test_case_to_desc) + +/** + * struct clk_register_clk_parent_data_of_ctx - Context for clk_parent_data OF tests + * @np: device node of clk under test + * @hw: clk_hw for clk under test + */ +struct clk_register_clk_parent_data_of_ctx { + struct device_node *np; + struct clk_hw hw; +}; + +static int clk_register_clk_parent_data_of_test_init(struct kunit *test) +{ + struct clk_register_clk_parent_data_of_ctx *ctx; + + KUNIT_ASSERT_EQ(test, 0, + of_overlay_apply_kunit(test, kunit_clk_parent_data_test)); + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + test->priv = ctx; + + ctx->np = of_find_compatible_node(NULL, NULL, "test,clk-parent-data"); + if (!ctx->np) + return -ENODEV; + + return kunit_add_action_or_reset(test, (kunit_action_t *)&of_node_put, ctx->np); +} + +/* + * Test that a clk registered with a struct device_node can find a parent based on + * struct clk_parent_data when the hw member isn't set. + */ +static void clk_register_clk_parent_data_of_test(struct kunit *test) +{ + struct clk_register_clk_parent_data_of_ctx *ctx = test->priv; + struct clk_hw *parent_hw; + const struct clk_register_clk_parent_data_test_case *test_param; + struct clk_init_data init = { }; + struct clk *expected_parent, *actual_parent; + + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->np); + + expected_parent = of_clk_get_kunit(test, ctx->np, 0); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_parent); + + test_param = test->param_value; + init.parent_data = &test_param->pdata; + init.num_parents = 1; + init.name = "parent_data_of_test_clk"; + init.ops = &clk_dummy_single_parent_ops; + ctx->hw.init = &init; + KUNIT_ASSERT_EQ(test, 0, of_clk_hw_register_kunit(test, ctx->np, &ctx->hw)); + + parent_hw = clk_hw_get_parent(&ctx->hw); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw); + + actual_parent = clk_hw_get_clk_kunit(test, parent_hw, __func__); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, actual_parent); + + KUNIT_EXPECT_TRUE(test, clk_is_match(expected_parent, actual_parent)); +} + +static struct kunit_case clk_register_clk_parent_data_of_test_cases[] = { + KUNIT_CASE_PARAM(clk_register_clk_parent_data_of_test, + clk_register_clk_parent_data_of_test_gen_params), + {} +}; + +/* + * Test suite for registering clks with struct clk_parent_data and a struct + * device_node. + */ +static struct kunit_suite clk_register_clk_parent_data_of_suite = { + .name = "clk_register_clk_parent_data_of", + .init = clk_register_clk_parent_data_of_test_init, + .test_cases = clk_register_clk_parent_data_of_test_cases, +}; + +/** + * struct clk_register_clk_parent_data_device_ctx - Context for clk_parent_data device tests + * @dev: device of clk under test + * @hw: clk_hw for clk under test + * @pdrv: driver to attach to find @dev + */ +struct clk_register_clk_parent_data_device_ctx { + struct device *dev; + struct clk_hw hw; + struct platform_driver pdrv; +}; + +static inline struct clk_register_clk_parent_data_device_ctx * +clk_register_clk_parent_data_driver_to_test_context(struct platform_device *pdev) +{ + return container_of(to_platform_driver(pdev->dev.driver), + struct clk_register_clk_parent_data_device_ctx, pdrv); +} + +static int clk_register_clk_parent_data_device_probe(struct platform_device *pdev) +{ + struct clk_register_clk_parent_data_device_ctx *ctx; + + ctx = clk_register_clk_parent_data_driver_to_test_context(pdev); + ctx->dev = &pdev->dev; + + return 0; +} + +static void clk_register_clk_parent_data_device_driver(struct kunit *test) +{ + struct clk_register_clk_parent_data_device_ctx *ctx = test->priv; + static const struct of_device_id match_table[] = { + { .compatible = "test,clk-parent-data" }, + { } + }; + + ctx->pdrv.probe = clk_register_clk_parent_data_device_probe; + ctx->pdrv.driver.of_match_table = match_table; + ctx->pdrv.driver.name = __func__; + ctx->pdrv.driver.owner = THIS_MODULE; + + KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv)); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->dev); +} + +static const struct clk_register_clk_parent_data_test_case +clk_register_clk_parent_data_device_cases[] = { + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::index. + */ + .desc = "clk_parent_data_device_index_test", + .pdata.index = 1, + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::fwname. + */ + .desc = "clk_parent_data_device_fwname_test", + .pdata.fw_name = CLK_PARENT_DATA_PARENT2, + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::name. + */ + .desc = "clk_parent_data_device_name_test", + /* The index must be negative to indicate firmware not used */ + .pdata.index = -1, + .pdata.name = CLK_PARENT_DATA_50MHZ_NAME, + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::{fw_name,name}. + */ + .desc = "clk_parent_data_device_fwname_name_test", + .pdata.fw_name = CLK_PARENT_DATA_PARENT2, + .pdata.name = "not_matching", + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::{index,name}. Index + * takes priority. + */ + .desc = "clk_parent_data_device_index_name_priority_test", + .pdata.index = 1, + .pdata.name = "not_matching", + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::{index,fwname,name}. + * The fw_name takes priority over index and name. + */ + .desc = "clk_parent_data_device_index_fwname_name_priority_test", + .pdata.index = 0, + .pdata.fw_name = CLK_PARENT_DATA_PARENT2, + .pdata.name = "not_matching", + }, +}; + +KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_device_test, + clk_register_clk_parent_data_device_cases, + clk_register_clk_parent_data_test_case_to_desc) + +/* + * Test that a clk registered with a struct device can find a parent based on + * struct clk_parent_data when the hw member isn't set. + */ +static void clk_register_clk_parent_data_device_test(struct kunit *test) +{ + struct clk_register_clk_parent_data_device_ctx *ctx; + const struct clk_register_clk_parent_data_test_case *test_param; + struct clk_hw *parent_hw; + struct clk_init_data init = { }; + struct clk *expected_parent, *actual_parent; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); + test->priv = ctx; + + clk_register_clk_parent_data_device_driver(test); + + expected_parent = clk_get_kunit(test, ctx->dev, "50"); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_parent); + + test_param = test->param_value; + init.parent_data = &test_param->pdata; + init.num_parents = 1; + init.name = "parent_data_device_test_clk"; + init.ops = &clk_dummy_single_parent_ops; + ctx->hw.init = &init; + KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, ctx->dev, &ctx->hw)); + + parent_hw = clk_hw_get_parent(&ctx->hw); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw); + + actual_parent = clk_hw_get_clk_kunit(test, parent_hw, __func__); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, actual_parent); + + KUNIT_EXPECT_TRUE(test, clk_is_match(expected_parent, actual_parent)); +} + +static const struct clk_register_clk_parent_data_test_case +clk_register_clk_parent_data_device_hw_cases[] = { + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::hw. + */ + .desc = "clk_parent_data_device_hw_index_test", + /* The index must be negative to indicate firmware not used */ + .pdata.index = -1, + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::hw when + * struct clk_parent_data::fw_name is set. + */ + .desc = "clk_parent_data_device_hw_fwname_test", + .pdata.fw_name = CLK_PARENT_DATA_PARENT2, + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::hw when struct + * clk_parent_data::name is set. + */ + .desc = "clk_parent_data_device_hw_name_test", + /* The index must be negative to indicate firmware not used */ + .pdata.index = -1, + .pdata.name = CLK_PARENT_DATA_50MHZ_NAME, + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::hw when struct + * clk_parent_data::{fw_name,name} are set. + */ + .desc = "clk_parent_data_device_hw_fwname_name_test", + .pdata.fw_name = CLK_PARENT_DATA_PARENT2, + .pdata.name = "not_matching", + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::hw when struct + * clk_parent_data::index is set. The hw pointer takes + * priority. + */ + .desc = "clk_parent_data_device_hw_index_priority_test", + .pdata.index = 0, + }, + { + /* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::hw when + * struct clk_parent_data::{index,fwname,name} are set. + * The hw pointer takes priority over everything else. + */ + .desc = "clk_parent_data_device_hw_index_fwname_name_priority_test", + .pdata.index = 0, + .pdata.fw_name = CLK_PARENT_DATA_PARENT2, + .pdata.name = "not_matching", + }, +}; + +KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_device_hw_test, + clk_register_clk_parent_data_device_hw_cases, + clk_register_clk_parent_data_test_case_to_desc) + +/* + * Test that a clk registered with a struct device can find a + * parent based on struct clk_parent_data::hw. + */ +static void clk_register_clk_parent_data_device_hw_test(struct kunit *test) +{ + struct clk_register_clk_parent_data_device_ctx *ctx; + const struct clk_register_clk_parent_data_test_case *test_param; + struct clk_dummy_context *parent; + struct clk_hw *parent_hw; + struct clk_parent_data pdata = { }; + struct clk_init_data init = { }; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); + test->priv = ctx; + + clk_register_clk_parent_data_device_driver(test); + + parent = kunit_kzalloc(test, sizeof(*parent), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent); + + parent_hw = &parent->hw; + parent_hw->init = CLK_HW_INIT_NO_PARENT("parent-clk", + &clk_dummy_rate_ops, 0); + + KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, ctx->dev, parent_hw)); + + test_param = test->param_value; + memcpy(&pdata, &test_param->pdata, sizeof(pdata)); + pdata.hw = parent_hw; + init.parent_data = &pdata; + init.num_parents = 1; + init.ops = &clk_dummy_single_parent_ops; + init.name = "parent_data_device_hw_test_clk"; + ctx->hw.init = &init; + KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, ctx->dev, &ctx->hw)); + + KUNIT_EXPECT_PTR_EQ(test, parent_hw, clk_hw_get_parent(&ctx->hw)); +} + +static struct kunit_case clk_register_clk_parent_data_device_test_cases[] = { + KUNIT_CASE_PARAM(clk_register_clk_parent_data_device_test, + clk_register_clk_parent_data_device_test_gen_params), + KUNIT_CASE_PARAM(clk_register_clk_parent_data_device_hw_test, + clk_register_clk_parent_data_device_hw_test_gen_params), + {} +}; + +static int clk_register_clk_parent_data_device_init(struct kunit *test) +{ + KUNIT_ASSERT_EQ(test, 0, + of_overlay_apply_kunit(test, kunit_clk_parent_data_test)); + + return 0; +} + +/* + * Test suite for registering clks with struct clk_parent_data and a struct + * device. + */ +static struct kunit_suite clk_register_clk_parent_data_device_suite = { + .name = "clk_register_clk_parent_data_device", + .init = clk_register_clk_parent_data_device_init, + .test_cases = clk_register_clk_parent_data_device_test_cases, +}; + kunit_test_suites( &clk_leaf_mux_set_rate_parent_test_suite, &clk_test_suite, @@ -2671,7 +3118,9 @@ kunit_test_suites( &clk_range_test_suite, &clk_range_maximize_test_suite, &clk_range_minimize_test_suite, + &clk_register_clk_parent_data_of_suite, + &clk_register_clk_parent_data_device_suite, &clk_single_parent_mux_test_suite, - &clk_uncached_test_suite + &clk_uncached_test_suite, ); MODULE_LICENSE("GPL v2"); diff --git a/drivers/clk/kunit_clk_parent_data_test.dtso b/drivers/clk/kunit_clk_parent_data_test.dtso new file mode 100644 index 000000000000..7d3ed9a5a2e8 --- /dev/null +++ b/drivers/clk/kunit_clk_parent_data_test.dtso @@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0 +/dts-v1/; +/plugin/; + +#include "clk_parent_data_test.h" + +&{/} { + fixed_50: kunit-clock-50MHz { + compatible = "fixed-clock"; + #clock-cells = <0>; + clock-frequency = <50000000>; + clock-output-names = CLK_PARENT_DATA_50MHZ_NAME; + }; + + fixed_parent: kunit-clock-1MHz { + compatible = "fixed-clock"; + #clock-cells = <0>; + clock-frequency = <1000000>; + clock-output-names = CLK_PARENT_DATA_1MHZ_NAME; + }; + + kunit-clock-controller { + compatible = "test,clk-parent-data"; + clocks = <&fixed_parent>, <&fixed_50>; + clock-names = CLK_PARENT_DATA_PARENT1, CLK_PARENT_DATA_PARENT2; + #clock-cells = <1>; + }; +};
On Tue, 4 Jun 2024 at 06:38, Stephen Boyd sboyd@kernel.org wrote:
Test that clks registered with 'struct clk_parent_data' work as intended and can find their parents.
Cc: Christian Marangi ansuelsmth@gmail.com Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org
This seems good to me overall, but will break if we can't compile the dtbo.o file. Maybe these need to live behind a #if IS_ENABLED(CONFIG_OF) or equivalent.
Also, there's a cast to kunit_action_t* which needs to use a wrapper.
Otherwise, Reviewed-by: David Gow davidgow@google.com
Cheers, -- David
drivers/clk/Kconfig | 1 + drivers/clk/Makefile | 3 +- drivers/clk/clk_parent_data_test.h | 10 + drivers/clk/clk_test.c | 451 +++++++++++++++++++- drivers/clk/kunit_clk_parent_data_test.dtso | 28 ++ 5 files changed, 491 insertions(+), 2 deletions(-) create mode 100644 drivers/clk/clk_parent_data_test.h create mode 100644 drivers/clk/kunit_clk_parent_data_test.dtso
diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig index f649f2a0279c..c33fdf9fdcd6 100644 --- a/drivers/clk/Kconfig +++ b/drivers/clk/Kconfig @@ -508,6 +508,7 @@ config CLK_KUNIT_TEST tristate "Basic Clock Framework Kunit Tests" if !KUNIT_ALL_TESTS depends on KUNIT default KUNIT_ALL_TESTS
select OF_OVERLAY if OF help Kunit tests for the common clock framework.diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index 7b57e3d22cee..ed4e1a0e6943 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -2,7 +2,8 @@ # common clock types obj-$(CONFIG_HAVE_CLK) += clk-devres.o clk-bulk.o clkdev.o obj-$(CONFIG_COMMON_CLK) += clk.o -obj-$(CONFIG_CLK_KUNIT_TEST) += clk_test.o +obj-$(CONFIG_CLK_KUNIT_TEST) += clk_test.o \
kunit_clk_parent_data_test.dtbo.o
This breaks if CONFIG_OF isn't enabled, as there's no rule to compile it: make[5]: *** No rule to make target 'drivers/clk/kunit_clk_parent_data_test.dtbo.o', needed by 'drivers/clk/modules.order'. Stop.
obj-$(CONFIG_COMMON_CLK) += clk-divider.o obj-$(CONFIG_COMMON_CLK) += clk-fixed-factor.o obj-$(CONFIG_COMMON_CLK) += clk-fixed-rate.o diff --git a/drivers/clk/clk_parent_data_test.h b/drivers/clk/clk_parent_data_test.h new file mode 100644 index 000000000000..eedd53ae910d --- /dev/null +++ b/drivers/clk/clk_parent_data_test.h @@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _CLK_PARENT_DATA_TEST_H +#define _CLK_PARENT_DATA_TEST_H
+#define CLK_PARENT_DATA_1MHZ_NAME "1mhz_fixed_legacy" +#define CLK_PARENT_DATA_PARENT1 "parent_fwname" +#define CLK_PARENT_DATA_PARENT2 "50" +#define CLK_PARENT_DATA_50MHZ_NAME "50_clk"
+#endif diff --git a/drivers/clk/clk_test.c b/drivers/clk/clk_test.c index 39e2b5ff4f51..bdf3c4bb2243 100644 --- a/drivers/clk/clk_test.c +++ b/drivers/clk/clk_test.c @@ -4,12 +4,19 @@ */ #include <linux/clk.h> #include <linux/clk-provider.h> +#include <linux/of.h> +#include <linux/platform_device.h>
/* Needed for clk_hw_get_clk() */ #include "clk.h"
+#include <kunit/clk.h> +#include <kunit/of.h> +#include <kunit/platform_device.h> #include <kunit/test.h>
+#include "clk_parent_data_test.h"
static const struct clk_ops empty_clk_ops = { };
#define DUMMY_CLOCK_INIT_RATE (42 * 1000 * 1000) @@ -2659,6 +2666,446 @@ static struct kunit_suite clk_mux_no_reparent_test_suite = { .test_cases = clk_mux_no_reparent_test_cases, };
+struct clk_register_clk_parent_data_test_case {
const char *desc;struct clk_parent_data pdata;+};
+static void +clk_register_clk_parent_data_test_case_to_desc(
const struct clk_register_clk_parent_data_test_case *t, char *desc)+{
strcpy(desc, t->desc);+}
+static const struct clk_register_clk_parent_data_test_case +clk_register_clk_parent_data_of_cases[] = {
{/** Test that a clk registered with a struct device_node can* find a parent based on struct clk_parent_data::index.*/.desc = "clk_parent_data_of_index_test",.pdata.index = 0,},{/** Test that a clk registered with a struct device_node can* find a parent based on struct clk_parent_data::fwname.*/.desc = "clk_parent_data_of_fwname_test",.pdata.fw_name = CLK_PARENT_DATA_PARENT1,},{/** Test that a clk registered with a struct device_node can* find a parent based on struct clk_parent_data::name.*/.desc = "clk_parent_data_of_name_test",/* The index must be negative to indicate firmware not used */.pdata.index = -1,.pdata.name = CLK_PARENT_DATA_1MHZ_NAME,},{/** Test that a clk registered with a struct device_node can* find a parent based on struct* clk_parent_data::{fw_name,name}.*/.desc = "clk_parent_data_of_fwname_name_test",.pdata.fw_name = CLK_PARENT_DATA_PARENT1,.pdata.name = "not_matching",},{/** Test that a clk registered with a struct device_node can* find a parent based on struct clk_parent_data::{index,name}.* Index takes priority.*/.desc = "clk_parent_data_of_index_name_priority_test",.pdata.index = 0,.pdata.name = "not_matching",},{/** Test that a clk registered with a struct device_node can* find a parent based on struct* clk_parent_data::{index,fwname,name}. The fw_name takes* priority over index and name.*/.desc = "clk_parent_data_of_index_fwname_name_priority_test",.pdata.index = 1,.pdata.fw_name = CLK_PARENT_DATA_PARENT1,.pdata.name = "not_matching",},+};
+KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_of_test, clk_register_clk_parent_data_of_cases,
clk_register_clk_parent_data_test_case_to_desc)+/**
- struct clk_register_clk_parent_data_of_ctx - Context for clk_parent_data OF tests
- @np: device node of clk under test
- @hw: clk_hw for clk under test
- */
+struct clk_register_clk_parent_data_of_ctx {
struct device_node *np;struct clk_hw hw;+};
+static int clk_register_clk_parent_data_of_test_init(struct kunit *test) +{
struct clk_register_clk_parent_data_of_ctx *ctx;KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(test, kunit_clk_parent_data_test));ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);if (!ctx)return -ENOMEM;test->priv = ctx;ctx->np = of_find_compatible_node(NULL, NULL, "test,clk-parent-data");if (!ctx->np)return -ENODEV;return kunit_add_action_or_reset(test, (kunit_action_t *)&of_node_put, ctx->np);
We should use an action wrapper here (KUNIT_DEFINE_ACTION_WRAPPER()), as casting function pointers to kunit_action_t* breaks control-flow integrity.
+}
+/*
- Test that a clk registered with a struct device_node can find a parent based on
- struct clk_parent_data when the hw member isn't set.
- */
+static void clk_register_clk_parent_data_of_test(struct kunit *test) +{
struct clk_register_clk_parent_data_of_ctx *ctx = test->priv;struct clk_hw *parent_hw;const struct clk_register_clk_parent_data_test_case *test_param;struct clk_init_data init = { };struct clk *expected_parent, *actual_parent;KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->np);expected_parent = of_clk_get_kunit(test, ctx->np, 0);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_parent);test_param = test->param_value;init.parent_data = &test_param->pdata;init.num_parents = 1;init.name = "parent_data_of_test_clk";init.ops = &clk_dummy_single_parent_ops;ctx->hw.init = &init;KUNIT_ASSERT_EQ(test, 0, of_clk_hw_register_kunit(test, ctx->np, &ctx->hw));parent_hw = clk_hw_get_parent(&ctx->hw);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw);actual_parent = clk_hw_get_clk_kunit(test, parent_hw, __func__);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, actual_parent);KUNIT_EXPECT_TRUE(test, clk_is_match(expected_parent, actual_parent));+}
+static struct kunit_case clk_register_clk_parent_data_of_test_cases[] = {
KUNIT_CASE_PARAM(clk_register_clk_parent_data_of_test,clk_register_clk_parent_data_of_test_gen_params),{}+};
+/*
- Test suite for registering clks with struct clk_parent_data and a struct
- device_node.
- */
+static struct kunit_suite clk_register_clk_parent_data_of_suite = {
.name = "clk_register_clk_parent_data_of",.init = clk_register_clk_parent_data_of_test_init,.test_cases = clk_register_clk_parent_data_of_test_cases,+};
+/**
- struct clk_register_clk_parent_data_device_ctx - Context for clk_parent_data device tests
- @dev: device of clk under test
- @hw: clk_hw for clk under test
- @pdrv: driver to attach to find @dev
- */
+struct clk_register_clk_parent_data_device_ctx {
struct device *dev;struct clk_hw hw;struct platform_driver pdrv;+};
+static inline struct clk_register_clk_parent_data_device_ctx * +clk_register_clk_parent_data_driver_to_test_context(struct platform_device *pdev) +{
return container_of(to_platform_driver(pdev->dev.driver),struct clk_register_clk_parent_data_device_ctx, pdrv);+}
+static int clk_register_clk_parent_data_device_probe(struct platform_device *pdev) +{
struct clk_register_clk_parent_data_device_ctx *ctx;ctx = clk_register_clk_parent_data_driver_to_test_context(pdev);ctx->dev = &pdev->dev;return 0;+}
+static void clk_register_clk_parent_data_device_driver(struct kunit *test) +{
struct clk_register_clk_parent_data_device_ctx *ctx = test->priv;static const struct of_device_id match_table[] = {{ .compatible = "test,clk-parent-data" },{ }};ctx->pdrv.probe = clk_register_clk_parent_data_device_probe;ctx->pdrv.driver.of_match_table = match_table;ctx->pdrv.driver.name = __func__;ctx->pdrv.driver.owner = THIS_MODULE;KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->dev);+}
+static const struct clk_register_clk_parent_data_test_case +clk_register_clk_parent_data_device_cases[] = {
{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::index.*/.desc = "clk_parent_data_device_index_test",.pdata.index = 1,},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::fwname.*/.desc = "clk_parent_data_device_fwname_test",.pdata.fw_name = CLK_PARENT_DATA_PARENT2,},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::name.*/.desc = "clk_parent_data_device_name_test",/* The index must be negative to indicate firmware not used */.pdata.index = -1,.pdata.name = CLK_PARENT_DATA_50MHZ_NAME,},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::{fw_name,name}.*/.desc = "clk_parent_data_device_fwname_name_test",.pdata.fw_name = CLK_PARENT_DATA_PARENT2,.pdata.name = "not_matching",},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::{index,name}. Index* takes priority.*/.desc = "clk_parent_data_device_index_name_priority_test",.pdata.index = 1,.pdata.name = "not_matching",},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::{index,fwname,name}.* The fw_name takes priority over index and name.*/.desc = "clk_parent_data_device_index_fwname_name_priority_test",.pdata.index = 0,.pdata.fw_name = CLK_PARENT_DATA_PARENT2,.pdata.name = "not_matching",},+};
+KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_device_test,
clk_register_clk_parent_data_device_cases,clk_register_clk_parent_data_test_case_to_desc)+/*
- Test that a clk registered with a struct device can find a parent based on
- struct clk_parent_data when the hw member isn't set.
- */
+static void clk_register_clk_parent_data_device_test(struct kunit *test) +{
struct clk_register_clk_parent_data_device_ctx *ctx;const struct clk_register_clk_parent_data_test_case *test_param;struct clk_hw *parent_hw;struct clk_init_data init = { };struct clk *expected_parent, *actual_parent;ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);test->priv = ctx;clk_register_clk_parent_data_device_driver(test);expected_parent = clk_get_kunit(test, ctx->dev, "50");KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_parent);test_param = test->param_value;init.parent_data = &test_param->pdata;init.num_parents = 1;init.name = "parent_data_device_test_clk";init.ops = &clk_dummy_single_parent_ops;ctx->hw.init = &init;KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, ctx->dev, &ctx->hw));parent_hw = clk_hw_get_parent(&ctx->hw);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw);actual_parent = clk_hw_get_clk_kunit(test, parent_hw, __func__);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, actual_parent);KUNIT_EXPECT_TRUE(test, clk_is_match(expected_parent, actual_parent));+}
+static const struct clk_register_clk_parent_data_test_case +clk_register_clk_parent_data_device_hw_cases[] = {
{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::hw.*/.desc = "clk_parent_data_device_hw_index_test",/* The index must be negative to indicate firmware not used */.pdata.index = -1,},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::hw when* struct clk_parent_data::fw_name is set.*/.desc = "clk_parent_data_device_hw_fwname_test",.pdata.fw_name = CLK_PARENT_DATA_PARENT2,},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::hw when struct* clk_parent_data::name is set.*/.desc = "clk_parent_data_device_hw_name_test",/* The index must be negative to indicate firmware not used */.pdata.index = -1,.pdata.name = CLK_PARENT_DATA_50MHZ_NAME,},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::hw when struct* clk_parent_data::{fw_name,name} are set.*/.desc = "clk_parent_data_device_hw_fwname_name_test",.pdata.fw_name = CLK_PARENT_DATA_PARENT2,.pdata.name = "not_matching",},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::hw when struct* clk_parent_data::index is set. The hw pointer takes* priority.*/.desc = "clk_parent_data_device_hw_index_priority_test",.pdata.index = 0,},{/** Test that a clk registered with a struct device can find a* parent based on struct clk_parent_data::hw when* struct clk_parent_data::{index,fwname,name} are set.* The hw pointer takes priority over everything else.*/.desc = "clk_parent_data_device_hw_index_fwname_name_priority_test",.pdata.index = 0,.pdata.fw_name = CLK_PARENT_DATA_PARENT2,.pdata.name = "not_matching",},+};
+KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_device_hw_test,
clk_register_clk_parent_data_device_hw_cases,clk_register_clk_parent_data_test_case_to_desc)+/*
- Test that a clk registered with a struct device can find a
- parent based on struct clk_parent_data::hw.
- */
+static void clk_register_clk_parent_data_device_hw_test(struct kunit *test) +{
struct clk_register_clk_parent_data_device_ctx *ctx;const struct clk_register_clk_parent_data_test_case *test_param;struct clk_dummy_context *parent;struct clk_hw *parent_hw;struct clk_parent_data pdata = { };struct clk_init_data init = { };ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);test->priv = ctx;clk_register_clk_parent_data_device_driver(test);parent = kunit_kzalloc(test, sizeof(*parent), GFP_KERNEL);KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);parent_hw = &parent->hw;parent_hw->init = CLK_HW_INIT_NO_PARENT("parenlookst-clk",&clk_dummy_rate_ops, 0);KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, ctx->dev, parent_hw));test_param = test->param_value;memcpy(&pdata, &test_param->pdata, sizeof(pdata));pdata.hw = parent_hw;init.parent_data = &pdata;init.num_parents = 1;init.ops = &clk_dummy_single_parent_ops;init.name = "parent_data_device_hw_test_clk";ctx->hw.init = &init;KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, ctx->dev, &ctx->hw));KUNIT_EXPECT_PTR_EQ(test, parent_hw, clk_hw_get_parent(&ctx->hw));+}
+static struct kunit_case clk_register_clk_parent_data_device_test_cases[] = {
KUNIT_CASE_PARAM(clk_register_clk_parent_data_device_test,clk_register_clk_parent_data_device_test_gen_params),KUNIT_CASE_PARAM(clk_register_clk_parent_data_device_hw_test,clk_register_clk_parent_data_device_hw_test_gen_params),{}+};
+static int clk_register_clk_parent_data_device_init(struct kunit *test) +{
KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(test, kunit_clk_parent_data_test));return 0;+}
+/*
- Test suite for registering clks with struct clk_parent_data and a struct
- device.
- */
+static struct kunit_suite clk_register_clk_parent_data_device_suite = {
.name = "clk_register_clk_parent_data_device",.init = clk_register_clk_parent_data_device_init,.test_cases = clk_register_clk_parent_data_device_test_cases,+};
kunit_test_suites( &clk_leaf_mux_set_rate_parent_test_suite, &clk_test_suite, @@ -2671,7 +3118,9 @@ kunit_test_suites( &clk_range_test_suite, &clk_range_maximize_test_suite, &clk_range_minimize_test_suite,
&clk_register_clk_parent_data_of_suite,&clk_register_clk_parent_data_device_suite, &clk_single_parent_mux_test_suite,
&clk_uncached_test_suite
&clk_uncached_test_suite,); MODULE_LICENSE("GPL v2"); diff --git a/drivers/clk/kunit_clk_parent_data_test.dtso b/drivers/clk/kunit_clk_parent_data_test.dtso new file mode 100644 index 000000000000..7d3ed9a5a2e8 --- /dev/null +++ b/drivers/clk/kunit_clk_parent_data_test.dtso @@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0 +/dts-v1/; +/plugin/;
+#include "clk_parent_data_test.h"
+&{/} {
fixed_50: kunit-clock-50MHz {compatible = "fixed-clock";#clock-cells = <0>;clock-frequency = <50000000>;clock-output-names = CLK_PARENT_DATA_50MHZ_NAME;};fixed_parent: kunit-clock-1MHz {compatible = "fixed-clock";#clock-cells = <0>;clock-frequency = <1000000>;clock-output-names = CLK_PARENT_DATA_1MHZ_NAME;};kunit-clock-controller {compatible = "test,clk-parent-data";clocks = <&fixed_parent>, <&fixed_50>;clock-names = CLK_PARENT_DATA_PARENT1, CLK_PARENT_DATA_PARENT2;#clock-cells = <1>;};+};
https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/ https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git
Quoting David Gow (2024-06-13 00:56:08)
On Tue, 4 Jun 2024 at 06:38, Stephen Boyd sboyd@kernel.org wrote:
Test that clks registered with 'struct clk_parent_data' work as intended and can find their parents.
Cc: Christian Marangi ansuelsmth@gmail.com Cc: Brendan Higgins brendan.higgins@linux.dev Cc: David Gow davidgow@google.com Cc: Rae Moar rmoar@google.com Signed-off-by: Stephen Boyd sboyd@kernel.org
This seems good to me overall, but will break if we can't compile the dtbo.o file. Maybe these need to live behind a #if IS_ENABLED(CONFIG_OF) or equivalent.
Also, there's a cast to kunit_action_t* which needs to use a wrapper.
Otherwise, Reviewed-by: David Gow davidgow@google.com
Cheers, -- David
drivers/clk/Kconfig | 1 + drivers/clk/Makefile | 3 +- drivers/clk/clk_parent_data_test.h | 10 + drivers/clk/clk_test.c | 451 +++++++++++++++++++- drivers/clk/kunit_clk_parent_data_test.dtso | 28 ++ 5 files changed, 491 insertions(+), 2 deletions(-) create mode 100644 drivers/clk/clk_parent_data_test.h create mode 100644 drivers/clk/kunit_clk_parent_data_test.dtso
diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig index f649f2a0279c..c33fdf9fdcd6 100644 --- a/drivers/clk/Kconfig +++ b/drivers/clk/Kconfig @@ -508,6 +508,7 @@ config CLK_KUNIT_TEST tristate "Basic Clock Framework Kunit Tests" if !KUNIT_ALL_TESTS depends on KUNIT default KUNIT_ALL_TESTS
select OF_OVERLAY if OF help Kunit tests for the common clock framework.diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index 7b57e3d22cee..ed4e1a0e6943 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -2,7 +2,8 @@ # common clock types obj-$(CONFIG_HAVE_CLK) += clk-devres.o clk-bulk.o clkdev.o obj-$(CONFIG_COMMON_CLK) += clk.o -obj-$(CONFIG_CLK_KUNIT_TEST) += clk_test.o +obj-$(CONFIG_CLK_KUNIT_TEST) += clk_test.o \
kunit_clk_parent_data_test.dtbo.oThis breaks if CONFIG_OF isn't enabled, as there's no rule to compile it: make[5]: *** No rule to make target 'drivers/clk/kunit_clk_parent_data_test.dtbo.o', needed by 'drivers/clk/modules.order'. Stop.
Ah, I see that I need to set CONFIG_DTC or the DT compiler (dtc) won't be built. Maybe I should just select OF_OVERLAY instead of being nice and letting OF be disabled? The problem is that I can't test the CONFIG_OF=n case easily then.
For now I'll go with 'select DTC', but it really feels like we should just get rid of that Kconfig and build 'dtc' if it is needed.
diff --git a/drivers/clk/clk_test.c b/drivers/clk/clk_test.c index 39e2b5ff4f51..bdf3c4bb2243 100644 --- a/drivers/clk/clk_test.c +++ b/drivers/clk/clk_test.c @@ -4,12 +4,19 @@ */ #include <linux/clk.h> #include <linux/clk-provider.h> +#include <linux/of.h> +#include <linux/platform_device.h>
/* Needed for clk_hw_get_clk() */ #include "clk.h"
[...]
+/**
- struct clk_register_clk_parent_data_of_ctx - Context for clk_parent_data OF tests
- @np: device node of clk under test
- @hw: clk_hw for clk under test
- */
+struct clk_register_clk_parent_data_of_ctx {
struct device_node *np;struct clk_hw hw;+};
+static int clk_register_clk_parent_data_of_test_init(struct kunit *test) +{
struct clk_register_clk_parent_data_of_ctx *ctx;KUNIT_ASSERT_EQ(test, 0,of_overlay_apply_kunit(test, kunit_clk_parent_data_test));ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);if (!ctx)return -ENOMEM;test->priv = ctx;ctx->np = of_find_compatible_node(NULL, NULL, "test,clk-parent-data");if (!ctx->np)return -ENODEV;return kunit_add_action_or_reset(test, (kunit_action_t *)&of_node_put, ctx->np);We should use an action wrapper here (KUNIT_DEFINE_ACTION_WRAPPER()), as casting function pointers to kunit_action_t* breaks control-flow integrity.
Got it, thanks. Maybe there should be an of_node_put_kunit_exit() helper that does that and can be used anywhere.
Quoting Stephen Boyd (2024-07-02 15:25:47)
Quoting David Gow (2024-06-13 00:56:08)
We should use an action wrapper here (KUNIT_DEFINE_ACTION_WRAPPER()), as casting function pointers to kunit_action_t* breaks control-flow integrity.
Got it, thanks. Maybe there should be an of_node_put_kunit_exit() helper that does that and can be used anywhere.
Heh I already have that with of_node_put_kunit(). I could add exit to it for clarity? I don't really care either way.
linux-kselftest-mirror@lists.linaro.org
-
David Gow -
Greg Kroah-Hartman -
Rob Herring -
Rob Herring (Arm)
-
Stephen Boyd