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 <test/ut.h> 18 19 DECLARE_GLOBAL_DATA_PTR; 20 21 static int testfdt_drv_ping(struct udevice *dev, int pingval, int *pingret) 22 { 23 const struct dm_test_pdata *pdata = dev->platdata; 24 struct dm_test_priv *priv = dev_get_priv(dev); 25 26 *pingret = pingval + pdata->ping_add; 27 priv->ping_total += *pingret; 28 29 return 0; 30 } 31 32 static const struct test_ops test_ops = { 33 .ping = testfdt_drv_ping, 34 }; 35 36 static int testfdt_ofdata_to_platdata(struct udevice *dev) 37 { 38 struct dm_test_pdata *pdata = dev_get_platdata(dev); 39 40 pdata->ping_add = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev), 41 "ping-add", -1); 42 pdata->base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev), 43 "ping-expect"); 44 45 return 0; 46 } 47 48 static int testfdt_drv_probe(struct udevice *dev) 49 { 50 struct dm_test_priv *priv = dev_get_priv(dev); 51 52 priv->ping_total += DM_TEST_START_TOTAL; 53 54 /* 55 * If this device is on a bus, the uclass_flag will be set before 56 * calling this function. This is used by 57 * dm_test_bus_child_pre_probe_uclass(). 58 */ 59 priv->uclass_total += priv->uclass_flag; 60 61 return 0; 62 } 63 64 static const struct udevice_id testfdt_ids[] = { 65 { 66 .compatible = "denx,u-boot-fdt-test", 67 .data = DM_TEST_TYPE_FIRST }, 68 { 69 .compatible = "google,another-fdt-test", 70 .data = DM_TEST_TYPE_SECOND }, 71 { } 72 }; 73 74 U_BOOT_DRIVER(testfdt_drv) = { 75 .name = "testfdt_drv", 76 .of_match = testfdt_ids, 77 .id = UCLASS_TEST_FDT, 78 .ofdata_to_platdata = testfdt_ofdata_to_platdata, 79 .probe = testfdt_drv_probe, 80 .ops = &test_ops, 81 .priv_auto_alloc_size = sizeof(struct dm_test_priv), 82 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata), 83 }; 84 85 /* From here is the testfdt uclass code */ 86 int testfdt_ping(struct udevice *dev, int pingval, int *pingret) 87 { 88 const struct test_ops *ops = device_get_ops(dev); 89 90 if (!ops->ping) 91 return -ENOSYS; 92 93 return ops->ping(dev, pingval, pingret); 94 } 95 96 UCLASS_DRIVER(testfdt) = { 97 .name = "testfdt", 98 .id = UCLASS_TEST_FDT, 99 .flags = DM_UC_FLAG_SEQ_ALIAS, 100 }; 101 102 struct dm_testprobe_pdata { 103 int probe_err; 104 }; 105 106 static int testprobe_drv_probe(struct udevice *dev) 107 { 108 struct dm_testprobe_pdata *pdata = dev_get_platdata(dev); 109 110 return pdata->probe_err; 111 } 112 113 static const struct udevice_id testprobe_ids[] = { 114 { .compatible = "denx,u-boot-probe-test" }, 115 { } 116 }; 117 118 U_BOOT_DRIVER(testprobe_drv) = { 119 .name = "testprobe_drv", 120 .of_match = testprobe_ids, 121 .id = UCLASS_TEST_PROBE, 122 .probe = testprobe_drv_probe, 123 .platdata_auto_alloc_size = sizeof(struct dm_testprobe_pdata), 124 }; 125 126 UCLASS_DRIVER(testprobe) = { 127 .name = "testprobe", 128 .id = UCLASS_TEST_PROBE, 129 .flags = DM_UC_FLAG_SEQ_ALIAS, 130 }; 131 132 int dm_check_devices(struct unit_test_state *uts, int num_devices) 133 { 134 struct udevice *dev; 135 int ret; 136 int i; 137 138 /* 139 * Now check that the ping adds are what we expect. This is using the 140 * ping-add property in each node. 141 */ 142 for (i = 0; i < num_devices; i++) { 143 uint32_t base; 144 145 ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev); 146 ut_assert(!ret); 147 148 /* 149 * Get the 'ping-expect' property, which tells us what the 150 * ping add should be. We don't use the platdata because we 151 * want to test the code that sets that up 152 * (testfdt_drv_probe()). 153 */ 154 base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev), 155 "ping-expect"); 156 debug("dev=%d, base=%d: %s\n", i, base, 157 fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL)); 158 159 ut_assert(!dm_check_operations(uts, dev, base, 160 dev_get_priv(dev))); 161 } 162 163 return 0; 164 } 165 166 /* Test that FDT-based binding works correctly */ 167 static int dm_test_fdt(struct unit_test_state *uts) 168 { 169 const int num_devices = 7; 170 struct udevice *dev; 171 struct uclass *uc; 172 int ret; 173 int i; 174 175 ret = dm_scan_fdt(gd->fdt_blob, false); 176 ut_assert(!ret); 177 178 ret = uclass_get(UCLASS_TEST_FDT, &uc); 179 ut_assert(!ret); 180 181 /* These are num_devices compatible root-level device tree nodes */ 182 ut_asserteq(num_devices, list_count_items(&uc->dev_head)); 183 184 /* Each should have platform data but no private data */ 185 for (i = 0; i < num_devices; i++) { 186 ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev); 187 ut_assert(!ret); 188 ut_assert(!dev_get_priv(dev)); 189 ut_assert(dev->platdata); 190 } 191 192 ut_assertok(dm_check_devices(uts, num_devices)); 193 194 return 0; 195 } 196 DM_TEST(dm_test_fdt, 0); 197 198 static int dm_test_fdt_pre_reloc(struct unit_test_state *uts) 199 { 200 struct uclass *uc; 201 int ret; 202 203 ret = dm_scan_fdt(gd->fdt_blob, true); 204 ut_assert(!ret); 205 206 ret = uclass_get(UCLASS_TEST_FDT, &uc); 207 ut_assert(!ret); 208 209 /* These is only one pre-reloc device */ 210 ut_asserteq(1, list_count_items(&uc->dev_head)); 211 212 return 0; 213 } 214 DM_TEST(dm_test_fdt_pre_reloc, 0); 215 216 /* Test that sequence numbers are allocated properly */ 217 static int dm_test_fdt_uclass_seq(struct unit_test_state *uts) 218 { 219 struct udevice *dev; 220 221 /* A few basic santiy tests */ 222 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, true, &dev)); 223 ut_asserteq_str("b-test", dev->name); 224 225 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, true, &dev)); 226 ut_asserteq_str("a-test", dev->name); 227 228 ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 5, 229 true, &dev)); 230 ut_asserteq_ptr(NULL, dev); 231 232 /* Test aliases */ 233 ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 6, &dev)); 234 ut_asserteq_str("e-test", dev->name); 235 236 ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7, 237 true, &dev)); 238 239 /* 240 * Note that c-test nodes are not probed since it is not a top-level 241 * node 242 */ 243 ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 3, &dev)); 244 ut_asserteq_str("b-test", dev->name); 245 246 /* 247 * d-test wants sequence number 3 also, but it can't have it because 248 * b-test gets it first. 249 */ 250 ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 2, &dev)); 251 ut_asserteq_str("d-test", dev->name); 252 253 /* d-test actually gets 0 */ 254 ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 0, &dev)); 255 ut_asserteq_str("d-test", dev->name); 256 257 /* initially no one wants seq 1 */ 258 ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_TEST_FDT, 1, 259 &dev)); 260 ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev)); 261 ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 4, &dev)); 262 263 /* But now that it is probed, we can find it */ 264 ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 1, &dev)); 265 ut_asserteq_str("f-test", dev->name); 266 267 return 0; 268 } 269 DM_TEST(dm_test_fdt_uclass_seq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 270 271 /* Test that we can find a device by device tree offset */ 272 static int dm_test_fdt_offset(struct unit_test_state *uts) 273 { 274 const void *blob = gd->fdt_blob; 275 struct udevice *dev; 276 int node; 277 278 node = fdt_path_offset(blob, "/e-test"); 279 ut_assert(node > 0); 280 ut_assertok(uclass_get_device_by_of_offset(UCLASS_TEST_FDT, node, 281 &dev)); 282 ut_asserteq_str("e-test", dev->name); 283 284 /* This node should not be bound */ 285 node = fdt_path_offset(blob, "/junk"); 286 ut_assert(node > 0); 287 ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT, 288 node, &dev)); 289 290 /* This is not a top level node so should not be probed */ 291 node = fdt_path_offset(blob, "/some-bus/c-test@5"); 292 ut_assert(node > 0); 293 ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT, 294 node, &dev)); 295 296 return 0; 297 } 298 DM_TEST(dm_test_fdt_offset, 299 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE); 300 301 /** 302 * Test various error conditions with uclass_first_device() and 303 * uclass_next_device() 304 */ 305 static int dm_test_first_next_device(struct unit_test_state *uts) 306 { 307 struct dm_testprobe_pdata *pdata; 308 struct udevice *dev, *parent = NULL; 309 int count; 310 int ret; 311 312 /* There should be 4 devices */ 313 for (ret = uclass_first_device(UCLASS_TEST_PROBE, &dev), count = 0; 314 dev; 315 ret = uclass_next_device(&dev)) { 316 count++; 317 parent = dev_get_parent(dev); 318 } 319 ut_assertok(ret); 320 ut_asserteq(4, count); 321 322 /* Remove them and try again, with an error on the second one */ 323 ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 1, &dev)); 324 pdata = dev_get_platdata(dev); 325 pdata->probe_err = -ENOMEM; 326 device_remove(parent, DM_REMOVE_NORMAL); 327 ut_assertok(uclass_first_device(UCLASS_TEST_PROBE, &dev)); 328 ut_asserteq(-ENOMEM, uclass_next_device(&dev)); 329 ut_asserteq_ptr(dev, NULL); 330 331 /* Now an error on the first one */ 332 ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 0, &dev)); 333 pdata = dev_get_platdata(dev); 334 pdata->probe_err = -ENOENT; 335 device_remove(parent, DM_REMOVE_NORMAL); 336 ut_asserteq(-ENOENT, uclass_first_device(UCLASS_TEST_PROBE, &dev)); 337 338 return 0; 339 } 340 DM_TEST(dm_test_first_next_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 341 342 /** 343 * check_devices() - Check return values and pointers 344 * 345 * This runs through a full sequence of uclass_first_device_check()... 346 * uclass_next_device_check() checking that the return values and devices 347 * are correct. 348 * 349 * @uts: Test state 350 * @devlist: List of expected devices 351 * @mask: Indicates which devices should return an error. Device n should 352 * return error (-NOENT - n) if bit n is set, or no error (i.e. 0) if 353 * bit n is clear. 354 */ 355 static int check_devices(struct unit_test_state *uts, 356 struct udevice *devlist[], int mask) 357 { 358 int expected_ret; 359 struct udevice *dev; 360 int i; 361 362 expected_ret = (mask & 1) ? -ENOENT : 0; 363 mask >>= 1; 364 ut_asserteq(expected_ret, 365 uclass_first_device_check(UCLASS_TEST_PROBE, &dev)); 366 for (i = 0; i < 4; i++) { 367 ut_asserteq_ptr(devlist[i], dev); 368 expected_ret = (mask & 1) ? -ENOENT - (i + 1) : 0; 369 mask >>= 1; 370 ut_asserteq(expected_ret, uclass_next_device_check(&dev)); 371 } 372 ut_asserteq_ptr(NULL, dev); 373 374 return 0; 375 } 376 377 /* Test uclass_first_device_check() and uclass_next_device_check() */ 378 static int dm_test_first_next_ok_device(struct unit_test_state *uts) 379 { 380 struct dm_testprobe_pdata *pdata; 381 struct udevice *dev, *parent = NULL, *devlist[4]; 382 int count; 383 int ret; 384 385 /* There should be 4 devices */ 386 count = 0; 387 for (ret = uclass_first_device_check(UCLASS_TEST_PROBE, &dev); 388 dev; 389 ret = uclass_next_device_check(&dev)) { 390 ut_assertok(ret); 391 devlist[count++] = dev; 392 parent = dev_get_parent(dev); 393 } 394 ut_asserteq(4, count); 395 ut_assertok(uclass_first_device_check(UCLASS_TEST_PROBE, &dev)); 396 ut_assertok(check_devices(uts, devlist, 0)); 397 398 /* Remove them and try again, with an error on the second one */ 399 pdata = dev_get_platdata(devlist[1]); 400 pdata->probe_err = -ENOENT - 1; 401 device_remove(parent, DM_REMOVE_NORMAL); 402 ut_assertok(check_devices(uts, devlist, 1 << 1)); 403 404 /* Now an error on the first one */ 405 pdata = dev_get_platdata(devlist[0]); 406 pdata->probe_err = -ENOENT - 0; 407 device_remove(parent, DM_REMOVE_NORMAL); 408 ut_assertok(check_devices(uts, devlist, 3 << 0)); 409 410 /* Now errors on all */ 411 pdata = dev_get_platdata(devlist[2]); 412 pdata->probe_err = -ENOENT - 2; 413 pdata = dev_get_platdata(devlist[3]); 414 pdata->probe_err = -ENOENT - 3; 415 device_remove(parent, DM_REMOVE_NORMAL); 416 ut_assertok(check_devices(uts, devlist, 0xf << 0)); 417 418 return 0; 419 } 420 DM_TEST(dm_test_first_next_ok_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 421 422 static const struct udevice_id fdt_dummy_ids[] = { 423 { .compatible = "denx,u-boot-fdt-dummy", }, 424 { } 425 }; 426 427 UCLASS_DRIVER(fdt_dummy) = { 428 .name = "fdt-dummy", 429 .id = UCLASS_TEST_DUMMY, 430 .flags = DM_UC_FLAG_SEQ_ALIAS, 431 }; 432 433 U_BOOT_DRIVER(fdt_dummy_drv) = { 434 .name = "fdt_dummy_drv", 435 .of_match = fdt_dummy_ids, 436 .id = UCLASS_TEST_DUMMY, 437 }; 438 439 static int dm_test_fdt_translation(struct unit_test_state *uts) 440 { 441 struct udevice *dev; 442 443 /* Some simple translations */ 444 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev)); 445 ut_asserteq_str("dev@0,0", dev->name); 446 ut_asserteq(0x8000, dev_read_addr(dev)); 447 448 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev)); 449 ut_asserteq_str("dev@1,100", dev->name); 450 ut_asserteq(0x9000, dev_read_addr(dev)); 451 452 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 2, true, &dev)); 453 ut_asserteq_str("dev@2,200", dev->name); 454 ut_asserteq(0xA000, dev_read_addr(dev)); 455 456 /* No translation for busses with #size-cells == 0 */ 457 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 3, true, &dev)); 458 ut_asserteq_str("dev@42", dev->name); 459 ut_asserteq(0x42, dev_read_addr(dev)); 460 461 return 0; 462 } 463 DM_TEST(dm_test_fdt_translation, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 464 465 /* Test devfdt_remap_addr_index() */ 466 static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts) 467 { 468 struct udevice *dev; 469 fdt_addr_t addr; 470 void *paddr; 471 472 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev)); 473 474 addr = devfdt_get_addr(dev); 475 ut_asserteq(0x8000, addr); 476 477 paddr = map_physmem(addr, 0, MAP_NOCACHE); 478 ut_assertnonnull(paddr); 479 ut_asserteq_ptr(paddr, devfdt_remap_addr(dev)); 480 481 return 0; 482 } 483 DM_TEST(dm_test_fdt_remap_addr_flat, 484 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE); 485 486 /* Test dev_remap_addr_index() */ 487 static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts) 488 { 489 struct udevice *dev; 490 fdt_addr_t addr; 491 void *paddr; 492 493 ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev)); 494 495 addr = dev_read_addr(dev); 496 ut_asserteq(0x8000, addr); 497 498 paddr = map_physmem(addr, 0, MAP_NOCACHE); 499 ut_assertnonnull(paddr); 500 ut_asserteq_ptr(paddr, dev_remap_addr(dev)); 501 502 return 0; 503 } 504 DM_TEST(dm_test_fdt_remap_addr_live, 505 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 506
