2007-05-01 00:26:07 -06:00
|
|
|
/*
|
|
|
|
* Procedures for creating, accessing and interpreting the device tree.
|
|
|
|
*
|
|
|
|
* Paul Mackerras August 1996.
|
|
|
|
* Copyright (C) 1996-2005 Paul Mackerras.
|
|
|
|
*
|
|
|
|
* Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
|
|
|
|
* {engebret|bergner}@us.ibm.com
|
|
|
|
*
|
|
|
|
* Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
|
|
|
|
*
|
2009-10-15 10:58:09 -06:00
|
|
|
* Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
|
|
|
|
* Grant Likely.
|
2007-05-01 00:26:07 -06:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
2014-03-27 18:18:55 -06:00
|
|
|
#include <linux/console.h>
|
2011-08-15 01:28:14 -06:00
|
|
|
#include <linux/ctype.h>
|
2013-08-15 07:01:40 -06:00
|
|
|
#include <linux/cpu.h>
|
2007-05-01 00:26:07 -06:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/of.h>
|
2014-02-10 14:01:48 -07:00
|
|
|
#include <linux/of_graph.h>
|
2007-04-24 00:46:53 -06:00
|
|
|
#include <linux/spinlock.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2014-02-20 11:02:11 -07:00
|
|
|
#include <linux/string.h>
|
2010-02-01 21:34:14 -07:00
|
|
|
#include <linux/proc_fs.h>
|
2007-04-24 00:46:53 -06:00
|
|
|
|
2012-12-06 15:55:41 -07:00
|
|
|
#include "of_private.h"
|
2011-08-15 01:28:14 -06:00
|
|
|
|
2012-12-06 15:55:41 -07:00
|
|
|
LIST_HEAD(aliases_lookup);
|
2011-08-15 01:28:14 -06:00
|
|
|
|
2014-10-03 09:28:27 -06:00
|
|
|
struct device_node *of_root;
|
|
|
|
EXPORT_SYMBOL(of_root);
|
2010-02-14 07:13:55 -07:00
|
|
|
struct device_node *of_chosen;
|
2011-08-15 01:28:14 -06:00
|
|
|
struct device_node *of_aliases;
|
2014-03-28 09:12:18 -06:00
|
|
|
struct device_node *of_stdout;
|
2014-11-27 10:56:07 -07:00
|
|
|
static const char *of_stdout_options;
|
2011-08-15 01:28:14 -06:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
struct kset *of_kset;
|
2014-02-20 11:02:11 -07:00
|
|
|
|
|
|
|
/*
|
2014-07-23 17:05:06 -06:00
|
|
|
* Used to protect the of_aliases, to hold off addition of nodes to sysfs.
|
|
|
|
* This mutex must be held whenever modifications are being made to the
|
|
|
|
* device tree. The of_{attach,detach}_node() and
|
|
|
|
* of_{add,remove,update}_property() helpers make sure this happens.
|
2014-02-20 11:02:11 -07:00
|
|
|
*/
|
2014-07-04 10:58:03 -06:00
|
|
|
DEFINE_MUTEX(of_mutex);
|
2007-04-24 01:57:33 -06:00
|
|
|
|
2014-10-03 09:28:27 -06:00
|
|
|
/* use when traversing tree through the child, sibling,
|
2007-04-24 00:46:53 -06:00
|
|
|
* or parent members of struct device_node.
|
|
|
|
*/
|
2013-02-06 13:30:56 -07:00
|
|
|
DEFINE_RAW_SPINLOCK(devtree_lock);
|
2007-05-01 00:26:07 -06:00
|
|
|
|
|
|
|
int of_n_addr_cells(struct device_node *np)
|
|
|
|
{
|
2010-10-10 21:24:10 -06:00
|
|
|
const __be32 *ip;
|
2007-05-01 00:26:07 -06:00
|
|
|
|
|
|
|
do {
|
|
|
|
if (np->parent)
|
|
|
|
np = np->parent;
|
|
|
|
ip = of_get_property(np, "#address-cells", NULL);
|
|
|
|
if (ip)
|
2010-01-30 01:45:26 -07:00
|
|
|
return be32_to_cpup(ip);
|
2007-05-01 00:26:07 -06:00
|
|
|
} while (np->parent);
|
|
|
|
/* No #address-cells property for the root node */
|
|
|
|
return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_n_addr_cells);
|
|
|
|
|
|
|
|
int of_n_size_cells(struct device_node *np)
|
|
|
|
{
|
2010-10-10 21:24:10 -06:00
|
|
|
const __be32 *ip;
|
2007-05-01 00:26:07 -06:00
|
|
|
|
|
|
|
do {
|
|
|
|
if (np->parent)
|
|
|
|
np = np->parent;
|
|
|
|
ip = of_get_property(np, "#size-cells", NULL);
|
|
|
|
if (ip)
|
2010-01-30 01:45:26 -07:00
|
|
|
return be32_to_cpup(ip);
|
2007-05-01 00:26:07 -06:00
|
|
|
} while (np->parent);
|
|
|
|
/* No #size-cells property for the root node */
|
|
|
|
return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_n_size_cells);
|
|
|
|
|
2013-09-17 09:42:50 -06:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
int __weak of_node_to_nid(struct device_node *np)
|
|
|
|
{
|
2015-04-08 10:59:20 -06:00
|
|
|
return NUMA_NO_NODE;
|
2013-09-17 09:42:50 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-06-26 08:40:48 -06:00
|
|
|
#ifndef CONFIG_OF_DYNAMIC
|
2014-02-20 11:02:11 -07:00
|
|
|
static void of_node_release(struct kobject *kobj)
|
|
|
|
{
|
|
|
|
/* Without CONFIG_OF_DYNAMIC, no nodes gets freed */
|
|
|
|
}
|
2012-02-15 20:38:40 -07:00
|
|
|
#endif /* CONFIG_OF_DYNAMIC */
|
2010-01-28 13:52:53 -07:00
|
|
|
|
2014-02-20 11:02:11 -07:00
|
|
|
struct kobj_type of_node_ktype = {
|
|
|
|
.release = of_node_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t of_node_property_read(struct file *filp, struct kobject *kobj,
|
|
|
|
struct bin_attribute *bin_attr, char *buf,
|
|
|
|
loff_t offset, size_t count)
|
|
|
|
{
|
|
|
|
struct property *pp = container_of(bin_attr, struct property, attr);
|
|
|
|
return memory_read_from_buffer(buf, count, &offset, pp->value, pp->length);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *safe_name(struct kobject *kobj, const char *orig_name)
|
|
|
|
{
|
|
|
|
const char *name = orig_name;
|
|
|
|
struct kernfs_node *kn;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
/* don't be a hero. After 16 tries give up */
|
|
|
|
while (i < 16 && (kn = sysfs_get_dirent(kobj->sd, name))) {
|
|
|
|
sysfs_put(kn);
|
|
|
|
if (name != orig_name)
|
|
|
|
kfree(name);
|
|
|
|
name = kasprintf(GFP_KERNEL, "%s#%i", orig_name, ++i);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (name != orig_name)
|
|
|
|
pr_warn("device-tree: Duplicate name in %s, renamed to \"%s\"\n",
|
|
|
|
kobject_name(kobj), name);
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
int __of_add_property_sysfs(struct device_node *np, struct property *pp)
|
2014-02-20 11:02:11 -07:00
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* Important: Don't leak passwords */
|
|
|
|
bool secure = strncmp(pp->name, "security-", 9) == 0;
|
|
|
|
|
2014-09-05 10:56:13 -06:00
|
|
|
if (!IS_ENABLED(CONFIG_SYSFS))
|
|
|
|
return 0;
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
if (!of_kset || !of_node_is_attached(np))
|
|
|
|
return 0;
|
|
|
|
|
2014-02-20 11:02:11 -07:00
|
|
|
sysfs_bin_attr_init(&pp->attr);
|
|
|
|
pp->attr.attr.name = safe_name(&np->kobj, pp->name);
|
|
|
|
pp->attr.attr.mode = secure ? S_IRUSR : S_IRUGO;
|
|
|
|
pp->attr.size = secure ? 0 : pp->length;
|
|
|
|
pp->attr.read = of_node_property_read;
|
|
|
|
|
|
|
|
rc = sysfs_create_bin_file(&np->kobj, &pp->attr);
|
|
|
|
WARN(rc, "error adding attribute %s to node %s\n", pp->name, np->full_name);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
int __of_attach_node_sysfs(struct device_node *np)
|
2014-02-20 11:02:11 -07:00
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
struct property *pp;
|
|
|
|
int rc;
|
|
|
|
|
2014-09-05 10:56:13 -06:00
|
|
|
if (!IS_ENABLED(CONFIG_SYSFS))
|
|
|
|
return 0;
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
if (!of_kset)
|
|
|
|
return 0;
|
|
|
|
|
2014-02-20 11:02:11 -07:00
|
|
|
np->kobj.kset = of_kset;
|
|
|
|
if (!np->parent) {
|
|
|
|
/* Nodes without parents are new top level trees */
|
2014-06-10 10:57:00 -06:00
|
|
|
rc = kobject_add(&np->kobj, NULL, "%s",
|
|
|
|
safe_name(&of_kset->kobj, "base"));
|
2014-02-20 11:02:11 -07:00
|
|
|
} else {
|
|
|
|
name = safe_name(&np->parent->kobj, kbasename(np->full_name));
|
|
|
|
if (!name || !name[0])
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
rc = kobject_add(&np->kobj, &np->parent->kobj, "%s", name);
|
|
|
|
}
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
for_each_property_of_node(np, pp)
|
|
|
|
__of_add_property_sysfs(np, pp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-14 08:28:24 -06:00
|
|
|
void __init of_core_init(void)
|
2014-02-20 11:02:11 -07:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
|
|
|
|
/* Create the kset, and register existing nodes */
|
2014-07-04 10:58:03 -06:00
|
|
|
mutex_lock(&of_mutex);
|
2014-02-20 11:02:11 -07:00
|
|
|
of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj);
|
|
|
|
if (!of_kset) {
|
2014-07-04 10:58:03 -06:00
|
|
|
mutex_unlock(&of_mutex);
|
2015-05-14 08:28:24 -06:00
|
|
|
pr_err("devicetree: failed to register existing nodes\n");
|
|
|
|
return;
|
2014-02-20 11:02:11 -07:00
|
|
|
}
|
|
|
|
for_each_of_allnodes(np)
|
2014-07-23 17:05:06 -06:00
|
|
|
__of_attach_node_sysfs(np);
|
2014-07-04 10:58:03 -06:00
|
|
|
mutex_unlock(&of_mutex);
|
2014-02-20 11:02:11 -07:00
|
|
|
|
2012-11-06 14:03:27 -07:00
|
|
|
/* Symlink in /proc as required by userspace ABI */
|
2014-10-03 09:28:27 -06:00
|
|
|
if (of_root)
|
2014-02-20 11:02:11 -07:00
|
|
|
proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
|
|
|
|
}
|
|
|
|
|
2013-01-25 11:21:47 -07:00
|
|
|
static struct property *__of_find_property(const struct device_node *np,
|
|
|
|
const char *name, int *lenp)
|
2007-04-24 00:46:53 -06:00
|
|
|
{
|
|
|
|
struct property *pp;
|
|
|
|
|
2008-05-07 13:19:59 -06:00
|
|
|
if (!np)
|
|
|
|
return NULL;
|
|
|
|
|
2012-06-26 22:14:45 -06:00
|
|
|
for (pp = np->properties; pp; pp = pp->next) {
|
2007-04-24 00:46:53 -06:00
|
|
|
if (of_prop_cmp(pp->name, name) == 0) {
|
2012-06-26 22:14:45 -06:00
|
|
|
if (lenp)
|
2007-04-24 00:46:53 -06:00
|
|
|
*lenp = pp->length;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-01-25 11:21:47 -07:00
|
|
|
|
|
|
|
return pp;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct property *of_find_property(const struct device_node *np,
|
|
|
|
const char *name,
|
|
|
|
int *lenp)
|
|
|
|
{
|
|
|
|
struct property *pp;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2013-01-25 11:21:47 -07:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2013-01-25 11:21:47 -07:00
|
|
|
pp = __of_find_property(np, name, lenp);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2007-04-24 00:46:53 -06:00
|
|
|
|
|
|
|
return pp;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_property);
|
|
|
|
|
2014-10-03 09:28:27 -06:00
|
|
|
struct device_node *__of_find_all_nodes(struct device_node *prev)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
if (!prev) {
|
|
|
|
np = of_root;
|
|
|
|
} else if (prev->child) {
|
|
|
|
np = prev->child;
|
|
|
|
} else {
|
|
|
|
/* Walk back up looking for a sibling, or the end of the structure */
|
|
|
|
np = prev;
|
|
|
|
while (np->parent && !np->sibling)
|
|
|
|
np = np->parent;
|
|
|
|
np = np->sibling; /* Might be null at the end of the tree */
|
|
|
|
}
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
|
2009-10-15 10:58:09 -06:00
|
|
|
/**
|
|
|
|
* of_find_all_nodes - Get next node in global list
|
|
|
|
* @prev: Previous node or NULL to start iteration
|
|
|
|
* of_node_put() will be called on it
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_all_nodes(struct device_node *prev)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
2013-06-11 23:39:04 -06:00
|
|
|
unsigned long flags;
|
2009-10-15 10:58:09 -06:00
|
|
|
|
2013-06-11 23:39:04 -06:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-10-03 09:28:27 -06:00
|
|
|
np = __of_find_all_nodes(prev);
|
|
|
|
of_node_get(np);
|
2009-10-15 10:58:09 -06:00
|
|
|
of_node_put(prev);
|
2013-06-11 23:39:04 -06:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2009-10-15 10:58:09 -06:00
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_all_nodes);
|
|
|
|
|
2013-01-25 11:21:47 -07:00
|
|
|
/*
|
|
|
|
* Find a property with a given name for a given node
|
|
|
|
* and return the value.
|
|
|
|
*/
|
2014-07-15 23:25:43 -06:00
|
|
|
const void *__of_get_property(const struct device_node *np,
|
|
|
|
const char *name, int *lenp)
|
2013-01-25 11:21:47 -07:00
|
|
|
{
|
|
|
|
struct property *pp = __of_find_property(np, name, lenp);
|
|
|
|
|
|
|
|
return pp ? pp->value : NULL;
|
|
|
|
}
|
|
|
|
|
2007-05-01 00:26:07 -06:00
|
|
|
/*
|
|
|
|
* 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,
|
2013-01-25 11:21:47 -07:00
|
|
|
int *lenp)
|
2007-05-01 00:26:07 -06:00
|
|
|
{
|
|
|
|
struct property *pp = of_find_property(np, name, lenp);
|
|
|
|
|
|
|
|
return pp ? pp->value : NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_property);
|
2007-05-01 00:29:19 -06:00
|
|
|
|
2013-08-15 07:01:40 -06:00
|
|
|
/*
|
|
|
|
* arch_match_cpu_phys_id - Match the given logical CPU and physical id
|
|
|
|
*
|
|
|
|
* @cpu: logical cpu index of a core/thread
|
|
|
|
* @phys_id: physical identifier of a core/thread
|
|
|
|
*
|
|
|
|
* CPU logical to physical index mapping is architecture specific.
|
|
|
|
* However this __weak function provides a default match of physical
|
|
|
|
* id to logical cpu index. phys_id provided here is usually values read
|
|
|
|
* from the device tree which must match the hardware internal registers.
|
|
|
|
*
|
|
|
|
* Returns true if the physical identifier and the logical cpu index
|
|
|
|
* correspond to the same core/thread, false otherwise.
|
|
|
|
*/
|
|
|
|
bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id)
|
|
|
|
{
|
|
|
|
return (u32)phys_id == cpu;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if the given "prop_name" property holds the physical id of the
|
|
|
|
* core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
|
|
|
|
* NULL, local thread number within the core is returned in it.
|
|
|
|
*/
|
|
|
|
static bool __of_find_n_match_cpu_property(struct device_node *cpun,
|
|
|
|
const char *prop_name, int cpu, unsigned int *thread)
|
|
|
|
{
|
|
|
|
const __be32 *cell;
|
|
|
|
int ac, prop_len, tid;
|
|
|
|
u64 hwid;
|
|
|
|
|
|
|
|
ac = of_n_addr_cells(cpun);
|
|
|
|
cell = of_get_property(cpun, prop_name, &prop_len);
|
2013-10-04 10:24:26 -06:00
|
|
|
if (!cell || !ac)
|
2013-08-15 07:01:40 -06:00
|
|
|
return false;
|
2013-10-04 10:24:26 -06:00
|
|
|
prop_len /= sizeof(*cell) * ac;
|
2013-08-15 07:01:40 -06:00
|
|
|
for (tid = 0; tid < prop_len; tid++) {
|
|
|
|
hwid = of_read_number(cell, ac);
|
|
|
|
if (arch_match_cpu_phys_id(cpu, hwid)) {
|
|
|
|
if (thread)
|
|
|
|
*thread = tid;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
cell += ac;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-10-03 15:24:51 -06:00
|
|
|
/*
|
|
|
|
* arch_find_n_match_cpu_physical_id - See if the given device node is
|
|
|
|
* for the cpu corresponding to logical cpu 'cpu'. Return true if so,
|
|
|
|
* else false. If 'thread' is non-NULL, the local thread number within the
|
|
|
|
* core is returned in it.
|
|
|
|
*/
|
|
|
|
bool __weak arch_find_n_match_cpu_physical_id(struct device_node *cpun,
|
|
|
|
int cpu, unsigned int *thread)
|
|
|
|
{
|
|
|
|
/* Check for non-standard "ibm,ppc-interrupt-server#s" property
|
|
|
|
* for thread ids on PowerPC. If it doesn't exist fallback to
|
|
|
|
* standard "reg" property.
|
|
|
|
*/
|
|
|
|
if (IS_ENABLED(CONFIG_PPC) &&
|
|
|
|
__of_find_n_match_cpu_property(cpun,
|
|
|
|
"ibm,ppc-interrupt-server#s",
|
|
|
|
cpu, thread))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (__of_find_n_match_cpu_property(cpun, "reg", cpu, thread))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-08-15 07:01:40 -06:00
|
|
|
/**
|
|
|
|
* of_get_cpu_node - Get device node associated with the given logical CPU
|
|
|
|
*
|
|
|
|
* @cpu: CPU number(logical index) for which device node is required
|
|
|
|
* @thread: if not NULL, local thread number within the physical core is
|
|
|
|
* returned
|
|
|
|
*
|
|
|
|
* The main purpose of this function is to retrieve the device node for the
|
|
|
|
* given logical CPU index. It should be used to initialize the of_node in
|
|
|
|
* cpu device. Once of_node in cpu device is populated, all the further
|
|
|
|
* references can use that instead.
|
|
|
|
*
|
|
|
|
* CPU logical to physical index mapping is architecture specific and is built
|
|
|
|
* before booting secondary cores. This function uses arch_match_cpu_phys_id
|
|
|
|
* which can be overridden by architecture specific implementation.
|
|
|
|
*
|
|
|
|
* Returns a node pointer for the logical cpu if found, else NULL.
|
|
|
|
*/
|
|
|
|
struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
|
|
|
|
{
|
2013-10-03 15:24:51 -06:00
|
|
|
struct device_node *cpun;
|
2013-08-15 07:01:40 -06:00
|
|
|
|
2013-10-03 15:24:51 -06:00
|
|
|
for_each_node_by_type(cpun, "cpu") {
|
|
|
|
if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread))
|
2013-08-15 07:01:40 -06:00
|
|
|
return cpun;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_cpu_node);
|
|
|
|
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
/**
|
|
|
|
* __of_device_is_compatible() - Check if the node matches given constraints
|
|
|
|
* @device: pointer to node
|
|
|
|
* @compat: required compatible string, NULL or "" for any match
|
|
|
|
* @type: required device_type value, NULL or "" for any match
|
|
|
|
* @name: required node name, NULL or "" for any match
|
|
|
|
*
|
|
|
|
* Checks if the given @compat, @type and @name strings match the
|
|
|
|
* properties of the given @device. A constraints can be skipped by
|
|
|
|
* passing NULL or an empty string as the constraint.
|
|
|
|
*
|
|
|
|
* Returns 0 for no match, and a positive integer on match. The return
|
|
|
|
* value is a relative score with larger values indicating better
|
|
|
|
* matches. The score is weighted for the most specific compatible value
|
|
|
|
* to get the highest score. Matching type is next, followed by matching
|
|
|
|
* name. Practically speaking, this results in the following priority
|
|
|
|
* order for matches:
|
|
|
|
*
|
|
|
|
* 1. specific compatible && type && name
|
|
|
|
* 2. specific compatible && type
|
|
|
|
* 3. specific compatible && name
|
|
|
|
* 4. specific compatible
|
|
|
|
* 5. general compatible && type && name
|
|
|
|
* 6. general compatible && type
|
|
|
|
* 7. general compatible && name
|
|
|
|
* 8. general compatible
|
|
|
|
* 9. type && name
|
|
|
|
* 10. type
|
|
|
|
* 11. name
|
2007-05-01 00:29:19 -06:00
|
|
|
*/
|
2013-01-25 11:21:47 -07:00
|
|
|
static int __of_device_is_compatible(const struct device_node *device,
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
const char *compat, const char *type, const char *name)
|
|
|
|
{
|
|
|
|
struct property *prop;
|
|
|
|
const char *cp;
|
|
|
|
int index = 0, score = 0;
|
|
|
|
|
|
|
|
/* Compatible match has highest priority */
|
|
|
|
if (compat && compat[0]) {
|
|
|
|
prop = __of_find_property(device, "compatible", NULL);
|
|
|
|
for (cp = of_prop_next_string(prop, NULL); cp;
|
|
|
|
cp = of_prop_next_string(prop, cp), index++) {
|
|
|
|
if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
|
|
|
|
score = INT_MAX/2 - (index << 2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!score)
|
|
|
|
return 0;
|
|
|
|
}
|
2007-05-01 00:29:19 -06:00
|
|
|
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
/* Matching type is better than matching name */
|
|
|
|
if (type && type[0]) {
|
|
|
|
if (!device->type || of_node_cmp(type, device->type))
|
|
|
|
return 0;
|
|
|
|
score += 2;
|
2007-05-01 00:29:19 -06:00
|
|
|
}
|
|
|
|
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
/* Matching name is a bit better than not */
|
|
|
|
if (name && name[0]) {
|
|
|
|
if (!device->name || of_node_cmp(name, device->name))
|
|
|
|
return 0;
|
|
|
|
score++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return score;
|
2007-05-01 00:29:19 -06:00
|
|
|
}
|
2013-01-25 11:21:47 -07:00
|
|
|
|
|
|
|
/** 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)
|
|
|
|
{
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2013-01-25 11:21:47 -07:00
|
|
|
int res;
|
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
res = __of_device_is_compatible(device, compat, NULL, NULL);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2013-01-25 11:21:47 -07:00
|
|
|
return res;
|
|
|
|
}
|
2007-05-01 00:29:19 -06:00
|
|
|
EXPORT_SYMBOL(of_device_is_compatible);
|
2007-04-24 01:16:16 -06:00
|
|
|
|
2010-01-28 13:47:25 -07:00
|
|
|
/**
|
2010-02-01 21:34:14 -07:00
|
|
|
* of_machine_is_compatible - Test root of device tree for a given compatible value
|
2010-01-28 13:47:25 -07:00
|
|
|
* @compat: compatible string to look for in root node's compatible property.
|
|
|
|
*
|
2014-11-12 13:54:00 -07:00
|
|
|
* Returns a positive integer if the root node has the given value in its
|
2010-01-28 13:47:25 -07:00
|
|
|
* compatible property.
|
|
|
|
*/
|
2010-02-01 21:34:14 -07:00
|
|
|
int of_machine_is_compatible(const char *compat)
|
2010-01-28 13:47:25 -07:00
|
|
|
{
|
|
|
|
struct device_node *root;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
root = of_find_node_by_path("/");
|
|
|
|
if (root) {
|
|
|
|
rc = of_device_is_compatible(root, compat);
|
|
|
|
of_node_put(root);
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
2010-02-01 21:34:14 -07:00
|
|
|
EXPORT_SYMBOL(of_machine_is_compatible);
|
2010-01-28 13:47:25 -07:00
|
|
|
|
2008-03-26 07:33:14 -06:00
|
|
|
/**
|
2013-02-11 14:15:32 -07:00
|
|
|
* __of_device_is_available - check if a device is available for use
|
2008-03-26 07:33:14 -06:00
|
|
|
*
|
2013-02-11 14:15:32 -07:00
|
|
|
* @device: Node to check for availability, with locks already held
|
2008-03-26 07:33:14 -06:00
|
|
|
*
|
2014-11-12 13:54:01 -07:00
|
|
|
* Returns true if the status property is absent or set to "okay" or "ok",
|
|
|
|
* false otherwise
|
2008-03-26 07:33:14 -06:00
|
|
|
*/
|
2014-11-12 13:54:01 -07:00
|
|
|
static bool __of_device_is_available(const struct device_node *device)
|
2008-03-26 07:33:14 -06:00
|
|
|
{
|
|
|
|
const char *status;
|
|
|
|
int statlen;
|
|
|
|
|
of: Fix __of_device_is_available check
From IEEE 1275, there defined a standard 'status' property indicating the
operational status of one device. The 'status' property has four possible
values: 'okay/ok', 'disabled', 'fail' and 'fail-xxx'.
If it is absent, that means the status of the device is unknown or okay.
The __of_device_is_available checks the state of the 'status' property of
a device. If the property is absent or set to 'okay/ok', it returns 1.
Otherwise it returns 0.
While in __of_device_is_available:
> status = of_get_property(device, "status", &statlen);
> if (status == NULL)
> return 1;
The status value returned from 'of_get_property()' will be NULL in two cases:
Firstly: the 'device' value (device node) is NULL.
Secondly: the 'status' property is actaully not exist.
If the device node is NULL, the __of_device_is_available will return true,
that will mean the absent state of the 'status' property.
So this add the device node check before checking the 'status' property's
state, and if the device node is not exist, 0 will be returned.
Signed-off-by: Xiubo Li <Li.Xiubo@freescale.com>
Signed-off-by: Grant Likely <grant.likely@linaro.org>
2014-01-12 20:07:28 -07:00
|
|
|
if (!device)
|
2014-11-12 13:54:01 -07:00
|
|
|
return false;
|
of: Fix __of_device_is_available check
From IEEE 1275, there defined a standard 'status' property indicating the
operational status of one device. The 'status' property has four possible
values: 'okay/ok', 'disabled', 'fail' and 'fail-xxx'.
If it is absent, that means the status of the device is unknown or okay.
The __of_device_is_available checks the state of the 'status' property of
a device. If the property is absent or set to 'okay/ok', it returns 1.
Otherwise it returns 0.
While in __of_device_is_available:
> status = of_get_property(device, "status", &statlen);
> if (status == NULL)
> return 1;
The status value returned from 'of_get_property()' will be NULL in two cases:
Firstly: the 'device' value (device node) is NULL.
Secondly: the 'status' property is actaully not exist.
If the device node is NULL, the __of_device_is_available will return true,
that will mean the absent state of the 'status' property.
So this add the device node check before checking the 'status' property's
state, and if the device node is not exist, 0 will be returned.
Signed-off-by: Xiubo Li <Li.Xiubo@freescale.com>
Signed-off-by: Grant Likely <grant.likely@linaro.org>
2014-01-12 20:07:28 -07:00
|
|
|
|
2013-02-11 14:15:32 -07:00
|
|
|
status = __of_get_property(device, "status", &statlen);
|
2008-03-26 07:33:14 -06:00
|
|
|
if (status == NULL)
|
2014-11-12 13:54:01 -07:00
|
|
|
return true;
|
2008-03-26 07:33:14 -06:00
|
|
|
|
|
|
|
if (statlen > 0) {
|
|
|
|
if (!strcmp(status, "okay") || !strcmp(status, "ok"))
|
2014-11-12 13:54:01 -07:00
|
|
|
return true;
|
2008-03-26 07:33:14 -06:00
|
|
|
}
|
|
|
|
|
2014-11-12 13:54:01 -07:00
|
|
|
return false;
|
2008-03-26 07:33:14 -06:00
|
|
|
}
|
2013-02-11 14:15:32 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_device_is_available - check if a device is available for use
|
|
|
|
*
|
|
|
|
* @device: Node to check for availability
|
|
|
|
*
|
2014-11-12 13:54:01 -07:00
|
|
|
* Returns true if the status property is absent or set to "okay" or "ok",
|
|
|
|
* false otherwise
|
2013-02-11 14:15:32 -07:00
|
|
|
*/
|
2014-11-12 13:54:01 -07:00
|
|
|
bool of_device_is_available(const struct device_node *device)
|
2013-02-11 14:15:32 -07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2014-11-12 13:54:01 -07:00
|
|
|
bool res;
|
2013-02-11 14:15:32 -07:00
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
|
|
|
res = __of_device_is_available(device);
|
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
|
|
|
return res;
|
|
|
|
|
|
|
|
}
|
2008-03-26 07:33:14 -06:00
|
|
|
EXPORT_SYMBOL(of_device_is_available);
|
|
|
|
|
2015-04-09 14:05:14 -06:00
|
|
|
/**
|
|
|
|
* of_device_is_big_endian - check if a device has BE registers
|
|
|
|
*
|
|
|
|
* @device: Node to check for endianness
|
|
|
|
*
|
|
|
|
* Returns true if the device has a "big-endian" property, or if the kernel
|
|
|
|
* was compiled for BE *and* the device has a "native-endian" property.
|
|
|
|
* Returns false otherwise.
|
|
|
|
*
|
|
|
|
* Callers would nominally use ioread32be/iowrite32be if
|
|
|
|
* of_device_is_big_endian() == true, or readl/writel otherwise.
|
|
|
|
*/
|
|
|
|
bool of_device_is_big_endian(const struct device_node *device)
|
|
|
|
{
|
|
|
|
if (of_property_read_bool(device, "big-endian"))
|
|
|
|
return true;
|
|
|
|
if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) &&
|
|
|
|
of_property_read_bool(device, "native-endian"))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_device_is_big_endian);
|
|
|
|
|
2007-04-24 01:16:16 -06:00
|
|
|
/**
|
|
|
|
* of_get_parent - Get a node's parent if any
|
|
|
|
* @node: Node to get parent
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_get_parent(const struct device_node *node)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2007-04-24 01:16:16 -06:00
|
|
|
|
|
|
|
if (!node)
|
|
|
|
return NULL;
|
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2007-04-24 01:16:16 -06:00
|
|
|
np = of_node_get(node->parent);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2007-04-24 01:16:16 -06:00
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_parent);
|
2007-04-24 01:21:29 -06:00
|
|
|
|
2007-10-26 00:54:31 -06:00
|
|
|
/**
|
|
|
|
* of_get_next_parent - Iterate to a node's parent
|
|
|
|
* @node: Node to get parent of
|
|
|
|
*
|
2014-10-22 03:44:55 -06:00
|
|
|
* This is like of_get_parent() except that it drops the
|
|
|
|
* refcount on the passed node, making it suitable for iterating
|
|
|
|
* through a node's parents.
|
2007-10-26 00:54:31 -06:00
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_get_next_parent(struct device_node *node)
|
|
|
|
{
|
|
|
|
struct device_node *parent;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2007-10-26 00:54:31 -06:00
|
|
|
|
|
|
|
if (!node)
|
|
|
|
return NULL;
|
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2007-10-26 00:54:31 -06:00
|
|
|
parent = of_node_get(node->parent);
|
|
|
|
of_node_put(node);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2007-10-26 00:54:31 -06:00
|
|
|
return parent;
|
|
|
|
}
|
2013-04-02 09:28:11 -06:00
|
|
|
EXPORT_SYMBOL(of_get_next_parent);
|
2007-10-26 00:54:31 -06:00
|
|
|
|
2014-05-21 10:04:17 -06:00
|
|
|
static struct device_node *__of_get_next_child(const struct device_node *node,
|
|
|
|
struct device_node *prev)
|
|
|
|
{
|
|
|
|
struct device_node *next;
|
|
|
|
|
2014-05-28 11:39:02 -06:00
|
|
|
if (!node)
|
|
|
|
return NULL;
|
|
|
|
|
2014-05-21 10:04:17 -06:00
|
|
|
next = prev ? prev->sibling : node->child;
|
|
|
|
for (; next; next = next->sibling)
|
|
|
|
if (of_node_get(next))
|
|
|
|
break;
|
|
|
|
of_node_put(prev);
|
|
|
|
return next;
|
|
|
|
}
|
|
|
|
#define __for_each_child_of_node(parent, child) \
|
|
|
|
for (child = __of_get_next_child(parent, NULL); child != NULL; \
|
|
|
|
child = __of_get_next_child(parent, child))
|
|
|
|
|
2007-04-24 01:21:29 -06:00
|
|
|
/**
|
|
|
|
* of_get_next_child - Iterate a node childs
|
|
|
|
* @node: parent node
|
|
|
|
* @prev: previous child of the parent node, or NULL to get first
|
|
|
|
*
|
2015-03-19 06:03:41 -06:00
|
|
|
* Returns a node pointer with refcount incremented, use of_node_put() on
|
|
|
|
* it when done. Returns NULL when prev is the last child. Decrements the
|
|
|
|
* refcount of prev.
|
2007-04-24 01:21:29 -06:00
|
|
|
*/
|
|
|
|
struct device_node *of_get_next_child(const struct device_node *node,
|
|
|
|
struct device_node *prev)
|
|
|
|
{
|
|
|
|
struct device_node *next;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2007-04-24 01:21:29 -06:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-05-21 10:04:17 -06:00
|
|
|
next = __of_get_next_child(node, prev);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2007-04-24 01:21:29 -06:00
|
|
|
return next;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_next_child);
|
2007-04-24 01:57:33 -06:00
|
|
|
|
2012-08-14 07:20:23 -06:00
|
|
|
/**
|
|
|
|
* of_get_next_available_child - Find the next available child node
|
|
|
|
* @node: parent node
|
|
|
|
* @prev: previous child of the parent node, or NULL to get first
|
|
|
|
*
|
|
|
|
* This function is like of_get_next_child(), except that it
|
|
|
|
* automatically skips any disabled nodes (i.e. status = "disabled").
|
|
|
|
*/
|
|
|
|
struct device_node *of_get_next_available_child(const struct device_node *node,
|
|
|
|
struct device_node *prev)
|
|
|
|
{
|
|
|
|
struct device_node *next;
|
2013-06-11 23:39:04 -06:00
|
|
|
unsigned long flags;
|
2012-08-14 07:20:23 -06:00
|
|
|
|
2014-05-28 11:39:02 -06:00
|
|
|
if (!node)
|
|
|
|
return NULL;
|
|
|
|
|
2013-06-11 23:39:04 -06:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2012-08-14 07:20:23 -06:00
|
|
|
next = prev ? prev->sibling : node->child;
|
|
|
|
for (; next; next = next->sibling) {
|
2013-02-11 14:15:32 -07:00
|
|
|
if (!__of_device_is_available(next))
|
2012-08-14 07:20:23 -06:00
|
|
|
continue;
|
|
|
|
if (of_node_get(next))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
of_node_put(prev);
|
2013-06-11 23:39:04 -06:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2012-08-14 07:20:23 -06:00
|
|
|
return next;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_next_available_child);
|
|
|
|
|
2012-09-18 01:10:28 -06:00
|
|
|
/**
|
|
|
|
* of_get_child_by_name - Find the child node by name for a given parent
|
|
|
|
* @node: parent node
|
|
|
|
* @name: child name to look for.
|
|
|
|
*
|
|
|
|
* This function looks for child node for given matching name
|
|
|
|
*
|
|
|
|
* Returns a node pointer if found, with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
* Returns NULL if node is not found.
|
|
|
|
*/
|
|
|
|
struct device_node *of_get_child_by_name(const struct device_node *node,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct device_node *child;
|
|
|
|
|
|
|
|
for_each_child_of_node(node, child)
|
|
|
|
if (child->name && (of_node_cmp(child->name, name) == 0))
|
|
|
|
break;
|
|
|
|
return child;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_child_by_name);
|
|
|
|
|
2014-03-14 11:07:12 -06:00
|
|
|
static struct device_node *__of_find_node_by_path(struct device_node *parent,
|
|
|
|
const char *path)
|
|
|
|
{
|
|
|
|
struct device_node *child;
|
2015-03-06 09:52:53 -07:00
|
|
|
int len;
|
2014-03-14 11:07:12 -06:00
|
|
|
|
2015-03-17 13:30:31 -06:00
|
|
|
len = strcspn(path, "/:");
|
2014-03-14 11:07:12 -06:00
|
|
|
if (!len)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
__for_each_child_of_node(parent, child) {
|
|
|
|
const char *name = strrchr(child->full_name, '/');
|
|
|
|
if (WARN(!name, "malformed device_node %s\n", child->full_name))
|
|
|
|
continue;
|
|
|
|
name++;
|
|
|
|
if (strncmp(path, name, len) == 0 && (strlen(name) == len))
|
|
|
|
return child;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-04-24 01:57:33 -06:00
|
|
|
/**
|
2014-11-28 04:34:28 -07:00
|
|
|
* of_find_node_opts_by_path - Find a node matching a full OF path
|
2014-03-14 11:07:12 -06:00
|
|
|
* @path: Either the full path to match, or if the path does not
|
|
|
|
* start with '/', the name of a property of the /aliases
|
|
|
|
* node (an alias). In the case of an alias, the node
|
|
|
|
* matching the alias' value will be returned.
|
2014-11-28 04:34:28 -07:00
|
|
|
* @opts: Address of a pointer into which to store the start of
|
|
|
|
* an options string appended to the end of the path with
|
|
|
|
* a ':' separator.
|
2014-03-14 11:07:12 -06:00
|
|
|
*
|
|
|
|
* Valid paths:
|
|
|
|
* /foo/bar Full path
|
|
|
|
* foo Valid alias
|
|
|
|
* foo/bar Valid alias + relative path
|
2007-04-24 01:57:33 -06:00
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
2014-11-28 04:34:28 -07:00
|
|
|
struct device_node *of_find_node_opts_by_path(const char *path, const char **opts)
|
2007-04-24 01:57:33 -06:00
|
|
|
{
|
2014-03-14 11:07:12 -06:00
|
|
|
struct device_node *np = NULL;
|
|
|
|
struct property *pp;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2014-11-28 04:34:28 -07:00
|
|
|
const char *separator = strchr(path, ':');
|
|
|
|
|
|
|
|
if (opts)
|
|
|
|
*opts = separator ? separator + 1 : NULL;
|
2007-04-24 01:57:33 -06:00
|
|
|
|
2014-03-14 11:07:12 -06:00
|
|
|
if (strcmp(path, "/") == 0)
|
2014-10-03 09:28:27 -06:00
|
|
|
return of_node_get(of_root);
|
2014-03-14 11:07:12 -06:00
|
|
|
|
|
|
|
/* The path could begin with an alias */
|
|
|
|
if (*path != '/') {
|
2015-03-06 09:52:53 -07:00
|
|
|
int len;
|
|
|
|
const char *p = separator;
|
|
|
|
|
|
|
|
if (!p)
|
|
|
|
p = strchrnul(path, '/');
|
|
|
|
len = p - path;
|
2014-03-14 11:07:12 -06:00
|
|
|
|
|
|
|
/* of_aliases must not be NULL */
|
|
|
|
if (!of_aliases)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
for_each_property_of_node(of_aliases, pp) {
|
|
|
|
if (strlen(pp->name) == len && !strncmp(pp->name, path, len)) {
|
|
|
|
np = of_find_node_by_path(pp->value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!np)
|
|
|
|
return NULL;
|
|
|
|
path = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Step down the tree matching path components */
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-03-14 11:07:12 -06:00
|
|
|
if (!np)
|
2014-10-03 09:28:27 -06:00
|
|
|
np = of_node_get(of_root);
|
2014-03-14 11:07:12 -06:00
|
|
|
while (np && *path == '/') {
|
|
|
|
path++; /* Increment past '/' delimiter */
|
|
|
|
np = __of_find_node_by_path(np, path);
|
|
|
|
path = strchrnul(path, '/');
|
2015-03-06 09:52:53 -07:00
|
|
|
if (separator && separator < path)
|
|
|
|
break;
|
2007-04-24 01:57:33 -06:00
|
|
|
}
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2007-04-24 01:57:33 -06:00
|
|
|
return np;
|
|
|
|
}
|
2014-11-28 04:34:28 -07:00
|
|
|
EXPORT_SYMBOL(of_find_node_opts_by_path);
|
2007-04-24 01:57:33 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_find_node_by_name - Find a node by its "name" property
|
|
|
|
* @from: The node to start searching from or NULL, the node
|
|
|
|
* you pass will not be searched, only the next one
|
|
|
|
* will; typically, you pass what the previous call
|
|
|
|
* returned. of_node_put() will be called on it
|
|
|
|
* @name: The name string to match against
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_node_by_name(struct device_node *from,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2007-04-24 01:57:33 -06:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-10-03 09:28:27 -06:00
|
|
|
for_each_of_allnodes_from(from, np)
|
2007-04-24 01:57:33 -06:00
|
|
|
if (np->name && (of_node_cmp(np->name, name) == 0)
|
|
|
|
&& of_node_get(np))
|
|
|
|
break;
|
|
|
|
of_node_put(from);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2007-04-24 01:57:33 -06:00
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_node_by_name);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_find_node_by_type - Find a node by its "device_type" property
|
|
|
|
* @from: The node to start searching from, or NULL to start searching
|
|
|
|
* the entire device tree. The node you pass will not be
|
|
|
|
* searched, only the next one will; typically, you pass
|
|
|
|
* what the previous call returned. of_node_put() will be
|
|
|
|
* called on from for you.
|
|
|
|
* @type: The type string to match against
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_node_by_type(struct device_node *from,
|
|
|
|
const char *type)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2007-04-24 01:57:33 -06:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-10-03 09:28:27 -06:00
|
|
|
for_each_of_allnodes_from(from, np)
|
2007-04-24 01:57:33 -06:00
|
|
|
if (np->type && (of_node_cmp(np->type, type) == 0)
|
|
|
|
&& of_node_get(np))
|
|
|
|
break;
|
|
|
|
of_node_put(from);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2007-04-24 01:57:33 -06:00
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_node_by_type);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_find_compatible_node - Find a node based on type and one of the
|
|
|
|
* tokens in its "compatible" property
|
|
|
|
* @from: The node to start searching from or NULL, the node
|
|
|
|
* you pass will not be searched, only the next one
|
|
|
|
* will; typically, you pass what the previous call
|
|
|
|
* returned. of_node_put() will be called on it
|
|
|
|
* @type: The type string to match "device_type" or NULL to ignore
|
|
|
|
* @compatible: The string to match to one of the tokens in the device
|
|
|
|
* "compatible" list.
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_compatible_node(struct device_node *from,
|
|
|
|
const char *type, const char *compatible)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2007-04-24 01:57:33 -06:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-10-03 09:28:27 -06:00
|
|
|
for_each_of_allnodes_from(from, np)
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
if (__of_device_is_compatible(np, compatible, type, NULL) &&
|
2013-01-25 11:21:47 -07:00
|
|
|
of_node_get(np))
|
2007-04-24 01:57:33 -06:00
|
|
|
break;
|
|
|
|
of_node_put(from);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2007-04-24 01:57:33 -06:00
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_compatible_node);
|
2008-01-08 12:20:40 -07:00
|
|
|
|
2008-11-12 11:54:42 -07:00
|
|
|
/**
|
|
|
|
* of_find_node_with_property - Find a node which has a property with
|
|
|
|
* the given name.
|
|
|
|
* @from: The node to start searching from or NULL, the node
|
|
|
|
* you pass will not be searched, only the next one
|
|
|
|
* will; typically, you pass what the previous call
|
|
|
|
* returned. of_node_put() will be called on it
|
|
|
|
* @prop_name: The name of the property to look for.
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_node_with_property(struct device_node *from,
|
|
|
|
const char *prop_name)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct property *pp;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2008-11-12 11:54:42 -07:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-10-03 09:28:27 -06:00
|
|
|
for_each_of_allnodes_from(from, np) {
|
2012-06-26 22:14:45 -06:00
|
|
|
for (pp = np->properties; pp; pp = pp->next) {
|
2008-11-12 11:54:42 -07:00
|
|
|
if (of_prop_cmp(pp->name, prop_name) == 0) {
|
|
|
|
of_node_get(np);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
of_node_put(from);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2008-11-12 11:54:42 -07:00
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_node_with_property);
|
|
|
|
|
2013-01-25 11:21:47 -07:00
|
|
|
static
|
|
|
|
const struct of_device_id *__of_match_node(const struct of_device_id *matches,
|
|
|
|
const struct device_node *node)
|
2008-01-08 12:20:40 -07:00
|
|
|
{
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
const struct of_device_id *best_match = NULL;
|
|
|
|
int score, best_score = 0;
|
|
|
|
|
2011-03-18 10:21:29 -06:00
|
|
|
if (!matches)
|
|
|
|
return NULL;
|
|
|
|
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
|
|
|
|
score = __of_device_is_compatible(node, matches->compatible,
|
|
|
|
matches->type, matches->name);
|
|
|
|
if (score > best_score) {
|
|
|
|
best_match = matches;
|
|
|
|
best_score = score;
|
|
|
|
}
|
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.
Reported-by: Stephen N Chivers <schivers@csc.com.au>
Cc: Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
Signed-off-by: Kevin Hao <haokexin@gmail.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2014-02-13 22:22:45 -07:00
|
|
|
}
|
of: reimplement the matching method for __of_match_node()
In the current implementation of __of_match_node(), it will compare
each given match entry against all the 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, we define a following priority order for the match, and
then scan all the entries to find the best match.
1. specific compatible && type && name
2. specific compatible && type
3. specific compatible && name
4. specific compatible
5. general compatible && type && name
6. general compatible && type
7. general compatible && name
8. general compatible
9. type && name
10. type
11. name
v5: Fix nested locking bug
v4: Short-circuit failure cases instead of mucking with score, and
remove extra __of_device_is_compatible() wrapper stub.
Move scoring logic directly into __of_device_is_compatible()
v3: Also need to bail out when there does have a compatible member in match
entry, but it doesn't match with the device node's compatible.
v2: Fix the bug such as we get the same score for the following two match
entries with the empty node 'name2 { };'
struct of_device_id matches[] = {
{.name = "name2", },
{.name = "name2", .type = "type1", },
{}
};
Signed-off-by: Kevin Hao <haokexin@gmail.com>
[grant.likely: added v4 changes]
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Stephen Chivers <schivers@csc.com>
Tested-by: Sachin Kamat <sachin.kamat@linaro.org>
2014-02-19 01:15:45 -07:00
|
|
|
|
|
|
|
return best_match;
|
2008-01-08 12:20:40 -07:00
|
|
|
}
|
2013-01-25 11:21:47 -07:00
|
|
|
|
|
|
|
/**
|
2014-10-22 03:44:54 -06:00
|
|
|
* of_match_node - Tell if a device_node has a matching of_match structure
|
2013-01-25 11:21:47 -07:00
|
|
|
* @matches: array of of device match structures to search in
|
|
|
|
* @node: the of device structure to match against
|
|
|
|
*
|
2014-02-18 00:57:29 -07:00
|
|
|
* Low level utility function used by device matching.
|
2013-01-25 11:21:47 -07:00
|
|
|
*/
|
|
|
|
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;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2013-01-25 11:21:47 -07:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2013-01-25 11:21:47 -07:00
|
|
|
match = __of_match_node(matches, node);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2013-01-25 11:21:47 -07:00
|
|
|
return match;
|
|
|
|
}
|
2008-01-08 12:20:40 -07:00
|
|
|
EXPORT_SYMBOL(of_match_node);
|
|
|
|
|
|
|
|
/**
|
2012-11-20 16:12:20 -07:00
|
|
|
* of_find_matching_node_and_match - Find a node based on an of_device_id
|
|
|
|
* match table.
|
2008-01-08 12:20:40 -07:00
|
|
|
* @from: The node to start searching from or NULL, the node
|
|
|
|
* you pass will not be searched, only the next one
|
|
|
|
* will; typically, you pass what the previous call
|
|
|
|
* returned. of_node_put() will be called on it
|
|
|
|
* @matches: array of of device match structures to search in
|
2012-11-20 16:12:20 -07:00
|
|
|
* @match Updated to point at the matches entry which matched
|
2008-01-08 12:20:40 -07:00
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
2012-11-20 16:12:20 -07:00
|
|
|
struct device_node *of_find_matching_node_and_match(struct device_node *from,
|
|
|
|
const struct of_device_id *matches,
|
|
|
|
const struct of_device_id **match)
|
2008-01-08 12:20:40 -07:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
2013-01-19 11:20:42 -07:00
|
|
|
const struct of_device_id *m;
|
2013-02-06 13:30:56 -07:00
|
|
|
unsigned long flags;
|
2008-01-08 12:20:40 -07:00
|
|
|
|
2012-11-20 16:12:20 -07:00
|
|
|
if (match)
|
|
|
|
*match = NULL;
|
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-10-03 09:28:27 -06:00
|
|
|
for_each_of_allnodes_from(from, np) {
|
2013-01-25 11:21:47 -07:00
|
|
|
m = __of_match_node(matches, np);
|
2013-01-19 11:20:42 -07:00
|
|
|
if (m && of_node_get(np)) {
|
2012-11-20 16:12:20 -07:00
|
|
|
if (match)
|
2013-01-19 11:20:42 -07:00
|
|
|
*match = m;
|
2008-01-08 12:20:40 -07:00
|
|
|
break;
|
2012-11-20 16:12:20 -07:00
|
|
|
}
|
2008-01-08 12:20:40 -07:00
|
|
|
}
|
|
|
|
of_node_put(from);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2008-01-08 12:20:40 -07:00
|
|
|
return np;
|
|
|
|
}
|
2012-12-19 03:45:36 -07:00
|
|
|
EXPORT_SYMBOL(of_find_matching_node_and_match);
|
2008-07-25 20:25:13 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_modalias_node - Lookup appropriate modalias for a device node
|
|
|
|
* @node: pointer to a device tree node
|
|
|
|
* @modalias: Pointer to buffer that modalias value will be copied into
|
|
|
|
* @len: Length of modalias value
|
|
|
|
*
|
2010-06-08 07:48:19 -06:00
|
|
|
* Based on the value of the compatible property, this routine will attempt
|
|
|
|
* to choose an appropriate modalias value for a particular device tree node.
|
|
|
|
* It does this by stripping the manufacturer prefix (as delimited by a ',')
|
|
|
|
* from the first entry in the compatible list property.
|
2008-07-25 20:25:13 -06:00
|
|
|
*
|
2010-06-08 07:48:19 -06:00
|
|
|
* This routine returns 0 on success, <0 on failure.
|
2008-07-25 20:25:13 -06:00
|
|
|
*/
|
|
|
|
int of_modalias_node(struct device_node *node, char *modalias, int len)
|
|
|
|
{
|
2010-06-08 07:48:19 -06:00
|
|
|
const char *compatible, *p;
|
|
|
|
int cplen;
|
2008-07-25 20:25:13 -06:00
|
|
|
|
|
|
|
compatible = of_get_property(node, "compatible", &cplen);
|
2010-06-08 07:48:19 -06:00
|
|
|
if (!compatible || strlen(compatible) > cplen)
|
2008-07-25 20:25:13 -06:00
|
|
|
return -ENODEV;
|
|
|
|
p = strchr(compatible, ',');
|
2010-06-08 07:48:19 -06:00
|
|
|
strlcpy(modalias, p ? p + 1 : compatible, len);
|
2008-07-25 20:25:13 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_modalias_node);
|
|
|
|
|
2010-02-01 21:34:11 -07:00
|
|
|
/**
|
|
|
|
* of_find_node_by_phandle - Find a node given a phandle
|
|
|
|
* @handle: phandle of the node to find
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_node_by_phandle(phandle handle)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
2013-06-11 23:39:04 -06:00
|
|
|
unsigned long flags;
|
2010-02-01 21:34:11 -07:00
|
|
|
|
2014-10-02 06:08:02 -06:00
|
|
|
if (!handle)
|
|
|
|
return NULL;
|
|
|
|
|
2013-06-11 23:39:04 -06:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-10-03 09:28:27 -06:00
|
|
|
for_each_of_allnodes(np)
|
2010-02-01 21:34:11 -07:00
|
|
|
if (np->phandle == handle)
|
|
|
|
break;
|
|
|
|
of_node_get(np);
|
2013-06-11 23:39:04 -06:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2010-02-01 21:34:11 -07:00
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_node_by_phandle);
|
|
|
|
|
2014-02-11 17:00:34 -07:00
|
|
|
/**
|
|
|
|
* of_property_count_elems_of_size - Count the number of elements in a property
|
|
|
|
*
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
|
|
|
* @elem_size: size of the individual element
|
|
|
|
*
|
|
|
|
* Search for a property in a device node and count the number of elements of
|
|
|
|
* size elem_size in it. Returns number of elements on sucess, -EINVAL if the
|
|
|
|
* property does not exist or its length does not match a multiple of elem_size
|
|
|
|
* and -ENODATA if the property does not have a value.
|
|
|
|
*/
|
|
|
|
int of_property_count_elems_of_size(const struct device_node *np,
|
|
|
|
const char *propname, int elem_size)
|
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
if (prop->length % elem_size != 0) {
|
|
|
|
pr_err("size of %s in node %s is not a multiple of %d\n",
|
|
|
|
propname, np->full_name, elem_size);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return prop->length / elem_size;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
|
|
|
|
|
2013-04-02 22:57:11 -06:00
|
|
|
/**
|
|
|
|
* of_find_property_value_of_size
|
|
|
|
*
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
|
|
|
* @len: requested length of property value
|
|
|
|
*
|
|
|
|
* Search for a property in a device node and valid the requested size.
|
|
|
|
* Returns the property value on success, -EINVAL if the property does not
|
|
|
|
* exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
|
* property data isn't large enough.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void *of_find_property_value_of_size(const struct device_node *np,
|
|
|
|
const char *propname, u32 len)
|
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
if (!prop->value)
|
|
|
|
return ERR_PTR(-ENODATA);
|
|
|
|
if (len > prop->length)
|
|
|
|
return ERR_PTR(-EOVERFLOW);
|
|
|
|
|
|
|
|
return prop->value;
|
|
|
|
}
|
|
|
|
|
2013-03-22 22:02:15 -06:00
|
|
|
/**
|
|
|
|
* of_property_read_u32_index - Find and read a u32 from a multi-value property.
|
|
|
|
*
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
|
|
|
* @index: index of the u32 in the list of values
|
|
|
|
* @out_value: pointer to return value, modified only if no error.
|
|
|
|
*
|
|
|
|
* Search for a property in a device node and read nth 32-bit value from
|
|
|
|
* it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
|
* -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
|
* property data isn't large enough.
|
|
|
|
*
|
|
|
|
* The out_value is modified only if a valid u32 value can be decoded.
|
|
|
|
*/
|
|
|
|
int of_property_read_u32_index(const struct device_node *np,
|
|
|
|
const char *propname,
|
|
|
|
u32 index, u32 *out_value)
|
|
|
|
{
|
2013-04-02 22:57:11 -06:00
|
|
|
const u32 *val = of_find_property_value_of_size(np, propname,
|
|
|
|
((index + 1) * sizeof(*out_value)));
|
2013-03-22 22:02:15 -06:00
|
|
|
|
2013-04-02 22:57:11 -06:00
|
|
|
if (IS_ERR(val))
|
|
|
|
return PTR_ERR(val);
|
2013-03-22 22:02:15 -06:00
|
|
|
|
2013-04-02 22:57:11 -06:00
|
|
|
*out_value = be32_to_cpup(((__be32 *)val) + index);
|
2013-03-22 22:02:15 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u32_index);
|
|
|
|
|
2012-11-19 21:45:19 -07:00
|
|
|
/**
|
|
|
|
* of_property_read_u8_array - Find and read an array of u8 from a property.
|
|
|
|
*
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
2013-05-07 00:04:11 -06:00
|
|
|
* @out_values: pointer to return value, modified only if return value is 0.
|
2012-11-19 21:45:19 -07:00
|
|
|
* @sz: number of array elements to read
|
|
|
|
*
|
|
|
|
* Search for a property in a device node and read 8-bit value(s) from
|
|
|
|
* it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
|
* -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
|
* property data isn't large enough.
|
|
|
|
*
|
|
|
|
* dts entry of array should be like:
|
|
|
|
* property = /bits/ 8 <0x50 0x60 0x70>;
|
|
|
|
*
|
2013-05-07 00:04:11 -06:00
|
|
|
* The out_values is modified only if a valid u8 value can be decoded.
|
2012-11-19 21:45:19 -07:00
|
|
|
*/
|
|
|
|
int of_property_read_u8_array(const struct device_node *np,
|
|
|
|
const char *propname, u8 *out_values, size_t sz)
|
|
|
|
{
|
2013-04-02 22:57:11 -06:00
|
|
|
const u8 *val = of_find_property_value_of_size(np, propname,
|
|
|
|
(sz * sizeof(*out_values)));
|
2012-11-19 21:45:19 -07:00
|
|
|
|
2013-04-02 22:57:11 -06:00
|
|
|
if (IS_ERR(val))
|
|
|
|
return PTR_ERR(val);
|
2012-11-19 21:45:19 -07:00
|
|
|
|
|
|
|
while (sz--)
|
|
|
|
*out_values++ = *val++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u8_array);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_property_read_u16_array - Find and read an array of u16 from a property.
|
|
|
|
*
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
2013-05-07 00:04:11 -06:00
|
|
|
* @out_values: pointer to return value, modified only if return value is 0.
|
2012-11-19 21:45:19 -07:00
|
|
|
* @sz: number of array elements to read
|
|
|
|
*
|
|
|
|
* Search for a property in a device node and read 16-bit value(s) from
|
|
|
|
* it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
|
* -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
|
* property data isn't large enough.
|
|
|
|
*
|
|
|
|
* dts entry of array should be like:
|
|
|
|
* property = /bits/ 16 <0x5000 0x6000 0x7000>;
|
|
|
|
*
|
2013-05-07 00:04:11 -06:00
|
|
|
* The out_values is modified only if a valid u16 value can be decoded.
|
2012-11-19 21:45:19 -07:00
|
|
|
*/
|
|
|
|
int of_property_read_u16_array(const struct device_node *np,
|
|
|
|
const char *propname, u16 *out_values, size_t sz)
|
|
|
|
{
|
2013-04-02 22:57:11 -06:00
|
|
|
const __be16 *val = of_find_property_value_of_size(np, propname,
|
|
|
|
(sz * sizeof(*out_values)));
|
2012-11-19 21:45:19 -07:00
|
|
|
|
2013-04-02 22:57:11 -06:00
|
|
|
if (IS_ERR(val))
|
|
|
|
return PTR_ERR(val);
|
2012-11-19 21:45:19 -07:00
|
|
|
|
|
|
|
while (sz--)
|
|
|
|
*out_values++ = be16_to_cpup(val++);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u16_array);
|
|
|
|
|
2011-06-30 09:56:10 -06:00
|
|
|
/**
|
2011-07-06 14:42:58 -06:00
|
|
|
* of_property_read_u32_array - Find and read an array of 32 bit integers
|
|
|
|
* from a property.
|
|
|
|
*
|
2011-06-30 09:56:10 -06:00
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
2013-05-07 00:04:11 -06:00
|
|
|
* @out_values: pointer to return value, modified only if return value is 0.
|
2012-11-19 21:45:19 -07:00
|
|
|
* @sz: number of array elements to read
|
2011-06-30 09:56:10 -06:00
|
|
|
*
|
2011-07-06 14:42:58 -06:00
|
|
|
* Search for a property in a device node and read 32-bit value(s) from
|
2011-06-30 09:56:10 -06:00
|
|
|
* it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
|
* -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
|
* property data isn't large enough.
|
|
|
|
*
|
2013-05-07 00:04:11 -06:00
|
|
|
* The out_values is modified only if a valid u32 value can be decoded.
|
2011-06-30 09:56:10 -06:00
|
|
|
*/
|
2011-08-02 08:45:07 -06:00
|
|
|
int of_property_read_u32_array(const struct device_node *np,
|
|
|
|
const char *propname, u32 *out_values,
|
|
|
|
size_t sz)
|
2011-06-30 09:56:10 -06:00
|
|
|
{
|
2013-04-02 22:57:11 -06:00
|
|
|
const __be32 *val = of_find_property_value_of_size(np, propname,
|
|
|
|
(sz * sizeof(*out_values)));
|
2011-06-30 09:56:10 -06:00
|
|
|
|
2013-04-02 22:57:11 -06:00
|
|
|
if (IS_ERR(val))
|
|
|
|
return PTR_ERR(val);
|
2011-07-06 14:42:58 -06:00
|
|
|
|
|
|
|
while (sz--)
|
|
|
|
*out_values++ = be32_to_cpup(val++);
|
2011-06-30 09:56:10 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2011-07-06 14:42:58 -06:00
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u32_array);
|
2011-06-30 09:56:10 -06:00
|
|
|
|
2011-09-14 13:49:59 -06:00
|
|
|
/**
|
|
|
|
* of_property_read_u64 - Find and read a 64 bit integer from a property
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
|
|
|
* @out_value: pointer to return value, modified only if return value is 0.
|
|
|
|
*
|
|
|
|
* Search for a property in a device node and read a 64-bit value from
|
|
|
|
* it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
|
* -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
|
* property data isn't large enough.
|
|
|
|
*
|
|
|
|
* The out_value is modified only if a valid u64 value can be decoded.
|
|
|
|
*/
|
|
|
|
int of_property_read_u64(const struct device_node *np, const char *propname,
|
|
|
|
u64 *out_value)
|
|
|
|
{
|
2013-04-02 22:57:11 -06:00
|
|
|
const __be32 *val = of_find_property_value_of_size(np, propname,
|
|
|
|
sizeof(*out_value));
|
2011-09-14 13:49:59 -06:00
|
|
|
|
2013-04-02 22:57:11 -06:00
|
|
|
if (IS_ERR(val))
|
|
|
|
return PTR_ERR(val);
|
|
|
|
|
|
|
|
*out_value = of_read_number(val, 2);
|
2011-09-14 13:49:59 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u64);
|
|
|
|
|
2014-11-03 17:28:56 -07:00
|
|
|
/**
|
|
|
|
* of_property_read_u64_array - Find and read an array of 64 bit integers
|
|
|
|
* from a property.
|
|
|
|
*
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
|
|
|
* @out_values: pointer to return value, modified only if return value is 0.
|
|
|
|
* @sz: number of array elements to read
|
|
|
|
*
|
|
|
|
* Search for a property in a device node and read 64-bit value(s) from
|
|
|
|
* it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
|
* -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
|
* property data isn't large enough.
|
|
|
|
*
|
|
|
|
* The out_values is modified only if a valid u64 value can be decoded.
|
|
|
|
*/
|
|
|
|
int of_property_read_u64_array(const struct device_node *np,
|
|
|
|
const char *propname, u64 *out_values,
|
|
|
|
size_t sz)
|
|
|
|
{
|
|
|
|
const __be32 *val = of_find_property_value_of_size(np, propname,
|
|
|
|
(sz * sizeof(*out_values)));
|
|
|
|
|
|
|
|
if (IS_ERR(val))
|
|
|
|
return PTR_ERR(val);
|
|
|
|
|
|
|
|
while (sz--) {
|
|
|
|
*out_values++ = of_read_number(val, 2);
|
|
|
|
val += 2;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2015-01-27 03:26:35 -07:00
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u64_array);
|
2014-11-03 17:28:56 -07:00
|
|
|
|
2011-06-30 09:56:10 -06:00
|
|
|
/**
|
|
|
|
* of_property_read_string - Find and read a string from a property
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
|
|
|
* @out_string: pointer to null terminated return string, modified only if
|
|
|
|
* return value is 0.
|
|
|
|
*
|
|
|
|
* Search for a property in a device tree node and retrieve a null
|
|
|
|
* terminated string value (pointer to data, not a copy). Returns 0 on
|
|
|
|
* success, -EINVAL if the property does not exist, -ENODATA if property
|
|
|
|
* does not have a value, and -EILSEQ if the string is not null-terminated
|
|
|
|
* within the length of the property data.
|
|
|
|
*
|
|
|
|
* The out_string pointer is modified only if a valid string can be decoded.
|
|
|
|
*/
|
2011-08-02 08:45:07 -06:00
|
|
|
int of_property_read_string(struct device_node *np, const char *propname,
|
2011-07-03 19:01:18 -06:00
|
|
|
const char **out_string)
|
2011-06-30 09:56:10 -06:00
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
|
|
|
if (!prop)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
|
|
|
if (strnlen(prop->value, prop->length) >= prop->length)
|
|
|
|
return -EILSEQ;
|
|
|
|
*out_string = prop->value;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_string);
|
|
|
|
|
2011-12-12 09:25:58 -07:00
|
|
|
/**
|
|
|
|
* of_property_match_string() - Find string in a list and return index
|
|
|
|
* @np: pointer to node containing string list property
|
|
|
|
* @propname: string list property name
|
|
|
|
* @string: pointer to string to search for in string list
|
|
|
|
*
|
|
|
|
* This function searches a string list property and returns the index
|
|
|
|
* of a specific string value.
|
|
|
|
*/
|
|
|
|
int of_property_match_string(struct device_node *np, const char *propname,
|
|
|
|
const char *string)
|
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
|
|
|
size_t l;
|
|
|
|
int i;
|
|
|
|
const char *p, *end;
|
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
p = prop->value;
|
|
|
|
end = p + prop->length;
|
|
|
|
|
|
|
|
for (i = 0; p < end; i++, p += l) {
|
2014-11-03 08:15:35 -07:00
|
|
|
l = strnlen(p, end - p) + 1;
|
2011-12-12 09:25:58 -07:00
|
|
|
if (p + l > end)
|
|
|
|
return -EILSEQ;
|
|
|
|
pr_debug("comparing %s with %s\n", string, p);
|
|
|
|
if (strcmp(string, p) == 0)
|
|
|
|
return i; /* Found it; return index */
|
|
|
|
}
|
|
|
|
return -ENODATA;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_match_string);
|
2011-09-27 09:45:43 -06:00
|
|
|
|
|
|
|
/**
|
2014-11-21 05:23:09 -07:00
|
|
|
* of_property_read_string_helper() - Utility helper for parsing string properties
|
2011-09-27 09:45:43 -06:00
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
2014-11-03 08:15:35 -07:00
|
|
|
* @out_strs: output array of string pointers.
|
|
|
|
* @sz: number of array elements to read.
|
|
|
|
* @skip: Number of strings to skip over at beginning of list.
|
2011-09-27 09:45:43 -06:00
|
|
|
*
|
2014-11-03 08:15:35 -07:00
|
|
|
* Don't call this function directly. It is a utility helper for the
|
|
|
|
* of_property_read_string*() family of functions.
|
2011-09-27 09:45:43 -06:00
|
|
|
*/
|
2014-11-03 08:15:35 -07:00
|
|
|
int of_property_read_string_helper(struct device_node *np, const char *propname,
|
|
|
|
const char **out_strs, size_t sz, int skip)
|
2011-09-27 09:45:43 -06:00
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
2014-11-03 08:15:35 -07:00
|
|
|
int l = 0, i = 0;
|
|
|
|
const char *p, *end;
|
2011-09-27 09:45:43 -06:00
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
|
|
|
p = prop->value;
|
2014-11-03 08:15:35 -07:00
|
|
|
end = p + prop->length;
|
2011-09-27 09:45:43 -06:00
|
|
|
|
2014-11-03 08:15:35 -07:00
|
|
|
for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
|
|
|
|
l = strnlen(p, end - p) + 1;
|
|
|
|
if (p + l > end)
|
|
|
|
return -EILSEQ;
|
|
|
|
if (out_strs && i >= skip)
|
|
|
|
*out_strs++ = p;
|
|
|
|
}
|
|
|
|
i -= skip;
|
|
|
|
return i <= 0 ? -ENODATA : i;
|
2011-09-27 09:45:43 -06:00
|
|
|
}
|
2014-11-03 08:15:35 -07:00
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_string_helper);
|
2011-09-27 09:45:43 -06:00
|
|
|
|
2013-10-11 15:05:10 -06:00
|
|
|
void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
printk("%s %s", msg, of_node_full_name(args->np));
|
|
|
|
for (i = 0; i < args->args_count; i++)
|
|
|
|
printk(i ? ",%08x" : ":%08x", args->args[i]);
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
|
2013-02-10 15:57:21 -07:00
|
|
|
static int __of_parse_phandle_with_args(const struct device_node *np,
|
|
|
|
const char *list_name,
|
2013-08-14 15:27:10 -06:00
|
|
|
const char *cells_name,
|
|
|
|
int cell_count, int index,
|
2013-02-10 15:57:21 -07:00
|
|
|
struct of_phandle_args *out_args)
|
2008-10-09 22:43:17 -06:00
|
|
|
{
|
2011-12-12 09:25:57 -07:00
|
|
|
const __be32 *list, *list_end;
|
2013-02-12 14:21:49 -07:00
|
|
|
int rc = 0, size, cur_index = 0;
|
2011-12-12 09:25:57 -07:00
|
|
|
uint32_t count = 0;
|
2008-10-09 22:43:17 -06:00
|
|
|
struct device_node *node = NULL;
|
2011-12-12 09:25:57 -07:00
|
|
|
phandle phandle;
|
2008-10-09 22:43:17 -06:00
|
|
|
|
2011-12-12 09:25:57 -07:00
|
|
|
/* Retrieve the phandle list property */
|
2008-10-09 22:43:17 -06:00
|
|
|
list = of_get_property(np, list_name, &size);
|
2011-12-12 09:25:57 -07:00
|
|
|
if (!list)
|
2012-06-28 22:57:58 -06:00
|
|
|
return -ENOENT;
|
2008-10-09 22:43:17 -06:00
|
|
|
list_end = list + size / sizeof(*list);
|
|
|
|
|
2011-12-12 09:25:57 -07:00
|
|
|
/* Loop over the phandles until all the requested entry is found */
|
2008-10-09 22:43:17 -06:00
|
|
|
while (list < list_end) {
|
2013-02-12 14:21:49 -07:00
|
|
|
rc = -EINVAL;
|
2011-12-12 09:25:57 -07:00
|
|
|
count = 0;
|
2008-10-09 22:43:17 -06:00
|
|
|
|
2011-12-12 09:25:57 -07:00
|
|
|
/*
|
|
|
|
* If phandle is 0, then it is an empty entry with no
|
|
|
|
* arguments. Skip forward to the next entry.
|
|
|
|
*/
|
2010-07-23 01:48:25 -06:00
|
|
|
phandle = be32_to_cpup(list++);
|
2011-12-12 09:25:57 -07:00
|
|
|
if (phandle) {
|
|
|
|
/*
|
|
|
|
* Find the provider node and parse the #*-cells
|
2013-08-14 15:27:11 -06:00
|
|
|
* property to determine the argument length.
|
|
|
|
*
|
|
|
|
* This is not needed if the cell count is hard-coded
|
|
|
|
* (i.e. cells_name not set, but cell_count is set),
|
|
|
|
* except when we're going to return the found node
|
|
|
|
* below.
|
2011-12-12 09:25:57 -07:00
|
|
|
*/
|
2013-08-14 15:27:11 -06:00
|
|
|
if (cells_name || cur_index == index) {
|
|
|
|
node = of_find_node_by_phandle(phandle);
|
|
|
|
if (!node) {
|
|
|
|
pr_err("%s: could not find phandle\n",
|
|
|
|
np->full_name);
|
|
|
|
goto err;
|
|
|
|
}
|
2011-12-12 09:25:57 -07:00
|
|
|
}
|
2013-08-14 15:27:10 -06:00
|
|
|
|
|
|
|
if (cells_name) {
|
|
|
|
if (of_property_read_u32(node, cells_name,
|
|
|
|
&count)) {
|
|
|
|
pr_err("%s: could not get %s for %s\n",
|
|
|
|
np->full_name, cells_name,
|
|
|
|
node->full_name);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
count = cell_count;
|
2011-12-12 09:25:57 -07:00
|
|
|
}
|
2008-10-09 22:43:17 -06:00
|
|
|
|
2011-12-12 09:25:57 -07:00
|
|
|
/*
|
|
|
|
* Make sure that the arguments actually fit in the
|
|
|
|
* remaining property data length
|
|
|
|
*/
|
|
|
|
if (list + count > list_end) {
|
|
|
|
pr_err("%s: arguments longer than property\n",
|
|
|
|
np->full_name);
|
2013-02-12 14:21:49 -07:00
|
|
|
goto err;
|
2011-12-12 09:25:57 -07:00
|
|
|
}
|
2008-10-09 22:43:17 -06:00
|
|
|
}
|
|
|
|
|
2011-12-12 09:25:57 -07:00
|
|
|
/*
|
|
|
|
* All of the error cases above bail out of the loop, so at
|
|
|
|
* this point, the parsing is successful. If the requested
|
|
|
|
* index matches, then fill the out_args structure and return,
|
|
|
|
* or return -ENOENT for an empty entry.
|
|
|
|
*/
|
2013-02-12 14:21:49 -07:00
|
|
|
rc = -ENOENT;
|
2011-12-12 09:25:57 -07:00
|
|
|
if (cur_index == index) {
|
|
|
|
if (!phandle)
|
2013-02-12 14:21:49 -07:00
|
|
|
goto err;
|
2011-12-12 09:25:57 -07:00
|
|
|
|
|
|
|
if (out_args) {
|
|
|
|
int i;
|
|
|
|
if (WARN_ON(count > MAX_PHANDLE_ARGS))
|
|
|
|
count = MAX_PHANDLE_ARGS;
|
|
|
|
out_args->np = node;
|
|
|
|
out_args->args_count = count;
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
out_args->args[i] = be32_to_cpup(list++);
|
2013-04-09 21:36:39 -06:00
|
|
|
} else {
|
|
|
|
of_node_put(node);
|
2011-12-12 09:25:57 -07:00
|
|
|
}
|
2013-02-12 14:21:49 -07:00
|
|
|
|
|
|
|
/* Found it! return success */
|
2011-12-12 09:25:57 -07:00
|
|
|
return 0;
|
2008-10-09 22:43:17 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
of_node_put(node);
|
|
|
|
node = NULL;
|
2011-12-12 09:25:57 -07:00
|
|
|
list += count;
|
2008-10-09 22:43:17 -06:00
|
|
|
cur_index++;
|
|
|
|
}
|
|
|
|
|
2013-02-12 14:21:49 -07:00
|
|
|
/*
|
|
|
|
* Unlock node before returning result; will be one of:
|
|
|
|
* -ENOENT : index is for empty phandle
|
|
|
|
* -EINVAL : parsing error on data
|
2013-02-10 15:57:21 -07:00
|
|
|
* [1..n] : Number of phandle (count mode; when index = -1)
|
2013-02-12 14:21:49 -07:00
|
|
|
*/
|
2013-02-10 15:57:21 -07:00
|
|
|
rc = index < 0 ? cur_index : -ENOENT;
|
2013-02-12 14:21:49 -07:00
|
|
|
err:
|
2011-12-12 09:25:57 -07:00
|
|
|
if (node)
|
|
|
|
of_node_put(node);
|
2013-02-12 14:21:49 -07:00
|
|
|
return rc;
|
2008-10-09 22:43:17 -06:00
|
|
|
}
|
2013-02-10 15:57:21 -07:00
|
|
|
|
2013-08-14 15:27:09 -06:00
|
|
|
/**
|
|
|
|
* of_parse_phandle - Resolve a phandle property to a device_node pointer
|
|
|
|
* @np: Pointer to device node holding phandle property
|
|
|
|
* @phandle_name: Name of property holding a phandle value
|
|
|
|
* @index: For properties holding a table of phandles, this is the index into
|
|
|
|
* the table
|
|
|
|
*
|
|
|
|
* Returns the device_node pointer with refcount incremented. Use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_parse_phandle(const struct device_node *np,
|
|
|
|
const char *phandle_name, int index)
|
|
|
|
{
|
2013-08-14 15:27:11 -06:00
|
|
|
struct of_phandle_args args;
|
|
|
|
|
|
|
|
if (index < 0)
|
|
|
|
return NULL;
|
2013-08-14 15:27:09 -06:00
|
|
|
|
2013-08-14 15:27:11 -06:00
|
|
|
if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
|
|
|
|
index, &args))
|
2013-08-14 15:27:09 -06:00
|
|
|
return NULL;
|
|
|
|
|
2013-08-14 15:27:11 -06:00
|
|
|
return args.np;
|
2013-08-14 15:27:09 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_parse_phandle);
|
|
|
|
|
2013-08-14 15:27:08 -06:00
|
|
|
/**
|
|
|
|
* of_parse_phandle_with_args() - Find a node pointed by phandle in a list
|
|
|
|
* @np: pointer to a device tree node containing a list
|
|
|
|
* @list_name: property name that contains a list
|
|
|
|
* @cells_name: property name that specifies phandles' arguments count
|
|
|
|
* @index: index of a phandle to parse out
|
|
|
|
* @out_args: optional pointer to output arguments structure (will be filled)
|
|
|
|
*
|
|
|
|
* This function is useful to parse lists of phandles and their arguments.
|
|
|
|
* Returns 0 on success and fills out_args, on error returns appropriate
|
|
|
|
* errno value.
|
|
|
|
*
|
2014-10-22 03:44:52 -06:00
|
|
|
* Caller is responsible to call of_node_put() on the returned out_args->np
|
2013-08-14 15:27:08 -06:00
|
|
|
* pointer.
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* phandle1: node1 {
|
2014-10-22 03:44:55 -06:00
|
|
|
* #list-cells = <2>;
|
2013-08-14 15:27:08 -06:00
|
|
|
* }
|
|
|
|
*
|
|
|
|
* phandle2: node2 {
|
2014-10-22 03:44:55 -06:00
|
|
|
* #list-cells = <1>;
|
2013-08-14 15:27:08 -06:00
|
|
|
* }
|
|
|
|
*
|
|
|
|
* node3 {
|
2014-10-22 03:44:55 -06:00
|
|
|
* list = <&phandle1 1 2 &phandle2 3>;
|
2013-08-14 15:27:08 -06:00
|
|
|
* }
|
|
|
|
*
|
|
|
|
* To get a device_node of the `node2' node you may call this:
|
|
|
|
* of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
|
|
|
|
*/
|
2013-02-10 15:57:21 -07:00
|
|
|
int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
|
|
|
|
const char *cells_name, int index,
|
|
|
|
struct of_phandle_args *out_args)
|
|
|
|
{
|
|
|
|
if (index < 0)
|
|
|
|
return -EINVAL;
|
2013-08-14 15:27:10 -06:00
|
|
|
return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
|
|
|
|
index, out_args);
|
2013-02-10 15:57:21 -07:00
|
|
|
}
|
2011-12-12 09:25:57 -07:00
|
|
|
EXPORT_SYMBOL(of_parse_phandle_with_args);
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2013-08-14 15:27:10 -06:00
|
|
|
/**
|
|
|
|
* of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
|
|
|
|
* @np: pointer to a device tree node containing a list
|
|
|
|
* @list_name: property name that contains a list
|
|
|
|
* @cell_count: number of argument cells following the phandle
|
|
|
|
* @index: index of a phandle to parse out
|
|
|
|
* @out_args: optional pointer to output arguments structure (will be filled)
|
|
|
|
*
|
|
|
|
* This function is useful to parse lists of phandles and their arguments.
|
|
|
|
* Returns 0 on success and fills out_args, on error returns appropriate
|
|
|
|
* errno value.
|
|
|
|
*
|
2014-10-22 03:44:52 -06:00
|
|
|
* Caller is responsible to call of_node_put() on the returned out_args->np
|
2013-08-14 15:27:10 -06:00
|
|
|
* pointer.
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* phandle1: node1 {
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* phandle2: node2 {
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* node3 {
|
2014-10-22 03:44:55 -06:00
|
|
|
* list = <&phandle1 0 2 &phandle2 2 3>;
|
2013-08-14 15:27:10 -06:00
|
|
|
* }
|
|
|
|
*
|
|
|
|
* To get a device_node of the `node2' node you may call this:
|
|
|
|
* of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
|
|
|
|
*/
|
|
|
|
int of_parse_phandle_with_fixed_args(const struct device_node *np,
|
|
|
|
const char *list_name, int cell_count,
|
|
|
|
int index, struct of_phandle_args *out_args)
|
|
|
|
{
|
|
|
|
if (index < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
|
|
|
|
index, out_args);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_parse_phandle_with_fixed_args);
|
|
|
|
|
2013-02-10 15:57:21 -07:00
|
|
|
/**
|
|
|
|
* of_count_phandle_with_args() - Find the number of phandles references in a property
|
|
|
|
* @np: pointer to a device tree node containing a list
|
|
|
|
* @list_name: property name that contains a list
|
|
|
|
* @cells_name: property name that specifies phandles' arguments count
|
|
|
|
*
|
|
|
|
* Returns the number of phandle + argument tuples within a property. It
|
|
|
|
* is a typical pattern to encode a list of phandle and variable
|
|
|
|
* arguments into a single property. The number of arguments is encoded
|
|
|
|
* by a property in the phandle-target node. For example, a gpios
|
|
|
|
* property would contain a list of GPIO specifies consisting of a
|
|
|
|
* phandle and 1 or more arguments. The number of arguments are
|
|
|
|
* determined by the #gpio-cells property in the node pointed to by the
|
|
|
|
* phandle.
|
|
|
|
*/
|
|
|
|
int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
|
|
|
|
const char *cells_name)
|
|
|
|
{
|
2013-08-14 15:27:10 -06:00
|
|
|
return __of_parse_phandle_with_args(np, list_name, cells_name, 0, -1,
|
|
|
|
NULL);
|
2013-02-10 15:57:21 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_count_phandle_with_args);
|
|
|
|
|
2014-01-21 22:57:39 -07:00
|
|
|
/**
|
|
|
|
* __of_add_property - Add a property to a node without lock operations
|
|
|
|
*/
|
2014-07-04 10:58:46 -06:00
|
|
|
int __of_add_property(struct device_node *np, struct property *prop)
|
2014-01-21 22:57:39 -07:00
|
|
|
{
|
|
|
|
struct property **next;
|
|
|
|
|
|
|
|
prop->next = NULL;
|
|
|
|
next = &np->properties;
|
|
|
|
while (*next) {
|
|
|
|
if (strcmp(prop->name, (*next)->name) == 0)
|
|
|
|
/* duplicate ! don't insert it */
|
|
|
|
return -EEXIST;
|
|
|
|
|
|
|
|
next = &(*next)->next;
|
|
|
|
}
|
|
|
|
*next = prop;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-23 20:16:45 -07:00
|
|
|
/**
|
2012-10-02 10:58:46 -06:00
|
|
|
* of_add_property - Add a property to a node
|
2009-11-23 20:16:45 -07:00
|
|
|
*/
|
2012-10-02 10:58:46 -06:00
|
|
|
int of_add_property(struct device_node *np, struct property *prop)
|
2009-11-23 20:16:45 -07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2012-10-02 10:57:57 -06:00
|
|
|
int rc;
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
mutex_lock(&of_mutex);
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-01-21 22:57:39 -07:00
|
|
|
rc = __of_add_property(np, prop);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
if (!rc)
|
2013-12-13 11:08:59 -07:00
|
|
|
__of_add_property_sysfs(np, prop);
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
mutex_unlock(&of_mutex);
|
|
|
|
|
2014-07-16 12:48:23 -06:00
|
|
|
if (!rc)
|
|
|
|
of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop, NULL);
|
|
|
|
|
2014-01-21 22:57:39 -07:00
|
|
|
return rc;
|
2009-11-23 20:16:45 -07:00
|
|
|
}
|
|
|
|
|
2014-07-04 10:58:46 -06:00
|
|
|
int __of_remove_property(struct device_node *np, struct property *prop)
|
|
|
|
{
|
|
|
|
struct property **next;
|
|
|
|
|
|
|
|
for (next = &np->properties; *next; next = &(*next)->next) {
|
|
|
|
if (*next == prop)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (*next == NULL)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* found the node */
|
|
|
|
*next = prop->next;
|
|
|
|
prop->next = np->deadprops;
|
|
|
|
np->deadprops = prop;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
void __of_remove_property_sysfs(struct device_node *np, struct property *prop)
|
|
|
|
{
|
2014-09-05 10:56:13 -06:00
|
|
|
if (!IS_ENABLED(CONFIG_SYSFS))
|
|
|
|
return;
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
/* at early boot, bail here and defer setup to of_init() */
|
|
|
|
if (of_kset && of_node_is_attached(np))
|
|
|
|
sysfs_remove_bin_file(&np->kobj, &prop->attr);
|
|
|
|
}
|
|
|
|
|
2009-11-23 20:16:45 -07:00
|
|
|
/**
|
2012-10-02 10:58:46 -06:00
|
|
|
* of_remove_property - Remove a property from a node.
|
2009-11-23 20:16:45 -07:00
|
|
|
*
|
|
|
|
* Note that we don't actually remove it, since we have given out
|
|
|
|
* who-knows-how-many pointers to the data using get-property.
|
|
|
|
* Instead we just move the property to the "dead properties"
|
|
|
|
* list, so it won't be found any more.
|
|
|
|
*/
|
2012-10-02 10:58:46 -06:00
|
|
|
int of_remove_property(struct device_node *np, struct property *prop)
|
2009-11-23 20:16:45 -07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2012-10-02 10:57:57 -06:00
|
|
|
int rc;
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
mutex_lock(&of_mutex);
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-07-04 10:58:46 -06:00
|
|
|
rc = __of_remove_property(np, prop);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
if (!rc)
|
|
|
|
__of_remove_property_sysfs(np, prop);
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
mutex_unlock(&of_mutex);
|
2014-02-20 11:02:11 -07:00
|
|
|
|
2014-07-16 12:48:23 -06:00
|
|
|
if (!rc)
|
|
|
|
of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop, NULL);
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
return rc;
|
2009-11-23 20:16:45 -07:00
|
|
|
}
|
|
|
|
|
2014-07-04 10:58:46 -06:00
|
|
|
int __of_update_property(struct device_node *np, struct property *newprop,
|
|
|
|
struct property **oldpropp)
|
2009-11-23 20:16:45 -07:00
|
|
|
{
|
2012-07-10 23:16:37 -06:00
|
|
|
struct property **next, *oldprop;
|
2009-11-23 20:16:45 -07:00
|
|
|
|
2014-07-04 10:58:46 -06:00
|
|
|
for (next = &np->properties; *next; next = &(*next)->next) {
|
|
|
|
if (of_prop_cmp((*next)->name, newprop->name) == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
*oldpropp = oldprop = *next;
|
2012-07-10 23:16:37 -06:00
|
|
|
|
2014-07-04 10:58:46 -06:00
|
|
|
if (oldprop) {
|
2014-04-17 01:48:29 -06:00
|
|
|
/* replace the node */
|
2014-07-04 10:58:46 -06:00
|
|
|
newprop->next = oldprop->next;
|
|
|
|
*next = newprop;
|
|
|
|
oldprop->next = np->deadprops;
|
|
|
|
np->deadprops = oldprop;
|
|
|
|
} else {
|
|
|
|
/* new node */
|
|
|
|
newprop->next = NULL;
|
|
|
|
*next = newprop;
|
2009-11-23 20:16:45 -07:00
|
|
|
}
|
2014-02-20 11:02:11 -07:00
|
|
|
|
2014-07-04 10:58:46 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
void __of_update_property_sysfs(struct device_node *np, struct property *newprop,
|
|
|
|
struct property *oldprop)
|
|
|
|
{
|
2014-09-05 10:56:13 -06:00
|
|
|
if (!IS_ENABLED(CONFIG_SYSFS))
|
|
|
|
return;
|
|
|
|
|
of: make of_update_property() usable earlier in the boot process
Commit 75b57ecf9d1d1e17d099ab13b8f48e6e038676be ('of: Make device
nodes kobjects so they show up in sysfs') has turned Device Tree nodes
in kobjects and added a sysfs based representation for Device Tree
nodes. Since the sysfs logic is only available after the execution of
a core_initcall(), the patch took precautions in of_add_property() and
of_remove_property() to not do any sysfs related manipulation early in
the boot process.
However, it forgot to do the same for of_update_property(), which if
used early in the boot process (before core_initcalls have been
called), tries to call sysfs_remove_bin_file(), and crashes:
------------[ cut here ]------------
WARNING: CPU: 0 PID: 0 at /home/thomas/projets/linux-2.6/fs/kernfs/dir.c:1216 kernfs_remove_by_name_ns+0x80/0x88()
kernfs: can not remove '(null)', no directory
Modules linked in:
CPU: 0 PID: 0 Comm: swapper/0 Not tainted 3.15.0-rc1-00127-g1d7e7b2-dirty #423
[<c0014910>] (unwind_backtrace) from [<c00110ec>] (show_stack+0x10/0x14)
[<c00110ec>] (show_stack) from [<c04c84b8>] (dump_stack+0x84/0x94)
[<c04c84b8>] (dump_stack) from [<c001d8c0>] (warn_slowpath_common+0x6c/0x88)
[<c001d8c0>] (warn_slowpath_common) from [<c001d90c>] (warn_slowpath_fmt+0x30/0x40)
[<c001d90c>] (warn_slowpath_fmt) from [<c0104468>] (kernfs_remove_by_name_ns+0x80/0x88)
[<c0104468>] (kernfs_remove_by_name_ns) from [<c0394d98>] (of_update_property+0xc0/0xf0)
[<c0394d98>] (of_update_property) from [<c0647248>] (mvebu_timer_and_clk_init+0xfc/0x194)
[<c0647248>] (mvebu_timer_and_clk_init) from [<c0640934>] (start_kernel+0x218/0x350)
[<c0640934>] (start_kernel) from [<00008070>] (0x8070)
---[ end trace 3406ff24bd97382e ]---
Unable to handle kernel NULL pointer dereference at virtual address 0000003c
pgd = c0004000
[0000003c] *pgd=00000000
Internal error: Oops: 5 [#1] SMP ARM
Modules linked in:
CPU: 0 PID: 0 Comm: swapper/0 Tainted: G W 3.15.0-rc1-00127-g1d7e7b2-dirty #423
task: c10ad4d8 ti: c10a2000 task.ti: c10a2000
PC is at kernfs_find_ns+0x8/0xf0
LR is at kernfs_find_and_get_ns+0x30/0x48
pc : [<c0103834>] lr : [<c010394c>] psr: 600001d3
sp : c10a3f34 ip : 00000073 fp : 00000000
r10: 00000000 r9 : cfffc240 r8 : cfdf2980
r7 : cf812c00 r6 : 00000000 r5 : 00000000 r4 : c10b45e0
r3 : c10ad4d8 r2 : 00000000 r1 : cf812c00 r0 : 00000000
Flags: nZCv IRQs off FIQs off Mode SVC_32 ISA ARM Segment kernel
Control: 10c53c7d Table: 0000404a DAC: 00000015
Process swapper/0 (pid: 0, stack limit = 0xc10a2240)
Stack: (0xc10a3f34 to 0xc10a4000)
3f20: c10b45e0 00000000 00000000
3f40: cf812c00 c010394c 00000063 cf812c00 00000001 cf812c00 cfdf29ac c03932cc
3f60: 00000063 cf812bc0 cfdf29ac cf812c00 ffffffff c03943f8 cfdf2980 c0104468
3f80: cfdf2a04 cfdf2980 cf812bc0 c06634b0 c10aa3c0 c0394da4 c10f74dc cfdf2980
3fa0: cf812bc0 c0647248 c10aa3c0 ffffffff c10de940 c10aa3c0 ffffffff c0640934
3fc0: ffffffff ffffffff c06404ec 00000000 00000000 c06634b0 00000000 10c53c7d
3fe0: c10aa434 c06634ac c10ae4c8 0000406a 414fc091 00008070 00000000 00000000
[<c0103834>] (kernfs_find_ns) from [<00000001>] (0x1)
Code: e5c89001 eaffffcf e92d40f0 e1a06002 (e1d023bc)
---[ end trace 3406ff24bd97382f ]---
Kernel panic - not syncing: Attempted to kill the idle task!
---[ end Kernel panic - not syncing: Attempted to kill the idle task!
To fix this problem, we simply skip the sysfs related calls in
of_update_property(), and rely on of_init() to fix up things when it
will be called, exactly as is done in of_add_property() and
of_remove_property().
Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Fixes: 75b57ecf9d1d ("of: Make device nodes kobjects so they show up in sysfs")
Signed-off-by: Grant Likely <grant.likely@linaro.org>
2014-05-14 05:36:36 -06:00
|
|
|
/* At early boot, bail out and defer setup to of_init() */
|
|
|
|
if (!of_kset)
|
2014-07-23 17:05:06 -06:00
|
|
|
return;
|
of: make of_update_property() usable earlier in the boot process
Commit 75b57ecf9d1d1e17d099ab13b8f48e6e038676be ('of: Make device
nodes kobjects so they show up in sysfs') has turned Device Tree nodes
in kobjects and added a sysfs based representation for Device Tree
nodes. Since the sysfs logic is only available after the execution of
a core_initcall(), the patch took precautions in of_add_property() and
of_remove_property() to not do any sysfs related manipulation early in
the boot process.
However, it forgot to do the same for of_update_property(), which if
used early in the boot process (before core_initcalls have been
called), tries to call sysfs_remove_bin_file(), and crashes:
------------[ cut here ]------------
WARNING: CPU: 0 PID: 0 at /home/thomas/projets/linux-2.6/fs/kernfs/dir.c:1216 kernfs_remove_by_name_ns+0x80/0x88()
kernfs: can not remove '(null)', no directory
Modules linked in:
CPU: 0 PID: 0 Comm: swapper/0 Not tainted 3.15.0-rc1-00127-g1d7e7b2-dirty #423
[<c0014910>] (unwind_backtrace) from [<c00110ec>] (show_stack+0x10/0x14)
[<c00110ec>] (show_stack) from [<c04c84b8>] (dump_stack+0x84/0x94)
[<c04c84b8>] (dump_stack) from [<c001d8c0>] (warn_slowpath_common+0x6c/0x88)
[<c001d8c0>] (warn_slowpath_common) from [<c001d90c>] (warn_slowpath_fmt+0x30/0x40)
[<c001d90c>] (warn_slowpath_fmt) from [<c0104468>] (kernfs_remove_by_name_ns+0x80/0x88)
[<c0104468>] (kernfs_remove_by_name_ns) from [<c0394d98>] (of_update_property+0xc0/0xf0)
[<c0394d98>] (of_update_property) from [<c0647248>] (mvebu_timer_and_clk_init+0xfc/0x194)
[<c0647248>] (mvebu_timer_and_clk_init) from [<c0640934>] (start_kernel+0x218/0x350)
[<c0640934>] (start_kernel) from [<00008070>] (0x8070)
---[ end trace 3406ff24bd97382e ]---
Unable to handle kernel NULL pointer dereference at virtual address 0000003c
pgd = c0004000
[0000003c] *pgd=00000000
Internal error: Oops: 5 [#1] SMP ARM
Modules linked in:
CPU: 0 PID: 0 Comm: swapper/0 Tainted: G W 3.15.0-rc1-00127-g1d7e7b2-dirty #423
task: c10ad4d8 ti: c10a2000 task.ti: c10a2000
PC is at kernfs_find_ns+0x8/0xf0
LR is at kernfs_find_and_get_ns+0x30/0x48
pc : [<c0103834>] lr : [<c010394c>] psr: 600001d3
sp : c10a3f34 ip : 00000073 fp : 00000000
r10: 00000000 r9 : cfffc240 r8 : cfdf2980
r7 : cf812c00 r6 : 00000000 r5 : 00000000 r4 : c10b45e0
r3 : c10ad4d8 r2 : 00000000 r1 : cf812c00 r0 : 00000000
Flags: nZCv IRQs off FIQs off Mode SVC_32 ISA ARM Segment kernel
Control: 10c53c7d Table: 0000404a DAC: 00000015
Process swapper/0 (pid: 0, stack limit = 0xc10a2240)
Stack: (0xc10a3f34 to 0xc10a4000)
3f20: c10b45e0 00000000 00000000
3f40: cf812c00 c010394c 00000063 cf812c00 00000001 cf812c00 cfdf29ac c03932cc
3f60: 00000063 cf812bc0 cfdf29ac cf812c00 ffffffff c03943f8 cfdf2980 c0104468
3f80: cfdf2a04 cfdf2980 cf812bc0 c06634b0 c10aa3c0 c0394da4 c10f74dc cfdf2980
3fa0: cf812bc0 c0647248 c10aa3c0 ffffffff c10de940 c10aa3c0 ffffffff c0640934
3fc0: ffffffff ffffffff c06404ec 00000000 00000000 c06634b0 00000000 10c53c7d
3fe0: c10aa434 c06634ac c10ae4c8 0000406a 414fc091 00008070 00000000 00000000
[<c0103834>] (kernfs_find_ns) from [<00000001>] (0x1)
Code: e5c89001 eaffffcf e92d40f0 e1a06002 (e1d023bc)
---[ end trace 3406ff24bd97382f ]---
Kernel panic - not syncing: Attempted to kill the idle task!
---[ end Kernel panic - not syncing: Attempted to kill the idle task!
To fix this problem, we simply skip the sysfs related calls in
of_update_property(), and rely on of_init() to fix up things when it
will be called, exactly as is done in of_add_property() and
of_remove_property().
Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Fixes: 75b57ecf9d1d ("of: Make device nodes kobjects so they show up in sysfs")
Signed-off-by: Grant Likely <grant.likely@linaro.org>
2014-05-14 05:36:36 -06:00
|
|
|
|
2014-04-17 01:48:29 -06:00
|
|
|
if (oldprop)
|
|
|
|
sysfs_remove_bin_file(&np->kobj, &oldprop->attr);
|
2014-02-20 11:02:11 -07:00
|
|
|
__of_add_property_sysfs(np, newprop);
|
2009-11-23 20:16:45 -07:00
|
|
|
}
|
2010-01-29 05:04:33 -07:00
|
|
|
|
|
|
|
/*
|
2012-10-02 10:58:46 -06:00
|
|
|
* of_update_property - Update a property in a node, if the property does
|
2012-07-10 23:16:37 -06:00
|
|
|
* not exist, add it.
|
2010-01-29 05:04:33 -07:00
|
|
|
*
|
2009-11-23 20:16:45 -07:00
|
|
|
* Note that we don't actually remove it, since we have given out
|
|
|
|
* who-knows-how-many pointers to the data using get-property.
|
|
|
|
* Instead we just move the property to the "dead properties" list,
|
|
|
|
* and add the new property to the property list
|
2010-01-29 05:04:33 -07:00
|
|
|
*/
|
2012-10-02 10:58:46 -06:00
|
|
|
int of_update_property(struct device_node *np, struct property *newprop)
|
2010-01-29 05:04:33 -07:00
|
|
|
{
|
2014-07-04 10:58:46 -06:00
|
|
|
struct property *oldprop;
|
2010-01-29 05:04:33 -07:00
|
|
|
unsigned long flags;
|
2012-10-02 10:57:57 -06:00
|
|
|
int rc;
|
|
|
|
|
2014-07-04 10:58:46 -06:00
|
|
|
if (!newprop->name)
|
|
|
|
return -EINVAL;
|
2012-10-02 10:57:57 -06:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
mutex_lock(&of_mutex);
|
2010-01-29 05:04:33 -07:00
|
|
|
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
2014-07-04 10:58:46 -06:00
|
|
|
rc = __of_update_property(np, newprop, &oldprop);
|
2013-02-06 13:30:56 -07:00
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
2010-01-29 05:04:33 -07:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
if (!rc)
|
|
|
|
__of_update_property_sysfs(np, newprop, oldprop);
|
2010-01-29 05:04:33 -07:00
|
|
|
|
2014-07-23 17:05:06 -06:00
|
|
|
mutex_unlock(&of_mutex);
|
2010-01-29 05:04:33 -07:00
|
|
|
|
2014-07-16 12:48:23 -06:00
|
|
|
if (!rc)
|
|
|
|
of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop, oldprop);
|
2012-10-02 10:55:01 -06:00
|
|
|
|
2012-10-02 10:57:57 -06:00
|
|
|
return rc;
|
2010-01-29 05:04:33 -07:00
|
|
|
}
|
|
|
|
|
2011-08-15 01:28:14 -06:00
|
|
|
static void of_alias_add(struct alias_prop *ap, struct device_node *np,
|
|
|
|
int id, const char *stem, int stem_len)
|
|
|
|
{
|
|
|
|
ap->np = np;
|
|
|
|
ap->id = id;
|
|
|
|
strncpy(ap->stem, stem, stem_len);
|
|
|
|
ap->stem[stem_len] = 0;
|
|
|
|
list_add_tail(&ap->link, &aliases_lookup);
|
|
|
|
pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
|
2012-06-15 11:50:25 -06:00
|
|
|
ap->alias, ap->stem, ap->id, of_node_full_name(np));
|
2011-08-15 01:28:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-10-22 03:44:53 -06:00
|
|
|
* of_alias_scan - Scan all properties of the 'aliases' node
|
2011-08-15 01:28:14 -06:00
|
|
|
*
|
2014-10-22 03:44:53 -06:00
|
|
|
* The function scans all the properties of the 'aliases' node and populates
|
|
|
|
* the global lookup table with the properties. It returns the
|
|
|
|
* number of alias properties found, or an error code in case of failure.
|
2011-08-15 01:28:14 -06:00
|
|
|
*
|
|
|
|
* @dt_alloc: An allocator that provides a virtual address to memory
|
2014-10-22 03:44:53 -06:00
|
|
|
* for storing the resulting tree
|
2011-08-15 01:28:14 -06:00
|
|
|
*/
|
|
|
|
void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
|
|
|
|
{
|
|
|
|
struct property *pp;
|
|
|
|
|
2014-08-27 08:09:39 -06:00
|
|
|
of_aliases = of_find_node_by_path("/aliases");
|
2011-08-15 01:28:14 -06:00
|
|
|
of_chosen = of_find_node_by_path("/chosen");
|
|
|
|
if (of_chosen == NULL)
|
|
|
|
of_chosen = of_find_node_by_path("/chosen@0");
|
2013-08-05 06:40:44 -06:00
|
|
|
|
|
|
|
if (of_chosen) {
|
2014-03-28 09:12:18 -06:00
|
|
|
/* linux,stdout-path and /aliases/stdout are for legacy compatibility */
|
2014-03-27 18:11:23 -06:00
|
|
|
const char *name = of_get_property(of_chosen, "stdout-path", NULL);
|
|
|
|
if (!name)
|
|
|
|
name = of_get_property(of_chosen, "linux,stdout-path", NULL);
|
2014-03-28 09:12:18 -06:00
|
|
|
if (IS_ENABLED(CONFIG_PPC) && !name)
|
|
|
|
name = of_get_property(of_aliases, "stdout", NULL);
|
2015-03-17 14:46:33 -06:00
|
|
|
if (name)
|
2014-11-27 10:56:07 -07:00
|
|
|
of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
|
2013-08-05 06:40:44 -06:00
|
|
|
}
|
|
|
|
|
2011-08-15 01:28:14 -06:00
|
|
|
if (!of_aliases)
|
|
|
|
return;
|
|
|
|
|
2011-12-22 05:19:24 -07:00
|
|
|
for_each_property_of_node(of_aliases, pp) {
|
2011-08-15 01:28:14 -06:00
|
|
|
const char *start = pp->name;
|
|
|
|
const char *end = start + strlen(start);
|
|
|
|
struct device_node *np;
|
|
|
|
struct alias_prop *ap;
|
|
|
|
int id, len;
|
|
|
|
|
|
|
|
/* Skip those we do not want to proceed */
|
|
|
|
if (!strcmp(pp->name, "name") ||
|
|
|
|
!strcmp(pp->name, "phandle") ||
|
|
|
|
!strcmp(pp->name, "linux,phandle"))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
np = of_find_node_by_path(pp->value);
|
|
|
|
if (!np)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* walk the alias backwards to extract the id and work out
|
|
|
|
* the 'stem' string */
|
|
|
|
while (isdigit(*(end-1)) && end > start)
|
|
|
|
end--;
|
|
|
|
len = end - start;
|
|
|
|
|
|
|
|
if (kstrtoint(end, 10, &id) < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Allocate an alias_prop with enough space for the stem */
|
|
|
|
ap = dt_alloc(sizeof(*ap) + len + 1, 4);
|
|
|
|
if (!ap)
|
|
|
|
continue;
|
2013-08-28 14:24:17 -06:00
|
|
|
memset(ap, 0, sizeof(*ap) + len + 1);
|
2011-08-15 01:28:14 -06:00
|
|
|
ap->alias = start;
|
|
|
|
of_alias_add(ap, np, id, start, len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_alias_get_id - Get alias id for the given device_node
|
|
|
|
* @np: Pointer to the given device_node
|
|
|
|
* @stem: Alias stem of the given device_node
|
|
|
|
*
|
2014-03-11 04:23:38 -06:00
|
|
|
* The function travels the lookup table to get the alias id for the given
|
|
|
|
* device_node and alias stem. It returns the alias id if found.
|
2011-08-15 01:28:14 -06:00
|
|
|
*/
|
|
|
|
int of_alias_get_id(struct device_node *np, const char *stem)
|
|
|
|
{
|
|
|
|
struct alias_prop *app;
|
|
|
|
int id = -ENODEV;
|
|
|
|
|
2014-07-04 10:58:03 -06:00
|
|
|
mutex_lock(&of_mutex);
|
2011-08-15 01:28:14 -06:00
|
|
|
list_for_each_entry(app, &aliases_lookup, link) {
|
|
|
|
if (strcmp(app->stem, stem) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (np == app->np) {
|
|
|
|
id = app->id;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-07-04 10:58:03 -06:00
|
|
|
mutex_unlock(&of_mutex);
|
2011-08-15 01:28:14 -06:00
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_alias_get_id);
|
dt: add property iteration helpers
This patch adds macros of_property_for_each_u32() and
of_property_for_each_string(), which iterate over an array of values
within a device-tree property. Usage is for example:
struct property *prop;
const __be32 *p;
u32 u;
of_property_for_each_u32(np, "propname", prop, p, u)
printk("U32 value: %x\n", u);
struct property *prop;
const char *s;
of_property_for_each_string(np, "propname", prop, s)
printk("String value: %s\n", s);
Based on work by Rob Herring <robherring2@gmail.com>
Cc: Grant Likely <grant.likely@secretlab.ca>
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-04-04 09:27:46 -06:00
|
|
|
|
2015-03-12 10:17:58 -06:00
|
|
|
/**
|
|
|
|
* of_alias_get_highest_id - Get highest alias id for the given stem
|
|
|
|
* @stem: Alias stem to be examined
|
|
|
|
*
|
|
|
|
* The function travels the lookup table to get the highest alias id for the
|
|
|
|
* given alias stem. It returns the alias id if found.
|
|
|
|
*/
|
|
|
|
int of_alias_get_highest_id(const char *stem)
|
|
|
|
{
|
|
|
|
struct alias_prop *app;
|
|
|
|
int id = -ENODEV;
|
|
|
|
|
|
|
|
mutex_lock(&of_mutex);
|
|
|
|
list_for_each_entry(app, &aliases_lookup, link) {
|
|
|
|
if (strcmp(app->stem, stem) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (app->id > id)
|
|
|
|
id = app->id;
|
|
|
|
}
|
|
|
|
mutex_unlock(&of_mutex);
|
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_alias_get_highest_id);
|
|
|
|
|
dt: add property iteration helpers
This patch adds macros of_property_for_each_u32() and
of_property_for_each_string(), which iterate over an array of values
within a device-tree property. Usage is for example:
struct property *prop;
const __be32 *p;
u32 u;
of_property_for_each_u32(np, "propname", prop, p, u)
printk("U32 value: %x\n", u);
struct property *prop;
const char *s;
of_property_for_each_string(np, "propname", prop, s)
printk("String value: %s\n", s);
Based on work by Rob Herring <robherring2@gmail.com>
Cc: Grant Likely <grant.likely@secretlab.ca>
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-04-04 09:27:46 -06:00
|
|
|
const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
|
|
|
|
u32 *pu)
|
|
|
|
{
|
|
|
|
const void *curv = cur;
|
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!cur) {
|
|
|
|
curv = prop->value;
|
|
|
|
goto out_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
curv += sizeof(*cur);
|
|
|
|
if (curv >= prop->value + prop->length)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
out_val:
|
|
|
|
*pu = be32_to_cpup(curv);
|
|
|
|
return curv;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_prop_next_u32);
|
|
|
|
|
|
|
|
const char *of_prop_next_string(struct property *prop, const char *cur)
|
|
|
|
{
|
|
|
|
const void *curv = cur;
|
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!cur)
|
|
|
|
return prop->value;
|
|
|
|
|
|
|
|
curv += strlen(cur) + 1;
|
|
|
|
if (curv >= prop->value + prop->length)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return curv;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_prop_next_string);
|
2013-08-05 06:40:44 -06:00
|
|
|
|
|
|
|
/**
|
2014-03-27 18:18:55 -06:00
|
|
|
* of_console_check() - Test and setup console for DT setup
|
|
|
|
* @dn - Pointer to device node
|
|
|
|
* @name - Name to use for preferred console without index. ex. "ttyS"
|
|
|
|
* @index - Index to use for preferred console.
|
|
|
|
*
|
|
|
|
* Check if the given device node matches the stdout-path property in the
|
|
|
|
* /chosen node. If it does then register it as the preferred console and return
|
|
|
|
* TRUE. Otherwise return FALSE.
|
2013-08-05 06:40:44 -06:00
|
|
|
*/
|
2014-03-27 18:18:55 -06:00
|
|
|
bool of_console_check(struct device_node *dn, char *name, int index)
|
2013-08-05 06:40:44 -06:00
|
|
|
{
|
2014-03-27 18:18:55 -06:00
|
|
|
if (!dn || dn != of_stdout || console_set_on_cmdline)
|
2013-08-05 06:40:44 -06:00
|
|
|
return false;
|
2014-11-27 10:56:07 -07:00
|
|
|
return !add_preferred_console(name, index,
|
|
|
|
kstrdup(of_stdout_options, GFP_KERNEL));
|
2013-08-05 06:40:44 -06:00
|
|
|
}
|
2014-03-27 18:18:55 -06:00
|
|
|
EXPORT_SYMBOL_GPL(of_console_check);
|
2013-09-18 04:53:05 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_find_next_cache_node - Find a node's subsidiary cache
|
|
|
|
* @np: node of type "cpu" or "cache"
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done. Caller should hold a reference
|
|
|
|
* to np.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_next_cache_node(const struct device_node *np)
|
|
|
|
{
|
|
|
|
struct device_node *child;
|
|
|
|
const phandle *handle;
|
|
|
|
|
|
|
|
handle = of_get_property(np, "l2-cache", NULL);
|
|
|
|
if (!handle)
|
|
|
|
handle = of_get_property(np, "next-level-cache", NULL);
|
|
|
|
|
|
|
|
if (handle)
|
|
|
|
return of_find_node_by_phandle(be32_to_cpup(handle));
|
|
|
|
|
|
|
|
/* OF on pmac has nodes instead of properties named "l2-cache"
|
|
|
|
* beneath CPU nodes.
|
|
|
|
*/
|
|
|
|
if (!strcmp(np->type, "cpu"))
|
|
|
|
for_each_child_of_node(np, child)
|
|
|
|
if (!strcmp(child->type, "cache"))
|
|
|
|
return child;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-02-10 14:01:48 -07:00
|
|
|
|
2014-02-14 03:53:56 -07:00
|
|
|
/**
|
|
|
|
* of_graph_parse_endpoint() - parse common endpoint node properties
|
|
|
|
* @node: pointer to endpoint device_node
|
|
|
|
* @endpoint: pointer to the OF endpoint data structure
|
|
|
|
*
|
|
|
|
* The caller should hold a reference to @node.
|
|
|
|
*/
|
|
|
|
int of_graph_parse_endpoint(const struct device_node *node,
|
|
|
|
struct of_endpoint *endpoint)
|
|
|
|
{
|
|
|
|
struct device_node *port_node = of_get_parent(node);
|
|
|
|
|
2014-03-04 04:31:24 -07:00
|
|
|
WARN_ONCE(!port_node, "%s(): endpoint %s has no parent node\n",
|
|
|
|
__func__, node->full_name);
|
|
|
|
|
2014-02-14 03:53:56 -07:00
|
|
|
memset(endpoint, 0, sizeof(*endpoint));
|
|
|
|
|
|
|
|
endpoint->local_node = node;
|
|
|
|
/*
|
|
|
|
* It doesn't matter whether the two calls below succeed.
|
|
|
|
* If they don't then the default value 0 is used.
|
|
|
|
*/
|
|
|
|
of_property_read_u32(port_node, "reg", &endpoint->port);
|
|
|
|
of_property_read_u32(node, "reg", &endpoint->id);
|
|
|
|
|
|
|
|
of_node_put(port_node);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_graph_parse_endpoint);
|
|
|
|
|
2014-03-11 04:21:11 -06:00
|
|
|
/**
|
|
|
|
* of_graph_get_port_by_id() - get the port matching a given id
|
|
|
|
* @parent: pointer to the parent device node
|
|
|
|
* @id: id of the port
|
|
|
|
*
|
|
|
|
* Return: A 'port' node pointer with refcount incremented. The caller
|
|
|
|
* has to use of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)
|
|
|
|
{
|
|
|
|
struct device_node *node, *port;
|
|
|
|
|
|
|
|
node = of_get_child_by_name(parent, "ports");
|
|
|
|
if (node)
|
|
|
|
parent = node;
|
|
|
|
|
|
|
|
for_each_child_of_node(parent, port) {
|
|
|
|
u32 port_id = 0;
|
|
|
|
|
|
|
|
if (of_node_cmp(port->name, "port") != 0)
|
|
|
|
continue;
|
|
|
|
of_property_read_u32(port, "reg", &port_id);
|
|
|
|
if (id == port_id)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
of_node_put(node);
|
|
|
|
|
|
|
|
return port;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_graph_get_port_by_id);
|
|
|
|
|
2014-02-10 14:01:48 -07:00
|
|
|
/**
|
|
|
|
* of_graph_get_next_endpoint() - get next endpoint node
|
|
|
|
* @parent: pointer to the parent device node
|
|
|
|
* @prev: previous endpoint node, or NULL to get first
|
|
|
|
*
|
|
|
|
* Return: An 'endpoint' node pointer with refcount incremented. Refcount
|
2014-12-01 05:32:32 -07:00
|
|
|
* of the passed @prev node is decremented.
|
2014-02-10 14:01:48 -07:00
|
|
|
*/
|
|
|
|
struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
|
|
|
|
struct device_node *prev)
|
|
|
|
{
|
|
|
|
struct device_node *endpoint;
|
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media updates from Mauro Carvalho Chehab:
"The main set of series of patches for media subsystem, including:
- document RC sysfs class
- added an API to setup scancode to allow waking up systems using the
Remote Controller
- add API for SDR devices. Drivers are still on staging
- some API improvements for getting EDID data from media
inputs/outputs
- new DVB frontend driver for drx-j (ATSC)
- one driver (it913x/it9137) got removed, in favor of an improvement
on another driver (af9035)
- added a skeleton V4L2 PCI driver at documentation
- added a dual flash driver (lm3646)
- added a new IR driver (img-ir)
- added an IR scancode decoder for the Sharp protocol
- some improvements at the usbtv driver, to allow its core to be
reused.
- added a new SDR driver (rtl2832u_sdr)
- added a new tuner driver (msi001)
- several improvements at em28xx driver to fix PM support, device
removal and to split the V4L2 specific bits into a separate
sub-driver
- one driver got converted to videobuf2 (s2255drv)
- the e4000 tuner driver now follows an improved binding model
- some fixes at V4L2 compat32 code
- several fixes and enhancements at videobuf2 code
- some cleanups at V4L2 API documentation
- usual driver enhancements, new board additions and misc fixups"
[ NOTE! This merge effective drops commit 4329b93b283c ("of: Reduce
indentation in of_graph_get_next_endpoint").
The of_graph_get_next_endpoint() function was moved and renamed by
commit fd9fdb78a9bf ("[media] of: move graph helpers from
drivers/media/v4l2-core to drivers/of"). It was originally called
v4l2_of_get_next_endpoint() and lived in the file
drivers/media/v4l2-core/v4l2-of.c.
In that original location, it was then fixed to support empty port
nodes by commit b9db140c1e46 ("[media] v4l: of: Support empty port
nodes"), and that commit clashes badly with the dropped "Reduce
intendation" commit. I had to choose one or the other, and decided
that the "Support empty port nodes" commit was more important ]
* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (426 commits)
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
Revert "[media] em28xx-dvb: fix PCTV 461e tuner I2C binding"
[media] em28xx: fix PCTV 290e LNA oops
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
[media] m88ds3103: fix bug on .set_tone()
[media] saa7134: fix WARN_ON during resume
[media] v4l2-dv-timings: add module name, description, license
[media] videodev2.h: add parenthesis around macro arguments
[media] saa6752hs: depends on CRC32
[media] si4713: fix Kconfig dependencies
[media] Sensoray 2255 uses videobuf2
[media] adv7180: free an interrupt on failure paths in init_device()
[media] e4000: make VIDEO_V4L2 dependency optional
[media] af9033: Don't export functions for the hardware filter
[media] af9035: use af9033 PID filters
[media] af9033: implement PID filter
[media] rtl2832_sdr: do not use dynamic stack allocation
[media] e4000: fix 32-bit build error
[media] em28xx-audio: make sure audio is unmuted on open()
[media] DocBook media: v4l2_format_sdr was renamed to v4l2_sdr_format
...
2014-04-04 10:50:07 -06:00
|
|
|
struct device_node *port;
|
2014-02-10 14:01:48 -07:00
|
|
|
|
|
|
|
if (!parent)
|
|
|
|
return NULL;
|
|
|
|
|
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media updates from Mauro Carvalho Chehab:
"The main set of series of patches for media subsystem, including:
- document RC sysfs class
- added an API to setup scancode to allow waking up systems using the
Remote Controller
- add API for SDR devices. Drivers are still on staging
- some API improvements for getting EDID data from media
inputs/outputs
- new DVB frontend driver for drx-j (ATSC)
- one driver (it913x/it9137) got removed, in favor of an improvement
on another driver (af9035)
- added a skeleton V4L2 PCI driver at documentation
- added a dual flash driver (lm3646)
- added a new IR driver (img-ir)
- added an IR scancode decoder for the Sharp protocol
- some improvements at the usbtv driver, to allow its core to be
reused.
- added a new SDR driver (rtl2832u_sdr)
- added a new tuner driver (msi001)
- several improvements at em28xx driver to fix PM support, device
removal and to split the V4L2 specific bits into a separate
sub-driver
- one driver got converted to videobuf2 (s2255drv)
- the e4000 tuner driver now follows an improved binding model
- some fixes at V4L2 compat32 code
- several fixes and enhancements at videobuf2 code
- some cleanups at V4L2 API documentation
- usual driver enhancements, new board additions and misc fixups"
[ NOTE! This merge effective drops commit 4329b93b283c ("of: Reduce
indentation in of_graph_get_next_endpoint").
The of_graph_get_next_endpoint() function was moved and renamed by
commit fd9fdb78a9bf ("[media] of: move graph helpers from
drivers/media/v4l2-core to drivers/of"). It was originally called
v4l2_of_get_next_endpoint() and lived in the file
drivers/media/v4l2-core/v4l2-of.c.
In that original location, it was then fixed to support empty port
nodes by commit b9db140c1e46 ("[media] v4l: of: Support empty port
nodes"), and that commit clashes badly with the dropped "Reduce
intendation" commit. I had to choose one or the other, and decided
that the "Support empty port nodes" commit was more important ]
* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (426 commits)
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
Revert "[media] em28xx-dvb: fix PCTV 461e tuner I2C binding"
[media] em28xx: fix PCTV 290e LNA oops
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
[media] m88ds3103: fix bug on .set_tone()
[media] saa7134: fix WARN_ON during resume
[media] v4l2-dv-timings: add module name, description, license
[media] videodev2.h: add parenthesis around macro arguments
[media] saa6752hs: depends on CRC32
[media] si4713: fix Kconfig dependencies
[media] Sensoray 2255 uses videobuf2
[media] adv7180: free an interrupt on failure paths in init_device()
[media] e4000: make VIDEO_V4L2 dependency optional
[media] af9033: Don't export functions for the hardware filter
[media] af9035: use af9033 PID filters
[media] af9033: implement PID filter
[media] rtl2832_sdr: do not use dynamic stack allocation
[media] e4000: fix 32-bit build error
[media] em28xx-audio: make sure audio is unmuted on open()
[media] DocBook media: v4l2_format_sdr was renamed to v4l2_sdr_format
...
2014-04-04 10:50:07 -06:00
|
|
|
/*
|
|
|
|
* Start by locating the port node. If no previous endpoint is specified
|
|
|
|
* search for the first port node, otherwise get the previous endpoint
|
|
|
|
* parent port node.
|
|
|
|
*/
|
2014-02-10 14:01:48 -07:00
|
|
|
if (!prev) {
|
|
|
|
struct device_node *node;
|
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media updates from Mauro Carvalho Chehab:
"The main set of series of patches for media subsystem, including:
- document RC sysfs class
- added an API to setup scancode to allow waking up systems using the
Remote Controller
- add API for SDR devices. Drivers are still on staging
- some API improvements for getting EDID data from media
inputs/outputs
- new DVB frontend driver for drx-j (ATSC)
- one driver (it913x/it9137) got removed, in favor of an improvement
on another driver (af9035)
- added a skeleton V4L2 PCI driver at documentation
- added a dual flash driver (lm3646)
- added a new IR driver (img-ir)
- added an IR scancode decoder for the Sharp protocol
- some improvements at the usbtv driver, to allow its core to be
reused.
- added a new SDR driver (rtl2832u_sdr)
- added a new tuner driver (msi001)
- several improvements at em28xx driver to fix PM support, device
removal and to split the V4L2 specific bits into a separate
sub-driver
- one driver got converted to videobuf2 (s2255drv)
- the e4000 tuner driver now follows an improved binding model
- some fixes at V4L2 compat32 code
- several fixes and enhancements at videobuf2 code
- some cleanups at V4L2 API documentation
- usual driver enhancements, new board additions and misc fixups"
[ NOTE! This merge effective drops commit 4329b93b283c ("of: Reduce
indentation in of_graph_get_next_endpoint").
The of_graph_get_next_endpoint() function was moved and renamed by
commit fd9fdb78a9bf ("[media] of: move graph helpers from
drivers/media/v4l2-core to drivers/of"). It was originally called
v4l2_of_get_next_endpoint() and lived in the file
drivers/media/v4l2-core/v4l2-of.c.
In that original location, it was then fixed to support empty port
nodes by commit b9db140c1e46 ("[media] v4l: of: Support empty port
nodes"), and that commit clashes badly with the dropped "Reduce
intendation" commit. I had to choose one or the other, and decided
that the "Support empty port nodes" commit was more important ]
* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (426 commits)
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
Revert "[media] em28xx-dvb: fix PCTV 461e tuner I2C binding"
[media] em28xx: fix PCTV 290e LNA oops
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
[media] m88ds3103: fix bug on .set_tone()
[media] saa7134: fix WARN_ON during resume
[media] v4l2-dv-timings: add module name, description, license
[media] videodev2.h: add parenthesis around macro arguments
[media] saa6752hs: depends on CRC32
[media] si4713: fix Kconfig dependencies
[media] Sensoray 2255 uses videobuf2
[media] adv7180: free an interrupt on failure paths in init_device()
[media] e4000: make VIDEO_V4L2 dependency optional
[media] af9033: Don't export functions for the hardware filter
[media] af9035: use af9033 PID filters
[media] af9033: implement PID filter
[media] rtl2832_sdr: do not use dynamic stack allocation
[media] e4000: fix 32-bit build error
[media] em28xx-audio: make sure audio is unmuted on open()
[media] DocBook media: v4l2_format_sdr was renamed to v4l2_sdr_format
...
2014-04-04 10:50:07 -06:00
|
|
|
|
2014-02-10 14:01:48 -07:00
|
|
|
node = of_get_child_by_name(parent, "ports");
|
|
|
|
if (node)
|
|
|
|
parent = node;
|
|
|
|
|
|
|
|
port = of_get_child_by_name(parent, "port");
|
|
|
|
of_node_put(node);
|
|
|
|
|
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media updates from Mauro Carvalho Chehab:
"The main set of series of patches for media subsystem, including:
- document RC sysfs class
- added an API to setup scancode to allow waking up systems using the
Remote Controller
- add API for SDR devices. Drivers are still on staging
- some API improvements for getting EDID data from media
inputs/outputs
- new DVB frontend driver for drx-j (ATSC)
- one driver (it913x/it9137) got removed, in favor of an improvement
on another driver (af9035)
- added a skeleton V4L2 PCI driver at documentation
- added a dual flash driver (lm3646)
- added a new IR driver (img-ir)
- added an IR scancode decoder for the Sharp protocol
- some improvements at the usbtv driver, to allow its core to be
reused.
- added a new SDR driver (rtl2832u_sdr)
- added a new tuner driver (msi001)
- several improvements at em28xx driver to fix PM support, device
removal and to split the V4L2 specific bits into a separate
sub-driver
- one driver got converted to videobuf2 (s2255drv)
- the e4000 tuner driver now follows an improved binding model
- some fixes at V4L2 compat32 code
- several fixes and enhancements at videobuf2 code
- some cleanups at V4L2 API documentation
- usual driver enhancements, new board additions and misc fixups"
[ NOTE! This merge effective drops commit 4329b93b283c ("of: Reduce
indentation in of_graph_get_next_endpoint").
The of_graph_get_next_endpoint() function was moved and renamed by
commit fd9fdb78a9bf ("[media] of: move graph helpers from
drivers/media/v4l2-core to drivers/of"). It was originally called
v4l2_of_get_next_endpoint() and lived in the file
drivers/media/v4l2-core/v4l2-of.c.
In that original location, it was then fixed to support empty port
nodes by commit b9db140c1e46 ("[media] v4l: of: Support empty port
nodes"), and that commit clashes badly with the dropped "Reduce
intendation" commit. I had to choose one or the other, and decided
that the "Support empty port nodes" commit was more important ]
* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (426 commits)
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
Revert "[media] em28xx-dvb: fix PCTV 461e tuner I2C binding"
[media] em28xx: fix PCTV 290e LNA oops
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
[media] m88ds3103: fix bug on .set_tone()
[media] saa7134: fix WARN_ON during resume
[media] v4l2-dv-timings: add module name, description, license
[media] videodev2.h: add parenthesis around macro arguments
[media] saa6752hs: depends on CRC32
[media] si4713: fix Kconfig dependencies
[media] Sensoray 2255 uses videobuf2
[media] adv7180: free an interrupt on failure paths in init_device()
[media] e4000: make VIDEO_V4L2 dependency optional
[media] af9033: Don't export functions for the hardware filter
[media] af9035: use af9033 PID filters
[media] af9033: implement PID filter
[media] rtl2832_sdr: do not use dynamic stack allocation
[media] e4000: fix 32-bit build error
[media] em28xx-audio: make sure audio is unmuted on open()
[media] DocBook media: v4l2_format_sdr was renamed to v4l2_sdr_format
...
2014-04-04 10:50:07 -06:00
|
|
|
if (!port) {
|
|
|
|
pr_err("%s(): no port node found in %s\n",
|
|
|
|
__func__, parent->full_name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
port = of_get_parent(prev);
|
|
|
|
if (WARN_ONCE(!port, "%s(): endpoint %s has no parent node\n",
|
|
|
|
__func__, prev->full_name))
|
|
|
|
return NULL;
|
2014-02-10 14:01:48 -07:00
|
|
|
}
|
|
|
|
|
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media updates from Mauro Carvalho Chehab:
"The main set of series of patches for media subsystem, including:
- document RC sysfs class
- added an API to setup scancode to allow waking up systems using the
Remote Controller
- add API for SDR devices. Drivers are still on staging
- some API improvements for getting EDID data from media
inputs/outputs
- new DVB frontend driver for drx-j (ATSC)
- one driver (it913x/it9137) got removed, in favor of an improvement
on another driver (af9035)
- added a skeleton V4L2 PCI driver at documentation
- added a dual flash driver (lm3646)
- added a new IR driver (img-ir)
- added an IR scancode decoder for the Sharp protocol
- some improvements at the usbtv driver, to allow its core to be
reused.
- added a new SDR driver (rtl2832u_sdr)
- added a new tuner driver (msi001)
- several improvements at em28xx driver to fix PM support, device
removal and to split the V4L2 specific bits into a separate
sub-driver
- one driver got converted to videobuf2 (s2255drv)
- the e4000 tuner driver now follows an improved binding model
- some fixes at V4L2 compat32 code
- several fixes and enhancements at videobuf2 code
- some cleanups at V4L2 API documentation
- usual driver enhancements, new board additions and misc fixups"
[ NOTE! This merge effective drops commit 4329b93b283c ("of: Reduce
indentation in of_graph_get_next_endpoint").
The of_graph_get_next_endpoint() function was moved and renamed by
commit fd9fdb78a9bf ("[media] of: move graph helpers from
drivers/media/v4l2-core to drivers/of"). It was originally called
v4l2_of_get_next_endpoint() and lived in the file
drivers/media/v4l2-core/v4l2-of.c.
In that original location, it was then fixed to support empty port
nodes by commit b9db140c1e46 ("[media] v4l: of: Support empty port
nodes"), and that commit clashes badly with the dropped "Reduce
intendation" commit. I had to choose one or the other, and decided
that the "Support empty port nodes" commit was more important ]
* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (426 commits)
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
Revert "[media] em28xx-dvb: fix PCTV 461e tuner I2C binding"
[media] em28xx: fix PCTV 290e LNA oops
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
[media] m88ds3103: fix bug on .set_tone()
[media] saa7134: fix WARN_ON during resume
[media] v4l2-dv-timings: add module name, description, license
[media] videodev2.h: add parenthesis around macro arguments
[media] saa6752hs: depends on CRC32
[media] si4713: fix Kconfig dependencies
[media] Sensoray 2255 uses videobuf2
[media] adv7180: free an interrupt on failure paths in init_device()
[media] e4000: make VIDEO_V4L2 dependency optional
[media] af9033: Don't export functions for the hardware filter
[media] af9035: use af9033 PID filters
[media] af9033: implement PID filter
[media] rtl2832_sdr: do not use dynamic stack allocation
[media] e4000: fix 32-bit build error
[media] em28xx-audio: make sure audio is unmuted on open()
[media] DocBook media: v4l2_format_sdr was renamed to v4l2_sdr_format
...
2014-04-04 10:50:07 -06:00
|
|
|
while (1) {
|
|
|
|
/*
|
|
|
|
* Now that we have a port node, get the next endpoint by
|
|
|
|
* getting the next child. If the previous endpoint is NULL this
|
|
|
|
* will return the first child.
|
|
|
|
*/
|
|
|
|
endpoint = of_get_next_child(port, prev);
|
|
|
|
if (endpoint) {
|
|
|
|
of_node_put(port);
|
|
|
|
return endpoint;
|
|
|
|
}
|
2014-02-26 12:43:42 -07:00
|
|
|
|
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media updates from Mauro Carvalho Chehab:
"The main set of series of patches for media subsystem, including:
- document RC sysfs class
- added an API to setup scancode to allow waking up systems using the
Remote Controller
- add API for SDR devices. Drivers are still on staging
- some API improvements for getting EDID data from media
inputs/outputs
- new DVB frontend driver for drx-j (ATSC)
- one driver (it913x/it9137) got removed, in favor of an improvement
on another driver (af9035)
- added a skeleton V4L2 PCI driver at documentation
- added a dual flash driver (lm3646)
- added a new IR driver (img-ir)
- added an IR scancode decoder for the Sharp protocol
- some improvements at the usbtv driver, to allow its core to be
reused.
- added a new SDR driver (rtl2832u_sdr)
- added a new tuner driver (msi001)
- several improvements at em28xx driver to fix PM support, device
removal and to split the V4L2 specific bits into a separate
sub-driver
- one driver got converted to videobuf2 (s2255drv)
- the e4000 tuner driver now follows an improved binding model
- some fixes at V4L2 compat32 code
- several fixes and enhancements at videobuf2 code
- some cleanups at V4L2 API documentation
- usual driver enhancements, new board additions and misc fixups"
[ NOTE! This merge effective drops commit 4329b93b283c ("of: Reduce
indentation in of_graph_get_next_endpoint").
The of_graph_get_next_endpoint() function was moved and renamed by
commit fd9fdb78a9bf ("[media] of: move graph helpers from
drivers/media/v4l2-core to drivers/of"). It was originally called
v4l2_of_get_next_endpoint() and lived in the file
drivers/media/v4l2-core/v4l2-of.c.
In that original location, it was then fixed to support empty port
nodes by commit b9db140c1e46 ("[media] v4l: of: Support empty port
nodes"), and that commit clashes badly with the dropped "Reduce
intendation" commit. I had to choose one or the other, and decided
that the "Support empty port nodes" commit was more important ]
* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (426 commits)
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
Revert "[media] em28xx-dvb: fix PCTV 461e tuner I2C binding"
[media] em28xx: fix PCTV 290e LNA oops
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
[media] m88ds3103: fix bug on .set_tone()
[media] saa7134: fix WARN_ON during resume
[media] v4l2-dv-timings: add module name, description, license
[media] videodev2.h: add parenthesis around macro arguments
[media] saa6752hs: depends on CRC32
[media] si4713: fix Kconfig dependencies
[media] Sensoray 2255 uses videobuf2
[media] adv7180: free an interrupt on failure paths in init_device()
[media] e4000: make VIDEO_V4L2 dependency optional
[media] af9033: Don't export functions for the hardware filter
[media] af9035: use af9033 PID filters
[media] af9033: implement PID filter
[media] rtl2832_sdr: do not use dynamic stack allocation
[media] e4000: fix 32-bit build error
[media] em28xx-audio: make sure audio is unmuted on open()
[media] DocBook media: v4l2_format_sdr was renamed to v4l2_sdr_format
...
2014-04-04 10:50:07 -06:00
|
|
|
/* No more endpoints under this port, try the next one. */
|
|
|
|
prev = NULL;
|
2014-02-26 12:43:42 -07:00
|
|
|
|
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media updates from Mauro Carvalho Chehab:
"The main set of series of patches for media subsystem, including:
- document RC sysfs class
- added an API to setup scancode to allow waking up systems using the
Remote Controller
- add API for SDR devices. Drivers are still on staging
- some API improvements for getting EDID data from media
inputs/outputs
- new DVB frontend driver for drx-j (ATSC)
- one driver (it913x/it9137) got removed, in favor of an improvement
on another driver (af9035)
- added a skeleton V4L2 PCI driver at documentation
- added a dual flash driver (lm3646)
- added a new IR driver (img-ir)
- added an IR scancode decoder for the Sharp protocol
- some improvements at the usbtv driver, to allow its core to be
reused.
- added a new SDR driver (rtl2832u_sdr)
- added a new tuner driver (msi001)
- several improvements at em28xx driver to fix PM support, device
removal and to split the V4L2 specific bits into a separate
sub-driver
- one driver got converted to videobuf2 (s2255drv)
- the e4000 tuner driver now follows an improved binding model
- some fixes at V4L2 compat32 code
- several fixes and enhancements at videobuf2 code
- some cleanups at V4L2 API documentation
- usual driver enhancements, new board additions and misc fixups"
[ NOTE! This merge effective drops commit 4329b93b283c ("of: Reduce
indentation in of_graph_get_next_endpoint").
The of_graph_get_next_endpoint() function was moved and renamed by
commit fd9fdb78a9bf ("[media] of: move graph helpers from
drivers/media/v4l2-core to drivers/of"). It was originally called
v4l2_of_get_next_endpoint() and lived in the file
drivers/media/v4l2-core/v4l2-of.c.
In that original location, it was then fixed to support empty port
nodes by commit b9db140c1e46 ("[media] v4l: of: Support empty port
nodes"), and that commit clashes badly with the dropped "Reduce
intendation" commit. I had to choose one or the other, and decided
that the "Support empty port nodes" commit was more important ]
* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (426 commits)
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
Revert "[media] em28xx-dvb: fix PCTV 461e tuner I2C binding"
[media] em28xx: fix PCTV 290e LNA oops
[media] em28xx-dvb: fix PCTV 461e tuner I2C binding
[media] m88ds3103: fix bug on .set_tone()
[media] saa7134: fix WARN_ON during resume
[media] v4l2-dv-timings: add module name, description, license
[media] videodev2.h: add parenthesis around macro arguments
[media] saa6752hs: depends on CRC32
[media] si4713: fix Kconfig dependencies
[media] Sensoray 2255 uses videobuf2
[media] adv7180: free an interrupt on failure paths in init_device()
[media] e4000: make VIDEO_V4L2 dependency optional
[media] af9033: Don't export functions for the hardware filter
[media] af9035: use af9033 PID filters
[media] af9033: implement PID filter
[media] rtl2832_sdr: do not use dynamic stack allocation
[media] e4000: fix 32-bit build error
[media] em28xx-audio: make sure audio is unmuted on open()
[media] DocBook media: v4l2_format_sdr was renamed to v4l2_sdr_format
...
2014-04-04 10:50:07 -06:00
|
|
|
do {
|
|
|
|
port = of_get_next_child(parent, port);
|
|
|
|
if (!port)
|
|
|
|
return NULL;
|
|
|
|
} while (of_node_cmp(port->name, "port"));
|
|
|
|
}
|
2014-02-10 14:01:48 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_graph_get_next_endpoint);
|
|
|
|
|
2015-06-12 06:59:01 -06:00
|
|
|
/**
|
|
|
|
* of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers
|
|
|
|
* @parent: pointer to the parent device node
|
|
|
|
* @port_reg: identifier (value of reg property) of the parent port node
|
|
|
|
* @reg: identifier (value of reg property) of the endpoint node
|
|
|
|
*
|
|
|
|
* Return: An 'endpoint' node pointer which is identified by reg and at the same
|
|
|
|
* is the child of a port node identified by port_reg. reg and port_reg are
|
|
|
|
* ignored when they are -1.
|
|
|
|
*/
|
|
|
|
struct device_node *of_graph_get_endpoint_by_regs(
|
|
|
|
const struct device_node *parent, int port_reg, int reg)
|
|
|
|
{
|
|
|
|
struct of_endpoint endpoint;
|
|
|
|
struct device_node *node, *prev_node = NULL;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
node = of_graph_get_next_endpoint(parent, prev_node);
|
|
|
|
of_node_put(prev_node);
|
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
|
|
|
|
of_graph_parse_endpoint(node, &endpoint);
|
|
|
|
if (((port_reg == -1) || (endpoint.port == port_reg)) &&
|
|
|
|
((reg == -1) || (endpoint.id == reg)))
|
|
|
|
return node;
|
|
|
|
|
|
|
|
prev_node = node;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-06-22 18:19:10 -06:00
|
|
|
EXPORT_SYMBOL(of_graph_get_endpoint_by_regs);
|
2015-06-12 06:59:01 -06:00
|
|
|
|
2014-02-10 14:01:48 -07:00
|
|
|
/**
|
|
|
|
* of_graph_get_remote_port_parent() - get remote port's parent node
|
|
|
|
* @node: pointer to a local endpoint device_node
|
|
|
|
*
|
|
|
|
* Return: Remote device node associated with remote endpoint node linked
|
|
|
|
* to @node. Use of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_graph_get_remote_port_parent(
|
|
|
|
const struct device_node *node)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
unsigned int depth;
|
|
|
|
|
|
|
|
/* Get remote endpoint node. */
|
|
|
|
np = of_parse_phandle(node, "remote-endpoint", 0);
|
|
|
|
|
|
|
|
/* Walk 3 levels up only if there is 'ports' node. */
|
|
|
|
for (depth = 3; depth && np; depth--) {
|
|
|
|
np = of_get_next_parent(np);
|
|
|
|
if (depth == 2 && of_node_cmp(np->name, "ports"))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_graph_get_remote_port_parent);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_graph_get_remote_port() - get remote port node
|
|
|
|
* @node: pointer to a local endpoint device_node
|
|
|
|
*
|
|
|
|
* Return: Remote port node associated with remote endpoint node linked
|
|
|
|
* to @node. Use of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_graph_get_remote_port(const struct device_node *node)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
|
|
|
|
/* Get remote endpoint node. */
|
|
|
|
np = of_parse_phandle(node, "remote-endpoint", 0);
|
|
|
|
if (!np)
|
|
|
|
return NULL;
|
|
|
|
return of_get_next_parent(np);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_graph_get_remote_port);
|