OF: Fixup resursive locking code paths

[deliverable/linux.git] / drivers / of / base.c

diff --git a/drivers/of/base.c b/drivers/of/base.c
index 960ae5bf3ddc64b1dcdc2800919dc260fac4f198..16ee7a08e044b8c4dfb2a34d7dde456987892f0e 100644 (file)
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -164,16 +164,14 @@ void of_node_put(struct device_node *node)
 EXPORT_SYMBOL(of_node_put);
 #endif /* CONFIG_OF_DYNAMIC */
 
-struct property *of_find_property(const struct device_node *np,
-                                 const char *name,
-                                 int *lenp)
+static struct property *__of_find_property(const struct device_node *np,
+                                          const char *name, int *lenp)
 {
        struct property *pp;
 
        if (!np)
                return NULL;
 
-       read_lock(&devtree_lock);
        for (pp = np->properties; pp; pp = pp->next) {
                if (of_prop_cmp(pp->name, name) == 0) {
                        if (lenp)
@@ -181,6 +179,18 @@ struct property *of_find_property(const struct device_node *np,
                        break;
                }
        }
+
+       return pp;
+}
+
+struct property *of_find_property(const struct device_node *np,
+                                 const char *name,
+                                 int *lenp)
+{
+       struct property *pp;
+
+       read_lock(&devtree_lock);
+       pp = __of_find_property(np, name, lenp);
        read_unlock(&devtree_lock);
 
        return pp;
@@ -210,12 +220,24 @@ struct device_node *of_find_all_nodes(struct device_node *prev)
 }
 EXPORT_SYMBOL(of_find_all_nodes);
 
+/*
+ * Find a property with a given name for a given node
+ * and return the value.
+ */
+static const void *__of_get_property(const struct device_node *np,
+                                    const char *name, int *lenp)
+{
+       struct property *pp = __of_find_property(np, name, lenp);
+
+       return pp ? pp->value : NULL;
+}
+
 /*
  * Find a property with a given name for a given node
  * and return the value.
  */
 const void *of_get_property(const struct device_node *np, const char *name,
-                        int *lenp)
+                           int *lenp)
 {
        struct property *pp = of_find_property(np, name, lenp);
 
@@ -226,13 +248,13 @@ EXPORT_SYMBOL(of_get_property);
 /** Checks if the given "compat" string matches one of the strings in
  * the device's "compatible" property
  */
-int of_device_is_compatible(const struct device_node *device,
-               const char *compat)
+static int __of_device_is_compatible(const struct device_node *device,
+                                    const char *compat)
 {
        const char* cp;
        int cplen, l;
 
-       cp = of_get_property(device, "compatible", &cplen);
+       cp = __of_get_property(device, "compatible", &cplen);
        if (cp == NULL)
                return 0;
        while (cplen > 0) {
@@ -245,6 +267,20 @@ int of_device_is_compatible(const struct device_node *device,
 
        return 0;
 }
+
+/** Checks if the given "compat" string matches one of the strings in
+ * the device's "compatible" property
+ */
+int of_device_is_compatible(const struct device_node *device,
+               const char *compat)
+{
+       int res;
+
+       read_lock(&devtree_lock);
+       res = __of_device_is_compatible(device, compat);
+       read_unlock(&devtree_lock);
+       return res;
+}
 EXPORT_SYMBOL(of_device_is_compatible);
 
 /**
@@ -518,7 +554,8 @@ struct device_node *of_find_compatible_node(struct device_node *from,
                if (type
                    && !(np->type && (of_node_cmp(np->type, type) == 0)))
                        continue;
-               if (of_device_is_compatible(np, compatible) && of_node_get(np))
+               if (__of_device_is_compatible(np, compatible) &&
+                   of_node_get(np))
                        break;
        }
        of_node_put(from);
@@ -562,15 +599,9 @@ out:
 }
 EXPORT_SYMBOL(of_find_node_with_property);
 
-/**
- * of_match_node - Tell if an device_node has a matching of_match structure
- *     @matches:       array of of device match structures to search in
- *     @node:          the of device structure to match against
- *
- *     Low level utility function used by device matching.
- */
-const struct of_device_id *of_match_node(const struct of_device_id *matches,
-                                        const struct device_node *node)
+static
+const struct of_device_id *__of_match_node(const struct of_device_id *matches,
+                                          const struct device_node *node)
 {
        if (!matches)
                return NULL;
@@ -584,14 +615,32 @@ const struct of_device_id *of_match_node(const struct of_device_id *matches,
                        match &= node->type
                                && !strcmp(matches->type, node->type);
                if (matches->compatible[0])
-                       match &= of_device_is_compatible(node,
-                                               matches->compatible);
+                       match &= __of_device_is_compatible(node,
+                                                          matches->compatible);
                if (match)
                        return matches;
                matches++;
        }
        return NULL;
 }
+
+/**
+ * of_match_node - Tell if an device_node has a matching of_match structure
+ *     @matches:       array of of device match structures to search in
+ *     @node:          the of device structure to match against
+ *
+ *     Low level utility function used by device matching.
+ */
+const struct of_device_id *of_match_node(const struct of_device_id *matches,
+                                        const struct device_node *node)
+{
+       const struct of_device_id *match;
+
+       read_lock(&devtree_lock);
+       match = __of_match_node(matches, node);
+       read_unlock(&devtree_lock);
+       return match;
+}
 EXPORT_SYMBOL(of_match_node);
 
 /**
@@ -620,7 +669,7 @@ struct device_node *of_find_matching_node_and_match(struct device_node *from,
        read_lock(&devtree_lock);
        np = from ? from->allnext : of_allnodes;
        for (; np; np = np->allnext) {
-               m = of_match_node(matches, np);
+               m = __of_match_node(matches, np);
                if (m && of_node_get(np)) {
                        if (match)
                                *match = m;