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