diff options
Diffstat (limited to 'test/dm/core.c')
| -rw-r--r-- | test/dm/core.c | 111 |
1 files changed, 65 insertions, 46 deletions
diff --git a/test/dm/core.c b/test/dm/core.c index 6f380a574c..1f5ca570dc 100644 --- a/test/dm/core.c +++ b/test/dm/core.c @@ -43,29 +43,29 @@ static const struct dm_test_pdata test_pdata_pre_reloc = { .ping_add = TEST_INTVAL_PRE_RELOC, }; -U_BOOT_DEVICE(dm_test_info1) = { +U_BOOT_DRVINFO(dm_test_info1) = { .name = "test_drv", - .platdata = &test_pdata[0], + .plat = &test_pdata[0], }; -U_BOOT_DEVICE(dm_test_info2) = { +U_BOOT_DRVINFO(dm_test_info2) = { .name = "test_drv", - .platdata = &test_pdata[1], + .plat = &test_pdata[1], }; -U_BOOT_DEVICE(dm_test_info3) = { +U_BOOT_DRVINFO(dm_test_info3) = { .name = "test_drv", - .platdata = &test_pdata[2], + .plat = &test_pdata[2], }; static struct driver_info driver_info_manual = { .name = "test_manual_drv", - .platdata = &test_pdata_manual, + .plat = &test_pdata_manual, }; static struct driver_info driver_info_pre_reloc = { .name = "test_pre_reloc_drv", - .platdata = &test_pdata_pre_reloc, + .plat = &test_pdata_pre_reloc, }; static struct driver_info driver_info_act_dma = { @@ -105,7 +105,7 @@ int dm_leak_check_end(struct unit_test_state *uts) return 0; } -/* Test that binding with platdata occurs correctly */ +/* Test that binding with plat occurs correctly */ static int dm_test_autobind(struct unit_test_state *uts) { struct dm_test_state *dms = uts->priv; @@ -116,14 +116,14 @@ static int dm_test_autobind(struct unit_test_state *uts) * device with no children. */ ut_assert(dms->root); - ut_asserteq(1, list_count_items(&gd->uclass_root)); + ut_asserteq(1, list_count_items(gd->uclass_root)); ut_asserteq(0, list_count_items(&gd->dm_root->child_head)); ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]); - ut_assertok(dm_scan_platdata(false)); + ut_assertok(dm_scan_plat(false)); /* We should have our test class now at least, plus more children */ - ut_assert(1 < list_count_items(&gd->uclass_root)); + ut_assert(1 < list_count_items(gd->uclass_root)); ut_assert(0 < list_count_items(&gd->dm_root->child_head)); /* Our 3 dm_test_infox children should be bound to the test uclass */ @@ -131,7 +131,7 @@ static int dm_test_autobind(struct unit_test_state *uts) /* No devices should be probed */ list_for_each_entry(dev, &gd->dm_root->child_head, sibling_node) - ut_assert(!(dev->flags & DM_FLAG_ACTIVATED)); + ut_assert(!(dev_get_flags(dev) & DM_FLAG_ACTIVATED)); /* Our test driver should have been bound 3 times */ ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND] == 3); @@ -140,7 +140,7 @@ static int dm_test_autobind(struct unit_test_state *uts) } DM_TEST(dm_test_autobind, 0); -/* Test that binding with uclass platdata allocation occurs correctly */ +/* Test that binding with uclass plat allocation occurs correctly */ static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts) { struct dm_test_perdev_uc_pdata *uc_pdata; @@ -152,16 +152,16 @@ static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts) /** * Test if test uclass driver requires allocation for the uclass - * platform data and then check the dev->uclass_platdata pointer. + * platform data and then check the dev->uclass_plat pointer. */ - ut_assert(uc->uc_drv->per_device_platdata_auto_alloc_size); + ut_assert(uc->uc_drv->per_device_plat_auto); for (uclass_find_first_device(UCLASS_TEST, &dev); dev; uclass_find_next_device(&dev)) { ut_assertnonnull(dev); - uc_pdata = dev_get_uclass_platdata(dev); + uc_pdata = dev_get_uclass_plat(dev); ut_assert(uc_pdata); } @@ -169,7 +169,7 @@ static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts) } DM_TEST(dm_test_autobind_uclass_pdata_alloc, UT_TESTF_SCAN_PDATA); -/* Test that binding with uclass platdata setting occurs correctly */ +/* Test that binding with uclass plat setting occurs correctly */ static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts) { struct dm_test_perdev_uc_pdata *uc_pdata; @@ -184,7 +184,7 @@ static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts) uclass_find_next_device(&dev)) { ut_assertnonnull(dev); - uc_pdata = dev_get_uclass_platdata(dev); + uc_pdata = dev_get_uclass_plat(dev); ut_assert(uc_pdata); ut_assert(uc_pdata->intval1 == TEST_UC_PDATA_INTVAL1); ut_assert(uc_pdata->intval2 == TEST_UC_PDATA_INTVAL2); @@ -212,7 +212,7 @@ static int dm_test_autoprobe(struct unit_test_state *uts) ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]); /* The root device should not be activated until needed */ - ut_assert(dms->root->flags & DM_FLAG_ACTIVATED); + ut_assert(dev_get_flags(dms->root) & DM_FLAG_ACTIVATED); /* * We should be able to find the three test devices, and they should @@ -222,17 +222,17 @@ static int dm_test_autoprobe(struct unit_test_state *uts) for (i = 0; i < 3; i++) { ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); ut_assert(dev); - ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED), + ut_assertf(!(dev_get_flags(dev) & DM_FLAG_ACTIVATED), "Driver %d/%s already activated", i, dev->name); /* This should activate it */ ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev)); ut_assert(dev); - ut_assert(dev->flags & DM_FLAG_ACTIVATED); + ut_assert(dev_get_flags(dev) & DM_FLAG_ACTIVATED); /* Activating a device should activate the root device */ if (!i) - ut_assert(dms->root->flags & DM_FLAG_ACTIVATED); + ut_assert(dev_get_flags(dms->root) & DM_FLAG_ACTIVATED); } /* @@ -255,7 +255,7 @@ static int dm_test_autoprobe(struct unit_test_state *uts) ut_assert(priv); ut_asserteq(expected_base_add, priv->base_add); - pdata = dev->platdata; + pdata = dev_get_plat(dev); expected_base_add += pdata->ping_add; } @@ -263,8 +263,8 @@ static int dm_test_autoprobe(struct unit_test_state *uts) } DM_TEST(dm_test_autoprobe, UT_TESTF_SCAN_PDATA); -/* Check that we see the correct platdata in each device */ -static int dm_test_platdata(struct unit_test_state *uts) +/* Check that we see the correct plat in each device */ +static int dm_test_plat(struct unit_test_state *uts) { const struct dm_test_pdata *pdata; struct udevice *dev; @@ -273,13 +273,13 @@ static int dm_test_platdata(struct unit_test_state *uts) for (i = 0; i < 3; i++) { ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); ut_assert(dev); - pdata = dev->platdata; + pdata = dev_get_plat(dev); ut_assert(pdata->ping_add == test_pdata[i].ping_add); } return 0; } -DM_TEST(dm_test_platdata, UT_TESTF_SCAN_PDATA); +DM_TEST(dm_test_plat, UT_TESTF_SCAN_PDATA); /* Test that we can bind, probe, remove, unbind a driver */ static int dm_test_lifecycle(struct unit_test_state *uts) @@ -297,7 +297,7 @@ static int dm_test_lifecycle(struct unit_test_state *uts) ut_assert(dev); ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND] == op_count[DM_TEST_OP_BIND] + 1); - ut_assert(!dev->priv); + ut_assert(!dev_get_priv(dev)); /* Probe the device - it should fail allocating private data */ dms->force_fail_alloc = 1; @@ -305,14 +305,14 @@ static int dm_test_lifecycle(struct unit_test_state *uts) ut_assert(ret == -ENOMEM); ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE] == op_count[DM_TEST_OP_PROBE] + 1); - ut_assert(!dev->priv); + ut_assert(!dev_get_priv(dev)); /* Try again without the alloc failure */ dms->force_fail_alloc = 0; ut_assertok(device_probe(dev)); ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE] == op_count[DM_TEST_OP_PROBE] + 2); - ut_assert(dev->priv); + ut_assert(dev_get_priv(dev)); /* This should be device 3 in the uclass */ ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev)); @@ -400,10 +400,10 @@ int dm_check_operations(struct unit_test_state *uts, struct udevice *dev, int expected; int pingret; - /* Getting the child device should allocate platdata / priv */ + /* Getting the child device should allocate plat / priv */ ut_assertok(testfdt_ping(dev, 10, &pingret)); - ut_assert(dev->priv); - ut_assert(dev->platdata); + ut_assert(dev_get_priv(dev)); + ut_assert(dev_get_plat(dev)); expected = 10 + base; ut_asserteq(expected, pingret); @@ -414,7 +414,7 @@ int dm_check_operations(struct unit_test_state *uts, struct udevice *dev, ut_asserteq(expected, pingret); /* Now check the ping_total */ - priv = dev->priv; + priv = dev_get_priv(dev); ut_asserteq(DM_TEST_START_TOTAL + 10 + 20 + base * 2, priv->ping_total); @@ -438,13 +438,13 @@ static int dm_test_operations(struct unit_test_state *uts) /* * Get the 'reg' property, which tells us what the ping add - * should be. We don't use the platdata because we want + * should be. We don't use the plat because we want * to test the code that sets that up (testfdt_drv_probe()). */ base = test_pdata[i].ping_add; debug("dev=%d, base=%d\n", i, base); - ut_assert(!dm_check_operations(uts, dev, base, dev->priv)); + ut_assert(!dm_check_operations(uts, dev, base, dev_get_priv(dev))); } return 0; @@ -460,13 +460,13 @@ static int dm_test_remove(struct unit_test_state *uts) for (i = 0; i < 3; i++) { ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); ut_assert(dev); - ut_assertf(dev->flags & DM_FLAG_ACTIVATED, + ut_assertf(dev_get_flags(dev) & DM_FLAG_ACTIVATED, "Driver %d/%s not activated", i, dev->name); ut_assertok(device_remove(dev, DM_REMOVE_NORMAL)); - ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED), + ut_assertf(!(dev_get_flags(dev) & DM_FLAG_ACTIVATED), "Driver %d/%s should have deactivated", i, dev->name); - ut_assert(!dev->priv); + ut_assert(!dev_get_priv(dev)); } return 0; @@ -485,8 +485,8 @@ static int dm_test_leak(struct unit_test_state *uts) dm_leak_check_start(uts); - ut_assertok(dm_scan_platdata(false)); - ut_assertok(dm_scan_fdt(gd->fdt_blob, false)); + ut_assertok(dm_scan_plat(false)); + ut_assertok(dm_scan_fdt(false)); /* Scanning the uclass is enough to probe all the devices */ for (id = UCLASS_ROOT; id < UCLASS_COUNT; id++) { @@ -512,7 +512,7 @@ static int dm_test_uclass(struct unit_test_state *uts) ut_assertok(uclass_get(UCLASS_TEST, &uc)); ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]); ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_DESTROY]); - ut_assert(uc->priv); + ut_assert(uclass_get_priv(uc)); ut_assertok(uclass_destroy(uc)); ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]); @@ -547,7 +547,7 @@ static int create_children(struct unit_test_state *uts, struct udevice *parent, &driver_info_manual, &dev)); pdata = calloc(1, sizeof(*pdata)); pdata->ping_add = key + i; - dev->platdata = pdata; + dev_set_plat(dev, pdata); if (child) child[i] = dev; } @@ -1052,8 +1052,8 @@ static int dm_test_inactive_child(struct unit_test_state *uts) */ ut_asserteq(-ENODEV, device_find_first_inactive_child(parent, UCLASS_TEST, &dev1)); - ut_assertok(device_bind_ofnode(parent, DM_GET_DRIVER(test_drv), - "test_child", 0, ofnode_null(), &dev1)); + ut_assertok(device_bind(parent, DM_DRIVER_GET(test_drv), + "test_child", 0, ofnode_null(), &dev1)); ut_assertok(device_find_first_inactive_child(parent, UCLASS_TEST, &dev2)); @@ -1066,3 +1066,22 @@ static int dm_test_inactive_child(struct unit_test_state *uts) return 0; } DM_TEST(dm_test_inactive_child, UT_TESTF_SCAN_PDATA); + +/* Make sure all bound devices have a sequence number */ +static int dm_test_all_have_seq(struct unit_test_state *uts) +{ + struct udevice *dev; + struct uclass *uc; + + list_for_each_entry(uc, gd->uclass_root, sibling_node) { + list_for_each_entry(dev, &uc->dev_head, uclass_node) { + if (dev->seq_ == -1) + printf("Device '%s' has no seq (%d)\n", + dev->name, dev->seq_); + ut_assert(dev->seq_ != -1); + } + } + + return 0; +} +DM_TEST(dm_test_all_have_seq, UT_TESTF_SCAN_PDATA); |