[net-next-2.6.git] / include / asm-generic / gpio.h

#ifndef _ASM_GENERIC_GPIO_H
#define _ASM_GENERIC_GPIO_H

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/errno.h>

#ifdef CONFIG_GPIOLIB

#include <linux/compiler.h>

/* Platforms may implement their GPIO interface with library code,
 * at a small performance cost for non-inlined operations and some
 * extra memory (for code and for per-GPIO table entries).
 *
 * While the GPIO programming interface defines valid GPIO numbers
 * to be in the range 0..MAX_INT, this library restricts them to the
 * smaller range 0..ARCH_NR_GPIOS-1.
 *
 * ARCH_NR_GPIOS is somewhat arbitrary; it usually reflects the sum of
 * builtin/SoC GPIOs plus a number of GPIOs on expanders; the latter is
 * actually an estimate of a board-specific value.
 */

#ifndef ARCH_NR_GPIOS
#define ARCH_NR_GPIOS		256
#endif

/*
 * "valid" GPIO numbers are nonnegative and may be passed to
 * setup routines like gpio_request().  only some valid numbers
 * can successfully be requested and used.
 *
 * Invalid GPIO numbers are useful for indicating no-such-GPIO in
 * platform data and other tables.
 */

static inline int gpio_is_valid(int number)
{
	return ((unsigned)number) < ARCH_NR_GPIOS;
}

struct device;
struct seq_file;
struct module;
struct device_node;

/**
 * struct gpio_chip - abstract a GPIO controller
 * @label: for diagnostics
 * @dev: optional device providing the GPIOs
 * @owner: helps prevent removal of modules exporting active GPIOs
 * @request: optional hook for chip-specific activation, such as
 *	enabling module power and clock; may sleep
 * @free: optional hook for chip-specific deactivation, such as
 *	disabling module power and clock; may sleep
 * @direction_input: configures signal "offset" as input, or returns error
 * @get: returns value for signal "offset"; for output signals this
 *	returns either the value actually sensed, or zero
 * @direction_output: configures signal "offset" as output, or returns error
 * @set: assigns output value for signal "offset"
 * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;
 *	implementation may not sleep
 * @dbg_show: optional routine to show contents in debugfs; default code
 *	will be used when this is omitted, but custom code can show extra
 *	state (such as pullup/pulldown configuration).
 * @base: identifies the first GPIO number handled by this chip; or, if
 *	negative during registration, requests dynamic ID allocation.
 * @ngpio: the number of GPIOs handled by this controller; the last GPIO
 *	handled is (base + ngpio - 1).
 * @can_sleep: flag must be set iff get()/set() methods sleep, as they
 *	must while accessing GPIO expander chips over I2C or SPI
 * @names: if set, must be an array of strings to use as alternative
 *      names for the GPIOs in this chip. Any entry in the array
 *      may be NULL if there is no alias for the GPIO, however the
 *      array must be @ngpio entries long.  A name can include a single printk
 *      format specifier for an unsigned int.  It is substituted by the actual
 *      number of the gpio.
 *
 * A gpio_chip can help platforms abstract various sources of GPIOs so
 * they can all be accessed through a common programing interface.
 * Example sources would be SOC controllers, FPGAs, multifunction
 * chips, dedicated GPIO expanders, and so on.
 *
 * Each chip controls a number of signals, identified in method calls
 * by "offset" values in the range 0..(@ngpio - 1).  When those signals
 * are referenced through calls like gpio_get_value(gpio), the offset
 * is calculated by subtracting @base from the gpio number.
 */
struct gpio_chip {
	const char		*label;
	struct device		*dev;
	struct module		*owner;

	int			(*request)(struct gpio_chip *chip,
						unsigned offset);
	void			(*free)(struct gpio_chip *chip,
						unsigned offset);

	int			(*direction_input)(struct gpio_chip *chip,
						unsigned offset);
	int			(*get)(struct gpio_chip *chip,
						unsigned offset);
	int			(*direction_output)(struct gpio_chip *chip,
						unsigned offset, int value);
	int			(*set_debounce)(struct gpio_chip *chip,
						unsigned offset, unsigned debounce);

	void			(*set)(struct gpio_chip *chip,
						unsigned offset, int value);

	int			(*to_irq)(struct gpio_chip *chip,
						unsigned offset);

