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

uclass: Cleanup uclass_find_next_device

Browse Source 
uclass_find_next_device always returns 0, so instead make it a void and
update calling sites.

Signed-off-by: Andrew Goodbody <andrew.goodbody@linaro.org>
This commit is contained in:
Andrew Goodbody
2025-07-16 10:58:39 +01:00
committed by Tom Rini
parent 7bf2a52b49
commit 70bf6e33e1
8 changed files with 90 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
board/emulation/qemu-ppce500/qemu-ppce500.c
View File

@@ -170,9 +170,9 @@ int misc_init_r(void)
* Detect the presence of the platform bus node, and
* create a virtual memory mapping for it.
*/
for (ret = uclass_find_first_device(UCLASS_SIMPLE_BUS, &dev);
for (uclass_find_first_device(UCLASS_SIMPLE_BUS, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
uclass_find_next_device(&dev)) {
if (device_is_compatible(dev, "qemu,platform")) {
struct simple_bus_plat *plat = dev_get_uclass_plat(dev);

8
boot/bootdev-uclass.c
View File

@@ -213,10 +213,12 @@ void bootdev_list(bool probe)
device_active(dev) ? '+' : ' ',
ret ? simple_itoa(-ret) : "OK",
dev_get_uclass_name(dev_get_parent(dev)), dev->name);
if (probe)
if (probe) {
ret = uclass_next_device_check(&dev);
else
ret = uclass_find_next_device(&dev);
} else {
uclass_find_next_device(&dev);
ret = 0;
}
}
printf("--- ------ ------ -------- ------------------\n");
printf("(%d bootdev%s)\n", i, i != 1 ? "s" : "");

8
cmd/regulator.c
View File

@@ -96,11 +96,11 @@ static int do_list(struct cmd_tbl *cmdtp, int flag, int argc,
LIMIT_OFNAME, LIMIT_OFNAME, "regulator-name",
"Parent");
for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
ret = uclass_find_next_device(&dev)) {
if (ret)
continue;
ret = uclass_find_first_device(UCLASS_REGULATOR, &dev);
if (ret)
return ret;
for (; dev; uclass_find_next_device(&dev)) {
uc_pdata = dev_get_uclass_plat(dev);
printf("| %-*.*s| %-*.*s| %s\n",
LIMIT_DEVNAME, LIMIT_DEVNAME, dev->name,

16
drivers/core/uclass.c
View File

@@ -261,17 +261,14 @@ int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
return 0;
}
int uclass_find_next_device(struct udevice **devp)
void uclass_find_next_device(struct udevice **devp)
{
struct udevice *dev = *devp;
*devp = NULL;
if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
return 0;
*devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
return 0;
if (!list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
*devp = list_entry(dev->uclass_node.next, struct udevice,
uclass_node);
}
int uclass_find_device_by_namelen(enum uclass_id id, const char *name, int len,
@@ -675,11 +672,8 @@ int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
int uclass_next_device_check(struct udevice **devp)
{
int ret;
uclass_find_next_device(devp);
ret = uclass_find_next_device(devp);
if (ret)
return ret;
if (!*devp)
return 0;

21
drivers/power/regulator/regulator-uclass.c
View File

@@ -260,13 +260,13 @@ int regulator_get_by_platname(const char *plat_name, struct udevice **devp)
*devp = NULL;
for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
ret = uclass_find_next_device(&dev)) {
if (ret) {
dev_dbg(dev, "ret=%d\n", ret);
continue;
}
ret = uclass_find_first_device(UCLASS_REGULATOR, &dev);
if (ret) {
dev_dbg(dev, "ret=%d\n", ret);
return ret;
}
for (; dev; uclass_find_next_device(&dev)) {
uc_pdata = dev_get_uclass_plat(dev);
if (!uc_pdata || strcmp(plat_name, uc_pdata->name))
continue;
@@ -410,9 +410,12 @@ static bool regulator_name_is_unique(struct udevice *check_dev,
int ret;
int len;
for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
ret = uclass_find_next_device(&dev)) {
if (ret || dev == check_dev)
ret = uclass_find_first_device(UCLASS_REGULATOR, &dev);
if (ret)
return true;
for (; dev; uclass_find_next_device(&dev)) {
if (dev == check_dev)
continue;
uc_pdata = dev_get_uclass_plat(dev);

9
drivers/remoteproc/rproc-uclass.c
View File

@@ -55,9 +55,12 @@ static int for_each_remoteproc_device(int (*fn) (struct udevice *dev,
struct dm_rproc_uclass_pdata *uc_pdata;
int ret;
for (ret = uclass_find_first_device(UCLASS_REMOTEPROC, &dev); dev;
ret = uclass_find_next_device(&dev)) {
if (ret || dev == skip_dev)
ret = uclass_find_first_device(UCLASS_REMOTEPROC, &dev);
if (ret)
return ret;
for (; dev; uclass_find_next_device(&dev)) {
if (dev == skip_dev)
continue;
uc_pdata = dev_get_uclass_plat(dev);
ret = fn(dev, uc_pdata, data);

4
include/dm/uclass-internal.h
View File

@@ -149,10 +149,8 @@ int uclass_find_first_device(enum uclass_id id, struct udevice **devp);
*
* The device is not prepared for use - this is an internal function.
* The function uclass_get_device_tail() can be used to probe the device.
*
* Return: 0 if OK (found or not found), -ve on error
*/
int uclass_find_next_device(struct udevice **devp);
void uclass_find_next_device(struct udevice **devp);
/**
* uclass_find_device_by_namelen() - Find uclass device based on ID and name

143
test/dm/core.c
View File

@@ -167,8 +167,6 @@ static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts)
for (uclass_find_first_device(UCLASS_TEST, &dev);
dev;
uclass_find_next_device(&dev)) {
ut_assertnonnull(dev);
uc_pdata = dev_get_uclass_plat(dev);
ut_assert(uc_pdata);
}
@@ -223,8 +221,6 @@ static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
for (uclass_find_first_device(UCLASS_TEST, &dev);
dev;
uclass_find_next_device(&dev)) {
ut_assertnonnull(dev);
uc_pdata = dev_get_uclass_plat(dev);
ut_assert(uc_pdata);
ut_assert(uc_pdata->intval1 == TEST_UC_PDATA_INTVAL1);
@@ -734,114 +730,90 @@ static int dm_test_device_reparent(struct unit_test_state *uts)
/* Re-parent top-level children with no grandchildren. */
ut_assertok(device_reparent(top[3], top[0]));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(device_reparent(top[4], top[0]));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
/* Re-parent top-level children with grandchildren. */
ut_assertok(device_reparent(top[2], top[0]));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(device_reparent(top[5], top[2]));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
/* Re-parent grandchildren. */
ut_assertok(device_reparent(grandchild[0], top[1]));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(device_reparent(grandchild[1], top[1]));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
/* Remove re-pareneted devices. */
ut_assertok(device_remove(top[3], DM_REMOVE_NORMAL));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(device_remove(top[4], DM_REMOVE_NORMAL));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(device_remove(top[5], DM_REMOVE_NORMAL));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(device_remove(top[2], DM_REMOVE_NORMAL));
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(device_remove(grandchild[0], DM_REMOVE_NORMAL));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(device_remove(grandchild[1], DM_REMOVE_NORMAL));
/* try to get devices */
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
/* Try the same with unbind */
ut_assertok(device_unbind(top[3]));
@@ -1090,12 +1062,9 @@ static int dm_test_uclass_devices_find(struct unit_test_state *uts)
struct udevice *dev;
int ret;
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assertnonnull(dev);
}
ret = uclass_find_first_device(UCLASS_TEST, &dev);
ut_assert(!ret);
ut_assertnonnull(dev);
ut_assertok(uclass_find_first_device(UCLASS_TEST_DUMMY, &dev));
ut_assertnull(dev);
@@ -1121,18 +1090,16 @@ static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
* this will fail on checking condition: testdev == finddev, since the
* uclass_find_device_by_name(), returns the first device by given name.
*/
for (ret = uclass_find_first_device(UCLASS_TEST_FDT, &testdev);
testdev;
ret = uclass_find_next_device(&testdev)) {
ut_assertok(ret);
ut_assertnonnull(testdev);
ret = uclass_find_first_device(UCLASS_TEST_FDT, &testdev);
ut_assertok(ret);
ut_assertnonnull(testdev);
for (; testdev; uclass_find_next_device(&testdev)) {
findret = uclass_find_device_by_name(UCLASS_TEST_FDT,
testdev->name,
&finddev);
ut_assertok(findret);
ut_assert(testdev);
ut_asserteq_str(testdev->name, finddev->name);
ut_asserteq_ptr(testdev, finddev);
}