kernel/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 /**
  20  * Struct containing an array of descriptors that can be obtained using
  21  * gpiod_get_array().
  22  */
  23 struct gpio_descs {
  24         unsigned int ndescs;
  25         struct gpio_desc *desc[];
  26 };
  27
  28 #define GPIOD_FLAGS_BIT_DIR_SET         BIT(0)
  29 #define GPIOD_FLAGS_BIT_DIR_OUT         BIT(1)
  30 #define GPIOD_FLAGS_BIT_DIR_VAL         BIT(2)
  31
  32 /**
  33  * Optional flags that can be passed to one of gpiod_* to configure direction
  34  * and output value. These values cannot be OR'd.
  35  */
  36 enum gpiod_flags {
  37         GPIOD_ASIS      = 0,
  38         GPIOD_IN        = GPIOD_FLAGS_BIT_DIR_SET,
  39         GPIOD_OUT_LOW   = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT,
  40         GPIOD_OUT_HIGH  = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
  41                           GPIOD_FLAGS_BIT_DIR_VAL,
  42 };
  43
  44 #ifdef CONFIG_GPIOLIB
  45
  46 /* Return the number of GPIOs associated with a device / function */
  47 int gpiod_count(struct device *dev, const char *con_id);
  48
  49 /* Acquire and dispose GPIOs */
  50 struct gpio_desc *__must_check __gpiod_get(struct device *dev,
  51                                          const char *con_id,
  52                                          enum gpiod_flags flags);
  53 struct gpio_desc *__must_check __gpiod_get_index(struct device *dev,
  54                                                const char *con_id,
  55                                                unsigned int idx,
  56                                                enum gpiod_flags flags);
  57 struct gpio_desc *__must_check __gpiod_get_optional(struct device *dev,
  58                                                   const char *con_id,
  59                                                   enum gpiod_flags flags);
  60 struct gpio_desc *__must_check __gpiod_get_index_optional(struct device *dev,
  61                                                         const char *con_id,
  62                                                         unsigned int index,
  63                                                         enum gpiod_flags flags);
  64 struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
  65                                                 const char *con_id,
  66                                                 enum gpiod_flags flags);
  67 struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
  68                                                         const char *con_id,
  69                                                         enum gpiod_flags flags);
  70 void gpiod_put(struct gpio_desc *desc);
  71 void gpiod_put_array(struct gpio_descs *descs);
  72
  73 struct gpio_desc *__must_check __devm_gpiod_get(struct device *dev,
  74                                               const char *con_id,
  75                                               enum gpiod_flags flags);
  76 struct gpio_desc *__must_check __devm_gpiod_get_index(struct device *dev,
  77                                                     const char *con_id,
  78                                                     unsigned int idx,
  79                                                     enum gpiod_flags flags);
  80 struct gpio_desc *__must_check __devm_gpiod_get_optional(struct device *dev,
  81                                                        const char *con_id,
  82                                                        enum gpiod_flags flags);
  83 struct gpio_desc *__must_check
  84 __devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
  85                               unsigned int index, enum gpiod_flags flags);
  86 struct gpio_descs *__must_check devm_gpiod_get_array(struct device *dev,
  87                                                      const char *con_id,
  88                                                      enum gpiod_flags flags);
  89 struct gpio_descs *__must_check
  90 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
  91                               enum gpiod_flags flags);
  92 void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
  93 void devm_gpiod_put_array(struct device *dev, struct gpio_descs *descs);
  94
  95 int gpiod_get_direction(struct gpio_desc *desc);
  96 int gpiod_direction_input(struct gpio_desc *desc);
  97 int gpiod_direction_output(struct gpio_desc *desc, int value);
  98 int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
  99
 100 /* Value get/set from non-sleeping context */
 101 int gpiod_get_value(const struct gpio_desc *desc);
 102 void gpiod_set_value(struct gpio_desc *desc, int value);
 103 void gpiod_set_array(unsigned int array_size,
 104                      struct gpio_desc **desc_array, int *value_array);
 105 int gpiod_get_raw_value(const struct gpio_desc *desc);
 106 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
 107 void gpiod_set_raw_array(unsigned int array_size,
 108                          struct gpio_desc **desc_array, int *value_array);
 109
 110 /* Value get/set from sleeping context */
 111 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 112 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
 113 void gpiod_set_array_cansleep(unsigned int array_size,
 114                               struct gpio_desc **desc_array,
 115                               int *value_array);
 116 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 117 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
 118 void gpiod_set_raw_array_cansleep(unsigned int array_size,
 119                                   struct gpio_desc **desc_array,
 120                                   int *value_array);
 121
 122 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
 123
 124 int gpiod_is_active_low(const struct gpio_desc *desc);
 125 int gpiod_cansleep(const struct gpio_desc *desc);
 126
 127 int gpiod_to_irq(const struct gpio_desc *desc);
 128
 129 /* Convert between the old gpio_ and new gpiod_ interfaces */
 130 struct gpio_desc *gpio_to_desc(unsigned gpio);
 131 int desc_to_gpio(const struct gpio_desc *desc);
 132
 133 /* Child properties interface */
 134 struct fwnode_handle;
 135
 136 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 137                                          const char *propname);
 138 struct gpio_desc *devm_get_gpiod_from_child(struct device *dev,
 139                                             const char *con_id,
 140                                             struct fwnode_handle *child);
 141 #else /* CONFIG_GPIOLIB */
 142
 143 static inline int gpiod_count(struct device *dev, const char *con_id)
 144 {
 145         return 0;
 146 }
 147
 148 static inline struct gpio_desc *__must_check __gpiod_get(struct device *dev,
 149                                                 const char *con_id,
 150                                                 enum gpiod_flags flags)
 151 {
 152         return ERR_PTR(-ENOSYS);
 153 }
 154 static inline struct gpio_desc *__must_check
 155 __gpiod_get_index(struct device *dev,
 156                   const char *con_id,
 157                   unsigned int idx,
 158                   enum gpiod_flags flags)
 159 {
 160         return ERR_PTR(-ENOSYS);
 161 }
 162
 163 static inline struct gpio_desc *__must_check
 164 __gpiod_get_optional(struct device *dev, const char *con_id,
 165                      enum gpiod_flags flags)
 166 {
 167         return ERR_PTR(-ENOSYS);
 168 }
 169
 170 static inline struct gpio_desc *__must_check
 171 __gpiod_get_index_optional(struct device *dev, const char *con_id,
 172                            unsigned int index, enum gpiod_flags flags)
 173 {
 174         return ERR_PTR(-ENOSYS);
 175 }
 176
 177 static inline struct gpio_descs *__must_check
 178 gpiod_get_array(struct device *dev, const char *con_id,
 179                 enum gpiod_flags flags)
 180 {
 181         return ERR_PTR(-ENOSYS);
 182 }
 183
 184 static inline struct gpio_descs *__must_check
 185 gpiod_get_array_optional(struct device *dev, const char *con_id,
 186                          enum gpiod_flags flags)
 187 {
 188         return ERR_PTR(-ENOSYS);
 189 }
 190
 191 static inline void gpiod_put(struct gpio_desc *desc)
 192 {
 193         might_sleep();
 194
 195         /* GPIO can never have been requested */
 196         WARN_ON(1);
 197 }
 198
 199 static inline void gpiod_put_array(struct gpio_descs *descs)
 200 {
 201         might_sleep();
 202
 203         /* GPIO can never have been requested */
 204         WARN_ON(1);
 205 }
 206
 207 static inline struct gpio_desc *__must_check
 208 __devm_gpiod_get(struct device *dev,
 209                  const char *con_id,
 210                  enum gpiod_flags flags)
 211 {
 212         return ERR_PTR(-ENOSYS);
 213 }
 214 static inline
 215 struct gpio_desc *__must_check
 216 __devm_gpiod_get_index(struct device *dev,
 217                        const char *con_id,
 218                        unsigned int idx,
 219                        enum gpiod_flags flags)
 220 {
 221         return ERR_PTR(-ENOSYS);
 222 }
 223
 224 static inline struct gpio_desc *__must_check
 225 __devm_gpiod_get_optional(struct device *dev, const char *con_id,
 226                           enum gpiod_flags flags)
 227 {
 228         return ERR_PTR(-ENOSYS);
 229 }
 230
 231 static inline struct gpio_desc *__must_check
 232 __devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 233                                 unsigned int index, enum gpiod_flags flags)
 234 {
 235         return ERR_PTR(-ENOSYS);
 236 }
 237
 238 static inline struct gpio_descs *__must_check
 239 devm_gpiod_get_array(struct device *dev, const char *con_id,
 240                      enum gpiod_flags flags)
 241 {
 242         return ERR_PTR(-ENOSYS);
 243 }
 244
 245 static inline struct gpio_descs *__must_check
 246 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
 247                               enum gpiod_flags flags)
 248 {
 249         return ERR_PTR(-ENOSYS);
 250 }
 251
 252 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
 253 {
 254         might_sleep();
 255
 256         /* GPIO can never have been requested */
 257         WARN_ON(1);
 258 }
 259
 260 static inline void devm_gpiod_put_array(struct device *dev,
 261                                         struct gpio_descs *descs)
 262 {
 263         might_sleep();
 264
 265         /* GPIO can never have been requested */
 266         WARN_ON(1);
 267 }
 268
 269
 270 static inline int gpiod_get_direction(const struct gpio_desc *desc)
 271 {
 272         /* GPIO can never have been requested */
 273         WARN_ON(1);
 274         return -ENOSYS;
 275 }
 276 static inline int gpiod_direction_input(struct gpio_desc *desc)
 277 {
 278         /* GPIO can never have been requested */
 279         WARN_ON(1);
 280         return -ENOSYS;
 281 }
 282 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
 283 {
 284         /* GPIO can never have been requested */
 285         WARN_ON(1);
 286         return -ENOSYS;
 287 }
 288 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 289 {
 290         /* GPIO can never have been requested */
 291         WARN_ON(1);
 292         return -ENOSYS;
 293 }
 294
 295
 296 static inline int gpiod_get_value(const struct gpio_desc *desc)
 297 {
 298         /* GPIO can never have been requested */
 299         WARN_ON(1);
 300         return 0;
 301 }
 302 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
 303 {
 304         /* GPIO can never have been requested */
 305         WARN_ON(1);
 306 }
 307 static inline void gpiod_set_array(unsigned int array_size,
 308                                    struct gpio_desc **desc_array,
 309                                    int *value_array)
 310 {
 311         /* GPIO can never have been requested */
 312         WARN_ON(1);
 313 }
 314 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 315 {
 316         /* GPIO can never have been requested */
 317         WARN_ON(1);
 318         return 0;
 319 }
 320 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 321 {
 322         /* GPIO can never have been requested */
 323         WARN_ON(1);
 324 }
 325 static inline void gpiod_set_raw_array(unsigned int array_size,
 326                                        struct gpio_desc **desc_array,
 327                                        int *value_array)
 328 {
 329         /* GPIO can never have been requested */
 330         WARN_ON(1);
 331 }
 332
 333 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 334 {
 335         /* GPIO can never have been requested */
 336         WARN_ON(1);
 337         return 0;
 338 }
 339 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 340 {
 341         /* GPIO can never have been requested */
 342         WARN_ON(1);
 343 }
 344 static inline void gpiod_set_array_cansleep(unsigned int array_size,
 345                                             struct gpio_desc **desc_array,
 346                                             int *value_array)
 347 {
 348         /* GPIO can never have been requested */
 349         WARN_ON(1);
 350 }
 351 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 352 {
 353         /* GPIO can never have been requested */
 354         WARN_ON(1);
 355         return 0;
 356 }
 357 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 358                                                 int value)
 359 {
 360         /* GPIO can never have been requested */
 361         WARN_ON(1);
 362 }
 363 static inline void gpiod_set_raw_array_cansleep(unsigned int array_size,
 364                                                 struct gpio_desc **desc_array,
 365                                                 int *value_array)
 366 {
 367         /* GPIO can never have been requested */
 368         WARN_ON(1);
 369 }
 370
 371 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 372 {
 373         /* GPIO can never have been requested */
 374         WARN_ON(1);
 375         return -ENOSYS;
 376 }
 377
 378 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 379 {
 380         /* GPIO can never have been requested */
 381         WARN_ON(1);
 382         return 0;
 383 }
 384 static inline int gpiod_cansleep(const struct gpio_desc *desc)
 385 {
 386         /* GPIO can never have been requested */
 387         WARN_ON(1);
 388         return 0;
 389 }
 390
 391 static inline int gpiod_to_irq(const struct gpio_desc *desc)
 392 {
 393         /* GPIO can never have been requested */
 394         WARN_ON(1);
 395         return -EINVAL;
 396 }
 397
 398 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 399 {
 400         return ERR_PTR(-EINVAL);
 401 }
 402 static inline int desc_to_gpio(const struct gpio_desc *desc)
 403 {
 404         /* GPIO can never have been requested */
 405         WARN_ON(1);
 406         return -EINVAL;
 407 }
 408
 409 /* Child properties interface */
 410 struct fwnode_handle;
 411
 412 static inline struct gpio_desc *fwnode_get_named_gpiod(
 413         struct fwnode_handle *fwnode, const char *propname)
 414 {
 415         return ERR_PTR(-ENOSYS);
 416 }
 417
 418 static inline struct gpio_desc *devm_get_gpiod_from_child(
 419         struct device *dev, const char *con_id, struct fwnode_handle *child)
 420 {
 421         return ERR_PTR(-ENOSYS);
 422 }
 423
 424 #endif /* CONFIG_GPIOLIB */
 425
 426 /*
 427  * Vararg-hacks! This is done to transition the kernel to always pass
 428  * the options flags argument to the below functions. During a transition
 429  * phase these vararg macros make both old-and-newstyle code compile,
 430  * but when all calls to the elder API are removed, these should go away
 431  * and the __gpiod_get() etc functions above be renamed just gpiod_get()
 432  * etc.
 433  */
 434 #define __gpiod_get(dev, con_id, flags, ...) __gpiod_get(dev, con_id, flags)
 435 #define gpiod_get(varargs...) __gpiod_get(varargs, GPIOD_ASIS)
 436 #define __gpiod_get_index(dev, con_id, index, flags, ...)               \
 437         __gpiod_get_index(dev, con_id, index, flags)
 438 #define gpiod_get_index(varargs...) __gpiod_get_index(varargs, GPIOD_ASIS)
 439 #define __gpiod_get_optional(dev, con_id, flags, ...)                   \
 440         __gpiod_get_optional(dev, con_id, flags)
 441 #define gpiod_get_optional(varargs...) __gpiod_get_optional(varargs, GPIOD_ASIS)
 442 #define __gpiod_get_index_optional(dev, con_id, index, flags, ...)      \
 443         __gpiod_get_index_optional(dev, con_id, index, flags)
 444 #define gpiod_get_index_optional(varargs...)                            \
 445         __gpiod_get_index_optional(varargs, GPIOD_ASIS)
 446 #define __devm_gpiod_get(dev, con_id, flags, ...)                       \
 447         __devm_gpiod_get(dev, con_id, flags)
 448 #define devm_gpiod_get(varargs...) __devm_gpiod_get(varargs, GPIOD_ASIS)
 449 #define __devm_gpiod_get_index(dev, con_id, index, flags, ...)          \
 450         __devm_gpiod_get_index(dev, con_id, index, flags)
 451 #define devm_gpiod_get_index(varargs...)                                \
 452         __devm_gpiod_get_index(varargs, GPIOD_ASIS)
 453 #define __devm_gpiod_get_optional(dev, con_id, flags, ...)              \
 454         __devm_gpiod_get_optional(dev, con_id, flags)
 455 #define devm_gpiod_get_optional(varargs...)                             \
 456         __devm_gpiod_get_optional(varargs, GPIOD_ASIS)
 457 #define __devm_gpiod_get_index_optional(dev, con_id, index, flags, ...) \
 458         __devm_gpiod_get_index_optional(dev, con_id, index, flags)
 459 #define devm_gpiod_get_index_optional(varargs...)                       \
 460         __devm_gpiod_get_index_optional(varargs, GPIOD_ASIS)
 461
 462 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 463
 464 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 465 int gpiod_export_link(struct device *dev, const char *name,
 466                       struct gpio_desc *desc);
 467 int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
 468 void gpiod_unexport(struct gpio_desc *desc);
 469
 470 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 471
 472 static inline int gpiod_export(struct gpio_desc *desc,
 473                                bool direction_may_change)
 474 {
 475         return -ENOSYS;
 476 }
 477
 478 static inline int gpiod_export_link(struct device *dev, const char *name,
 479                                     struct gpio_desc *desc)
 480 {
 481         return -ENOSYS;
 482 }
 483
 484 static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
 485 {
 486         return -ENOSYS;
 487 }
 488
 489 static inline void gpiod_unexport(struct gpio_desc *desc)
 490 {
 491 }
 492
 493 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 494
 495 #endif