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