X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=test%2Fdm%2Freset.c;h=c61daed49032b64ebbd0ebaf8a36400dc4ed9f44;hb=5a24239c951e8dc3177b63881631868b8d487920;hp=5d53f252bb5e1e5d6404f4031c22dcfbd1d8a5bb;hpb=7c0e5d865ff0b86dfce492b656238919c659d756;p=oweals%2Fu-boot.git

diff --git a/test/dm/reset.c b/test/dm/reset.c
index 5d53f252bb..c61daed490 100644
--- a/test/dm/reset.c
+++ b/test/dm/reset.c
@@ -1,74 +1,94 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
- * Copyright (C) 2015 Google, Inc
- *
- * SPDX-License-Identifier:	GPL-2.0+
+ * Copyright (c) 2016, NVIDIA CORPORATION.
  */
 
 #include <common.h>
 #include <dm.h>
 #include <reset.h>
-#include <asm/state.h>
-#include <asm/test.h>
 #include <dm/test.h>
+#include <asm/reset.h>
 #include <test/ut.h>
 
-/* Test that we can use particular reset devices */
+/* This must match the specifier for mbox-names="test" in the DT node */
+#define TEST_RESET_ID 2
+
+/* This is the other reset phandle specifier handled by bulk */
+#define OTHER_RESET_ID 2
+
+/* Base test of the reset uclass */
 static int dm_test_reset_base(struct unit_test_state *uts)
 {
-	struct sandbox_state *state = state_get_current();
 	struct udevice *dev;
+	struct reset_ctl reset_method1;
+	struct reset_ctl reset_method2;
+
+	/* Get the device using the reset device */
+	ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "reset-ctl-test",
+					      &dev));
 
-	/* Device 0 is the platform data device - it should never respond */
-	ut_assertok(uclass_get_device(UCLASS_RESET, 0, &dev));
-	ut_asserteq(-ENODEV, reset_request(dev, RESET_WARM));
-	ut_asserteq(-ENODEV, reset_request(dev, RESET_COLD));
-	ut_asserteq(-ENODEV, reset_request(dev, RESET_POWER));
-
-	/* Device 1 is the warm reset device */
-	ut_assertok(uclass_get_device(UCLASS_RESET, 1, &dev));
-	ut_asserteq(-EACCES, reset_request(dev, RESET_WARM));
-	ut_asserteq(-ENOSYS, reset_request(dev, RESET_COLD));
-	ut_asserteq(-ENOSYS, reset_request(dev, RESET_POWER));
-
-	state->reset_allowed[RESET_WARM] = true;
-	ut_asserteq(-EINPROGRESS, reset_request(dev, RESET_WARM));
-	state->reset_allowed[RESET_WARM] = false;
-
-	/* Device 2 is the cold reset device */
-	ut_assertok(uclass_get_device(UCLASS_RESET, 2, &dev));
-	ut_asserteq(-ENOSYS, reset_request(dev, RESET_WARM));
-	ut_asserteq(-EACCES, reset_request(dev, RESET_COLD));
-	state->reset_allowed[RESET_POWER] = false;
-	ut_asserteq(-EACCES, reset_request(dev, RESET_POWER));
-	state->reset_allowed[RESET_POWER] = true;
+	/* Get the same reset port in 2 different ways and compare */
+	ut_assertok(reset_get_by_index(dev, 1, &reset_method1));
+	ut_assertok(reset_get_by_index_nodev(dev_ofnode(dev), 1,
+					     &reset_method2));
+	ut_asserteq(reset_method1.id, reset_method2.id);
 
 	return 0;
 }
-DM_TEST(dm_test_reset_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
-/* Test that we can walk through the reset devices */
-static int dm_test_reset_walk(struct unit_test_state *uts)
+DM_TEST(dm_test_reset_base, DM_TESTF_SCAN_FDT);
+
+static int dm_test_reset(struct unit_test_state *uts)
 {
-	struct sandbox_state *state = state_get_current();
-
-	/* If we generate a power reset, we will exit sandbox! */
-	state->reset_allowed[RESET_POWER] = false;
-	ut_asserteq(-EACCES, reset_walk(RESET_WARM));
-	ut_asserteq(-EACCES, reset_walk(RESET_COLD));
-	ut_asserteq(-EACCES, reset_walk(RESET_POWER));
-
-	/*
-	 * Enable cold reset - this should make cold reset work, plus a warm
-	 * reset should be promoted to cold, since this is the next step
-	 * along.
-	 */
-	state->reset_allowed[RESET_COLD] = true;
-	ut_asserteq(-EINPROGRESS, reset_walk(RESET_WARM));
-	ut_asserteq(-EINPROGRESS, reset_walk(RESET_COLD));
-	ut_asserteq(-EACCES, reset_walk(RESET_POWER));
-	state->reset_allowed[RESET_COLD] = false;
-	state->reset_allowed[RESET_POWER] = true;
+	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));
+
+	ut_assertok(sandbox_reset_test_assert(dev_test));
+	ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID));
+
+	ut_assertok(sandbox_reset_test_deassert(dev_test));
+	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, DM_TESTF_SCAN_FDT);
+
+static int dm_test_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));
+
+	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_deassert_bulk(dev_test));
+	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));
+	ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID));
+	ut_asserteq(1, sandbox_reset_query(dev_reset, OTHER_RESET_ID));
 
 	return 0;
 }
-DM_TEST(dm_test_reset_walk, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_reset_bulk, DM_TESTF_SCAN_FDT);