[deliverable/linux.git] / include / linux / property.h

/*
 * property.h - Unified device property interface.
 *
 * Copyright (C) 2014, Intel Corporation
 * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 *          Mika Westerberg <mika.westerberg@linux.intel.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#ifndef _LINUX_PROPERTY_H_
#define _LINUX_PROPERTY_H_

#include <linux/fwnode.h>
#include <linux/types.h>

struct device;

enum dev_prop_type {
	DEV_PROP_U8,
	DEV_PROP_U16,
	DEV_PROP_U32,
	DEV_PROP_U64,
	DEV_PROP_STRING,
	DEV_PROP_MAX,
};

bool device_property_present(struct device *dev, const char *propname);
int device_property_read_u8_array(struct device *dev, const char *propname,
				  u8 *val, size_t nval);
int device_property_read_u16_array(struct device *dev, const char *propname,
				   u16 *val, size_t nval);
int device_property_read_u32_array(struct device *dev, const char *propname,
				   u32 *val, size_t nval);
int device_property_read_u64_array(struct device *dev, const char *propname,
				   u64 *val, size_t nval);
int device_property_read_string_array(struct device *dev, const char *propname,
				      const char **val, size_t nval);
int device_property_read_string(struct device *dev, const char *propname,
				const char **val);
int device_property_match_string(struct device *dev,
				 const char *propname, const char *string);

bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname);
int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
				  const char *propname, u8 *val,
				  size_t nval);
int fwnode_property_read_u16_array(struct fwnode_handle *fwnode,
				   const char *propname, u16 *val,
				   size_t nval);
int fwnode_property_read_u32_array(struct fwnode_handle *fwnode,
				   const char *propname, u32 *val,
				   size_t nval);
int fwnode_property_read_u64_array(struct fwnode_handle *fwnode,
				   const char *propname, u64 *val,
				   size_t nval);
int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
				      const char *propname, const char **val,
				      size_t nval);
int fwnode_property_read_string(struct fwnode_handle *fwnode,
				const char *propname, const char **val);
int fwnode_property_match_string(struct fwnode_handle *fwnode,
				 const char *propname, const char *string);

struct fwnode_handle *device_get_next_child_node(struct device *dev,
						 struct fwnode_handle *child);

#define device_for_each_child_node(dev, child) \
	for (child = device_get_next_child_node(dev, NULL); child; \
	     child = device_get_next_child_node(dev, child))

void fwnode_handle_put(struct fwnode_handle *fwnode);

unsigned int device_get_child_node_count(struct device *dev);

static inline bool device_property_read_bool(struct device *dev,
					     const char *propname)
{
	return device_property_present(dev, propname);
}

static inline int device_property_read_u8(struct device *dev,
					  const char *propname, u8 *val)
{
	return device_property_read_u8_array(dev, propname, val, 1);
}

static inline int device_property_read_u16(struct device *dev,
					   const char *propname, u16 *val)
{
	return device_property_read_u16_array(dev, propname, val, 1);
}

static inline int device_property_read_u32(struct device *dev,
					   const char *propname, u32 *val)
{
	return device_property_read_u32_array(dev, propname, val, 1);
}

static inline int device_property_read_u64(struct device *dev,
					   const char *propname, u64 *val)
{
	return device_property_read_u64_array(dev, propname, val, 1);
}

static inline bool fwnode_property_read_bool(struct fwnode_handle *fwnode,
					     const char *propname)
{
	return fwnode_property_present(fwnode, propname);
}

static inline int fwnode_property_read_u8(struct fwnode_handle *fwnode,
					  const char *propname, u8 *val)
{
	return fwnode_property_read_u8_array(fwnode, propname, val, 1);
}

static inline int fwnode_property_read_u16(struct fwnode_handle *fwnode,
					   const char *propname, u16 *val)
{
	return fwnode_property_read_u16_array(fwnode, propname, val, 1);
}

static inline int fwnode_property_read_u32(struct fwnode_handle *fwnode,
					   const char *propname, u32 *val)
{
	return fwnode_property_read_u32_array(fwnode, propname, val, 1);
}

static inline int fwnode_property_read_u64(struct fwnode_handle *fwnode,
					   const char *propname, u64 *val)
{
	return fwnode_property_read_u64_array(fwnode, propname, val, 1);
}

/**
 * struct property_entry - "Built-in" device property representation.
 * @name: Name of the property.
 * @type: Type of the property.
 * @nval: Number of items of type @type making up the value.
 * @value: Value of the property (an array of @nval items of type @type).
 */