	void			(*dbg_show)(struct seq_file *s,
						struct gpio_chip *chip);
	int			base;
	u16			ngpio;
	const char		*const *names;
	unsigned		can_sleep:1;
	unsigned		exported:1;

#if defined(CONFIG_OF_GPIO)
	/*
	 * If CONFIG_OF is enabled, then all GPIO controllers described in the
	 * device tree automatically may have an OF translation
	 */
	struct device_node *of_node;
	int of_gpio_n_cells;
	int (*of_xlate)(struct gpio_chip *gc, struct device_node *np,
		        const void *gpio_spec, u32 *flags);
#endif
};

extern const char *gpiochip_is_requested(struct gpio_chip *chip,
			unsigned offset);
extern int __must_check gpiochip_reserve(int start, int ngpio);

/* add/remove chips */
extern int gpiochip_add(struct gpio_chip *chip);
extern int __must_check gpiochip_remove(struct gpio_chip *chip);
extern struct gpio_chip *gpiochip_find(void *data,
					int (*match)(struct gpio_chip *chip,
						     void *data));


/* Always use the library code for GPIO management calls,
 * or when sleeping may be involved.
 */
extern int gpio_request(unsigned gpio, const char *label);
extern void gpio_free(unsigned gpio);

extern int gpio_direction_input(unsigned gpio);
extern int gpio_direction_output(unsigned gpio, int value);

extern int gpio_set_debounce(unsigned gpio, unsigned debounce);

extern int gpio_get_value_cansleep(unsigned gpio);
extern void gpio_set_value_cansleep(unsigned gpio, int value);


/* A platform's <asm/gpio.h> code may want to inline the I/O calls when
 * the GPIO is constant and refers to some always-present controller,
 * giving direct access to chip registers and tight bitbanging loops.
 */
extern int __gpio_get_value(unsigned gpio);
extern void __gpio_set_value(unsigned gpio, int value);

extern int __gpio_cansleep(unsigned gpio);

extern int __gpio_to_irq(unsigned gpio);

#define GPIOF_DIR_OUT	(0 << 0)
#define GPIOF_DIR_IN	(1 << 0)

#define GPIOF_INIT_LOW	(0 << 1)
#define GPIOF_INIT_HIGH	(1 << 1)

#define GPIOF_IN		(GPIOF_DIR_IN)
#define GPIOF_OUT_INIT_LOW	(GPIOF_DIR_OUT | GPIOF_INIT_LOW)
#define GPIOF_OUT_INIT_HIGH	(GPIOF_DIR_OUT | GPIOF_INIT_HIGH)

/**
 * struct gpio - a structure describing a GPIO with configuration
 * @gpio:	the GPIO number
 * @flags:	GPIO configuration as specified by GPIOF_*
 * @label:	a literal description string of this GPIO
 */
struct gpio {
	unsigned	gpio;
	unsigned long	flags;
	const char	*label;
};

extern int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
extern int gpio_request_array(struct gpio *array, size_t num);
extern void gpio_free_array(struct gpio *array, size_t num);

#ifdef CONFIG_GPIO_SYSFS

/*
 * A sysfs interface can be exported by individual drivers if they want,
 * but more typically is configured entirely from userspace.
 */
extern int gpio_export(unsigned gpio, bool direction_may_change);
extern int gpio_export_link(struct device *dev, const char *name,
			unsigned gpio);
extern int gpio_sysfs_set_active_low(unsigned gpio, int value);
extern void gpio_unexport(unsigned gpio);

#endif	/* CONFIG_GPIO_SYSFS */

#else	/* !CONFIG_HAVE_GPIO_LIB */

static inline int gpio_is_valid(int number)
{
	/* only non-negative numbers are valid */
	return number >= 0;
}

/* platforms that don't directly support access to GPIOs through I2C, SPI,
 * or other blocking infrastructure can use these wrappers.
 */

static inline int gpio_cansleep(unsigned gpio)
{
	return 0;
}

static inline int gpio_get_value_cansleep(unsigned gpio)
{
	might_sleep();
	return gpio_get_value(gpio);
}

static inline void gpio_set_value_cansleep(unsigned gpio, int value)
{
	might_sleep();
	gpio_set_value(gpio, value);
}

