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 /* Child properties interface */
  98 struct fwnode_handle;
  99
 100 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 101                                          const char *propname);
 102 struct gpio_desc *devm_get_gpiod_from_child(struct device *dev,
 103                                             struct fwnode_handle *child);
 104 #else /* CONFIG_GPIOLIB */
 105
 106 static inline struct gpio_desc *__must_check __gpiod_get(struct device *dev,
 107                                                 const char *con_id,
 108                                                 enum gpiod_flags flags)
 109 {
 110         return ERR_PTR(-ENOSYS);
 111 }
 112 static inline struct gpio_desc *__must_check
 113 __gpiod_get_index(struct device *dev,
 114                   const char *con_id,
 115                   unsigned int idx,
 116                   enum gpiod_flags flags)
 117 {
 118         return ERR_PTR(-ENOSYS);
 119 }
 120
 121 static inline struct gpio_desc *__must_check
 122 __gpiod_get_optional(struct device *dev, const char *con_id,
 123                      enum gpiod_flags flags)
 124 {
 125         return ERR_PTR(-ENOSYS);
 126 }
 127
 128 static inline struct gpio_desc *__must_check
 129 __gpiod_get_index_optional(struct device *dev, const char *con_id,
 130                            unsigned int index, enum gpiod_flags flags)
 131 {
 132         return ERR_PTR(-ENOSYS);
 133 }
 134
 135 static inline void gpiod_put(struct gpio_desc *desc)
 136 {
 137         might_sleep();
 138
 139         /* GPIO can never have been requested */
 140         WARN_ON(1);
 141 }
 142
 143 static inline struct gpio_desc *__must_check
 144 __devm_gpiod_get(struct device *dev,
 145                  const char *con_id,
 146                  enum gpiod_flags flags)
 147 {
 148         return ERR_PTR(-ENOSYS);
 149 }
 150 static inline
 151 struct gpio_desc *__must_check
 152 __devm_gpiod_get_index(struct device *dev,
 153                        const char *con_id,
 154                        unsigned int idx,
 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_optional(struct device *dev, const char *con_id,
 162                           enum gpiod_flags flags)
 163 {
 164         return ERR_PTR(-ENOSYS);
 165 }
 166
 167 static inline struct gpio_desc *__must_check
 168 __devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 169                                 unsigned int index, enum gpiod_flags flags)
 170 {
 171         return ERR_PTR(-ENOSYS);
 172 }
 173
 174 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
 175 {
 176         might_sleep();
 177
 178         /* GPIO can never have been requested */
 179         WARN_ON(1);
 180 }
 181
 182
 183 static inline int gpiod_get_direction(const struct gpio_desc *desc)
 184 {
 185         /* GPIO can never have been requested */
 186         WARN_ON(1);
 187         return -ENOSYS;
 188 }
 189 static inline int gpiod_direction_input(struct gpio_desc *desc)
 190 {
 191         /* GPIO can never have been requested */
 192         WARN_ON(1);
 193         return -ENOSYS;
 194 }
 195 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
 196 {
 197         /* GPIO can never have been requested */
 198         WARN_ON(1);
 199         return -ENOSYS;
 200 }
 201 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 202 {
 203         /* GPIO can never have been requested */
 204         WARN_ON(1);
 205         return -ENOSYS;
 206 }
 207
 208
 209 static inline int gpiod_get_value(const struct gpio_desc *desc)
 210 {
 211         /* GPIO can never have been requested */
 212         WARN_ON(1);
 213         return 0;
 214 }
 215 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
 216 {
 217         /* GPIO can never have been requested */
 218         WARN_ON(1);
 219 }
 220 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 221 {
 222         /* GPIO can never have been requested */
 223         WARN_ON(1);
 224         return 0;
 225 }
 226 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 227 {
 228         /* GPIO can never have been requested */
 229         WARN_ON(1);
 230 }
 231
 232 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 233 {
 234         /* GPIO can never have been requested */
 235         WARN_ON(1);
 236         return 0;
 237 }
 238 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 239 {
 240         /* GPIO can never have been requested */
 241         WARN_ON(1);
 242 }
 243 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 244 {
 245         /* GPIO can never have been requested */
 246         WARN_ON(1);
 247         return 0;
 248 }
 249 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 250                                                 int value)
 251 {
 252         /* GPIO can never have been requested */
 253         WARN_ON(1);
 254 }
 255
 256 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 257 {
 258         /* GPIO can never have been requested */
 259         WARN_ON(1);
 260         return -ENOSYS;
 261 }
 262
 263 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 264 {
 265         /* GPIO can never have been requested */
 266         WARN_ON(1);
 267         return 0;
 268 }
 269 static inline int gpiod_cansleep(const struct gpio_desc *desc)
 270 {
 271         /* GPIO can never have been requested */
 272         WARN_ON(1);
 273         return 0;
 274 }
 275
 276 static inline int gpiod_to_irq(const struct gpio_desc *desc)
 277 {
 278         /* GPIO can never have been requested */
 279         WARN_ON(1);
 280         return -EINVAL;
 281 }
 282
 283 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 284 {
 285         return ERR_PTR(-EINVAL);
 286 }
 287 static inline int desc_to_gpio(const struct gpio_desc *desc)
 288 {
 289         /* GPIO can never have been requested */
 290         WARN_ON(1);
 291         return -EINVAL;
 292 }
 293
 294 #endif /* CONFIG_GPIOLIB */
 295
 296 /*
 297  * Vararg-hacks! This is done to transition the kernel to always pass
 298  * the options flags argument to the below functions. During a transition
 299  * phase these vararg macros make both old-and-newstyle code compile,
 300  * but when all calls to the elder API are removed, these should go away
 301  * and the __gpiod_get() etc functions above be renamed just gpiod_get()
 302  * etc.
 303  */
 304 #define __gpiod_get(dev, con_id, flags, ...) __gpiod_get(dev, con_id, flags)
 305 #define gpiod_get(varargs...) __gpiod_get(varargs, 0)
 306 #define __gpiod_get_index(dev, con_id, index, flags, ...)               \
 307         __gpiod_get_index(dev, con_id, index, flags)
 308 #define gpiod_get_index(varargs...) __gpiod_get_index(varargs, 0)
 309 #define __gpiod_get_optional(dev, con_id, flags, ...)                   \
 310         __gpiod_get_optional(dev, con_id, flags)
 311 #define gpiod_get_optional(varargs...) __gpiod_get_optional(varargs, 0)
 312 #define __gpiod_get_index_optional(dev, con_id, index, flags, ...)      \
 313         __gpiod_get_index_optional(dev, con_id, index, flags)
 314 #define gpiod_get_index_optional(varargs...)                            \
 315         __gpiod_get_index_optional(varargs, 0)
 316 #define __devm_gpiod_get(dev, con_id, flags, ...)                       \
 317         __devm_gpiod_get(dev, con_id, flags)
 318 #define devm_gpiod_get(varargs...) __devm_gpiod_get(varargs, 0)
 319 #define __devm_gpiod_get_index(dev, con_id, index, flags, ...)          \
 320         __devm_gpiod_get_index(dev, con_id, index, flags)
 321 #define devm_gpiod_get_index(varargs...) __devm_gpiod_get_index(varargs, 0)
 322 #define __devm_gpiod_get_optional(dev, con_id, flags, ...)              \
 323         __devm_gpiod_get_optional(dev, con_id, flags)
 324 #define devm_gpiod_get_optional(varargs...)                             \
 325         __devm_gpiod_get_optional(varargs, 0)
 326 #define __devm_gpiod_get_index_optional(dev, con_id, index, flags, ...) \
 327         __devm_gpiod_get_index_optional(dev, con_id, index, flags)
 328 #define devm_gpiod_get_index_optional(varargs...)                       \
 329         __devm_gpiod_get_index_optional(varargs, 0)
 330
 331 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 332
 333 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 334 int gpiod_export_link(struct device *dev, const char *name,
 335                       struct gpio_desc *desc);
 336 int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
 337 void gpiod_unexport(struct gpio_desc *desc);
 338
 339 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 340
 341 static inline int gpiod_export(struct gpio_desc *desc,
 342                                bool direction_may_change)
 343 {
 344         return -ENOSYS;
 345 }
 346
 347 static inline int gpiod_export_link(struct device *dev, const char *name,
 348                                     struct gpio_desc *desc)
 349 {
 350         return -ENOSYS;
 351 }
 352
 353 static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
 354 {
 355         return -ENOSYS;
 356 }
 357
 358 static inline void gpiod_unexport(struct gpio_desc *desc)
 359 {
 360 }
 361
 362 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 363
 364 #endif