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

#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

/* 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);
void gpiod_put(struct gpio_desc *desc);

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);
void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);

int gpiod_get_direction(const 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);
int gpiod_get_raw_value(const struct gpio_desc *desc);
void gpiod_set_raw_value(struct gpio_desc *desc, int value);

/* 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);
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);

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

#else /* CONFIG_GPIOLIB */

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 void gpiod_put(struct gpio_desc *desc)
{
	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 void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
{
	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 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 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 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 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;
}

#endif /* CONFIG_GPIOLIB */

/*
 * Vararg-hacks! This is done to transition the kernel to always pass
 * the options flags argument to the below functions. During a transition
 * phase these vararg macros make both old-and-newstyle code compile,
 * but when all calls to the elder API are removed, these should go away
 * and the __gpiod_get() etc functions above be renamed just gpiod_get()
 * etc.
 */
#define __gpiod_get(dev, con_id, flags, ...) __gpiod_get(dev, con_id, flags)
#define gpiod_get(varargs...) __gpiod_get(varargs, 0)
#define __gpiod_get_index(dev, con_id, index, flags, ...)		\
	__gpiod_get_index(dev, con_id, index, flags)
#define gpiod_get_index(varargs...) __gpiod_get_index(varargs, 0)
#define __gpiod_get_optional(dev, con_id, flags, ...)			\
	__gpiod_get_optional(dev, con_id, flags)
#define gpiod_get_optional(varargs...) __gpiod_get_optional(varargs, 0)
#define __gpiod_get_index_optional(dev, con_id, index, flags, ...)	\
	__gpiod_get_index_optional(dev, con_id, index, flags)
#define gpiod_get_index_optional(varargs...)				\
	__gpiod_get_index_optional(varargs, 0)
#define __devm_gpiod_get(dev, con_id, flags, ...)			\
	__devm_gpiod_get(dev, con_id, flags)
#define devm_gpiod_get(varargs...) __devm_gpiod_get(varargs, 0)
#define __devm_gpiod_get_index(dev, con_id, index, flags, ...)		\
	__devm_gpiod_get_index(dev, con_id, index, flags)
#define devm_gpiod_get_index(varargs...) __devm_gpiod_get_index(varargs, 0)
#define __devm_gpiod_get_optional(dev, con_id, flags, ...)		\
	__devm_gpiod_get_optional(dev, con_id, flags)
#define devm_gpiod_get_optional(varargs...)				\
	__devm_gpiod_get_optional(varargs, 0)
#define __devm_gpiod_get_index_optional(dev, con_id, index, flags, ...)	\
	__devm_gpiod_get_index_optional(dev, con_id, index, flags)
#define devm_gpiod_get_index_optional(varargs...)			\
	__devm_gpiod_get_index_optional(varargs, 0)

#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);
int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
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 int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
{
	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
39b2bbe3 AC	19	#define GPIOD_FLAGS_BIT_DIR_SET BIT(0)
	20	#define GPIOD_FLAGS_BIT_DIR_OUT BIT(1)
	21	#define GPIOD_FLAGS_BIT_DIR_VAL BIT(2)
	22
	23	/**
	24	* Optional flags that can be passed to one of gpiod_* to configure direction
	25	* and output value. These values cannot be OR'd.
	26	*/
	27	enum gpiod_flags {
	28	GPIOD_ASIS = 0,
	29	GPIOD_IN = GPIOD_FLAGS_BIT_DIR_SET,
	30	GPIOD_OUT_LOW = GPIOD_FLAGS_BIT_DIR_SET \| GPIOD_FLAGS_BIT_DIR_OUT,
	31	GPIOD_OUT_HIGH = GPIOD_FLAGS_BIT_DIR_SET \| GPIOD_FLAGS_BIT_DIR_OUT \|
	32	GPIOD_FLAGS_BIT_DIR_VAL,
	33	};
	34
58b84f6a LW	35	#ifdef CONFIG_GPIOLIB
58b84f6a LW	36
bae48da2	37	/* Acquire and dispose GPIOs */
39b2bbe3 AC	38	struct gpio_desc __must_check __gpiod_get(struct device dev,
	39	const char *con_id,
	40	enum gpiod_flags flags);
39b2bbe3	41	struct gpio_desc __must_check __gpiod_get_index(struct device dev,
bae48da2	42	const char *con_id,
39b2bbe3 AC	43	unsigned int idx,
39b2bbe3 AC	44	enum gpiod_flags flags);
39b2bbe3 AC	45	struct gpio_desc __must_check __gpiod_get_optional(struct device dev,
	46	const char *con_id,
	47	enum gpiod_flags flags);
39b2bbe3	48	struct gpio_desc __must_check __gpiod_get_index_optional(struct device dev,
29a1f233	49	const char *con_id,
39b2bbe3 AC	50	unsigned int index,
39b2bbe3 AC	51	enum gpiod_flags flags);
bae48da2 AC	52	void gpiod_put(struct gpio_desc *desc);
bae48da2 AC	53
39b2bbe3 AC	54	struct gpio_desc __must_check __devm_gpiod_get(struct device dev,
	55	const char *con_id,
	56	enum gpiod_flags flags);
39b2bbe3	57	struct gpio_desc __must_check __devm_gpiod_get_index(struct device dev,
bae48da2	58	const char *con_id,
39b2bbe3 AC	59	unsigned int idx,
39b2bbe3 AC	60	enum gpiod_flags flags);
39b2bbe3 AC	61	struct gpio_desc __must_check __devm_gpiod_get_optional(struct device dev,
	62	const char *con_id,
	63	enum gpiod_flags flags);
29a1f233	64	struct gpio_desc *__must_check
39b2bbe3 AC	65	__devm_gpiod_get_index_optional(struct device dev, const char con_id,
39b2bbe3 AC	66	unsigned int index, enum gpiod_flags flags);
bae48da2 AC	67	void devm_gpiod_put(struct device dev, struct gpio_desc desc);
bae48da2 AC	68
79a9becd AC	69	int gpiod_get_direction(const struct gpio_desc *desc);
	70	int gpiod_direction_input(struct gpio_desc *desc);
	71	int gpiod_direction_output(struct gpio_desc *desc, int value);
ef70bbe1	72	int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
79a9becd AC	73
	74	/* Value get/set from non-sleeping context */
	75	int gpiod_get_value(const struct gpio_desc *desc);
	76	void gpiod_set_value(struct gpio_desc *desc, int value);
	77	int gpiod_get_raw_value(const struct gpio_desc *desc);
	78	void gpiod_set_raw_value(struct gpio_desc *desc, int value);
	79
	80	/* Value get/set from sleeping context */
	81	int gpiod_get_value_cansleep(const struct gpio_desc *desc);
	82	void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
	83	int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
	84	void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
	85
	86	int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
	87
	88	int gpiod_is_active_low(const struct gpio_desc *desc);
	89	int gpiod_cansleep(const struct gpio_desc *desc);
	90
	91	int gpiod_to_irq(const struct gpio_desc *desc);
	92
	93	/* Convert between the old gpio_ and new gpiod_ interfaces */
	94	struct gpio_desc *gpio_to_desc(unsigned gpio);
	95	int desc_to_gpio(const struct gpio_desc *desc);
79a9becd AC	96
	97	#else /* CONFIG_GPIOLIB */
	98
0dbc8b7a LW	99	static inline struct gpio_desc __must_check __gpiod_get(struct device dev,
	100	const char *con_id,
	101	enum gpiod_flags flags)
79a9becd AC	102	{
	103	return ERR_PTR(-ENOSYS);
	104	}
0dbc8b7a LW	105	static inline struct gpio_desc *__must_check
	106	__gpiod_get_index(struct device *dev,
	107	const char *con_id,
	108	unsigned int idx,
	109	enum gpiod_flags flags)
79a9becd AC	110	{
	111	return ERR_PTR(-ENOSYS);
	112	}
29a1f233 TR	113
29a1f233 TR	114	static inline struct gpio_desc *__must_check
0dbc8b7a LW	115	__gpiod_get_optional(struct device dev, const char con_id,
0dbc8b7a LW	116	enum gpiod_flags flags)
29a1f233 TR	117	{
	118	return ERR_PTR(-ENOSYS);
	119	}
	120
	121	static inline struct gpio_desc *__must_check
0dbc8b7a LW	122	__gpiod_get_index_optional(struct device dev, const char con_id,
0dbc8b7a LW	123	unsigned int index, enum gpiod_flags flags)
29a1f233 TR	124	{
	125	return ERR_PTR(-ENOSYS);
	126	}
	127
79a9becd AC	128	static inline void gpiod_put(struct gpio_desc *desc)
	129	{
	130	might_sleep();
	131
	132	/* GPIO can never have been requested */
	133	WARN_ON(1);
	134	}
	135
0dbc8b7a LW	136	static inline struct gpio_desc *__must_check
	137	__devm_gpiod_get(struct device *dev,
	138	const char *con_id,
	139	enum gpiod_flags flags)
79a9becd AC	140	{
	141	return ERR_PTR(-ENOSYS);
	142	}
	143	static inline
0dbc8b7a LW	144	struct gpio_desc *__must_check
	145	__devm_gpiod_get_index(struct device *dev,
	146	const char *con_id,
	147	unsigned int idx,
	148	enum gpiod_flags flags)
79a9becd AC	149	{
	150	return ERR_PTR(-ENOSYS);
	151	}
29a1f233 TR	152
29a1f233 TR	153	static inline struct gpio_desc *__must_check
0dbc8b7a LW	154	__devm_gpiod_get_optional(struct device dev, const char con_id,
0dbc8b7a LW	155	enum gpiod_flags flags)
29a1f233 TR	156	{
	157	return ERR_PTR(-ENOSYS);
	158	}
	159
	160	static inline struct gpio_desc *__must_check
0dbc8b7a LW	161	__devm_gpiod_get_index_optional(struct device dev, const char con_id,
0dbc8b7a LW	162	unsigned int index, enum gpiod_flags flags)
29a1f233 TR	163	{
	164	return ERR_PTR(-ENOSYS);
	165	}
	166
79a9becd AC	167	static inline void devm_gpiod_put(struct device dev, struct gpio_desc desc)
	168	{
	169	might_sleep();
	170
	171	/* GPIO can never have been requested */
	172	WARN_ON(1);
	173	}
	174
	175
	176	static inline int gpiod_get_direction(const struct gpio_desc *desc)
	177	{
	178	/* GPIO can never have been requested */
	179	WARN_ON(1);
	180	return -ENOSYS;
	181	}
	182	static inline int gpiod_direction_input(struct gpio_desc *desc)
	183	{
	184	/* GPIO can never have been requested */
	185	WARN_ON(1);
	186	return -ENOSYS;
	187	}
	188	static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
	189	{
	190	/* GPIO can never have been requested */
	191	WARN_ON(1);
	192	return -ENOSYS;
	193	}
ef70bbe1 PZ	194	static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
	195	{
	196	/* GPIO can never have been requested */
	197	WARN_ON(1);
	198	return -ENOSYS;
	199	}
79a9becd AC	200
	201
	202	static inline int gpiod_get_value(const struct gpio_desc *desc)
	203	{
	204	/* GPIO can never have been requested */
	205	WARN_ON(1);
	206	return 0;
	207	}
	208	static inline void gpiod_set_value(struct gpio_desc *desc, int value)
	209	{
	210	/* GPIO can never have been requested */
	211	WARN_ON(1);
	212	}
	213	static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
	214	{
	215	/* GPIO can never have been requested */
	216	WARN_ON(1);
	217	return 0;
	218	}
	219	static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
	220	{
	221	/* GPIO can never have been requested */
	222	WARN_ON(1);
	223	}
	224
	225	static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
	226	{
	227	/* GPIO can never have been requested */
	228	WARN_ON(1);
	229	return 0;
	230	}
	231	static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
	232	{
	233	/* GPIO can never have been requested */
	234	WARN_ON(1);
	235	}
	236	static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
	237	{
	238	/* GPIO can never have been requested */
	239	WARN_ON(1);
	240	return 0;
	241	}
	242	static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
	243	int value)
	244	{
	245	/* GPIO can never have been requested */
	246	WARN_ON(1);
	247	}
	248
	249	static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
	250	{
	251	/* GPIO can never have been requested */
	252	WARN_ON(1);
	253	return -ENOSYS;
	254	}
	255
	256	static inline int gpiod_is_active_low(const struct gpio_desc *desc)
	257	{
	258	/* GPIO can never have been requested */
	259	WARN_ON(1);
	260	return 0;
	261	}
	262	static inline int gpiod_cansleep(const struct gpio_desc *desc)
	263	{
264	/* GPIO can never have been requested */
265	WARN_ON(1);
266	return 0;
267	}
268
269	static inline int gpiod_to_irq(const struct gpio_desc *desc)
270	{
271	/* GPIO can never have been requested */
272	WARN_ON(1);
273	return -EINVAL;
274	}
275
276	static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
277	{
278	return ERR_PTR(-EINVAL);
279	}
280	static inline int desc_to_gpio(const struct gpio_desc *desc)
281	{
282	/* GPIO can never have been requested */
283	WARN_ON(1);
284	return -EINVAL;
285	}
79a9becd	286
79a9becd AC	287	#endif /* CONFIG_GPIOLIB */
79a9becd AC	288
0dbc8b7a LW	289	/*
	290	* Vararg-hacks! This is done to transition the kernel to always pass
	291	* the options flags argument to the below functions. During a transition
	292	* phase these vararg macros make both old-and-newstyle code compile,
	293	* but when all calls to the elder API are removed, these should go away
	294	* and the __gpiod_get() etc functions above be renamed just gpiod_get()
	295	* etc.
	296	*/
	297	#define __gpiod_get(dev, con_id, flags, ...) __gpiod_get(dev, con_id, flags)
	298	#define gpiod_get(varargs...) __gpiod_get(varargs, 0)
	299	#define __gpiod_get_index(dev, con_id, index, flags, ...) \
	300	__gpiod_get_index(dev, con_id, index, flags)
	301	#define gpiod_get_index(varargs...) __gpiod_get_index(varargs, 0)
	302	#define __gpiod_get_optional(dev, con_id, flags, ...) \
	303	__gpiod_get_optional(dev, con_id, flags)
	304	#define gpiod_get_optional(varargs...) __gpiod_get_optional(varargs, 0)
	305	#define __gpiod_get_index_optional(dev, con_id, index, flags, ...) \
	306	__gpiod_get_index_optional(dev, con_id, index, flags)
	307	#define gpiod_get_index_optional(varargs...) \
	308	__gpiod_get_index_optional(varargs, 0)
	309	#define __devm_gpiod_get(dev, con_id, flags, ...) \
	310	__devm_gpiod_get(dev, con_id, flags)
	311	#define devm_gpiod_get(varargs...) __devm_gpiod_get(varargs, 0)
	312	#define __devm_gpiod_get_index(dev, con_id, index, flags, ...) \
	313	__devm_gpiod_get_index(dev, con_id, index, flags)
	314	#define devm_gpiod_get_index(varargs...) __devm_gpiod_get_index(varargs, 0)
	315	#define __devm_gpiod_get_optional(dev, con_id, flags, ...) \
	316	__devm_gpiod_get_optional(dev, con_id, flags)
	317	#define devm_gpiod_get_optional(varargs...) \
	318	__devm_gpiod_get_optional(varargs, 0)
	319	#define __devm_gpiod_get_index_optional(dev, con_id, index, flags, ...) \
	320	__devm_gpiod_get_index_optional(dev, con_id, index, flags)
	321	#define devm_gpiod_get_index_optional(varargs...) \
	322	__devm_gpiod_get_index_optional(varargs, 0)
	323
79a9becd AC	324	#if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
	325
	326	int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
	327	int gpiod_export_link(struct device dev, const char name,
	328	struct gpio_desc *desc);
	329	int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
	330	void gpiod_unexport(struct gpio_desc *desc);
	331
	332	#else /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
	333
	334	static inline int gpiod_export(struct gpio_desc *desc,
	335	bool direction_may_change)
	336	{
	337	return -ENOSYS;
	338	}
	339
	340	static inline int gpiod_export_link(struct device dev, const char name,
	341	struct gpio_desc *desc)
	342	{
	343	return -ENOSYS;
	344	}
	345
	346	static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
	347	{
	348	return -ENOSYS;
	349	}
	350
	351	static inline void gpiod_unexport(struct gpio_desc *desc)
	352	{
	353	}
	354
	355	#endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
	356
	357	#endif