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 <cyclic.h>
   8 #include <dm.h>
   9 #include <wdt.h>
  10 #include <asm/gpio.h>
  11 #include <asm/state.h>
  12 #include <asm/test.h>
  13 #include <dm/test.h>
  14 #include <test/test.h>
  15 #include <test/ut.h>
  16 #include <linux/delay.h>
  17 #include <watchdog.h>
  18
  19 /* Test that watchdog driver functions are called */
  20 static int dm_test_wdt_base(struct unit_test_state *uts)
  21 {
  22         struct sandbox_state *state = state_get_current();
  23         struct udevice *dev;
  24         const u64 timeout = 42;
  25
  26         ut_assertok(uclass_get_device_by_driver(UCLASS_WDT,
  27                                                 DM_DRIVER_GET(wdt_sandbox), &dev));
  28         ut_assertnonnull(dev);
  29         ut_asserteq(0, state->wdt.counter);
  30         ut_asserteq(false, state->wdt.running);
  31
  32         ut_assertok(wdt_start(dev, timeout, 0));
  33         ut_asserteq(timeout, state->wdt.counter);
  34         ut_asserteq(true, state->wdt.running);
  35
  36         uint reset_count = state->wdt.reset_count;
  37         ut_assertok(wdt_reset(dev));
  38         ut_asserteq(reset_count + 1, state->wdt.reset_count);
  39         ut_asserteq(true, state->wdt.running);
  40
  41         ut_assertok(wdt_stop(dev));
  42         ut_asserteq(false, state->wdt.running);
  43
  44         return 0;
  45 }
  46 DM_TEST(dm_test_wdt_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  47
  48 static int dm_test_wdt_gpio_toggle(struct unit_test_state *uts)
  49 {
  50         /*
  51          * The sandbox wdt gpio is "connected" to gpio bank a, offset
  52          * 7. Use the sandbox back door to verify that the gpio-wdt
  53          * driver behaves as expected when using the 'toggle' algorithm.
  54          */
  55         struct udevice *wdt, *gpio;
  56         const u64 timeout = 42;
  57         const int offset = 8;
  58         int val;
  59
  60         ut_assertok(uclass_get_device_by_name(UCLASS_WDT,
  61                                               "wdt-gpio-toggle", &wdt));
  62         ut_assertnonnull(wdt);
  63
  64         ut_assertok(uclass_get_device_by_name(UCLASS_GPIO, "base-gpios", &gpio));
  65         ut_assertnonnull(gpio);
  66         ut_assertok(wdt_start(wdt, timeout, 0));
  67
  68         val = sandbox_gpio_get_value(gpio, offset);
  69         ut_assertok(wdt_reset(wdt));
  70         ut_asserteq(!val, sandbox_gpio_get_value(gpio, offset));
  71         ut_assertok(wdt_reset(wdt));
  72         ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
  73
  74         ut_asserteq(-ENOSYS, wdt_stop(wdt));
  75
  76         return 0;
  77 }
  78 DM_TEST(dm_test_wdt_gpio_toggle, UT_TESTF_SCAN_FDT);
  79
  80 static int dm_test_wdt_gpio_level(struct unit_test_state *uts)
  81 {
  82         /*
  83          * The sandbox wdt gpio is "connected" to gpio bank a, offset
  84          * 7. Use the sandbox back door to verify that the gpio-wdt
  85          * driver behaves as expected when using the 'level' algorithm.
  86          */
  87         struct udevice *wdt, *gpio;
  88         const u64 timeout = 42;
  89         const int offset = 7;
  90         int val;
  91
  92         ut_assertok(uclass_get_device_by_name(UCLASS_WDT,
  93                                               "wdt-gpio-level", &wdt));
  94         ut_assertnonnull(wdt);
  95
  96         ut_assertok(uclass_get_device_by_name(UCLASS_GPIO, "base-gpios", &gpio));
  97         ut_assertnonnull(gpio);
  98         ut_assertok(wdt_start(wdt, timeout, 0));
  99
 100         val = sandbox_gpio_get_value(gpio, offset);
 101         ut_assertok(wdt_reset(wdt));
 102         ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
 103         ut_assertok(wdt_reset(wdt));
 104         ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
 105
 106         ut_asserteq(-ENOSYS, wdt_stop(wdt));
 107
 108         return 0;
 109 }
 110 DM_TEST(dm_test_wdt_gpio_level, UT_TESTF_SCAN_FDT);
 111
 112 static int dm_test_wdt_watchdog_reset(struct unit_test_state *uts)
 113 {
 114         struct sandbox_state *state = state_get_current();
 115         struct udevice *gpio_wdt, *sandbox_wdt;
 116         struct udevice *gpio;
 117         const u64 timeout = 42;
 118         const int offset = 8;
 119         uint reset_count;
 120         int val;
 121
 122         ut_assertok(uclass_get_device_by_name(UCLASS_WDT,
 123                                               "wdt-gpio-toggle", &gpio_wdt));
 124         ut_assertnonnull(gpio_wdt);
 125         ut_assertok(uclass_get_device_by_driver(UCLASS_WDT,
 126                                                 DM_DRIVER_GET(wdt_sandbox), &sandbox_wdt));
 127         ut_assertnonnull(sandbox_wdt);
 128         ut_assertok(uclass_get_device_by_name(UCLASS_GPIO, "base-gpios", &gpio));
 129         ut_assertnonnull(gpio);
 130
 131         /* Neither device should be "started", so watchdog_reset() should be a no-op. */
 132         reset_count = state->wdt.reset_count;
 133         val = sandbox_gpio_get_value(gpio, offset);
 134         cyclic_run();
 135         ut_asserteq(reset_count, state->wdt.reset_count);
 136         ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
 137
 138         /* Start both devices. */
 139         ut_assertok(wdt_start(gpio_wdt, timeout, 0));
 140         ut_assertok(wdt_start(sandbox_wdt, timeout, 0));
 141
 142         /* Make sure both devices have just been pinged. */
 143         timer_test_add_offset(100);
 144         cyclic_run();
 145         reset_count = state->wdt.reset_count;
 146         val = sandbox_gpio_get_value(gpio, offset);
 147
 148         /* The gpio watchdog should be pinged, the sandbox one not. */
 149         timer_test_add_offset(30);
 150         cyclic_run();
 151         ut_asserteq(reset_count, state->wdt.reset_count);
 152         ut_asserteq(!val, sandbox_gpio_get_value(gpio, offset));
 153
 154         /* After another ~30ms, both devices should get pinged. */
 155         timer_test_add_offset(30);
 156         cyclic_run();
 157         ut_asserteq(reset_count + 1, state->wdt.reset_count);
 158         ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
 159
 160         return 0;
 161 }
 162 DM_TEST(dm_test_wdt_watchdog_reset, UT_TESTF_SCAN_FDT);