2007-05-01 14:26:07 +08: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-16 00:58:09 +08:00
|
|
|
* Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
|
|
|
|
* Grant Likely.
|
2007-05-01 14:26:07 +08: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.
|
|
|
|
*/
|
2011-08-15 15:28:14 +08:00
|
|
|
#include <linux/ctype.h>
|
2007-05-01 14:26:07 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/of.h>
|
2007-04-24 14:46:53 +08: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 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2010-02-02 12:34:14 +08:00
|
|
|
#include <linux/proc_fs.h>
|
2007-04-24 14:46:53 +08:00
|
|
|
|
2011-08-15 15:28:14 +08:00
|
|
|
/**
|
|
|
|
* struct alias_prop - Alias property in 'aliases' node
|
|
|
|
* @link: List node to link the structure in aliases_lookup list
|
|
|
|
* @alias: Alias property name
|
|
|
|
* @np: Pointer to device_node that the alias stands for
|
|
|
|
* @id: Index value from end of alias name
|
|
|
|
* @stem: Alias string without the index
|
|
|
|
*
|
|
|
|
* The structure represents one alias property of 'aliases' node as
|
|
|
|
* an entry in aliases_lookup list.
|
|
|
|
*/
|
|
|
|
struct alias_prop {
|
|
|
|
struct list_head link;
|
|
|
|
const char *alias;
|
|
|
|
struct device_node *np;
|
|
|
|
int id;
|
|
|
|
char stem[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(aliases_lookup);
|
|
|
|
|
2007-04-24 15:57:33 +08:00
|
|
|
struct device_node *allnodes;
|
2010-02-14 22:13:55 +08:00
|
|
|
struct device_node *of_chosen;
|
2011-08-15 15:28:14 +08:00
|
|
|
struct device_node *of_aliases;
|
|
|
|
|
|
|
|
static DEFINE_MUTEX(of_aliases_mutex);
|
2007-04-24 15:57:33 +08:00
|
|
|
|
2007-04-24 14:46:53 +08:00
|
|
|
/* use when traversing tree through the allnext, child, sibling,
|
|
|
|
* or parent members of struct device_node.
|
|
|
|
*/
|
|
|
|
DEFINE_RWLOCK(devtree_lock);
|
2007-05-01 14:26:07 +08:00
|
|
|
|
|
|
|
int of_n_addr_cells(struct device_node *np)
|
|
|
|
{
|
2010-10-11 11:24:10 +08:00
|
|
|
const __be32 *ip;
|
2007-05-01 14:26:07 +08:00
|
|
|
|
|
|
|
do {
|
|
|
|
if (np->parent)
|
|
|
|
np = np->parent;
|
|
|
|
ip = of_get_property(np, "#address-cells", NULL);
|
|
|
|
if (ip)
|
2010-01-30 16:45:26 +08:00
|
|
|
return be32_to_cpup(ip);
|
2007-05-01 14:26:07 +08: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-11 11:24:10 +08:00
|
|
|
const __be32 *ip;
|
2007-05-01 14:26:07 +08:00
|
|
|
|
|
|
|
do {
|
|
|
|
if (np->parent)
|
|
|
|
np = np->parent;
|
|
|
|
ip = of_get_property(np, "#size-cells", NULL);
|
|
|
|
if (ip)
|
2010-01-30 16:45:26 +08:00
|
|
|
return be32_to_cpup(ip);
|
2007-05-01 14:26:07 +08: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);
|
|
|
|
|
2012-02-16 11:38:40 +08:00
|
|
|
#if defined(CONFIG_OF_DYNAMIC)
|
2010-01-29 04:52:53 +08:00
|
|
|
/**
|
|
|
|
* of_node_get - Increment refcount of a node
|
|
|
|
* @node: Node to inc refcount, NULL is supported to
|
|
|
|
* simplify writing of callers
|
|
|
|
*
|
|
|
|
* Returns node.
|
|
|
|
*/
|
|
|
|
struct device_node *of_node_get(struct device_node *node)
|
|
|
|
{
|
|
|
|
if (node)
|
|
|
|
kref_get(&node->kref);
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_node_get);
|
|
|
|
|
|
|
|
static inline struct device_node *kref_to_device_node(struct kref *kref)
|
|
|
|
{
|
|
|
|
return container_of(kref, struct device_node, kref);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_node_release - release a dynamically allocated node
|
|
|
|
* @kref: kref element of the node to be released
|
|
|
|
*
|
|
|
|
* In of_node_put() this function is passed to kref_put()
|
|
|
|
* as the destructor.
|
|
|
|
*/
|
|
|
|
static void of_node_release(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct device_node *node = kref_to_device_node(kref);
|
|
|
|
struct property *prop = node->properties;
|
|
|
|
|
|
|
|
/* We should never be releasing nodes that haven't been detached. */
|
|
|
|
if (!of_node_check_flag(node, OF_DETACHED)) {
|
|
|
|
pr_err("ERROR: Bad of_node_put() on %s\n", node->full_name);
|
|
|
|
dump_stack();
|
|
|
|
kref_init(&node->kref);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!of_node_check_flag(node, OF_DYNAMIC))
|
|
|
|
return;
|
|
|
|
|
|
|
|
while (prop) {
|
|
|
|
struct property *next = prop->next;
|
|
|
|
kfree(prop->name);
|
|
|
|
kfree(prop->value);
|
|
|
|
kfree(prop);
|
|
|
|
prop = next;
|
|
|
|
|
|
|
|
if (!prop) {
|
|
|
|
prop = node->deadprops;
|
|
|
|
node->deadprops = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kfree(node->full_name);
|
|
|
|
kfree(node->data);
|
|
|
|
kfree(node);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_node_put - Decrement refcount of a node
|
|
|
|
* @node: Node to dec refcount, NULL is supported to
|
|
|
|
* simplify writing of callers
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void of_node_put(struct device_node *node)
|
|
|
|
{
|
|
|
|
if (node)
|
|
|
|
kref_put(&node->kref, of_node_release);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_node_put);
|
2012-02-16 11:38:40 +08:00
|
|
|
#endif /* CONFIG_OF_DYNAMIC */
|
2010-01-29 04:52:53 +08:00
|
|
|
|
2007-04-24 14:46:53 +08:00
|
|
|
struct property *of_find_property(const struct device_node *np,
|
|
|
|
const char *name,
|
|
|
|
int *lenp)
|
|
|
|
{
|
|
|
|
struct property *pp;
|
|
|
|
|
2008-05-08 03:19:59 +08:00
|
|
|
if (!np)
|
|
|
|
return NULL;
|
|
|
|
|
2007-04-24 14:46:53 +08:00
|
|
|
read_lock(&devtree_lock);
|
2012-06-27 12:14:45 +08:00
|
|
|
for (pp = np->properties; pp; pp = pp->next) {
|
2007-04-24 14:46:53 +08:00
|
|
|
if (of_prop_cmp(pp->name, name) == 0) {
|
2012-06-27 12:14:45 +08:00
|
|
|
if (lenp)
|
2007-04-24 14:46:53 +08:00
|
|
|
*lenp = pp->length;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
|
|
|
|
return pp;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_property);
|
|
|
|
|
2009-10-16 00:58:09 +08: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;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
np = prev ? prev->allnext : allnodes;
|
|
|
|
for (; np != NULL; np = np->allnext)
|
|
|
|
if (of_node_get(np))
|
|
|
|
break;
|
|
|
|
of_node_put(prev);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_all_nodes);
|
|
|
|
|
2007-05-01 14:26:07 +08: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,
|
|
|
|
int *lenp)
|
|
|
|
{
|
|
|
|
struct property *pp = of_find_property(np, name, lenp);
|
|
|
|
|
|
|
|
return pp ? pp->value : NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_property);
|
2007-05-01 14:29:19 +08: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)
|
|
|
|
{
|
|
|
|
const char* cp;
|
|
|
|
int cplen, l;
|
|
|
|
|
|
|
|
cp = of_get_property(device, "compatible", &cplen);
|
|
|
|
if (cp == NULL)
|
|
|
|
return 0;
|
|
|
|
while (cplen > 0) {
|
|
|
|
if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
|
|
|
|
return 1;
|
|
|
|
l = strlen(cp) + 1;
|
|
|
|
cp += l;
|
|
|
|
cplen -= l;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_device_is_compatible);
|
2007-04-24 15:16:16 +08:00
|
|
|
|
2010-01-29 04:47:25 +08:00
|
|
|
/**
|
2010-02-02 12:34:14 +08:00
|
|
|
* of_machine_is_compatible - Test root of device tree for a given compatible value
|
2010-01-29 04:47:25 +08:00
|
|
|
* @compat: compatible string to look for in root node's compatible property.
|
|
|
|
*
|
|
|
|
* Returns true if the root node has the given value in its
|
|
|
|
* compatible property.
|
|
|
|
*/
|
2010-02-02 12:34:14 +08:00
|
|
|
int of_machine_is_compatible(const char *compat)
|
2010-01-29 04:47:25 +08: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-02 12:34:14 +08:00
|
|
|
EXPORT_SYMBOL(of_machine_is_compatible);
|
2010-01-29 04:47:25 +08:00
|
|
|
|
2008-03-26 21:33:14 +08:00
|
|
|
/**
|
|
|
|
* of_device_is_available - check if a device is available for use
|
|
|
|
*
|
|
|
|
* @device: Node to check for availability
|
|
|
|
*
|
|
|
|
* Returns 1 if the status property is absent or set to "okay" or "ok",
|
|
|
|
* 0 otherwise
|
|
|
|
*/
|
|
|
|
int of_device_is_available(const struct device_node *device)
|
|
|
|
{
|
|
|
|
const char *status;
|
|
|
|
int statlen;
|
|
|
|
|
|
|
|
status = of_get_property(device, "status", &statlen);
|
|
|
|
if (status == NULL)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (statlen > 0) {
|
|
|
|
if (!strcmp(status, "okay") || !strcmp(status, "ok"))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_device_is_available);
|
|
|
|
|
2007-04-24 15:16:16 +08: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;
|
|
|
|
|
|
|
|
if (!node)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
np = of_node_get(node->parent);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_parent);
|
2007-04-24 15:21:29 +08:00
|
|
|
|
2007-10-26 14:54:31 +08:00
|
|
|
/**
|
|
|
|
* of_get_next_parent - Iterate to a node's parent
|
|
|
|
* @node: Node to get parent of
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
if (!node)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
parent = of_node_get(node->parent);
|
|
|
|
of_node_put(node);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return parent;
|
|
|
|
}
|
|
|
|
|
2007-04-24 15:21:29 +08:00
|
|
|
/**
|
|
|
|
* of_get_next_child - Iterate a node childs
|
|
|
|
* @node: parent node
|
|
|
|
* @prev: previous child of the parent node, or NULL to get first
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_get_next_child(const struct device_node *node,
|
|
|
|
struct device_node *prev)
|
|
|
|
{
|
|
|
|
struct device_node *next;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
next = prev ? prev->sibling : node->child;
|
|
|
|
for (; next; next = next->sibling)
|
|
|
|
if (of_node_get(next))
|
|
|
|
break;
|
|
|
|
of_node_put(prev);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return next;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_get_next_child);
|
2007-04-24 15:57:33 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_find_node_by_path - Find a node matching a full OF path
|
|
|
|
* @path: The full path to match
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_node_by_path(const char *path)
|
|
|
|
{
|
|
|
|
struct device_node *np = allnodes;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
for (; np; np = np->allnext) {
|
|
|
|
if (np->full_name && (of_node_cmp(np->full_name, path) == 0)
|
|
|
|
&& of_node_get(np))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_node_by_path);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
np = from ? from->allnext : allnodes;
|
|
|
|
for (; np; np = np->allnext)
|
|
|
|
if (np->name && (of_node_cmp(np->name, name) == 0)
|
|
|
|
&& of_node_get(np))
|
|
|
|
break;
|
|
|
|
of_node_put(from);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
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;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
np = from ? from->allnext : allnodes;
|
|
|
|
for (; np; np = np->allnext)
|
|
|
|
if (np->type && (of_node_cmp(np->type, type) == 0)
|
|
|
|
&& of_node_get(np))
|
|
|
|
break;
|
|
|
|
of_node_put(from);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
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;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
np = from ? from->allnext : allnodes;
|
|
|
|
for (; np; np = np->allnext) {
|
|
|
|
if (type
|
|
|
|
&& !(np->type && (of_node_cmp(np->type, type) == 0)))
|
|
|
|
continue;
|
|
|
|
if (of_device_is_compatible(np, compatible) && of_node_get(np))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
of_node_put(from);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_compatible_node);
|
2008-01-09 03:20:40 +08:00
|
|
|
|
2008-11-13 02:54:42 +08: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;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
np = from ? from->allnext : allnodes;
|
|
|
|
for (; np; np = np->allnext) {
|
2012-06-27 12:14:45 +08:00
|
|
|
for (pp = np->properties; pp; pp = pp->next) {
|
2008-11-13 02:54:42 +08:00
|
|
|
if (of_prop_cmp(pp->name, prop_name) == 0) {
|
|
|
|
of_node_get(np);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
of_node_put(from);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_node_with_property);
|
|
|
|
|
2008-01-09 03:20:40 +08:00
|
|
|
/**
|
|
|
|
* of_match_node - Tell if an device_node has a matching of_match structure
|
|
|
|
* @matches: array of of device match structures to search in
|
|
|
|
* @node: the of device structure to match against
|
|
|
|
*
|
|
|
|
* Low level utility function used by device matching.
|
|
|
|
*/
|
|
|
|
const struct of_device_id *of_match_node(const struct of_device_id *matches,
|
|
|
|
const struct device_node *node)
|
|
|
|
{
|
2011-03-19 00:21:29 +08:00
|
|
|
if (!matches)
|
|
|
|
return NULL;
|
|
|
|
|
2008-01-09 03:20:40 +08:00
|
|
|
while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
|
|
|
|
int match = 1;
|
|
|
|
if (matches->name[0])
|
|
|
|
match &= node->name
|
|
|
|
&& !strcmp(matches->name, node->name);
|
|
|
|
if (matches->type[0])
|
|
|
|
match &= node->type
|
|
|
|
&& !strcmp(matches->type, node->type);
|
|
|
|
if (matches->compatible[0])
|
|
|
|
match &= of_device_is_compatible(node,
|
|
|
|
matches->compatible);
|
|
|
|
if (match)
|
|
|
|
return matches;
|
|
|
|
matches++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_match_node);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_find_matching_node - Find a node based on an of_device_id match
|
|
|
|
* table.
|
|
|
|
* @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
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_matching_node(struct device_node *from,
|
|
|
|
const struct of_device_id *matches)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
np = from ? from->allnext : allnodes;
|
|
|
|
for (; np; np = np->allnext) {
|
|
|
|
if (of_match_node(matches, np) && of_node_get(np))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
of_node_put(from);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_matching_node);
|
2008-07-26 10:25:13 +08: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 21:48:19 +08: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-26 10:25:13 +08:00
|
|
|
*
|
2010-06-08 21:48:19 +08:00
|
|
|
* This routine returns 0 on success, <0 on failure.
|
2008-07-26 10:25:13 +08:00
|
|
|
*/
|
|
|
|
int of_modalias_node(struct device_node *node, char *modalias, int len)
|
|
|
|
{
|
2010-06-08 21:48:19 +08:00
|
|
|
const char *compatible, *p;
|
|
|
|
int cplen;
|
2008-07-26 10:25:13 +08:00
|
|
|
|
|
|
|
compatible = of_get_property(node, "compatible", &cplen);
|
2010-06-08 21:48:19 +08:00
|
|
|
if (!compatible || strlen(compatible) > cplen)
|
2008-07-26 10:25:13 +08:00
|
|
|
return -ENODEV;
|
|
|
|
p = strchr(compatible, ',');
|
2010-06-08 21:48:19 +08:00
|
|
|
strlcpy(modalias, p ? p + 1 : compatible, len);
|
2008-07-26 10:25:13 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_modalias_node);
|
|
|
|
|
2010-02-02 12:34:11 +08: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;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
for (np = allnodes; np; np = np->allnext)
|
|
|
|
if (np->phandle == handle)
|
|
|
|
break;
|
|
|
|
of_node_get(np);
|
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_node_by_phandle);
|
|
|
|
|
2011-06-30 23:56:10 +08:00
|
|
|
/**
|
2011-07-07 04:42:58 +08:00
|
|
|
* of_property_read_u32_array - Find and read an array of 32 bit integers
|
|
|
|
* from a property.
|
|
|
|
*
|
2011-06-30 23:56:10 +08:00
|
|
|
* @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.
|
|
|
|
*
|
2011-07-07 04:42:58 +08:00
|
|
|
* Search for a property in a device node and read 32-bit value(s) from
|
2011-06-30 23:56:10 +08: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.
|
|
|
|
*
|
|
|
|
* The out_value is modified only if a valid u32 value can be decoded.
|
|
|
|
*/
|
2011-08-02 22:45:07 +08:00
|
|
|
int of_property_read_u32_array(const struct device_node *np,
|
|
|
|
const char *propname, u32 *out_values,
|
|
|
|
size_t sz)
|
2011-06-30 23:56:10 +08:00
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
2011-07-07 04:42:58 +08:00
|
|
|
const __be32 *val;
|
2011-06-30 23:56:10 +08:00
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
2011-07-07 04:42:58 +08:00
|
|
|
if ((sz * sizeof(*out_values)) > prop->length)
|
2011-06-30 23:56:10 +08:00
|
|
|
return -EOVERFLOW;
|
2011-07-07 04:42:58 +08:00
|
|
|
|
|
|
|
val = prop->value;
|
|
|
|
while (sz--)
|
|
|
|
*out_values++ = be32_to_cpup(val++);
|
2011-06-30 23:56:10 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2011-07-07 04:42:58 +08:00
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u32_array);
|
2011-06-30 23:56:10 +08:00
|
|
|
|
2011-09-15 03:49:59 +08: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)
|
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
|
|
|
if (sizeof(*out_value) > prop->length)
|
|
|
|
return -EOVERFLOW;
|
|
|
|
*out_value = of_read_number(prop->value, 2);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u64);
|
|
|
|
|
2011-06-30 23:56:10 +08: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 22:45:07 +08:00
|
|
|
int of_property_read_string(struct device_node *np, const char *propname,
|
2011-07-04 09:01:18 +08:00
|
|
|
const char **out_string)
|
2011-06-30 23:56:10 +08: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-09-27 23:45:43 +08:00
|
|
|
/**
|
|
|
|
* of_property_read_string_index - Find and read a string from a multiple
|
|
|
|
* strings 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 string in the list of strings
|
|
|
|
* @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) in the list of strings
|
|
|
|
* contained in that property.
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
int of_property_read_string_index(struct device_node *np, const char *propname,
|
|
|
|
int index, const char **output)
|
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
|
|
|
int i = 0;
|
|
|
|
size_t l = 0, total = 0;
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
|
|
|
if (strnlen(prop->value, prop->length) >= prop->length)
|
|
|
|
return -EILSEQ;
|
|
|
|
|
|
|
|
p = prop->value;
|
|
|
|
|
|
|
|
for (i = 0; total < prop->length; total += l, p += l) {
|
|
|
|
l = strlen(p) + 1;
|
2011-12-05 22:23:54 +08:00
|
|
|
if (i++ == index) {
|
2011-09-27 23:45:43 +08:00
|
|
|
*output = p;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -ENODATA;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_string_index);
|
|
|
|
|
2011-12-13 00:25:58 +08: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) {
|
|
|
|
l = strlen(p) + 1;
|
|
|
|
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 23:45:43 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_property_count_strings - Find and return the number of strings from a
|
|
|
|
* multiple strings property.
|
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
|
* @propname: name of the property to be searched.
|
|
|
|
*
|
|
|
|
* Search for a property in a device tree node and retrieve the number of null
|
|
|
|
* terminated string contain in it. Returns the number of strings 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.
|
|
|
|
*/
|
|
|
|
int of_property_count_strings(struct device_node *np, const char *propname)
|
|
|
|
{
|
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
|
|
|
int i = 0;
|
|
|
|
size_t l = 0, total = 0;
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
if (!prop)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
|
|
|
if (strnlen(prop->value, prop->length) >= prop->length)
|
|
|
|
return -EILSEQ;
|
|
|
|
|
|
|
|
p = prop->value;
|
|
|
|
|
2011-12-05 22:23:54 +08:00
|
|
|
for (i = 0; total < prop->length; total += l, p += l, i++)
|
2011-09-27 23:45:43 +08:00
|
|
|
l = strlen(p) + 1;
|
2011-12-05 22:23:54 +08:00
|
|
|
|
2011-09-27 23:45:43 +08:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_property_count_strings);
|
|
|
|
|
2009-04-25 20:52:40 +08: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(struct device_node *np, const char *phandle_name, int index)
|
|
|
|
{
|
2010-07-23 15:48:25 +08:00
|
|
|
const __be32 *phandle;
|
2009-04-25 20:52:40 +08:00
|
|
|
int size;
|
|
|
|
|
|
|
|
phandle = of_get_property(np, phandle_name, &size);
|
|
|
|
if ((!phandle) || (size < sizeof(*phandle) * (index + 1)))
|
|
|
|
return NULL;
|
|
|
|
|
2010-07-23 15:48:25 +08:00
|
|
|
return of_find_node_by_phandle(be32_to_cpup(phandle + index));
|
2009-04-25 20:52:40 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_parse_phandle);
|
|
|
|
|
2008-10-10 12:43:17 +08:00
|
|
|
/**
|
2011-12-13 00:25:57 +08:00
|
|
|
* of_parse_phandle_with_args() - Find a node pointed by phandle in a list
|
2008-10-10 12:43:17 +08:00
|
|
|
* @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
|
2011-12-13 00:25:57 +08:00
|
|
|
* @out_args: optional pointer to output arguments structure (will be filled)
|
2008-10-10 12:43:17 +08:00
|
|
|
*
|
|
|
|
* This function is useful to parse lists of phandles and their arguments.
|
2011-12-13 00:25:57 +08:00
|
|
|
* Returns 0 on success and fills out_args, on error returns appropriate
|
|
|
|
* errno value.
|
|
|
|
*
|
|
|
|
* Caller is responsible to call of_node_put() on the returned out_args->node
|
|
|
|
* pointer.
|
2008-10-10 12:43:17 +08:00
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* phandle1: node1 {
|
|
|
|
* #list-cells = <2>;
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* phandle2: node2 {
|
|
|
|
* #list-cells = <1>;
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* node3 {
|
|
|
|
* list = <&phandle1 1 2 &phandle2 3>;
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* To get a device_node of the `node2' node you may call this:
|
2011-12-13 00:25:57 +08:00
|
|
|
* of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
|
2008-10-10 12:43:17 +08:00
|
|
|
*/
|
2011-12-13 00:25:57 +08:00
|
|
|
int of_parse_phandle_with_args(struct device_node *np, const char *list_name,
|
2008-10-10 12:43:17 +08:00
|
|
|
const char *cells_name, int index,
|
2011-12-13 00:25:57 +08:00
|
|
|
struct of_phandle_args *out_args)
|
2008-10-10 12:43:17 +08:00
|
|
|
{
|
2011-12-13 00:25:57 +08:00
|
|
|
const __be32 *list, *list_end;
|
|
|
|
int size, cur_index = 0;
|
|
|
|
uint32_t count = 0;
|
2008-10-10 12:43:17 +08:00
|
|
|
struct device_node *node = NULL;
|
2011-12-13 00:25:57 +08:00
|
|
|
phandle phandle;
|
2008-10-10 12:43:17 +08:00
|
|
|
|
2011-12-13 00:25:57 +08:00
|
|
|
/* Retrieve the phandle list property */
|
2008-10-10 12:43:17 +08:00
|
|
|
list = of_get_property(np, list_name, &size);
|
2011-12-13 00:25:57 +08:00
|
|
|
if (!list)
|
|
|
|
return -EINVAL;
|
2008-10-10 12:43:17 +08:00
|
|
|
list_end = list + size / sizeof(*list);
|
|
|
|
|
2011-12-13 00:25:57 +08:00
|
|
|
/* Loop over the phandles until all the requested entry is found */
|
2008-10-10 12:43:17 +08:00
|
|
|
while (list < list_end) {
|
2011-12-13 00:25:57 +08:00
|
|
|
count = 0;
|
2008-10-10 12:43:17 +08:00
|
|
|
|
2011-12-13 00:25:57 +08:00
|
|
|
/*
|
|
|
|
* If phandle is 0, then it is an empty entry with no
|
|
|
|
* arguments. Skip forward to the next entry.
|
|
|
|
*/
|
2010-07-23 15:48:25 +08:00
|
|
|
phandle = be32_to_cpup(list++);
|
2011-12-13 00:25:57 +08:00
|
|
|
if (phandle) {
|
|
|
|
/*
|
|
|
|
* Find the provider node and parse the #*-cells
|
|
|
|
* property to determine the argument length
|
|
|
|
*/
|
|
|
|
node = of_find_node_by_phandle(phandle);
|
|
|
|
if (!node) {
|
|
|
|
pr_err("%s: could not find phandle\n",
|
|
|
|
np->full_name);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
break;
|
|
|
|
}
|
2008-10-10 12:43:17 +08:00
|
|
|
|
2011-12-13 00:25:57 +08: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);
|
|
|
|
break;
|
|
|
|
}
|
2008-10-10 12:43:17 +08:00
|
|
|
}
|
|
|
|
|
2011-12-13 00:25:57 +08: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.
|
|
|
|
*/
|
|
|
|
if (cur_index == index) {
|
|
|
|
if (!phandle)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
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++);
|
|
|
|
}
|
|
|
|
return 0;
|
2008-10-10 12:43:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
of_node_put(node);
|
|
|
|
node = NULL;
|
2011-12-13 00:25:57 +08:00
|
|
|
list += count;
|
2008-10-10 12:43:17 +08:00
|
|
|
cur_index++;
|
|
|
|
}
|
|
|
|
|
2011-12-13 00:25:57 +08:00
|
|
|
/* Loop exited without finding a valid entry; return an error */
|
|
|
|
if (node)
|
|
|
|
of_node_put(node);
|
|
|
|
return -EINVAL;
|
2008-10-10 12:43:17 +08:00
|
|
|
}
|
2011-12-13 00:25:57 +08:00
|
|
|
EXPORT_SYMBOL(of_parse_phandle_with_args);
|
2009-11-24 11:16:45 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* prom_add_property - Add a property to a node
|
|
|
|
*/
|
|
|
|
int prom_add_property(struct device_node *np, struct property *prop)
|
|
|
|
{
|
|
|
|
struct property **next;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
prop->next = NULL;
|
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
|
|
|
next = &np->properties;
|
|
|
|
while (*next) {
|
|
|
|
if (strcmp(prop->name, (*next)->name) == 0) {
|
|
|
|
/* duplicate ! don't insert it */
|
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
next = &(*next)->next;
|
|
|
|
}
|
|
|
|
*next = prop;
|
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_DEVICETREE
|
|
|
|
/* try to add to proc as well if it was initialized */
|
|
|
|
if (np->pde)
|
|
|
|
proc_device_tree_add_prop(np->pde, prop);
|
|
|
|
#endif /* CONFIG_PROC_DEVICETREE */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* prom_remove_property - Remove a property from a node.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
int prom_remove_property(struct device_node *np, struct property *prop)
|
|
|
|
{
|
|
|
|
struct property **next;
|
|
|
|
unsigned long flags;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
|
|
|
next = &np->properties;
|
|
|
|
while (*next) {
|
|
|
|
if (*next == prop) {
|
|
|
|
/* found the node */
|
|
|
|
*next = prop->next;
|
|
|
|
prop->next = np->deadprops;
|
|
|
|
np->deadprops = prop;
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
next = &(*next)->next;
|
|
|
|
}
|
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
|
|
|
|
|
|
|
if (!found)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_DEVICETREE
|
|
|
|
/* try to remove the proc node as well */
|
|
|
|
if (np->pde)
|
|
|
|
proc_device_tree_remove_prop(np->pde, prop);
|
|
|
|
#endif /* CONFIG_PROC_DEVICETREE */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* prom_update_property - Update a property in a node.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
int prom_update_property(struct device_node *np,
|
|
|
|
struct property *newprop,
|
|
|
|
struct property *oldprop)
|
|
|
|
{
|
|
|
|
struct property **next;
|
|
|
|
unsigned long flags;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
|
|
|
next = &np->properties;
|
|
|
|
while (*next) {
|
|
|
|
if (*next == oldprop) {
|
|
|
|
/* found the node */
|
|
|
|
newprop->next = oldprop->next;
|
|
|
|
*next = newprop;
|
|
|
|
oldprop->next = np->deadprops;
|
|
|
|
np->deadprops = oldprop;
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
next = &(*next)->next;
|
|
|
|
}
|
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
|
|
|
|
|
|
|
if (!found)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_DEVICETREE
|
|
|
|
/* try to add to proc as well if it was initialized */
|
|
|
|
if (np->pde)
|
|
|
|
proc_device_tree_update_prop(np->pde, newprop, oldprop);
|
|
|
|
#endif /* CONFIG_PROC_DEVICETREE */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2010-01-29 20:04:33 +08:00
|
|
|
|
|
|
|
#if defined(CONFIG_OF_DYNAMIC)
|
|
|
|
/*
|
|
|
|
* Support for dynamic device trees.
|
|
|
|
*
|
|
|
|
* On some platforms, the device tree can be manipulated at runtime.
|
|
|
|
* The routines in this section support adding, removing and changing
|
|
|
|
* device tree nodes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_attach_node - Plug a device node into the tree and global list.
|
|
|
|
*/
|
|
|
|
void of_attach_node(struct device_node *np)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
|
|
|
np->sibling = np->parent->child;
|
|
|
|
np->allnext = allnodes;
|
|
|
|
np->parent->child = np;
|
|
|
|
allnodes = np;
|
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_detach_node - "Unplug" a node from the device tree.
|
|
|
|
*
|
|
|
|
* The caller must hold a reference to the node. The memory associated with
|
|
|
|
* the node is not freed until its refcount goes to zero.
|
|
|
|
*/
|
|
|
|
void of_detach_node(struct device_node *np)
|
|
|
|
{
|
|
|
|
struct device_node *parent;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
|
|
|
|
|
|
|
parent = np->parent;
|
|
|
|
if (!parent)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
if (allnodes == np)
|
|
|
|
allnodes = np->allnext;
|
|
|
|
else {
|
|
|
|
struct device_node *prev;
|
|
|
|
for (prev = allnodes;
|
|
|
|
prev->allnext != np;
|
|
|
|
prev = prev->allnext)
|
|
|
|
;
|
|
|
|
prev->allnext = np->allnext;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parent->child == np)
|
|
|
|
parent->child = np->sibling;
|
|
|
|
else {
|
|
|
|
struct device_node *prevsib;
|
|
|
|
for (prevsib = np->parent->child;
|
|
|
|
prevsib->sibling != np;
|
|
|
|
prevsib = prevsib->sibling)
|
|
|
|
;
|
|
|
|
prevsib->sibling = np->sibling;
|
|
|
|
}
|
|
|
|
|
|
|
|
of_node_set_flag(np, OF_DETACHED);
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
|
|
|
}
|
|
|
|
#endif /* defined(CONFIG_OF_DYNAMIC) */
|
|
|
|
|
2011-08-15 15:28:14 +08: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",
|
|
|
|
ap->alias, ap->stem, ap->id, np ? np->full_name : NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_alias_scan - Scan all properties of 'aliases' node
|
|
|
|
*
|
|
|
|
* The function scans all the properties of 'aliases' node and populate
|
|
|
|
* the the global lookup table with the properties. It returns the
|
|
|
|
* number of alias_prop found, or error code in error case.
|
|
|
|
*
|
|
|
|
* @dt_alloc: An allocator that provides a virtual address to memory
|
|
|
|
* for the resulting tree
|
|
|
|
*/
|
|
|
|
void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
|
|
|
|
{
|
|
|
|
struct property *pp;
|
|
|
|
|
|
|
|
of_chosen = of_find_node_by_path("/chosen");
|
|
|
|
if (of_chosen == NULL)
|
|
|
|
of_chosen = of_find_node_by_path("/chosen@0");
|
|
|
|
of_aliases = of_find_node_by_path("/aliases");
|
|
|
|
if (!of_aliases)
|
|
|
|
return;
|
|
|
|
|
2011-12-22 20:19:24 +08:00
|
|
|
for_each_property_of_node(of_aliases, pp) {
|
2011-08-15 15:28:14 +08: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;
|
|
|
|
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
|
|
|
|
*
|
|
|
|
* The function travels the lookup table to get alias id for the given
|
|
|
|
* device_node and alias stem. It returns the alias id if find it.
|
|
|
|
*/
|
|
|
|
int of_alias_get_id(struct device_node *np, const char *stem)
|
|
|
|
{
|
|
|
|
struct alias_prop *app;
|
|
|
|
int id = -ENODEV;
|
|
|
|
|
|
|
|
mutex_lock(&of_aliases_mutex);
|
|
|
|
list_for_each_entry(app, &aliases_lookup, link) {
|
|
|
|
if (strcmp(app->stem, stem) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (np == app->np) {
|
|
|
|
id = app->id;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&of_aliases_mutex);
|
|
|
|
|
|
|
|
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 23:27:46 +08: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);
|