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           256
  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(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_lock_as_irq(struct gpio_chip *chip, unsigned int offset);
 114 extern void gpio_unlock_as_irq(struct gpio_chip *chip, unsigned int offset);
 115
 116 extern int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
 117 extern int gpio_request_array(const struct gpio *array, size_t num);
 118 extern void gpio_free_array(const struct gpio *array, size_t num);
 119
 120 /*
 121  * A sysfs interface can be exported by individual drivers if they want,
 122  * but more typically is configured entirely from userspace.
 123  */
 124 static inline int gpio_export(unsigned gpio, bool direction_may_change)
 125 {
 126         return gpiod_export(gpio_to_desc(gpio), direction_may_change);
 127 }
 128
 129 static inline int gpio_export_link(struct device *dev, const char *name,
 130                                    unsigned gpio)
 131 {
 132         return gpiod_export_link(dev, name, gpio_to_desc(gpio));
 133 }
 134
 135 static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
 136 {
 137         return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
 138 }
 139
 140 static inline void gpio_unexport(unsigned gpio)
 141 {
 142         gpiod_unexport(gpio_to_desc(gpio));
 143 }
 144
 145 #ifdef CONFIG_PINCTRL
 146
 147 /**
 148  * struct gpio_pin_range - pin range controlled by a gpio chip
 149  * @head: list for maintaining set of pin ranges, used internally
 150  * @pctldev: pinctrl device which handles corresponding pins
 151  * @range: actual range of pins controlled by a gpio controller
 152  */
 153
 154 struct gpio_pin_range {
 155         struct list_head node;
 156         struct pinctrl_dev *pctldev;
 157         struct pinctrl_gpio_range range;
 158 };
 159
 160 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
 161                            unsigned int gpio_offset, unsigned int pin_offset,
 162                            unsigned int npins);
 163 int gpiochip_add_pingroup_range(struct gpio_chip *chip,
 164                         struct pinctrl_dev *pctldev,
 165                         unsigned int gpio_offset, const char *pin_group);
 166 void gpiochip_remove_pin_ranges(struct gpio_chip *chip);
 167
 168 #else
 169
 170 static inline int
 171 gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
 172                        unsigned int gpio_offset, unsigned int pin_offset,
 173                        unsigned int npins)
 174 {
 175         return 0;
 176 }
 177 static inline int
 178 gpiochip_add_pingroup_range(struct gpio_chip *chip,
 179                         struct pinctrl_dev *pctldev,
 180                         unsigned int gpio_offset, const char *pin_group)
 181 {
 182         return 0;
 183 }
 184
 185 static inline void
 186 gpiochip_remove_pin_ranges(struct gpio_chip *chip)
 187 {
 188 }
 189
 190 #endif /* CONFIG_PINCTRL */
 191
 192 #else   /* !CONFIG_GPIOLIB */
 193
 194 static inline bool gpio_is_valid(int number)
 195 {
 196         /* only non-negative numbers are valid */
 197         return number >= 0;
 198 }
 199
 200 /* platforms that don't directly support access to GPIOs through I2C, SPI,
 201  * or other blocking infrastructure can use these wrappers.
 202  */
 203
 204 static inline int gpio_cansleep(unsigned gpio)
 205 {
 206         return 0;
 207 }
 208
 209 static inline int gpio_get_value_cansleep(unsigned gpio)
 210 {
 211         might_sleep();
 212         return __gpio_get_value(gpio);
 213 }
 214
 215 static inline void gpio_set_value_cansleep(unsigned gpio, int value)
 216 {
 217         might_sleep();
 218         __gpio_set_value(gpio, value);
 219 }
 220
 221 #endif /* !CONFIG_GPIOLIB */
 222
 223 #endif /* _ASM_GENERIC_GPIO_H */