#endif /* !CONFIG_HAVE_GPIO_LIB */

#ifndef CONFIG_GPIO_SYSFS

struct device;

/* sysfs support is only available with gpiolib, where it's optional */

static inline int gpio_export(unsigned gpio, bool direction_may_change)
{
	return -ENOSYS;
}

static inline int gpio_export_link(struct device *dev, const char *name,
				unsigned gpio)
{
	return -ENOSYS;
}

static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
{
	return -ENOSYS;
}

static inline void gpio_unexport(unsigned gpio)
{
}
#endif	/* CONFIG_GPIO_SYSFS */

#endif /* _ASM_GENERIC_GPIO_H */
Commit	Line	Data
4c20386c DB	1	#ifndef _ASM_GENERIC_GPIO_H
	2	#define _ASM_GENERIC_GPIO_H
	3
b3db4a8a	4	#include <linux/kernel.h>
6ea0205b	5	#include <linux/types.h>
25947d5a	6	#include <linux/errno.h>
6ea0205b	7
7444a72e	8	#ifdef CONFIG_GPIOLIB
d2876d08	9
6ea0205b DB	10	#include <linux/compiler.h>
6ea0205b DB	11
d2876d08 DB	12	/* Platforms may implement their GPIO interface with library code,
	13	* at a small performance cost for non-inlined operations and some
	14	* extra memory (for code and for per-GPIO table entries).
	15	*
	16	* While the GPIO programming interface defines valid GPIO numbers
	17	* to be in the range 0..MAX_INT, this library restricts them to the
6a9436d0	18	* smaller range 0..ARCH_NR_GPIOS-1.
c956126c DB	19	*
	20	* ARCH_NR_GPIOS is somewhat arbitrary; it usually reflects the sum of
	21	* builtin/SoC GPIOs plus a number of GPIOs on expanders; the latter is
	22	* actually an estimate of a board-specific value.
d2876d08 DB	23	*/
	24
	25	#ifndef ARCH_NR_GPIOS
	26	#define ARCH_NR_GPIOS 256
	27	#endif
	28
c956126c DB	29	/*
	30	* "valid" GPIO numbers are nonnegative and may be passed to
	31	* setup routines like gpio_request(). only some valid numbers
	32	* can successfully be requested and used.
	33	*
	34	* Invalid GPIO numbers are useful for indicating no-such-GPIO in
	35	* platform data and other tables.
	36	*/
	37
e6de1808 GL	38	static inline int gpio_is_valid(int number)
e6de1808 GL	39	{
e6de1808 GL	40	return ((unsigned)number) < ARCH_NR_GPIOS;
	41	}
	42
