reset: sandbox: Cover reset_reset() fallback with second sandbox provider

Add a sandbox reset controller compatible string
"sandbox,reset-ctl-fallback-only" that reuses the existing sandbox assert,
deassert, request, and free helpers but omits rst_reset. That forces
reset_reset() through the core assert / udelay / deassert fallback.

Extend the reset-ctl-test DT node with a fifth reset line named "fallback"
that points at the new provider, and add dm_test_reset_reset_fallback_path
which verifies sandbox_reset_get_count() stays zero (rst_reset is never
invoked) while the line ends deasserted after reset_reset().

This complements the existing rst_reset coverage on sandbox,reset-ctl and
matches the approach of using a separate controller to exercise the
fallback path in unit tests.

Reviewed-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Michal Simek <michal.simek@amd.com>
Link: https://lore.kernel.org/r/c1d40db6e2332a8b23ba842385b3f8c3d0290109.1779709539.git.michal.simek@amd.com

diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts
index 0887de4333b01ca836865486d0dba8bfc3a88469..074e5c06ec82c354aeb084baad747b7286c742d5 100644 (file)
--- a/arch/sandbox/dts/test.dts
+++ b/arch/sandbox/dts/test.dts
@@ -1530,10 +1530,16 @@
                #reset-cells = <1>;
        };
 
+       resetc_fb: reset-ctl-fallback {
+               compatible = "sandbox,reset-ctl-fallback-only";
+               #reset-cells = <1>;
+       };
+
        reset-ctl-test {
                compatible = "sandbox,reset-ctl-test";
-               resets = <&resetc 100>, <&resetc 2>, <&resetc 20>, <&resetc 40>;
-               reset-names = "other", "test", "test2", "test3";
+               resets = <&resetc 100>, <&resetc 2>, <&resetc 20>, <&resetc 40>,
+                        <&resetc_fb 5>;
+               reset-names = "other", "test", "test2", "test3", "fallback";
        };
 
        rng {

diff --git a/drivers/reset/sandbox-reset.c b/drivers/reset/sandbox-reset.c
index 458c332071fbc88ff4c737f8f26f039dd2de4d16..12812f0f340ff04263b465204d8b0d4c303f64b5 100644 (file)
--- a/drivers/reset/sandbox-reset.c
+++ b/drivers/reset/sandbox-reset.c
@@ -121,6 +121,33 @@ U_BOOT_DRIVER(sandbox_reset) = {
        .ops = &sandbox_reset_reset_ops,
 };
 
+/*
+ * Second sandbox reset controller for tests: same assert/deassert
+ * behaviour as sandbox_reset, but no rst_reset so reset_reset() uses
+ * the core assert / udelay / deassert fallback (reset_count never bumps).
+ */
+static const struct udevice_id sandbox_reset_fallback_ids[] = {
+       { .compatible = "sandbox,reset-ctl-fallback-only" },
+       { }
+};
+
+static const struct reset_ops sandbox_reset_fallback_reset_ops = {
+       .request = sandbox_reset_request,
+       .rfree = sandbox_reset_free,
+       .rst_assert = sandbox_reset_assert,
+       .rst_deassert = sandbox_reset_deassert,
+};
+
+U_BOOT_DRIVER(sandbox_reset_fallback) = {
+       .name = "sandbox_reset_fallback",
+       .id = UCLASS_RESET,
+       .of_match = sandbox_reset_fallback_ids,
+       .bind = sandbox_reset_bind,
+       .probe = sandbox_reset_probe,
+       .priv_auto = sizeof(struct sandbox_reset),
+       .ops = &sandbox_reset_fallback_reset_ops,
+};
+
 int sandbox_reset_query(struct udevice *dev, unsigned long id)
 {
        struct sandbox_reset *sbr = dev_get_priv(dev);

diff --git a/test/dm/reset.c b/test/dm/reset.c
index 043d7cb7e0fc71473f106c6fab27d9dc525b0c27..91fa7ff723bbc78a116e628bf0cab6e3773acd1f 100644 (file)
--- a/test/dm/reset.c
+++ b/test/dm/reset.c
@@ -19,6 +19,9 @@
 /* This is the other reset phandle specifier handled by bulk */
 #define OTHER_RESET_ID 2
 
+/* Line on reset-ctl-fallback (sandbox,reset-ctl-fallback-only); see test.dts */
+#define FALLBACK_RESET_ID 5
+
 /* Base test of the reset uclass */
 static int dm_test_reset_base(struct unit_test_state *uts)
 {
@@ -151,6 +154,43 @@ static int dm_test_reset_reset(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_reset_reset, UTF_SCAN_FDT);
 
+/*
+ * reset_reset() fallback path: controller has no rst_reset op, so the
+ * core does assert -> udelay -> deassert. rst_reset-only accounting
+ * (reset_count) stays zero. Leave the line asserted before reset_reset()
+ * so we verify the fallback actually pulses it back to deasserted.
+ */
+static int dm_test_reset_reset_fallback_path(struct unit_test_state *uts)
+{
+       struct udevice *dev_reset_fb;
+       struct udevice *dev_test;
+       struct reset_ctl ctl;
+
+       ut_assertok(uclass_get_device_by_name(UCLASS_RESET, "reset-ctl-fallback",
+                                             &dev_reset_fb));
+       ut_asserteq(0, sandbox_reset_query(dev_reset_fb, FALLBACK_RESET_ID));
+       ut_asserteq(0, sandbox_reset_get_count(dev_reset_fb, FALLBACK_RESET_ID));
+
+       ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "reset-ctl-test",
+                                             &dev_test));
+       ut_assertok(reset_get_by_name(dev_test, "fallback", &ctl));
+       ut_asserteq_ptr(ctl.dev, dev_reset_fb);
+       ut_asserteq(FALLBACK_RESET_ID, ctl.id);
+
+       ut_assertok(reset_assert(&ctl));
+       ut_asserteq(1, sandbox_reset_query(dev_reset_fb, FALLBACK_RESET_ID));
+       ut_asserteq(0, sandbox_reset_get_count(dev_reset_fb, FALLBACK_RESET_ID));
+
+       ut_assertok(reset_reset(&ctl, 1));
+       ut_asserteq(0, sandbox_reset_get_count(dev_reset_fb, FALLBACK_RESET_ID));
+       ut_asserteq(0, sandbox_reset_query(dev_reset_fb, FALLBACK_RESET_ID));
+
+       ut_assertok(reset_free(&ctl));
+
+       return 0;
+}
+DM_TEST(dm_test_reset_reset_fallback_path, UTF_SCAN_FDT);
+
 static int dm_test_reset_reset_bulk(struct unit_test_state *uts)
 {
        struct udevice *dev_reset;