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