[deliverable/linux.git] / include / linux / gpio / consumer.h

#ifndef __LINUX_GPIO_CONSUMER_H
#define __LINUX_GPIO_CONSUMER_H

#include <linux/bug.h>
#include <linux/err.h>
#include <linux/kernel.h>

struct device;

/**
 * Opaque descriptor for a GPIO. These are obtained using gpiod_get() and are
 * preferable to the old integer-based handles.
 *
 * Contrary to integers, a pointer to a gpio_desc is guaranteed to be valid
 * until the GPIO is released.
 */
struct gpio_desc;

/**
 * Struct containing an array of descriptors that can be obtained using
 * gpiod_get_array().
 */
struct gpio_descs {
	unsigned int ndescs;
	struct gpio_desc *desc[];
};

#define GPIOD_FLAGS_BIT_DIR_SET		BIT(0)
#define GPIOD_FLAGS_BIT_DIR_OUT		BIT(1)
#define GPIOD_FLAGS_BIT_DIR_VAL		BIT(2)

/**
 * Optional flags that can be passed to one of gpiod_* to configure direction
 * and output value. These values cannot be OR'd.
 */
enum gpiod_flags {
	GPIOD_ASIS	= 0,
	GPIOD_IN	= GPIOD_FLAGS_BIT_DIR_SET,
	GPIOD_OUT_LOW	= GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT,
	GPIOD_OUT_HIGH	= GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
			  GPIOD_FLAGS_BIT_DIR_VAL,
};

#ifdef CONFIG_GPIOLIB

/* Return the number of GPIOs associated with a device / function */
int gpiod_count(struct device *dev, const char *con_id);

/* Acquire and dispose GPIOs */
struct gpio_desc *__must_check gpiod_get(struct device *dev,
					 const char *con_id,
					 enum gpiod_flags flags);
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
					       const char *con_id,
					       unsigned int idx,
					       enum gpiod_flags flags);
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
						  const char *con_id,
						  enum gpiod_flags flags);
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
							const char *con_id,
							unsigned int index,
							enum gpiod_flags flags);
struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
						const char *con_id,
						enum gpiod_flags flags);
struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
							const char *con_id,
							enum gpiod_flags flags);
void gpiod_put(struct gpio_desc *desc);
void gpiod_put_array(struct gpio_descs *descs);

struct gpio_desc *__must_check devm_gpiod_get(struct device *dev,
					      const char *con_id,
					      enum gpiod_flags flags);
struct gpio_desc *__must_check devm_gpiod_get_index(struct device *dev,
						    const char *con_id,
						    unsigned int idx,
						    enum gpiod_flags flags);
struct gpio_desc *__must_check devm_gpiod_get_optional(struct device *dev,
						       const char *con_id,
						       enum gpiod_flags flags);
struct gpio_desc *__must_check
devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
			      unsigned int index, enum gpiod_flags flags);
struct gpio_descs *__must_check devm_gpiod_get_array(struct device *dev,
						     const char *con_id,
						     enum gpiod_flags flags);
struct gpio_descs *__must_check
devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
			      enum gpiod_flags flags);
void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
void devm_gpiod_put_array(struct device *dev, struct gpio_descs *descs);

int gpiod_get_direction(struct gpio_desc *desc);
int gpiod_direction_input(struct gpio_desc *desc);
int gpiod_direction_output(struct gpio_desc *desc, int value);
int gpiod_direction_output_raw(struct gpio_desc *desc, int value);

/* Value get/set from non-sleeping context */
int gpiod_get_value(const struct gpio_desc *desc);
void gpiod_set_value(struct gpio_desc *desc, int value);
void gpiod_set_array_value(unsigned int array_size,
			   struct gpio_desc **desc_array, int *value_array);
int gpiod_get_raw_value(const struct gpio_desc *desc);
void gpiod_set_raw_value(struct gpio_desc *desc, int value);
void gpiod_set_raw_array_value(unsigned int array_size,
			       struct gpio_desc **desc_array,
			       int *value_array);

