test/dm/wdt.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2017 Google, Inc
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <wdt.h>
   9 #include <asm/gpio.h>
  10 #include <asm/state.h>
  11 #include <asm/test.h>
  12 #include <dm/test.h>
  13 #include <test/test.h>
  14 #include <test/ut.h>
  15
  16 /* Test that watchdog driver functions are called */
  17 static int dm_test_wdt_base(struct unit_test_state *uts)
  18 {
  19         struct sandbox_state *state = state_get_current();
  20         struct udevice *dev;
  21         const u64 timeout = 42;
  22
  23         ut_assertok(uclass_get_device_by_driver(UCLASS_WDT,
  24                                                 DM_DRIVER_GET(wdt_sandbox), &dev));
  25         ut_assertnonnull(dev);
  26         ut_asserteq(0, state->wdt.counter);
  27         ut_asserteq(false, state->wdt.running);
  28
  29         ut_assertok(wdt_start(dev, timeout, 0));
  30         ut_asserteq(timeout, state->wdt.counter);
  31         ut_asserteq(true, state->wdt.running);
  32
  33         uint reset_count = state->wdt.reset_count;
  34         ut_assertok(wdt_reset(dev));
  35         ut_asserteq(reset_count + 1, state->wdt.reset_count);
  36         ut_asserteq(true, state->wdt.running);
  37
  38         ut_assertok(wdt_stop(dev));
  39         ut_asserteq(false, state->wdt.running);
  40
  41         return 0;
  42 }
  43 DM_TEST(dm_test_wdt_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  44
  45 static int dm_test_wdt_gpio(struct unit_test_state *uts)
  46 {
  47         /*
  48          * The sandbox wdt gpio is "connected" to gpio bank a, offset
  49          * 7. Use the sandbox back door to verify that the gpio-wdt
  50          * driver behaves as expected.
  51          */
  52         struct udevice *wdt, *gpio;
  53         const u64 timeout = 42;
  54         const int offset = 7;
  55         int val;
  56
  57         ut_assertok(uclass_get_device_by_driver(UCLASS_WDT,
  58                                                 DM_DRIVER_GET(wdt_gpio), &wdt));
  59         ut_assertnonnull(wdt);
  60
  61         ut_assertok(uclass_get_device_by_name(UCLASS_GPIO, "base-gpios", &gpio));
  62         ut_assertnonnull(gpio);
  63         ut_assertok(wdt_start(wdt, timeout, 0));
  64
  65         val = sandbox_gpio_get_value(gpio, offset);
  66         ut_assertok(wdt_reset(wdt));
  67         ut_asserteq(!val, sandbox_gpio_get_value(gpio, offset));
  68         ut_assertok(wdt_reset(wdt));
  69         ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
  70
  71         ut_asserteq(-ENOSYS, wdt_stop(wdt));
  72
  73         return 0;
  74 }
  75 DM_TEST(dm_test_wdt_gpio, UT_TESTF_SCAN_FDT);