Skip to contentSkip to conversation

of: fix a regression when trying to find the best compatible match

PATCH In review Kevin Hao 6 participants 10 messages Feb 14, 2014 – Feb 18, 2014 4 messages not in the archive Device tree

lore
Share & tools
lore

Kevin Hao

author
#0 lore raw

cover of: fix a regression when trying to find the best compatible match

Hi,

This fix a regression when trying to find the best compatible match. You can find the detail of the issue reported by Stephen Chivers at:
https://lists.ozlabs.org/pipermail/linuxppc-dev/2014-February/115278.html

I have made a patch to fix this previously.
http://patchwork.ozlabs.org/patch/319624/

This is another respin with the implementation suggested by Rob Herring.

Kevin Hao (2):
Revert "OF: base: match each node compatible against all given matches
first"
of: search the best compatible match first in __of_match_node()

 drivers/of/base.c | 88 ++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 54 insertions(+), 34 deletions(-)
Signature · 6 lines
1.8.5.3

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

A message that is not in the archive (sent off-list or not yet received): 1392355366-1445-1-git-send-email-haokexin-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org

author
#2 lore raw

PATCH 1/2 Revert "OF: base: match each node compatible against all given matches first"

This reverts commit 105353145eafb3ea919f5cdeb652a9d8f270228e. Stephen Chivers reported this is broken as we will get a match entry '.type = "serial"' instead of the '.compatible = "ns16550"' in the following scenario:

	serial0: serial@4500 {
		compatible = "fsl,ns16550", "ns16550";
	}

	struct of_device_id of_platform_serial_table[] = {
		{ .compatible = "ns8250",   .data = (void *)PORT_8250, },
		{ .compatible = "ns16450",  .data = (void *)PORT_16450, },
		{ .compatible = "ns16550a", .data = (void *)PORT_16550A, },
		{ .compatible = "ns16550",  .data = (void *)PORT_16550, },
		{ .compatible = "ns16750",  .data = (void *)PORT_16750, },
		{ .compatible = "ns16850",  .data = (void *)PORT_16850, },
		...
		{ .type = "serial",         .data = (void *)PORT_UNKNOWN, },
		{ /* end of list */ },
	};

So just revert this patch, we will use another implementation to find the best compatible match in a follow-on patch.

---
 drivers/of/base.c | 53 ++++++++++++++++-------------------------------------
 1 file changed, 16 insertions(+), 37 deletions(-)
drivers/of/base.c +16 -37
index ff85450d5683..ba195fbce4c6 100644
@@ -734,42 +734,24 @@ static
 const struct of_device_id *__of_match_node(const struct of_device_id *matches,
 					   const struct device_node *node)
 {
-	const char *cp;
-	int cplen, l;
-
 	if (!matches)
 		return NULL;
 
-	cp = __of_get_property(node, "compatible", &cplen);
-	do {
-		const struct of_device_id *m = matches;
-
-		/* Check against matches with current compatible string */
-		while (m->name[0] || m->type[0] || m->compatible[0]) {
-			int match = 1;
-			if (m->name[0])
-				match &= node->name
-					&& !strcmp(m->name, node->name);
-			if (m->type[0])
-				match &= node->type
-					&& !strcmp(m->type, node->type);
-			if (m->compatible[0])
-				match &= cp
-					&& !of_compat_cmp(m->compatible, cp,
-							strlen(m->compatible));
-			if (match)
-				return m;
-			m++;
-		}
-
-		/* Get node's next compatible string */ 
-		if (cp) {
-			l = strlen(cp) + 1;
-			cp += l;
-			cplen -= l;
-		}
-	} while (cp && (cplen > 0));
-
+	while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
+		int match = 1;
+		if (matches->name[0])
+			match &= node->name
+				&& !strcmp(matches->name, node->name);
+		if (matches->type[0])
+			match &= node->type
+				&& !strcmp(matches->type, node->type);
+		if (matches->compatible[0])
+			match &= __of_device_is_compatible(node,
+							   matches->compatible);
+		if (match)
+			return matches;
+		matches++;
+	}
 	return NULL;
 }
 
