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 */
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_asserteq(-ENODEV, uclass_get_device(UCLASS_LED, 5, &dev));
25
26 return 0;
27 }
28 DM_TEST(dm_test_led_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
29
30 /* Test of the LED 'default-state' device tree property */
dm_test_led_default_state(struct unit_test_state * uts)31 static 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 }
47 DM_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 */
dm_test_led_gpio(struct unit_test_state * uts)50 static 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 }
72 DM_TEST(dm_test_led_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
73
74 /* Test that we can toggle LEDs */
dm_test_led_toggle(struct unit_test_state * uts)75 static 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 }
97 DM_TEST(dm_test_led_toggle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
98
99 /* Test obtaining an LED by label */
dm_test_led_label(struct unit_test_state * uts)100 static 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 }
118 DM_TEST(dm_test_led_label, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
119
120 /* Test LED blinking */
121 #ifdef CONFIG_LED_BLINK
dm_test_led_blink(struct unit_test_state * uts)122 static 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 }
141 DM_TEST(dm_test_led_blink, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
142 #endif
143