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/bits.h>
   6 #include <linux/bug.h>
   7 #include <linux/compiler_types.h>
   8 #include <linux/err.h>
   9
  10 struct device;
  11
  12 /**
  13  * Opaque descriptor for a GPIO. These are obtained using gpiod_get() and are
  14  * preferable to the old integer-based handles.
  15  *
  16  * Contrary to integers, a pointer to a gpio_desc is guaranteed to be valid
  17  * until the GPIO is released.
  18  */
  19 struct gpio_desc;
  20
  21 /**
  22  * Opaque descriptor for a structure of GPIO array attributes.  This structure
  23  * is attached to struct gpiod_descs obtained from gpiod_get_array() and can be
  24  * passed back to get/set array functions in order to activate fast processing
  25  * path if applicable.
  26  */
  27 struct gpio_array;
  28
  29 /**
  30  * Struct containing an array of descriptors that can be obtained using
  31  * gpiod_get_array().
  32  */
  33 struct gpio_descs {
  34         struct gpio_array *info;
  35         unsigned int ndescs;
  36         struct gpio_desc *desc[];
  37 };
  38
  39 #define GPIOD_FLAGS_BIT_DIR_SET         BIT(0)
  40 #define GPIOD_FLAGS_BIT_DIR_OUT         BIT(1)
  41 #define GPIOD_FLAGS_BIT_DIR_VAL         BIT(2)
  42 #define GPIOD_FLAGS_BIT_OPEN_DRAIN      BIT(3)
  43 #define GPIOD_FLAGS_BIT_NONEXCLUSIVE    BIT(4)
  44
  45 /**
  46  * Optional flags that can be passed to one of gpiod_* to configure direction
  47  * and output value. These values cannot be OR'd.
  48  */
  49 enum gpiod_flags {
  50         GPIOD_ASIS      = 0,
  51         GPIOD_IN        = GPIOD_FLAGS_BIT_DIR_SET,
  52         GPIOD_OUT_LOW   = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT,
  53         GPIOD_OUT_HIGH  = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
  54                           GPIOD_FLAGS_BIT_DIR_VAL,
  55         GPIOD_OUT_LOW_OPEN_DRAIN = GPIOD_OUT_LOW | GPIOD_FLAGS_BIT_OPEN_DRAIN,
  56         GPIOD_OUT_HIGH_OPEN_DRAIN = GPIOD_OUT_HIGH | GPIOD_FLAGS_BIT_OPEN_DRAIN,
  57 };
  58
  59 #ifdef CONFIG_GPIOLIB
  60
  61 /* Return the number of GPIOs associated with a device / function */
  62 int gpiod_count(struct device *dev, const char *con_id);
  63
  64 /* Acquire and dispose GPIOs */
  65 struct gpio_desc *__must_check gpiod_get(struct device *dev,
  66                                          const char *con_id,
  67                                          enum gpiod_flags flags);
  68 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
  69                                                const char *con_id,
  70                                                unsigned int idx,
  71                                                enum gpiod_flags flags);
  72 struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
  73                                                   const char *con_id,
  74                                                   enum gpiod_flags flags);
  75 struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
  76                                                         const char *con_id,
  77                                                         unsigned int index,
  78                                                         enum gpiod_flags flags);
  79 struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
  80                                                 const char *con_id,
  81                                                 enum gpiod_flags flags);
  82 struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
  83                                                         const char *con_id,
  84                                                         enum gpiod_flags flags);
  85 void gpiod_put(struct gpio_desc *desc);
  86 void gpiod_put_array(struct gpio_descs *descs);
  87
  88 struct gpio_desc *__must_check devm_gpiod_get(struct device *dev,
  89                                               const char *con_id,
  90                                               enum gpiod_flags flags);
  91 struct gpio_desc *__must_check devm_gpiod_get_index(struct device *dev,
  92                                                     const char *con_id,
  93                                                     unsigned int idx,
  94                                                     enum gpiod_flags flags);
  95 struct gpio_desc *__must_check devm_gpiod_get_optional(struct device *dev,
  96                                                        const char *con_id,
  97                                                        enum gpiod_flags flags);
  98 struct gpio_desc *__must_check
  99 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 100                               unsigned int index, enum gpiod_flags flags);
 101 struct gpio_descs *__must_check devm_gpiod_get_array(struct device *dev,
 102                                                      const char *con_id,
 103                                                      enum gpiod_flags flags);
 104 struct gpio_descs *__must_check
 105 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
 106                               enum gpiod_flags flags);
 107 void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
 108 void devm_gpiod_unhinge(struct device *dev, struct gpio_desc *desc);
 109 void devm_gpiod_put_array(struct device *dev, struct gpio_descs *descs);
 110
 111 int gpiod_get_direction(struct gpio_desc *desc);
 112 int gpiod_direction_input(struct gpio_desc *desc);
 113 int gpiod_direction_output(struct gpio_desc *desc, int value);
 114 int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
 115
 116 /* Value get/set from non-sleeping context */
 117 int gpiod_get_value(const struct gpio_desc *desc);
 118 int gpiod_get_array_value(unsigned int array_size,
 119                           struct gpio_desc **desc_array,
 120                           struct gpio_array *array_info,
 121                           unsigned long *value_bitmap);
 122 void gpiod_set_value(struct gpio_desc *desc, int value);
 123 int gpiod_set_array_value(unsigned int array_size,
 124                           struct gpio_desc **desc_array,
 125                           struct gpio_array *array_info,
 126                           unsigned long *value_bitmap);
 127 int gpiod_get_raw_value(const struct gpio_desc *desc);
 128 int gpiod_get_raw_array_value(unsigned int array_size,
 129                               struct gpio_desc **desc_array,
 130                               struct gpio_array *array_info,
 131                               unsigned long *value_bitmap);
 132 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
 133 int gpiod_set_raw_array_value(unsigned int array_size,
 134                               struct gpio_desc **desc_array,
 135                               struct gpio_array *array_info,
 136                               unsigned long *value_bitmap);
 137
 138 /* Value get/set from sleeping context */
 139 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 140 int gpiod_get_array_value_cansleep(unsigned int array_size,
 141                                    struct gpio_desc **desc_array,
 142                                    struct gpio_array *array_info,
 143                                    unsigned long *value_bitmap);
 144 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
 145 int gpiod_set_array_value_cansleep(unsigned int array_size,
 146                                    struct gpio_desc **desc_array,
 147                                    struct gpio_array *array_info,
 148                                    unsigned long *value_bitmap);
 149 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 150 int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
 151                                        struct gpio_desc **desc_array,
 152                                        struct gpio_array *array_info,
 153                                        unsigned long *value_bitmap);
 154 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
 155 int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
 156                                        struct gpio_desc **desc_array,
 157                                        struct gpio_array *array_info,
 158                                        unsigned long *value_bitmap);
 159
 160 int gpiod_set_config(struct gpio_desc *desc, unsigned long config);
 161 int gpiod_set_debounce(struct gpio_desc *desc, unsigned int debounce);
 162 int gpiod_set_transitory(struct gpio_desc *desc, bool transitory);
 163 void gpiod_toggle_active_low(struct gpio_desc *desc);
 164
 165 int gpiod_is_active_low(const struct gpio_desc *desc);
 166 int gpiod_cansleep(const struct gpio_desc *desc);
 167
 168 int gpiod_to_irq(const struct gpio_desc *desc);
 169 int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name);
 170
 171 /* Convert between the old gpio_ and new gpiod_ interfaces */
 172 struct gpio_desc *gpio_to_desc(unsigned gpio);
 173 int desc_to_gpio(const struct gpio_desc *desc);
 174
 175 /* Child properties interface */
 176 struct fwnode_handle;
 177
 178 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 179                                          const char *propname, int index,
 180                                          enum gpiod_flags dflags,
 181                                          const char *label);
 182 struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
 183                                          const char *con_id, int index,
 184                                          enum gpiod_flags flags,
 185                                          const char *label);
 186 struct gpio_desc *devm_fwnode_gpiod_get_index(struct device *dev,
 187                                               struct fwnode_handle *child,
 188                                               const char *con_id, int index,
 189                                               enum gpiod_flags flags,
 190                                               const char *label);
 191
 192 #else /* CONFIG_GPIOLIB */
 193
 194 #include <linux/kernel.h>
 195
 196 static inline int gpiod_count(struct device *dev, const char *con_id)
 197 {
 198         return 0;
 199 }
 200
 201 static inline struct gpio_desc *__must_check gpiod_get(struct device *dev,
 202                                                        const char *con_id,
 203                                                        enum gpiod_flags flags)
 204 {
 205         return ERR_PTR(-ENOSYS);
 206 }
 207 static inline struct gpio_desc *__must_check
 208 gpiod_get_index(struct device *dev,
 209                 const char *con_id,
 210                 unsigned int idx,
 211                 enum gpiod_flags flags)
 212 {
 213         return ERR_PTR(-ENOSYS);
 214 }
 215
 216 static inline struct gpio_desc *__must_check
 217 gpiod_get_optional(struct device *dev, const char *con_id,
 218                    enum gpiod_flags flags)
 219 {
 220         return NULL;
 221 }
 222
 223 static inline struct gpio_desc *__must_check
 224 gpiod_get_index_optional(struct device *dev, const char *con_id,
 225                          unsigned int index, enum gpiod_flags flags)
 226 {
 227         return NULL;
 228 }
 229
 230 static inline struct gpio_descs *__must_check
 231 gpiod_get_array(struct device *dev, const char *con_id,
 232                 enum gpiod_flags flags)
 233 {
 234         return ERR_PTR(-ENOSYS);
 235 }
 236
 237 static inline struct gpio_descs *__must_check
 238 gpiod_get_array_optional(struct device *dev, const char *con_id,
 239                          enum gpiod_flags flags)
 240 {
 241         return NULL;
 242 }
 243
 244 static inline void gpiod_put(struct gpio_desc *desc)
 245 {
 246         might_sleep();
 247
 248         /* GPIO can never have been requested */
 249         WARN_ON(desc);
 250 }
 251
 252 static inline void devm_gpiod_unhinge(struct device *dev,
 253                                       struct gpio_desc *desc)
 254 {
 255         might_sleep();
 256
 257         /* GPIO can never have been requested */
 258         WARN_ON(desc);
 259 }
 260
 261 static inline void gpiod_put_array(struct gpio_descs *descs)
 262 {
 263         might_sleep();
 264
 265         /* GPIO can never have been requested */
 266         WARN_ON(descs);
 267 }
 268
 269 static inline struct gpio_desc *__must_check
 270 devm_gpiod_get(struct device *dev,
 271                  const char *con_id,
 272                  enum gpiod_flags flags)
 273 {
 274         return ERR_PTR(-ENOSYS);
 275 }
 276 static inline
 277 struct gpio_desc *__must_check
 278 devm_gpiod_get_index(struct device *dev,
 279                        const char *con_id,
 280                        unsigned int idx,
 281                        enum gpiod_flags flags)
 282 {
 283         return ERR_PTR(-ENOSYS);
 284 }
 285
 286 static inline struct gpio_desc *__must_check
 287 devm_gpiod_get_optional(struct device *dev, const char *con_id,
 288                           enum gpiod_flags flags)
 289 {
 290         return NULL;
 291 }
 292
 293 static inline struct gpio_desc *__must_check
 294 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 295                                 unsigned int index, enum gpiod_flags flags)
 296 {
 297         return NULL;
 298 }
 299
 300 static inline struct gpio_descs *__must_check
 301 devm_gpiod_get_array(struct device *dev, const char *con_id,
 302                      enum gpiod_flags flags)
 303 {
 304         return ERR_PTR(-ENOSYS);
 305 }
 306
 307 static inline struct gpio_descs *__must_check
 308 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
 309                               enum gpiod_flags flags)
 310 {
 311         return NULL;
 312 }
 313
 314 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
 315 {
 316         might_sleep();
 317
 318         /* GPIO can never have been requested */
 319         WARN_ON(desc);
 320 }
 321
 322 static inline void devm_gpiod_put_array(struct device *dev,
 323                                         struct gpio_descs *descs)
 324 {
 325         might_sleep();
 326
 327         /* GPIO can never have been requested */
 328         WARN_ON(descs);
 329 }
 330
 331
 332 static inline int gpiod_get_direction(const struct gpio_desc *desc)
 333 {
 334         /* GPIO can never have been requested */
 335         WARN_ON(desc);
 336         return -ENOSYS;
 337 }
 338 static inline int gpiod_direction_input(struct gpio_desc *desc)
 339 {
 340         /* GPIO can never have been requested */
 341         WARN_ON(desc);
 342         return -ENOSYS;
 343 }
 344 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
 345 {
 346         /* GPIO can never have been requested */
 347         WARN_ON(desc);
 348         return -ENOSYS;
 349 }
 350 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 351 {
 352         /* GPIO can never have been requested */
 353         WARN_ON(desc);
 354         return -ENOSYS;
 355 }
 356
 357
 358 static inline int gpiod_get_value(const struct gpio_desc *desc)
 359 {
 360         /* GPIO can never have been requested */
 361         WARN_ON(desc);
 362         return 0;
 363 }
 364 static inline int gpiod_get_array_value(unsigned int array_size,
 365                                         struct gpio_desc **desc_array,
 366                                         struct gpio_array *array_info,
 367                                         unsigned long *value_bitmap)
 368 {
 369         /* GPIO can never have been requested */
 370         WARN_ON(desc_array);
 371         return 0;
 372 }
 373 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
 374 {
 375         /* GPIO can never have been requested */
 376         WARN_ON(desc);
 377 }
 378 static inline int gpiod_set_array_value(unsigned int array_size,
 379                                         struct gpio_desc **desc_array,
 380                                         struct gpio_array *array_info,
 381                                         unsigned long *value_bitmap)
 382 {
 383         /* GPIO can never have been requested */
 384         WARN_ON(desc_array);
 385         return 0;
 386 }
 387 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 388 {
 389         /* GPIO can never have been requested */
 390         WARN_ON(desc);
 391         return 0;
 392 }
 393 static inline int gpiod_get_raw_array_value(unsigned int array_size,
 394                                             struct gpio_desc **desc_array,
 395                                             struct gpio_array *array_info,
 396                                             unsigned long *value_bitmap)
 397 {
 398         /* GPIO can never have been requested */
 399         WARN_ON(desc_array);
 400         return 0;
 401 }
 402 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 403 {
 404         /* GPIO can never have been requested */
 405         WARN_ON(desc);
 406 }
 407 static inline int gpiod_set_raw_array_value(unsigned int array_size,
 408                                             struct gpio_desc **desc_array,
 409                                             struct gpio_array *array_info,
 410                                             unsigned long *value_bitmap)
 411 {
 412         /* GPIO can never have been requested */
 413         WARN_ON(desc_array);
 414         return 0;
 415 }
 416
 417 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 418 {
 419         /* GPIO can never have been requested */
 420         WARN_ON(desc);
 421         return 0;
 422 }
 423 static inline int gpiod_get_array_value_cansleep(unsigned int array_size,
 424                                      struct gpio_desc **desc_array,
 425                                      struct gpio_array *array_info,
 426                                      unsigned long *value_bitmap)
 427 {
 428         /* GPIO can never have been requested */
 429         WARN_ON(desc_array);
 430         return 0;
 431 }
 432 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 433 {
 434         /* GPIO can never have been requested */
 435         WARN_ON(desc);
 436 }
 437 static inline int gpiod_set_array_value_cansleep(unsigned int array_size,
 438                                             struct gpio_desc **desc_array,
 439                                             struct gpio_array *array_info,
 440                                             unsigned long *value_bitmap)
 441 {
 442         /* GPIO can never have been requested */
 443         WARN_ON(desc_array);
 444         return 0;
 445 }
 446 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 447 {
 448         /* GPIO can never have been requested */
 449         WARN_ON(desc);
 450         return 0;
 451 }
 452 static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
 453                                                struct gpio_desc **desc_array,
 454                                                struct gpio_array *array_info,
 455                                                unsigned long *value_bitmap)
 456 {
 457         /* GPIO can never have been requested */
 458         WARN_ON(desc_array);
 459         return 0;
 460 }
 461 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 462                                                 int value)
 463 {
 464         /* GPIO can never have been requested */
 465         WARN_ON(desc);
 466 }
 467 static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
 468                                                 struct gpio_desc **desc_array,
 469                                                 struct gpio_array *array_info,
 470                                                 unsigned long *value_bitmap)
 471 {
 472         /* GPIO can never have been requested */
 473         WARN_ON(desc_array);
 474         return 0;
 475 }
 476
 477 static inline int gpiod_set_config(struct gpio_desc *desc, unsigned long config)
 478 {
 479         /* GPIO can never have been requested */
 480         WARN_ON(desc);
 481         return -ENOSYS;
 482 }
 483
 484 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned int debounce)
 485 {
 486         /* GPIO can never have been requested */
 487         WARN_ON(desc);
 488         return -ENOSYS;
 489 }
 490
 491 static inline int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
 492 {
 493         /* GPIO can never have been requested */
 494         WARN_ON(desc);
 495         return -ENOSYS;
 496 }
 497
 498 static inline void gpiod_toggle_active_low(struct gpio_desc *desc)
 499 {
 500         /* GPIO can never have been requested */
 501         WARN_ON(desc);
 502 }
 503
 504 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 505 {
 506         /* GPIO can never have been requested */
 507         WARN_ON(desc);
 508         return 0;
 509 }
 510 static inline int gpiod_cansleep(const struct gpio_desc *desc)
 511 {
 512         /* GPIO can never have been requested */
 513         WARN_ON(desc);
 514         return 0;
 515 }
 516
 517 static inline int gpiod_to_irq(const struct gpio_desc *desc)
 518 {
 519         /* GPIO can never have been requested */
 520         WARN_ON(desc);
 521         return -EINVAL;
 522 }
 523
 524 static inline int gpiod_set_consumer_name(struct gpio_desc *desc,
 525                                           const char *name)
 526 {
 527         /* GPIO can never have been requested */
 528         WARN_ON(desc);
 529         return -EINVAL;
 530 }
 531
 532 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 533 {
 534         return NULL;
 535 }
 536
 537 static inline int desc_to_gpio(const struct gpio_desc *desc)
 538 {
 539         /* GPIO can never have been requested */
 540         WARN_ON(desc);
 541         return -EINVAL;
 542 }
 543
 544 /* Child properties interface */
 545 struct fwnode_handle;
 546
 547 static inline
 548 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 549                                          const char *propname, int index,
 550                                          enum gpiod_flags dflags,
 551                                          const char *label)
 552 {
 553         return ERR_PTR(-ENOSYS);
 554 }
 555
 556 static inline
 557 struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
 558                                          const char *con_id, int index,
 559                                          enum gpiod_flags flags,
 560                                          const char *label)
 561 {
 562         return ERR_PTR(-ENOSYS);
 563 }
 564
 565 static inline
 566 struct gpio_desc *devm_fwnode_gpiod_get_index(struct device *dev,
 567                                               struct fwnode_handle *fwnode,
 568                                               const char *con_id, int index,
 569                                               enum gpiod_flags flags,
 570                                               const char *label)
 571 {
 572         return ERR_PTR(-ENOSYS);
 573 }
 574
 575 #endif /* CONFIG_GPIOLIB */
 576
 577 static inline
 578 struct gpio_desc *devm_fwnode_gpiod_get(struct device *dev,
 579                                         struct fwnode_handle *fwnode,
 580                                         const char *con_id,
 581                                         enum gpiod_flags flags,
 582                                         const char *label)
 583 {
 584         return devm_fwnode_gpiod_get_index(dev, fwnode, con_id, 0,
 585                                            flags, label);
 586 }
 587
 588 static inline
 589 struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
 590                                                 const char *con_id, int index,
 591                                                 struct fwnode_handle *child,
 592                                                 enum gpiod_flags flags,
 593                                                 const char *label)
 594 {
 595         return devm_fwnode_gpiod_get_index(dev, child, con_id, index,
 596                                            flags, label);
 597 }
 598
 599 static inline
 600 struct gpio_desc *devm_fwnode_get_gpiod_from_child(struct device *dev,
 601                                                    const char *con_id,
 602                                                    struct fwnode_handle *child,
 603                                                    enum gpiod_flags flags,
 604                                                    const char *label)
 605 {
 606         return devm_fwnode_gpiod_get_index(dev, child, con_id, 0, flags, label);
 607 }
 608
 609 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_OF_GPIO)
 610 struct device_node;
 611
 612 struct gpio_desc *gpiod_get_from_of_node(const struct device_node *node,
 613                                          const char *propname, int index,
 614                                          enum gpiod_flags dflags,
 615                                          const char *label);
 616
 617 #else  /* CONFIG_GPIOLIB && CONFIG_OF_GPIO */
 618
 619 struct device_node;
 620
 621 static inline
 622 struct gpio_desc *gpiod_get_from_of_node(const struct device_node *node,
 623                                          const char *propname, int index,
 624                                          enum gpiod_flags dflags,
 625                                          const char *label)
 626 {
 627         return ERR_PTR(-ENOSYS);
 628 }
 629
 630 #endif /* CONFIG_GPIOLIB && CONFIG_OF_GPIO */
 631
 632 #ifdef CONFIG_GPIOLIB
 633 struct device_node;
 634
 635 struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
 636                                               const struct device_node *node,
 637                                               const char *propname, int index,
 638                                               enum gpiod_flags dflags,
 639                                               const char *label);
 640
 641 #else  /* CONFIG_GPIOLIB */
 642
 643 struct device_node;
 644
 645 static inline
 646 struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
 647                                               const struct device_node *node,
 648                                               const char *propname, int index,
 649                                               enum gpiod_flags dflags,
 650                                               const char *label)
 651 {
 652         return ERR_PTR(-ENOSYS);
 653 }
 654
 655 #endif /* CONFIG_GPIOLIB */
 656
 657 struct acpi_gpio_params {
 658         unsigned int crs_entry_index;
 659         unsigned int line_index;
 660         bool active_low;
 661 };
 662
 663 struct acpi_gpio_mapping {
 664         const char *name;
 665         const struct acpi_gpio_params *data;
 666         unsigned int size;
 667
 668 /* Ignore IoRestriction field */
 669 #define ACPI_GPIO_QUIRK_NO_IO_RESTRICTION       BIT(0)
 670 /*
 671  * When ACPI GPIO mapping table is in use the index parameter inside it
 672  * refers to the GPIO resource in _CRS method. That index has no
 673  * distinction of actual type of the resource. When consumer wants to
 674  * get GpioIo type explicitly, this quirk may be used.
 675  */
 676 #define ACPI_GPIO_QUIRK_ONLY_GPIOIO             BIT(1)
 677 /* Use given pin as an absolute GPIO number in the system */
 678 #define ACPI_GPIO_QUIRK_ABSOLUTE_NUMBER         BIT(2)
 679
 680         unsigned int quirks;
 681 };
 682
 683 struct acpi_device;
 684
 685 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_ACPI)
 686
 687 int acpi_dev_add_driver_gpios(struct acpi_device *adev,
 688                               const struct acpi_gpio_mapping *gpios);
 689 void acpi_dev_remove_driver_gpios(struct acpi_device *adev);
 690
 691 int devm_acpi_dev_add_driver_gpios(struct device *dev,
 692                                    const struct acpi_gpio_mapping *gpios);
 693 void devm_acpi_dev_remove_driver_gpios(struct device *dev);
 694
 695 struct gpio_desc *acpi_get_and_request_gpiod(char *path, int pin, char *label);
 696
 697 #else  /* CONFIG_GPIOLIB && CONFIG_ACPI */
 698
 699 static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
 700                               const struct acpi_gpio_mapping *gpios)
 701 {
 702         return -ENXIO;
 703 }
 704 static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}
 705
 706 static inline int devm_acpi_dev_add_driver_gpios(struct device *dev,
 707                               const struct acpi_gpio_mapping *gpios)
 708 {
 709         return -ENXIO;
 710 }
 711 static inline void devm_acpi_dev_remove_driver_gpios(struct device *dev) {}
 712
 713 #endif /* CONFIG_GPIOLIB && CONFIG_ACPI */
 714
 715
 716 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 717
 718 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 719 int gpiod_export_link(struct device *dev, const char *name,
 720                       struct gpio_desc *desc);
 721 void gpiod_unexport(struct gpio_desc *desc);
 722
 723 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 724
 725 static inline int gpiod_export(struct gpio_desc *desc,
 726                                bool direction_may_change)
 727 {
 728         return -ENOSYS;
 729 }
 730
 731 static inline int gpiod_export_link(struct device *dev, const char *name,
 732                                     struct gpio_desc *desc)
 733 {
 734         return -ENOSYS;
 735 }
 736
 737 static inline void gpiod_unexport(struct gpio_desc *desc)
 738 {
 739 }
 740
 741 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 742
 743 #endif