Release 4.12 include/linux/of.h

Directory: include/linux
#ifndef _LINUX_OF_H

#define _LINUX_OF_H
/*
 * Definitions for talking to the Open Firmware PROM on
 * Power Macintosh and other computers.
 *
 * Copyright (C) 1996-2005 Paul Mackerras.
 *
 * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
 * Updates for SPARC64 by David S. Miller
 * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp.
 *
 * 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/types.h>
#include <linux/bitops.h>
#include <linux/errno.h>
#include <linux/kobject.h>
#include <linux/mod_devicetable.h>
#include <linux/spinlock.h>
#include <linux/topology.h>
#include <linux/notifier.h>
#include <linux/property.h>
#include <linux/list.h>

#include <asm/byteorder.h>
#include <asm/errno.h>


typedef u32 phandle;

typedef u32 ihandle;


struct property {
	
char	*name;
	
int	length;
	
void	*value;
	
struct property *next;
	
unsigned long _flags;
	
unsigned int unique_id;
	
struct bin_attribute attr;
};

#if defined(CONFIG_SPARC)
struct of_irq_controller;
#endif


struct device_node {
	
const char *name;
	
const char *type;
	
phandle phandle;
	
const char *full_name;
	
struct fwnode_handle fwnode;

	
struct	property *properties;
	
struct	property *deadprops;	/* removed properties */
	
struct	device_node *parent;
	
struct	device_node *child;
	
struct	device_node *sibling;
	
struct	kobject kobj;
	
unsigned long _flags;
	
void	*data;
#if defined(CONFIG_SPARC)
	
const char *path_component_name;
	
unsigned int unique_id;
	
struct of_irq_controller *irq_trans;
#endif
};


#define MAX_PHANDLE_ARGS 16

struct of_phandle_args {
	
struct device_node *np;
	
int args_count;
	
uint32_t args[MAX_PHANDLE_ARGS];
};


struct of_phandle_iterator {
	/* Common iterator information */
	
const char *cells_name;
	
int cell_count;
	
const struct device_node *parent;

	/* List size information */
	
const __be32 *list_end;
	
const __be32 *phandle_end;

	/* Current position state */
	
const __be32 *cur;
	
uint32_t cur_count;
	
phandle phandle;
	
struct device_node *node;
};


struct of_reconfig_data {
	
struct device_node	*dn;
	
struct property		*prop;
	
struct property		*old_prop;
};

/* initialize a node */
extern struct kobj_type of_node_ktype;


static inline void of_node_init(struct device_node *node)
{
	kobject_init(&node->kobj, &of_node_ktype);
	node->fwnode.type = FWNODE_OF;
}

Contributors
Person Tokens Prop Commits CommitProp
Pantelis Antoniou 23 74.19% 1 50.00%
Rafael J. Wysocki 8 25.81% 1 50.00%
Total 31 100.00% 2 100.00%

/* true when node is initialized */


static inline int of_node_is_initialized(struct device_node *node)
{
	return node && node->kobj.state_initialized;
}

Contributors
Person Tokens Prop Commits CommitProp
Pantelis Antoniou 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%

/* true when node is attached (i.e. present on sysfs) */


static inline int of_node_is_attached(struct device_node *node)
{
	return node && node->kobj.state_in_sysfs;
}

Contributors
Person Tokens Prop Commits CommitProp
Pantelis Antoniou 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%

#ifdef CONFIG_OF_DYNAMIC
extern struct device_node *of_node_get(struct device_node *node);
extern void of_node_put(struct device_node *node);
#else /* CONFIG_OF_DYNAMIC */
/* Dummy ref counting routines - to be implemented later */


