aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/dm/acpi.c14
-rw-r--r--test/dm/adc.c2
-rw-r--r--test/dm/blk.c2
-rw-r--r--test/dm/bus.c69
-rw-r--r--test/dm/core.c52
-rw-r--r--test/dm/devres.c4
-rw-r--r--test/dm/gpio.c2
-rw-r--r--test/dm/mux-emul.c2
-rw-r--r--test/dm/of_platdata.c30
-rw-r--r--test/dm/ofnode.c12
-rw-r--r--test/dm/ofread.c2
-rw-r--r--test/dm/regmap.c2
-rw-r--r--test/dm/regulator.c18
-rw-r--r--test/dm/test-driver.c6
-rw-r--r--test/dm/test-fdt.c56
-rw-r--r--test/dm/test-main.c8
-rw-r--r--test/dm/test-uclass.c11
-rw-r--r--test/dm/video.c8
-rw-r--r--test/py/tests/test_sandbox_exit.py24
19 files changed, 179 insertions, 145 deletions
diff --git a/test/dm/acpi.c b/test/dm/acpi.c
index f5eddac10d..c5c3726382 100644
--- a/test/dm/acpi.c
+++ b/test/dm/acpi.c
@@ -25,12 +25,12 @@
#define BUF_SIZE 4096
/**
- * struct testacpi_platdata - Platform data for the test ACPI device
+ * struct testacpi_plat - Platform data for the test ACPI device
*
* @no_name: true to emit an empty ACPI name from testacpi_get_name()
* @return_error: true to return an error instead of a name
*/
-struct testacpi_platdata {
+struct testacpi_plat {
bool return_error;
bool no_name;
};
@@ -53,7 +53,7 @@ static int testacpi_write_tables(const struct udevice *dev,
static int testacpi_get_name(const struct udevice *dev, char *out_name)
{
- struct testacpi_platdata *plat = dev_get_platdata(dev);
+ struct testacpi_plat *plat = dev_get_plat(dev);
if (plat->return_error)
return -EINVAL;
@@ -110,7 +110,7 @@ U_BOOT_DRIVER(testacpi_drv) = {
.of_match = testacpi_ids,
.id = UCLASS_TEST_ACPI,
.bind = dm_scan_fdt_dev,
- .platdata_auto_alloc_size = sizeof(struct testacpi_platdata),
+ .plat_auto = sizeof(struct testacpi_plat),
ACPI_OPS_PTR(&testacpi_ops)
};
@@ -422,7 +422,7 @@ DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_device_path() */
static int dm_test_acpi_device_path(struct unit_test_state *uts)
{
- struct testacpi_platdata *plat;
+ struct testacpi_plat *plat;
char buf[ACPI_PATH_MAX];
struct udevice *dev, *child;
@@ -442,13 +442,13 @@ static int dm_test_acpi_device_path(struct unit_test_state *uts)
buf);
/* Test handling of a device which doesn't produce a name */
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
plat->no_name = true;
ut_assertok(acpi_device_path(child, buf, sizeof(buf)));
ut_asserteq_str("\\_SB." ACPI_TEST_CHILD_NAME, buf);
/* Test handling of a device which returns an error */
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
plat->return_error = true;
ut_asserteq(-EINVAL, acpi_device_path(child, buf, sizeof(buf)));
diff --git a/test/dm/adc.c b/test/dm/adc.c
index 8c6e4b0604..740167e16b 100644
--- a/test/dm/adc.c
+++ b/test/dm/adc.c
@@ -67,7 +67,7 @@ static int dm_test_adc_supply(struct unit_test_state *uts)
ut_assertok(regulator_set_value(supply, SANDBOX_BUCK2_SET_UV));
ut_asserteq(SANDBOX_BUCK2_SET_UV, regulator_get_value(supply));
- /* Update ADC platdata and get new Vdd value */
+ /* Update ADC plat and get new Vdd value */
ut_assertok(adc_vdd_value(dev, &uV));
ut_asserteq(SANDBOX_BUCK2_SET_UV, uV);
diff --git a/test/dm/blk.c b/test/dm/blk.c
index f34c13f751..23940b3e03 100644
--- a/test/dm/blk.c
+++ b/test/dm/blk.c
@@ -139,7 +139,7 @@ static int dm_test_blk_devnum(struct unit_test_state *uts)
* Check that the block device devnum matches its parent's
* sequence number
*/
- desc = dev_get_uclass_platdata(dev);
+ desc = dev_get_uclass_plat(dev);
ut_asserteq(desc->devnum, i);
}
diff --git a/test/dm/bus.c b/test/dm/bus.c
index 27b7266645..9e81b1da1f 100644
--- a/test/dm/bus.c
+++ b/test/dm/bus.c
@@ -19,7 +19,7 @@
DECLARE_GLOBAL_DATA_PTR;
-struct dm_test_parent_platdata {
+struct dm_test_parent_plat {
int count;
int bind_flag;
int uclass_bind_flag;
@@ -39,9 +39,9 @@ static int testbus_drv_probe(struct udevice *dev)
static int testbus_child_post_bind(struct udevice *dev)
{
- struct dm_test_parent_platdata *plat;
+ struct dm_test_parent_plat *plat;
- plat = dev_get_parent_platdata(dev);
+ plat = dev_get_parent_plat(dev);
plat->bind_flag = 1;
plat->uclass_bind_flag = 2;
@@ -100,11 +100,10 @@ U_BOOT_DRIVER(testbus_drv) = {
.id = UCLASS_TEST_BUS,
.probe = testbus_drv_probe,
.child_post_bind = testbus_child_post_bind,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
- .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
- .per_child_auto_alloc_size = sizeof(struct dm_test_parent_data),
- .per_child_platdata_auto_alloc_size =
- sizeof(struct dm_test_parent_platdata),
+ .priv_auto = sizeof(struct dm_test_priv),
+ .plat_auto = sizeof(struct dm_test_pdata),
+ .per_child_auto = sizeof(struct dm_test_parent_data),
+ .per_child_plat_auto = sizeof(struct dm_test_parent_plat),
.child_pre_probe = testbus_child_pre_probe,
.child_post_remove = testbus_child_post_remove,
};
@@ -312,19 +311,19 @@ static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
/* Set the driver size to 0 so that the uclass size is used */
ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
drv = (struct driver *)bus->driver;
- size = drv->per_child_auto_alloc_size;
+ size = drv->per_child_auto;
#ifdef CONFIG_SANDBOX
os_mprotect_allow(bus->uclass->uc_drv, sizeof(*bus->uclass->uc_drv));
os_mprotect_allow(drv, sizeof(*drv));
#endif
- bus->uclass->uc_drv->per_child_auto_alloc_size = size;
- drv->per_child_auto_alloc_size = 0;
+ bus->uclass->uc_drv->per_child_auto = size;
+ drv->per_child_auto = 0;
ret = test_bus_parent_data(uts);
if (ret)
return ret;
- bus->uclass->uc_drv->per_child_auto_alloc_size = 0;
- drv->per_child_auto_alloc_size = size;
+ bus->uclass->uc_drv->per_child_auto = 0;
+ drv->per_child_auto = size;
return 0;
}
@@ -370,9 +369,9 @@ static int dm_test_bus_parent_ops(struct unit_test_state *uts)
}
DM_TEST(dm_test_bus_parent_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
-static int test_bus_parent_platdata(struct unit_test_state *uts)
+static int test_bus_parent_plat(struct unit_test_state *uts)
{
- struct dm_test_parent_platdata *plat;
+ struct dm_test_parent_plat *plat;
struct udevice *bus, *dev;
/* Check that the bus has no children */
@@ -386,7 +385,7 @@ static int test_bus_parent_platdata(struct unit_test_state *uts)
dev;
device_find_next_child(&dev)) {
/* Check that platform data is allocated */
- plat = dev_get_parent_platdata(dev);
+ plat = dev_get_parent_plat(dev);
ut_assert(plat != NULL);
/*
@@ -398,7 +397,7 @@ static int test_bus_parent_platdata(struct unit_test_state *uts)
device_probe(dev);
device_remove(dev, DM_REMOVE_NORMAL);
- ut_asserteq_ptr(plat, dev_get_parent_platdata(dev));
+ ut_asserteq_ptr(plat, dev_get_parent_plat(dev));
ut_asserteq(1, plat->count);
ut_assertok(device_probe(dev));
}
@@ -410,7 +409,7 @@ static int test_bus_parent_platdata(struct unit_test_state *uts)
dev;
device_find_next_child(&dev)) {
/* Check that platform data is allocated */
- plat = dev_get_parent_platdata(dev);
+ plat = dev_get_parent_plat(dev);
ut_assert(plat != NULL);
ut_asserteq(1, plat->count);
}
@@ -423,13 +422,13 @@ static int test_bus_parent_platdata(struct unit_test_state *uts)
device_unbind(dev);
} while (dev);
- /* Now the child platdata should be removed and re-added */
+ /* Now the child plat should be removed and re-added */
device_probe(bus);
for (device_find_first_child(bus, &dev);
dev;
device_find_next_child(&dev)) {
/* Check that platform data is allocated */
- plat = dev_get_parent_platdata(dev);
+ plat = dev_get_parent_plat(dev);
ut_assert(plat != NULL);
ut_asserteq(0, plat->count);
}
@@ -439,14 +438,14 @@ static int test_bus_parent_platdata(struct unit_test_state *uts)
}
/* Test that the bus can store platform data about each child */
-static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
+static int dm_test_bus_parent_plat(struct unit_test_state *uts)
{
- return test_bus_parent_platdata(uts);
+ return test_bus_parent_plat(uts);
}
-DM_TEST(dm_test_bus_parent_platdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
+DM_TEST(dm_test_bus_parent_plat, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* As above but the size is controlled by the uclass */
-static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
+static int dm_test_bus_parent_plat_uclass(struct unit_test_state *uts)
{
struct udevice *bus;
struct driver *drv;
@@ -456,28 +455,28 @@ static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
/* Set the driver size to 0 so that the uclass size is used */
ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
drv = (struct driver *)bus->driver;
- size = drv->per_child_platdata_auto_alloc_size;
+ size = drv->per_child_plat_auto;
#ifdef CONFIG_SANDBOX
os_mprotect_allow(bus->uclass->uc_drv, sizeof(*bus->uclass->uc_drv));
os_mprotect_allow(drv, sizeof(*drv));
#endif
- bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
- drv->per_child_platdata_auto_alloc_size = 0;
- ret = test_bus_parent_platdata(uts);
+ bus->uclass->uc_drv->per_child_plat_auto = size;
+ drv->per_child_plat_auto = 0;
+ ret = test_bus_parent_plat(uts);
if (ret)
return ret;
- bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
- drv->per_child_platdata_auto_alloc_size = size;
+ bus->uclass->uc_drv->per_child_plat_auto = 0;
+ drv->per_child_plat_auto = size;
return 0;
}
-DM_TEST(dm_test_bus_parent_platdata_uclass,
+DM_TEST(dm_test_bus_parent_plat_uclass,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that the child post_bind method is called */
static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
{
- struct dm_test_parent_platdata *plat;
+ struct dm_test_parent_plat *plat;
struct udevice *bus, *dev;
ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
@@ -485,7 +484,7 @@ static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
dev;
device_find_next_child(&dev)) {
/* Check that platform data is allocated */
- plat = dev_get_parent_platdata(dev);
+ plat = dev_get_parent_plat(dev);
ut_assert(plat != NULL);
ut_asserteq(1, plat->bind_flag);
}
@@ -498,7 +497,7 @@ DM_TEST(dm_test_bus_child_post_bind, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that the child post_bind method is called */
static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
{
- struct dm_test_parent_platdata *plat;
+ struct dm_test_parent_plat *plat;
struct udevice *bus, *dev;
ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
@@ -506,7 +505,7 @@ static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
dev;
device_find_next_child(&dev)) {
/* Check that platform data is allocated */
- plat = dev_get_parent_platdata(dev);
+ plat = dev_get_parent_plat(dev);
ut_assert(plat != NULL);
ut_asserteq(2, plat->uclass_bind_flag);
}
diff --git a/test/dm/core.c b/test/dm/core.c
index 6f380a574c..0e0696af98 100644
--- a/test/dm/core.c
+++ b/test/dm/core.c
@@ -45,27 +45,27 @@ static const struct dm_test_pdata test_pdata_pre_reloc = {
U_BOOT_DEVICE(dm_test_info1) = {
.name = "test_drv",
- .platdata = &test_pdata[0],
+ .plat = &test_pdata[0],
};
U_BOOT_DEVICE(dm_test_info2) = {
.name = "test_drv",
- .platdata = &test_pdata[1],
+ .plat = &test_pdata[1],
};
U_BOOT_DEVICE(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;
@@ -120,7 +120,7 @@ static int dm_test_autobind(struct unit_test_state *uts)
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));
@@ -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);
@@ -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->plat;
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->plat;
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)
@@ -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->plat);
expected = 10 + base;
ut_asserteq(expected, pingret);
@@ -438,7 +438,7 @@ 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;
@@ -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++) {
@@ -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->plat = 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_GET_DRIVER(test_drv),
+ "test_child", 0, ofnode_null(), &dev1));
ut_assertok(device_find_first_inactive_child(parent, UCLASS_TEST,
&dev2));
diff --git a/test/dm/devres.c b/test/dm/devres.c
index e1e088a3ca..4f959d11da 100644
--- a/test/dm/devres.c
+++ b/test/dm/devres.c
@@ -158,8 +158,8 @@ static int dm_test_devres_phase(struct unit_test_state *uts)
ut_asserteq(1, stats.allocs);
ut_asserteq(TEST_DEVRES_SIZE, stats.total_size);
- /* Getting platdata should add one allocation */
- ut_assertok(device_ofdata_to_platdata(dev));
+ /* Getting plat should add one allocation */
+ ut_assertok(device_of_to_plat(dev));
devres_get_stats(dev, &stats);
ut_asserteq(2, stats.allocs);
ut_asserteq(TEST_DEVRES_SIZE + TEST_DEVRES_SIZE3, stats.total_size);
diff --git a/test/dm/gpio.c b/test/dm/gpio.c
index 54e960b185..d7b85e74ce 100644
--- a/test/dm/gpio.c
+++ b/test/dm/gpio.c
@@ -30,7 +30,7 @@ static int dm_test_gpio(struct unit_test_state *uts)
/*
* We expect to get 4 banks. One is anonymous (just numbered) and
- * comes from platdata. The other are named a (20 gpios),
+ * comes from plat. The other are named a (20 gpios),
* b (10 gpios) and c (10 gpios) and come from the device tree. See
* test/dm/test.dts.
*/
diff --git a/test/dm/mux-emul.c b/test/dm/mux-emul.c
index 141fd4d908..45154cea50 100644
--- a/test/dm/mux-emul.c
+++ b/test/dm/mux-emul.c
@@ -60,7 +60,7 @@ U_BOOT_DRIVER(emul_mux) = {
.of_match = mux_emul_of_match,
.ops = &mux_emul_ops,
.probe = mux_emul_probe,
- .priv_auto_alloc_size = sizeof(struct mux_emul_priv),
+ .priv_auto = sizeof(struct mux_emul_priv),
};
static int dm_test_mux_emul_default_state(struct unit_test_state *uts)
diff --git a/test/dm/of_platdata.c b/test/dm/of_platdata.c
index 4f3cc159d0..cfc43a5b03 100644
--- a/test/dm/of_platdata.c
+++ b/test/dm/of_platdata.c
@@ -8,7 +8,7 @@
#include <test/ut.h>
/* Test that we can find a device using of-platdata */
-static int dm_test_of_platdata_base(struct unit_test_state *uts)
+static int dm_test_of_plat_base(struct unit_test_state *uts)
{
struct udevice *dev;
@@ -17,10 +17,10 @@ static int dm_test_of_platdata_base(struct unit_test_state *uts)
return 0;
}
-DM_TEST(dm_test_of_platdata_base, UT_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_of_plat_base, UT_TESTF_SCAN_PDATA);
/* Test that we can read properties from a device */
-static int dm_test_of_platdata_props(struct unit_test_state *uts)
+static int dm_test_of_plat_props(struct unit_test_state *uts)
{
struct dtd_sandbox_spl_test *plat;
struct udevice *dev;
@@ -31,7 +31,7 @@ static int dm_test_of_platdata_props(struct unit_test_state *uts)
ut_asserteq_str("sandbox_clk_test", dev->name);
ut_assertok(uclass_next_device_err(&dev));
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
ut_assert(plat->boolval);
ut_asserteq(1, plat->intval);
ut_asserteq(4, ARRAY_SIZE(plat->intarray));
@@ -54,7 +54,7 @@ static int dm_test_of_platdata_props(struct unit_test_state *uts)
ut_asserteq_str("", plat->stringarray[2]);
ut_assertok(uclass_next_device_err(&dev));
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
ut_assert(!plat->boolval);
ut_asserteq(3, plat->intval);
ut_asserteq(5, plat->intarray[0]);
@@ -74,14 +74,14 @@ static int dm_test_of_platdata_props(struct unit_test_state *uts)
ut_asserteq_str("message", plat->stringarray[2]);
ut_assertok(uclass_next_device_err(&dev));
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
ut_assert(!plat->boolval);
ut_asserteq_str("one", plat->stringarray[0]);
ut_asserteq_str("", plat->stringarray[1]);
ut_asserteq_str("", plat->stringarray[2]);
ut_assertok(uclass_next_device_err(&dev));
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
ut_assert(!plat->boolval);
ut_asserteq_str("spl", plat->stringarray[0]);
@@ -89,7 +89,7 @@ static int dm_test_of_platdata_props(struct unit_test_state *uts)
return 0;
}
-DM_TEST(dm_test_of_platdata_props, UT_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_of_plat_props, UT_TESTF_SCAN_PDATA);
/*
* find_driver_info - recursively find the driver_info for a device
@@ -139,7 +139,7 @@ static int find_driver_info(struct unit_test_state *uts, struct udevice *parent,
}
/* Check that every device is recorded in its driver_info struct */
-static int dm_test_of_platdata_dev(struct unit_test_state *uts)
+static int dm_test_of_plat_dev(struct unit_test_state *uts)
{
const struct driver_info *info =
ll_entry_start(struct driver_info, driver_info);
@@ -171,17 +171,17 @@ static int dm_test_of_platdata_dev(struct unit_test_state *uts)
return 0;
}
-DM_TEST(dm_test_of_platdata_dev, UT_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_of_plat_dev, UT_TESTF_SCAN_PDATA);
/* Test handling of phandles that point to other devices */
-static int dm_test_of_platdata_phandle(struct unit_test_state *uts)
+static int dm_test_of_plat_phandle(struct unit_test_state *uts)
{
struct dtd_sandbox_clk_test *plat;
struct udevice *dev, *clk;
ut_assertok(uclass_first_device_err(UCLASS_MISC, &dev));
ut_asserteq_str("sandbox_clk_test", dev->name);
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
ut_assertok(device_get_by_driver_info_idx(plat->clocks[0].idx, &clk));
ut_asserteq_str("fixed_clock", clk->name);
@@ -204,11 +204,11 @@ static int dm_test_of_platdata_phandle(struct unit_test_state *uts)
return 0;
}
-DM_TEST(dm_test_of_platdata_phandle, UT_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_of_plat_phandle, UT_TESTF_SCAN_PDATA);
#if CONFIG_IS_ENABLED(OF_PLATDATA_PARENT)
/* Test that device parents are correctly set up */
-static int dm_test_of_platdata_parent(struct unit_test_state *uts)
+static int dm_test_of_plat_parent(struct unit_test_state *uts)
{
struct udevice *rtc, *i2c;
@@ -218,5 +218,5 @@ static int dm_test_of_platdata_parent(struct unit_test_state *uts)
return 0;
}
-DM_TEST(dm_test_of_platdata_parent, UT_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_of_plat_parent, UT_TESTF_SCAN_PDATA);
#endif
diff --git a/test/dm/ofnode.c b/test/dm/ofnode.c
index fb1ceb1318..c539134296 100644
--- a/test/dm/ofnode.c
+++ b/test/dm/ofnode.c
@@ -249,3 +249,15 @@ static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
}
DM_TEST(dm_test_ofnode_get_child_count,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
+
+static int dm_test_ofnode_is_enabled(struct unit_test_state *uts)
+{
+ ofnode root_node = ofnode_path("/");
+ ofnode node = ofnode_path("/usb@0");
+
+ ut_assert(ofnode_is_enabled(root_node));
+ ut_assert(!ofnode_is_enabled(node));
+
+ return 0;
+}
+DM_TEST(dm_test_ofnode_is_enabled, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/ofread.c b/test/dm/ofread.c
index 9064426e21..8c7dd82513 100644
--- a/test/dm/ofread.c
+++ b/test/dm/ofread.c
@@ -33,7 +33,7 @@ static int dm_test_ofnode_get_property_by_prop(struct unit_test_state *uts)
ut_asserteq(4, len);
break;
case 3:
- /* only for platdata */
+ /* only for plat */
ut_asserteq_str("name", propname);
ut_asserteq(6, len);
ut_asserteq_str("flash", value);
diff --git a/test/dm/regmap.c b/test/dm/regmap.c
index 2effef3c1c..22a293096c 100644
--- a/test/dm/regmap.c
+++ b/test/dm/regmap.c
@@ -280,7 +280,7 @@ U_BOOT_DRIVER(regmap_test) = {
.of_match = regmaptest_ids,
.id = UCLASS_NOP,
.probe = remaptest_probe,
- .priv_auto_alloc_size = sizeof(struct regmaptest_priv),
+ .priv_auto = sizeof(struct regmaptest_priv),
};
static int dm_test_devm_regmap(struct unit_test_state *uts)
diff --git a/test/dm/regulator.c b/test/dm/regulator.c
index 0e7a232a70..86f4862d9d 100644
--- a/test/dm/regulator.c
+++ b/test/dm/regulator.c
@@ -50,7 +50,7 @@ static const char *regulator_names[OUTPUT_COUNT][OUTPUT_NAME_COUNT] = {
/* Test regulator get method */
static int dm_test_power_regulator_get(struct unit_test_state *uts)
{
- struct dm_regulator_uclass_platdata *uc_pdata;
+ struct dm_regulator_uclass_plat *uc_pdata;
struct udevice *dev_by_devname;
struct udevice *dev_by_platname;
const char *devname;
@@ -77,7 +77,7 @@ static int dm_test_power_regulator_get(struct unit_test_state *uts)
* a device with the name equal to the requested one.
*/
ut_assertok(regulator_get_by_platname(platname, &dev_by_platname));
- uc_pdata = dev_get_uclass_platdata(dev_by_platname);
+ uc_pdata = dev_get_uclass_plat(dev_by_platname);
ut_assert(uc_pdata);
ut_asserteq_str(platname, uc_pdata->name);
@@ -95,7 +95,7 @@ DM_TEST(dm_test_power_regulator_get, UT_TESTF_SCAN_FDT);
/* Test regulator set and get Voltage method */
static int dm_test_power_regulator_set_get_voltage(struct unit_test_state *uts)
{
- struct dm_regulator_uclass_platdata *uc_pdata;
+ struct dm_regulator_uclass_plat *uc_pdata;
struct udevice *dev;
const char *platname;
int val_set, val_get;
@@ -104,7 +104,7 @@ static int dm_test_power_regulator_set_get_voltage(struct unit_test_state *uts)
platname = regulator_names[BUCK1][PLATNAME];
ut_assertok(regulator_get_by_platname(platname, &dev));
- uc_pdata = dev_get_uclass_platdata(dev);
+ uc_pdata = dev_get_uclass_plat(dev);
ut_assert(uc_pdata);
val_set = uc_pdata->min_uV;
@@ -122,7 +122,7 @@ DM_TEST(dm_test_power_regulator_set_get_voltage, UT_TESTF_SCAN_FDT);
/* Test regulator set and get Current method */
static int dm_test_power_regulator_set_get_current(struct unit_test_state *uts)
{
- struct dm_regulator_uclass_platdata *uc_pdata;
+ struct dm_regulator_uclass_plat *uc_pdata;
struct udevice *dev;
const char *platname;
int val_set, val_get;
@@ -131,7 +131,7 @@ static int dm_test_power_regulator_set_get_current(struct unit_test_state *uts)
platname = regulator_names[LDO1][PLATNAME];
ut_assertok(regulator_get_by_platname(platname, &dev));
- uc_pdata = dev_get_uclass_platdata(dev);
+ uc_pdata = dev_get_uclass_plat(dev);
ut_assert(uc_pdata);
val_set = uc_pdata->min_uA;
@@ -146,7 +146,7 @@ static int dm_test_power_regulator_set_get_current(struct unit_test_state *uts)
platname = regulator_names[LDO2][PLATNAME];
ut_assertok(regulator_get_by_platname(platname, &dev));
- uc_pdata = dev_get_uclass_platdata(dev);
+ uc_pdata = dev_get_uclass_plat(dev);
ut_assert(uc_pdata);
ut_asserteq(-ENODATA, uc_pdata->min_uA);
ut_asserteq(-ENODATA, uc_pdata->max_uA);
@@ -220,7 +220,7 @@ DM_TEST(dm_test_power_regulator_set_get_mode, UT_TESTF_SCAN_FDT);
/* Test regulator set and get suspend Voltage method */
static int dm_test_power_regulator_set_get_suspend_voltage(struct unit_test_state *uts)
{
- struct dm_regulator_uclass_platdata *uc_pdata;
+ struct dm_regulator_uclass_plat *uc_pdata;
const struct dm_regulator_ops *ops;
struct udevice *dev;
const char *platname;
@@ -230,7 +230,7 @@ static int dm_test_power_regulator_set_get_suspend_voltage(struct unit_test_stat
platname = regulator_names[BUCK1][PLATNAME];
ut_assertok(regulator_get_by_platname(platname, &dev));
- uc_pdata = dev_get_uclass_platdata(dev);
+ uc_pdata = dev_get_uclass_plat(dev);
ut_assert(uc_pdata);
ops = dev_get_driver_ops(dev);
diff --git a/test/dm/test-driver.c b/test/dm/test-driver.c
index 08bdf01194..b9f49de10a 100644
--- a/test/dm/test-driver.c
+++ b/test/dm/test-driver.c
@@ -21,7 +21,7 @@ static struct unit_test_state *uts = &global_dm_test_state;
static int testdrv_ping(struct udevice *dev, int pingval, int *pingret)
{
- const struct dm_test_pdata *pdata = dev_get_platdata(dev);
+ const struct dm_test_pdata *pdata = dev_get_plat(dev);
struct dm_test_priv *priv = dev_get_priv(dev);
*pingret = pingval + pdata->ping_add;
@@ -81,7 +81,7 @@ U_BOOT_DRIVER(test_drv) = {
.probe = test_probe,
.remove = test_remove,
.unbind = test_unbind,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
+ .priv_auto = sizeof(struct dm_test_priv),
};
U_BOOT_DRIVER(test2_drv) = {
@@ -92,7 +92,7 @@ U_BOOT_DRIVER(test2_drv) = {
.probe = test_probe,
.remove = test_remove,
.unbind = test_unbind,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
+ .priv_auto = sizeof(struct dm_test_priv),
};
static int test_manual_drv_ping(struct udevice *dev, int pingval, int *pingret)
diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c
index cc12419ea0..fda2ba6493 100644
--- a/test/dm/test-fdt.c
+++ b/test/dm/test-fdt.c
@@ -25,7 +25,7 @@ DECLARE_GLOBAL_DATA_PTR;
static int testfdt_drv_ping(struct udevice *dev, int pingval, int *pingret)
{
- const struct dm_test_pdata *pdata = dev->platdata;
+ const struct dm_test_pdata *pdata = dev->plat;
struct dm_test_priv *priv = dev_get_priv(dev);
*pingret = pingval + pdata->ping_add;
@@ -38,9 +38,9 @@ static const struct test_ops test_ops = {
.ping = testfdt_drv_ping,
};
-static int testfdt_ofdata_to_platdata(struct udevice *dev)
+static int testfdt_of_to_plat(struct udevice *dev)
{
- struct dm_test_pdata *pdata = dev_get_platdata(dev);
+ struct dm_test_pdata *pdata = dev_get_plat(dev);
pdata->ping_add = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
"ping-add", -1);
@@ -83,11 +83,11 @@ U_BOOT_DRIVER(testfdt_drv) = {
.name = "testfdt_drv",
.of_match = testfdt_ids,
.id = UCLASS_TEST_FDT,
- .ofdata_to_platdata = testfdt_ofdata_to_platdata,
+ .of_to_plat = testfdt_of_to_plat,
.probe = testfdt_drv_probe,
.ops = &test_ops,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
- .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
+ .priv_auto = sizeof(struct dm_test_priv),
+ .plat_auto = sizeof(struct dm_test_pdata),
};
static const struct udevice_id testfdt1_ids[] = {
@@ -101,11 +101,11 @@ U_BOOT_DRIVER(testfdt1_drv) = {
.name = "testfdt1_drv",
.of_match = testfdt1_ids,
.id = UCLASS_TEST_FDT,
- .ofdata_to_platdata = testfdt_ofdata_to_platdata,
+ .of_to_plat = testfdt_of_to_plat,
.probe = testfdt_drv_probe,
.ops = &test_ops,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
- .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
+ .priv_auto = sizeof(struct dm_test_priv),
+ .plat_auto = sizeof(struct dm_test_pdata),
.flags = DM_FLAG_PRE_RELOC,
};
@@ -132,7 +132,7 @@ struct dm_testprobe_pdata {
static int testprobe_drv_probe(struct udevice *dev)
{
- struct dm_testprobe_pdata *pdata = dev_get_platdata(dev);
+ struct dm_testprobe_pdata *pdata = dev_get_plat(dev);
return pdata->probe_err;
}
@@ -147,7 +147,7 @@ U_BOOT_DRIVER(testprobe_drv) = {
.of_match = testprobe_ids,
.id = UCLASS_TEST_PROBE,
.probe = testprobe_drv_probe,
- .platdata_auto_alloc_size = sizeof(struct dm_testprobe_pdata),
+ .plat_auto = sizeof(struct dm_testprobe_pdata),
};
UCLASS_DRIVER(testprobe) = {
@@ -167,14 +167,14 @@ struct dm_testdevres_priv {
static int testdevres_drv_bind(struct udevice *dev)
{
- struct dm_testdevres_pdata *pdata = dev_get_platdata(dev);
+ struct dm_testdevres_pdata *pdata = dev_get_plat(dev);
pdata->ptr = devm_kmalloc(dev, TEST_DEVRES_SIZE, 0);
return 0;
}
-static int testdevres_drv_ofdata_to_platdata(struct udevice *dev)
+static int testdevres_drv_of_to_plat(struct udevice *dev)
{
struct dm_testdevres_priv *priv = dev_get_priv(dev);
@@ -202,10 +202,10 @@ U_BOOT_DRIVER(testdevres_drv) = {
.of_match = testdevres_ids,
.id = UCLASS_TEST_DEVRES,
.bind = testdevres_drv_bind,
- .ofdata_to_platdata = testdevres_drv_ofdata_to_platdata,
+ .of_to_plat = testdevres_drv_of_to_plat,
.probe = testdevres_drv_probe,
- .platdata_auto_alloc_size = sizeof(struct dm_testdevres_pdata),
- .priv_auto_alloc_size = sizeof(struct dm_testdevres_priv),
+ .plat_auto = sizeof(struct dm_testdevres_pdata),
+ .priv_auto = sizeof(struct dm_testdevres_priv),
};
UCLASS_DRIVER(testdevres) = {
@@ -232,7 +232,7 @@ int dm_check_devices(struct unit_test_state *uts, int num_devices)
/*
* Get the 'ping-expect' property, which tells us what the
- * ping add should be. We don't use the platdata because we
+ * ping add should be. We don't use the plat because we
* want to test the code that sets that up
* (testfdt_drv_probe()).
*/
@@ -257,7 +257,7 @@ static int dm_test_fdt(struct unit_test_state *uts)
int ret;
int i;
- ret = dm_extended_scan_fdt(gd->fdt_blob, false);
+ ret = dm_extended_scan(false);
ut_assert(!ret);
ret = uclass_get(UCLASS_TEST_FDT, &uc);
@@ -271,7 +271,7 @@ static int dm_test_fdt(struct unit_test_state *uts)
ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev);
ut_assert(!ret);
ut_assert(!dev_get_priv(dev));
- ut_assert(dev->platdata);
+ ut_assert(dev->plat);
}
ut_assertok(dm_check_devices(uts, num_devices));
@@ -308,7 +308,7 @@ static int dm_test_fdt_pre_reloc(struct unit_test_state *uts)
struct uclass *uc;
int ret;
- ret = dm_scan_fdt(gd->fdt_blob, true);
+ ret = dm_scan_fdt(true);
ut_assert(!ret);
ret = uclass_get(UCLASS_TEST_FDT, &uc);
@@ -445,7 +445,7 @@ static int dm_test_first_next_device(struct unit_test_state *uts)
/* Remove them and try again, with an error on the second one */
ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 1, &dev));
- pdata = dev_get_platdata(dev);
+ pdata = dev_get_plat(dev);
pdata->probe_err = -ENOMEM;
device_remove(parent, DM_REMOVE_NORMAL);
ut_assertok(uclass_first_device(UCLASS_TEST_PROBE, &dev));
@@ -454,7 +454,7 @@ static int dm_test_first_next_device(struct unit_test_state *uts)
/* Now an error on the first one */
ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 0, &dev));
- pdata = dev_get_platdata(dev);
+ pdata = dev_get_plat(dev);
pdata->probe_err = -ENOENT;
device_remove(parent, DM_REMOVE_NORMAL);
ut_asserteq(-ENOENT, uclass_first_device(UCLASS_TEST_PROBE, &dev));
@@ -541,21 +541,21 @@ static int dm_test_first_next_ok_device(struct unit_test_state *uts)
ut_assertok(check_devices(uts, devlist, 0));
/* Remove them and try again, with an error on the second one */
- pdata = dev_get_platdata(devlist[1]);
+ pdata = dev_get_plat(devlist[1]);
pdata->probe_err = -ENOENT - 1;
device_remove(parent, DM_REMOVE_NORMAL);
ut_assertok(check_devices(uts, devlist, 1 << 1));
/* Now an error on the first one */
- pdata = dev_get_platdata(devlist[0]);
+ pdata = dev_get_plat(devlist[0]);
pdata->probe_err = -ENOENT - 0;
device_remove(parent, DM_REMOVE_NORMAL);
ut_assertok(check_devices(uts, devlist, 3 << 0));
/* Now errors on all */
- pdata = dev_get_platdata(devlist[2]);
+ pdata = dev_get_plat(devlist[2]);
pdata->probe_err = -ENOENT - 2;
- pdata = dev_get_platdata(devlist[3]);
+ pdata = dev_get_plat(devlist[3]);
pdata->probe_err = -ENOENT - 3;
device_remove(parent, DM_REMOVE_NORMAL);
ut_assertok(check_devices(uts, devlist, 0xf << 0));
@@ -1062,7 +1062,7 @@ static int dm_test_child_ofdata(struct unit_test_state *uts)
ut_assertok(uclass_first_device_err(UCLASS_TEST_BUS, &bus));
count = 0;
- device_foreach_child_ofdata_to_platdata(dev, bus) {
+ device_foreach_child_of_to_plat(dev, bus) {
ut_assert(dev->flags & DM_FLAG_PLATDATA_VALID);
ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
count++;
@@ -1106,7 +1106,7 @@ static int dm_test_ofdata_order(struct unit_test_state *uts)
ut_assert(!(dev->flags & DM_FLAG_PLATDATA_VALID));
/* read the child's ofdata which should cause the parent's to be read */
- ut_assertok(device_ofdata_to_platdata(dev));
+ ut_assertok(device_of_to_plat(dev));
ut_assert(dev->flags & DM_FLAG_PLATDATA_VALID);
ut_assert(bus->flags & DM_FLAG_PLATDATA_VALID);
diff --git a/test/dm/test-main.c b/test/dm/test-main.c
index fd24635006..69458d62c8 100644
--- a/test/dm/test-main.c
+++ b/test/dm/test-main.c
@@ -89,12 +89,12 @@ static int dm_do_test(struct unit_test_state *uts, struct unit_test *test,
uts->start = mallinfo();
if (test->flags & UT_TESTF_SCAN_PDATA)
- ut_assertok(dm_scan_platdata(false));
+ ut_assertok(dm_scan_plat(false));
if (test->flags & UT_TESTF_PROBE_TEST)
ut_assertok(do_autoprobe(uts));
if (!CONFIG_IS_ENABLED(OF_PLATDATA) &&
(test->flags & UT_TESTF_SCAN_FDT))
- ut_assertok(dm_extended_scan_fdt(gd->fdt_blob, false));
+ ut_assertok(dm_extended_scan(false));
/*
* Silence the console and rely on console recording to get
@@ -211,9 +211,9 @@ int dm_test_main(const char *test_name)
gd_set_of_root(uts->of_root);
gd->dm_root = NULL;
ut_assertok(dm_init(CONFIG_IS_ENABLED(OF_LIVE)));
- dm_scan_platdata(false);
+ dm_scan_plat(false);
if (!CONFIG_IS_ENABLED(OF_PLATDATA))
- dm_scan_fdt(gd->fdt_blob, false);
+ dm_scan_fdt(false);
return uts->fail_count ? CMD_RET_FAILURE : 0;
}
diff --git a/test/dm/test-uclass.c b/test/dm/test-uclass.c
index 760731b066..3ab4a23649 100644
--- a/test/dm/test-uclass.c
+++ b/test/dm/test-uclass.c
@@ -36,7 +36,7 @@ static int test_post_bind(struct udevice *dev)
dm_testdrv_op_count[DM_TEST_OP_POST_BIND]++;
ut_assert(!device_active(dev));
- uc_pdata = dev_get_uclass_platdata(dev);
+ uc_pdata = dev_get_uclass_plat(dev);
ut_assert(uc_pdata);
uc_pdata->intval1 = TEST_UC_PDATA_INTVAL1;
@@ -82,7 +82,7 @@ static int test_post_probe(struct udevice *dev)
if (&prev->uclass_node != &uc->dev_head) {
struct dm_test_uclass_perdev_priv *prev_uc_priv
= dev_get_uclass_priv(prev);
- struct dm_test_pdata *pdata = prev->platdata;
+ struct dm_test_pdata *pdata = prev->plat;
ut_assert(pdata);
ut_assert(prev_uc_priv);
@@ -124,8 +124,7 @@ UCLASS_DRIVER(test) = {
.pre_remove = test_pre_remove,
.init = test_init,
.destroy = test_destroy,
- .priv_auto_alloc_size = sizeof(struct dm_test_uclass_priv),
- .per_device_auto_alloc_size = sizeof(struct dm_test_uclass_perdev_priv),
- .per_device_platdata_auto_alloc_size =
- sizeof(struct dm_test_perdev_uc_pdata),
+ .priv_auto = sizeof(struct dm_test_uclass_priv),
+ .per_device_auto = sizeof(struct dm_test_uclass_perdev_priv),
+ .per_device_plat_auto = sizeof(struct dm_test_perdev_uc_pdata),
};
diff --git a/test/dm/video.c b/test/dm/video.c
index 1af948dca3..da0ae3622f 100644
--- a/test/dm/video.c
+++ b/test/dm/video.c
@@ -107,7 +107,7 @@ static int select_vidconsole(struct unit_test_state *uts, const char *drv_name)
ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
ut_assert(!device_active(dev));
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
plat->vidconsole_drv_name = "vidconsole0";
return 0;
@@ -217,7 +217,7 @@ static int check_vidconsole_output(struct unit_test_state *uts, int rot,
ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
ut_assert(!device_active(dev));
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
plat->rot = rot;
ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
@@ -359,7 +359,7 @@ static int dm_test_video_truetype_scroll(struct unit_test_state *uts)
ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
ut_assert(!device_active(dev));
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
plat->font_size = 100;
ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
@@ -380,7 +380,7 @@ static int dm_test_video_truetype_bs(struct unit_test_state *uts)
ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
ut_assert(!device_active(dev));
- plat = dev_get_platdata(dev);
+ plat = dev_get_plat(dev);
plat->font_size = 100;
ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
diff --git a/test/py/tests/test_sandbox_exit.py b/test/py/tests/test_sandbox_exit.py
index 2d242ae0f6..706f5fa359 100644
--- a/test/py/tests/test_sandbox_exit.py
+++ b/test/py/tests/test_sandbox_exit.py
@@ -19,3 +19,27 @@ def test_ctrl_c(u_boot_console):
u_boot_console.kill(signal.SIGINT)
assert(u_boot_console.validate_exited())
+
+@pytest.mark.boardspec('sandbox')
+@pytest.mark.buildconfigspec('cmd_exception')
+@pytest.mark.buildconfigspec('sandbox_crash_reset')
+def test_exception_reset(u_boot_console):
+ """Test that SIGILL causes a reset."""
+
+ u_boot_console.run_command('exception undefined', wait_for_prompt=False)
+ m = u_boot_console.p.expect(['resetting ...', 'U-Boot'])
+ if m != 0:
+ raise Exception('SIGILL did not lead to reset')
+ m = u_boot_console.p.expect(['U-Boot', '=>'])
+ if m != 0:
+ raise Exception('SIGILL did not lead to reset')
+ u_boot_console.restart_uboot()
+
+@pytest.mark.boardspec('sandbox')
+@pytest.mark.buildconfigspec('cmd_exception')
+@pytest.mark.notbuildconfigspec('sandbox_crash_reset')
+def test_exception_exit(u_boot_console):
+ """Test that SIGILL causes a reset."""
+
+ u_boot_console.run_command('exception undefined', wait_for_prompt=False)
+ assert(u_boot_console.validate_exited())
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-13 13:27:21 +0000