/* Value get/set from sleeping context */
int gpiod_get_value_cansleep(const struct gpio_desc *desc);
void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
void gpiod_set_array_value_cansleep(unsigned int array_size,
				    struct gpio_desc **desc_array,
				    int *value_array);
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
					struct gpio_desc **desc_array,
					int *value_array);

int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);

int gpiod_is_active_low(const struct gpio_desc *desc);
int gpiod_cansleep(const struct gpio_desc *desc);

int gpiod_to_irq(const struct gpio_desc *desc);

/* Convert between the old gpio_ and new gpiod_ interfaces */
struct gpio_desc *gpio_to_desc(unsigned gpio);
int desc_to_gpio(const struct gpio_desc *desc);

/* Child properties interface */
struct fwnode_handle;

struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
					 const char *propname);
struct gpio_desc *devm_get_gpiod_from_child(struct device *dev,
					    const char *con_id,
					    struct fwnode_handle *child);
#else /* CONFIG_GPIOLIB */

static inline int gpiod_count(struct device *dev, const char *con_id)
{
	return 0;
}

static inline struct gpio_desc *__must_check gpiod_get(struct device *dev,
						       const char *con_id,
						       enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}
static inline struct gpio_desc *__must_check
gpiod_get_index(struct device *dev,
		const char *con_id,
		unsigned int idx,
		enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_desc *__must_check
gpiod_get_optional(struct device *dev, const char *con_id,
		   enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_desc *__must_check
gpiod_get_index_optional(struct device *dev, const char *con_id,
			 unsigned int index, enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_descs *__must_check
gpiod_get_array(struct device *dev, const char *con_id,
		enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_descs *__must_check
gpiod_get_array_optional(struct device *dev, const char *con_id,
			 enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline void gpiod_put(struct gpio_desc *desc)
{
	might_sleep();

	/* GPIO can never have been requested */
	WARN_ON(1);
}

static inline void gpiod_put_array(struct gpio_descs *descs)
{
	might_sleep();

	/* GPIO can never have been requested */
	WARN_ON(1);
}

static inline struct gpio_desc *__must_check
devm_gpiod_get(struct device *dev,
		 const char *con_id,
		 enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}
static inline
struct gpio_desc *__must_check
devm_gpiod_get_index(struct device *dev,
		       const char *con_id,
		       unsigned int idx,
		       enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_desc *__must_check
devm_gpiod_get_optional(struct device *dev, const char *con_id,
			  enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_desc *__must_check
devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
				unsigned int index, enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_descs *__must_check
devm_gpiod_get_array(struct device *dev, const char *con_id,
		     enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_descs *__must_check
devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
			      enum gpiod_flags flags)
{
	return ERR_PTR(-ENOSYS);
}

static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
{
	might_sleep();

	/* GPIO can never have been requested */
	WARN_ON(1);
}

static inline void devm_gpiod_put_array(struct device *dev,
					struct gpio_descs *descs)
{
	might_sleep();

	/* GPIO can never have been requested */
	WARN_ON(1);
}


static inline int gpiod_get_direction(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return -ENOSYS;
}
static inline int gpiod_direction_input(struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return -ENOSYS;
}
static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return -ENOSYS;
}
static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return -ENOSYS;
}


static inline int gpiod_get_value(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return 0;
}
static inline void gpiod_set_value(struct gpio_desc *desc, int value)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
}
static inline void gpiod_set_array_value(unsigned int array_size,
					 struct gpio_desc **desc_array,
					 int *value_array)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
}
static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return 0;
}
static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
}
static inline void gpiod_set_raw_array_value(unsigned int array_size,
					     struct gpio_desc **desc_array,
					     int *value_array)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
}

static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return 0;
}
static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
}
static inline void gpiod_set_array_value_cansleep(unsigned int array_size,
					    struct gpio_desc **desc_array,
					    int *value_array)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
}
static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return 0;
}
static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
						int value)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
}
static inline void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
						struct gpio_desc **desc_array,
						int *value_array)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
}

