net: sun8i_emac: Use consistent clock bitfield definitions

[oweals/u-boot.git] / drivers / core / root.c

diff --git a/drivers/core/root.c b/drivers/core/root.c
index 9000ed55ca583f0c84abe81e0c209e8240fad6e2..7d257ea887dd482b803c94836fa6375f84d228a7 100644 (file)
--- a/drivers/core/root.c
+++ b/drivers/core/root.c
@@ -1,15 +1,15 @@
+// SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright (c) 2013 Google, Inc
  *
  * (C) Copyright 2012
  * Pavel Herrmann <morpheus.ibis@gmail.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
  */
 
 #include <common.h>
 #include <errno.h>
 #include <fdtdec.h>
+#include <log.h>
 #include <malloc.h>
 #include <linux/libfdt.h>
 #include <dm/device.h>
@@ -26,10 +26,6 @@
 
 DECLARE_GLOBAL_DATA_PTR;
 
-struct root_priv {
-       fdt_addr_t translation_offset;  /* optional translation offset */
-};
-
 static const struct driver_info root_info = {
        .name           = "root_driver",
 };
@@ -53,22 +49,6 @@ void dm_fixup_for_gd_move(struct global_data *new_gd)
        }
 }
 
-fdt_addr_t dm_get_translation_offset(void)
-{
-       struct udevice *root = dm_root();
-       struct root_priv *priv = dev_get_priv(root);
-
-       return priv->translation_offset;
-}
-
-void dm_set_translation_offset(fdt_addr_t offs)
-{
-       struct udevice *root = dm_root();
-       struct root_priv *priv = dev_get_priv(root);
-
-       priv->translation_offset = offs;
-}
-
 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 void fix_drivers(void)
 {
@@ -188,6 +168,7 @@ int dm_uninit(void)
 {
        device_remove(dm_root(), DM_REMOVE_NORMAL);
        device_unbind(dm_root());
+       gd->dm_root = NULL;
 
        return 0;
 }
@@ -223,14 +204,13 @@ static int dm_scan_fdt_live(struct udevice *parent,
        int ret = 0, err;
 
        for (np = node_parent->child; np; np = np->sibling) {
-               if (pre_reloc_only &&
-                   !of_find_property(np, "u-boot,dm-pre-reloc", NULL))
-                       continue;
+
                if (!of_device_is_available(np)) {
                        pr_debug("   - ignoring disabled device\n");
                        continue;
                }
-               err = lists_bind_fdt(parent, np_to_ofnode(np), NULL);
+               err = lists_bind_fdt(parent, np_to_ofnode(np), NULL,
+                                    pre_reloc_only);
                if (err && !ret) {
                        ret = err;
                        debug("%s: ret=%d\n", np->name, ret);
@@ -266,29 +246,17 @@ static int dm_scan_fdt_node(struct udevice *parent, const void *blob,
        for (offset = fdt_first_subnode(blob, offset);
             offset > 0;
             offset = fdt_next_subnode(blob, offset)) {
-               /* "chosen" node isn't a device itself but may contain some: */
-               if (!strcmp(fdt_get_name(blob, offset, NULL), "chosen")) {
-                       pr_debug("parsing subnodes of \"chosen\"\n");
-
-                       err = dm_scan_fdt_node(parent, blob, offset,
-                                              pre_reloc_only);
-                       if (err && !ret)
-                               ret = err;
-                       continue;
-               }
+               const char *node_name = fdt_get_name(blob, offset, NULL);
 
-               if (pre_reloc_only &&
-                   !dm_fdt_pre_reloc(blob, offset))
-                       continue;
                if (!fdtdec_get_is_enabled(blob, offset)) {
                        pr_debug("   - ignoring disabled device\n");
                        continue;
                }
-               err = lists_bind_fdt(parent, offset_to_ofnode(offset), NULL);
+               err = lists_bind_fdt(parent, offset_to_ofnode(offset), NULL,
+                                    pre_reloc_only);
                if (err && !ret) {
                        ret = err;
-                       debug("%s: ret=%d\n", fdt_get_name(blob, offset, NULL),
-                             ret);
+                       debug("%s: ret=%d\n", node_name, ret);
                }
        }
 
@@ -323,43 +291,52 @@ int dm_scan_fdt(const void *blob, bool pre_reloc_only)
 #endif
        return dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only);
 }
-#else
-static int dm_scan_fdt_node(struct udevice *parent, const void *blob,
-                           int offset, bool pre_reloc_only)
+
+static int dm_scan_fdt_ofnode_path(const void *blob, const char *path,
+                                  bool pre_reloc_only)
 {
-       return 0;
-}
+       ofnode node;
+
+       node = ofnode_path(path);
+       if (!ofnode_valid(node))
+               return 0;
+
+#if CONFIG_IS_ENABLED(OF_LIVE)
+       if (of_live_active())
+               return dm_scan_fdt_live(gd->dm_root, node.np, pre_reloc_only);
 #endif
+       return dm_scan_fdt_node(gd->dm_root, blob, node.of_offset,
+                               pre_reloc_only);
+}
 
 int dm_extended_scan_fdt(const void *blob, bool pre_reloc_only)
 {
-       int ret;
-       ofnode node;
-
-       ret = dm_scan_fdt(gd->fdt_blob, pre_reloc_only);
+       int ret, i;
+       const char * const nodes[] = {
+               "/chosen",
+               "/clocks",
+               "/firmware"
+       };
+
+       ret = dm_scan_fdt(blob, pre_reloc_only);
        if (ret) {
                debug("dm_scan_fdt() failed: %d\n", ret);
                return ret;
        }
 
-       /* bind fixed-clock */
-       node = ofnode_path("/clocks");
-       /* if no DT "clocks" node, no need to go further */
-       if (!ofnode_valid(node))
-               return ret;
-
-#if CONFIG_IS_ENABLED(OF_LIVE)
-       if (of_live_active())
-               ret = dm_scan_fdt_live(gd->dm_root, node.np, pre_reloc_only);
-       else
-#endif
-               ret = dm_scan_fdt_node(gd->dm_root, gd->fdt_blob, node.of_offset,
-                                      pre_reloc_only);
-       if (ret)
-               debug("dm_scan_fdt_node() failed: %d\n", ret);
+       /* Some nodes aren't devices themselves but may contain some */
+       for (i = 0; i < ARRAY_SIZE(nodes); i++) {
+               ret = dm_scan_fdt_ofnode_path(blob, nodes[i], pre_reloc_only);
+               if (ret) {
+                       debug("dm_scan_fdt() scan for %s failed: %d\n",
+                             nodes[i], ret);
+                       return ret;
+               }
+       }
 
        return ret;
 }
+#endif
 
 __weak int dm_scan_other(bool pre_reloc_only)
 {
@@ -400,7 +377,6 @@ int dm_init_and_scan(bool pre_reloc_only)
 U_BOOT_DRIVER(root_driver) = {
        .name   = "root_driver",
        .id     = UCLASS_ROOT,
-       .priv_auto_alloc_size = sizeof(struct root_priv),
 };
 
 /* This is the root uclass */