1 // SPDX-License-Identifier: GPL-2.0+
2
3 #include <common.h>
4 #include <clk.h>
5 #include <dm.h>
6 #include <dt-structs.h>
7 #include <irq.h>
8 #include <dm/test.h>
9 #include <test/test.h>
10 #include <test/ut.h>
11 #include <asm-generic/gpio.h>
12 #include <asm/global_data.h>
13
14 /* Test that we can find a device using of-platdata */
dm_test_of_plat_base(struct unit_test_state * uts)15 static int dm_test_of_plat_base(struct unit_test_state *uts)
16 {
17 struct udevice *dev;
18
19 ut_assertok(uclass_first_device_err(UCLASS_SERIAL, &dev));
20 ut_asserteq_str("sandbox_serial", dev->name);
21
22 return 0;
23 }
24 DM_TEST(dm_test_of_plat_base, UT_TESTF_SCAN_PDATA);
25
26 /* Test that we can read properties from a device */
dm_test_of_plat_props(struct unit_test_state * uts)27 static int dm_test_of_plat_props(struct unit_test_state *uts)
28 {
29 struct dtd_sandbox_spl_test *plat;
30 struct udevice *dev;
31 int i;
32
33 ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_spl_test",
34 &dev));
35
36 plat = dev_get_plat(dev);
37 ut_assert(plat->boolval);
38 ut_asserteq(1, plat->intval);
39 ut_asserteq(3, ARRAY_SIZE(plat->intarray));
40 ut_asserteq(2, plat->intarray[0]);
41 ut_asserteq(3, plat->intarray[1]);
42 ut_asserteq(4, plat->intarray[2]);
43 ut_asserteq(5, plat->byteval);
44 ut_asserteq(1, ARRAY_SIZE(plat->maybe_empty_int));
45 ut_asserteq(0, plat->maybe_empty_int[0]);
46 ut_asserteq(3, ARRAY_SIZE(plat->bytearray));
47 ut_asserteq(6, plat->bytearray[0]);
48 ut_asserteq(0, plat->bytearray[1]);
49 ut_asserteq(0, plat->bytearray[2]);
50 ut_asserteq(9, ARRAY_SIZE(plat->longbytearray));
51 for (i = 0; i < ARRAY_SIZE(plat->longbytearray); i++)
52 ut_asserteq(9 + i, plat->longbytearray[i]);
53 ut_asserteq_str("message", plat->stringval);
54 ut_asserteq(3, ARRAY_SIZE(plat->stringarray));
55 ut_asserteq_str("multi-word", plat->stringarray[0]);
56 ut_asserteq_str("message", plat->stringarray[1]);
57 ut_asserteq_str("", plat->stringarray[2]);
58
59 ut_assertok(uclass_next_device_err(&dev));
60 plat = dev_get_plat(dev);
61 ut_assert(!plat->boolval);
62 ut_asserteq(3, plat->intval);
63 ut_asserteq(5, plat->intarray[0]);
64 ut_asserteq(0, plat->intarray[1]);
65 ut_asserteq(0, plat->intarray[2]);
66 ut_asserteq(8, plat->byteval);
67 ut_asserteq(3, ARRAY_SIZE(plat->bytearray));
68 ut_asserteq(1, plat->bytearray[0]);
69 ut_asserteq(0x23, plat->bytearray[1]);
70 ut_asserteq(0x34, plat->bytearray[2]);
71 for (i = 0; i < ARRAY_SIZE(plat->longbytearray); i++)
72 ut_asserteq(i < 4 ? 9 + i : 0, plat->longbytearray[i]);
73 ut_asserteq_str("message2", plat->stringval);
74 ut_asserteq_str("another", plat->stringarray[0]);
75 ut_asserteq_str("multi-word", plat->stringarray[1]);
76 ut_asserteq_str("message", plat->stringarray[2]);
77
78 ut_assertok(uclass_next_device_err(&dev));
79 plat = dev_get_plat(dev);
80 ut_assert(!plat->boolval);
81 ut_asserteq_str("one", plat->stringarray[0]);
82 ut_asserteq_str("", plat->stringarray[1]);
83 ut_asserteq_str("", plat->stringarray[2]);
84 ut_asserteq(1, plat->maybe_empty_int[0]);
85
86 ut_assertok(uclass_next_device_err(&dev));
87 plat = dev_get_plat(dev);
88 ut_assert(!plat->boolval);
89 ut_asserteq_str("spl", plat->stringarray[0]);
90
91 ut_asserteq(-ENODEV, uclass_next_device_err(&dev));
92
93 return 0;
94 }
95 DM_TEST(dm_test_of_plat_props, UT_TESTF_SCAN_PDATA);
96
97 /*
98 * find_driver_info - recursively find the driver_info for a device
99 *
100 * This sets found[idx] to true when it finds the driver_info record for a
101 * device, where idx is the index in the driver_info linker list.
102 *
103 * @uts: Test state
104 * @parent: Parent to search
105 * @found: bool array to update
106 * @return 0 if OK, non-zero on error
107 */
find_driver_info(struct unit_test_state * uts,struct udevice * parent,bool found[])108 static int find_driver_info(struct unit_test_state *uts, struct udevice *parent,
109 bool found[])
110 {
111 struct udevice *dev;
112
113 /* If not the root device, find the entry that caused it to be bound */
114 if (parent->parent) {
115 const int n_ents =
116 ll_entry_count(struct driver_info, driver_info);
117 int idx = -1;
118 int i;
119
120 for (i = 0; i < n_ents; i++) {
121 const struct driver_rt *drt = gd_dm_driver_rt() + i;
122
123 if (drt->dev == parent) {
124 idx = i;
125 found[idx] = true;
126 break;
127 }
128 }
129
130 ut_assert(idx != -1);
131 }
132
133 device_foreach_child(dev, parent) {
134 int ret;
135
136 ret = find_driver_info(uts, dev, found);
137 if (ret < 0)
138 return ret;
139 }
140
141 return 0;
142 }
143
144 /* Check that every device is recorded in its driver_info struct */
dm_test_of_plat_dev(struct unit_test_state * uts)145 static int dm_test_of_plat_dev(struct unit_test_state *uts)
146 {
147 const int n_ents = ll_entry_count(struct driver_info, driver_info);
148 bool found[n_ents];
149 uint i;
150
151 /* Skip this test if there is no platform data */
152 if (!CONFIG_IS_ENABLED(OF_PLATDATA_DRIVER_RT))
153 return 0;
154
155 /* Record the indexes that are found */
156 memset(found, '\0', sizeof(found));
157 ut_assertok(find_driver_info(uts, gd->dm_root, found));
158
159 /* Make sure that the driver entries without devices have no ->dev */
160 for (i = 0; i < n_ents; i++) {
161 const struct driver_rt *drt = gd_dm_driver_rt() + i;
162 struct udevice *dev;
163
164 if (found[i]) {
165 /* Make sure we can find it */
166 ut_assertnonnull(drt->dev);
167 ut_assertok(device_get_by_ofplat_idx(i, &dev));
168 ut_asserteq_ptr(dev, drt->dev);
169 } else {
170 ut_assertnull(drt->dev);
171 ut_asserteq(-ENOENT, device_get_by_ofplat_idx(i, &dev));
172 }
173 }
174
175 return 0;
176 }
177 DM_TEST(dm_test_of_plat_dev, UT_TESTF_SCAN_PDATA);
178
179 /* Test handling of phandles that point to other devices */
dm_test_of_plat_phandle(struct unit_test_state * uts)180 static int dm_test_of_plat_phandle(struct unit_test_state *uts)
181 {
182 struct dtd_sandbox_clk_test *plat;
183 struct udevice *dev, *clk;
184
185 ut_assertok(uclass_first_device_err(UCLASS_MISC, &dev));
186 ut_asserteq_str("sandbox_clk_test", dev->name);
187 plat = dev_get_plat(dev);
188
189 ut_assertok(device_get_by_ofplat_idx(plat->clocks[0].idx, &clk));
190 ut_asserteq_str("sandbox_fixed_clock", clk->name);
191
192 ut_assertok(device_get_by_ofplat_idx(plat->clocks[1].idx, &clk));
193 ut_asserteq_str("sandbox_clk", clk->name);
194 ut_asserteq(1, plat->clocks[1].arg[0]);
195
196 ut_assertok(device_get_by_ofplat_idx(plat->clocks[2].idx, &clk));
197 ut_asserteq_str("sandbox_clk", clk->name);
198 ut_asserteq(0, plat->clocks[2].arg[0]);
199
200 ut_assertok(device_get_by_ofplat_idx(plat->clocks[3].idx, &clk));
201 ut_asserteq_str("sandbox_clk", clk->name);
202 ut_asserteq(3, plat->clocks[3].arg[0]);
203
204 ut_assertok(device_get_by_ofplat_idx(plat->clocks[4].idx, &clk));
205 ut_asserteq_str("sandbox_clk", clk->name);
206 ut_asserteq(2, plat->clocks[4].arg[0]);
207
208 return 0;
209 }
210 DM_TEST(dm_test_of_plat_phandle, UT_TESTF_SCAN_PDATA);
211
212 #if CONFIG_IS_ENABLED(OF_PLATDATA_PARENT)
213 /* Test that device parents are correctly set up */
dm_test_of_plat_parent(struct unit_test_state * uts)214 static int dm_test_of_plat_parent(struct unit_test_state *uts)
215 {
216 struct udevice *rtc, *i2c;
217
218 ut_assertok(uclass_first_device_err(UCLASS_RTC, &rtc));
219 ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
220 ut_asserteq_ptr(i2c, dev_get_parent(rtc));
221
222 return 0;
223 }
224 DM_TEST(dm_test_of_plat_parent, UT_TESTF_SCAN_PDATA);
225 #endif
226
227 /* Test clocks with of-platdata */
dm_test_of_plat_clk(struct unit_test_state * uts)228 static int dm_test_of_plat_clk(struct unit_test_state *uts)
229 {
230 struct dtd_sandbox_clk_test *plat;
231 struct udevice *dev;
232 struct clk clk;
233
234 ut_assertok(uclass_first_device_err(UCLASS_MISC, &dev));
235 ut_asserteq_str("sandbox_clk_test", dev->name);
236 plat = dev_get_plat(dev);
237
238 ut_assertok(clk_get_by_phandle(dev, &plat->clocks[0], &clk));
239 ut_asserteq_str("sandbox_fixed_clock", clk.dev->name);
240
241 return 0;
242 }
243 DM_TEST(dm_test_of_plat_clk, UT_TESTF_SCAN_PDATA);
244
245 /* Test irqs with of-platdata */
dm_test_of_plat_irq(struct unit_test_state * uts)246 static int dm_test_of_plat_irq(struct unit_test_state *uts)
247 {
248 struct dtd_sandbox_irq_test *plat;
249 struct udevice *dev;
250 struct irq irq;
251
252 ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_irq_test",
253 &dev));
254 plat = dev_get_plat(dev);
255
256 ut_assertok(irq_get_by_phandle(dev, &plat->interrupts_extended[0],
257 &irq));
258 ut_asserteq_str("sandbox_irq", irq.dev->name);
259
260 return 0;
261 }
262 DM_TEST(dm_test_of_plat_irq, UT_TESTF_SCAN_PDATA);
263
264 /* Test GPIOs with of-platdata */
dm_test_of_plat_gpio(struct unit_test_state * uts)265 static int dm_test_of_plat_gpio(struct unit_test_state *uts)
266 {
267 struct dtd_sandbox_gpio_test *plat;
268 struct udevice *dev;
269 struct gpio_desc desc;
270
271 ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_gpio_test",
272 &dev));
273 plat = dev_get_plat(dev);
274
275 ut_assertok(gpio_request_by_phandle(dev, &plat->test_gpios[0], &desc,
276 GPIOD_IS_OUT));
277 ut_asserteq_str("sandbox_gpio", desc.dev->name);
278
279 return 0;
280 }
281 DM_TEST(dm_test_of_plat_gpio, UT_TESTF_SCAN_PDATA);
282