Release 4.7 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 pantelis antoniou 23 74.19% 1 50.00%
rafael j. wysocki 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 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 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 rob herring 10 58.82% 1 50.00%
grant likely grant 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 rob herring 8 72.73% 1 50.00%
grant likely grant 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 rafael j. wysocki 21 84.00% 1 50.00%
heikki krogerus 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 rafael j. wysocki 28 87.50% 1 33.33%
andy shevchenko andy shevchenko 3 9.38% 1 33.33%
alexander sverdlin alexander sverdlin 1 3.12% 1 33.33%
Total 32 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 13 92.86% 1 50.00%
grant likely grant 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 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 likely grant 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 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 likely grant 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 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 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 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 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 likely grant likely 41 91.11% 1 50.00%
jeremy kerr 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 likely grant likely 24 96.00% 2 66.67%
jeremy kerr 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

/* Default string compare functions, Allow arch asm/prom.h to override */
#if !defined(of_compat_cmp)

#define of_compat_cmp(s1, s2, l)	strcasecmp((s1), (s2))

#define of_prop_cmp(s1, s2)		strcmp((s1), (s2))

#define of_node_cmp(s1, s2)		strcasecmp((s1), (s2))
#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 likely grant likely 23 95.83% 1 50.00%
steffen trumtrar 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 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 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_u8_array(const struct device_node *np,
			const char *propname, u8 *out_values, size_t sz);
extern int of_property_read_u16_array(const struct device_node *np,
			const char *propname, u16 *out_values, size_t sz);
extern int of_property_read_u32_array(const struct device_node *np,
				      const char *propname,
				      u32 *out_values,
				      size_t sz);
extern int of_property_read_u64(const struct device_node *np,
				const char *propname, u64 *out_value);
extern int of_property_read_u64_array(const struct device_node *np,
				      const char *propname,
				      u64 *out_values,
				      size_t sz);

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