static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return -ENOSYS;
}

static inline int gpiod_is_active_low(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return 0;
}
static inline int gpiod_cansleep(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return 0;
}

static inline int gpiod_to_irq(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return -EINVAL;
}

static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
{
	return ERR_PTR(-EINVAL);
}

static inline int desc_to_gpio(const struct gpio_desc *desc)
{
	/* GPIO can never have been requested */
	WARN_ON(1);
	return -EINVAL;
}

/* Child properties interface */
struct fwnode_handle;

static inline struct gpio_desc *fwnode_get_named_gpiod(
	struct fwnode_handle *fwnode, const char *propname)
{
	return ERR_PTR(-ENOSYS);
}

static inline struct gpio_desc *devm_get_gpiod_from_child(
	struct device *dev, const char *con_id, struct fwnode_handle *child)
{
	return ERR_PTR(-ENOSYS);
}

#endif /* CONFIG_GPIOLIB */

#if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)

int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
int gpiod_export_link(struct device *dev, const char *name,
		      struct gpio_desc *desc);
void gpiod_unexport(struct gpio_desc *desc);

#else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */

static inline int gpiod_export(struct gpio_desc *desc,
			       bool direction_may_change)
{
	return -ENOSYS;
}

static inline int gpiod_export_link(struct device *dev, const char *name,
				    struct gpio_desc *desc)
{
	return -ENOSYS;
}

static inline void gpiod_unexport(struct gpio_desc *desc)
{
}

#endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */

#endif
Commit	Line	Data
79a9becd AC	1	#ifndef __LINUX_GPIO_CONSUMER_H
	2	#define __LINUX_GPIO_CONSUMER_H
	3
cdf86cd2	4	#include <linux/bug.h>
79a9becd AC	5	#include <linux/err.h>
	6	#include <linux/kernel.h>
	7
79a9becd	8	struct device;
79a9becd AC	9
	10	/**
	11	* Opaque descriptor for a GPIO. These are obtained using gpiod_get() and are
	12	* preferable to the old integer-based handles.
	13	*
	14	* Contrary to integers, a pointer to a gpio_desc is guaranteed to be valid
	15	* until the GPIO is released.
	16	*/
	17	struct gpio_desc;
	18
66858527 RI	19	/**
	20	* Struct containing an array of descriptors that can be obtained using
	21	* gpiod_get_array().
	22	*/
	23	struct gpio_descs {
	24	unsigned int ndescs;
	25	struct gpio_desc *desc[];
	26	};
	27
39b2bbe3 AC	28	#define GPIOD_FLAGS_BIT_DIR_SET BIT(0)
	29	#define GPIOD_FLAGS_BIT_DIR_OUT BIT(1)
	30	#define GPIOD_FLAGS_BIT_DIR_VAL BIT(2)
	31
	32	/**
	33	* Optional flags that can be passed to one of gpiod_* to configure direction
	34	* and output value. These values cannot be OR'd.
	35	*/
	36	enum gpiod_flags {
	37	GPIOD_ASIS = 0,
	38	GPIOD_IN = GPIOD_FLAGS_BIT_DIR_SET,
	39	GPIOD_OUT_LOW = GPIOD_FLAGS_BIT_DIR_SET \| GPIOD_FLAGS_BIT_DIR_OUT,
	40	GPIOD_OUT_HIGH = GPIOD_FLAGS_BIT_DIR_SET \| GPIOD_FLAGS_BIT_DIR_OUT \|
	41	GPIOD_FLAGS_BIT_DIR_VAL,
	42	};
	43
58b84f6a LW	44	#ifdef CONFIG_GPIOLIB
58b84f6a LW	45
66858527 RI	46	/* Return the number of GPIOs associated with a device / function */
	47	int gpiod_count(struct device dev, const char con_id);
	48