@@ -778,10 +760,7 @@ const struct of_device_id *__of_match_node(const struct of_device_id *matches,
  *	@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. Matching order
- *	is to compare each of the node's compatibles with all given matches
- *	first. This implies node's compatible is sorted from specific to
- *	generic while matches can be in any order.
+ *	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)
Signature · 6 lines
1.8.5.3

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
author
#3 lore raw

PATCH 2/2 of: search the best compatible match first in __of_match_node()

In reply to a message not in the archive

Currently, of_match_node compares each given match against all node's compatible strings with of_device_is_compatible.

To achieve multiple compatible strings per node with ordering from specific to generic, this requires given matches to be ordered from specific to generic. For most of the drivers this is not true and also an alphabetical ordering is more sane there.

Therefore, this patch introduces a function to match each of the node's compatible strings against all given compatible matches without type and name first, before checking the next compatible string. This implies that node's compatibles are ordered from specific to generic while given matches can be in any order. If we fail to find such a match entry, then fall-back to the old method in order to keep compatibility.

Cc Sebastian Hesselbarth <[email protected]>
---
 drivers/of/base.c | 43 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)
drivers/of/base.c +42 -1
index ba195fbce4c6..10b51106c854 100644
@@ -730,13 +730,49 @@ out:
 }
 EXPORT_SYMBOL(of_find_node_with_property);
 
+static const struct of_device_id *
+of_match_compatible(const struct of_device_id *matches,
+			const struct device_node *node)
+{
+	const char *cp;
+	int cplen, l;
+	const struct of_device_id *m;
+
+	cp = __of_get_property(node, "compatible", &cplen);
+	while (cp && (cplen > 0)) {
+		m = matches;
+		while (m->name[0] || m->type[0] || m->compatible[0]) {
+			/* Only match for the entries without type and name */
+			if (m->name[0] || m->type[0] ||
+				of_compat_cmp(m->compatible, cp,
+					 strlen(m->compatible)))
+				m++;
+			else
+				return m;
+		}
+
+		/* Get node's next compatible string */
+		l = strlen(cp) + 1;
+		cp += l;
+		cplen -= l;
+	}
+
+	return NULL;
+}
+
 static
 const struct of_device_id *__of_match_node(const struct of_device_id *matches,
 					   const struct device_node *node)
 {
+	const struct of_device_id *m;
+
 	if (!matches)
 		return NULL;
 
+	m = of_match_compatible(matches, node);
+	if (m)
+		return m;
+
 	while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
 		int match = 1;
 		if (matches->name[0])
@@ -760,7 +796,12 @@ const struct of_device_id *__of_match_node(const struct of_device_id *matches,
  *	@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.
+ *	Low level utility function used by device matching. We have two ways
+ *	of matching:
+ *	- Try to find the best compatible match by comparing each compatible
+ *	  string of device node with all the given matches respectively.
+ *	- If the above method failed, then try to match the compatible by using
+ *	  __of_device_is_compatible() besides the match in type and name.
  */
 const struct of_device_id *of_match_node(const struct of_device_id *matches,
 					 const struct device_node *node)
Signature · 6 lines
1.8.5.3

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

A message that is not in the archive (sent off-list or not yet received): 1392355366-1445-3-git-send-email-haokexin-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org

#5 lore raw

Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()

Quoted 15 lines · Kevin Hao

Currently, of_match_node compares each given match against all node's compatible strings with of_device_is_compatible.

To achieve multiple compatible strings per node with ordering from specific to generic, this requires given matches to be ordered from specific to generic. For most of the drivers this is not true and also an alphabetical ordering is more sane there.

Therefore, this patch introduces a function to match each of the node's compatible strings against all given compatible matches without type and name first, before checking the next compatible string. This implies that node's compatibles are ordered from specific to generic while given matches can be in any order. If we fail to find such a match entry, then fall-back to the old method in order to keep compatibility.

Quoted 2 lines
Cc Sebastian Hesselbarth <[email protected]>

Looks good to me. I'll put this in next for a few days. I'd really like to see some acks and tested-by's before sending to Linus.

We could be a bit more strict here and fallback to the old matching if the match table has any entries with name or type. I don't think that should be necessary though.

Rob

Quoted 73 lines
---
 drivers/of/base.c | 43 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)
drivers/of/base.c +42 -2
index ba195fbce4c6..10b51106c854 100644
@@ -730,13 +730,49 @@ out:
 }
 EXPORT_SYMBOL(of_find_node_with_property);
 
