eaw/u-boot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

dm: treewide: Rename 'platdata' variables to just 'plat'

Browse Source 
We use 'priv' for private data but often use 'platdata' for platform data.
We can't really use 'pdata' since that is ambiguous (it could mean private
or platform data).

Rename some of the latter variables to end with 'plat' for consistency.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass
2020-12-03 16:55:18 -07:00
parent 41575d8e4c
commit caa4daa2ae
575 changed files with 1633 additions and 1644 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test/dm/acpi.c
View File

@@ -110,7 +110,7 @@ U_BOOT_DRIVER(testacpi_drv) = {
.of_match = testacpi_ids,
.id = UCLASS_TEST_ACPI,
.bind = dm_scan_fdt_dev,
.platdata_auto = sizeof(struct testacpi_platdata),
.plat_auto = sizeof(struct testacpi_platdata),
ACPI_OPS_PTR(&testacpi_ops)
};

2
test/dm/adc.c
View File

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

2
test/dm/blk.c
View File

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

56
test/dm/bus.c
View File

@@ -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;
@@ -101,10 +101,10 @@ U_BOOT_DRIVER(testbus_drv) = {
.probe = testbus_drv_probe,
.child_post_bind = testbus_child_post_bind,
.priv_auto = sizeof(struct dm_test_priv),
.platdata_auto = sizeof(struct dm_test_pdata),
.plat_auto = sizeof(struct dm_test_pdata),
.per_child_auto = sizeof(struct dm_test_parent_data),
.per_child_platdata_auto =
sizeof(struct dm_test_parent_platdata),
.per_child_plat_auto =
sizeof(struct dm_test_parent_plat),
.child_pre_probe = testbus_child_pre_probe,
.child_post_remove = testbus_child_post_remove,
};
@@ -370,9 +370,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 +386,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 +398,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 +410,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 +423,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 +439,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 +456,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;
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 = size;
drv->per_child_platdata_auto = 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 = 0;
drv->per_child_platdata_auto = 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 +485,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 +498,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 +506,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);
}

38
test/dm/core.c
View File

@@ -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;
@@ -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);
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,7 +263,7 @@ 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 */
/* Check that we see the correct plat in each device */
static int dm_test_platdata(struct unit_test_state *uts)
{
const struct dm_test_pdata *pdata;
@@ -273,7 +273,7 @@ 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);
}
@@ -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;
@@ -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;
}

2
test/dm/devres.c
View File

@@ -158,7 +158,7 @@ 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 */
/* Getting plat should add one allocation */
ut_assertok(device_ofdata_to_platdata(dev));
devres_get_stats(dev, &stats);
ut_asserteq(2, stats.allocs);

2
test/dm/gpio.c
View File

@@ -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.
*/

2
test/dm/ofread.c
View File

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

18
test/dm/regulator.c
View File

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

14
test/dm/test-fdt.c
View File

@@ -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;
@@ -87,7 +87,7 @@ U_BOOT_DRIVER(testfdt_drv) = {
.probe = testfdt_drv_probe,
.ops = &test_ops,
.priv_auto = sizeof(struct dm_test_priv),
.platdata_auto = sizeof(struct dm_test_pdata),
.plat_auto = sizeof(struct dm_test_pdata),
};
static const struct udevice_id testfdt1_ids[] = {
@@ -105,7 +105,7 @@ U_BOOT_DRIVER(testfdt1_drv) = {
.probe = testfdt_drv_probe,
.ops = &test_ops,
.priv_auto = sizeof(struct dm_test_priv),
.platdata_auto = sizeof(struct dm_test_pdata),
.plat_auto = sizeof(struct dm_test_pdata),
.flags = DM_FLAG_PRE_RELOC,
};
@@ -147,7 +147,7 @@ U_BOOT_DRIVER(testprobe_drv) = {
.of_match = testprobe_ids,
.id = UCLASS_TEST_PROBE,
.probe = testprobe_drv_probe,
.platdata_auto = sizeof(struct dm_testprobe_pdata),
.plat_auto = sizeof(struct dm_testprobe_pdata),
};
UCLASS_DRIVER(testprobe) = {
@@ -204,7 +204,7 @@ U_BOOT_DRIVER(testdevres_drv) = {
.bind = testdevres_drv_bind,
.ofdata_to_platdata = testdevres_drv_ofdata_to_platdata,
.probe = testdevres_drv_probe,
.platdata_auto = sizeof(struct dm_testdevres_pdata),
.plat_auto = sizeof(struct dm_testdevres_pdata),
.priv_auto = sizeof(struct dm_testdevres_priv),
};
@@ -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()).
*/
@@ -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));

6
test/dm/test-uclass.c
View File

@@ -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);
@@ -126,6 +126,6 @@ UCLASS_DRIVER(test) = {
.destroy = test_destroy,
.priv_auto = sizeof(struct dm_test_uclass_priv),
.per_device_auto = sizeof(struct dm_test_uclass_perdev_priv),
.per_device_platdata_auto =
.per_device_plat_auto =
sizeof(struct dm_test_perdev_uc_pdata),
};