/*
 * 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 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 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 rafael j. wysocki 16 94.12% 1 50.00%
alexander sverdlin 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 likely grant likely 17 94.44% 1 50.00%
stephen rothwell 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 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 alexander shiyan 15 68.18% 1 50.00%
rob herring 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 rob herring 22 73.33% 1 50.00%
sebastian andrzej siewior sebastian andrzej siewior 8 26.67% 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 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 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 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 rob herring 10 55.56% 1 50.00%
david howells 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 rob herring 20 86.96% 1 50.00%
sylwester nawrocki sylwester nawrocki 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
olof johansson olof johansson 19 82.61% 1 50.00%
rob herring rob herring 4 17.39% 1 50.00%
Total 23 100.00% 2 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
rob herring rob herring 11 50.00% 1 50.00%
dong aisheng dong aisheng 11 50.00% 1 50.00%
Total 22 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
rob herring rob herring 10 83.33% 1 50.00%
bryan wu bryan wu 2 16.67% 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
rob herring rob herring 13 56.52% 1 50.00%
bryan wu bryan wu 10 43.48% 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 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 rob herring 14 87.50% 1 50.00%
kevin cernekee 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
rob herring rob herring 9 56.25% 1 33.33%
kevin cernekee kevin cernekee 7 43.75% 2 66.67%
Total 16 100.00% 3 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 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 shawn guo 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static inline int of_property_count_elems_of_size(const struct device_node *np,
			const char *propname, int elem_size)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
heiko stuebner heiko stuebner 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%



static inline int of_property_read_u32_index(const struct device_node *np,
			const char *propname, u32 index, u32 *out_value)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
tony prisk tony prisk 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline int of_property_read_u8_array(const struct device_node *np,
			const char *propname, u8 *out_values, size_t sz)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline int of_property_read_u16_array(const struct device_node *np,
			const char *propname, u16 *out_values, size_t sz)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline int of_property_read_u32_array(const struct device_node *np,
					     const char *propname,
					     u32 *out_values, size_t sz)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
shawn guo shawn guo 28 96.55% 1 50.00%
jamie iles jamie iles 1 3.45% 1 50.00%
Total 29 100.00% 2 100.00%



static inline int of_property_read_u64_array(const struct device_node *np,
					     const char *propname,
					     u64 *out_values, size_t sz)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline int of_property_read_string(const struct device_node *np,
					  const char *propname,
					  const char **out_string)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
shawn guo shawn guo 26 92.86% 1 33.33%
david rivshin david rivshin 1 3.57% 1 33.33%
jamie iles jamie iles 1 3.57% 1 33.33%
Total 28 100.00% 3 100.00%



static inline int of_property_read_string_helper(const struct device_node *np,
						 const char *propname,
						 const char **out_strs, size_t sz, int index)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
benoit cousson benoit cousson 26 76.47% 1 33.33%
grant likely grant likely 7 20.59% 1 33.33%
david rivshin david rivshin 1 2.94% 1 33.33%
Total 34 100.00% 3 100.00%



static inline const void *of_get_property(const struct device_node *node,
				const char *name,
				int *lenp)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen warren stephen warren 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static inline struct device_node *of_get_cpu_node(int cpu,
					unsigned int *thread)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
sudeep karkadanagesha sudeep karkadanagesha 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



static inline int of_property_read_u64(const struct device_node *np,
				       const char *propname, u64 *out_value)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
jamie iles jamie iles 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static inline int of_property_match_string(const struct device_node *np,
					   const char *propname,
					   const char *string)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
thierry reding thierry reding 26 96.30% 1 50.00%
david rivshin david rivshin 1 3.70% 1 50.00%
Total 27 100.00% 2 100.00%



static inline struct device_node *of_parse_phandle(const struct device_node *np,
						   const char *phandle_name,
						   int index)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
rajendra nayak rajendra nayak 25 96.15% 1 50.00%
steffen trumtrar steffen trumtrar 1 3.85% 1 50.00%
Total 26 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
thierry reding thierry reding 34 97.14% 1 50.00%
kuninori morimoto kuninori morimoto 1 2.86% 1 50.00%
Total 35 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
stephen warren stephen warren 33 100.00% 1 100.00%
Total 33 100.00% 1 100.00%



static inline int of_count_phandle_with_args(struct device_node *np,
					     const char *list_name,
					     const char *cells_name)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
joerg roedel joerg roedel 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



static inline int of_phandle_iterator_next(struct of_phandle_iterator *it)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
joerg roedel joerg roedel 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static inline int of_phandle_iterator_args(struct of_phandle_iterator *it,
					   uint32_t *args,
					   int size)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
joerg roedel joerg roedel 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%



static inline int of_alias_get_id(struct device_node *np, const char *stem)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
nicolas ferre nicolas ferre 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static inline int of_alias_get_highest_id(const char *stem)
{
	return -ENOSYS;
}

Contributors
Person Tokens Prop Commits CommitProp
wolfram sang wolfram sang 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static inline int of_machine_is_compatible(const char *compat)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen warren stephen warren 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static inline bool of_console_check(const struct device_node *dn, const char *name, int index)
{
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 12 50.00% 1 50.00%
sascha hauer sascha hauer 12 50.00% 1 50.00%
Total 24 100.00% 2 100.00%



static inline const __be32 *of_prop_next_u32(struct property *prop,
		const __be32 *cur, u32 *pu)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static inline const char *of_prop_next_string(struct property *prop,
		const char *cur)
{
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%



static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static inline int of_node_test_and_set_flag(struct device_node *n,
					    unsigned long flag)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
{
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
{
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static inline int of_property_check_flag(struct property *p, unsigned long flag)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static inline void of_property_set_flag(struct property *p, unsigned long flag)
{
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static inline void of_property_clear_flag(struct property *p, unsigned long flag)
{
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


#define of_match_ptr(_ptr)	NULL

#define of_match_node(_matches, _node)	NULL
#endif /* CONFIG_OF */

#if defined(CONFIG_OF) && defined(CONFIG_NUMA)
extern int of_node_to_nid(struct device_node *np);
#else


static inline int of_node_to_nid(struct device_node *device)
{
	return NUMA_NO_NODE;
}
Contributors
Person Tokens Prop Commits CommitProp
paul mundt paul mundt 13 86.67% 1 33.33%
rob herring rob herring 1 6.67% 1 33.33%
konstantin khlebnikov konstantin khlebnikov 1 6.67% 1 33.33%
Total 15 100.00% 3 100.00%

#endif

#ifdef CONFIG_OF_NUMA
extern int of_numa_init(void);
#else


static inline int of_numa_init(void)
{
	return -ENOSYS;
}
Contributors
Person Tokens Prop Commits CommitProp
david daney david daney 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%

#endif