bae48da2	49	/* Acquire and dispose GPIOs */
b17d1bf1	50	struct gpio_desc __must_check gpiod_get(struct device dev,
39b2bbe3 AC	51	const char *con_id,
39b2bbe3 AC	52	enum gpiod_flags flags);
b17d1bf1	53	struct gpio_desc __must_check gpiod_get_index(struct device dev,
bae48da2	54	const char *con_id,
39b2bbe3 AC	55	unsigned int idx,
39b2bbe3 AC	56	enum gpiod_flags flags);
b17d1bf1	57	struct gpio_desc __must_check gpiod_get_optional(struct device dev,
39b2bbe3 AC	58	const char *con_id,
39b2bbe3 AC	59	enum gpiod_flags flags);
b17d1bf1	60	struct gpio_desc __must_check gpiod_get_index_optional(struct device dev,
29a1f233	61	const char *con_id,
39b2bbe3 AC	62	unsigned int index,
39b2bbe3 AC	63	enum gpiod_flags flags);
66858527 RI	64	struct gpio_descs __must_check gpiod_get_array(struct device dev,
	65	const char *con_id,
	66	enum gpiod_flags flags);
	67	struct gpio_descs __must_check gpiod_get_array_optional(struct device dev,
	68	const char *con_id,
	69	enum gpiod_flags flags);
bae48da2	70	void gpiod_put(struct gpio_desc *desc);
66858527	71	void gpiod_put_array(struct gpio_descs *descs);
bae48da2	72
b17d1bf1	73	struct gpio_desc __must_check devm_gpiod_get(struct device dev,
39b2bbe3 AC	74	const char *con_id,
39b2bbe3 AC	75	enum gpiod_flags flags);
b17d1bf1	76	struct gpio_desc __must_check devm_gpiod_get_index(struct device dev,
bae48da2	77	const char *con_id,
39b2bbe3 AC	78	unsigned int idx,
39b2bbe3 AC	79	enum gpiod_flags flags);
b17d1bf1	80	struct gpio_desc __must_check devm_gpiod_get_optional(struct device dev,
39b2bbe3 AC	81	const char *con_id,
39b2bbe3 AC	82	enum gpiod_flags flags);
29a1f233	83	struct gpio_desc *__must_check
b17d1bf1	84	devm_gpiod_get_index_optional(struct device dev, const char con_id,
39b2bbe3	85	unsigned int index, enum gpiod_flags flags);
331758ee RI	86	struct gpio_descs __must_check devm_gpiod_get_array(struct device dev,
	87	const char *con_id,
	88	enum gpiod_flags flags);
	89	struct gpio_descs *__must_check
	90	devm_gpiod_get_array_optional(struct device dev, const char con_id,
	91	enum gpiod_flags flags);
bae48da2	92	void devm_gpiod_put(struct device dev, struct gpio_desc desc);
331758ee	93	void devm_gpiod_put_array(struct device dev, struct gpio_descs descs);
bae48da2	94
8e53b0f1	95	int gpiod_get_direction(struct gpio_desc *desc);
79a9becd AC	96	int gpiod_direction_input(struct gpio_desc *desc);
79a9becd AC	97	int gpiod_direction_output(struct gpio_desc *desc, int value);
ef70bbe1	98	int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
79a9becd AC	99
	100	/* Value get/set from non-sleeping context */
	101	int gpiod_get_value(const struct gpio_desc *desc);
	102	void gpiod_set_value(struct gpio_desc *desc, int value);
3fff99bc RI	103	void gpiod_set_array_value(unsigned int array_size,
3fff99bc RI	104	struct gpio_desc *desc_array, int value_array);
79a9becd AC	105	int gpiod_get_raw_value(const struct gpio_desc *desc);
79a9becd AC	106	void gpiod_set_raw_value(struct gpio_desc *desc, int value);
3fff99bc RI	107	void gpiod_set_raw_array_value(unsigned int array_size,
	108	struct gpio_desc **desc_array,
	109	int *value_array);
79a9becd AC	110
	111	/* Value get/set from sleeping context */
	112	int gpiod_get_value_cansleep(const struct gpio_desc *desc);
	113	void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
