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 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 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 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 */ 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 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 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 */ 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 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 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 */ 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 */ 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 */ 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 */ 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() */ 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 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 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 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 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 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 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 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 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 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 */ 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() */ 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_...() */ 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