uclass: Cleanup uclass_find_next_device

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>

diff --git a/board/emulation/qemu-ppce500/qemu-ppce500.c b/board/emulation/qemu-ppce500/qemu-ppce500.c
index 40d295dbf060dc6be509796e09afd70b563c9e82..58de4a0529654cd80a44b903bfdd3d8fcaf20c6c 100644 (file)
--- a/board/emulation/qemu-ppce500/qemu-ppce500.c
+++ b/board/emulation/qemu-ppce500/qemu-ppce500.c
@@ -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);
 

diff --git a/boot/bootdev-uclass.c b/boot/bootdev-uclass.c
index 3791ebfcb42d19bb764fc1a9b11ea48ccf8fc7b8..3f8dc2c3c4e69dc438321587f20f076e2dde91ba 100644 (file)
--- a/boot/bootdev-uclass.c
+++ b/boot/bootdev-uclass.c
@@ -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" : "");

diff --git a/cmd/regulator.c b/cmd/regulator.c
index da298090bb7605d0e6dbf9630edc6971044ff114..8d743c8d2698f0c2b827b8d2d28d04f3bcd8f56b 100644 (file)
--- a/cmd/regulator.c
+++ b/cmd/regulator.c
@@ -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,

diff --git a/drivers/core/uclass.c b/drivers/core/uclass.c
index ce5e61bbaa63a181a1ea6781ad6a7f06be67c7e0..5365ac68f9e253b3ce12e1b93f075164393e249b 100644 (file)
--- a/drivers/core/uclass.c
+++ b/drivers/core/uclass.c
@@ -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;
 

diff --git a/drivers/power/regulator/regulator-uclass.c b/drivers/power/regulator/regulator-uclass.c
index 09567eb9dbb6c755fcd23f31e5ed33270814a885..2a59a1b79c2d8720591b6186c0a5bf12fda2dbbd 100644 (file)
--- a/drivers/power/regulator/regulator-uclass.c
+++ b/drivers/power/regulator/regulator-uclass.c
@@ -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);

diff --git a/drivers/remoteproc/rproc-uclass.c b/drivers/remoteproc/rproc-uclass.c
index 3233ff80419b2f4f667b5ec92ab00bc57a181221..2dbd3a21cea6382a7ec02e52b2c0eb757197d434 100644 (file)
--- a/drivers/remoteproc/rproc-uclass.c
+++ b/drivers/remoteproc/rproc-uclass.c
@@ -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);

diff --git a/include/dm/uclass-internal.h b/include/dm/uclass-internal.h
index 3ddcdd21439cad4b79464b161d0ada376eaff252..9cb3f0902719524def275b92fdbf0a3047bfb945 100644 (file)
--- a/include/dm/uclass-internal.h
+++ b/include/dm/uclass-internal.h
@@ -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

diff --git a/test/dm/core.c b/test/dm/core.c
index 959b834576ffd6e88b5e60b05879c8c47dc02c63..53693f4f7ed7c7265218e4154ebf81a044a3a431 100644 (file)
--- a/test/dm/core.c
+++ b/test/dm/core.c
@@ -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);
        }