[mirror_ubuntu-bionic-kernel.git] / include / linux / nvmem-consumer.h

/*
 * nvmem framework consumer.
 *
 * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
 * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2.  This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#ifndef _LINUX_NVMEM_CONSUMER_H
#define _LINUX_NVMEM_CONSUMER_H

#include <linux/err.h>
#include <linux/errno.h>

struct device;
struct device_node;
/* consumer cookie */
struct nvmem_cell;
struct nvmem_device;

struct nvmem_cell_info {
	const char		*name;
	unsigned int		offset;
	unsigned int		bytes;
	unsigned int		bit_offset;
	unsigned int		nbits;
};

#if IS_ENABLED(CONFIG_NVMEM)

/* Cell based interface */
struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *name);
struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *name);
void nvmem_cell_put(struct nvmem_cell *cell);
void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell);
void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len);
int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len);
int nvmem_cell_read_u32(struct device *dev, const char *cell_id, u32 *val);

/* direct nvmem device read/write interface */
struct nvmem_device *nvmem_device_get(struct device *dev, const char *name);
struct nvmem_device *devm_nvmem_device_get(struct device *dev,
					   const char *name);
void nvmem_device_put(struct nvmem_device *nvmem);
void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem);
int nvmem_device_read(struct nvmem_device *nvmem, unsigned int offset,
		      size_t bytes, void *buf);
int nvmem_device_write(struct nvmem_device *nvmem, unsigned int offset,
		       size_t bytes, void *buf);
ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
			   struct nvmem_cell_info *info, void *buf);
int nvmem_device_cell_write(struct nvmem_device *nvmem,
			    struct nvmem_cell_info *info, void *buf);

#else

static inline struct nvmem_cell *nvmem_cell_get(struct device *dev,
						const char *name)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct nvmem_cell *devm_nvmem_cell_get(struct device *dev,
				       const char *name)
{
	return ERR_PTR(-ENOSYS);
}

static inline void devm_nvmem_cell_put(struct device *dev,
				       struct nvmem_cell *cell)
{

}
static inline void nvmem_cell_put(struct nvmem_cell *cell)
{
}

static inline void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
{
	return ERR_PTR(-ENOSYS);
}

static inline int nvmem_cell_write(struct nvmem_cell *cell,
				    const char *buf, size_t len)
{
	return -ENOSYS;
}

static inline int nvmem_cell_read_u32(struct device *dev,
				      const char *cell_id, u32 *val)
{
	return -ENOSYS;
}

static inline struct nvmem_device *nvmem_device_get(struct device *dev,
						    const char *name)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct nvmem_device *devm_nvmem_device_get(struct device *dev,
							 const char *name)
{
	return ERR_PTR(-ENOSYS);
}

static inline void nvmem_device_put(struct nvmem_device *nvmem)
{
}

static inline void devm_nvmem_device_put(struct device *dev,
					 struct nvmem_device *nvmem)
{
}

static inline ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
					 struct nvmem_cell_info *info,
					 void *buf)
{
	return -ENOSYS;
}

static inline int nvmem_device_cell_write(struct nvmem_device *nvmem,
					  struct nvmem_cell_info *info,
					  void *buf)
{
	return -ENOSYS;
}

static inline int nvmem_device_read(struct nvmem_device *nvmem,
				    unsigned int offset, size_t bytes,
				    void *buf)
{
	return -ENOSYS;
}

static inline int nvmem_device_write(struct nvmem_device *nvmem,
				     unsigned int offset, size_t bytes,
				     void *buf)
{
	return -ENOSYS;
}
#endif /* CONFIG_NVMEM */

#if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)
struct nvmem_cell *of_nvmem_cell_get(struct device_node *np,
				     const char *name);
struct nvmem_device *of_nvmem_device_get(struct device_node *np,
					 const char *name);
#else
static inline struct nvmem_cell *of_nvmem_cell_get(struct device_node *np,
				     const char *name)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct nvmem_device *of_nvmem_device_get(struct device_node *np,
						       const char *name)
{
	return ERR_PTR(-ENOSYS);
}
#endif /* CONFIG_NVMEM && CONFIG_OF */

#endif  /* ifndef _LINUX_NVMEM_CONSUMER_H */
Commit	Line	Data
eace75cf SK	1	/*
	2	* nvmem framework consumer.
	3	*
	4	* Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
	5	* Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
	6	*
	7	* This file is licensed under the terms of the GNU General Public
	8	* License version 2. This program is licensed "as is" without any
	9	* warranty of any kind, whether express or implied.
	10	*/
	11
	12	#ifndef _LINUX_NVMEM_CONSUMER_H
	13	#define _LINUX_NVMEM_CONSUMER_H
	14
4da69f49 SK	15	#include <linux/err.h>
	16	#include <linux/errno.h>
	17
69aba794 SK	18	struct device;
	19	struct device_node;
	20	/* consumer cookie */
	21	struct nvmem_cell;
e2a5402e	22	struct nvmem_device;
69aba794	23
eace75cf SK	24	struct nvmem_cell_info {
	25	const char *name;
	26	unsigned int offset;
	27	unsigned int bytes;
	28	unsigned int bit_offset;
	29	unsigned int nbits;
	30	};
	31
