1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2013 Google, Inc
4 */
5
6 #include <common.h>
7 #include <dm.h>
8 #include <errno.h>
9 #include <fdtdec.h>
10 #include <malloc.h>
11 #include <asm/io.h>
12 #include <dm/test.h>
13 #include <dm/root.h>
14 #include <dm/device-internal.h>
15 #include <dm/uclass-internal.h>
16 #include <dm/util.h>
17 #include <dm/lists.h>
18 #include <dm/of_access.h>
19 #include <test/ut.h>
20
21 DECLARE_GLOBAL_DATA_PTR;
22
testfdt_drv_ping(struct udevice * dev,int pingval,int * pingret)23 static int testfdt_drv_ping(struct udevice *dev, int pingval, int *pingret)
24 {
25 const struct dm_test_pdata *pdata = dev->platdata;
26 struct dm_test_priv *priv = dev_get_priv(dev);
27
28 *pingret = pingval + pdata->ping_add;
29 priv->ping_total += *pingret;
30
31 return 0;
32 }
33
34 static const struct test_ops test_ops = {
35 .ping = testfdt_drv_ping,
36 };
37
testfdt_ofdata_to_platdata(struct udevice * dev)38 static int testfdt_ofdata_to_platdata(struct udevice *dev)
39 {
40 struct dm_test_pdata *pdata = dev_get_platdata(dev);
41
42 pdata->ping_add = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
43 "ping-add", -1);
44 pdata->base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev),
45 "ping-expect");
46
47 return 0;
48 }
49
testfdt_drv_probe(struct udevice * dev)50 static int testfdt_drv_probe(struct udevice *dev)
51 {
52 struct dm_test_priv *priv = dev_get_priv(dev);
53
54 priv->ping_total += DM_TEST_START_TOTAL;
55
56 /*
57 * If this device is on a bus, the uclass_flag will be set before
58 * calling this function. In the meantime the uclass_postp is
59 * initlized to a value -1. These are used respectively by
60 * dm_test_bus_child_pre_probe_uclass() and
61 * dm_test_bus_child_post_probe_uclass().
62 */
63 priv->uclass_total += priv->uclass_flag;
64 priv->uclass_postp = -1;
65
66 return 0;
67 }
68
69 static const struct udevice_id testfdt_ids[] = {
70 {
71 .compatible = "denx,u-boot-fdt-test",
72 .data = DM_TEST_TYPE_FIRST },
73 {
74 .compatible = "google,another-fdt-test",
75 .data = DM_TEST_TYPE_SECOND },
76 { }
77 };
78
79 U_BOOT_DRIVER(testfdt_drv) = {
80 .name = "testfdt_drv",
81 .of_match = testfdt_ids,
82 .id = UCLASS_TEST_FDT,
83 .ofdata_to_platdata = testfdt_ofdata_to_platdata,
84 .probe = testfdt_drv_probe,
85 .ops = &test_ops,
86 .priv_auto_alloc_size = sizeof(struct dm_test_priv),
87 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
88 };
89
90 static const struct udevice_id testfdt1_ids[] = {
91 {
92 .compatible = "denx,u-boot-fdt-test1",
93 .data = DM_TEST_TYPE_FIRST },
94 { }
95 };
96
97 U_BOOT_DRIVER(testfdt1_drv) = {
98 .name = "testfdt1_drv",
99 .of_match = testfdt1_ids,
100 .id = UCLASS_TEST_FDT,
101 .ofdata_to_platdata = testfdt_ofdata_to_platdata,
102 .probe = testfdt_drv_probe,
103 .ops = &test_ops,
104 .priv_auto_alloc_size = sizeof(struct dm_test_priv),
105 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
106 .flags = DM_FLAG_PRE_RELOC,
107 };
108
109 /* From here is the testfdt uclass code */
testfdt_ping(struct udevice * dev,int pingval,int * pingret)110 int testfdt_ping(struct udevice *dev, int pingval, int *pingret)
111 {
112 const struct test_ops *ops = device_get_ops(dev);
113
114 if (!ops->ping)
115 return -ENOSYS;
116
117 return ops->ping(dev, pingval, pingret);
118 }
119
120 UCLASS_DRIVER(testfdt) = {
121 .name = "testfdt",
122 .id = UCLASS_TEST_FDT,
123 .flags = DM_UC_FLAG_SEQ_ALIAS,
124 };
125
126 struct dm_testprobe_pdata {
127 int probe_err;
128 };
129
testprobe_drv_probe(struct udevice * dev)130 static int testprobe_drv_probe(struct udevice *dev)
131 {
132 struct dm_testprobe_pdata *pdata = dev_get_platdata(dev);
133
134 return pdata->probe_err;
135 }
136
137 static const struct udevice_id testprobe_ids[] = {
138 { .compatible = "denx,u-boot-probe-test" },
139 { }
140 };
141
142 U_BOOT_DRIVER(testprobe_drv) = {
143 .name = "testprobe_drv",
144 .of_match = testprobe_ids,
145 .id = UCLASS_TEST_PROBE,
146 .probe = testprobe_drv_probe,
147 .platdata_auto_alloc_size = sizeof(struct dm_testprobe_pdata),
148 };
149
150 UCLASS_DRIVER(testprobe) = {
151 .name = "testprobe",
152 .id = UCLASS_TEST_PROBE,
153 .flags = DM_UC_FLAG_SEQ_ALIAS,
154 };
155
dm_check_devices(struct unit_test_state * uts,int num_devices)156 int dm_check_devices(struct unit_test_state *uts, int num_devices)
157 {
158 struct udevice *dev;
159 int ret;
160 int i;
161
162 /*
163 * Now check that the ping adds are what we expect. This is using the
164 * ping-add property in each node.
165 */
166 for (i = 0; i < num_devices; i++) {
167 uint32_t base;
168
169 ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev);
170 ut_assert(!ret);
171
172 /*
173 * Get the 'ping-expect' property, which tells us what the
174 * ping add should be. We don't use the platdata because we
175 * want to test the code that sets that up
176 * (testfdt_drv_probe()).
177 */
178 base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev),
179 "ping-expect");
180 debug("dev=%d, base=%d: %s\n", i, base,
181 fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL));
182
183 ut_assert(!dm_check_operations(uts, dev, base,
184 dev_get_priv(dev)));
185 }
186
187 return 0;
188 }
189
190 /* Test that FDT-based binding works correctly */
dm_test_fdt(struct unit_test_state * uts)191 static int dm_test_fdt(struct unit_test_state *uts)
192 {
193 const int num_devices = 8;
194 struct udevice *dev;
195 struct uclass *uc;
196 int ret;
197 int i;
198
199 ret = dm_scan_fdt(gd->fdt_blob, false);
200 ut_assert(!ret);
201
202 ret = uclass_get(UCLASS_TEST_FDT, &uc);
203 ut_assert(!ret);
204
205 /* These are num_devices compatible root-level device tree nodes */
206 ut_asserteq(num_devices, list_count_items(&uc->dev_head));
207
208 /* Each should have platform data but no private data */
209 for (i = 0; i < num_devices; i++) {
210 ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev);
211 ut_assert(!ret);
212 ut_assert(!dev_get_priv(dev));
213 ut_assert(dev->platdata);
214 }
215
216 ut_assertok(dm_check_devices(uts, num_devices));
217
218 return 0;
219 }
220 DM_TEST(dm_test_fdt, 0);
221
dm_test_alias_highest_id(struct unit_test_state * uts)222 static int dm_test_alias_highest_id(struct unit_test_state *uts)
223 {
224 int ret;
225
226 ret = dev_read_alias_highest_id("eth");
227 ut_asserteq(5, ret);
228
229 ret = dev_read_alias_highest_id("gpio");
230 ut_asserteq(2, ret);
231
232 ret = dev_read_alias_highest_id("pci");
233 ut_asserteq(2, ret);
234
235 ret = dev_read_alias_highest_id("i2c");
236 ut_asserteq(0, ret);
237
238 ret = dev_read_alias_highest_id("deadbeef");
239 ut_asserteq(-1, ret);
240
241 return 0;
242 }
243 DM_TEST(dm_test_alias_highest_id, 0);
244
dm_test_fdt_pre_reloc(struct unit_test_state * uts)245 static int dm_test_fdt_pre_reloc(struct unit_test_state *uts)
246 {
247 struct uclass *uc;
248 int ret;
249
250 ret = dm_scan_fdt(gd->fdt_blob, true);
251 ut_assert(!ret);
252
253 ret = uclass_get(UCLASS_TEST_FDT, &uc);
254 ut_assert(!ret);
255
256 /*
257 * These are 2 pre-reloc devices:
258 * one with "u-boot,dm-pre-reloc" property (a-test node), and the other
259 * one whose driver marked with DM_FLAG_PRE_RELOC flag (h-test node).
260 */
261 ut_asserteq(2, list_count_items(&uc->dev_head));
262
263 return 0;
264 }
265 DM_TEST(dm_test_fdt_pre_reloc, 0);
266
267 /* Test that sequence numbers are allocated properly */
dm_test_fdt_uclass_seq(struct unit_test_state * uts)268 static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
269 {
270 struct udevice *dev;
271
272 /* A few basic santiy tests */
273 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, true, &dev));
274 ut_asserteq_str("b-test", dev->name);
275
276 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, true, &dev));
277 ut_asserteq_str("a-test", dev->name);
278
279 ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 5,
280 true, &dev));
281 ut_asserteq_ptr(NULL, dev);
282
283 /* Test aliases */
284 ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 6, &dev));
285 ut_asserteq_str("e-test", dev->name);
286
287 ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7,
288 true, &dev));
289
290 /*
291 * Note that c-test nodes are not probed since it is not a top-level
292 * node
293 */
294 ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 3, &dev));
295 ut_asserteq_str("b-test", dev->name);
296
297 /*
298 * d-test wants sequence number 3 also, but it can't have it because
299 * b-test gets it first.
300 */
301 ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 2, &dev));
302 ut_asserteq_str("d-test", dev->name);
303
304 /* d-test actually gets 0 */
305 ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 0, &dev));
306 ut_asserteq_str("d-test", dev->name);
307
308 /* initially no one wants seq 1 */
309 ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_TEST_FDT, 1,
310 &dev));
311 ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
312 ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 4, &dev));
313
314 /* But now that it is probed, we can find it */
315 ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 1, &dev));
316 ut_asserteq_str("f-test", dev->name);
317
318 return 0;
319 }
320 DM_TEST(dm_test_fdt_uclass_seq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
321
322 /* Test that we can find a device by device tree offset */
dm_test_fdt_offset(struct unit_test_state * uts)323 static int dm_test_fdt_offset(struct unit_test_state *uts)
324 {
325 const void *blob = gd->fdt_blob;
326 struct udevice *dev;
327 int node;
328
329 node = fdt_path_offset(blob, "/e-test");
330 ut_assert(node > 0);
331 ut_assertok(uclass_get_device_by_of_offset(UCLASS_TEST_FDT, node,
332 &dev));
333 ut_asserteq_str("e-test", dev->name);
334
335 /* This node should not be bound */
336 node = fdt_path_offset(blob, "/junk");
337 ut_assert(node > 0);
338 ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
339 node, &dev));
340
341 /* This is not a top level node so should not be probed */
342 node = fdt_path_offset(blob, "/some-bus/c-test@5");
343 ut_assert(node > 0);
344 ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
345 node, &dev));
346
347 return 0;
348 }
349 DM_TEST(dm_test_fdt_offset,
350 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
351
352 /**
353 * Test various error conditions with uclass_first_device() and
354 * uclass_next_device()
355 */
dm_test_first_next_device(struct unit_test_state * uts)356 static int dm_test_first_next_device(struct unit_test_state *uts)
357 {
358 struct dm_testprobe_pdata *pdata;
359 struct udevice *dev, *parent = NULL;
360 int count;
361 int ret;
362
363 /* There should be 4 devices */
364 for (ret = uclass_first_device(UCLASS_TEST_PROBE, &dev), count = 0;
365 dev;
366 ret = uclass_next_device(&dev)) {
367 count++;
368 parent = dev_get_parent(dev);
369 }
370 ut_assertok(ret);
371 ut_asserteq(4, count);
372
373 /* Remove them and try again, with an error on the second one */
374 ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 1, &dev));
375 pdata = dev_get_platdata(dev);
376 pdata->probe_err = -ENOMEM;
377 device_remove(parent, DM_REMOVE_NORMAL);
378 ut_assertok(uclass_first_device(UCLASS_TEST_PROBE, &dev));
379 ut_asserteq(-ENOMEM, uclass_next_device(&dev));
380 ut_asserteq_ptr(dev, NULL);
381
382 /* Now an error on the first one */
383 ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 0, &dev));
384 pdata = dev_get_platdata(dev);
385 pdata->probe_err = -ENOENT;
386 device_remove(parent, DM_REMOVE_NORMAL);
387 ut_asserteq(-ENOENT, uclass_first_device(UCLASS_TEST_PROBE, &dev));
388
389 return 0;
390 }
391 DM_TEST(dm_test_first_next_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
392
393 /**
394 * check_devices() - Check return values and pointers
395 *
396 * This runs through a full sequence of uclass_first_device_check()...
397 * uclass_next_device_check() checking that the return values and devices
398 * are correct.
399 *
400 * @uts: Test state
401 * @devlist: List of expected devices
402 * @mask: Indicates which devices should return an error. Device n should
403 * return error (-NOENT - n) if bit n is set, or no error (i.e. 0) if
404 * bit n is clear.
405 */
check_devices(struct unit_test_state * uts,struct udevice * devlist[],int mask)406 static int check_devices(struct unit_test_state *uts,
407 struct udevice *devlist[], int mask)
408 {
409 int expected_ret;
410 struct udevice *dev;
411 int i;
412
413 expected_ret = (mask & 1) ? -ENOENT : 0;
414 mask >>= 1;
415 ut_asserteq(expected_ret,
416 uclass_first_device_check(UCLASS_TEST_PROBE, &dev));
417 for (i = 0; i < 4; i++) {
418 ut_asserteq_ptr(devlist[i], dev);
419 expected_ret = (mask & 1) ? -ENOENT - (i + 1) : 0;
420 mask >>= 1;
421 ut_asserteq(expected_ret, uclass_next_device_check(&dev));
422 }
423 ut_asserteq_ptr(NULL, dev);
424
425 return 0;
426 }
427
428 /* Test uclass_first_device_check() and uclass_next_device_check() */
dm_test_first_next_ok_device(struct unit_test_state * uts)429 static int dm_test_first_next_ok_device(struct unit_test_state *uts)
430 {
431 struct dm_testprobe_pdata *pdata;
432 struct udevice *dev, *parent = NULL, *devlist[4];
433 int count;
434 int ret;
435
436 /* There should be 4 devices */
437 count = 0;
438 for (ret = uclass_first_device_check(UCLASS_TEST_PROBE, &dev);
439 dev;
440 ret = uclass_next_device_check(&dev)) {
441 ut_assertok(ret);
442 devlist[count++] = dev;
443 parent = dev_get_parent(dev);
444 }
445 ut_asserteq(4, count);
446 ut_assertok(uclass_first_device_check(UCLASS_TEST_PROBE, &dev));
447 ut_assertok(check_devices(uts, devlist, 0));
448
449 /* Remove them and try again, with an error on the second one */
450 pdata = dev_get_platdata(devlist[1]);
451 pdata->probe_err = -ENOENT - 1;
452 device_remove(parent, DM_REMOVE_NORMAL);
453 ut_assertok(check_devices(uts, devlist, 1 << 1));
454
455 /* Now an error on the first one */
456 pdata = dev_get_platdata(devlist[0]);
457 pdata->probe_err = -ENOENT - 0;
458 device_remove(parent, DM_REMOVE_NORMAL);
459 ut_assertok(check_devices(uts, devlist, 3 << 0));
460
461 /* Now errors on all */
462 pdata = dev_get_platdata(devlist[2]);
463 pdata->probe_err = -ENOENT - 2;
464 pdata = dev_get_platdata(devlist[3]);
465 pdata->probe_err = -ENOENT - 3;
466 device_remove(parent, DM_REMOVE_NORMAL);
467 ut_assertok(check_devices(uts, devlist, 0xf << 0));
468
469 return 0;
470 }
471 DM_TEST(dm_test_first_next_ok_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
472
473 static const struct udevice_id fdt_dummy_ids[] = {
474 { .compatible = "denx,u-boot-fdt-dummy", },
475 { }
476 };
477
478 UCLASS_DRIVER(fdt_dummy) = {
479 .name = "fdt-dummy",
480 .id = UCLASS_TEST_DUMMY,
481 .flags = DM_UC_FLAG_SEQ_ALIAS,
482 };
483
484 U_BOOT_DRIVER(fdt_dummy_drv) = {
485 .name = "fdt_dummy_drv",
486 .of_match = fdt_dummy_ids,
487 .id = UCLASS_TEST_DUMMY,
488 };
489
dm_test_fdt_translation(struct unit_test_state * uts)490 static int dm_test_fdt_translation(struct unit_test_state *uts)
491 {
492 struct udevice *dev;
493
494 /* Some simple translations */
495 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
496 ut_asserteq_str("dev@0,0", dev->name);
497 ut_asserteq(0x8000, dev_read_addr(dev));
498
499 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
500 ut_asserteq_str("dev@1,100", dev->name);
501 ut_asserteq(0x9000, dev_read_addr(dev));
502
503 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 2, true, &dev));
504 ut_asserteq_str("dev@2,200", dev->name);
505 ut_asserteq(0xA000, dev_read_addr(dev));
506
507 /* No translation for busses with #size-cells == 0 */
508 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 3, true, &dev));
509 ut_asserteq_str("dev@42", dev->name);
510 ut_asserteq(0x42, dev_read_addr(dev));
511
512 return 0;
513 }
514 DM_TEST(dm_test_fdt_translation, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
515
dm_test_fdt_remap_addr_flat(struct unit_test_state * uts)516 static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
517 {
518 struct udevice *dev;
519 fdt_addr_t addr;
520 void *paddr;
521
522 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
523
524 addr = devfdt_get_addr(dev);
525 ut_asserteq(0x8000, addr);
526
527 paddr = map_physmem(addr, 0, MAP_NOCACHE);
528 ut_assertnonnull(paddr);
529 ut_asserteq_ptr(paddr, devfdt_remap_addr(dev));
530
531 return 0;
532 }
533 DM_TEST(dm_test_fdt_remap_addr_flat,
534 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
535
dm_test_fdt_remap_addr_index_flat(struct unit_test_state * uts)536 static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
537 {
538 struct udevice *dev;
539 fdt_addr_t addr;
540 void *paddr;
541
542 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
543
544 addr = devfdt_get_addr_index(dev, 0);
545 ut_asserteq(0x8000, addr);
546
547 paddr = map_physmem(addr, 0, MAP_NOCACHE);
548 ut_assertnonnull(paddr);
549 ut_asserteq_ptr(paddr, devfdt_remap_addr_index(dev, 0));
550
551 return 0;
552 }
553 DM_TEST(dm_test_fdt_remap_addr_index_flat,
554 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
555
dm_test_fdt_remap_addr_name_flat(struct unit_test_state * uts)556 static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
557 {
558 struct udevice *dev;
559 fdt_addr_t addr;
560 void *paddr;
561
562 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
563
564 addr = devfdt_get_addr_name(dev, "sandbox-dummy-0");
565 ut_asserteq(0x8000, addr);
566
567 paddr = map_physmem(addr, 0, MAP_NOCACHE);
568 ut_assertnonnull(paddr);
569 ut_asserteq_ptr(paddr, devfdt_remap_addr_name(dev, "sandbox-dummy-0"));
570
571 return 0;
572 }
573 DM_TEST(dm_test_fdt_remap_addr_name_flat,
574 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
575
dm_test_fdt_remap_addr_live(struct unit_test_state * uts)576 static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
577 {
578 struct udevice *dev;
579 fdt_addr_t addr;
580 void *paddr;
581
582 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
583
584 addr = dev_read_addr(dev);
585 ut_asserteq(0x8000, addr);
586
587 paddr = map_physmem(addr, 0, MAP_NOCACHE);
588 ut_assertnonnull(paddr);
589 ut_asserteq_ptr(paddr, dev_remap_addr(dev));
590
591 return 0;
592 }
593 DM_TEST(dm_test_fdt_remap_addr_live,
594 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
595
dm_test_fdt_remap_addr_index_live(struct unit_test_state * uts)596 static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
597 {
598 struct udevice *dev;
599 fdt_addr_t addr;
600 void *paddr;
601
602 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
603
604 addr = dev_read_addr_index(dev, 0);
605 ut_asserteq(0x8000, addr);
606
607 paddr = map_physmem(addr, 0, MAP_NOCACHE);
608 ut_assertnonnull(paddr);
609 ut_asserteq_ptr(paddr, dev_remap_addr_index(dev, 0));
610
611 return 0;
612 }
613 DM_TEST(dm_test_fdt_remap_addr_index_live,
614 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
615
dm_test_fdt_remap_addr_name_live(struct unit_test_state * uts)616 static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
617 {
618 struct udevice *dev;
619 fdt_addr_t addr;
620 void *paddr;
621
622 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
623
624 addr = dev_read_addr_name(dev, "sandbox-dummy-0");
625 ut_asserteq(0x8000, addr);
626
627 paddr = map_physmem(addr, 0, MAP_NOCACHE);
628 ut_assertnonnull(paddr);
629 ut_asserteq_ptr(paddr, dev_remap_addr_name(dev, "sandbox-dummy-0"));
630
631 return 0;
632 }
633 DM_TEST(dm_test_fdt_remap_addr_name_live,
634 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
635
dm_test_fdt_livetree_writing(struct unit_test_state * uts)636 static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
637 {
638 struct udevice *dev;
639 ofnode node;
640
641 if (!of_live_active()) {
642 printf("Live tree not active; ignore test\n");
643 return 0;
644 }
645
646 /* Test enabling devices */
647
648 node = ofnode_path("/usb@2");
649
650 ut_assert(!of_device_is_available(ofnode_to_np(node)));
651 ofnode_set_enabled(node, true);
652 ut_assert(of_device_is_available(ofnode_to_np(node)));
653
654 device_bind_driver_to_node(dm_root(), "usb_sandbox", "usb@2", node,
655 &dev);
656 ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, true, &dev));
657
658 /* Test string property setting */
659
660 ut_assert(device_is_compatible(dev, "sandbox,usb"));
661 ofnode_write_string(node, "compatible", "gdsys,super-usb");
662 ut_assert(device_is_compatible(dev, "gdsys,super-usb"));
663 ofnode_write_string(node, "compatible", "sandbox,usb");
664 ut_assert(device_is_compatible(dev, "sandbox,usb"));
665
666 /* Test setting generic properties */
667
668 /* Non-existent in DTB */
669 ut_asserteq(FDT_ADDR_T_NONE, dev_read_addr(dev));
670 /* reg = 0x42, size = 0x100 */
671 ut_assertok(ofnode_write_prop(node, "reg", 8,
672 "\x00\x00\x00\x42\x00\x00\x01\x00"));
673 ut_asserteq(0x42, dev_read_addr(dev));
674
675 /* Test disabling devices */
676
677 device_remove(dev, DM_REMOVE_NORMAL);
678 device_unbind(dev);
679
680 ut_assert(of_device_is_available(ofnode_to_np(node)));
681 ofnode_set_enabled(node, false);
682 ut_assert(!of_device_is_available(ofnode_to_np(node)));
683
684 return 0;
685 }
686 DM_TEST(dm_test_fdt_livetree_writing, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
687
dm_test_fdt_disable_enable_by_path(struct unit_test_state * uts)688 static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
689 {
690 ofnode node;
691
692 if (!of_live_active()) {
693 printf("Live tree not active; ignore test\n");
694 return 0;
695 }
696
697 node = ofnode_path("/usb@2");
698
699 /* Test enabling devices */
700
701 ut_assert(!of_device_is_available(ofnode_to_np(node)));
702 dev_enable_by_path("/usb@2");
703 ut_assert(of_device_is_available(ofnode_to_np(node)));
704
705 /* Test disabling devices */
706
707 ut_assert(of_device_is_available(ofnode_to_np(node)));
708 dev_disable_by_path("/usb@2");
709 ut_assert(!of_device_is_available(ofnode_to_np(node)));
710
711 return 0;
712 }
713 DM_TEST(dm_test_fdt_disable_enable_by_path, DM_TESTF_SCAN_PDATA |
714 DM_TESTF_SCAN_FDT);
715
716 /* Test a few uclass phandle functions */
dm_test_fdt_phandle(struct unit_test_state * uts)717 static int dm_test_fdt_phandle(struct unit_test_state *uts)
718 {
719 struct udevice *back, *dev, *dev2;
720
721 ut_assertok(uclass_find_first_device(UCLASS_PANEL_BACKLIGHT, &back));
722 ut_asserteq(-ENOENT, uclass_find_device_by_phandle(UCLASS_REGULATOR,
723 back, "missing", &dev));
724 ut_assertok(uclass_find_device_by_phandle(UCLASS_REGULATOR, back,
725 "power-supply", &dev));
726 ut_asserteq(0, device_active(dev));
727 ut_asserteq_str("ldo1", dev->name);
728 ut_assertok(uclass_get_device_by_phandle(UCLASS_REGULATOR, back,
729 "power-supply", &dev2));
730 ut_asserteq_ptr(dev, dev2);
731
732 return 0;
733 }
734 DM_TEST(dm_test_fdt_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
735
736 /* Test device_find_first_child_by_uclass() */
dm_test_first_child(struct unit_test_state * uts)737 static int dm_test_first_child(struct unit_test_state *uts)
738 {
739 struct udevice *i2c, *dev, *dev2;
740
741 ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
742 ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_RTC, &dev));
743 ut_asserteq_str("rtc@43", dev->name);
744 ut_assertok(device_find_child_by_name(i2c, "rtc@43", &dev2));
745 ut_asserteq_ptr(dev, dev2);
746 ut_assertok(device_find_child_by_name(i2c, "rtc@61", &dev2));
747 ut_asserteq_str("rtc@61", dev2->name);
748
749 ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_I2C_EEPROM,
750 &dev));
751 ut_asserteq_str("eeprom@2c", dev->name);
752 ut_assertok(device_find_child_by_name(i2c, "eeprom@2c", &dev2));
753 ut_asserteq_ptr(dev, dev2);
754
755 ut_asserteq(-ENODEV, device_find_first_child_by_uclass(i2c,
756 UCLASS_VIDEO, &dev));
757 ut_asserteq(-ENODEV, device_find_child_by_name(i2c, "missing", &dev));
758
759 return 0;
760 }
761 DM_TEST(dm_test_first_child, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
762
763 /* Test integer functions in dm_read_...() */
dm_test_read_int(struct unit_test_state * uts)764 static int dm_test_read_int(struct unit_test_state *uts)
765 {
766 struct udevice *dev;
767 u32 val32;
768 s32 sval;
769 uint val;
770
771 ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
772 ut_asserteq_str("a-test", dev->name);
773 ut_assertok(dev_read_u32(dev, "int-value", &val32));
774 ut_asserteq(1234, val32);
775
776 ut_asserteq(-EINVAL, dev_read_u32(dev, "missing", &val32));
777 ut_asserteq(6, dev_read_u32_default(dev, "missing", 6));
778
779 ut_asserteq(1234, dev_read_u32_default(dev, "int-value", 6));
780 ut_asserteq(1234, val32);
781
782 ut_asserteq(-EINVAL, dev_read_s32(dev, "missing", &sval));
783 ut_asserteq(6, dev_read_s32_default(dev, "missing", 6));
784
785 ut_asserteq(-1234, dev_read_s32_default(dev, "uint-value", 6));
786 ut_assertok(dev_read_s32(dev, "uint-value", &sval));
787 ut_asserteq(-1234, sval);
788
789 val = 0;
790 ut_asserteq(-EINVAL, dev_read_u32u(dev, "missing", &val));
791 ut_assertok(dev_read_u32u(dev, "uint-value", &val));
792 ut_asserteq(-1234, val);
793
794 return 0;
795 }
796 DM_TEST(dm_test_read_int, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
797