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/root.h>
  11 #include <dm/test.h>
  12 #include <dm/uclass-internal.h>
  13 #include <dm/util.h>
  14 #include <test/ut.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_parent_priv(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_parent_priv(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 unit_test_state *uts)
 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(uts, 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 unit_test_state *uts)
 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 unit_test_state *uts)
 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 unit_test_state *uts)
 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_parent_priv(dev));
 219         ut_assertok(device_get_child_by_seq(bus, 0, &dev));
 220         parent_data = dev_get_parent_priv(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_parent_priv(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_parent_priv(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_parent_priv(dev));
 243                         continue;
 244                 }
 245                 ut_assertok(device_probe(dev));
 246                 parent_data = dev_get_parent_priv(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_parent_priv(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 unit_test_state *uts)
 268 {
 269         return test_bus_parent_data(uts);
 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 unit_test_state *uts)
 275 {
 276         struct driver *drv;
 277         struct udevice *bus;
 278         int size;
 279         int ret;
 280
 281         /* Set the driver size to 0 so that the uclass size is used */
 282         ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
 283         drv = (struct driver *)bus->driver;
 284         size = drv->per_child_auto_alloc_size;
 285         bus->uclass->uc_drv->per_child_auto_alloc_size = size;
 286         drv->per_child_auto_alloc_size = 0;
 287         ret = test_bus_parent_data(uts);
 288         if (ret)
 289                 return ret;
 290         bus->uclass->uc_drv->per_child_auto_alloc_size = 0;
 291         drv->per_child_auto_alloc_size = size;
 292
 293         return 0;
 294 }
 295 DM_TEST(dm_test_bus_parent_data_uclass,
 296         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 297
 298 /* Test that the bus ops are called when a child is probed/removed */
 299 static int dm_test_bus_parent_ops(struct unit_test_state *uts)
 300 {
 301         struct dm_test_parent_data *parent_data;
 302         struct dm_test_state *dms = uts->priv;
 303         struct udevice *bus, *dev;
 304         struct uclass *uc;
 305
 306         test_state = dms;
 307         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
 308         ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
 309
 310         uclass_foreach_dev(dev, uc) {
 311                 /* Ignore these if they are not on this bus */
 312                 if (dev->parent != bus)
 313                         continue;
 314                 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
 315
 316                 ut_assertok(device_probe(dev));
 317                 parent_data = dev_get_parent_priv(dev);
 318                 ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
 319         }
 320
 321         uclass_foreach_dev(dev, uc) {
 322                 /* Ignore these if they are not on this bus */
 323                 if (dev->parent != bus)
 324                         continue;
 325                 parent_data = dev_get_parent_priv(dev);
 326                 ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
 327                 ut_assertok(device_remove(dev));
 328                 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
 329                 ut_asserteq_ptr(dms->removed, dev);
 330         }
 331         test_state = NULL;
 332
 333         return 0;
 334 }
 335 DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 336
 337 static int test_bus_parent_platdata(struct unit_test_state *uts)
 338 {
 339         struct dm_test_parent_platdata *plat;
 340         struct udevice *bus, *dev;
 341         int child_count;
 342
 343         /* Check that the bus has no children */
 344         ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
 345         device_find_first_child(bus, &dev);
 346         ut_asserteq_ptr(NULL, dev);
 347
 348         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
 349
 350         for (device_find_first_child(bus, &dev), child_count = 0;
 351              dev;
 352              device_find_next_child(&dev)) {
 353                 /* Check that platform data is allocated */
 354                 plat = dev_get_parent_platdata(dev);
 355                 ut_assert(plat != NULL);
 356
 357                 /*
 358                  * Check that it is not affected by the device being
 359                  * probed/removed
 360                  */
 361                 plat->count++;
 362                 ut_asserteq(1, plat->count);
 363                 device_probe(dev);
 364                 device_remove(dev);
 365
 366                 ut_asserteq_ptr(plat, dev_get_parent_platdata(dev));
 367                 ut_asserteq(1, plat->count);
 368                 ut_assertok(device_probe(dev));
 369                 child_count++;
 370         }
 371         ut_asserteq(3, child_count);
 372
 373         /* Removing the bus should also have no effect (it is still bound) */
 374         device_remove(bus);
 375         for (device_find_first_child(bus, &dev), child_count = 0;
 376              dev;
 377              device_find_next_child(&dev)) {
 378                 /* Check that platform data is allocated */
 379                 plat = dev_get_parent_platdata(dev);
 380                 ut_assert(plat != NULL);
 381                 ut_asserteq(1, plat->count);
 382                 child_count++;
 383         }
 384         ut_asserteq(3, child_count);
 385
 386         /* Unbind all the children */
 387         do {
 388                 device_find_first_child(bus, &dev);
 389                 if (dev)
 390                         device_unbind(dev);
 391         } while (dev);
 392
 393         /* Now the child platdata should be removed and re-added */
 394         device_probe(bus);
 395         for (device_find_first_child(bus, &dev), child_count = 0;
 396              dev;
 397              device_find_next_child(&dev)) {
 398                 /* Check that platform data is allocated */
 399                 plat = dev_get_parent_platdata(dev);
 400                 ut_assert(plat != NULL);
 401                 ut_asserteq(0, plat->count);
 402                 child_count++;
 403         }
 404         ut_asserteq(3, child_count);
 405
 406         return 0;
 407 }
 408
 409 /* Test that the bus can store platform data about each child */
 410 static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
 411 {
 412         return test_bus_parent_platdata(uts);
 413 }
 414 DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 415
 416 /* As above but the size is controlled by the uclass */
 417 static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
 418 {
 419         struct udevice *bus;
 420         struct driver *drv;
 421         int size;
 422         int ret;
 423
 424         /* Set the driver size to 0 so that the uclass size is used */
 425         ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
 426         drv = (struct driver *)bus->driver;
 427         size = drv->per_child_platdata_auto_alloc_size;
 428         bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
 429         drv->per_child_platdata_auto_alloc_size = 0;
 430         ret = test_bus_parent_platdata(uts);
 431         if (ret)
 432                 return ret;
 433         bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
 434         drv->per_child_platdata_auto_alloc_size = size;
 435
 436         return 0;
 437 }
 438 DM_TEST(dm_test_bus_parent_platdata_uclass,
 439         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 440
 441 /* Test that the child post_bind method is called */
 442 static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
 443 {
 444         struct dm_test_parent_platdata *plat;
 445         struct udevice *bus, *dev;
 446         int child_count;
 447
 448         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
 449         for (device_find_first_child(bus, &dev), child_count = 0;
 450              dev;
 451              device_find_next_child(&dev)) {
 452                 /* Check that platform data is allocated */
 453                 plat = dev_get_parent_platdata(dev);
 454                 ut_assert(plat != NULL);
 455                 ut_asserteq(1, plat->bind_flag);
 456                 child_count++;
 457         }
 458         ut_asserteq(3, child_count);
 459
 460         return 0;
 461 }
 462 DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 463
 464 /* Test that the child post_bind method is called */
 465 static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
 466 {
 467         struct dm_test_parent_platdata *plat;
 468         struct udevice *bus, *dev;
 469         int child_count;
 470
 471         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
 472         for (device_find_first_child(bus, &dev), child_count = 0;
 473              dev;
 474              device_find_next_child(&dev)) {
 475                 /* Check that platform data is allocated */
 476                 plat = dev_get_parent_platdata(dev);
 477                 ut_assert(plat != NULL);
 478                 ut_asserteq(2, plat->uclass_bind_flag);
 479                 child_count++;
 480         }
 481         ut_asserteq(3, child_count);
 482
 483         return 0;
 484 }
 485 DM_TEST(dm_test_bus_child_post_bind_uclass,
 486         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 487
 488 /*
 489  * Test that the bus' uclass' child_pre_probe() is called before the
 490  * device's probe() method
 491  */
 492 static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts)
 493 {
 494         struct udevice *bus, *dev;
 495         int child_count;
 496
 497         /*
 498          * See testfdt_drv_probe() which effectively checks that the uclass
 499          * flag is set before that method is called
 500          */
 501         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
 502         for (device_find_first_child(bus, &dev), child_count = 0;
 503              dev;
 504              device_find_next_child(&dev)) {
 505                 struct dm_test_priv *priv = dev_get_priv(dev);
 506
 507                 /* Check that things happened in the right order */
 508                 ut_asserteq_ptr(NULL, priv);
 509                 ut_assertok(device_probe(dev));
 510
 511                 priv = dev_get_priv(dev);
 512                 ut_assert(priv != NULL);
 513                 ut_asserteq(1, priv->uclass_flag);
 514                 ut_asserteq(1, priv->uclass_total);
 515                 child_count++;
 516         }
 517         ut_asserteq(3, child_count);
 518
 519         return 0;
 520 }
 521 DM_TEST(dm_test_bus_child_pre_probe_uclass,
 522         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);