static inline struct device_node *of_node_get(struct device_node *node)
{
	return node;
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 10 58.82% 1 50.00%
Grant C. Likely 7 41.18% 1 50.00%
Total 17 100.00% 2 100.00%



static inline void of_node_put(struct device_node *node) { }
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 8 72.73% 1 50.00%
Grant C. Likely 3 27.27% 1 50.00%
Total 11 100.00% 2 100.00%

#endif /* !CONFIG_OF_DYNAMIC */

/* Pointer for first entry in chain of all nodes. */
extern struct device_node *of_root;
extern struct device_node *of_chosen;
extern struct device_node *of_aliases;
extern struct device_node *of_stdout;
extern raw_spinlock_t devtree_lock;

/* flag descriptions (need to be visible even when !CONFIG_OF) */

#define OF_DYNAMIC	1 
/* node and properties were allocated via kmalloc */

#define OF_DETACHED	2 
/* node has been detached from the device tree */

#define OF_POPULATED	3 
/* device already created for the node */

#define OF_POPULATED_BUS	4 
/* of_platform_populate recursed to children of this node */


#define OF_BAD_ADDR	((u64)-1)

#ifdef CONFIG_OF
void of_core_init(void);



static inline bool is_of_node(struct fwnode_handle *fwnode)
{
	return !IS_ERR_OR_NULL(fwnode) && fwnode->type == FWNODE_OF;
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 21 84.00% 1 50.00%
Heikki Krogerus 4 16.00% 1 50.00%
Total 25 100.00% 2 100.00%



static inline struct device_node *to_of_node(struct fwnode_handle *fwnode)
{
	return is_of_node(fwnode) ?
		container_of(fwnode, struct device_node, fwnode) : NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 28 87.50% 1 33.33%
Andy Shevchenko 3 9.38% 1 33.33%
Alexander Sverdlin 1 3.12% 1 33.33%
Total 32 100.00% 3 100.00%


#define of_fwnode_handle(node) (&(node)->fwnode)



static inline bool of_have_populated_dt(void)
{
	return of_root != NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Sebastian Andrzej Siewior 13 92.86% 1 50.00%
Grant C. Likely 1 7.14% 1 50.00%
Total 14 100.00% 2 100.00%



static inline bool of_node_is_root(const struct device_node *node)
{
	return node && (node->parent == NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
Andres Salomon 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
{
	return test_bit(flag, &n->_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Grant C. Likely 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static inline int of_node_test_and_set_flag(struct device_node *n,
					    unsigned long flag)
{
	return test_and_set_bit(flag, &n->_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Pawel Moll 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
{
	set_bit(flag, &n->_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Grant C. Likely 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
{
	clear_bit(flag, &n->_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Pantelis Antoniou 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static inline int of_property_check_flag(struct property *p, unsigned long flag)
{
	return test_bit(flag, &p->_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Pantelis Antoniou 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static inline void of_property_set_flag(struct property *p, unsigned long flag)
{
	set_bit(flag, &p->_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Pantelis Antoniou 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static inline void of_property_clear_flag(struct property *p, unsigned long flag)
{
	clear_bit(flag, &p->_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Pantelis Antoniou 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%

extern struct device_node *__of_find_all_nodes(struct device_node *prev);
extern struct device_node *of_find_all_nodes(struct device_node *prev);

/*
 * OF address retrieval & translation
 */

/* Helper to read a big number; size is in cells (not bytes) */


static inline u64 of_read_number(const __be32 *cell, int size)
{
	u64 r = 0;
	while (size--)
		r = (r << 32) | be32_to_cpu(*(cell++));
	return r;
}

Contributors
Person Tokens Prop Commits CommitProp
Grant C. Likely 41 91.11% 1 50.00%
Jeremy Kerr 4 8.89% 1 50.00%
Total 45 100.00% 2 100.00%

/* Like of_read_number, but we want an unsigned long result */


static inline unsigned long of_read_ulong(const __be32 *cell, int size)
{
	/* toss away upper bits if unsigned long is smaller than u64 */
	return of_read_number(cell, size);
}

Contributors
Person Tokens Prop Commits CommitProp
Grant C. Likely 24 96.00% 2 66.67%
Jeremy Kerr 1 4.00% 1 33.33%
Total 25 100.00% 3 100.00%

#if defined(CONFIG_SPARC)
#include <asm/prom.h>
#endif

/* Default #address and #size cells.  Allow arch asm/prom.h to override */
#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)

#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1

#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
#endif


#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)

#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)



static inline const char *of_node_full_name(const struct device_node *np)
{
	return np ? np->full_name : "<no-node>";
}

Contributors
Person Tokens Prop Commits CommitProp
Grant C. Likely 23 95.83% 1 50.00%
Steffen Trumtrar 1 4.17% 1 50.00%
Total 24 100.00% 2 100.00%


#define for_each_of_allnodes_from(from, dn) \
	for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn))

#define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn)
extern struct device_node *of_find_node_by_name(struct device_node *from,
	const char *name);
extern struct device_node *of_find_node_by_type(struct device_node *from,
	const char *type);
extern struct device_node *of_find_compatible_node(struct device_node *from,
	const char *type, const char *compat);
extern 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);

extern struct device_node *of_find_node_opts_by_path(const char *path,
	const char **opts);


static inline struct device_node *of_find_node_by_path(const char *path)
{
	return of_find_node_opts_by_path(path, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
Leif Lindholm 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%

extern struct device_node *of_find_node_by_phandle(phandle handle);
extern struct device_node *of_get_parent(const struct device_node *node);
extern struct device_node *of_get_next_parent(struct device_node *node);
extern struct device_node *of_get_next_child(const struct device_node *node,
					     struct device_node *prev);
extern struct device_node *of_get_next_available_child(
	const struct device_node *node, struct device_node *prev);

extern struct device_node *of_get_child_by_name(const struct device_node *node,
					const char *name);

/* cache lookup */
extern struct device_node *of_find_next_cache_node(const struct device_node *);
extern int of_find_last_cache_level(unsigned int cpu);
extern struct device_node *of_find_node_with_property(
	struct device_node *from, const char *prop_name);

extern struct property *of_find_property(const struct device_node *np,
					 const char *name,
					 int *lenp);
extern int of_property_count_elems_of_size(const struct device_node *np,
				const char *propname, int elem_size);
extern int of_property_read_u32_index(const struct device_node *np,
				       const char *propname,
				       u32 index, u32 *out_value);
extern int of_property_read_u64_index(const struct device_node *np,
				       const char *propname,
				       u32 index, u64 *out_value);
extern int of_property_read_variable_u8_array(const struct device_node *np,
					const char *propname, u8 *out_values,
					size_t sz_min, size_t sz_max);
extern int of_property_read_variable_u16_array(const struct device_node *np,
					const char *propname, u16 *out_values,
					size_t sz_min, size_t sz_max);
extern int of_property_read_variable_u32_array(const struct device_node *np,
					const char *propname,
					u32 *out_values,
					size_t sz_min,
					size_t sz_max);
extern int of_property_read_u64(const struct device_node *np,
				const char *propname, u64 *out_value);
extern int of_property_read_variable_u64_array(const struct device_node *np,
					const char *propname,
					u64 *out_values,
					size_t sz_min,
					size_t sz_max);

extern int of_property_read_string(const struct device_node *np,
				   const char *propname,
				   const char **out_string);
extern int of_property_match_string(const struct device_node *np,
				    const char *propname,
				    const char *string);
extern int of_property_read_string_helper(const struct device_node *np,
					      const char *propname,
					      const char **out_strs, size_t sz, int index);
extern int of_device_is_compatible(const struct device_node *device,
				   const char *);
extern int of_device_compatible_match(struct device_node *device,
				      const char *const *compat);
extern bool of_device_is_available(const struct device_node *device);
extern bool of_device_is_big_endian(const struct device_node *device);
extern const void *of_get_property(const struct device_node *node,
				const char *name,
				int *lenp);
extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);

#define for_each_property_of_node(dn, pp) \
	for (pp = dn->properties; pp != NULL; pp = pp->next)

extern int of_n_addr_cells(struct device_node *np);
extern int of_n_size_cells(struct device_node *np);
extern const struct of_device_id *of_match_node(
	const struct of_device_id *matches, const struct device_node *node);
extern int of_modalias_node(struct device_node *node, char *modalias, int len);
extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
extern struct device_node *of_parse_phandle(const struct device_node *np,
					    const char *phandle_name,
					    int index);
extern 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);
extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
	const char *list_name, int cells_count, int index,
	struct of_phandle_args *out_args);
extern int of_count_phandle_with_args(const struct device_node *np,
	const char *list_name, const char *cells_name);

/* phandle iterator functions */
extern int of_phandle_iterator_init(struct of_phandle_iterator *it,
				    const struct device_node *np,
				    const char *list_name,
				    const char *cells_name,
				    int cell_count);

extern int of_phandle_iterator_next(struct of_phandle_iterator *it);
extern int of_phandle_iterator_args(struct of_phandle_iterator *it,
				    uint32_t *args,
				    int size);

extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
extern int of_alias_get_id(struct device_node *np, const char *stem);
extern int of_alias_get_highest_id(const char *stem);

extern int of_machine_is_compatible(const char *compat);

extern int of_add_property(struct device_node *np, struct property *prop);
extern int of_remove_property(struct device_node *np, struct property *prop);
extern int of_update_property(struct device_node *np, struct property *newprop);

/* For updating the device tree at runtime */

#define OF_RECONFIG_ATTACH_NODE		0x0001

#define OF_RECONFIG_DETACH_NODE		0x0002

#define OF_RECONFIG_ADD_PROPERTY	0x0003

#define OF_RECONFIG_REMOVE_PROPERTY	0x0004

#define OF_RECONFIG_UPDATE_PROPERTY	0x0005

extern int of_attach_node(struct device_node *);
extern int of_detach_node(struct device_node *);


#define of_match_ptr(_ptr)	(_ptr)

/**
 * 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.
 * @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 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>;
 *
 * The out_values is modified only if a valid u8 value can be decoded.
 */


static inline int of_property_read_u8_array(const struct device_node *np,
					    const char *propname,
					    u8 *out_values, size_t sz)
{
	int ret = of_property_read_variable_u8_array(np, propname, out_values,
						     sz, 0);
	if (ret >= 0)
		return 0;
	else
		return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Richard Fitzgerald 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%

/**
 * 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.
 * @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 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>;
 *
 * The out_values is modified only if a valid u16 value can be decoded.
 */


static inline int of_property_read_u16_array(const struct device_node *np,
					     const char *propname,
					     u16 *out_values, size_t sz)
{
	int ret = of_property_read_variable_u16_array(np, propname, out_values,
						      sz, 0);
	if (ret >= 0)
		return 0;
	else
		return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Richard Fitzgerald 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%

/**
 * of_property_read_u32_array - Find and read an array of 32 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 32-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 u32 value can be decoded.
 */


static inline int of_property_read_u32_array(const struct device_node *np,
					     const char *propname,
					     u32 *out_values, size_t sz)
{
	int ret = of_property_read_variable_u32_array(np, propname, out_values,
						      sz, 0);
	if (ret >= 0)
		return 0;
	else
		return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Richard Fitzgerald 54 100.00% 1 100.00%
Total 54 100.00% 1 100.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.
 */


static inline int of_property_read_u64_array(const struct device_node *np,
					     const char *propname,
					     u64 *out_values, size_t sz)
{
	int ret = of_property_read_variable_u64_array(np, propname, out_values,
						      sz, 0);
	if (ret >= 0)
		return 0;
	else
		return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Richard Fitzgerald 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%

/*
 * struct property *prop;
 * const __be32 *p;
 * u32 u;
 *
 * of_property_for_each_u32(np, "propname", prop, p, u)
 *         printk("U32 value: %x\n", u);
 */
const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
			       u32 *pu);
/*
 * struct property *prop;
 * const char *s;
 *
 * of_property_for_each_string(np, "propname", prop, s)
 *         printk("String value: %s\n", s);
 */
const char *of_prop_next_string(struct property *prop, const char *cur);

bool of_console_check(struct device_node *dn, char *name, int index);

#else /* CONFIG_OF */



static inline void of_core_init(void)
{
}

Contributors
Person Tokens Prop Commits CommitProp
Sudeep Holla 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%



static inline bool is_of_node(struct fwnode_handle *fwnode)
{
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static inline struct device_node *to_of_node(struct fwnode_handle *fwnode)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 16 94.12% 1 50.00%
Alexander Sverdlin 1 5.88% 1 50.00%
Total 17 100.00% 2 100.00%



static inline const char* of_node_full_name(const struct device_node *np)
{
	return "<no-node>";
}

Contributors
Person Tokens Prop Commits CommitProp
Grant C. Likely 17 94.44% 1 50.00%
Stephen Rothwell 1 5.56% 1 50.00%
Total 18 100.00% 2 100.00%



static inline struct device_node *of_find_node_by_name(struct device_node *from,
	const char *name)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Peter Ujfalusi 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%



static inline struct device_node *of_find_node_by_type(struct device_node *from,
	const char *type)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Shiyan 15 68.18% 1 50.00%
Rob Herring 7 31.82% 1 50.00%
Total 22 100.00% 2 100.00%



static inline 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)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 27 90.00% 1 50.00%
Sebastian Andrzej Siewior 3 10.00% 1 50.00%
Total 30 100.00% 2 100.00%



static inline struct device_node *of_find_node_by_path(const char *path)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexander Shiyan 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%



static inline struct device_node *of_find_node_opts_by_path(const char *path,
	const char **opts)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Leif Lindholm 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%



static inline struct device_node *of_find_node_by_phandle(phandle handle)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Suman Anna 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static inline struct device_node *of_get_parent(const struct device_node *node)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 10 55.56% 1 50.00%
David Howells 8 44.44% 1 50.00%
Total 18 100.00% 2 100.00%



static inline struct device_node *of_get_next_child(
	const struct device_node *node, struct device_node *prev)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 20 86.96% 1 50.00%
Stephen Warren 3 13.04% 1 50.00%
Total 23 100.00% 2 100.00%



static inline struct device_node *of_get_next_available_child(
	const struct device_node *node, struct device_node *prev)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 20 86.96% 1 33.33%
Stephen Warren 2 8.70% 1 33.33%
Sylwester Nawrocki 1 4.35% 1 33.33%
Total 23 100.00% 3 100.00%



static inline struct device_node *of_find_node_with_property(
	struct device_node *from, const char *prop_name)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Olof Johansson 19 86.36% 1 50.00%
Rob Herring 3 13.64% 1 50.00%
Total 22 100.00% 2 100.00%


#define of_fwnode_handle(node) NULL



static inline bool of_have_populated_dt(void)
{
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Dong Aisheng 8 66.67% 1 50.00%
Rob Herring 4 33.33% 1 50.00%
Total 12 100.00% 2 100.00%



static inline struct device_node *of_get_child_by_name(
					const struct device_node *node,
					const char *name)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Bryan Wu 12 52.17% 1 50.00%
Rob Herring 11 47.83% 1 50.00%
Total 23 100.00% 2 100.00%



static inline int of_device_is_compatible(const struct device_node *device,
					  const char *name)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Rajendra Nayak 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static inline bool of_device_is_available(const struct device_node *device)
{
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 14 87.50% 1 50.00%
Kevin Cernekee 2 12.50% 1 50.00%
Total 16 100.00% 2 100.00%



static inline bool of_device_is_big_endian(const struct device_node *device)
{
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Kevin Cernekee 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static inline struct property *of_find_property(const struct device_node *np,
						const char *name,
						int *lenp)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Stephen Warren 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static inline struct device_node *of_find_compatible_node(
						struct device_node *from,
						const char *type,
						const char *compat)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Shawn Guo 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static inline int </
Person	Tokens	Prop	Commits	CommitProp
Pantelis Antoniou	23	74.19%	1	50.00%
Rafael J. Wysocki	8	25.81%	1	50.00%
Total	31	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.12 include/linux/of.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
