include/asm-generic/gpio.h

   1 #ifndef _ASM_GENERIC_GPIO_H
   2 #define _ASM_GENERIC_GPIO_H
   3
   4 #include <linux/kernel.h>
   5 #include <linux/types.h>
   6 #include <linux/errno.h>
   7 #include <linux/of.h>
   8 #include <linux/pinctrl/pinctrl.h>
   9
  10 #ifdef CONFIG_GPIOLIB
  11
  12 #include <linux/compiler.h>
  13 #include <linux/gpio/driver.h>
  14 #include <linux/gpio/consumer.h>
  15
  16 /* Platforms may implement their GPIO interface with library code,
  17  * at a small performance cost for non-inlined operations and some
  18  * extra memory (for code and for per-GPIO table entries).
  19  *
  20  * While the GPIO programming interface defines valid GPIO numbers
  21  * to be in the range 0..MAX_INT, this library restricts them to the
  22  * smaller range 0..ARCH_NR_GPIOS-1.
  23  *
  24  * ARCH_NR_GPIOS is somewhat arbitrary; it usually reflects the sum of
  25  * builtin/SoC GPIOs plus a number of GPIOs on expanders; the latter is
  26  * actually an estimate of a board-specific value.
  27  */
  28
  29 #ifndef ARCH_NR_GPIOS
  30 #define ARCH_NR_GPIOS           512
  31 #endif
  32
  33 /*
  34  * "valid" GPIO numbers are nonnegative and may be passed to
  35  * setup routines like gpio_request().  only some valid numbers
  36  * can successfully be requested and used.
  37  *
  38  * Invalid GPIO numbers are useful for indicating no-such-GPIO in
  39  * platform data and other tables.
  40  */
  41
  42 static inline bool gpio_is_valid(int number)
  43 {
  44         return number >= 0 && number < ARCH_NR_GPIOS;
  45 }
  46
  47 struct device;
  48 struct gpio;
  49 struct seq_file;
  50 struct module;
  51 struct device_node;
  52 struct gpio_desc;
  53
  54 /* caller holds gpio_lock *OR* gpio is marked as requested */
  55 static inline struct gpio_chip *gpio_to_chip(unsigned gpio)
  56 {
  57         return gpiod_to_chip(gpio_to_desc(gpio));
  58 }
  59
  60 /* Always use the library code for GPIO management calls,
  61  * or when sleeping may be involved.
  62  */
  63 extern int gpio_request(unsigned gpio, const char *label);
  64 extern void gpio_free(unsigned gpio);
  65
  66 static inline int gpio_direction_input(unsigned gpio)
  67 {
  68         return gpiod_direction_input(gpio_to_desc(gpio));
  69 }
  70 static inline int gpio_direction_output(unsigned gpio, int value)
  71 {
  72         return gpiod_direction_output_raw(gpio_to_desc(gpio), value);
  73 }
  74
  75 static inline int gpio_set_debounce(unsigned gpio, unsigned debounce)
  76 {
  77         return gpiod_set_debounce(gpio_to_desc(gpio), debounce);
  78 }
  79
  80 static inline int gpio_get_value_cansleep(unsigned gpio)
  81 {
  82         return gpiod_get_raw_value_cansleep(gpio_to_desc(gpio));
  83 }
  84 static inline void gpio_set_value_cansleep(unsigned gpio, int value)
  85 {
  86         return gpiod_set_raw_value_cansleep(gpio_to_desc(gpio), value);
  87 }
  88
  89
  90 /* A platform's <asm/gpio.h> code may want to inline the I/O calls when
  91  * the GPIO is constant and refers to some always-present controller,
  92  * giving direct access to chip registers and tight bitbanging loops.
  93  */
  94 static inline int __gpio_get_value(unsigned gpio)
  95 {
  96         return gpiod_get_raw_value(gpio_to_desc(gpio));
  97 }
  98 static inline void __gpio_set_value(unsigned gpio, int value)
  99 {
 100         return gpiod_set_raw_value(gpio_to_desc(gpio), value);
 101 }
 102
 103 static inline int __gpio_cansleep(unsigned gpio)
 104 {
 105         return gpiod_cansleep(gpio_to_desc(gpio));
 106 }
 107
 108 static inline int __gpio_to_irq(unsigned gpio)
 109 {
 110         return gpiod_to_irq(gpio_to_desc(gpio));
 111 }
 112
 113 extern int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
 114 extern int gpio_request_array(const struct gpio *array, size_t num);
 115 extern void gpio_free_array(const struct gpio *array, size_t num);
 116
 117 /*
 118  * A sysfs interface can be exported by individual drivers if they want,
 119  * but more typically is configured entirely from userspace.
 120  */
 121 static inline int gpio_export(unsigned gpio, bool direction_may_change)
 122 {
 123         return gpiod_export(gpio_to_desc(gpio), direction_may_change);
 124 }
 125
 126 static inline int gpio_export_link(struct device *dev, const char *name,
 127                                    unsigned gpio)
 128 {
 129         return gpiod_export_link(dev, name, gpio_to_desc(gpio));
 130 }
 131
 132 static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
 133 {
 134         return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
 135 }
 136
 137 static inline void gpio_unexport(unsigned gpio)
 138 {
 139         gpiod_unexport(gpio_to_desc(gpio));
 140 }
 141
 142 #ifdef CONFIG_PINCTRL
 143
 144 /**
 145  * struct gpio_pin_range - pin range controlled by a gpio chip
 146  * @head: list for maintaining set of pin ranges, used internally
 147  * @pctldev: pinctrl device which handles corresponding pins
 148  * @range: actual range of pins controlled by a gpio controller
 149  */
 150
 151 struct gpio_pin_range {
 152         struct list_head node;
 153         struct pinctrl_dev *pctldev;
 154         struct pinctrl_gpio_range range;
 155 };
 156
 157 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
 158                            unsigned int gpio_offset, unsigned int pin_offset,
 159                            unsigned int npins);
 160 int gpiochip_add_pingroup_range(struct gpio_chip *chip,
 161                         struct pinctrl_dev *pctldev,
 162                         unsigned int gpio_offset, const char *pin_group);
 163 void gpiochip_remove_pin_ranges(struct gpio_chip *chip);
 164
 165 #else
 166
 167 static inline int
 168 gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
 169                        unsigned int gpio_offset, unsigned int pin_offset,
 170                        unsigned int npins)
 171 {
 172         return 0;
 173 }
 174 static inline int
 175 gpiochip_add_pingroup_range(struct gpio_chip *chip,
 176                         struct pinctrl_dev *pctldev,
 177                         unsigned int gpio_offset, const char *pin_group)
 178 {
 179         return 0;
 180 }
 181
 182 static inline void
 183 gpiochip_remove_pin_ranges(struct gpio_chip *chip)
 184 {
 185 }
 186
 187 #endif /* CONFIG_PINCTRL */
 188
 189 #else   /* !CONFIG_GPIOLIB */
 190
 191 static inline bool gpio_is_valid(int number)
 192 {
 193         /* only non-negative numbers are valid */
 194         return number >= 0;
 195 }
 196
 197 /* platforms that don't directly support access to GPIOs through I2C, SPI,
 198  * or other blocking infrastructure can use these wrappers.
 199  */
 200
 201 static inline int gpio_cansleep(unsigned gpio)
 202 {
 203         return 0;
 204 }
 205
 206 static inline int gpio_get_value_cansleep(unsigned gpio)
 207 {
 208         might_sleep();
 209         return __gpio_get_value(gpio);
 210 }
 211
 212 static inline void gpio_set_value_cansleep(unsigned gpio, int value)
 213 {
 214         might_sleep();
 215         __gpio_set_value(gpio, value);
 216 }
 217
 218 #endif /* !CONFIG_GPIOLIB */
 219
 220 #endif /* _ASM_GENERIC_GPIO_H */