LXR linux/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
   8struct 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 */
  17struct 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 */
  27enum 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 */
  38struct gpio_desc *__must_check __gpiod_get(struct device *dev,
  39                                         const char *con_id,
  40                                         enum gpiod_flags flags);
  41struct gpio_desc *__must_check __gpiod_get_index(struct device *dev,
  42                                               const char *con_id,
  43                                               unsigned int idx,
  44                                               enum gpiod_flags flags);
  45struct gpio_desc *__must_check __gpiod_get_optional(struct device *dev,
  46                                                  const char *con_id,
  47                                                  enum gpiod_flags flags);
  48struct 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);
  52void gpiod_put(struct gpio_desc *desc);
  53
  54struct gpio_desc *__must_check __devm_gpiod_get(struct device *dev,
  55                                              const char *con_id,
  56                                              enum gpiod_flags flags);
  57struct 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);
  61struct gpio_desc *__must_check __devm_gpiod_get_optional(struct device *dev,
  62                                                       const char *con_id,
  63                                                       enum gpiod_flags flags);
  64struct 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);
  67void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
  68
  69int gpiod_get_direction(const struct gpio_desc *desc);
  70int gpiod_direction_input(struct gpio_desc *desc);
  71int gpiod_direction_output(struct gpio_desc *desc, int value);
  72int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
  73
  74/* Value get/set from non-sleeping context */
  75int gpiod_get_value(const struct gpio_desc *desc);
  76void gpiod_set_value(struct gpio_desc *desc, int value);
  77int gpiod_get_raw_value(const struct gpio_desc *desc);
  78void gpiod_set_raw_value(struct gpio_desc *desc, int value);
  79
  80/* Value get/set from sleeping context */
  81int gpiod_get_value_cansleep(const struct gpio_desc *desc);
  82void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
  83int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
  84void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
  85
  86int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
  87
  88int gpiod_is_active_low(const struct gpio_desc *desc);
  89int gpiod_cansleep(const struct gpio_desc *desc);
  90
  91int gpiod_to_irq(const struct gpio_desc *desc);
  92
  93/* Convert between the old gpio_ and new gpiod_ interfaces */
  94struct gpio_desc *gpio_to_desc(unsigned gpio);
  95int desc_to_gpio(const struct gpio_desc *desc);
  96
  97#else /* CONFIG_GPIOLIB */
  98
  99static 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}
 105static 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
 114static 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
 121static 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
 128static 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
 136static 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}
 143static inline
 144struct 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
 153static 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
 160static 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
 167static 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
 176static 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}
 182static 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}
 188static 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}
 194static 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
 202static 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}
 208static inline void gpiod_set_value(struct gpio_desc *desc, int value)
 209{
 210        /* GPIO can never have been requested */
 211        WARN_ON(1);
 212}
 213static 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}
 219static 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
 225static 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}
 231static 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}
 236static 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}
 242static 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
 249static 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
 256static 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}
 262static 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
 269static 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
 276static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 277{
 278        return ERR_PTR(-EINVAL);
 279}
 280static 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
 326int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 327int gpiod_export_link(struct device *dev, const char *name,
 328                      struct gpio_desc *desc);
 329int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
 330void gpiod_unexport(struct gpio_desc *desc);
 331
 332#else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 333
 334static inline int gpiod_export(struct gpio_desc *desc,
 335                               bool direction_may_change)
 336{
 337        return -ENOSYS;
 338}
 339
 340static inline int gpiod_export_link(struct device *dev, const char *name,
 341                                    struct gpio_desc *desc)
 342{
 343        return -ENOSYS;
 344}
 345
 346static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
 347{
 348        return -ENOSYS;
 349}
 350
 351static inline void gpiod_unexport(struct gpio_desc *desc)
 352{
 353}
 354
 355#endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 356
 357#endif
 358