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