struct property_entry {
	const char *name;
	enum dev_prop_type type;
	size_t nval;
	union {
		void *raw_data;
		u8 *u8_data;
		u16 *u16_data;
		u32 *u32_data;
		u64 *u64_data;
		const char **str;
	} value;
};

/**
 * struct property_set - Collection of "built-in" device properties.
 * @fwnode: Handle to be pointed to by the fwnode field of struct device.
 * @properties: Array of properties terminated with a null entry.
 */
struct property_set {
	struct fwnode_handle fwnode;
	struct property_entry *properties;
};

void device_add_property_set(struct device *dev, struct property_set *pset);

bool device_dma_is_coherent(struct device *dev);

int device_get_phy_mode(struct device *dev);

void *device_get_mac_address(struct device *dev, char *addr, int alen);

#endif /* _LINUX_PROPERTY_H_ */
Commit	Line	Data
b31384fa RW	1	/*
	2	* property.h - Unified device property interface.
	3	*
	4	* Copyright (C) 2014, Intel Corporation
	5	* Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
	6	* Mika Westerberg <mika.westerberg@linux.intel.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#ifndef _LINUX_PROPERTY_H_
	14	#define _LINUX_PROPERTY_H_
	15
ce793486	16	#include <linux/fwnode.h>
b31384fa RW	17	#include <linux/types.h>
	18
	19	struct device;
	20
	21	enum dev_prop_type {
	22	DEV_PROP_U8,
	23	DEV_PROP_U16,
	24	DEV_PROP_U32,
	25	DEV_PROP_U64,
	26	DEV_PROP_STRING,
	27	DEV_PROP_MAX,
	28	};
	29
	30	bool device_property_present(struct device dev, const char propname);
	31	int device_property_read_u8_array(struct device dev, const char propname,
	32	u8 *val, size_t nval);
	33	int device_property_read_u16_array(struct device dev, const char propname,
	34	u16 *val, size_t nval);
	35	int device_property_read_u32_array(struct device dev, const char propname,
	36	u32 *val, size_t nval);
	37	int device_property_read_u64_array(struct device dev, const char propname,
	38	u64 *val, size_t nval);
	39	int device_property_read_string_array(struct device dev, const char propname,
	40	const char **val, size_t nval);
	41	int device_property_read_string(struct device dev, const char propname,
	42	const char **val);
3f5c8d31 MW	43	int device_property_match_string(struct device *dev,
3f5c8d31 MW	44	const char propname, const char string);
b31384fa	45
8a0662d9 RW	46	bool fwnode_property_present(struct fwnode_handle fwnode, const char propname);
	47	int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
	48	const char propname, u8 val,
	49	size_t nval);
	50	int fwnode_property_read_u16_array(struct fwnode_handle *fwnode,
	51	const char propname, u16 val,
	52	size_t nval);
	53	int fwnode_property_read_u32_array(struct fwnode_handle *fwnode,
	54	const char propname, u32 val,
	55	size_t nval);
	56	int fwnode_property_read_u64_array(struct fwnode_handle *fwnode,
	57	const char propname, u64 val,
	58	size_t nval);
	59	int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
	60	const char propname, const char *val,
	61	size_t nval);
	62	int fwnode_property_read_string(struct fwnode_handle *fwnode,
	63	const char propname, const char *val);
3f5c8d31 MW	64	int fwnode_property_match_string(struct fwnode_handle *fwnode,
3f5c8d31 MW	65	const char propname, const char string);
8a0662d9 RW	66
	67	struct fwnode_handle device_get_next_child_node(struct device dev,
	68	struct fwnode_handle *child);
	69
	70	#define device_for_each_child_node(dev, child) \
	71	for (child = device_get_next_child_node(dev, NULL); child; \
	72	child = device_get_next_child_node(dev, child))
	73
	74	void fwnode_handle_put(struct fwnode_handle *fwnode);
	75
	76	unsigned int device_get_child_node_count(struct device *dev);
	77
b31384fa RW	78	static inline bool device_property_read_bool(struct device *dev,
	79	const char *propname)
	80	{
	81	return device_property_present(dev, propname);
	82	}
	83
	84	static inline int device_property_read_u8(struct device *dev,
	85	const char propname, u8 val)
	86	{
	87	return device_property_read_u8_array(dev, propname, val, 1);
	88	}
	89
	90	static inline int device_property_read_u16(struct device *dev,
	91	const char propname, u16 val)
	92	{
	93	return device_property_read_u16_array(dev, propname, val, 1);
	94	}
	95
	96	static inline int device_property_read_u32(struct device *dev,
	97	const char propname, u32 val)
	98	{
	99	return device_property_read_u32_array(dev, propname, val, 1);
	100	}
	101
	102	static inline int device_property_read_u64(struct device *dev,
	103	const char propname, u64 val)
	104	{
	105	return device_property_read_u64_array(dev, propname, val, 1);
	106	}
	107
8a0662d9 RW	108	static inline bool fwnode_property_read_bool(struct fwnode_handle *fwnode,
	109	const char *propname)
	110	{
	111	return fwnode_property_present(fwnode, propname);
	112	}
	113
	114	static inline int fwnode_property_read_u8(struct fwnode_handle *fwnode,
	115	const char propname, u8 val)
	116	{
	117	return fwnode_property_read_u8_array(fwnode, propname, val, 1);
	118	}
	119
	120	static inline int fwnode_property_read_u16(struct fwnode_handle *fwnode,
	121	const char propname, u16 val)
	122	{
	123	return fwnode_property_read_u16_array(fwnode, propname, val, 1);
	124	}
	125
	126	static inline int fwnode_property_read_u32(struct fwnode_handle *fwnode,
	127	const char propname, u32 val)
	128	{
	129	return fwnode_property_read_u32_array(fwnode, propname, val, 1);
	130	}
	131
	132	static inline int fwnode_property_read_u64(struct fwnode_handle *fwnode,
	133	const char propname, u64 val)
	134	{
	135	return fwnode_property_read_u64_array(fwnode, propname, val, 1);
	136	}
	137
16ba08d5 RW	138	/**
	139	* struct property_entry - "Built-in" device property representation.
	140	* @name: Name of the property.
	141	* @type: Type of the property.
	142	* @nval: Number of items of type @type making up the value.
	143	* @value: Value of the property (an array of @nval items of type @type).
	144	*/
	145	struct property_entry {
	146	const char *name;
	147	enum dev_prop_type type;
	148	size_t nval;
	149	union {
	150	void *raw_data;
	151	u8 *u8_data;
	152	u16 *u16_data;
	153	u32 *u32_data;
	154	u64 *u64_data;
	155	const char **str;
	156	} value;
	157	};
	158
	159	/**
	160	* struct property_set - Collection of "built-in" device properties.
	161	* @fwnode: Handle to be pointed to by the fwnode field of struct device.
	162	* @properties: Array of properties terminated with a null entry.
	163	*/
	164	struct property_set {
	165	struct fwnode_handle fwnode;
	166	struct property_entry *properties;
	167	};
	168
	169	void device_add_property_set(struct device dev, struct property_set pset);
	170
05ca5560 SS	171	bool device_dma_is_coherent(struct device *dev);
05ca5560 SS	172
4c96b7dc JL	173	int device_get_phy_mode(struct device *dev);
	174
	175	void device_get_mac_address(struct device dev, char *addr, int alen);
	176
b31384fa	177	#endif /* _LINUX_PROPERTY_H_ */