include/linux/gpio/consumer.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __LINUX_GPIO_CONSUMER_H
   3 #define __LINUX_GPIO_CONSUMER_H
   4
   5 #include <linux/bug.h>
   6 #include <linux/err.h>
   7 #include <linux/kernel.h>
   8
   9 struct device;
  10
  11 /**
  12  * Opaque descriptor for a GPIO. These are obtained using gpiod_get() and are
  13  * preferable to the old integer-based handles.
  14  *
  15  * Contrary to integers, a pointer to a gpio_desc is guaranteed to be valid
  16  * until the GPIO is released.
  17  */
  18 struct gpio_desc;
  19
  20 /**
  21  * Struct containing an array of descriptors that can be obtained using
  22  * gpiod_get_array().
  23  */
  24 struct gpio_descs {
  25         unsigned int ndescs;
  26         struct gpio_desc *desc[];
  27 };
  28
  29 #define GPIOD_FLAGS_BIT_DIR_SET         BIT(0)
  30 #define GPIOD_FLAGS_BIT_DIR_OUT         BIT(1)
  31 #define GPIOD_FLAGS_BIT_DIR_VAL         BIT(2)
  32 #define GPIOD_FLAGS_BIT_OPEN_DRAIN      BIT(3)
  33
  34 /**
  35  * Optional flags that can be passed to one of gpiod_* to configure direction
  36  * and output value. These values cannot be OR'd.
  37  */
  38 enum gpiod_flags {
  39         GPIOD_ASIS      = 0,
  40         GPIOD_IN        = GPIOD_FLAGS_BIT_DIR_SET,
  41         GPIOD_OUT_LOW   = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT,
  42         GPIOD_OUT_HIGH  = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
  43                           GPIOD_FLAGS_BIT_DIR_VAL,
  44         GPIOD_OUT_LOW_OPEN_DRAIN = GPIOD_FLAGS_BIT_DIR_SET |
  45                           GPIOD_FLAGS_BIT_DIR_OUT | GPIOD_FLAGS_BIT_OPEN_DRAIN,
  46         GPIOD_OUT_HIGH_OPEN_DRAIN = GPIOD_FLAGS_BIT_DIR_SET |
  47                           GPIOD_FLAGS_BIT_DIR_OUT | GPIOD_FLAGS_BIT_DIR_VAL |
  48                           GPIOD_FLAGS_BIT_OPEN_DRAIN,
  49 };
  50
  51 #ifdef CONFIG_GPIOLIB
  52
  53 /* Return the number of GPIOs associated with a device / function */
  54 int gpiod_count(struct device *dev, const char *con_id);
  55
  56 /* Acquire and dispose GPIOs */
  57 struct gpio_desc *__must_check gpiod_get(struct device *dev,
  58                                          const char *con_id,
  59                                          enum gpiod_flags flags);
  60 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
  61                                                const char *con_id,
  62                                                unsigned int idx,
  63                                                enum gpiod_flags flags);
  64 struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
  65                                                   const char *con_id,
  66                                                   enum gpiod_flags flags);
  67 struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
  68                                                         const char *con_id,
  69                                                         unsigned int index,
  70                                                         enum gpiod_flags flags);
  71 struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
  72                                                 const char *con_id,
  73                                                 enum gpiod_flags flags);
  74 struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
  75                                                         const char *con_id,
  76                                                         enum gpiod_flags flags);
  77 void gpiod_put(struct gpio_desc *desc);
  78 void gpiod_put_array(struct gpio_descs *descs);
  79
  80 struct gpio_desc *__must_check devm_gpiod_get(struct device *dev,
  81                                               const char *con_id,
  82                                               enum gpiod_flags flags);
  83 struct gpio_desc *__must_check devm_gpiod_get_index(struct device *dev,
  84                                                     const char *con_id,
  85                                                     unsigned int idx,
  86                                                     enum gpiod_flags flags);
  87 struct gpio_desc *__must_check devm_gpiod_get_optional(struct device *dev,
  88                                                        const char *con_id,
  89                                                        enum gpiod_flags flags);
  90 struct gpio_desc *__must_check
  91 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
  92                               unsigned int index, enum gpiod_flags flags);
  93 struct gpio_descs *__must_check devm_gpiod_get_array(struct device *dev,
  94                                                      const char *con_id,
  95                                                      enum gpiod_flags flags);
  96 struct gpio_descs *__must_check
  97 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
  98                               enum gpiod_flags flags);
  99 void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
 100 void devm_gpiod_put_array(struct device *dev, struct gpio_descs *descs);
 101
 102 int gpiod_get_direction(struct gpio_desc *desc);
 103 int gpiod_direction_input(struct gpio_desc *desc);
 104 int gpiod_direction_output(struct gpio_desc *desc, int value);
 105 int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
 106
 107 /* Value get/set from non-sleeping context */
 108 int gpiod_get_value(const struct gpio_desc *desc);
 109 int gpiod_get_array_value(unsigned int array_size,
 110                           struct gpio_desc **desc_array, int *value_array);
 111 void gpiod_set_value(struct gpio_desc *desc, int value);
 112 void gpiod_set_array_value(unsigned int array_size,
 113                            struct gpio_desc **desc_array, int *value_array);
 114 int gpiod_get_raw_value(const struct gpio_desc *desc);
 115 int gpiod_get_raw_array_value(unsigned int array_size,
 116                               struct gpio_desc **desc_array,
 117                               int *value_array);
 118 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
 119 int gpiod_set_raw_array_value(unsigned int array_size,
 120                                struct gpio_desc **desc_array,
 121                                int *value_array);
 122
 123 /* Value get/set from sleeping context */
 124 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 125 int gpiod_get_array_value_cansleep(unsigned int array_size,
 126                                    struct gpio_desc **desc_array,
 127                                    int *value_array);
 128 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
 129 void gpiod_set_array_value_cansleep(unsigned int array_size,
 130                                     struct gpio_desc **desc_array,
 131                                     int *value_array);
 132 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 133 int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
 134                                        struct gpio_desc **desc_array,
 135                                        int *value_array);
 136 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
 137 int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
 138                                         struct gpio_desc **desc_array,
 139                                         int *value_array);
 140
 141 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
 142 int gpiod_set_transitory(struct gpio_desc *desc, bool transitory);
 143
 144 int gpiod_is_active_low(const struct gpio_desc *desc);
 145 int gpiod_cansleep(const struct gpio_desc *desc);
 146
 147 int gpiod_to_irq(const struct gpio_desc *desc);
 148
 149 /* Convert between the old gpio_ and new gpiod_ interfaces */
 150 struct gpio_desc *gpio_to_desc(unsigned gpio);
 151 int desc_to_gpio(const struct gpio_desc *desc);
 152
 153 /* Child properties interface */
 154 struct device_node;
 155 struct fwnode_handle;
 156
 157 struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
 158                                               struct device_node *node,
 159                                               const char *propname, int index,
 160                                               enum gpiod_flags dflags,
 161                                               const char *label);
 162 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 163                                          const char *propname, int index,
 164                                          enum gpiod_flags dflags,
 165                                          const char *label);
 166 struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
 167                                                 const char *con_id, int index,
 168                                                 struct fwnode_handle *child,
 169                                                 enum gpiod_flags flags,
 170                                                 const char *label);
 171
 172 #else /* CONFIG_GPIOLIB */
 173
 174 static inline int gpiod_count(struct device *dev, const char *con_id)
 175 {
 176         return 0;
 177 }
 178
 179 static inline struct gpio_desc *__must_check gpiod_get(struct device *dev,
 180                                                        const char *con_id,
 181                                                        enum gpiod_flags flags)
 182 {
 183         return ERR_PTR(-ENOSYS);
 184 }
 185 static inline struct gpio_desc *__must_check
 186 gpiod_get_index(struct device *dev,
 187                 const char *con_id,
 188                 unsigned int idx,
 189                 enum gpiod_flags flags)
 190 {
 191         return ERR_PTR(-ENOSYS);
 192 }
 193
 194 static inline struct gpio_desc *__must_check
 195 gpiod_get_optional(struct device *dev, const char *con_id,
 196                    enum gpiod_flags flags)
 197 {
 198         return NULL;
 199 }
 200
 201 static inline struct gpio_desc *__must_check
 202 gpiod_get_index_optional(struct device *dev, const char *con_id,
 203                          unsigned int index, enum gpiod_flags flags)
 204 {
 205         return NULL;
 206 }
 207
 208 static inline struct gpio_descs *__must_check
 209 gpiod_get_array(struct device *dev, const char *con_id,
 210                 enum gpiod_flags flags)
 211 {
 212         return ERR_PTR(-ENOSYS);
 213 }
 214
 215 static inline struct gpio_descs *__must_check
 216 gpiod_get_array_optional(struct device *dev, const char *con_id,
 217                          enum gpiod_flags flags)
 218 {
 219         return NULL;
 220 }
 221
 222 static inline void gpiod_put(struct gpio_desc *desc)
 223 {
 224         might_sleep();
 225
 226         /* GPIO can never have been requested */
 227         WARN_ON(1);
 228 }
 229
 230 static inline void gpiod_put_array(struct gpio_descs *descs)
 231 {
 232         might_sleep();
 233
 234         /* GPIO can never have been requested */
 235         WARN_ON(1);
 236 }
 237
 238 static inline struct gpio_desc *__must_check
 239 devm_gpiod_get(struct device *dev,
 240                  const char *con_id,
 241                  enum gpiod_flags flags)
 242 {
 243         return ERR_PTR(-ENOSYS);
 244 }
 245 static inline
 246 struct gpio_desc *__must_check
 247 devm_gpiod_get_index(struct device *dev,
 248                        const char *con_id,
 249                        unsigned int idx,
 250                        enum gpiod_flags flags)
 251 {
 252         return ERR_PTR(-ENOSYS);
 253 }
 254
 255 static inline struct gpio_desc *__must_check
 256 devm_gpiod_get_optional(struct device *dev, const char *con_id,
 257                           enum gpiod_flags flags)
 258 {
 259         return NULL;
 260 }
 261
 262 static inline struct gpio_desc *__must_check
 263 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 264                                 unsigned int index, enum gpiod_flags flags)
 265 {
 266         return NULL;
 267 }
 268
 269 static inline struct gpio_descs *__must_check
 270 devm_gpiod_get_array(struct device *dev, const char *con_id,
 271                      enum gpiod_flags flags)
 272 {
 273         return ERR_PTR(-ENOSYS);
 274 }
 275
 276 static inline struct gpio_descs *__must_check
 277 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
 278                               enum gpiod_flags flags)
 279 {
 280         return NULL;
 281 }
 282
 283 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
 284 {
 285         might_sleep();
 286
 287         /* GPIO can never have been requested */
 288         WARN_ON(1);
 289 }
 290
 291 static inline void devm_gpiod_put_array(struct device *dev,
 292                                         struct gpio_descs *descs)
 293 {
 294         might_sleep();
 295
 296         /* GPIO can never have been requested */
 297         WARN_ON(1);
 298 }
 299
 300
 301 static inline int gpiod_get_direction(const struct gpio_desc *desc)
 302 {
 303         /* GPIO can never have been requested */
 304         WARN_ON(1);
 305         return -ENOSYS;
 306 }
 307 static inline int gpiod_direction_input(struct gpio_desc *desc)
 308 {
 309         /* GPIO can never have been requested */
 310         WARN_ON(1);
 311         return -ENOSYS;
 312 }
 313 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
 314 {
 315         /* GPIO can never have been requested */
 316         WARN_ON(1);
 317         return -ENOSYS;
 318 }
 319 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 320 {
 321         /* GPIO can never have been requested */
 322         WARN_ON(1);
 323         return -ENOSYS;
 324 }
 325
 326
 327 static inline int gpiod_get_value(const struct gpio_desc *desc)
 328 {
 329         /* GPIO can never have been requested */
 330         WARN_ON(1);
 331         return 0;
 332 }
 333 static inline int gpiod_get_array_value(unsigned int array_size,
 334                                         struct gpio_desc **desc_array,
 335                                         int *value_array)
 336 {
 337         /* GPIO can never have been requested */
 338         WARN_ON(1);
 339         return 0;
 340 }
 341 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
 342 {
 343         /* GPIO can never have been requested */
 344         WARN_ON(1);
 345 }
 346 static inline void gpiod_set_array_value(unsigned int array_size,
 347                                          struct gpio_desc **desc_array,
 348                                          int *value_array)
 349 {
 350         /* GPIO can never have been requested */
 351         WARN_ON(1);
 352 }
 353 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 354 {
 355         /* GPIO can never have been requested */
 356         WARN_ON(1);
 357         return 0;
 358 }
 359 static inline int gpiod_get_raw_array_value(unsigned int array_size,
 360                                             struct gpio_desc **desc_array,
 361                                             int *value_array)
 362 {
 363         /* GPIO can never have been requested */
 364         WARN_ON(1);
 365         return 0;
 366 }
 367 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 368 {
 369         /* GPIO can never have been requested */
 370         WARN_ON(1);
 371 }
 372 static inline int gpiod_set_raw_array_value(unsigned int array_size,
 373                                              struct gpio_desc **desc_array,
 374                                              int *value_array)
 375 {
 376         /* GPIO can never have been requested */
 377         WARN_ON(1);
 378         return 0;
 379 }
 380
 381 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 382 {
 383         /* GPIO can never have been requested */
 384         WARN_ON(1);
 385         return 0;
 386 }
 387 static inline int gpiod_get_array_value_cansleep(unsigned int array_size,
 388                                      struct gpio_desc **desc_array,
 389                                      int *value_array)
 390 {
 391         /* GPIO can never have been requested */
 392         WARN_ON(1);
 393         return 0;
 394 }
 395 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 396 {
 397         /* GPIO can never have been requested */
 398         WARN_ON(1);
 399 }
 400 static inline void gpiod_set_array_value_cansleep(unsigned int array_size,
 401                                             struct gpio_desc **desc_array,
 402                                             int *value_array)
 403 {
 404         /* GPIO can never have been requested */
 405         WARN_ON(1);
 406 }
 407 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 408 {
 409         /* GPIO can never have been requested */
 410         WARN_ON(1);
 411         return 0;
 412 }
 413 static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
 414                                                struct gpio_desc **desc_array,
 415                                                int *value_array)
 416 {
 417         /* GPIO can never have been requested */
 418         WARN_ON(1);
 419         return 0;
 420 }
 421 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 422                                                 int value)
 423 {
 424         /* GPIO can never have been requested */
 425         WARN_ON(1);
 426 }
 427 static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
 428                                                 struct gpio_desc **desc_array,
 429                                                 int *value_array)
 430 {
 431         /* GPIO can never have been requested */
 432         WARN_ON(1);
 433         return 0;
 434 }
 435
 436 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 437 {
 438         /* GPIO can never have been requested */
 439         WARN_ON(1);
 440         return -ENOSYS;
 441 }
 442
 443 static inline int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
 444 {
 445         /* GPIO can never have been requested */
 446         WARN_ON(1);
 447         return -ENOSYS;
 448 }
 449
 450 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 451 {
 452         /* GPIO can never have been requested */
 453         WARN_ON(1);
 454         return 0;
 455 }
 456 static inline int gpiod_cansleep(const struct gpio_desc *desc)
 457 {
 458         /* GPIO can never have been requested */
 459         WARN_ON(1);
 460         return 0;
 461 }
 462
 463 static inline int gpiod_to_irq(const struct gpio_desc *desc)
 464 {
 465         /* GPIO can never have been requested */
 466         WARN_ON(1);
 467         return -EINVAL;
 468 }
 469
 470 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 471 {
 472         return ERR_PTR(-EINVAL);
 473 }
 474
 475 static inline int desc_to_gpio(const struct gpio_desc *desc)
 476 {
 477         /* GPIO can never have been requested */
 478         WARN_ON(1);
 479         return -EINVAL;
 480 }
 481
 482 /* Child properties interface */
 483 struct device_node;
 484 struct fwnode_handle;
 485
 486 static inline
 487 struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
 488                                               struct device_node *node,
 489                                               const char *propname, int index,
 490                                               enum gpiod_flags dflags,
 491                                               const char *label)
 492 {
 493         return ERR_PTR(-ENOSYS);
 494 }
 495
 496 static inline
 497 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 498                                          const char *propname, int index,
 499                                          enum gpiod_flags dflags,
 500                                          const char *label)
 501 {
 502         return ERR_PTR(-ENOSYS);
 503 }
 504
 505 static inline
 506 struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
 507                                                 const char *con_id, int index,
 508                                                 struct fwnode_handle *child,
 509                                                 enum gpiod_flags flags,
 510                                                 const char *label)
 511 {
 512         return ERR_PTR(-ENOSYS);
 513 }
 514
 515 #endif /* CONFIG_GPIOLIB */
 516
 517 static inline
 518 struct gpio_desc *devm_fwnode_get_gpiod_from_child(struct device *dev,
 519                                                    const char *con_id,
 520                                                    struct fwnode_handle *child,
 521                                                    enum gpiod_flags flags,
 522                                                    const char *label)
 523 {
 524         return devm_fwnode_get_index_gpiod_from_child(dev, con_id, 0, child,
 525                                                       flags, label);
 526 }
 527
 528 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 529
 530 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 531 int gpiod_export_link(struct device *dev, const char *name,
 532                       struct gpio_desc *desc);
 533 void gpiod_unexport(struct gpio_desc *desc);
 534
 535 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 536
 537 static inline int gpiod_export(struct gpio_desc *desc,
 538                                bool direction_may_change)
 539 {
 540         return -ENOSYS;
 541 }
 542
 543 static inline int gpiod_export_link(struct device *dev, const char *name,
 544                                     struct gpio_desc *desc)
 545 {
 546         return -ENOSYS;
 547 }
 548
 549 static inline void gpiod_unexport(struct gpio_desc *desc)
 550 {
 551 }
 552
 553 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 554
 555 #endif