3fff99bc RI	114	void gpiod_set_array_value_cansleep(unsigned int array_size,
	115	struct gpio_desc **desc_array,
	116	int *value_array);
79a9becd AC	117	int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
79a9becd AC	118	void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
3fff99bc RI	119	void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
	120	struct gpio_desc **desc_array,
	121	int *value_array);
79a9becd AC	122
	123	int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
	124
	125	int gpiod_is_active_low(const struct gpio_desc *desc);
	126	int gpiod_cansleep(const struct gpio_desc *desc);
	127
	128	int gpiod_to_irq(const struct gpio_desc *desc);
	129
	130	/* Convert between the old gpio_ and new gpiod_ interfaces */
	131	struct gpio_desc *gpio_to_desc(unsigned gpio);
	132	int desc_to_gpio(const struct gpio_desc *desc);
79a9becd	133
40b73183 MW	134	/* Child properties interface */
	135	struct fwnode_handle;
	136
	137	struct gpio_desc fwnode_get_named_gpiod(struct fwnode_handle fwnode,
	138	const char *propname);
	139	struct gpio_desc devm_get_gpiod_from_child(struct device dev,
1feb57a2	140	const char *con_id,
40b73183	141	struct fwnode_handle *child);
79a9becd AC	142	#else /* CONFIG_GPIOLIB */
79a9becd AC	143
66858527 RI	144	static inline int gpiod_count(struct device dev, const char con_id)
	145	{
	146	return 0;
	147	}
	148
b17d1bf1 UKK	149	static inline struct gpio_desc __must_check gpiod_get(struct device dev,
	150	const char *con_id,
	151	enum gpiod_flags flags)
79a9becd AC	152	{
	153	return ERR_PTR(-ENOSYS);
	154	}
0dbc8b7a	155	static inline struct gpio_desc *__must_check
b17d1bf1 UKK	156	gpiod_get_index(struct device *dev,
	157	const char *con_id,
	158	unsigned int idx,
	159	enum gpiod_flags flags)
79a9becd AC	160	{
	161	return ERR_PTR(-ENOSYS);
	162	}
29a1f233 TR	163
29a1f233 TR	164	static inline struct gpio_desc *__must_check
b17d1bf1 UKK	165	gpiod_get_optional(struct device dev, const char con_id,
b17d1bf1 UKK	166	enum gpiod_flags flags)
29a1f233 TR	167	{
	168	return ERR_PTR(-ENOSYS);
	169	}
	170
	171	static inline struct gpio_desc *__must_check
b17d1bf1 UKK	172	gpiod_get_index_optional(struct device dev, const char con_id,
b17d1bf1 UKK	173	unsigned int index, enum gpiod_flags flags)
29a1f233 TR	174	{
	175	return ERR_PTR(-ENOSYS);
	176	}
	177
66858527 RI	178	static inline struct gpio_descs *__must_check
	179	gpiod_get_array(struct device dev, const char con_id,
	180	enum gpiod_flags flags)
	181	{
	182	return ERR_PTR(-ENOSYS);
	183	}
	184
	185	static inline struct gpio_descs *__must_check
	186	gpiod_get_array_optional(struct device dev, const char con_id,
	187	enum gpiod_flags flags)
	188	{
	189	return ERR_PTR(-ENOSYS);
	190	}
	191
79a9becd AC	192	static inline void gpiod_put(struct gpio_desc *desc)
	193	{
	194	might_sleep();
	195
	196	/* GPIO can never have been requested */
	197	WARN_ON(1);
	198	}
	199
66858527 RI	200	static inline void gpiod_put_array(struct gpio_descs *descs)
	201	{
	202	might_sleep();
	203
	204	/* GPIO can never have been requested */
	205	WARN_ON(1);
	206	}
	207
