[linux-2.6-block.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);

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

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

#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);
	43
8a0662d9 RW	44	bool fwnode_property_present(struct fwnode_handle fwnode, const char propname);
	45	int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
	46	const char propname, u8 val,
	47	size_t nval);
	48	int fwnode_property_read_u16_array(struct fwnode_handle *fwnode,
	49	const char propname, u16 val,
	50	size_t nval);
	51	int fwnode_property_read_u32_array(struct fwnode_handle *fwnode,
	52	const char propname, u32 val,
	53	size_t nval);
	54	int fwnode_property_read_u64_array(struct fwnode_handle *fwnode,
	55	const char propname, u64 val,
	56	size_t nval);
	57	int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
	58	const char propname, const char *val,
	59	size_t nval);
	60	int fwnode_property_read_string(struct fwnode_handle *fwnode,
	61	const char propname, const char *val);
	62
	63	struct fwnode_handle device_get_next_child_node(struct device dev,
	64	struct fwnode_handle *child);
	65
	66	#define device_for_each_child_node(dev, child) \
	67	for (child = device_get_next_child_node(dev, NULL); child; \
	68	child = device_get_next_child_node(dev, child))
	69
	70	void fwnode_handle_put(struct fwnode_handle *fwnode);
	71
	72	unsigned int device_get_child_node_count(struct device *dev);
	73
b31384fa RW	74	static inline bool device_property_read_bool(struct device *dev,
	75	const char *propname)
	76	{
	77	return device_property_present(dev, propname);
	78	}
	79
	80	static inline int device_property_read_u8(struct device *dev,
	81	const char propname, u8 val)
	82	{
	83	return device_property_read_u8_array(dev, propname, val, 1);
	84	}
	85
	86	static inline int device_property_read_u16(struct device *dev,
	87	const char propname, u16 val)
	88	{
	89	return device_property_read_u16_array(dev, propname, val, 1);
	90	}
	91
	92	static inline int device_property_read_u32(struct device *dev,
	93	const char propname, u32 val)
	94	{
	95	return device_property_read_u32_array(dev, propname, val, 1);
	96	}
	97
	98	static inline int device_property_read_u64(struct device *dev,
	99	const char propname, u64 val)
	100	{
	101	return device_property_read_u64_array(dev, propname, val, 1);
	102	}
	103
8a0662d9 RW	104	static inline bool fwnode_property_read_bool(struct fwnode_handle *fwnode,
	105	const char *propname)
	106	{
	107	return fwnode_property_present(fwnode, propname);
	108	}
	109
	110	static inline int fwnode_property_read_u8(struct fwnode_handle *fwnode,
	111	const char propname, u8 val)
	112	{
	113	return fwnode_property_read_u8_array(fwnode, propname, val, 1);
	114	}
	115
	116	static inline int fwnode_property_read_u16(struct fwnode_handle *fwnode,
	117	const char propname, u16 val)
	118	{
	119	return fwnode_property_read_u16_array(fwnode, propname, val, 1);
	120	}
	121
	122	static inline int fwnode_property_read_u32(struct fwnode_handle *fwnode,
	123	const char propname, u32 val)
	124	{
	125	return fwnode_property_read_u32_array(fwnode, propname, val, 1);
	126	}
	127
	128	static inline int fwnode_property_read_u64(struct fwnode_handle *fwnode,
	129	const char propname, u64 val)
	130	{
	131	return fwnode_property_read_u64_array(fwnode, propname, val, 1);
	132	}
	133
16ba08d5 RW	134	/**
	135	* struct property_entry - "Built-in" device property representation.
	136	* @name: Name of the property.
	137	* @type: Type of the property.
	138	* @nval: Number of items of type @type making up the value.
	139	* @value: Value of the property (an array of @nval items of type @type).
	140	*/
	141	struct property_entry {
	142	const char *name;
	143	enum dev_prop_type type;
	144	size_t nval;
	145	union {
	146	void *raw_data;
	147	u8 *u8_data;
	148	u16 *u16_data;
	149	u32 *u32_data;
	150	u64 *u64_data;
	151	const char **str;
	152	} value;
	153	};
	154
	155	/**
	156	* struct property_set - Collection of "built-in" device properties.
	157	* @fwnode: Handle to be pointed to by the fwnode field of struct device.
	158	* @properties: Array of properties terminated with a null entry.
	159	*/
	160	struct property_set {
	161	struct fwnode_handle fwnode;
	162	struct property_entry *properties;
	163	};
	164
	165	void device_add_property_set(struct device dev, struct property_set pset);
	166
05ca5560 SS	167	bool device_dma_is_coherent(struct device *dev);
05ca5560 SS	168
b31384fa	169	#endif /* _LINUX_PROPERTY_H_ */