include/linux/gpio/consumer.h

   1 #ifndef __LINUX_GPIO_CONSUMER_H
   2 #define __LINUX_GPIO_CONSUMER_H
   3
   4 #include <linux/bug.h>
   5 #include <linux/err.h>
   6 #include <linux/kernel.h>
   7
   8 struct device;
   9
  10 /**
  11  * Opaque descriptor for a GPIO. These are obtained using gpiod_get() and are
  12  * preferable to the old integer-based handles.
  13  *
  14  * Contrary to integers, a pointer to a gpio_desc is guaranteed to be valid
  15  * until the GPIO is released.
  16  */
  17 struct gpio_desc;
  18
  19 #define GPIOD_FLAGS_BIT_DIR_SET         BIT(0)
  20 #define GPIOD_FLAGS_BIT_DIR_OUT         BIT(1)
  21 #define GPIOD_FLAGS_BIT_DIR_VAL         BIT(2)
  22
  23 /**
  24  * Optional flags that can be passed to one of gpiod_* to configure direction
  25  * and output value. These values cannot be OR'd.
  26  */
  27 enum gpiod_flags {
  28         GPIOD_ASIS      = 0,
  29         GPIOD_IN        = GPIOD_FLAGS_BIT_DIR_SET,
  30         GPIOD_OUT_LOW   = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT,
  31         GPIOD_OUT_HIGH  = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
  32                           GPIOD_FLAGS_BIT_DIR_VAL,
  33 };
  34
  35 #ifdef CONFIG_GPIOLIB
  36
  37 /* Acquire and dispose GPIOs */
  38 struct gpio_desc *__must_check __gpiod_get(struct device *dev,
  39                                          const char *con_id,
  40                                          enum gpiod_flags flags);
  41 struct gpio_desc *__must_check __gpiod_get_index(struct device *dev,
  42                                                const char *con_id,
  43                                                unsigned int idx,
  44                                                enum gpiod_flags flags);
  45 struct gpio_desc *__must_check __gpiod_get_optional(struct device *dev,
  46                                                   const char *con_id,
  47                                                   enum gpiod_flags flags);
  48 struct gpio_desc *__must_check __gpiod_get_index_optional(struct device *dev,
  49                                                         const char *con_id,
  50                                                         unsigned int index,
  51                                                         enum gpiod_flags flags);
  52 void gpiod_put(struct gpio_desc *desc);
  53
  54 struct gpio_desc *__must_check __devm_gpiod_get(struct device *dev,
  55                                               const char *con_id,
  56                                               enum gpiod_flags flags);
  57 struct gpio_desc *__must_check __devm_gpiod_get_index(struct device *dev,
  58                                                     const char *con_id,
  59                                                     unsigned int idx,
  60                                                     enum gpiod_flags flags);
  61 struct gpio_desc *__must_check __devm_gpiod_get_optional(struct device *dev,
  62                                                        const char *con_id,
  63                                                        enum gpiod_flags flags);
  64 struct gpio_desc *__must_check
  65 __devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
  66                               unsigned int index, enum gpiod_flags flags);
  67 void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
  68
  69 int gpiod_get_direction(const struct gpio_desc *desc);
  70 int gpiod_direction_input(struct gpio_desc *desc);
  71 int gpiod_direction_output(struct gpio_desc *desc, int value);
  72 int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
  73
  74 /* Value get/set from non-sleeping context */
  75 int gpiod_get_value(const struct gpio_desc *desc);
  76 void gpiod_set_value(struct gpio_desc *desc, int value);
  77 int gpiod_get_raw_value(const struct gpio_desc *desc);
  78 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
  79
  80 /* Value get/set from sleeping context */
  81 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
  82 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
  83 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
  84 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
  85
  86 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
  87
  88 int gpiod_is_active_low(const struct gpio_desc *desc);
  89 int gpiod_cansleep(const struct gpio_desc *desc);
  90
  91 int gpiod_to_irq(const struct gpio_desc *desc);
  92
  93 /* Convert between the old gpio_ and new gpiod_ interfaces */
  94 struct gpio_desc *gpio_to_desc(unsigned gpio);
  95 int desc_to_gpio(const struct gpio_desc *desc);
  96
  97 #else /* CONFIG_GPIOLIB */
  98
  99 static inline struct gpio_desc *__must_check __gpiod_get(struct device *dev,
 100                                                 const char *con_id,
 101                                                 enum gpiod_flags flags)
 102 {
 103         return ERR_PTR(-ENOSYS);
 104 }
 105 static inline struct gpio_desc *__must_check
 106 __gpiod_get_index(struct device *dev,
 107                   const char *con_id,
 108                   unsigned int idx,
 109                   enum gpiod_flags flags)
 110 {
 111         return ERR_PTR(-ENOSYS);
 112 }
 113
 114 static inline struct gpio_desc *__must_check
 115 __gpiod_get_optional(struct device *dev, const char *con_id,
 116                      enum gpiod_flags flags)
 117 {
 118         return ERR_PTR(-ENOSYS);
 119 }
 120
 121 static inline struct gpio_desc *__must_check
 122 __gpiod_get_index_optional(struct device *dev, const char *con_id,
 123                            unsigned int index, enum gpiod_flags flags)
 124 {
 125         return ERR_PTR(-ENOSYS);
 126 }
 127
 128 static inline void gpiod_put(struct gpio_desc *desc)
 129 {
 130         might_sleep();
 131
 132         /* GPIO can never have been requested */
 133         WARN_ON(1);
 134 }
 135
 136 static inline struct gpio_desc *__must_check
 137 __devm_gpiod_get(struct device *dev,
 138                  const char *con_id,
 139                  enum gpiod_flags flags)
 140 {
 141         return ERR_PTR(-ENOSYS);
 142 }
 143 static inline
 144 struct gpio_desc *__must_check
 145 __devm_gpiod_get_index(struct device *dev,
 146                        const char *con_id,
 147                        unsigned int idx,
 148                        enum gpiod_flags flags)
 149 {
 150         return ERR_PTR(-ENOSYS);
 151 }
 152
 153 static inline struct gpio_desc *__must_check
 154 __devm_gpiod_get_optional(struct device *dev, const char *con_id,
 155                           enum gpiod_flags flags)
 156 {
 157         return ERR_PTR(-ENOSYS);
 158 }
 159
 160 static inline struct gpio_desc *__must_check
 161 __devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 162                                 unsigned int index, enum gpiod_flags flags)
 163 {
 164         return ERR_PTR(-ENOSYS);
 165 }
 166
 167 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
 168 {
 169         might_sleep();
 170
 171         /* GPIO can never have been requested */
 172         WARN_ON(1);
 173 }
 174
 175
 176 static inline int gpiod_get_direction(const struct gpio_desc *desc)
 177 {
 178         /* GPIO can never have been requested */
 179         WARN_ON(1);
 180         return -ENOSYS;
 181 }
 182 static inline int gpiod_direction_input(struct gpio_desc *desc)
 183 {
 184         /* GPIO can never have been requested */
 185         WARN_ON(1);
 186         return -ENOSYS;
 187 }
 188 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
 189 {
 190         /* GPIO can never have been requested */
 191         WARN_ON(1);
 192         return -ENOSYS;
 193 }
 194 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 195 {
 196         /* GPIO can never have been requested */
 197         WARN_ON(1);
 198         return -ENOSYS;
 199 }
 200
 201
 202 static inline int gpiod_get_value(const struct gpio_desc *desc)
 203 {
 204         /* GPIO can never have been requested */
 205         WARN_ON(1);
 206         return 0;
 207 }
 208 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
 209 {
 210         /* GPIO can never have been requested */
 211         WARN_ON(1);
 212 }
 213 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 214 {
 215         /* GPIO can never have been requested */
 216         WARN_ON(1);
 217         return 0;
 218 }
 219 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 220 {
 221         /* GPIO can never have been requested */
 222         WARN_ON(1);
 223 }
 224
 225 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 226 {
 227         /* GPIO can never have been requested */
 228         WARN_ON(1);
 229         return 0;
 230 }
 231 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 232 {
 233         /* GPIO can never have been requested */
 234         WARN_ON(1);
 235 }
 236 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 237 {
 238         /* GPIO can never have been requested */
 239         WARN_ON(1);
 240         return 0;
 241 }
 242 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 243                                                 int value)
 244 {
 245         /* GPIO can never have been requested */
 246         WARN_ON(1);
 247 }
 248
 249 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 250 {
 251         /* GPIO can never have been requested */
 252         WARN_ON(1);
 253         return -ENOSYS;
 254 }
 255
 256 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 257 {
 258         /* GPIO can never have been requested */
 259         WARN_ON(1);
 260         return 0;
 261 }
 262 static inline int gpiod_cansleep(const struct gpio_desc *desc)
 263 {
 264         /* GPIO can never have been requested */
 265         WARN_ON(1);
 266         return 0;
 267 }
 268
 269 static inline int gpiod_to_irq(const struct gpio_desc *desc)
 270 {
 271         /* GPIO can never have been requested */
 272         WARN_ON(1);
 273         return -EINVAL;
 274 }
 275
 276 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 277 {
 278         return ERR_PTR(-EINVAL);
 279 }
 280 static inline int desc_to_gpio(const struct gpio_desc *desc)
 281 {
 282         /* GPIO can never have been requested */
 283         WARN_ON(1);
 284         return -EINVAL;
 285 }
 286
 287 #endif /* CONFIG_GPIOLIB */
 288
 289 /*
 290  * Vararg-hacks! This is done to transition the kernel to always pass
 291  * the options flags argument to the below functions. During a transition
 292  * phase these vararg macros make both old-and-newstyle code compile,
 293  * but when all calls to the elder API are removed, these should go away
 294  * and the __gpiod_get() etc functions above be renamed just gpiod_get()
 295  * etc.
 296  */
 297 #define __gpiod_get(dev, con_id, flags, ...) __gpiod_get(dev, con_id, flags)
 298 #define gpiod_get(varargs...) __gpiod_get(varargs, 0)
 299 #define __gpiod_get_index(dev, con_id, index, flags, ...)               \
 300         __gpiod_get_index(dev, con_id, index, flags)
 301 #define gpiod_get_index(varargs...) __gpiod_get_index(varargs, 0)
 302 #define __gpiod_get_optional(dev, con_id, flags, ...)                   \
 303         __gpiod_get_optional(dev, con_id, flags)
 304 #define gpiod_get_optional(varargs...) __gpiod_get_optional(varargs, 0)
 305 #define __gpiod_get_index_optional(dev, con_id, index, flags, ...)      \
 306         __gpiod_get_index_optional(dev, con_id, index, flags)
 307 #define gpiod_get_index_optional(varargs...)                            \
 308         __gpiod_get_index_optional(varargs, 0)
 309 #define __devm_gpiod_get(dev, con_id, flags, ...)                       \
 310         __devm_gpiod_get(dev, con_id, flags)
 311 #define devm_gpiod_get(varargs...) __devm_gpiod_get(varargs, 0)
 312 #define __devm_gpiod_get_index(dev, con_id, index, flags, ...)          \
 313         __devm_gpiod_get_index(dev, con_id, index, flags)
 314 #define devm_gpiod_get_index(varargs...) __devm_gpiod_get_index(varargs, 0)
 315 #define __devm_gpiod_get_optional(dev, con_id, flags, ...)              \
 316         __devm_gpiod_get_optional(dev, con_id, flags)
 317 #define devm_gpiod_get_optional(varargs...)                             \
 318         __devm_gpiod_get_optional(varargs, 0)
 319 #define __devm_gpiod_get_index_optional(dev, con_id, index, flags, ...) \
 320         __devm_gpiod_get_index_optional(dev, con_id, index, flags)
 321 #define devm_gpiod_get_index_optional(varargs...)                       \
 322         __devm_gpiod_get_index_optional(varargs, 0)
 323
 324 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 325
 326 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 327 int gpiod_export_link(struct device *dev, const char *name,
 328                       struct gpio_desc *desc);
 329 int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
 330 void gpiod_unexport(struct gpio_desc *desc);
 331
 332 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 333
 334 static inline int gpiod_export(struct gpio_desc *desc,
 335                                bool direction_may_change)
 336 {
 337         return -ENOSYS;
 338 }
 339
 340 static inline int gpiod_export_link(struct device *dev, const char *name,
 341                                     struct gpio_desc *desc)
 342 {
 343         return -ENOSYS;
 344 }
 345
 346 static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
 347 {
 348         return -ENOSYS;
 349 }
 350
 351 static inline void gpiod_unexport(struct gpio_desc *desc)
 352 {
 353 }
 354
 355 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 356
 357 #endif