0dbc8b7a	208	static inline struct gpio_desc *__must_check
b17d1bf1	209	devm_gpiod_get(struct device *dev,
0dbc8b7a LW	210	const char *con_id,
0dbc8b7a LW	211	enum gpiod_flags flags)
79a9becd AC	212	{
	213	return ERR_PTR(-ENOSYS);
	214	}
	215	static inline
0dbc8b7a	216	struct gpio_desc *__must_check
b17d1bf1	217	devm_gpiod_get_index(struct device *dev,
0dbc8b7a LW	218	const char *con_id,
	219	unsigned int idx,
	220	enum gpiod_flags flags)
79a9becd AC	221	{
	222	return ERR_PTR(-ENOSYS);
	223	}
29a1f233 TR	224
29a1f233 TR	225	static inline struct gpio_desc *__must_check
b17d1bf1	226	devm_gpiod_get_optional(struct device dev, const char con_id,
0dbc8b7a	227	enum gpiod_flags flags)
29a1f233 TR	228	{
	229	return ERR_PTR(-ENOSYS);
	230	}
	231
	232	static inline struct gpio_desc *__must_check
b17d1bf1	233	devm_gpiod_get_index_optional(struct device dev, const char con_id,
0dbc8b7a	234	unsigned int index, enum gpiod_flags flags)
29a1f233 TR	235	{
	236	return ERR_PTR(-ENOSYS);
	237	}
	238
331758ee RI	239	static inline struct gpio_descs *__must_check
	240	devm_gpiod_get_array(struct device dev, const char con_id,
	241	enum gpiod_flags flags)
	242	{
	243	return ERR_PTR(-ENOSYS);
	244	}
	245
	246	static inline struct gpio_descs *__must_check
	247	devm_gpiod_get_array_optional(struct device dev, const char con_id,
	248	enum gpiod_flags flags)
	249	{
	250	return ERR_PTR(-ENOSYS);
	251	}
	252
79a9becd	253	static inline void devm_gpiod_put(struct device dev, struct gpio_desc desc)
331758ee RI	254	{
	255	might_sleep();
	256
	257	/* GPIO can never have been requested */
	258	WARN_ON(1);
	259	}
	260
	261	static inline void devm_gpiod_put_array(struct device *dev,
	262	struct gpio_descs *descs)
79a9becd AC	263	{
	264	might_sleep();
	265
	266	/* GPIO can never have been requested */
	267	WARN_ON(1);
	268	}
	269
	270
	271	static inline int gpiod_get_direction(const struct gpio_desc *desc)
	272	{
	273	/* GPIO can never have been requested */
	274	WARN_ON(1);
	275	return -ENOSYS;
	276	}
	277	static inline int gpiod_direction_input(struct gpio_desc *desc)
	278	{
	279	/* GPIO can never have been requested */
	280	WARN_ON(1);
	281	return -ENOSYS;
	282	}
	283	static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
	284	{
	285	/* GPIO can never have been requested */
	286	WARN_ON(1);
	287	return -ENOSYS;
	288	}
ef70bbe1 PZ	289	static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
	290	{
	291	/* GPIO can never have been requested */
	292	WARN_ON(1);
	293	return -ENOSYS;
	294	}
79a9becd AC	295
	296
	297	static inline int gpiod_get_value(const struct gpio_desc *desc)
	298	{
	299	/* GPIO can never have been requested */
	300	WARN_ON(1);
	301	return 0;
	302	}
	303	static inline void gpiod_set_value(struct gpio_desc *desc, int value)
	304	{
	305	/* GPIO can never have been requested */
	306	WARN_ON(1);
	307	}
3fff99bc RI	308	static inline void gpiod_set_array_value(unsigned int array_size,
	309	struct gpio_desc **desc_array,
	310	int *value_array)
5f424243 RI	311	{
	312	/* GPIO can never have been requested */
	313	WARN_ON(1);
	314	}
79a9becd AC	315	static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
	316	{
	317	/* GPIO can never have been requested */
	318	WARN_ON(1);
	319	return 0;
	320	}
	321	static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
	322	{
	323	/* GPIO can never have been requested */
	324	WARN_ON(1);
	325	}
