mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Tejun Heo](/assets/img/avatar_default.png)
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>
967 lines
24 KiB
C
967 lines
24 KiB
C
/*
|
|
* 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
|
|
*
|
|
* Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
|
|
* Grant Likely.
|
|
*
|
|
* 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.
|
|
*/
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/proc_fs.h>
|
|
|
|
struct device_node *allnodes;
|
|
struct device_node *of_chosen;
|
|
|
|
/* use when traversing tree through the allnext, child, sibling,
|
|
* or parent members of struct device_node.
|
|
*/
|
|
DEFINE_RWLOCK(devtree_lock);
|
|
|
|
int of_n_addr_cells(struct device_node *np)
|
|
{
|
|
const int *ip;
|
|
|
|
do {
|
|
if (np->parent)
|
|
np = np->parent;
|
|
ip = of_get_property(np, "#address-cells", NULL);
|
|
if (ip)
|
|
return be32_to_cpup(ip);
|
|
} 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)
|
|
{
|
|
const int *ip;
|
|
|
|
do {
|
|
if (np->parent)
|
|
np = np->parent;
|
|
ip = of_get_property(np, "#size-cells", NULL);
|
|
if (ip)
|
|
return be32_to_cpup(ip);
|
|
} while (np->parent);
|
|
/* No #size-cells property for the root node */
|
|
return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
|
|
}
|
|
EXPORT_SYMBOL(of_n_size_cells);
|
|
|
|
#if !defined(CONFIG_SPARC) /* SPARC doesn't do ref counting (yet) */
|
|
/**
|
|
* 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);
|
|
#endif /* !CONFIG_SPARC */
|
|
|
|
struct property *of_find_property(const struct device_node *np,
|
|
const char *name,
|
|
int *lenp)
|
|
{
|
|
struct property *pp;
|
|
|
|
if (!np)
|
|
return NULL;
|
|
|
|
read_lock(&devtree_lock);
|
|
for (pp = np->properties; pp != 0; pp = pp->next) {
|
|
if (of_prop_cmp(pp->name, name) == 0) {
|
|
if (lenp != 0)
|
|
*lenp = pp->length;
|
|
break;
|
|
}
|
|
}
|
|
read_unlock(&devtree_lock);
|
|
|
|
return pp;
|
|
}
|
|
EXPORT_SYMBOL(of_find_property);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/*
|
|
* 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);
|
|
|
|
/** 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);
|
|
|
|
/**
|
|
* of_machine_is_compatible - Test root of device tree for a given compatible value
|
|
* @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.
|
|
*/
|
|
int of_machine_is_compatible(const char *compat)
|
|
{
|
|
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;
|
|
}
|
|
EXPORT_SYMBOL(of_machine_is_compatible);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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) {
|
|
for (pp = np->properties; pp != 0; pp = pp->next) {
|
|
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);
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
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);
|
|
|
|
/**
|
|
* of_modalias_table: Table of explicit compatible ==> modalias mappings
|
|
*
|
|
* This table allows particulare compatible property values to be mapped
|
|
* to modalias strings. This is useful for busses which do not directly
|
|
* understand the OF device tree but are populated based on data contained
|
|
* within the device tree. SPI and I2C are the two current users of this
|
|
* table.
|
|
*
|
|
* In most cases, devices do not need to be listed in this table because
|
|
* the modalias value can be derived directly from the compatible table.
|
|
* However, if for any reason a value cannot be derived, then this table
|
|
* provides a method to override the implicit derivation.
|
|
*
|
|
* At the moment, a single table is used for all bus types because it is
|
|
* assumed that the data size is small and that the compatible values
|
|
* should already be distinct enough to differentiate between SPI, I2C
|
|
* and other devices.
|
|
*/
|
|
struct of_modalias_table {
|
|
char *of_device;
|
|
char *modalias;
|
|
};
|
|
static struct of_modalias_table of_modalias_table[] = {
|
|
{ "fsl,mcu-mpc8349emitx", "mcu-mpc8349emitx" },
|
|
{ "mmc-spi-slot", "mmc_spi" },
|
|
};
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* Based on the value of the compatible property, this routine will determine
|
|
* an appropriate modalias value for a particular device tree node. Two
|
|
* separate methods are attempted to derive a modalias value.
|
|
*
|
|
* First method is to lookup the compatible value in of_modalias_table.
|
|
* Second is to strip off the manufacturer prefix from the first
|
|
* compatible entry and use the remainder as modalias
|
|
*
|
|
* This routine returns 0 on success
|
|
*/
|
|
int of_modalias_node(struct device_node *node, char *modalias, int len)
|
|
{
|
|
int i, cplen;
|
|
const char *compatible;
|
|
const char *p;
|
|
|
|
/* 1. search for exception list entry */
|
|
for (i = 0; i < ARRAY_SIZE(of_modalias_table); i++) {
|
|
compatible = of_modalias_table[i].of_device;
|
|
if (!of_device_is_compatible(node, compatible))
|
|
continue;
|
|
strlcpy(modalias, of_modalias_table[i].modalias, len);
|
|
return 0;
|
|
}
|
|
|
|
compatible = of_get_property(node, "compatible", &cplen);
|
|
if (!compatible)
|
|
return -ENODEV;
|
|
|
|
/* 2. take first compatible entry and strip manufacturer */
|
|
p = strchr(compatible, ',');
|
|
if (!p)
|
|
return -ENODEV;
|
|
p++;
|
|
strlcpy(modalias, p, len);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(of_modalias_node);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
const phandle *phandle;
|
|
int size;
|
|
|
|
phandle = of_get_property(np, phandle_name, &size);
|
|
if ((!phandle) || (size < sizeof(*phandle) * (index + 1)))
|
|
return NULL;
|
|
|
|
return of_find_node_by_phandle(phandle[index]);
|
|
}
|
|
EXPORT_SYMBOL(of_parse_phandle);
|
|
|
|
/**
|
|
* of_parse_phandles_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_node: optional pointer to device_node struct pointer (will be filled)
|
|
* @out_args: optional pointer to arguments pointer (will be filled)
|
|
*
|
|
* This function is useful to parse lists of phandles and their arguments.
|
|
* Returns 0 on success and fills out_node and out_args, on error returns
|
|
* appropriate errno value.
|
|
*
|
|
* 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:
|
|
* of_parse_phandles_with_args(node3, "list", "#list-cells", 2, &node2, &args);
|
|
*/
|
|
int of_parse_phandles_with_args(struct device_node *np, const char *list_name,
|
|
const char *cells_name, int index,
|
|
struct device_node **out_node,
|
|
const void **out_args)
|
|
{
|
|
int ret = -EINVAL;
|
|
const __be32 *list;
|
|
const __be32 *list_end;
|
|
int size;
|
|
int cur_index = 0;
|
|
struct device_node *node = NULL;
|
|
const void *args = NULL;
|
|
|
|
list = of_get_property(np, list_name, &size);
|
|
if (!list) {
|
|
ret = -ENOENT;
|
|
goto err0;
|
|
}
|
|
list_end = list + size / sizeof(*list);
|
|
|
|
while (list < list_end) {
|
|
const __be32 *cells;
|
|
const phandle *phandle;
|
|
|
|
phandle = list++;
|
|
args = list;
|
|
|
|
/* one cell hole in the list = <>; */
|
|
if (!*phandle)
|
|
goto next;
|
|
|
|
node = of_find_node_by_phandle(*phandle);
|
|
if (!node) {
|
|
pr_debug("%s: could not find phandle\n",
|
|
np->full_name);
|
|
goto err0;
|
|
}
|
|
|
|
cells = of_get_property(node, cells_name, &size);
|
|
if (!cells || size != sizeof(*cells)) {
|
|
pr_debug("%s: could not get %s for %s\n",
|
|
np->full_name, cells_name, node->full_name);
|
|
goto err1;
|
|
}
|
|
|
|
list += be32_to_cpup(cells);
|
|
if (list > list_end) {
|
|
pr_debug("%s: insufficient arguments length\n",
|
|
np->full_name);
|
|
goto err1;
|
|
}
|
|
next:
|
|
if (cur_index == index)
|
|
break;
|
|
|
|
of_node_put(node);
|
|
node = NULL;
|
|
args = NULL;
|
|
cur_index++;
|
|
}
|
|
|
|
if (!node) {
|
|
/*
|
|
* args w/o node indicates that the loop above has stopped at
|
|
* the 'hole' cell. Report this differently.
|
|
*/
|
|
if (args)
|
|
ret = -EEXIST;
|
|
else
|
|
ret = -ENOENT;
|
|
goto err0;
|
|
}
|
|
|
|
if (out_node)
|
|
*out_node = node;
|
|
if (out_args)
|
|
*out_args = args;
|
|
|
|
return 0;
|
|
err1:
|
|
of_node_put(node);
|
|
err0:
|
|
pr_debug("%s failed with status %d\n", __func__, ret);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(of_parse_phandles_with_args);
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
#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) */
|
|
|