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