1f018c8d	43	struct device;
d2876d08	44	struct seq_file;
438d8908	45	struct module;
a19e3da5	46	struct device_node;
d2876d08 DB	47
	48	/**
	49	* struct gpio_chip - abstract a GPIO controller
	50	* @label: for diagnostics
d8f388d8 DB	51	* @dev: optional device providing the GPIOs
d8f388d8 DB	52	* @owner: helps prevent removal of modules exporting active GPIOs
35e8bb51 DB	53	* @request: optional hook for chip-specific activation, such as
	54	* enabling module power and clock; may sleep
	55	* @free: optional hook for chip-specific deactivation, such as
	56	* disabling module power and clock; may sleep
d2876d08 DB	57	* @direction_input: configures signal "offset" as input, or returns error
	58	* @get: returns value for signal "offset"; for output signals this
	59	* returns either the value actually sensed, or zero
	60	* @direction_output: configures signal "offset" as output, or returns error
	61	* @set: assigns output value for signal "offset"
0f6d504e DB	62	* @to_irq: optional hook supporting non-static gpio_to_irq() mappings;
0f6d504e DB	63	* implementation may not sleep
d2876d08 DB	64	* @dbg_show: optional routine to show contents in debugfs; default code
	65	* will be used when this is omitted, but custom code can show extra
	66	* state (such as pullup/pulldown configuration).
	67	* @base: identifies the first GPIO number handled by this chip; or, if
	68	* negative during registration, requests dynamic ID allocation.
	69	* @ngpio: the number of GPIOs handled by this controller; the last GPIO
	70	* handled is (base + ngpio - 1).
	71	* @can_sleep: flag must be set iff get()/set() methods sleep, as they
	72	* must while accessing GPIO expander chips over I2C or SPI
926b663c DS	73	* @names: if set, must be an array of strings to use as alternative
	74	* names for the GPIOs in this chip. Any entry in the array
	75	* may be NULL if there is no alias for the GPIO, however the
7839ec78 UKK	76	* array must be @ngpio entries long. A name can include a single printk
	77	* format specifier for an unsigned int. It is substituted by the actual
	78	* number of the gpio.
d2876d08 DB	79	*
	80	* A gpio_chip can help platforms abstract various sources of GPIOs so
	81	* they can all be accessed through a common programing interface.
	82	* Example sources would be SOC controllers, FPGAs, multifunction
	83	* chips, dedicated GPIO expanders, and so on.
	84	*
	85	* Each chip controls a number of signals, identified in method calls
	86	* by "offset" values in the range 0..(@ngpio - 1). When those signals
	87	* are referenced through calls like gpio_get_value(gpio), the offset
	88	* is calculated by subtracting @base from the gpio number.
	89	*/
	90	struct gpio_chip {
4fd5463c	91	const char *label;
d8f388d8	92	struct device *dev;
438d8908	93	struct module *owner;
d2876d08	94
35e8bb51 DB	95	int (request)(struct gpio_chip chip,
	96	unsigned offset);
	97	void (free)(struct gpio_chip chip,
	98	unsigned offset);
	99
d2876d08 DB	100	int (direction_input)(struct gpio_chip chip,
	101	unsigned offset);
	102	int (get)(struct gpio_chip chip,
	103	unsigned offset);
	104	int (direction_output)(struct gpio_chip chip,
	105	unsigned offset, int value);
c4b5be98 FB	106	int (set_debounce)(struct gpio_chip chip,
	107	unsigned offset, unsigned debounce);
	108
d2876d08 DB	109	void (set)(struct gpio_chip chip,
d2876d08 DB	110	unsigned offset, int value);
0f6d504e DB	111
	112	int (to_irq)(struct gpio_chip chip,
	113	unsigned offset);
	114
d2876d08 DB	115	void (dbg_show)(struct seq_file s,
	116	struct gpio_chip *chip);
	117	int base;
	118	u16 ngpio;
62154991	119	const char const names;
d2876d08	120	unsigned can_sleep:1;
d8f388d8	121	unsigned exported:1;
a19e3da5 AV	122
	123	#if defined(CONFIG_OF_GPIO)
	124	/*
	125	* If CONFIG_OF is enabled, then all GPIO controllers described in the
	126	* device tree automatically may have an OF translation
	127	*/
	128	struct device_node *of_node;
	129	int of_gpio_n_cells;
	130	int (of_xlate)(struct gpio_chip gc, struct device_node *np,
	131	const void gpio_spec, u32 flags);
	132	#endif
d2876d08 DB	133	};
	134
	135	extern const char gpiochip_is_requested(struct gpio_chip chip,
	136	unsigned offset);
6ea0205b	137	extern int __must_check gpiochip_reserve(int start, int ngpio);
d2876d08 DB	138
	139	/* add/remove chips */
	140	extern int gpiochip_add(struct gpio_chip *chip);
	141	extern int __must_check gpiochip_remove(struct gpio_chip *chip);
594fa265 GL	142	extern struct gpio_chip gpiochip_find(void data,
	143	int (match)(struct gpio_chip chip,
	144	void *data));
d2876d08 DB	145
	146
	147	/* Always use the library code for GPIO management calls,
	148	* or when sleeping may be involved.
	149	*/
	150	extern int gpio_request(unsigned gpio, const char *label);
	151	extern void gpio_free(unsigned gpio);
	152
	153	extern int gpio_direction_input(unsigned gpio);
	154	extern int gpio_direction_output(unsigned gpio, int value);
	155
c4b5be98 FB	156	extern int gpio_set_debounce(unsigned gpio, unsigned debounce);
c4b5be98 FB	157
d2876d08 DB	158	extern int gpio_get_value_cansleep(unsigned gpio);
	159	extern void gpio_set_value_cansleep(unsigned gpio, int value);
	160
	161
	162	/* A platform's <asm/gpio.h> code may want to inline the I/O calls when
	163	* the GPIO is constant and refers to some always-present controller,
	164	* giving direct access to chip registers and tight bitbanging loops.
	165	*/
	166	extern int __gpio_get_value(unsigned gpio);
	167	extern void __gpio_set_value(unsigned gpio, int value);
	168
	169	extern int __gpio_cansleep(unsigned gpio);
	170
