of: fix a regression when trying to find the best compatible match
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
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
@@ -734,42 +734,24 @@ staticconst 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
PATCH 2/2 of: search the best compatible match first in __of_match_node()
In reply to a message not in the archiveCurrently, 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.
--- drivers/of/base.c | 43 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-)
drivers/of/base.c +42 -1
@@ -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
Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()
Quoted 15 lines · Kevin Hao
Currently,
of_match_nodecompares each given match against all node's compatible strings withof_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]>Signed-off-by Kevin Hao <[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@@ -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
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_nodecompares each given match against all node's compatible strings withof_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]>Signed-off-by Kevin Hao <[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@@ -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 structof_device_id*__of_match_node(const structof_device_id*matches,
const structdevice_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
Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()
In reply to a message not in the archiveQuoted 19 lines · Rob Herring
Quoted 15 lines · Kevin Hao
Currently,
of_match_nodecompares each given match against all node's compatible strings withof_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]>Signed-off-by Kevin Hao <[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
Stephen N Chivers
Tested-by Stephen ChiversRe: [PATCH 2/2] of: search the best compatible match first in __of_match_node()
In reply to a message not in the archiveRob 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_nodecompares each given match against all node's compatible strings withof_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]>Signed-off-by Kevin Hao <[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 foundof_serial ef600300.serial: Port foundof_serial ef600300.serial: Unknown serial port found, ignored of_serial ef600400.serial: Port foundof_serial ef600400.serial: Port foundof_serial ef600400.serial: Unknown serial port found, ignored of_serial ef600500.serial: Port foundof_serial ef600500.serial: Port foundof_serial ef600500.serial: Unknown serial port found, ignored of_serial ef600600.serial: Port foundof_serial ef600600.serial: Port foundof_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@@ -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
-0const 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
-0int 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
-0const 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
Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()
In reply to a message not in the archiveQuoted 16 lines · Rob Herring
Quoted 15 lines · Kevin Hao
Currently,
of_match_nodecompares each given match against all node's compatible strings withof_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]>Signed-off-by Kevin Hao <[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
Re: [PATCH 2/2] of: search the best compatible match first in __of_match_node()
In reply to a message not in the archiveQuoted 36 lines · Kevin Hao
Currently,
of_match_nodecompares each given match against all node's compatible strings withof_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]>Signed-off-by Kevin Hao <[email protected]>--- drivers/of/base.c | 43 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-)drivers/of/base.c +7
-0@@ -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]
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->nameorm->typeare 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.