69aba794 SK	32	#if IS_ENABLED(CONFIG_NVMEM)
	33
	34	/* Cell based interface */
	35	struct nvmem_cell nvmem_cell_get(struct device dev, const char *name);
	36	struct nvmem_cell devm_nvmem_cell_get(struct device dev, const char *name);
	37	void nvmem_cell_put(struct nvmem_cell *cell);
	38	void devm_nvmem_cell_put(struct device dev, struct nvmem_cell cell);
	39	void nvmem_cell_read(struct nvmem_cell cell, size_t *len);
	40	int nvmem_cell_write(struct nvmem_cell cell, void buf, size_t len);
d026d70a	41	int nvmem_cell_read_u32(struct device dev, const char cell_id, u32 *val);
69aba794	42
e2a5402e SK	43	/* direct nvmem device read/write interface */
	44	struct nvmem_device nvmem_device_get(struct device dev, const char *name);
	45	struct nvmem_device devm_nvmem_device_get(struct device dev,
	46	const char *name);
	47	void nvmem_device_put(struct nvmem_device *nvmem);
	48	void devm_nvmem_device_put(struct device dev, struct nvmem_device nvmem);
	49	int nvmem_device_read(struct nvmem_device *nvmem, unsigned int offset,
	50	size_t bytes, void *buf);
	51	int nvmem_device_write(struct nvmem_device *nvmem, unsigned int offset,
	52	size_t bytes, void *buf);
	53	ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
	54	struct nvmem_cell_info info, void buf);
	55	int nvmem_device_cell_write(struct nvmem_device *nvmem,
	56	struct nvmem_cell_info info, void buf);
	57
69aba794 SK	58	#else
	59
	60	static inline struct nvmem_cell nvmem_cell_get(struct device dev,
	61	const char *name)
	62	{
	63	return ERR_PTR(-ENOSYS);
	64	}
	65
	66	static inline struct nvmem_cell devm_nvmem_cell_get(struct device dev,
	67	const char *name)
	68	{
	69	return ERR_PTR(-ENOSYS);
	70	}
	71
	72	static inline void devm_nvmem_cell_put(struct device *dev,
	73	struct nvmem_cell *cell)
	74	{
	75
	76	}
	77	static inline void nvmem_cell_put(struct nvmem_cell *cell)
	78	{
	79	}
	80
a6c50912	81	static inline void nvmem_cell_read(struct nvmem_cell cell, size_t *len)
69aba794 SK	82	{
	83	return ERR_PTR(-ENOSYS);
	84	}
	85
	86	static inline int nvmem_cell_write(struct nvmem_cell *cell,
	87	const char *buf, size_t len)
	88	{
	89	return -ENOSYS;
	90	}
e2a5402e	91
d026d70a LC	92	static inline int nvmem_cell_read_u32(struct device *dev,
	93	const char cell_id, u32 val)
	94	{
	95	return -ENOSYS;
	96	}
	97
e2a5402e SK	98	static inline struct nvmem_device nvmem_device_get(struct device dev,
	99	const char *name)
	100	{
	101	return ERR_PTR(-ENOSYS);
	102	}
	103
	104	static inline struct nvmem_device devm_nvmem_device_get(struct device dev,
	105	const char *name)
	106	{
	107	return ERR_PTR(-ENOSYS);
	108	}
	109
	110	static inline void nvmem_device_put(struct nvmem_device *nvmem)
	111	{
	112	}
	113
	114	static inline void devm_nvmem_device_put(struct device *dev,
	115	struct nvmem_device *nvmem)
	116	{
	117	}
	118
	119	static inline ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
	120	struct nvmem_cell_info *info,
	121	void *buf)
	122	{
	123	return -ENOSYS;
	124	}
	125
	126	static inline int nvmem_device_cell_write(struct nvmem_device *nvmem,
	127	struct nvmem_cell_info *info,
	128	void *buf)
	129	{
	130	return -ENOSYS;
	131	}
	132
	133	static inline int nvmem_device_read(struct nvmem_device *nvmem,
	134	unsigned int offset, size_t bytes,
	135	void *buf)
	136	{
	137	return -ENOSYS;
	138	}
	139
	140	static inline int nvmem_device_write(struct nvmem_device *nvmem,
	141	unsigned int offset, size_t bytes,
	142	void *buf)
	143	{
	144	return -ENOSYS;
	145	}
69aba794 SK	146	#endif /* CONFIG_NVMEM */
	147
	148	#if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)
	149	struct nvmem_cell of_nvmem_cell_get(struct device_node np,
	150	const char *name);
e2a5402e SK	151	struct nvmem_device of_nvmem_device_get(struct device_node np,
e2a5402e SK	152	const char *name);
69aba794 SK	153	#else
	154	static inline struct nvmem_cell of_nvmem_cell_get(struct device_node np,
	155	const char *name)
	156	{
	157	return ERR_PTR(-ENOSYS);
	158	}
e2a5402e SK	159
	160	static inline struct nvmem_device of_nvmem_device_get(struct device_node np,
	161	const char *name)
	162	{
	163	return ERR_PTR(-ENOSYS);
	164	}
69aba794 SK	165	#endif /* CONFIG_NVMEM && CONFIG_OF */
69aba794 SK	166
eace75cf	167	#endif /* ifndef _LINUX_NVMEM_CONSUMER_H */