1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2015 Google, Inc
4 */
5
6 #include <dm.h>
7 #include <led.h>
8 #include <asm/gpio.h>
9 #include <dm/test.h>
10 #include <test/test.h>
11 #include <test/ut.h>
12
13 /* Base test of the led uclass */
dm_test_led_base(struct unit_test_state * uts)14 static 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_assertok(uclass_get_device(UCLASS_LED, 5, &dev));
25 ut_assertok(uclass_get_device(UCLASS_LED, 6, &dev));
26 ut_assertok(uclass_get_device(UCLASS_LED, 7, &dev));
27 ut_assertok(uclass_get_device(UCLASS_LED, 8, &dev));
28 ut_asserteq(-ENODEV, uclass_get_device(UCLASS_LED, 9, &dev));
29
30 return 0;
31 }
32 DM_TEST(dm_test_led_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
33
34 /* Test of the LED 'default-state' device tree property */
dm_test_led_default_state(struct unit_test_state * uts)35 static int dm_test_led_default_state(struct unit_test_state *uts)
36 {
37 struct udevice *dev;
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, UTF_SCAN_PDATA | UTF_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 0 is connected to GPIO
59 * bank gpio_a, offset 1.
60 */
61 ut_assertok(uclass_get_device(UCLASS_LED, 0, &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, UTF_SCAN_PDATA | UTF_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 0 is connected to GPIO
84 * bank gpio_a, offset 1.
85 */
86 ut_assertok(uclass_get_device(UCLASS_LED, 0, &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, UTF_SCAN_PDATA | UTF_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, 0, &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, 1, &cmp));
114 ut_asserteq_ptr(dev, cmp);
115
116 ut_asserteq(-ENODEV, led_get_by_label("sandbox:blue", &dev));
117
118 /* Test if function, color and function-enumerator naming works */
119 ut_assertok(led_get_by_label("red:status-20", &dev));
120
121 /* Test if function, color naming works */
122 ut_assertok(led_get_by_label("green:status", &dev));
123
124 /* Test if function, without color naming works */
125 ut_assertok(led_get_by_label(":status", &dev));
126
127 /* Test if color without function naming works */
128 ut_assertok(led_get_by_label("green:", &dev));
129
130 /* Test if function, color naming is ignored if label is found */
131 ut_assertok(led_get_by_label("sandbox:function", &dev));
132
133 return 0;
134 }
135 DM_TEST(dm_test_led_label, UTF_SCAN_PDATA | UTF_SCAN_FDT);
136
137 /* Test LED blinking */
138 #ifdef CONFIG_LED_BLINK
dm_test_led_blink(struct unit_test_state * uts)139 static int dm_test_led_blink(struct unit_test_state *uts)
140 {
141 const int offset = 1;
142 struct udevice *dev, *gpio;
143
144 /*
145 * Check that we get an error when trying to blink an LED, since it is
146 * not supported by the GPIO LED driver.
147 */
148 ut_assertok(uclass_get_device(UCLASS_LED, 0, &dev));
149 ut_assertok(uclass_get_device(UCLASS_GPIO, 1, &gpio));
150 ut_asserteq(0, sandbox_gpio_get_value(gpio, offset));
151 ut_asserteq(-ENOSYS, led_set_state(dev, LEDST_BLINK));
152 ut_asserteq(0, sandbox_gpio_get_value(gpio, offset));
153 ut_asserteq(LEDST_OFF, led_get_state(dev));
154 ut_asserteq(-ENOSYS, led_set_period(dev, 100));
155
156 return 0;
157 }
158 DM_TEST(dm_test_led_blink, UTF_SCAN_PDATA | UTF_SCAN_FDT);
159 #endif
160
161 /* Test LED boot */
162 #ifdef CONFIG_LED_BOOT
dm_test_led_boot(struct unit_test_state * uts)163 static int dm_test_led_boot(struct unit_test_state *uts)
164 {
165 struct udevice *dev
166
167 /* options/u-boot/boot-led is set to phandle to "sandbox:green" */
168 ut_assertok(led_get_by_label("sandbox:green", &dev));
169 ut_asserteq(LEDST_OFF, led_get_state(dev));
170 ut_assertok(led_boot_on());
171 ut_asserteq(LEDST_ON, led_get_state(dev));
172 ut_assertok(led_boot_off());
173 ut_asserteq(LEDST_OFF, led_get_state(dev));
174
175 return 0;
176 }
177 DM_TEST(dm_test_led_boot, UTF_SCAN_PDATA | UTF_SCAN_FDT);
178
179 /* Test LED boot blink fallback */
180 #ifndef CONFIG_LED_BLINK
dm_test_led_boot_blink(struct unit_test_state * uts)181 static int dm_test_led_boot_blink(struct unit_test_state *uts)
182 {
183 struct udevice *dev
184
185 /* options/u-boot/boot-led is set to phandle to "sandbox:green" */
186 ut_assertok(led_get_by_label("sandbox:green", &dev));
187 ut_asserteq(LEDST_OFF, led_get_state(dev));
188 ut_assertok(led_boot_blink());
189 ut_asserteq(LEDST_ON, led_get_state(dev));
190 ut_assertok(led_boot_off());
191 ut_asserteq(LEDST_OFF, led_get_state(dev));
192
193 return 0;
194 }
195 DM_TEST(dm_test_led_boot_blink, UTF_SCAN_PDATA | UTF_SCAN_FDT);
196 #endif
197 #endif
198
199 /* Test LED activity */
200 #ifdef CONFIG_LED_ACTIVITY
dm_test_led_activity(struct unit_test_state * uts)201 static int dm_test_led_activity(struct unit_test_state *uts)
202 {
203 struct udevice *dev
204
205 /* options/u-boot/activity-led is set to phandle to "sandbox:red" */
206 ut_assertok(led_get_by_label("sandbox:red", &dev));
207 ut_asserteq(LEDST_OFF, led_get_state(dev));
208 ut_assertok(led_activity_on());
209 ut_asserteq(LEDST_ON, led_get_state(dev));
210 ut_assertok(led_activity_off());
211 ut_asserteq(LEDST_OFF, led_get_state(dev));
212
213 return 0;
214 }
215 DM_TEST(dm_test_led_activity, UTF_SCAN_PDATA | UTF_SCAN_FDT);
216
217 /* Test LED activity blink fallback */
218 #ifndef CONFIG_LED_BLINK
dm_test_led_activityt_blink(struct unit_test_state * uts)219 static int dm_test_led_activityt_blink(struct unit_test_state *uts)
220 {
221 struct udevice *dev
222
223 /* options/u-boot/activity-led is set to phandle to "sandbox:red" */
224 ut_assertok(led_get_by_label("sandbox:red", &dev));
225 ut_asserteq(LEDST_OFF, led_get_state(dev));
226 ut_assertok(led_activity_blink());
227 ut_asserteq(LEDST_ON, led_get_state(dev));
228 ut_assertok(led_activity_off());
229 ut_asserteq(LEDST_OFF, led_get_state(dev));
230
231 return 0;
232 }
233 DM_TEST(dm_test_led_activityt_blink, UTF_SCAN_PDATA | UTF_SCAN_FDT);
234 #endif
235 #endif
236