1 /* 2 * Copyright (c) 2014 Google, Inc 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <common.h> 8 #include <dm.h> 9 #include <dm/device-internal.h> 10 #include <dm/test.h> 11 #include <dm/uclass-internal.h> 12 #include <dm/util.h> 13 #include <test/ut.h> 14 15 DECLARE_GLOBAL_DATA_PTR; 16 17 struct dm_test_parent_platdata { 18 int count; 19 int bind_flag; 20 int uclass_bind_flag; 21 }; 22 23 enum { 24 FLAG_CHILD_PROBED = 10, 25 FLAG_CHILD_REMOVED = -7, 26 }; 27 28 static struct dm_test_state *test_state; 29 30 static int testbus_drv_probe(struct udevice *dev) 31 { 32 return dm_scan_fdt_dev(dev); 33 } 34 35 static int testbus_child_post_bind(struct udevice *dev) 36 { 37 struct dm_test_parent_platdata *plat; 38 39 plat = dev_get_parent_platdata(dev); 40 plat->bind_flag = 1; 41 plat->uclass_bind_flag = 2; 42 43 return 0; 44 } 45 46 static int testbus_child_pre_probe(struct udevice *dev) 47 { 48 struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev); 49 50 parent_data->flag += FLAG_CHILD_PROBED; 51 52 return 0; 53 } 54 55 static int testbus_child_pre_probe_uclass(struct udevice *dev) 56 { 57 struct dm_test_priv *priv = dev_get_priv(dev); 58 59 priv->uclass_flag++; 60 61 return 0; 62 } 63 64 static int testbus_child_post_remove(struct udevice *dev) 65 { 66 struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev); 67 struct dm_test_state *dms = test_state; 68 69 parent_data->flag += FLAG_CHILD_REMOVED; 70 if (dms) 71 dms->removed = dev; 72 73 return 0; 74 } 75 76 static const struct udevice_id testbus_ids[] = { 77 { 78 .compatible = "denx,u-boot-test-bus", 79 .data = DM_TEST_TYPE_FIRST }, 80 { } 81 }; 82 83 U_BOOT_DRIVER(testbus_drv) = { 84 .name = "testbus_drv", 85 .of_match = testbus_ids, 86 .id = UCLASS_TEST_BUS, 87 .probe = testbus_drv_probe, 88 .child_post_bind = testbus_child_post_bind, 89 .priv_auto_alloc_size = sizeof(struct dm_test_priv), 90 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata), 91 .per_child_auto_alloc_size = sizeof(struct dm_test_parent_data), 92 .per_child_platdata_auto_alloc_size = 93 sizeof(struct dm_test_parent_platdata), 94 .child_pre_probe = testbus_child_pre_probe, 95 .child_post_remove = testbus_child_post_remove, 96 }; 97 98 UCLASS_DRIVER(testbus) = { 99 .name = "testbus", 100 .id = UCLASS_TEST_BUS, 101 .flags = DM_UC_FLAG_SEQ_ALIAS, 102 .child_pre_probe = testbus_child_pre_probe_uclass, 103 }; 104 105 /* Test that we can probe for children */ 106 static int dm_test_bus_children(struct unit_test_state *uts) 107 { 108 int num_devices = 6; 109 struct udevice *bus; 110 struct uclass *uc; 111 112 ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc)); 113 ut_asserteq(num_devices, list_count_items(&uc->dev_head)); 114 115 /* Probe the bus, which should yield 3 more devices */ 116 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 117 num_devices += 3; 118 119 ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc)); 120 ut_asserteq(num_devices, list_count_items(&uc->dev_head)); 121 122 ut_assert(!dm_check_devices(uts, num_devices)); 123 124 return 0; 125 } 126 DM_TEST(dm_test_bus_children, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 127 128 /* Test our functions for accessing children */ 129 static int dm_test_bus_children_funcs(struct unit_test_state *uts) 130 { 131 const void *blob = gd->fdt_blob; 132 struct udevice *bus, *dev; 133 int node; 134 135 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 136 137 /* device_get_child() */ 138 ut_assertok(device_get_child(bus, 0, &dev)); 139 ut_asserteq(-ENODEV, device_get_child(bus, 4, &dev)); 140 ut_assertok(device_get_child_by_seq(bus, 5, &dev)); 141 ut_assert(dev->flags & DM_FLAG_ACTIVATED); 142 ut_asserteq_str("c-test@5", dev->name); 143 144 /* Device with sequence number 0 should be accessible */ 145 ut_asserteq(-ENODEV, device_find_child_by_seq(bus, -1, true, &dev)); 146 ut_assertok(device_find_child_by_seq(bus, 0, true, &dev)); 147 ut_assert(!(dev->flags & DM_FLAG_ACTIVATED)); 148 ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 0, false, &dev)); 149 ut_assertok(device_get_child_by_seq(bus, 0, &dev)); 150 ut_assert(dev->flags & DM_FLAG_ACTIVATED); 151 152 /* There is no device with sequence number 2 */ 153 ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, false, &dev)); 154 ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, true, &dev)); 155 ut_asserteq(-ENODEV, device_get_child_by_seq(bus, 2, &dev)); 156 157 /* Looking for something that is not a child */ 158 node = fdt_path_offset(blob, "/junk"); 159 ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev)); 160 node = fdt_path_offset(blob, "/d-test"); 161 ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev)); 162 163 return 0; 164 } 165 DM_TEST(dm_test_bus_children_funcs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 166 167 static int dm_test_bus_children_of_offset(struct unit_test_state *uts) 168 { 169 const void *blob = gd->fdt_blob; 170 struct udevice *bus, *dev; 171 int node; 172 173 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 174 ut_assertnonnull(bus); 175 176 /* Find a valid child */ 177 node = fdt_path_offset(blob, "/some-bus/c-test@1"); 178 ut_assert(node > 0); 179 ut_assertok(device_find_child_by_of_offset(bus, node, &dev)); 180 ut_assertnonnull(dev); 181 ut_assert(!(dev->flags & DM_FLAG_ACTIVATED)); 182 ut_assertok(device_get_child_by_of_offset(bus, node, &dev)); 183 ut_assertnonnull(dev); 184 ut_assert(dev->flags & DM_FLAG_ACTIVATED); 185 186 return 0; 187 } 188 DM_TEST(dm_test_bus_children_of_offset, 189 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE); 190 191 /* Test that we can iterate through children */ 192 static int dm_test_bus_children_iterators(struct unit_test_state *uts) 193 { 194 struct udevice *bus, *dev, *child; 195 196 /* Walk through the children one by one */ 197 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 198 ut_assertok(device_find_first_child(bus, &dev)); 199 ut_asserteq_str("c-test@5", dev->name); 200 ut_assertok(device_find_next_child(&dev)); 201 ut_asserteq_str("c-test@0", dev->name); 202 ut_assertok(device_find_next_child(&dev)); 203 ut_asserteq_str("c-test@1", dev->name); 204 ut_assertok(device_find_next_child(&dev)); 205 ut_asserteq_ptr(dev, NULL); 206 207 /* Move to the next child without using device_find_first_child() */ 208 ut_assertok(device_find_child_by_seq(bus, 5, true, &dev)); 209 ut_asserteq_str("c-test@5", dev->name); 210 ut_assertok(device_find_next_child(&dev)); 211 ut_asserteq_str("c-test@0", dev->name); 212 213 /* Try a device with no children */ 214 ut_assertok(device_find_first_child(dev, &child)); 215 ut_asserteq_ptr(child, NULL); 216 217 return 0; 218 } 219 DM_TEST(dm_test_bus_children_iterators, 220 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 221 222 /* Test that the bus can store data about each child */ 223 static int test_bus_parent_data(struct unit_test_state *uts) 224 { 225 struct dm_test_parent_data *parent_data; 226 struct udevice *bus, *dev; 227 struct uclass *uc; 228 int value; 229 230 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 231 232 /* Check that parent data is allocated */ 233 ut_assertok(device_find_child_by_seq(bus, 0, true, &dev)); 234 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev)); 235 ut_assertok(device_get_child_by_seq(bus, 0, &dev)); 236 parent_data = dev_get_parent_priv(dev); 237 ut_assert(NULL != parent_data); 238 239 /* Check that it starts at 0 and goes away when device is removed */ 240 parent_data->sum += 5; 241 ut_asserteq(5, parent_data->sum); 242 device_remove(dev, DM_REMOVE_NORMAL); 243 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev)); 244 245 /* Check that we can do this twice */ 246 ut_assertok(device_get_child_by_seq(bus, 0, &dev)); 247 parent_data = dev_get_parent_priv(dev); 248 ut_assert(NULL != parent_data); 249 parent_data->sum += 5; 250 ut_asserteq(5, parent_data->sum); 251 252 /* Add parent data to all children */ 253 ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc)); 254 value = 5; 255 uclass_foreach_dev(dev, uc) { 256 /* Ignore these if they are not on this bus */ 257 if (dev->parent != bus) { 258 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev)); 259 continue; 260 } 261 ut_assertok(device_probe(dev)); 262 parent_data = dev_get_parent_priv(dev); 263 264 parent_data->sum = value; 265 value += 5; 266 } 267 268 /* Check it is still there */ 269 value = 5; 270 uclass_foreach_dev(dev, uc) { 271 /* Ignore these if they are not on this bus */ 272 if (dev->parent != bus) 273 continue; 274 parent_data = dev_get_parent_priv(dev); 275 276 ut_asserteq(value, parent_data->sum); 277 value += 5; 278 } 279 280 return 0; 281 } 282 /* Test that the bus can store data about each child */ 283 static int dm_test_bus_parent_data(struct unit_test_state *uts) 284 { 285 return test_bus_parent_data(uts); 286 } 287 DM_TEST(dm_test_bus_parent_data, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 288 289 /* As above but the size is controlled by the uclass */ 290 static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts) 291 { 292 struct driver *drv; 293 struct udevice *bus; 294 int size; 295 int ret; 296 297 /* Set the driver size to 0 so that the uclass size is used */ 298 ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus)); 299 drv = (struct driver *)bus->driver; 300 size = drv->per_child_auto_alloc_size; 301 bus->uclass->uc_drv->per_child_auto_alloc_size = size; 302 drv->per_child_auto_alloc_size = 0; 303 ret = test_bus_parent_data(uts); 304 if (ret) 305 return ret; 306 bus->uclass->uc_drv->per_child_auto_alloc_size = 0; 307 drv->per_child_auto_alloc_size = size; 308 309 return 0; 310 } 311 DM_TEST(dm_test_bus_parent_data_uclass, 312 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 313 314 /* Test that the bus ops are called when a child is probed/removed */ 315 static int dm_test_bus_parent_ops(struct unit_test_state *uts) 316 { 317 struct dm_test_parent_data *parent_data; 318 struct dm_test_state *dms = uts->priv; 319 struct udevice *bus, *dev; 320 struct uclass *uc; 321 322 test_state = dms; 323 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 324 ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc)); 325 326 uclass_foreach_dev(dev, uc) { 327 /* Ignore these if they are not on this bus */ 328 if (dev->parent != bus) 329 continue; 330 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev)); 331 332 ut_assertok(device_probe(dev)); 333 parent_data = dev_get_parent_priv(dev); 334 ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag); 335 } 336 337 uclass_foreach_dev(dev, uc) { 338 /* Ignore these if they are not on this bus */ 339 if (dev->parent != bus) 340 continue; 341 parent_data = dev_get_parent_priv(dev); 342 ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag); 343 ut_assertok(device_remove(dev, DM_REMOVE_NORMAL)); 344 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev)); 345 ut_asserteq_ptr(dms->removed, dev); 346 } 347 test_state = NULL; 348 349 return 0; 350 } 351 DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 352 353 static int test_bus_parent_platdata(struct unit_test_state *uts) 354 { 355 struct dm_test_parent_platdata *plat; 356 struct udevice *bus, *dev; 357 int child_count; 358 359 /* Check that the bus has no children */ 360 ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus)); 361 device_find_first_child(bus, &dev); 362 ut_asserteq_ptr(NULL, dev); 363 364 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 365 366 for (device_find_first_child(bus, &dev), child_count = 0; 367 dev; 368 device_find_next_child(&dev)) { 369 /* Check that platform data is allocated */ 370 plat = dev_get_parent_platdata(dev); 371 ut_assert(plat != NULL); 372 373 /* 374 * Check that it is not affected by the device being 375 * probed/removed 376 */ 377 plat->count++; 378 ut_asserteq(1, plat->count); 379 device_probe(dev); 380 device_remove(dev, DM_REMOVE_NORMAL); 381 382 ut_asserteq_ptr(plat, dev_get_parent_platdata(dev)); 383 ut_asserteq(1, plat->count); 384 ut_assertok(device_probe(dev)); 385 child_count++; 386 } 387 ut_asserteq(3, child_count); 388 389 /* Removing the bus should also have no effect (it is still bound) */ 390 device_remove(bus, DM_REMOVE_NORMAL); 391 for (device_find_first_child(bus, &dev), child_count = 0; 392 dev; 393 device_find_next_child(&dev)) { 394 /* Check that platform data is allocated */ 395 plat = dev_get_parent_platdata(dev); 396 ut_assert(plat != NULL); 397 ut_asserteq(1, plat->count); 398 child_count++; 399 } 400 ut_asserteq(3, child_count); 401 402 /* Unbind all the children */ 403 do { 404 device_find_first_child(bus, &dev); 405 if (dev) 406 device_unbind(dev); 407 } while (dev); 408 409 /* Now the child platdata should be removed and re-added */ 410 device_probe(bus); 411 for (device_find_first_child(bus, &dev), child_count = 0; 412 dev; 413 device_find_next_child(&dev)) { 414 /* Check that platform data is allocated */ 415 plat = dev_get_parent_platdata(dev); 416 ut_assert(plat != NULL); 417 ut_asserteq(0, plat->count); 418 child_count++; 419 } 420 ut_asserteq(3, child_count); 421 422 return 0; 423 } 424 425 /* Test that the bus can store platform data about each child */ 426 static int dm_test_bus_parent_platdata(struct unit_test_state *uts) 427 { 428 return test_bus_parent_platdata(uts); 429 } 430 DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 431 432 /* As above but the size is controlled by the uclass */ 433 static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts) 434 { 435 struct udevice *bus; 436 struct driver *drv; 437 int size; 438 int ret; 439 440 /* Set the driver size to 0 so that the uclass size is used */ 441 ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus)); 442 drv = (struct driver *)bus->driver; 443 size = drv->per_child_platdata_auto_alloc_size; 444 bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size; 445 drv->per_child_platdata_auto_alloc_size = 0; 446 ret = test_bus_parent_platdata(uts); 447 if (ret) 448 return ret; 449 bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0; 450 drv->per_child_platdata_auto_alloc_size = size; 451 452 return 0; 453 } 454 DM_TEST(dm_test_bus_parent_platdata_uclass, 455 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 456 457 /* Test that the child post_bind method is called */ 458 static int dm_test_bus_child_post_bind(struct unit_test_state *uts) 459 { 460 struct dm_test_parent_platdata *plat; 461 struct udevice *bus, *dev; 462 int child_count; 463 464 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 465 for (device_find_first_child(bus, &dev), child_count = 0; 466 dev; 467 device_find_next_child(&dev)) { 468 /* Check that platform data is allocated */ 469 plat = dev_get_parent_platdata(dev); 470 ut_assert(plat != NULL); 471 ut_asserteq(1, plat->bind_flag); 472 child_count++; 473 } 474 ut_asserteq(3, child_count); 475 476 return 0; 477 } 478 DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 479 480 /* Test that the child post_bind method is called */ 481 static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts) 482 { 483 struct dm_test_parent_platdata *plat; 484 struct udevice *bus, *dev; 485 int child_count; 486 487 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 488 for (device_find_first_child(bus, &dev), child_count = 0; 489 dev; 490 device_find_next_child(&dev)) { 491 /* Check that platform data is allocated */ 492 plat = dev_get_parent_platdata(dev); 493 ut_assert(plat != NULL); 494 ut_asserteq(2, plat->uclass_bind_flag); 495 child_count++; 496 } 497 ut_asserteq(3, child_count); 498 499 return 0; 500 } 501 DM_TEST(dm_test_bus_child_post_bind_uclass, 502 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 503 504 /* 505 * Test that the bus' uclass' child_pre_probe() is called before the 506 * device's probe() method 507 */ 508 static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts) 509 { 510 struct udevice *bus, *dev; 511 int child_count; 512 513 /* 514 * See testfdt_drv_probe() which effectively checks that the uclass 515 * flag is set before that method is called 516 */ 517 ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); 518 for (device_find_first_child(bus, &dev), child_count = 0; 519 dev; 520 device_find_next_child(&dev)) { 521 struct dm_test_priv *priv = dev_get_priv(dev); 522 523 /* Check that things happened in the right order */ 524 ut_asserteq_ptr(NULL, priv); 525 ut_assertok(device_probe(dev)); 526 527 priv = dev_get_priv(dev); 528 ut_assert(priv != NULL); 529 ut_asserteq(1, priv->uclass_flag); 530 ut_asserteq(1, priv->uclass_total); 531 child_count++; 532 } 533 ut_asserteq(3, child_count); 534 535 return 0; 536 } 537 DM_TEST(dm_test_bus_child_pre_probe_uclass, 538 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 539