static inline struct device_node *of_find_matching_node(
	struct device_node *from,
	const struct of_device_id *matches)
{
	return of_find_matching_node_and_match(from, matches, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
rob herring rob herring 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%

/**
 * of_property_count_u8_elems - Count the number of u8 elements in a 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 node and count the number of u8 elements
 * in it. Returns number of elements on sucess, -EINVAL if the property does
 * not exist or its length does not match a multiple of u8 and -ENODATA if the
 * property does not have a value.
 */


static inline int of_property_count_u8_elems(const struct device_node *np,
				const char *propname)
{
	return of_property_count_elems_of_size(np, propname, sizeof(u8));
}

Contributors
Person Tokens Prop Commits CommitProp
heiko stuebner heiko stuebner 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * of_property_count_u16_elems - Count the number of u16 elements in a 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 node and count the number of u16 elements
 * in it. Returns number of elements on sucess, -EINVAL if the property does
 * not exist or its length does not match a multiple of u16 and -ENODATA if the
 * property does not have a value.
 */


static inline int of_property_count_u16_elems(const struct device_node *np,
				const char *propname)
{
	return of_property_count_elems_of_size(np, propname, sizeof(u16));
}

Contributors
Person Tokens Prop Commits CommitProp
heiko stuebner heiko stuebner 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * of_property_count_u32_elems - Count the number of u32 elements in a 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 node and count the number of u32 elements
 * in it. Returns number of elements on sucess, -EINVAL if the property does
 * not exist or its length does not match a multiple of u32 and -ENODATA if the
 * property does not have a value.
 */


static inline int of_property_count_u32_elems(const struct device_node *np,
				const char *propname)
{
	return of_property_count_elems_of_size(np, propname, sizeof(u32));
}

Contributors
Person Tokens Prop Commits CommitProp
heiko stuebner heiko stuebner 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * of_property_count_u64_elems - Count the number of u64 elements in a 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 node and count the number of u64 elements
 * in it. Returns number of elements on sucess, -EINVAL if the property does
 * not exist or its length does not match a multiple of u64 and -ENODATA if the
 * property does not have a value.
 */


static inline int of_property_count_u64_elems(const struct device_node *np,
				const char *propname)
{
	return of_property_count_elems_of_size(np, propname, sizeof(u64));
}

Contributors
Person Tokens Prop Commits CommitProp
heiko stuebner heiko stuebner 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * of_property_read_string_array() - Read an array 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.
 * @out_strs:   output array of string pointers.
 * @sz:         number of array elements to read.
 *
 * Search for a property in a device tree node and retrieve a list of
 * terminated string values (pointer to data, not a copy) in that property.
 *
 * If @out_strs is NULL, the number of strings in the property is returned.
 */


static inline int of_property_read_string_array(const struct device_node *np,
						const char *propname, const char **out_strs,
						size_t sz)
{
	return of_property_read_string_helper(np, propname, out_strs, sz, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 40 97.56% 1 50.00%
david rivshin david rivshin 1 2.44% 1 50.00%
Total 41 100.00% 2 100.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.
 */


static inline int of_property_count_strings(const struct device_node *np,
					    const char *propname)
{
	return of_property_read_string_helper(np, propname, NULL, 0, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 31 96.88% 1 50.00%
david rivshin david rivshin 1 3.12% 1 50.00%
Total 32 100.00% 2 100.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.
 */


static inline int of_property_read_string_index(const struct device_node *np,
						const char *propname,
						int index, const char **output)
{
	int rc = of_property_read_string_helper(np, propname, output, 1, index);
	return rc < 0 ? rc : 0;
}

Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 51 98.08% 1 50.00%
david rivshin david rivshin 1 1.92% 1 50.00%
Total 52 100.00% 2 100.00%

/**
 * of_property_read_bool - Findfrom a 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 node.
 * Returns true if the property exists false otherwise.
 */


static inline bool of_property_read_bool(const struct device_node *np,
					 const char *propname)
{
	struct property *prop = of_find_property(np, propname, NULL);

	return prop ? true : false;
}

Contributors
Person Tokens Prop Commits CommitProp
jean-christophe plagniol-villard jean-christophe plagniol-villard 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%



static inline int of_property_read_u8(const struct device_node *np,
				       const char *propname,
				       u8 *out_value)
{
	return of_property_read_u8_array(np, propname, out_value, 1);
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



static inline int of_property_read_u16(const struct device_node *np,
				       const char *propname,
				       u16 *out_value)
{
	return of_property_read_u16_array(np, propname, out_value, 1);
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



static inline int of_property_read_u32(const struct device_node *np,
				       const char *propname,
				       u32 *out_value)
{
	return of_property_read_u32_array(np, propname, out_value, 1);
}

Contributors
Person Tokens Prop Commits CommitProp
shawn guo shawn guo 33 97.06% 1 50.00%
jamie iles jamie iles 1 2.94% 1 50.00%
Total 34 100.00% 2 100.00%



static inline int of_property_read_s32(const struct device_node *np,
				       const char *propname,
				       s32 *out_value)
{
	return of_property_read_u32(np, propname, (u32*) out_value);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian reichel sebastian reichel 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%


#define of_for_each_phandle(it, err, np, ln, cn, cc)			\
	for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)),    \
             err = of_phandle_iterator_next(it);                        \
             err == 0;                                                  \
             err = of_phandle_iterator_next(it))


#define of_property_for_each_u32(np, propname, prop, p, u)	\
	for (prop = of_find_property(np, propname, NULL),       \
                p = of_prop_next_u32(prop, NULL, &u);           \
                p;                                              \
                p = of_prop_next_u32(prop, p, &u))


#define of_property_for_each_string(np, propname, prop, s)	\
	for (prop = of_find_property(np, propname, NULL),       \
                s = of_prop_next_string(prop, NULL);            \
                s;                                              \
                s = of_prop_next_string(prop, s))


#define for_each_node_by_name(dn, name) \
	for (dn = of_find_node_by_name(NULL, name); dn; \
             dn = of_find_node_by_name(dn, name))

#define for_each_node_by_type(dn, type) \
	for (dn = of_find_node_by_type(NULL, type); dn; \
             dn = of_find_node_by_type(dn, type))

#define for_each_compatible_node(dn, type, compatible) \
	for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
             dn = of_find_compatible_node(dn, type, compatible))

#define for_each_matching_node(dn, matches) \
	for (dn = of_find_matching_node(NULL, matches); dn; \
             dn = of_find_matching_node(dn, matches))

#define for_each_matching_node_and_match(dn, matches, match) \
	for (dn = of_find_matching_node_and_match(NULL, matches, match); \
             dn; dn = of_find_matching_node_and_match(dn, matches, match))


#define for_each_child_of_node(parent, child) \
	for (child = of_get_next_child(parent, NULL); child != NULL; \
             child = of_get_next_child(parent, child))

#define for_each_available_child_of_node(parent, child) \
	for (child = of_get_next_available_child(parent, NULL); child != NULL; \
             child = of_get_next_available_child(parent, child))


#define for_each_node_with_property(dn, prop_name) \
	for (dn = of_find_node_with_property(NULL, prop_name); dn; \
             dn = of_find_node_with_property(dn, prop_name))



static inline int of_get_child_count(const struct device_node *np)
{
	struct device_node *child;
	int num = 0;

	for_each_child_of_node(np, child)
		num++;

	return num;
}

Contributors
Person Tokens Prop Commits CommitProp
rob herring rob herring 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



static inline int of_get_available_child_count(const struct device_node *np)
{
	struct device_node *child;
	int num = 0;

	for_each_available_child_of_node(np, child)
		num++;

	return num;
}

Contributors
Person Tokens Prop Commits CommitProp
rob herring rob herring 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%

#if defined(CONFIG_OF) && !defined(MODULE)

#define _OF_DECLARE(table, name, compat, fn, fn_type)			\
	static const struct of_device_id __of_table_##name              \
                __used __section(__##table##_of_table)                  \
                 = { .compatible = compat,                              \
                     .data = (fn == (fn_type)NULL) ? fn : fn  }
#else

#define _OF_DECLARE(table, name, compat, fn, fn_type)			\
	static const struct of_device_id __of_table_##name              \
                __attribute__((unused))                                 \
                 = { .compatible = compat,                              \
                     .data = (fn == (fn_type)NULL) ? fn : fn }
#endif


typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);

typedef void (*of_init_fn_1)(struct device_node *);


#define OF_DECLARE_1(table, name, compat, fn) \
		_OF_DECLARE(table, name, compat, fn, of_init_fn_1)

#define OF_DECLARE_2(table, name, compat, fn) \
		_OF_DECLARE(table, name, compat, fn, of_init_fn_2)

/**
 * struct of_changeset_entry    - Holds a changeset entry
 *
 * @node:       list_head for the log list
 * @action:     notifier action
 * @np:         pointer to the device node affected
 * @prop:       pointer to the property affected
 * @old_prop:   hold a pointer to the original property
 *
 * Every modification of the device tree during a changeset
 * is held in a list of of_changeset_entry structures.
 * That way we can recover from a partial application, or we can
 * revert the changeset
 */

struct of_changeset_entry {
	
struct list_head node;
	
unsigned long action;
	
struct device_node *np;
	
struct property *prop;
	
struct property *old_prop;
};

/**
 * struct of_changeset - changeset tracker structure
 *
 * @entries:    list_head for the changeset entries
 *
 * changesets are a convenient way to apply bulk changes to the
 * live tree. In case of an error, changes are rolled-back.
 * changesets live on after initial application, and if not
 * destroyed after use, they can be reverted in one single call.
 */

struct of_changeset {
	
struct list_head entries;
};


enum of_reconfig_change {
	
OF_RECONFIG_NO_CHANGE = 0,
	
OF_RECONFIG_CHANGE_ADD,
	
OF_RECONFIG_CHANGE_REMOVE,
};

#ifdef CONFIG_OF_DYNAMIC
extern int of_reconfig_notifier_register(struct notifier_block *);
extern int of_reconfig_notifier_unregister(struct notifier_block *);
extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
extern int of_reconfig_get_state_change(unsigned long action,
					struct of_reconfig_data *arg);

extern void of_changeset_init(struct of_changeset *ocs);
extern void of_changeset_destroy(struct of_changeset *ocs);
extern int of_changeset_apply(struct of_changeset *ocs);
extern int of_changeset_revert(struct of_changeset *ocs);
extern int of_changeset_action(struct of_changeset *ocs,
		unsigned long action, struct device_node *np,
		struct property *prop);



static inline int of_changeset_attach_node(struct of_changeset *ocs,
		struct device_node *np)
{
	return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline int of_changeset_detach_node(struct of_changeset *ocs,
		struct device_node *np)
{
	return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline int of_changeset_add_property(struct of_changeset *ocs,
		struct device_node *np, struct property *prop)
{
	return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop);
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



static inline int of_changeset_remove_property(struct of_changeset *ocs,
		struct device_node *np, struct property *prop)
{
	return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop);
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



static inline int of_changeset_update_property(struct of_changeset *ocs,
		struct device_node *np, struct property *prop)
{
	return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
}
Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%

#else /* CONFIG_OF_DYNAMIC */


static inline int of_reconfig_notifier_register(struct notifier_block *nb)
{
	return -EINVAL;
}
Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
{
	return -EINVAL;
}
Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static inline int of_reconfig_notify(unsigned long action,
				     struct of_reconfig_data *arg)
{
	return -EINVAL;
}
Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 20 100.00% 2 100.00%
Total 20 100.00% 2 100.00%



static inline int of_reconfig_get_state_change(unsigned long action,
						struct of_reconfig_data *arg)
{
	return -EINVAL;
}
Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 20 100.00% 2 100.00%
Total 20 100.00% 2 100.00%

#endif /* CONFIG_OF_DYNAMIC */

/* CONFIG_OF_RESOLVE api */
extern int of_resolve_phandles(struct device_node *tree);

/**
 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node
 * @np: Pointer to the given device_node
 *
 * return true if present false otherwise
 */


static inline bool of_device_is_system_power_controller(const struct device_node *np)
{
	return of_property_read_bool(np, "system-power-controller");
}

Contributors
Person Tokens Prop Commits CommitProp
romain perier romain perier 21 100.00% 2 100.00%
Total 21 100.00% 2 100.00%

/**
 * Overlay support
 */

#ifdef CONFIG_OF_OVERLAY

/* ID based overlays; the API for external users */
int of_overlay_create(struct device_node *tree);
int of_overlay_destroy(int id);
int of_overlay_destroy_all(void);

#else



static inline int of_overlay_create(struct device_node *tree)
{
	return -ENOTSUPP;
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static inline int of_overlay_destroy(int id)
{
	return -ENOTSUPP;
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%



static inline int of_overlay_destroy_all(void)
{
	return -ENOTSUPP;
}

Contributors
Person Tokens Prop Commits CommitProp
pantelis antoniou pantelis antoniou 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%

#endif

#endif /* _LINUX_OF_H */
Overall Contributors
Person Tokens Prop Commits CommitProp
grant likely grant likely 1006 22.23% 31 22.96%
pantelis antoniou pantelis antoniou 684 15.11% 8 5.93%
rob herring rob herring 474 10.47% 7 5.19%
stephen rothwell stephen rothwell 208 4.60% 2 1.48%
joerg roedel joerg roedel 195 4.31% 4 2.96%
stephen warren stephen warren 175 3.87% 6 4.44%
viresh kumar viresh kumar 172 3.80% 1 0.74%
heiko stuebner heiko stuebner 172 3.80% 1 0.74%
shawn guo shawn guo 162 3.58% 4 2.96%
rafael j. wysocki rafael j. wysocki 147 3.25% 2 1.48%
sebastian andrzej siewior sebastian andrzej siewior 101 2.23% 2 1.48%
thierry reding thierry reding 60 1.33% 2 1.48%
leif lindholm leif lindholm 52 1.15% 1 0.74%
tony prisk tony prisk 52 1.15% 1 0.74%
jamie iles jamie iles 51 1.13% 2 1.48%
benoit cousson benoit cousson 50 1.10% 1 0.74%
sudeep karkadanagesha sudeep karkadanagesha 48 1.06% 2 1.48%
rajendra nayak rajendra nayak 46 1.02% 1 0.74%
jean-christophe plagniol-villard jean-christophe plagniol-villard 39 0.86% 1 0.74%
sebastian reichel sebastian reichel 36 0.80% 1 0.74%
thomas abraham thomas abraham 35 0.77% 1 0.74%
alexander shiyan alexander shiyan 32 0.71% 2 1.48%
nicolas ferre nicolas ferre 30 0.66% 2 1.48%
michael ellerman michael ellerman 29 0.64% 2 1.48%
nathan fontenot nathan fontenot 29 0.64% 2 1.48%
pawel moll pawel moll 27 0.60% 1 0.74%
david daney david daney 27 0.60% 1 0.74%
anton vorontsov anton vorontsov 26 0.57% 1 0.74%
wolfram sang wolfram sang 26 0.57% 1 0.74%
andres salomon andres salomon 24 0.53% 1 0.74%
peter ujfalusi peter ujfalusi 22 0.49% 1 0.74%
romain perier romain perier 22 0.49% 2 1.48%
kevin cernekee kevin cernekee 21 0.46% 2 1.48%
paul mundt paul mundt 19 0.42% 1 0.74%
olof johansson olof johansson 19 0.42% 1 0.74%
sascha hauer sascha hauer 19 0.42% 1 0.74%
timur tabi timur tabi 18 0.40% 1 0.74%
suman anna suman anna 15 0.33% 1 0.74%
dong aisheng dong aisheng 15 0.33% 2 1.48%
ben dooks ben dooks 14 0.31% 1 0.74%
sudeep holla sudeep holla 14 0.31% 1 0.74%
bryan wu bryan wu 12 0.27% 1 0.74%
srinivas kandagatla srinivas kandagatla 12 0.27% 1 0.74%
masahiro yamada masahiro yamada 11 0.24% 1 0.74%
jeremy kerr jeremy kerr 11 0.24% 2 1.48%
josh boyer josh boyer 10 0.22% 1 0.74%
david rivshin david rivshin 9 0.20% 1 0.74%
david howells david howells 8 0.18% 1 0.74%
linus torvalds linus torvalds 4 0.09% 1 0.74%
guenter roeck guenter roeck 4 0.09% 1 0.74%
heikki krogerus heikki krogerus 4 0.09% 1 0.74%
andy shevchenko andy shevchenko 3 0.07% 1 0.74%
paul gortmaker paul gortmaker 3 0.07% 1 0.74%
kalle valo kalle valo 3 0.07% 1 0.74%
steffen trumtrar steffen trumtrar 3 0.07% 2 1.48%
sylwester nawrocki sylwester nawrocki 3 0.07% 1 0.74%
hans de goede hans de goede 3 0.07% 1 0.74%
alexander sverdlin alexander sverdlin 2 0.04% 1 0.74%
jiri slaby jiri slaby 1 0.02% 1 0.74%
konstantin khlebnikov konstantin khlebnikov 1 0.02% 1 0.74%
andreas herrmann andreas herrmann 1 0.02% 1 0.74%
guennadi liakhovetski guennadi liakhovetski 1 0.02% 1 0.74%
geert uytterhoeven geert uytterhoeven 1 0.02% 1 0.74%
lennert buytenhek lennert buytenhek 1 0.02% 1 0.74%
thomas gleixner thomas gleixner 1 0.02% 1 0.74%
kuninori morimoto kuninori morimoto 1 0.02% 1 0.74%
Total 4526 100.00% 135 100.00%
  Directory: include/linux

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
pantelis antoniou	pantelis antoniou	23	74.19%	1	50.00%
rafael j. wysocki	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.7 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

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
