reset: Add sandbox tests for reset_reset() and reset_reset_bulk()

Add DM test coverage for the new reset_reset() and reset_reset_bulk()
API functions.
The sandbox reset driver implements rst_reset so these tests exercise that
op (not the assert/udelay/deassert fallback in reset_reset()).
reset_reset_bulk() calls reset_reset() on each bulk entry in order, so each
line's rst_reset runs in sequence.

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

diff --git a/arch/sandbox/include/asm/reset.h b/arch/sandbox/include/asm/reset.h
index f0709b41c09ff5364623768ccfac7e4b7ca57d15..2890e0dc09bdee2bbb75b6b443b9662207102cfc 100644 (file)
--- a/arch/sandbox/include/asm/reset.h
+++ b/arch/sandbox/include/asm/reset.h
@@ -10,6 +10,7 @@ struct udevice;
 
 int sandbox_reset_query(struct udevice *dev, unsigned long id);
 int sandbox_reset_is_requested(struct udevice *dev, unsigned long id);
+int sandbox_reset_get_count(struct udevice *dev, unsigned long id);
 
 int sandbox_reset_test_get(struct udevice *dev);
 int sandbox_reset_test_get_devm(struct udevice *dev);
@@ -19,6 +20,8 @@ int sandbox_reset_test_assert(struct udevice *dev);
 int sandbox_reset_test_assert_bulk(struct udevice *dev);
 int sandbox_reset_test_deassert(struct udevice *dev);
 int sandbox_reset_test_deassert_bulk(struct udevice *dev);
+int sandbox_reset_test_reset(struct udevice *dev);
+int sandbox_reset_test_reset_bulk(struct udevice *dev);
 int sandbox_reset_test_free(struct udevice *dev);
 int sandbox_reset_test_release_bulk(struct udevice *dev);
 

diff --git a/drivers/reset/sandbox-reset-test.c b/drivers/reset/sandbox-reset-test.c
index dfacb764bc775a641c70611959c218543b317626..64c205596c5ec327f75b5d7881fed89eebdd47b5 100644 (file)
--- a/drivers/reset/sandbox-reset-test.c
+++ b/drivers/reset/sandbox-reset-test.c
@@ -96,6 +96,20 @@ int sandbox_reset_test_deassert_bulk(struct udevice *dev)
        return reset_deassert_bulk(sbrt->bulkp);
 }
 
+int sandbox_reset_test_reset(struct udevice *dev)
+{
+       struct sandbox_reset_test *sbrt = dev_get_priv(dev);
+
+       return reset_reset(sbrt->ctlp, 0);
+}
+
+int sandbox_reset_test_reset_bulk(struct udevice *dev)
+{
+       struct sandbox_reset_test *sbrt = dev_get_priv(dev);
+
+       return reset_reset_bulk(sbrt->bulkp, 0);
+}
+
 int sandbox_reset_test_free(struct udevice *dev)
 {
        struct sandbox_reset_test *sbrt = dev_get_priv(dev);

diff --git a/drivers/reset/sandbox-reset.c b/drivers/reset/sandbox-reset.c
index 1c0ea7390df3ff0d78fa08704b27091fadbc323e..458c332071fbc88ff4c737f8f26f039dd2de4d16 100644 (file)
--- a/drivers/reset/sandbox-reset.c
+++ b/drivers/reset/sandbox-reset.c
@@ -9,12 +9,14 @@
 #include <reset-uclass.h>
 #include <asm/io.h>
 #include <asm/reset.h>
+#include <linux/delay.h>
 
 #define SANDBOX_RESET_SIGNALS 101
 
 struct sandbox_reset_signal {
        bool asserted;
        bool requested;
+       int reset_count;
 };
 
 struct sandbox_reset {
@@ -31,6 +33,7 @@ static int sandbox_reset_request(struct reset_ctl *reset_ctl)
                return -EINVAL;
 
        sbr->signals[reset_ctl->id].requested = true;
+       sbr->signals[reset_ctl->id].reset_count = 0;
        return 0;
 }
 
@@ -66,6 +69,21 @@ static int sandbox_reset_deassert(struct reset_ctl *reset_ctl)
        return 0;
 }
 
