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