Merge tag 'dt-fixes-for-3.14' of git://git.kernel.org/pub/scm/linux/kernel/git/robh/linux

}

EXPORT_SYMBOL(of_find_node_with_property);

static

const struct of_device_id *__of_match_node(const struct of_device_id *matches,

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;

	if (!matches)

		return NULL;

	const struct of_device_id *m;

	cp = __of_get_property(node, "compatible", &cplen);

	do {

		const struct of_device_id *m = matches;

		/* Check against matches with current compatible string */

	while (cp && (cplen > 0)) {

		m = matches;

		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;

			/* 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 */

		if (cp) {

		l = strlen(cp) + 1;

		cp += l;

		cplen -= l;

	}

	} while (cp && (cplen > 0));

	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])

			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;

}

/**

 * 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. 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. 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)