+static int sandbox_reset_reset(struct reset_ctl *reset_ctl, ulong delay_us)
+{
+       struct sandbox_reset *sbr = dev_get_priv(reset_ctl->dev);
+
+       debug("%s(reset_ctl=%p, delay_us=%lu)\n", __func__, reset_ctl,
+             delay_us);
+
+       sbr->signals[reset_ctl->id].asserted = true;
+       udelay(delay_us);
+       sbr->signals[reset_ctl->id].asserted = false;
+       sbr->signals[reset_ctl->id].reset_count++;
+
+       return 0;
+}
+
 static int sandbox_reset_bind(struct udevice *dev)
 {
        debug("%s(dev=%p)\n", __func__, dev);
@@ -90,6 +108,7 @@ static const struct reset_ops sandbox_reset_reset_ops = {
        .rfree = sandbox_reset_free,
        .rst_assert = sandbox_reset_assert,
        .rst_deassert = sandbox_reset_deassert,
+       .rst_reset = sandbox_reset_reset,
 };
 
 U_BOOT_DRIVER(sandbox_reset) = {
@@ -125,3 +144,15 @@ int sandbox_reset_is_requested(struct udevice *dev, unsigned long id)
 
        return sbr->signals[id].requested;
 }
+
+int sandbox_reset_get_count(struct udevice *dev, unsigned long id)
+{
+       struct sandbox_reset *sbr = dev_get_priv(dev);
+
+       debug("%s(dev=%p, id=%ld)\n", __func__, dev, id);
+
+       if (id >= SANDBOX_RESET_SIGNALS)
+               return -EINVAL;
+
+       return sbr->signals[id].reset_count;
+}

diff --git a/test/dm/reset.c b/test/dm/reset.c
index dceb6a1dad3867aa6aae8bf90fe04e06ba1d8c6d..043d7cb7e0fc71473f106c6fab27d9dc525b0c27 100644 (file)
--- a/test/dm/reset.c
+++ b/test/dm/reset.c
@@ -120,6 +120,73 @@ static int dm_test_reset_devm(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_reset_devm, UTF_SCAN_FDT);
 
+static int dm_test_reset_reset(struct unit_test_state *uts)
+{
+       struct udevice *dev_reset;
+       struct udevice *dev_test;
+
+       ut_assertok(uclass_get_device_by_name(UCLASS_RESET, "reset-ctl",
+                                             &dev_reset));
+       ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID));
+
+       ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "reset-ctl-test",
+                                             &dev_test));
+       ut_assertok(sandbox_reset_test_get(dev_test));
+
+       /* Verify reset_count starts at 0 */
+       ut_asserteq(0, sandbox_reset_get_count(dev_reset, TEST_RESET_ID));
+
+       ut_assertok(sandbox_reset_test_assert(dev_test));
+       ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID));
+
+       ut_assertok(sandbox_reset_test_reset(dev_test));
+
+       /* Verify reset was pulsed (count incremented) */
+       ut_asserteq(1, sandbox_reset_get_count(dev_reset, TEST_RESET_ID));
+       ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID));
+
+       ut_assertok(sandbox_reset_test_free(dev_test));
+
+       return 0;
+}
+DM_TEST(dm_test_reset_reset, UTF_SCAN_FDT);
+
+static int dm_test_reset_reset_bulk(struct unit_test_state *uts)
+{
+       struct udevice *dev_reset;
+       struct udevice *dev_test;
+
+       ut_assertok(uclass_get_device_by_name(UCLASS_RESET, "reset-ctl",
+                                             &dev_reset));
+       ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID));
+       ut_asserteq(0, sandbox_reset_query(dev_reset, OTHER_RESET_ID));
+
+       ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "reset-ctl-test",
+                                             &dev_test));
+       ut_assertok(sandbox_reset_test_get_bulk(dev_test));
+
+       /* Verify reset_count starts at 0 */
+       ut_asserteq(0, sandbox_reset_get_count(dev_reset, TEST_RESET_ID));
+       ut_asserteq(0, sandbox_reset_get_count(dev_reset, OTHER_RESET_ID));
+
+       ut_assertok(sandbox_reset_test_assert_bulk(dev_test));
+       ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID));
+       ut_asserteq(1, sandbox_reset_query(dev_reset, OTHER_RESET_ID));
+
+       ut_assertok(sandbox_reset_test_reset_bulk(dev_test));
+
+       /* Verify resets were pulsed (counts incremented) */
+       ut_asserteq(1, sandbox_reset_get_count(dev_reset, TEST_RESET_ID));
+       ut_asserteq(1, sandbox_reset_get_count(dev_reset, OTHER_RESET_ID));
+       ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID));
+       ut_asserteq(0, sandbox_reset_query(dev_reset, OTHER_RESET_ID));
+
+       ut_assertok(sandbox_reset_test_release_bulk(dev_test));
+
+       return 0;
+}
+DM_TEST(dm_test_reset_reset_bulk, UTF_SCAN_FDT);
+
 static int dm_test_reset_bulk(struct unit_test_state *uts)
 {
        struct udevice *dev_reset;