test/dm/sysreset.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Google, Inc
   4  */
   5
   6 #include <dm.h>
   7 #include <sysreset.h>
   8 #include <asm/state.h>
   9 #include <asm/test.h>
  10 #include <dm/test.h>
  11 #include <test/test.h>
  12 #include <test/ut.h>
  13
  14 /* Test that we can use particular sysreset devices */
  15 static int dm_test_sysreset_base(struct unit_test_state *uts)
  16 {
  17         struct sandbox_state *state = state_get_current();
  18         struct udevice *dev;
  19
  20         /* Device 0 is the platform data device - it should never respond */
  21         ut_assertok(uclass_get_device(UCLASS_SYSRESET, 0, &dev));
  22         ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_WARM));
  23         ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_COLD));
  24         ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_POWER));
  25
  26         /* Device 1 is the warm sysreset device */
  27         ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
  28         ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_WARM));
  29         ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_COLD));
  30         ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_POWER));
  31
  32         state->sysreset_allowed[SYSRESET_WARM] = true;
  33         ut_asserteq(-EINPROGRESS, sysreset_request(dev, SYSRESET_WARM));
  34         state->sysreset_allowed[SYSRESET_WARM] = false;
  35
  36         /* Device 2 is the cold sysreset device */
  37         ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
  38         ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_WARM));
  39         state->sysreset_allowed[SYSRESET_COLD] = false;
  40         ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_COLD));
  41         state->sysreset_allowed[SYSRESET_COLD] = true;
  42         state->sysreset_allowed[SYSRESET_POWER] = false;
  43         ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_POWER));
  44         state->sysreset_allowed[SYSRESET_POWER] = true;
  45
  46         return 0;
  47 }
  48 DM_TEST(dm_test_sysreset_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
  49
  50 static int dm_test_sysreset_get_status(struct unit_test_state *uts)
  51 {
  52         struct udevice *dev;
  53         char msg[64];
  54
  55         /* Device 1 is the warm sysreset device */
  56         ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
  57         ut_assertok(sysreset_get_status(dev, msg, sizeof(msg)));
  58         ut_asserteq_str("Reset Status: WARM", msg);
  59
  60         /* Device 2 is the cold sysreset device */
  61         ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
  62         ut_assertok(sysreset_get_status(dev, msg, sizeof(msg)));
  63         ut_asserteq_str("Reset Status: COLD", msg);
  64
  65         return 0;
  66 }
  67 DM_TEST(dm_test_sysreset_get_status, UTF_SCAN_PDATA | UTF_SCAN_FDT);
  68
  69 /* Test that we can walk through the sysreset devices */
  70 static int dm_test_sysreset_walk(struct unit_test_state *uts)
  71 {
  72         struct sandbox_state *state = state_get_current();
  73
  74         /* If we generate a power sysreset, we will exit sandbox! */
  75         state->sysreset_allowed[SYSRESET_WARM] = false;
  76         state->sysreset_allowed[SYSRESET_COLD] = false;
  77         state->sysreset_allowed[SYSRESET_POWER] = false;
  78         state->sysreset_allowed[SYSRESET_POWER_OFF] = false;
  79         ut_asserteq(-EACCES, sysreset_walk(SYSRESET_WARM));
  80         ut_asserteq(-EACCES, sysreset_walk(SYSRESET_COLD));
  81         ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER));
  82         ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER_OFF));
  83
  84         /*
  85          * Enable cold system reset - this should make cold system reset work,
  86          * plus a warm system reset should be promoted to cold, since this is
  87          * the next step along.
  88          */
  89         state->sysreset_allowed[SYSRESET_WARM] = true;
  90         ut_asserteq(-EINPROGRESS, sysreset_walk(SYSRESET_WARM));
  91         ut_asserteq(-EACCES, sysreset_walk(SYSRESET_COLD));
  92         ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER));
  93         state->sysreset_allowed[SYSRESET_COLD] = true;
  94         state->sysreset_allowed[SYSRESET_POWER] = true;
  95
  96         return 0;
  97 }
  98 DM_TEST(dm_test_sysreset_walk, UTF_SCAN_PDATA | UTF_SCAN_FDT);
  99
 100 static int dm_test_sysreset_get_last(struct unit_test_state *uts)
 101 {
 102         struct udevice *dev;
 103
 104         /* Device 1 is the warm sysreset device */
 105         ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
 106         ut_asserteq(SYSRESET_WARM, sysreset_get_last(dev));
 107
 108         /* Device 2 is the cold sysreset device */
 109         ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
 110         ut_asserteq(SYSRESET_POWER, sysreset_get_last(dev));
 111
 112         /* This is device 0, the non-DT one */
 113         ut_asserteq(SYSRESET_POWER, sysreset_get_last_walk());
 114
 115         return 0;
 116 }
 117 DM_TEST(dm_test_sysreset_get_last, UTF_SCAN_PDATA | UTF_SCAN_FDT);