LXR uboot/test/dm/led.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (C) 2015 Google, Inc
   4 */
   5
   6#include <common.h>
   7#include <dm.h>
   8#include <led.h>
   9#include <asm/gpio.h>
  10#include <dm/test.h>
  11#include <test/ut.h>
  12
  13/* Base test of the led uclass */
  14static int dm_test_led_base(struct unit_test_state *uts)
  15{
  16        struct udevice *dev;
  17
  18        /* Get the top-level device */
  19        ut_assertok(uclass_get_device(UCLASS_LED, 0, &dev));
  20        ut_assertok(uclass_get_device(UCLASS_LED, 1, &dev));
  21        ut_assertok(uclass_get_device(UCLASS_LED, 2, &dev));
  22        ut_assertok(uclass_get_device(UCLASS_LED, 3, &dev));
  23        ut_assertok(uclass_get_device(UCLASS_LED, 4, &dev));
  24        ut_asserteq(-ENODEV, uclass_get_device(UCLASS_LED, 5, &dev));
  25
  26        return 0;
  27}
  28DM_TEST(dm_test_led_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  29
  30/* Test of the LED 'default-state' device tree property */
  31static int dm_test_led_default_state(struct unit_test_state *uts)
  32{
  33        struct udevice *dev;
  34
  35        /* configure the default state (auto-probe) */
  36        led_default_state();
  37
  38        /* Check that we handle the default-state property correctly. */
  39        ut_assertok(led_get_by_label("sandbox:default_on", &dev));
  40        ut_asserteq(LEDST_ON, led_get_state(dev));
  41
  42        ut_assertok(led_get_by_label("sandbox:default_off", &dev));
  43        ut_asserteq(LEDST_OFF, led_get_state(dev));
  44
  45        return 0;
  46}
  47DM_TEST(dm_test_led_default_state, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  48
  49/* Test of the led uclass using the led_gpio driver */
  50static int dm_test_led_gpio(struct unit_test_state *uts)
  51{
  52        const int offset = 1;
  53        struct udevice *dev, *gpio;
  54
  55        /*
  56         * Check that we can manipulate an LED. LED 1 is connected to GPIO
  57         * bank gpio_a, offset 1.
  58         */
  59        ut_assertok(uclass_get_device(UCLASS_LED, 1, &dev));
  60        ut_assertok(uclass_get_device(UCLASS_GPIO, 1, &gpio));
  61        ut_asserteq(0, sandbox_gpio_get_value(gpio, offset));
  62        ut_assertok(led_set_state(dev, LEDST_ON));
  63        ut_asserteq(1, sandbox_gpio_get_value(gpio, offset));
  64        ut_asserteq(LEDST_ON, led_get_state(dev));
  65
  66        ut_assertok(led_set_state(dev, LEDST_OFF));
  67        ut_asserteq(0, sandbox_gpio_get_value(gpio, offset));
  68        ut_asserteq(LEDST_OFF, led_get_state(dev));
  69
  70        return 0;
  71}
  72DM_TEST(dm_test_led_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  73
  74/* Test that we can toggle LEDs */
  75static int dm_test_led_toggle(struct unit_test_state *uts)
  76{
  77        const int offset = 1;
  78        struct udevice *dev, *gpio;
  79
  80        /*
  81         * Check that we can manipulate an LED. LED 1 is connected to GPIO
  82         * bank gpio_a, offset 1.
  83         */
  84        ut_assertok(uclass_get_device(UCLASS_LED, 1, &dev));
  85        ut_assertok(uclass_get_device(UCLASS_GPIO, 1, &gpio));
  86        ut_asserteq(0, sandbox_gpio_get_value(gpio, offset));
  87        ut_assertok(led_set_state(dev, LEDST_TOGGLE));
  88        ut_asserteq(1, sandbox_gpio_get_value(gpio, offset));
  89        ut_asserteq(LEDST_ON, led_get_state(dev));
  90
  91        ut_assertok(led_set_state(dev, LEDST_TOGGLE));
  92        ut_asserteq(0, sandbox_gpio_get_value(gpio, offset));
  93        ut_asserteq(LEDST_OFF, led_get_state(dev));
  94
  95        return 0;
  96}
  97DM_TEST(dm_test_led_toggle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  98
  99/* Test obtaining an LED by label */
 100static int dm_test_led_label(struct unit_test_state *uts)
 101{
 102        struct udevice *dev, *cmp;
 103
 104        ut_assertok(led_get_by_label("sandbox:red", &dev));
 105        ut_asserteq(1, device_active(dev));
 106        ut_assertok(uclass_get_device(UCLASS_LED, 1, &cmp));
 107        ut_asserteq_ptr(dev, cmp);
 108
 109        ut_assertok(led_get_by_label("sandbox:green", &dev));
 110        ut_asserteq(1, device_active(dev));
 111        ut_assertok(uclass_get_device(UCLASS_LED, 2, &cmp));
 112        ut_asserteq_ptr(dev, cmp);
 113
 114        ut_asserteq(-ENODEV, led_get_by_label("sandbox:blue", &dev));
 115
 116        return 0;
 117}
 118DM_TEST(dm_test_led_label, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 119
 120/* Test LED blinking */
 121#ifdef CONFIG_LED_BLINK
 122static int dm_test_led_blink(struct unit_test_state *uts)
 123{
 124        const int offset = 1;
 125        struct udevice *dev, *gpio;
 126
 127        /*
 128         * Check that we get an error when trying to blink an LED, since it is
 129         * not supported by the GPIO LED driver.
 130         */
 131        ut_assertok(uclass_get_device(UCLASS_LED, 1, &dev));
 132        ut_assertok(uclass_get_device(UCLASS_GPIO, 1, &gpio));
 133        ut_asserteq(0, sandbox_gpio_get_value(gpio, offset));
 134        ut_asserteq(-ENOSYS, led_set_state(dev, LEDST_BLINK));
 135        ut_asserteq(0, sandbox_gpio_get_value(gpio, offset));
 136        ut_asserteq(LEDST_OFF, led_get_state(dev));
 137        ut_asserteq(-ENOSYS, led_set_period(dev, 100));
 138
 139        return 0;
 140}
 141DM_TEST(dm_test_led_blink, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 142#endif
 143