0f6d504e	171	extern int __gpio_to_irq(unsigned gpio);
d2876d08	172
3e45f1d1 EM	173	#define GPIOF_DIR_OUT (0 << 0)
	174	#define GPIOF_DIR_IN (1 << 0)
	175
	176	#define GPIOF_INIT_LOW (0 << 1)
	177	#define GPIOF_INIT_HIGH (1 << 1)
	178
	179	#define GPIOF_IN (GPIOF_DIR_IN)
	180	#define GPIOF_OUT_INIT_LOW (GPIOF_DIR_OUT \| GPIOF_INIT_LOW)
	181	#define GPIOF_OUT_INIT_HIGH (GPIOF_DIR_OUT \| GPIOF_INIT_HIGH)
	182
	183	/**
	184	* struct gpio - a structure describing a GPIO with configuration
	185	* @gpio: the GPIO number
	186	* @flags: GPIO configuration as specified by GPIOF_*
	187	* @label: a literal description string of this GPIO
	188	*/
	189	struct gpio {
	190	unsigned gpio;
	191	unsigned long flags;
	192	const char *label;
	193	};
	194
	195	extern int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
	196	extern int gpio_request_array(struct gpio *array, size_t num);
	197	extern void gpio_free_array(struct gpio *array, size_t num);
	198
d8f388d8 DB	199	#ifdef CONFIG_GPIO_SYSFS
	200
	201	/*
	202	* A sysfs interface can be exported by individual drivers if they want,
	203	* but more typically is configured entirely from userspace.
	204	*/
	205	extern int gpio_export(unsigned gpio, bool direction_may_change);
a4177ee7 JN	206	extern int gpio_export_link(struct device dev, const char name,
a4177ee7 JN	207	unsigned gpio);
07697461	208	extern int gpio_sysfs_set_active_low(unsigned gpio, int value);
d8f388d8 DB	209	extern void gpio_unexport(unsigned gpio);
	210
	211	#endif /* CONFIG_GPIO_SYSFS */
	212
	213	#else /* !CONFIG_HAVE_GPIO_LIB */
d2876d08	214
e6de1808 GL	215	static inline int gpio_is_valid(int number)
	216	{
	217	/* only non-negative numbers are valid */
	218	return number >= 0;
	219	}
	220
4c20386c DB	221	/* platforms that don't directly support access to GPIOs through I2C, SPI,
	222	* or other blocking infrastructure can use these wrappers.
	223	*/
	224
	225	static inline int gpio_cansleep(unsigned gpio)
	226	{
	227	return 0;
	228	}
	229
	230	static inline int gpio_get_value_cansleep(unsigned gpio)
	231	{
	232	might_sleep();
	233	return gpio_get_value(gpio);
	234	}
	235
	236	static inline void gpio_set_value_cansleep(unsigned gpio, int value)
	237	{
	238	might_sleep();
	239	gpio_set_value(gpio, value);
	240	}
	241
d8f388d8 DB	242	#endif /* !CONFIG_HAVE_GPIO_LIB */
	243
	244	#ifndef CONFIG_GPIO_SYSFS
	245
1f018c8d MF	246	struct device;
1f018c8d MF	247
d8f388d8 DB	248	/* sysfs support is only available with gpiolib, where it's optional */
	249
	250	static inline int gpio_export(unsigned gpio, bool direction_may_change)
	251	{
	252	return -ENOSYS;
	253	}
	254
a4177ee7 JN	255	static inline int gpio_export_link(struct device dev, const char name,
	256	unsigned gpio)
	257	{
	258	return -ENOSYS;
	259	}
	260
07697461 JN	261	static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
	262	{
	263	return -ENOSYS;
	264	}
	265
d8f388d8 DB	266	static inline void gpio_unexport(unsigned gpio)
	267	{
	268	}
	269	#endif /* CONFIG_GPIO_SYSFS */
d2876d08	270
4c20386c	271	#endif /* _ASM_GENERIC_GPIO_H */