+static const struct of_device_id *
+of_match_compatible(const struct of_device_id *matches,
+                       const struct device_node *node)
+{
+       const char *cp;
+       int cplen, l;
+       const struct of_device_id *m;
+
+       cp = __of_get_property(node, "compatible", &cplen);
+       while (cp && (cplen > 0)) {
+               m = matches;
+               while (m->name[0] || m->type[0] || m->compatible[0]) {
+                       /* Only match for the entries without type and name */
+                       if (m->name[0] || m->type[0] ||
+                               of_compat_cmp(m->compatible, cp,
+                                        strlen(m->compatible)))
+                               m++;
+                       else
+                               return m;
+               }
+
+               /* Get node's next compatible string */
+               l = strlen(cp) + 1;
+               cp += l;
+               cplen -= l;
+       }
+
+       return NULL;
+}
+
 static
 const struct of_device_id *__of_match_node(const struct of_device_id *matches,
                                           const struct device_node *node)
 {
+       const struct of_device_id *m;
+
        if (!matches)
                return NULL;
 
+       m = of_match_compatible(matches, node);
+       if (m)
+               return m;
+
        while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
                int match = 1;
                if (matches->name[0])
@@ -760,7 +796,12 @@ const struct of_device_id *__of_match_node(const struct of_device_id *matches,
  *     @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.
+ *     Low level utility function used by device matching. We have two ways
+ *     of matching:
+ *     - Try to find the best compatible match by comparing each compatible
+ *       string of device node with all the given matches respectively.
+ *     - If the above method failed, then try to match the compatible by using
+ *       __of_device_is_compatible() besides the match in type and name.
  */
 const struct of_device_id *of_match_node(const struct of_device_id *matches,
                                         const struct device_node *node)
--
Quoted 2 lines

1.8.5.3

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

A message that is not in the archive (sent off-list or not yet received): CAL_JsqKq4_1K8EF+PZoP=0=H6tiRxbgdzs9UHHVdbHS014n74Q-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org

#7 lore raw

Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()

Quoted 19 lines · Rob Herring
Quoted 15 lines · Kevin Hao

Currently, of_match_node compares each given match against all node's compatible strings with of_device_is_compatible.

To achieve multiple compatible strings per node with ordering from specific to generic, this requires given matches to be ordered from specific to generic. For most of the drivers this is not true and also an alphabetical ordering is more sane there.

Therefore, this patch introduces a function to match each of the node's compatible strings against all given compatible matches without type and name first, before checking the next compatible string. This implies that node's compatibles are ordered from specific to generic while given matches can be in any order. If we fail to find such a match entry, then fall-back to the old method in order to keep compatibility.

Quoted 2 lines
Cc Sebastian Hesselbarth <[email protected]>
Quoted 8 lines

Looks good to me. I'll put this in next for a few days. I'd really like to see some acks and tested-by's before sending to Linus.

We could be a bit more strict here and fallback to the old matching if the match table has any entries with name or type. I don't think that should be necessary though.

Rob

Can you push the revert to Linus sooner, since currently a ton of boards wouldn’t be working on the PPC side, so at least -rc3 has the possibility of working for them.

- k

Quoted 75 lines
Quoted 75 lines

---
drivers/of/base.c | 43 ++++++++++++++++++++++++++++++++++++++++++-

1 file changed, 42 insertions(+), 1 deletion(-)
drivers/of/base.c +30 -0
index ba195fbce4c6..10b51106c854 100644
@@ -730,13 +730,49 @@ out:
 }
 EXPORT_SYMBOL(of_find_node_with_property);
 
+static const struct of_device_id *
+of_match_compatible(const struct of_device_id *matches,
+                       const struct device_node *node)
+{
+       const char *cp;
+       int cplen, l;
+       const struct of_device_id *m;
+
+       cp = __of_get_property(node, "compatible", &cplen);
+       while (cp && (cplen > 0)) {
+               m = matches;
+               while (m->name[0] || m->type[0] || m->compatible[0]) {
+                       /* Only match for the entries without type and name */
+                       if (m->name[0] || m->type[0] ||
+                               of_compat_cmp(m->compatible, cp,
+                                        strlen(m->compatible)))
+                               m++;
+                       else
+                               return m;
+               }
+
+               /* Get node's next compatible string */
+               l = strlen(cp) + 1;
+               cp += l;
+               cplen -= l;
+       }
+
+       return NULL;
+}
+

static
const struct of_device_id *__of_match_node(const struct of_device_id *matches,
const struct device_node *node)
{

drivers/of/base.c +12 -2
+       const struct of_device_id *m;
+
       if (!matches)
               return NULL;
 
+       m = of_match_compatible(matches, node);
+       if (m)
+               return m;
+
       while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
               int match = 1;
               if (matches->name[0])
@@ -760,7 +796,12 @@ const struct of_device_id *__of_match_node(const struct of_device_id *matches,
 *     @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.
+ *     Low level utility function used by device matching. We have two ways
+ *     of matching:
+ *     - Try to find the best compatible match by comparing each compatible
+ *       string of device node with all the given matches respectively.
+ *     - If the above method failed, then try to match the compatible by using
+ *       __of_device_is_compatible() besides the match in type and name.
 */
 const struct of_device_id *of_match_node(const struct of_device_id *matches,
                                        const struct device_node *node)
--

1.8.5.3

Signature · 7 lines
Employee of Qualcomm Innovation Center, Inc.
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
#8 lore raw

Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()

In reply to a message not in the archive
Quoted 19 lines · Rob Herring
Quoted 15 lines · Kevin Hao

Currently, of_match_node compares each given match against all node's compatible strings with of_device_is_compatible.

To achieve multiple compatible strings per node with ordering from specific to generic, this requires given matches to be ordered from specific to generic. For most of the drivers this is not true and also an alphabetical ordering is more sane there.

Therefore, this patch introduces a function to match each of the node's compatible strings against all given compatible matches without type and name first, before checking the next compatible string. This implies that node's compatibles are ordered from specific to generic while given matches can be in any order. If we fail to find such a match entry, then fall-back to the old method in order to keep compatibility.

Quoted 2 lines
Cc Sebastian Hesselbarth <[email protected]>
Quoted 9 lines

Looks good to me. I'll put this in next for a few days. I'd really like to see some acks and tested-by's before sending to Linus.

We could be a bit more strict here and fallback to the old matching if the match table has any entries with name or type. I don't think that should be necessary though.

Rob

Can you push the revert to Linus sooner, since currently a ton of boards wouldn’t be working on the PPC side, so at least -rc3 has the possibility of working for them.

- k
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

Tested-by Stephen Chivers
#9 lore raw

Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()

In reply to a message not in the archive

Rob Herring <[email protected]> wrote on 02/15/2014 02:53:40 AM:

Quoted 11 lines

From: Rob Herring <[email protected]>
To: Kevin Hao <[email protected]>
Cc: "[email protected]" <[email protected]>, linuxppc-dev <linuxppc-dev-uLR06cmDAlY/[email protected]>, Sebastian Hesselbarth <[email protected]>, Stephen N Chivers <[email protected]>, Grant Likely <[email protected]>, Rob Herring <[email protected]>, Kumar Gala <[email protected]>
Date: 02/15/2014 02:53 AM
Subject: Re: [PATCH 2/2] of: search the best compatible match first
in __of_match_node()

Quoted 10 lines
Quoted 9 lines · Kevin Hao

Currently, of_match_node compares each given match against all node's compatible strings with of_device_is_compatible.

To achieve multiple compatible strings per node with ordering from specific to generic, this requires given matches to be ordered from specific to generic. For most of the drivers this is not true and also an alphabetical ordering is more sane there.

Therefore, this patch introduces a function to match each of the

node's

Quoted 1 line
Quoted 1 line

compatible strings against all given compatible matches without type

and

Quoted 4 lines
Quoted 4 lines

name first, before checking the next compatible string. This implies that node's compatibles are ordered from specific to generic while given matches can be in any order. If we fail to find such a match entry, then fall-back to the old method in order to keep

compatibility.

Quoted 7 lines
Quoted 3 lines
Cc Sebastian Hesselbarth <[email protected]>

Looks good to me. I'll put this in next for a few days. I'd really like to see some acks and tested-by's before sending to Linus.

I have tested the patch for the four PowerPC platforms available to me.

They are:

MPC8349_MITXGP - Works.
MVME5100 - Works.
MVME4100 - Works.
SAM440EP - Works.

The MPC8349_MITXGP platform is present in Linux-3.13 and previous releases.
The MVME5100 is a "revived" platform that is in Linux-3.14-rc2. The MVME4100 is a work in progress and is the 85xx platform that the original failure report was for.
The SAM440EP is present in Linux-3.13 and previous releases.

The MPC8349_MITXGP is one of the 49 DTS files with the serial compatible:

compatible = "fsl,ns16550", "ns16550";

For the SAM440EP, the patch improves things from Linux-3.13. In that release the same sort of problem as reported in:

"Linux-3.14-rc2: Order of serial node compatibles in DTS files."

occurs with slightly different symptoms:

of_serial ef600300.serial: Port found
of_serial ef600300.serial: Port found
of_serial ef600300.serial: Unknown serial port found, ignored of_serial ef600400.serial: Port found
of_serial ef600400.serial: Port found
of_serial ef600400.serial: Unknown serial port found, ignored of_serial ef600500.serial: Port found
of_serial ef600500.serial: Port found
of_serial ef600500.serial: Unknown serial port found, ignored of_serial ef600600.serial: Port found
of_serial ef600600.serial: Port found
of_serial ef600600.serial: Unknown serial port found, ignored

The SAM440EP has a IBM/AMCC 440EP PowerPC CPU and so simply has "ns16550" as its serial compatible.

Quoted 5 lines

We could be a bit more strict here and fallback to the old matching if the match table has any entries with name or type. I don't think that should be necessary though.

Rob

Stephen Chivers,
CSC Australia Pty. Ltd.

Quoted 39 lines
Quoted 16 lines
---
 drivers/of/base.c | 43 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)
drivers/of/base.c +3 -0
index ba195fbce4c6..10b51106c854 100644
@@ -730,13 +730,49 @@ out:
 }
 EXPORT_SYMBOL(of_find_node_with_property);
 
+static const struct of_device_id *
+of_match_compatible(const struct of_device_id *matches,
+                       const struct device_node *node)

drivers/of/base.c out: · line 745

Quoted 10 lines
drivers/of/base.c +10 -0
+{
+       const char *cp;
+       int cplen, l;
+       const struct of_device_id *m;
+
+       cp = __of_get_property(node, "compatible", &cplen);
+       while (cp && (cplen > 0)) {
+               m = matches;
+               while (m->name[0] || m->type[0] || m->compatible[0]) {
+                       /* Only match for the entries without type

and name */

Quoted 12 lines
drivers/of/base.c +12 -0
+                       if (m->name[0] || m->type[0] ||
+                               of_compat_cmp(m->compatible, cp,
+                                        strlen(m->compatible)))
+                               m++;
+                       else
+                               return m;
+               }
+
+               /* Get node's next compatible string */
+               l = strlen(cp) + 1;
+               cp += l;
+               cplen -= l;
Quoted 9 lines

drivers/of/base.c out:

Quoted 7 lines
drivers/of/base.c +5 -0
+       }
+
+       return NULL;
+}
+
 static
 const struct of_device_id *__of_match_node(const struct 

of_device_id *matches,

Quoted 1 line
drivers/of/base.c +0 -0
                                           const struct device_node 

*node)

Quoted 12 lines

drivers/of/base.c out:

Quoted 11 lines
drivers/of/base.c +6 -0
 {
+       const struct of_device_id *m;
+
        if (!matches)
                return NULL;
 
+       m = of_match_compatible(matches, node);
+       if (m)
+               return m;
+
        while (matches->name[0] || matches->type[0] || 

matches->compatible[0]) {

Quoted 5 lines

drivers/of/base.c const struct of_device_id *__of_match_node

Quoted 3 lines
drivers/of/base.c +0 -0
                int match = 1;
                if (matches->name[0])
@@ -760,7 +796,12 @@ const struct of_device_id *__of_match_node

(const struct of_device_id *matches,

Quoted 1 line
drivers/of/base.c +0 -0
  *     @matches:       array of of device match structures to search 

in

Quoted 4 lines

drivers/of/base.c const struct of_device_id *__of_match_node(const struct of_device_id *matches,

Quoted 4 lines
drivers/of/base.c +1 -1
  *     @node:          the of device structure to match against
  *
- *     Low level utility function used by device matching.
+ *     Low level utility function used by device matching. We have 

two ways

Quoted 2 lines

drivers/of/base.c const struct of_device_id *__of_match_node · line 801

Quoted 2 lines
drivers/of/base.c +2 -0
+ *     of matching:
+ *     - Try to find the best compatible match by comparing each 

compatible

Quoted 1 line

drivers/of/base.c const struct of_device_id *__of_match_node · line 802

Quoted 1 line
drivers/of/base.c +1 -0
+ *       string of device node with all the given matches 

respectively.

Quoted 3 lines

drivers/of/base.c const struct of_device_id *__of_match_node · line 803

Quoted 1 line
drivers/of/base.c +1 -0
+ *     - If the above method failed, then try to match the 

compatible by using

Quoted 1 line
drivers/of/base.c +1 -0
+ *       __of_device_is_compatible() besides the match in type and 

name.

Quoted 4 lines

drivers/of/base.c const struct of_device_id *__of_match_node · line 806

Quoted 2 lines
drivers/of/base.c +0 -0
  */
 const struct of_device_id *of_match_node(const struct 

of_device_id *matches,

Quoted 1 line
drivers/of/base.c +0 -0
                                         const struct device_node 

*node)

Quoted 3 lines
Quoted 3 lines

--
1.8.5.3

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

#10 lore raw

Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()

In reply to a message not in the archive
Quoted 16 lines · Rob Herring
Quoted 15 lines · Kevin Hao

Currently, of_match_node compares each given match against all node's compatible strings with of_device_is_compatible.

To achieve multiple compatible strings per node with ordering from specific to generic, this requires given matches to be ordered from specific to generic. For most of the drivers this is not true and also an alphabetical ordering is more sane there.

Therefore, this patch introduces a function to match each of the node's compatible strings against all given compatible matches without type and name first, before checking the next compatible string. This implies that node's compatibles are ordered from specific to generic while given matches can be in any order. If we fail to find such a match entry, then fall-back to the old method in order to keep compatibility.

Quoted 5 lines
Quoted 2 lines
Cc Sebastian Hesselbarth <[email protected]>

Looks good to me. I'll put this in next for a few days. I'd really like to see some acks and tested-by's before sending to Linus.

As I commented on the patch, I don't think the new solution is correct either. I've made a suggestion on how to fix it, but in the mean time the revert should be applied and sent to Linus.

g.

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

#11 lore raw

Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()

In reply to a message not in the archive
Quoted 36 lines · Kevin Hao

Currently, of_match_node compares each given match against all node's compatible strings with of_device_is_compatible.

To achieve multiple compatible strings per node with ordering from specific to generic, this requires given matches to be ordered from specific to generic. For most of the drivers this is not true and also an alphabetical ordering is more sane there.

Therefore, this patch introduces a function to match each of the node's compatible strings against all given compatible matches without type and name first, before checking the next compatible string. This implies that node's compatibles are ordered from specific to generic while given matches can be in any order. If we fail to find such a match entry, then fall-back to the old method in order to keep compatibility.

Cc Sebastian Hesselbarth <[email protected]>
---
 drivers/of/base.c | 43 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)
drivers/of/base.c +7 -0
index ba195fbce4c6..10b51106c854 100644
@@ -730,13 +730,49 @@ out:
 }
 EXPORT_SYMBOL(of_find_node_with_property);
 
+static const struct of_device_id *
+of_match_compatible(const struct of_device_id *matches,
+			const struct device_node *node)
+{
+	const char *cp;
+	int cplen, l;
+	const struct of_device_id *m;

drivers/of/base.c out: · line 749

Quoted 10 lines
drivers/of/base.c +10 -0
+
+	cp = __of_get_property(node, "compatible", &cplen);
+	while (cp && (cplen > 0)) {
+		m = matches;
+		while (m->name[0] || m->type[0] || m->compatible[0]) {
+			/* Only match for the entries without type and name */
+			if (m->name[0] || m->type[0] ||
+				of_compat_cmp(m->compatible, cp,
+					 strlen(m->compatible)))
+				m++;

This seems wrong also. The compatible order should be checked for even when m->name or m->type are set. You actually need to score the entries to do this properly. The pseudo-code should look like this:

uint best_score = ~0;
of_device_id *best_match = NULL;

for_each(matches) {
	uint score = ~0;
	for_each_compatible(index) {
		if (match->compatible == compatible[index])
			score = index * 10;
	}

	/* Matching name is a bit better than not */
	if (match->name == node->name)
		score--;

	/* Matching type is better than matching name */
	/* (but matching both is even better than that */
	if (match->type == node->type)
		score -= 2;

	if (score < best_score)
		best_match = match;
}

return best_match;

This is actually very similar to the original code. It is an easy modification. This is very similar to how the of_fdt_is_compatible() function works.

g.
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

A message that is not in the archive (sent off-list or not yet received): 20140217175834.62ED6C403C8-WNowdnHR2B42iJbIjFUEsiwD8/[email protected]

author
#13 lore raw

Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()

Quoted 25 lines · Grant Likely

This seems wrong also. The compatible order should be checked for even when m->name or m->type are set. You actually need to score the entries to do this properly. The pseudo-code should look like this:

uint best_score = ~0;
of_device_id *best_match = NULL;

for_each(matches) {
	uint score = ~0;
	for_each_compatible(index) {
		if (match->compatible == compatible[index])
			score = index * 10;
	}

	/* Matching name is a bit better than not */
	if (match->name == node->name)
		score--;

	/* Matching type is better than matching name */
	/* (but matching both is even better than that */
	if (match->type == node->type)
		score -= 2;

	if (score < best_score)
		best_match = match;
}
Quoted 5 lines

return best_match;

This is actually very similar to the original code. It is an easy modification. This is very similar to how the of_fdt_is_compatible() function works.

I like this idea and will make a new patch based on this.

Thanks,
Kevin

Quoted 2 lines

g.