From dc71bcf1b99c265fffdb1e8c60e7933612f3bca7 Mon Sep 17 00:00:00 2001 From: Thomas Abraham Date: Sat, 19 Jan 2013 10:20:42 -0800 Subject: of: fix incorrect return value of of_find_matching_node_and_match() The of_find_matching_node_and_match() function incorrectly sets the matched entry to 'matches' when the compatible value of a node matches one of the possible values. This results in incorrectly selecting the the first entry in the 'matches' list as the matched entry. Fix this by noting down the result of the call to of_match_node() and setting that as the matched entry. Signed-off-by: Thomas Abraham Signed-off-by: Rob Herring --- drivers/of/base.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'drivers/of') diff --git a/drivers/of/base.c b/drivers/of/base.c index 2390ddb22d60..960ae5bf3ddc 100644 --- a/drivers/of/base.c +++ b/drivers/of/base.c @@ -612,6 +612,7 @@ struct device_node *of_find_matching_node_and_match(struct device_node *from, const struct of_device_id **match) { struct device_node *np; + const struct of_device_id *m; if (match) *match = NULL; @@ -619,9 +620,10 @@ 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) { - if (of_match_node(matches, np) && of_node_get(np)) { + m = of_match_node(matches, np); + if (m && of_node_get(np)) { if (match) - *match = matches; + *match = m; break; } } -- cgit v1.2.3-59-g8ed1b From 28d0e36bf96863df1195f8f7b9fd559142873389 Mon Sep 17 00:00:00 2001 From: Thomas Gleixner Date: Fri, 25 Jan 2013 13:21:47 -0500 Subject: OF: Fixup resursive locking code paths There is no real reason to use a rwlock for devtree_lock. It even could be a mutex, but unfortunately it's locked from cpu hotplug paths which can't schedule :( So it needs to become a raw lock on rt as well. The devtree_lock would be the only user of a raw_rw_lock, so we are better off cleaning up the recursive locking paths which allows us to convert devtree_lock to a read_lock. Here we do the standard thing of introducing __foo() as the "raw" version of foo(), so that we can take better control of the locking. The "raw" versions are not exported and are for internal use within the file itself. Signed-off-by: Thomas Gleixner Signed-off-by: Paul Gortmaker Signed-off-by: Rob Herring --- drivers/of/base.c | 91 ++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 70 insertions(+), 21 deletions(-) (limited to 'drivers/of') diff --git a/drivers/of/base.c b/drivers/of/base.c index 960ae5bf3ddc..16ee7a08e044 100644 --- 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; -- cgit v1.2.3-59-g8ed1b