include/asm-generic/gpio.h - maze/linux - Git at Google

 #ifndef _ASM_GENERIC_GPIO_H
 #define _ASM_GENERIC_GPIO_H

 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/of.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 bool gpio_is_valid(int number)
 {
 	return number >= 0 && number < ARCH_NR_GPIOS;
 }

 struct device;
 struct gpio;
 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_debounce: optional hook for setting debounce time for specified gpio in
  *      interrupt triggered gpio chips
  * @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,
 		        const struct of_phandle_args *gpiospec, u32 *flags);
 #endif
 };

 extern const char *gpiochip_is_requested(struct gpio_chip *chip,
 			unsigned offset);
 extern struct gpio_chip *gpio_to_chip(unsigned gpio);
 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);

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

 /* bindings for managed devices that want to request gpios */
 int devm_gpio_request(struct device *dev, unsigned gpio, const char *label);
 int devm_gpio_request_one(struct device *dev, unsigned gpio,
 			  unsigned long flags, const char *label);
 void devm_gpio_free(struct device *dev, unsigned int gpio);

 #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_GPIOLIB */

 static inline bool 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_GPIOLIB */

 #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 */
	#ifndef _ASM_GENERIC_GPIO_H
	#define _ASM_GENERIC_GPIO_H

	#include <linux/kernel.h>
	#include <linux/types.h>
	#include <linux/errno.h>
	#include <linux/of.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 bool gpio_is_valid(int number)
	{
	return number >= 0 && number < ARCH_NR_GPIOS;
	}

	struct device;
	struct gpio;
	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_debounce: optional hook for setting debounce time for specified gpio in
	* interrupt triggered gpio chips
	* @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,
	const struct of_phandle_args gpiospec, u32 flags);
	#endif
	};

	extern const char gpiochip_is_requested(struct gpio_chip chip,
	unsigned offset);
	extern struct gpio_chip *gpio_to_chip(unsigned gpio);
	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);

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

	/* bindings for managed devices that want to request gpios */
	int devm_gpio_request(struct device dev, unsigned gpio, const char label);
	int devm_gpio_request_one(struct device *dev, unsigned gpio,
	unsigned long flags, const char *label);
	void devm_gpio_free(struct device *dev, unsigned int gpio);

	#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_GPIOLIB */

	static inline bool 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_GPIOLIB */

	#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 */