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/err.h>
   7 #include <linux/types.h>
   8
   9 struct acpi_device;
  10 struct device;
  11 struct fwnode_handle;
  12
  13 struct gpio_array;
  14 struct gpio_desc;
  15
  16 /**
  17  * struct gpio_descs - Struct containing an array of descriptors that can be
  18  *                     obtained using gpiod_get_array()
  19  *
  20  * @info:       Pointer to the opaque gpio_array structure
  21  * @ndescs:     Number of held descriptors
  22  * @desc:       Array of pointers to GPIO descriptors
  23  */
  24 struct gpio_descs {
  25         struct gpio_array *info;
  26         unsigned int ndescs;
  27         struct gpio_desc *desc[];
  28 };
  29
  30 #define GPIOD_FLAGS_BIT_DIR_SET         BIT(0)
  31 #define GPIOD_FLAGS_BIT_DIR_OUT         BIT(1)
  32 #define GPIOD_FLAGS_BIT_DIR_VAL         BIT(2)
  33 #define GPIOD_FLAGS_BIT_OPEN_DRAIN      BIT(3)
  34 /* GPIOD_FLAGS_BIT_NONEXCLUSIVE is DEPRECATED, don't use in new code. */
  35 #define GPIOD_FLAGS_BIT_NONEXCLUSIVE    BIT(4)
  36
  37 /**
  38  * enum gpiod_flags - Optional flags that can be passed to one of gpiod_* to
  39  *                    configure direction and output value. These values
  40  *                    cannot be OR'd.
  41  *
  42  * @GPIOD_ASIS:                 Don't change anything
  43  * @GPIOD_IN:                   Set lines to input mode
  44  * @GPIOD_OUT_LOW:              Set lines to output and drive them low
  45  * @GPIOD_OUT_HIGH:             Set lines to output and drive them high
  46  * @GPIOD_OUT_LOW_OPEN_DRAIN:   Set lines to open-drain output and drive them low
  47  * @GPIOD_OUT_HIGH_OPEN_DRAIN:  Set lines to open-drain output and drive them high
  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 int 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 int 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 int 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 int 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 void gpiod_toggle_active_low(struct gpio_desc *desc);
 163
 164 int gpiod_is_active_low(const struct gpio_desc *desc);
 165 int gpiod_cansleep(const struct gpio_desc *desc);
 166
 167 int gpiod_to_irq(const struct gpio_desc *desc);
 168 int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name);
 169
 170 /* Convert between the old gpio_ and new gpiod_ interfaces */
 171 struct gpio_desc *gpio_to_desc(unsigned gpio);
 172 int desc_to_gpio(const struct gpio_desc *desc);
 173
 174 struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
 175                                          const char *con_id, int index,
 176                                          enum gpiod_flags flags,
 177                                          const char *label);
 178 struct gpio_desc *devm_fwnode_gpiod_get_index(struct device *dev,
 179                                               struct fwnode_handle *child,
 180                                               const char *con_id, int index,
 181                                               enum gpiod_flags flags,
 182                                               const char *label);
 183
 184 bool gpiod_is_equal(struct gpio_desc *desc, struct gpio_desc *other);
 185
 186 #else /* CONFIG_GPIOLIB */
 187
 188 #include <linux/bug.h>
 189 #include <linux/kernel.h>
 190
 191 static inline int gpiod_count(struct device *dev, const char *con_id)
 192 {
 193         return 0;
 194 }
 195
 196 static inline struct gpio_desc *__must_check gpiod_get(struct device *dev,
 197                                                        const char *con_id,
 198                                                        enum gpiod_flags flags)
 199 {
 200         return ERR_PTR(-ENOSYS);
 201 }
 202 static inline struct gpio_desc *__must_check
 203 gpiod_get_index(struct device *dev,
 204                 const char *con_id,
 205                 unsigned int idx,
 206                 enum gpiod_flags flags)
 207 {
 208         return ERR_PTR(-ENOSYS);
 209 }
 210
 211 static inline struct gpio_desc *__must_check
 212 gpiod_get_optional(struct device *dev, const char *con_id,
 213                    enum gpiod_flags flags)
 214 {
 215         return NULL;
 216 }
 217
 218 static inline struct gpio_desc *__must_check
 219 gpiod_get_index_optional(struct device *dev, const char *con_id,
 220                          unsigned int index, enum gpiod_flags flags)
 221 {
 222         return NULL;
 223 }
 224
 225 static inline struct gpio_descs *__must_check
 226 gpiod_get_array(struct device *dev, const char *con_id,
 227                 enum gpiod_flags flags)
 228 {
 229         return ERR_PTR(-ENOSYS);
 230 }
 231
 232 static inline struct gpio_descs *__must_check
 233 gpiod_get_array_optional(struct device *dev, const char *con_id,
 234                          enum gpiod_flags flags)
 235 {
 236         return NULL;
 237 }
 238
 239 static inline void gpiod_put(struct gpio_desc *desc)
 240 {
 241         might_sleep();
 242
 243         /* GPIO can never have been requested */
 244         WARN_ON(desc);
 245 }
 246
 247 static inline void devm_gpiod_unhinge(struct device *dev,
 248                                       struct gpio_desc *desc)
 249 {
 250         might_sleep();
 251
 252         /* GPIO can never have been requested */
 253         WARN_ON(desc);
 254 }
 255
 256 static inline void gpiod_put_array(struct gpio_descs *descs)
 257 {
 258         might_sleep();
 259
 260         /* GPIO can never have been requested */
 261         WARN_ON(descs);
 262 }
 263
 264 static inline struct gpio_desc *__must_check
 265 devm_gpiod_get(struct device *dev,
 266                  const char *con_id,
 267                  enum gpiod_flags flags)
 268 {
 269         return ERR_PTR(-ENOSYS);
 270 }
 271 static inline
 272 struct gpio_desc *__must_check
 273 devm_gpiod_get_index(struct device *dev,
 274                        const char *con_id,
 275                        unsigned int idx,
 276                        enum gpiod_flags flags)
 277 {
 278         return ERR_PTR(-ENOSYS);
 279 }
 280
 281 static inline struct gpio_desc *__must_check
 282 devm_gpiod_get_optional(struct device *dev, const char *con_id,
 283                           enum gpiod_flags flags)
 284 {
 285         return NULL;
 286 }
 287
 288 static inline struct gpio_desc *__must_check
 289 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 290                                 unsigned int index, enum gpiod_flags flags)
 291 {
 292         return NULL;
 293 }
 294
 295 static inline struct gpio_descs *__must_check
 296 devm_gpiod_get_array(struct device *dev, const char *con_id,
 297                      enum gpiod_flags flags)
 298 {
 299         return ERR_PTR(-ENOSYS);
 300 }
 301
 302 static inline struct gpio_descs *__must_check
 303 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
 304                               enum gpiod_flags flags)
 305 {
 306         return NULL;
 307 }
 308
 309 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
 310 {
 311         might_sleep();
 312
 313         /* GPIO can never have been requested */
 314         WARN_ON(desc);
 315 }
 316
 317 static inline void devm_gpiod_put_array(struct device *dev,
 318                                         struct gpio_descs *descs)
 319 {
 320         might_sleep();
 321
 322         /* GPIO can never have been requested */
 323         WARN_ON(descs);
 324 }
 325
 326
 327 static inline int gpiod_get_direction(const struct gpio_desc *desc)
 328 {
 329         /* GPIO can never have been requested */
 330         WARN_ON(desc);
 331         return -ENOSYS;
 332 }
 333 static inline int gpiod_direction_input(struct gpio_desc *desc)
 334 {
 335         /* GPIO can never have been requested */
 336         WARN_ON(desc);
 337         return -ENOSYS;
 338 }
 339 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
 340 {
 341         /* GPIO can never have been requested */
 342         WARN_ON(desc);
 343         return -ENOSYS;
 344 }
 345 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 346 {
 347         /* GPIO can never have been requested */
 348         WARN_ON(desc);
 349         return -ENOSYS;
 350 }
 351 static inline int gpiod_get_value(const struct gpio_desc *desc)
 352 {
 353         /* GPIO can never have been requested */
 354         WARN_ON(desc);
 355         return 0;
 356 }
 357 static inline int gpiod_get_array_value(unsigned int array_size,
 358                                         struct gpio_desc **desc_array,
 359                                         struct gpio_array *array_info,
 360                                         unsigned long *value_bitmap)
 361 {
 362         /* GPIO can never have been requested */
 363         WARN_ON(desc_array);
 364         return 0;
 365 }
 366 static inline int gpiod_set_value(struct gpio_desc *desc, int value)
 367 {
 368         /* GPIO can never have been requested */
 369         WARN_ON(desc);
 370         return 0;
 371 }
 372 static inline int gpiod_set_array_value(unsigned int array_size,
 373                                         struct gpio_desc **desc_array,
 374                                         struct gpio_array *array_info,
 375                                         unsigned long *value_bitmap)
 376 {
 377         /* GPIO can never have been requested */
 378         WARN_ON(desc_array);
 379         return 0;
 380 }
 381 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 382 {
 383         /* GPIO can never have been requested */
 384         WARN_ON(desc);
 385         return 0;
 386 }
 387 static inline int gpiod_get_raw_array_value(unsigned int array_size,
 388                                             struct gpio_desc **desc_array,
 389                                             struct gpio_array *array_info,
 390                                             unsigned long *value_bitmap)
 391 {
 392         /* GPIO can never have been requested */
 393         WARN_ON(desc_array);
 394         return 0;
 395 }
 396 static inline int gpiod_set_raw_value(struct gpio_desc *desc, int value)
 397 {
 398         /* GPIO can never have been requested */
 399         WARN_ON(desc);
 400         return 0;
 401 }
 402 static inline int gpiod_set_raw_array_value(unsigned int array_size,
 403                                             struct gpio_desc **desc_array,
 404                                             struct gpio_array *array_info,
 405                                             unsigned long *value_bitmap)
 406 {
 407         /* GPIO can never have been requested */
 408         WARN_ON(desc_array);
 409         return 0;
 410 }
 411
 412 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 413 {
 414         /* GPIO can never have been requested */
 415         WARN_ON(desc);
 416         return 0;
 417 }
 418 static inline int gpiod_get_array_value_cansleep(unsigned int array_size,
 419                                      struct gpio_desc **desc_array,
 420                                      struct gpio_array *array_info,
 421                                      unsigned long *value_bitmap)
 422 {
 423         /* GPIO can never have been requested */
 424         WARN_ON(desc_array);
 425         return 0;
 426 }
 427 static inline int gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 428 {
 429         /* GPIO can never have been requested */
 430         WARN_ON(desc);
 431         return 0;
 432 }
 433 static inline int gpiod_set_array_value_cansleep(unsigned int array_size,
 434                                             struct gpio_desc **desc_array,
 435                                             struct gpio_array *array_info,
 436                                             unsigned long *value_bitmap)
 437 {
 438         /* GPIO can never have been requested */
 439         WARN_ON(desc_array);
 440         return 0;
 441 }
 442 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 443 {
 444         /* GPIO can never have been requested */
 445         WARN_ON(desc);
 446         return 0;
 447 }
 448 static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
 449                                                struct gpio_desc **desc_array,
 450                                                struct gpio_array *array_info,
 451                                                unsigned long *value_bitmap)
 452 {
 453         /* GPIO can never have been requested */
 454         WARN_ON(desc_array);
 455         return 0;
 456 }
 457 static inline int gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 458                                                int value)
 459 {
 460         /* GPIO can never have been requested */
 461         WARN_ON(desc);
 462         return 0;
 463 }
 464 static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
 465                                                 struct gpio_desc **desc_array,
 466                                                 struct gpio_array *array_info,
 467                                                 unsigned long *value_bitmap)
 468 {
 469         /* GPIO can never have been requested */
 470         WARN_ON(desc_array);
 471         return 0;
 472 }
 473
 474 static inline int gpiod_set_config(struct gpio_desc *desc, unsigned long config)
 475 {
 476         /* GPIO can never have been requested */
 477         WARN_ON(desc);
 478         return -ENOSYS;
 479 }
 480
 481 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned int debounce)
 482 {
 483         /* GPIO can never have been requested */
 484         WARN_ON(desc);
 485         return -ENOSYS;
 486 }
 487
 488 static inline void gpiod_toggle_active_low(struct gpio_desc *desc)
 489 {
 490         /* GPIO can never have been requested */
 491         WARN_ON(desc);
 492 }
 493
 494 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 495 {
 496         /* GPIO can never have been requested */
 497         WARN_ON(desc);
 498         return 0;
 499 }
 500 static inline int gpiod_cansleep(const struct gpio_desc *desc)
 501 {
 502         /* GPIO can never have been requested */
 503         WARN_ON(desc);
 504         return 0;
 505 }
 506
 507 static inline int gpiod_to_irq(const struct gpio_desc *desc)
 508 {
 509         /* GPIO can never have been requested */
 510         WARN_ON(desc);
 511         return -EINVAL;
 512 }
 513
 514 static inline int gpiod_set_consumer_name(struct gpio_desc *desc,
 515                                           const char *name)
 516 {
 517         /* GPIO can never have been requested */
 518         WARN_ON(desc);
 519         return -EINVAL;
 520 }
 521
 522 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 523 {
 524         return NULL;
 525 }
 526
 527 static inline int desc_to_gpio(const struct gpio_desc *desc)
 528 {
 529         /* GPIO can never have been requested */
 530         WARN_ON(desc);
 531         return -EINVAL;
 532 }
 533
 534 static inline
 535 struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
 536                                          const char *con_id, int index,
 537                                          enum gpiod_flags flags,
 538                                          const char *label)
 539 {
 540         return ERR_PTR(-ENOSYS);
 541 }
 542
 543 static inline
 544 struct gpio_desc *devm_fwnode_gpiod_get_index(struct device *dev,
 545                                               struct fwnode_handle *fwnode,
 546                                               const char *con_id, int index,
 547                                               enum gpiod_flags flags,
 548                                               const char *label)
 549 {
 550         return ERR_PTR(-ENOSYS);
 551 }
 552
 553 static inline bool
 554 gpiod_is_equal(struct gpio_desc *desc, struct gpio_desc *other)
 555 {
 556         WARN_ON(desc || other);
 557         return false;
 558 }
 559
 560 #endif /* CONFIG_GPIOLIB */
 561
 562 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_HTE)
 563 int gpiod_enable_hw_timestamp_ns(struct gpio_desc *desc, unsigned long flags);
 564 int gpiod_disable_hw_timestamp_ns(struct gpio_desc *desc, unsigned long flags);
 565 #else
 566
 567 #include <linux/bug.h>
 568
 569 static inline int gpiod_enable_hw_timestamp_ns(struct gpio_desc *desc,
 570                                                unsigned long flags)
 571 {
 572         if (!IS_ENABLED(CONFIG_GPIOLIB))
 573                 WARN_ON(desc);
 574
 575         return -ENOSYS;
 576 }
 577 static inline int gpiod_disable_hw_timestamp_ns(struct gpio_desc *desc,
 578                                                 unsigned long flags)
 579 {
 580         if (!IS_ENABLED(CONFIG_GPIOLIB))
 581                 WARN_ON(desc);
 582
 583         return -ENOSYS;
 584 }
 585 #endif /* CONFIG_GPIOLIB && CONFIG_HTE */
 586
 587 static inline
 588 struct gpio_desc *devm_fwnode_gpiod_get(struct device *dev,
 589                                         struct fwnode_handle *fwnode,
 590                                         const char *con_id,
 591                                         enum gpiod_flags flags,
 592                                         const char *label)
 593 {
 594         return devm_fwnode_gpiod_get_index(dev, fwnode, con_id, 0,
 595                                            flags, label);
 596 }
 597
 598 struct acpi_gpio_params {
 599         unsigned int crs_entry_index;
 600         unsigned short line_index;
 601         bool active_low;
 602 };
 603
 604 struct acpi_gpio_mapping {
 605         const char *name;
 606         const struct acpi_gpio_params *data;
 607         unsigned int size;
 608
 609 /* Ignore IoRestriction field */
 610 #define ACPI_GPIO_QUIRK_NO_IO_RESTRICTION       BIT(0)
 611 /*
 612  * When ACPI GPIO mapping table is in use the index parameter inside it
 613  * refers to the GPIO resource in _CRS method. That index has no
 614  * distinction of actual type of the resource. When consumer wants to
 615  * get GpioIo type explicitly, this quirk may be used.
 616  */
 617 #define ACPI_GPIO_QUIRK_ONLY_GPIOIO             BIT(1)
 618 /* Use given pin as an absolute GPIO number in the system */
 619 #define ACPI_GPIO_QUIRK_ABSOLUTE_NUMBER         BIT(2)
 620
 621         unsigned int quirks;
 622 };
 623
 624 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_ACPI)
 625
 626 int acpi_dev_add_driver_gpios(struct acpi_device *adev,
 627                               const struct acpi_gpio_mapping *gpios);
 628 void acpi_dev_remove_driver_gpios(struct acpi_device *adev);
 629
 630 int devm_acpi_dev_add_driver_gpios(struct device *dev,
 631                                    const struct acpi_gpio_mapping *gpios);
 632
 633 #else  /* CONFIG_GPIOLIB && CONFIG_ACPI */
 634
 635 static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
 636                               const struct acpi_gpio_mapping *gpios)
 637 {
 638         return -ENXIO;
 639 }
 640 static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}
 641
 642 static inline int devm_acpi_dev_add_driver_gpios(struct device *dev,
 643                               const struct acpi_gpio_mapping *gpios)
 644 {
 645         return -ENXIO;
 646 }
 647
 648 #endif /* CONFIG_GPIOLIB && CONFIG_ACPI */
 649
 650
 651 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 652
 653 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 654 int gpiod_export_link(struct device *dev, const char *name,
 655                       struct gpio_desc *desc);
 656 void gpiod_unexport(struct gpio_desc *desc);
 657
 658 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 659
 660 static inline int gpiod_export(struct gpio_desc *desc,
 661                                bool direction_may_change)
 662 {
 663         return -ENOSYS;
 664 }
 665
 666 static inline int gpiod_export_link(struct device *dev, const char *name,
 667                                     struct gpio_desc *desc)
 668 {
 669         return -ENOSYS;
 670 }
 671
 672 static inline void gpiod_unexport(struct gpio_desc *desc)
 673 {
 674 }
 675
 676 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 677
 678 static inline int gpiod_multi_set_value_cansleep(struct gpio_descs *descs,
 679                                                  unsigned long *value_bitmap)
 680 {
 681         if (IS_ERR_OR_NULL(descs))
 682                 return PTR_ERR_OR_ZERO(descs);
 683
 684         return gpiod_set_array_value_cansleep(descs->ndescs, descs->desc,
 685                                               descs->info, value_bitmap);
 686 }
 687
 688 #endif