3fff99bc RI	326	static inline void gpiod_set_raw_array_value(unsigned int array_size,
	327	struct gpio_desc **desc_array,
	328	int *value_array)
5f424243 RI	329	{
	330	/* GPIO can never have been requested */
	331	WARN_ON(1);
	332	}
79a9becd AC	333
	334	static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
	335	{
	336	/* GPIO can never have been requested */
	337	WARN_ON(1);
	338	return 0;
	339	}
	340	static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
	341	{
	342	/* GPIO can never have been requested */
	343	WARN_ON(1);
	344	}
3fff99bc	345	static inline void gpiod_set_array_value_cansleep(unsigned int array_size,
5f424243 RI	346	struct gpio_desc **desc_array,
	347	int *value_array)
	348	{
	349	/* GPIO can never have been requested */
	350	WARN_ON(1);
	351	}
79a9becd AC	352	static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
	353	{
	354	/* GPIO can never have been requested */
	355	WARN_ON(1);
	356	return 0;
	357	}
	358	static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
	359	int value)
	360	{
	361	/* GPIO can never have been requested */
	362	WARN_ON(1);
	363	}
3fff99bc	364	static inline void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
5f424243 RI	365	struct gpio_desc **desc_array,
	366	int *value_array)
	367	{
	368	/* GPIO can never have been requested */
	369	WARN_ON(1);
	370	}
79a9becd AC	371
	372	static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
	373	{
	374	/* GPIO can never have been requested */
	375	WARN_ON(1);
	376	return -ENOSYS;
	377	}
	378
	379	static inline int gpiod_is_active_low(const struct gpio_desc *desc)
	380	{
	381	/* GPIO can never have been requested */
	382	WARN_ON(1);
	383	return 0;
	384	}
	385	static inline int gpiod_cansleep(const struct gpio_desc *desc)
	386	{
	387	/* GPIO can never have been requested */
	388	WARN_ON(1);
	389	return 0;
	390	}
	391
	392	static inline int gpiod_to_irq(const struct gpio_desc *desc)
	393	{
	394	/* GPIO can never have been requested */
	395	WARN_ON(1);
	396	return -EINVAL;
	397	}
	398
	399	static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
	400	{
	401	return ERR_PTR(-EINVAL);
	402	}
c0017ed7	403
79a9becd AC	404	static inline int desc_to_gpio(const struct gpio_desc *desc)
	405	{
	406	/* GPIO can never have been requested */
	407	WARN_ON(1);
	408	return -EINVAL;
	409	}
79a9becd	410
496e7ce2 GU	411	/* Child properties interface */
	412	struct fwnode_handle;
	413
	414	static inline struct gpio_desc *fwnode_get_named_gpiod(
	415	struct fwnode_handle fwnode, const char propname)
	416	{
	417	return ERR_PTR(-ENOSYS);
	418	}
	419
	420	static inline struct gpio_desc *devm_get_gpiod_from_child(
	421	struct device dev, const char con_id, struct fwnode_handle *child)
	422	{
	423	return ERR_PTR(-ENOSYS);
	424	}
	425
79a9becd AC	426	#endif /* CONFIG_GPIOLIB */
	427
	428	#if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
	429
	430	int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
	431	int gpiod_export_link(struct device dev, const char name,
	432	struct gpio_desc *desc);
79a9becd AC	433	void gpiod_unexport(struct gpio_desc *desc);
	434
	435	#else /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
	436
	437	static inline int gpiod_export(struct gpio_desc *desc,
	438	bool direction_may_change)
	439	{
	440	return -ENOSYS;
	441	}
	442
	443	static inline int gpiod_export_link(struct device dev, const char name,
	444	struct gpio_desc *desc)
	445	{
	446	return -ENOSYS;
	447	}
	448
79a9becd AC	449	static inline void gpiod_unexport(struct gpio_desc *desc)
	450	{
	451	}
	452
	453	#endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
	454
	455	#endif