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 void 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 void 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
 143 int gpiod_is_active_low(const struct gpio_desc *desc);
 144 int gpiod_cansleep(const struct gpio_desc *desc);
 145
 146 int gpiod_to_irq(const struct gpio_desc *desc);
 147
 148 /* Convert between the old gpio_ and new gpiod_ interfaces */
 149 struct gpio_desc *gpio_to_desc(unsigned gpio);
 150 int desc_to_gpio(const struct gpio_desc *desc);
 151
 152 /* Child properties interface */
 153 struct fwnode_handle;
 154
 155 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 156                                          const char *propname, int index,
 157                                          enum gpiod_flags dflags,
 158                                          const char *label);
 159 struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
 160                                                 const char *con_id, int index,
 161                                                 struct fwnode_handle *child,
 162                                                 enum gpiod_flags flags,
 163                                                 const char *label);
 164
 165 #else /* CONFIG_GPIOLIB */
 166
 167 static inline int gpiod_count(struct device *dev, const char *con_id)
 168 {
 169         return 0;
 170 }
 171
 172 static inline struct gpio_desc *__must_check gpiod_get(struct device *dev,
 173                                                        const char *con_id,
 174                                                        enum gpiod_flags flags)
 175 {
 176         return ERR_PTR(-ENOSYS);
 177 }
 178 static inline struct gpio_desc *__must_check
 179 gpiod_get_index(struct device *dev,
 180                 const char *con_id,
 181                 unsigned int idx,
 182                 enum gpiod_flags flags)
 183 {
 184         return ERR_PTR(-ENOSYS);
 185 }
 186
 187 static inline struct gpio_desc *__must_check
 188 gpiod_get_optional(struct device *dev, const char *con_id,
 189                    enum gpiod_flags flags)
 190 {
 191         return NULL;
 192 }
 193
 194 static inline struct gpio_desc *__must_check
 195 gpiod_get_index_optional(struct device *dev, const char *con_id,
 196                          unsigned int index, enum gpiod_flags flags)
 197 {
 198         return NULL;
 199 }
 200
 201 static inline struct gpio_descs *__must_check
 202 gpiod_get_array(struct device *dev, const char *con_id,
 203                 enum gpiod_flags flags)
 204 {
 205         return ERR_PTR(-ENOSYS);
 206 }
 207
 208 static inline struct gpio_descs *__must_check
 209 gpiod_get_array_optional(struct device *dev, const char *con_id,
 210                          enum gpiod_flags flags)
 211 {
 212         return NULL;
 213 }
 214
 215 static inline void gpiod_put(struct gpio_desc *desc)
 216 {
 217         might_sleep();
 218
 219         /* GPIO can never have been requested */
 220         WARN_ON(1);
 221 }
 222
 223 static inline void gpiod_put_array(struct gpio_descs *descs)
 224 {
 225         might_sleep();
 226
 227         /* GPIO can never have been requested */
 228         WARN_ON(1);
 229 }
 230
 231 static inline struct gpio_desc *__must_check
 232 devm_gpiod_get(struct device *dev,
 233                  const char *con_id,
 234                  enum gpiod_flags flags)
 235 {
 236         return ERR_PTR(-ENOSYS);
 237 }
 238 static inline
 239 struct gpio_desc *__must_check
 240 devm_gpiod_get_index(struct device *dev,
 241                        const char *con_id,
 242                        unsigned int idx,
 243                        enum gpiod_flags flags)
 244 {
 245         return ERR_PTR(-ENOSYS);
 246 }
 247
 248 static inline struct gpio_desc *__must_check
 249 devm_gpiod_get_optional(struct device *dev, const char *con_id,
 250                           enum gpiod_flags flags)
 251 {
 252         return NULL;
 253 }
 254
 255 static inline struct gpio_desc *__must_check
 256 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 257                                 unsigned int index, enum gpiod_flags flags)
 258 {
 259         return NULL;
 260 }
 261
 262 static inline struct gpio_descs *__must_check
 263 devm_gpiod_get_array(struct device *dev, const char *con_id,
 264                      enum gpiod_flags flags)
 265 {
 266         return ERR_PTR(-ENOSYS);
 267 }
 268
 269 static inline struct gpio_descs *__must_check
 270 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
 271                               enum gpiod_flags flags)
 272 {
 273         return NULL;
 274 }
 275
 276 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
 277 {
 278         might_sleep();
 279
 280         /* GPIO can never have been requested */
 281         WARN_ON(1);
 282 }
 283
 284 static inline void devm_gpiod_put_array(struct device *dev,
 285                                         struct gpio_descs *descs)
 286 {
 287         might_sleep();
 288
 289         /* GPIO can never have been requested */
 290         WARN_ON(1);
 291 }
 292
 293
 294 static inline int gpiod_get_direction(const struct gpio_desc *desc)
 295 {
 296         /* GPIO can never have been requested */
 297         WARN_ON(1);
 298         return -ENOSYS;
 299 }
 300 static inline int gpiod_direction_input(struct gpio_desc *desc)
 301 {
 302         /* GPIO can never have been requested */
 303         WARN_ON(1);
 304         return -ENOSYS;
 305 }
 306 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
 307 {
 308         /* GPIO can never have been requested */
 309         WARN_ON(1);
 310         return -ENOSYS;
 311 }
 312 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 313 {
 314         /* GPIO can never have been requested */
 315         WARN_ON(1);
 316         return -ENOSYS;
 317 }
 318
 319
 320 static inline int gpiod_get_value(const struct gpio_desc *desc)
 321 {
 322         /* GPIO can never have been requested */
 323         WARN_ON(1);
 324         return 0;
 325 }
 326 static inline int gpiod_get_array_value(unsigned int array_size,
 327                                         struct gpio_desc **desc_array,
 328                                         int *value_array)
 329 {
 330         /* GPIO can never have been requested */
 331         WARN_ON(1);
 332         return 0;
 333 }
 334 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
 335 {
 336         /* GPIO can never have been requested */
 337         WARN_ON(1);
 338 }
 339 static inline void gpiod_set_array_value(unsigned int array_size,
 340                                          struct gpio_desc **desc_array,
 341                                          int *value_array)
 342 {
 343         /* GPIO can never have been requested */
 344         WARN_ON(1);
 345 }
 346 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 347 {
 348         /* GPIO can never have been requested */
 349         WARN_ON(1);
 350         return 0;
 351 }
 352 static inline int gpiod_get_raw_array_value(unsigned int array_size,
 353                                             struct gpio_desc **desc_array,
 354                                             int *value_array)
 355 {
 356         /* GPIO can never have been requested */
 357         WARN_ON(1);
 358         return 0;
 359 }
 360 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 361 {
 362         /* GPIO can never have been requested */
 363         WARN_ON(1);
 364 }
 365 static inline void gpiod_set_raw_array_value(unsigned int array_size,
 366                                              struct gpio_desc **desc_array,
 367                                              int *value_array)
 368 {
 369         /* GPIO can never have been requested */
 370         WARN_ON(1);
 371 }
 372
 373 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 374 {
 375         /* GPIO can never have been requested */
 376         WARN_ON(1);
 377         return 0;
 378 }
 379 static inline int gpiod_get_array_value_cansleep(unsigned int array_size,
 380                                      struct gpio_desc **desc_array,
 381                                      int *value_array)
 382 {
 383         /* GPIO can never have been requested */
 384         WARN_ON(1);
 385         return 0;
 386 }
 387 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 388 {
 389         /* GPIO can never have been requested */
 390         WARN_ON(1);
 391 }
 392 static inline void gpiod_set_array_value_cansleep(unsigned int array_size,
 393                                             struct gpio_desc **desc_array,
 394                                             int *value_array)
 395 {
 396         /* GPIO can never have been requested */
 397         WARN_ON(1);
 398 }
 399 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 400 {
 401         /* GPIO can never have been requested */
 402         WARN_ON(1);
 403         return 0;
 404 }
 405 static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
 406                                                struct gpio_desc **desc_array,
 407                                                int *value_array)
 408 {
 409         /* GPIO can never have been requested */
 410         WARN_ON(1);
 411         return 0;
 412 }
 413 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 414                                                 int value)
 415 {
 416         /* GPIO can never have been requested */
 417         WARN_ON(1);
 418 }
 419 static inline void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
 420                                                 struct gpio_desc **desc_array,
 421                                                 int *value_array)
 422 {
 423         /* GPIO can never have been requested */
 424         WARN_ON(1);
 425 }
 426
 427 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 428 {
 429         /* GPIO can never have been requested */
 430         WARN_ON(1);
 431         return -ENOSYS;
 432 }
 433
 434 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 435 {
 436         /* GPIO can never have been requested */
 437         WARN_ON(1);
 438         return 0;
 439 }
 440 static inline int gpiod_cansleep(const struct gpio_desc *desc)
 441 {
 442         /* GPIO can never have been requested */
 443         WARN_ON(1);
 444         return 0;
 445 }
 446
 447 static inline int gpiod_to_irq(const struct gpio_desc *desc)
 448 {
 449         /* GPIO can never have been requested */
 450         WARN_ON(1);
 451         return -EINVAL;
 452 }
 453
 454 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 455 {
 456         return ERR_PTR(-EINVAL);
 457 }
 458
 459 static inline int desc_to_gpio(const struct gpio_desc *desc)
 460 {
 461         /* GPIO can never have been requested */
 462         WARN_ON(1);
 463         return -EINVAL;
 464 }
 465
 466 /* Child properties interface */
 467 struct fwnode_handle;
 468
 469 static inline
 470 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 471                                          const char *propname, int index,
 472                                          enum gpiod_flags dflags,
 473                                          const char *label)
 474 {
 475         return ERR_PTR(-ENOSYS);
 476 }
 477
 478 static inline
 479 struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
 480                                                 const char *con_id, int index,
 481                                                 struct fwnode_handle *child,
 482                                                 enum gpiod_flags flags,
 483                                                 const char *label)
 484 {
 485         return ERR_PTR(-ENOSYS);
 486 }
 487
 488 #endif /* CONFIG_GPIOLIB */
 489
 490 static inline
 491 struct gpio_desc *devm_fwnode_get_gpiod_from_child(struct device *dev,
 492                                                    const char *con_id,
 493                                                    struct fwnode_handle *child,
 494                                                    enum gpiod_flags flags,
 495                                                    const char *label)
 496 {
 497         return devm_fwnode_get_index_gpiod_from_child(dev, con_id, 0, child,
 498                                                       flags, label);
 499 }
 500
 501 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 502
 503 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 504 int gpiod_export_link(struct device *dev, const char *name,
 505                       struct gpio_desc *desc);
 506 void gpiod_unexport(struct gpio_desc *desc);
 507
 508 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 509
 510 static inline int gpiod_export(struct gpio_desc *desc,
 511                                bool direction_may_change)
 512 {
 513         return -ENOSYS;
 514 }
 515
 516 static inline int gpiod_export_link(struct device *dev, const char *name,
 517                                     struct gpio_desc *desc)
 518 {
 519         return -ENOSYS;
 520 }
 521
 522 static inline void gpiod_unexport(struct gpio_desc *desc)
 523 {
 524 }
 525
 526 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 527
 528 #endif