test/dm/bus.c

   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);