drivers/gpio/gpiolib.c

   1 #include <linux/kernel.h>
   2 #include <linux/module.h>
   3 #include <linux/interrupt.h>
   4 #include <linux/irq.h>
   5 #include <linux/spinlock.h>
   6 #include <linux/list.h>
   7 #include <linux/device.h>
   8 #include <linux/err.h>
   9 #include <linux/debugfs.h>
  10 #include <linux/seq_file.h>
  11 #include <linux/gpio.h>
  12 #include <linux/of_gpio.h>
  13 #include <linux/idr.h>
  14 #include <linux/slab.h>
  15 #include <linux/acpi.h>
  16 #include <linux/gpio/driver.h>
  17
  18 #include "gpiolib.h"
  19
  20 #define CREATE_TRACE_POINTS
  21 #include <trace/events/gpio.h>
  22
  23 /* Implementation infrastructure for GPIO interfaces.
  24  *
  25  * The GPIO programming interface allows for inlining speed-critical
  26  * get/set operations for common cases, so that access to SOC-integrated
  27  * GPIOs can sometimes cost only an instruction or two per bit.
  28  */
  29
  30
  31 /* When debugging, extend minimal trust to callers and platform code.
  32  * Also emit diagnostic messages that may help initial bringup, when
  33  * board setup or driver bugs are most common.
  34  *
  35  * Otherwise, minimize overhead in what may be bitbanging codepaths.
  36  */
  37 #ifdef  DEBUG
  38 #define extra_checks    1
  39 #else
  40 #define extra_checks    0
  41 #endif
  42
  43 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
  44  * While any GPIO is requested, its gpio_chip is not removable;
  45  * each GPIO's "requested" flag serves as a lock and refcount.
  46  */
  47 static DEFINE_SPINLOCK(gpio_lock);
  48
  49 struct gpio_desc {
  50         struct gpio_chip        *chip;
  51         unsigned long           flags;
  52 /* flag symbols are bit numbers */
  53 #define FLAG_REQUESTED  0
  54 #define FLAG_IS_OUT     1
  55 #define FLAG_EXPORT     2       /* protected by sysfs_lock */
  56 #define FLAG_SYSFS      3       /* exported via /sys/class/gpio/control */
  57 #define FLAG_TRIG_FALL  4       /* trigger on falling edge */
  58 #define FLAG_TRIG_RISE  5       /* trigger on rising edge */
  59 #define FLAG_ACTIVE_LOW 6       /* value has active low */
  60 #define FLAG_OPEN_DRAIN 7       /* Gpio is open drain type */
  61 #define FLAG_OPEN_SOURCE 8      /* Gpio is open source type */
  62 #define FLAG_USED_AS_IRQ 9      /* GPIO is connected to an IRQ */
  63
  64 #define ID_SHIFT        16      /* add new flags before this one */
  65
  66 #define GPIO_FLAGS_MASK         ((1 << ID_SHIFT) - 1)
  67 #define GPIO_TRIGGER_MASK       (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
  68
  69 #ifdef CONFIG_DEBUG_FS
  70         const char              *label;
  71 #endif
  72 };
  73 static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
  74
  75 #define GPIO_OFFSET_VALID(chip, offset) (offset >= 0 && offset < chip->ngpio)
  76
  77 static DEFINE_MUTEX(gpio_lookup_lock);
  78 static LIST_HEAD(gpio_lookup_list);
  79 static LIST_HEAD(gpio_chips);
  80
  81 #ifdef CONFIG_GPIO_SYSFS
  82 static DEFINE_IDR(dirent_idr);
  83 #endif
  84
  85 static int gpiod_request(struct gpio_desc *desc, const char *label);
  86 static void gpiod_free(struct gpio_desc *desc);
  87
  88 /* With descriptor prefix */
  89
  90 #ifdef CONFIG_DEBUG_FS
  91 #define gpiod_emerg(desc, fmt, ...)                                            \
  92         pr_emerg("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
  93                  ##__VA_ARGS__)
  94 #define gpiod_crit(desc, fmt, ...)                                             \
  95         pr_crit("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
  96                  ##__VA_ARGS__)
  97 #define gpiod_err(desc, fmt, ...)                                              \
  98         pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",  \
  99                  ##__VA_ARGS__)
 100 #define gpiod_warn(desc, fmt, ...)                                             \
 101         pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
 102                  ##__VA_ARGS__)
 103 #define gpiod_info(desc, fmt, ...)                                             \
 104         pr_info("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
 105                 ##__VA_ARGS__)
 106 #define gpiod_dbg(desc, fmt, ...)                                              \
 107         pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
 108                  ##__VA_ARGS__)
 109 #else
 110 #define gpiod_emerg(desc, fmt, ...)                                     \
 111         pr_emerg("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
 112 #define gpiod_crit(desc, fmt, ...)                                      \
 113         pr_crit("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
 114 #define gpiod_err(desc, fmt, ...)                                       \
 115         pr_err("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
 116 #define gpiod_warn(desc, fmt, ...)                                      \
 117         pr_warn("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
 118 #define gpiod_info(desc, fmt, ...)                                      \
 119         pr_info("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
 120 #define gpiod_dbg(desc, fmt, ...)                                       \
 121         pr_debug("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
 122 #endif
 123
 124 /* With chip prefix */
 125
 126 #define chip_emerg(chip, fmt, ...)                                      \
 127         pr_emerg("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
 128 #define chip_crit(chip, fmt, ...)                                       \
 129         pr_crit("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
 130 #define chip_err(chip, fmt, ...)                                        \
 131         pr_err("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
 132 #define chip_warn(chip, fmt, ...)                                       \
 133         pr_warn("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
 134 #define chip_info(chip, fmt, ...)                                       \
 135         pr_info("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
 136 #define chip_dbg(chip, fmt, ...)                                        \
 137         pr_debug("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
 138
 139 static inline void desc_set_label(struct gpio_desc *d, const char *label)
 140 {
 141 #ifdef CONFIG_DEBUG_FS
 142         d->label = label;
 143 #endif
 144 }
 145
 146 /*
 147  * Return the GPIO number of the passed descriptor relative to its chip
 148  */
 149 static int gpio_chip_hwgpio(const struct gpio_desc *desc)
 150 {
 151         return desc - &desc->chip->desc[0];
 152 }
 153
 154 /**
 155  * Convert a GPIO number to its descriptor
 156  */
 157 struct gpio_desc *gpio_to_desc(unsigned gpio)
 158 {
 159         if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
 160                 return NULL;
 161         else
 162                 return &gpio_desc[gpio];
 163 }
 164 EXPORT_SYMBOL_GPL(gpio_to_desc);
 165
 166 /**
 167  * Get the GPIO descriptor corresponding to the given hw number for this chip.
 168  */
 169 struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
 170                                     u16 hwnum)
 171 {
 172         if (hwnum >= chip->ngpio)
 173                 return ERR_PTR(-EINVAL);
 174
 175         return &chip->desc[hwnum];
 176 }
 177 EXPORT_SYMBOL_GPL(gpiochip_get_desc);
 178
 179 /**
 180  * Convert a GPIO descriptor to the integer namespace.
 181  * This should disappear in the future but is needed since we still
 182  * use GPIO numbers for error messages and sysfs nodes
 183  */
 184 int desc_to_gpio(const struct gpio_desc *desc)
 185 {
 186         return desc - &gpio_desc[0];
 187 }
 188 EXPORT_SYMBOL_GPL(desc_to_gpio);
 189
 190
 191 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
 192  * when setting direction, and otherwise illegal.  Until board setup code
 193  * and drivers use explicit requests everywhere (which won't happen when
 194  * those calls have no teeth) we can't avoid autorequesting.  This nag
 195  * message should motivate switching to explicit requests... so should
 196  * the weaker cleanup after faults, compared to gpio_request().
 197  *
 198  * NOTE: the autorequest mechanism is going away; at this point it's
 199  * only "legal" in the sense that (old) code using it won't break yet,
 200  * but instead only triggers a WARN() stack dump.
 201  */
 202 static int gpio_ensure_requested(struct gpio_desc *desc)
 203 {
 204         const struct gpio_chip *chip = desc->chip;
 205         const int gpio = desc_to_gpio(desc);
 206
 207         if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
 208                         "autorequest GPIO-%d\n", gpio)) {
 209                 if (!try_module_get(chip->owner)) {
 210                         gpiod_err(desc, "%s: module can't be gotten\n",
 211                                         __func__);
 212                         clear_bit(FLAG_REQUESTED, &desc->flags);
 213                         /* lose */
 214                         return -EIO;
 215                 }
 216                 desc_set_label(desc, "[auto]");
 217                 /* caller must chip->request() w/o spinlock */
 218                 if (chip->request)
 219                         return 1;
 220         }
 221         return 0;
 222 }
 223
 224 /**
 225  * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
 226  * @desc:       descriptor to return the chip of
 227  */
 228 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
 229 {
 230         return desc ? desc->chip : NULL;
 231 }
 232 EXPORT_SYMBOL_GPL(gpiod_to_chip);
 233
 234 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
 235 static int gpiochip_find_base(int ngpio)
 236 {
 237         struct gpio_chip *chip;
 238         int base = ARCH_NR_GPIOS - ngpio;
 239
 240         list_for_each_entry_reverse(chip, &gpio_chips, list) {
 241                 /* found a free space? */
 242                 if (chip->base + chip->ngpio <= base)
 243                         break;
 244                 else
 245                         /* nope, check the space right before the chip */
 246                         base = chip->base - ngpio;
 247         }
 248
 249         if (gpio_is_valid(base)) {
 250                 pr_debug("%s: found new base at %d\n", __func__, base);
 251                 return base;
 252         } else {
 253                 pr_err("%s: cannot find free range\n", __func__);
 254                 return -ENOSPC;
 255         }
 256 }
 257
 258 /**
 259  * gpiod_get_direction - return the current direction of a GPIO
 260  * @desc:       GPIO to get the direction of
 261  *
 262  * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
 263  *
 264  * This function may sleep if gpiod_cansleep() is true.
 265  */
 266 int gpiod_get_direction(const struct gpio_desc *desc)
 267 {
 268         struct gpio_chip        *chip;
 269         unsigned                offset;
 270         int                     status = -EINVAL;
 271
 272         chip = gpiod_to_chip(desc);
 273         offset = gpio_chip_hwgpio(desc);
 274
 275         if (!chip->get_direction)
 276                 return status;
 277
 278         status = chip->get_direction(chip, offset);
 279         if (status > 0) {
 280                 /* GPIOF_DIR_IN, or other positive */
 281                 status = 1;
 282                 /* FLAG_IS_OUT is just a cache of the result of get_direction(),
 283                  * so it does not affect constness per se */
 284                 clear_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
 285         }
 286         if (status == 0) {
 287                 /* GPIOF_DIR_OUT */
 288                 set_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
 289         }
 290         return status;
 291 }
 292 EXPORT_SYMBOL_GPL(gpiod_get_direction);
 293
 294 #ifdef CONFIG_GPIO_SYSFS
 295
 296 /* lock protects against unexport_gpio() being called while
 297  * sysfs files are active.
 298  */
 299 static DEFINE_MUTEX(sysfs_lock);
 300
 301 /*
 302  * /sys/class/gpio/gpioN... only for GPIOs that are exported
 303  *   /direction
 304  *      * MAY BE OMITTED if kernel won't allow direction changes
 305  *      * is read/write as "in" or "out"
 306  *      * may also be written as "high" or "low", initializing
 307  *        output value as specified ("out" implies "low")
 308  *   /value
 309  *      * always readable, subject to hardware behavior
 310  *      * may be writable, as zero/nonzero
 311  *   /edge
 312  *      * configures behavior of poll(2) on /value
 313  *      * available only if pin can generate IRQs on input
 314  *      * is read/write as "none", "falling", "rising", or "both"
 315  *   /active_low
 316  *      * configures polarity of /value
 317  *      * is read/write as zero/nonzero
 318  *      * also affects existing and subsequent "falling" and "rising"
 319  *        /edge configuration
 320  */
 321
 322 static ssize_t gpio_direction_show(struct device *dev,
 323                 struct device_attribute *attr, char *buf)
 324 {
 325         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 326         ssize_t                 status;
 327
 328         mutex_lock(&sysfs_lock);
 329
 330         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
 331                 status = -EIO;
 332         } else {
 333                 gpiod_get_direction(desc);
 334                 status = sprintf(buf, "%s\n",
 335                         test_bit(FLAG_IS_OUT, &desc->flags)
 336                                 ? "out" : "in");
 337         }
 338
 339         mutex_unlock(&sysfs_lock);
 340         return status;
 341 }
 342
 343 static ssize_t gpio_direction_store(struct device *dev,
 344                 struct device_attribute *attr, const char *buf, size_t size)
 345 {
 346         struct gpio_desc        *desc = dev_get_drvdata(dev);
 347         ssize_t                 status;
 348
 349         mutex_lock(&sysfs_lock);
 350
 351         if (!test_bit(FLAG_EXPORT, &desc->flags))
 352                 status = -EIO;
 353         else if (sysfs_streq(buf, "high"))
 354                 status = gpiod_direction_output_raw(desc, 1);
 355         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
 356                 status = gpiod_direction_output_raw(desc, 0);
 357         else if (sysfs_streq(buf, "in"))
 358                 status = gpiod_direction_input(desc);
 359         else
 360                 status = -EINVAL;
 361
 362         mutex_unlock(&sysfs_lock);
 363         return status ? : size;
 364 }
 365
 366 static /* const */ DEVICE_ATTR(direction, 0644,
 367                 gpio_direction_show, gpio_direction_store);
 368
 369 static ssize_t gpio_value_show(struct device *dev,
 370                 struct device_attribute *attr, char *buf)
 371 {
 372         struct gpio_desc        *desc = dev_get_drvdata(dev);
 373         ssize_t                 status;
 374
 375         mutex_lock(&sysfs_lock);
 376
 377         if (!test_bit(FLAG_EXPORT, &desc->flags))
 378                 status = -EIO;
 379         else
 380                 status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
 381
 382         mutex_unlock(&sysfs_lock);
 383         return status;
 384 }
 385
 386 static ssize_t gpio_value_store(struct device *dev,
 387                 struct device_attribute *attr, const char *buf, size_t size)
 388 {
 389         struct gpio_desc        *desc = dev_get_drvdata(dev);
 390         ssize_t                 status;
 391
 392         mutex_lock(&sysfs_lock);
 393
 394         if (!test_bit(FLAG_EXPORT, &desc->flags))
 395                 status = -EIO;
 396         else if (!test_bit(FLAG_IS_OUT, &desc->flags))
 397                 status = -EPERM;
 398         else {
 399                 long            value;
 400
 401                 status = kstrtol(buf, 0, &value);
 402                 if (status == 0) {
 403                         gpiod_set_value_cansleep(desc, value);
 404                         status = size;
 405                 }
 406         }
 407
 408         mutex_unlock(&sysfs_lock);
 409         return status;
 410 }
 411
 412 static const DEVICE_ATTR(value, 0644,
 413                 gpio_value_show, gpio_value_store);
 414
 415 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
 416 {
 417         struct kernfs_node      *value_sd = priv;
 418
 419         sysfs_notify_dirent(value_sd);
 420         return IRQ_HANDLED;
 421 }
 422
 423 static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
 424                 unsigned long gpio_flags)
 425 {
 426         struct kernfs_node      *value_sd;
 427         unsigned long           irq_flags;
 428         int                     ret, irq, id;
 429
 430         if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
 431                 return 0;
 432
 433         irq = gpiod_to_irq(desc);
 434         if (irq < 0)
 435                 return -EIO;
 436
 437         id = desc->flags >> ID_SHIFT;
 438         value_sd = idr_find(&dirent_idr, id);
 439         if (value_sd)
 440                 free_irq(irq, value_sd);
 441
 442         desc->flags &= ~GPIO_TRIGGER_MASK;
 443
 444         if (!gpio_flags) {
 445                 gpiod_unlock_as_irq(desc);
 446                 ret = 0;
 447                 goto free_id;
 448         }
 449
 450         irq_flags = IRQF_SHARED;
 451         if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
 452                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 453                         IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
 454         if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
 455                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 456                         IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
 457
 458         if (!value_sd) {
 459                 value_sd = sysfs_get_dirent(dev->kobj.sd, "value");
 460                 if (!value_sd) {
 461                         ret = -ENODEV;
 462                         goto err_out;
 463                 }
 464
 465                 ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
 466                 if (ret < 0)
 467                         goto free_sd;
 468                 id = ret;
 469
 470                 desc->flags &= GPIO_FLAGS_MASK;
 471                 desc->flags |= (unsigned long)id << ID_SHIFT;
 472
 473                 if (desc->flags >> ID_SHIFT != id) {
 474                         ret = -ERANGE;
 475                         goto free_id;
 476                 }
 477         }
 478
 479         ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
 480                                 "gpiolib", value_sd);
 481         if (ret < 0)
 482                 goto free_id;
 483
 484         ret = gpiod_lock_as_irq(desc);
 485         if (ret < 0) {
 486                 gpiod_warn(desc, "failed to flag the GPIO for IRQ\n");
 487                 goto free_id;
 488         }
 489
 490         desc->flags |= gpio_flags;
 491         return 0;
 492
 493 free_id:
 494         idr_remove(&dirent_idr, id);
 495         desc->flags &= GPIO_FLAGS_MASK;
 496 free_sd:
 497         if (value_sd)
 498                 sysfs_put(value_sd);
 499 err_out:
 500         return ret;
 501 }
 502
 503 static const struct {
 504         const char *name;
 505         unsigned long flags;
 506 } trigger_types[] = {
 507         { "none",    0 },
 508         { "falling", BIT(FLAG_TRIG_FALL) },
 509         { "rising",  BIT(FLAG_TRIG_RISE) },
 510         { "both",    BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
 511 };
 512
 513 static ssize_t gpio_edge_show(struct device *dev,
 514                 struct device_attribute *attr, char *buf)
 515 {
 516         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 517         ssize_t                 status;
 518
 519         mutex_lock(&sysfs_lock);
 520
 521         if (!test_bit(FLAG_EXPORT, &desc->flags))
 522                 status = -EIO;
 523         else {
 524                 int i;
 525
 526                 status = 0;
 527                 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
 528                         if ((desc->flags & GPIO_TRIGGER_MASK)
 529                                         == trigger_types[i].flags) {
 530                                 status = sprintf(buf, "%s\n",
 531                                                  trigger_types[i].name);
 532                                 break;
 533                         }
 534         }
 535
 536         mutex_unlock(&sysfs_lock);
 537         return status;
 538 }
 539
 540 static ssize_t gpio_edge_store(struct device *dev,
 541                 struct device_attribute *attr, const char *buf, size_t size)
 542 {
 543         struct gpio_desc        *desc = dev_get_drvdata(dev);
 544         ssize_t                 status;
 545         int                     i;
 546
 547         for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
 548                 if (sysfs_streq(trigger_types[i].name, buf))
 549                         goto found;
 550         return -EINVAL;
 551
 552 found:
 553         mutex_lock(&sysfs_lock);
 554
 555         if (!test_bit(FLAG_EXPORT, &desc->flags))
 556                 status = -EIO;
 557         else {
 558                 status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
 559                 if (!status)
 560                         status = size;
 561         }
 562
 563         mutex_unlock(&sysfs_lock);
 564
 565         return status;
 566 }
 567
 568 static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
 569
 570 static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
 571                                 int value)
 572 {
 573         int                     status = 0;
 574
 575         if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
 576                 return 0;
 577
 578         if (value)
 579                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 580         else
 581                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
 582
 583         /* reconfigure poll(2) support if enabled on one edge only */
 584         if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
 585                                 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
 586                 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
 587
 588                 gpio_setup_irq(desc, dev, 0);
 589                 status = gpio_setup_irq(desc, dev, trigger_flags);
 590         }
 591
 592         return status;
 593 }
 594
 595 static ssize_t gpio_active_low_show(struct device *dev,
 596                 struct device_attribute *attr, char *buf)
 597 {
 598         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 599         ssize_t                 status;
 600
 601         mutex_lock(&sysfs_lock);
 602
 603         if (!test_bit(FLAG_EXPORT, &desc->flags))
 604                 status = -EIO;
 605         else
 606                 status = sprintf(buf, "%d\n",
 607                                 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
 608
 609         mutex_unlock(&sysfs_lock);
 610
 611         return status;
 612 }
 613
 614 static ssize_t gpio_active_low_store(struct device *dev,
 615                 struct device_attribute *attr, const char *buf, size_t size)
 616 {
 617         struct gpio_desc        *desc = dev_get_drvdata(dev);
 618         ssize_t                 status;
 619
 620         mutex_lock(&sysfs_lock);
 621
 622         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
 623                 status = -EIO;
 624         } else {
 625                 long            value;
 626
 627                 status = kstrtol(buf, 0, &value);
 628                 if (status == 0)
 629                         status = sysfs_set_active_low(desc, dev, value != 0);
 630         }
 631
 632         mutex_unlock(&sysfs_lock);
 633
 634         return status ? : size;
 635 }
 636
 637 static const DEVICE_ATTR(active_low, 0644,
 638                 gpio_active_low_show, gpio_active_low_store);
 639
 640 static const struct attribute *gpio_attrs[] = {
 641         &dev_attr_value.attr,
 642         &dev_attr_active_low.attr,
 643         NULL,
 644 };
 645
 646 static const struct attribute_group gpio_attr_group = {
 647         .attrs = (struct attribute **) gpio_attrs,
 648 };
 649
 650 /*
 651  * /sys/class/gpio/gpiochipN/
 652  *   /base ... matching gpio_chip.base (N)
 653  *   /label ... matching gpio_chip.label
 654  *   /ngpio ... matching gpio_chip.ngpio
 655  */
 656
 657 static ssize_t chip_base_show(struct device *dev,
 658                                struct device_attribute *attr, char *buf)
 659 {
 660         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 661
 662         return sprintf(buf, "%d\n", chip->base);
 663 }
 664 static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
 665
 666 static ssize_t chip_label_show(struct device *dev,
 667                                struct device_attribute *attr, char *buf)
 668 {
 669         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 670
 671         return sprintf(buf, "%s\n", chip->label ? : "");
 672 }
 673 static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
 674
 675 static ssize_t chip_ngpio_show(struct device *dev,
 676                                struct device_attribute *attr, char *buf)
 677 {
 678         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 679
 680         return sprintf(buf, "%u\n", chip->ngpio);
 681 }
 682 static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
 683
 684 static const struct attribute *gpiochip_attrs[] = {
 685         &dev_attr_base.attr,
 686         &dev_attr_label.attr,
 687         &dev_attr_ngpio.attr,
 688         NULL,
 689 };
 690
 691 static const struct attribute_group gpiochip_attr_group = {
 692         .attrs = (struct attribute **) gpiochip_attrs,
 693 };
 694
 695 /*
 696  * /sys/class/gpio/export ... write-only
 697  *      integer N ... number of GPIO to export (full access)
 698  * /sys/class/gpio/unexport ... write-only
 699  *      integer N ... number of GPIO to unexport
 700  */
 701 static ssize_t export_store(struct class *class,
 702                                 struct class_attribute *attr,
 703                                 const char *buf, size_t len)
 704 {
 705         long                    gpio;
 706         struct gpio_desc        *desc;
 707         int                     status;
 708
 709         status = kstrtol(buf, 0, &gpio);
 710         if (status < 0)
 711                 goto done;
 712
 713         desc = gpio_to_desc(gpio);
 714         /* reject invalid GPIOs */
 715         if (!desc) {
 716                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 717                 return -EINVAL;
 718         }
 719
 720         /* No extra locking here; FLAG_SYSFS just signifies that the
 721          * request and export were done by on behalf of userspace, so
 722          * they may be undone on its behalf too.
 723          */
 724
 725         status = gpiod_request(desc, "sysfs");
 726         if (status < 0) {
 727                 if (status == -EPROBE_DEFER)
 728                         status = -ENODEV;
 729                 goto done;
 730         }
 731         status = gpiod_export(desc, true);
 732         if (status < 0)
 733                 gpiod_free(desc);
 734         else
 735                 set_bit(FLAG_SYSFS, &desc->flags);
 736
 737 done:
 738         if (status)
 739                 pr_debug("%s: status %d\n", __func__, status);
 740         return status ? : len;
 741 }
 742
 743 static ssize_t unexport_store(struct class *class,
 744                                 struct class_attribute *attr,
 745                                 const char *buf, size_t len)
 746 {
 747         long                    gpio;
 748         struct gpio_desc        *desc;
 749         int                     status;
 750
 751         status = kstrtol(buf, 0, &gpio);
 752         if (status < 0)
 753                 goto done;
 754
 755         desc = gpio_to_desc(gpio);
 756         /* reject bogus commands (gpio_unexport ignores them) */
 757         if (!desc) {
 758                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 759                 return -EINVAL;
 760         }
 761
 762         status = -EINVAL;
 763
 764         /* No extra locking here; FLAG_SYSFS just signifies that the
 765          * request and export were done by on behalf of userspace, so
 766          * they may be undone on its behalf too.
 767          */
 768         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
 769                 status = 0;
 770                 gpiod_free(desc);
 771         }
 772 done:
 773         if (status)
 774                 pr_debug("%s: status %d\n", __func__, status);
 775         return status ? : len;
 776 }
 777
 778 static struct class_attribute gpio_class_attrs[] = {
 779         __ATTR(export, 0200, NULL, export_store),
 780         __ATTR(unexport, 0200, NULL, unexport_store),
 781         __ATTR_NULL,
 782 };
 783
 784 static struct class gpio_class = {
 785         .name =         "gpio",
 786         .owner =        THIS_MODULE,
 787
 788         .class_attrs =  gpio_class_attrs,
 789 };
 790
 791
 792 /**
 793  * gpiod_export - export a GPIO through sysfs
 794  * @gpio: gpio to make available, already requested
 795  * @direction_may_change: true if userspace may change gpio direction
 796  * Context: arch_initcall or later
 797  *
 798  * When drivers want to make a GPIO accessible to userspace after they
 799  * have requested it -- perhaps while debugging, or as part of their
 800  * public interface -- they may use this routine.  If the GPIO can
 801  * change direction (some can't) and the caller allows it, userspace
 802  * will see "direction" sysfs attribute which may be used to change
 803  * the gpio's direction.  A "value" attribute will always be provided.
 804  *
 805  * Returns zero on success, else an error.
 806  */
 807 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 808 {
 809         unsigned long           flags;
 810         int                     status;
 811         const char              *ioname = NULL;
 812         struct device           *dev;
 813         int                     offset;
 814
 815         /* can't export until sysfs is available ... */
 816         if (!gpio_class.p) {
 817                 pr_debug("%s: called too early!\n", __func__);
 818                 return -ENOENT;
 819         }
 820
 821         if (!desc) {
 822                 pr_debug("%s: invalid gpio descriptor\n", __func__);
 823                 return -EINVAL;
 824         }
 825
 826         mutex_lock(&sysfs_lock);
 827
 828         spin_lock_irqsave(&gpio_lock, flags);
 829         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
 830              test_bit(FLAG_EXPORT, &desc->flags)) {
 831                 spin_unlock_irqrestore(&gpio_lock, flags);
 832                 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
 833                                 __func__,
 834                                 test_bit(FLAG_REQUESTED, &desc->flags),
 835                                 test_bit(FLAG_EXPORT, &desc->flags));
 836                 status = -EPERM;
 837                 goto fail_unlock;
 838         }
 839
 840         if (!desc->chip->direction_input || !desc->chip->direction_output)
 841                 direction_may_change = false;
 842         spin_unlock_irqrestore(&gpio_lock, flags);
 843
 844         offset = gpio_chip_hwgpio(desc);
 845         if (desc->chip->names && desc->chip->names[offset])
 846                 ioname = desc->chip->names[offset];
 847
 848         dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
 849                             desc, ioname ? ioname : "gpio%u",
 850                             desc_to_gpio(desc));
 851         if (IS_ERR(dev)) {
 852                 status = PTR_ERR(dev);
 853                 goto fail_unlock;
 854         }
 855
 856         status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
 857         if (status)
 858                 goto fail_unregister_device;
 859
 860         if (direction_may_change) {
 861                 status = device_create_file(dev, &dev_attr_direction);
 862                 if (status)
 863                         goto fail_unregister_device;
 864         }
 865
 866         if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
 867                                        !test_bit(FLAG_IS_OUT, &desc->flags))) {
 868                 status = device_create_file(dev, &dev_attr_edge);
 869                 if (status)
 870                         goto fail_unregister_device;
 871         }
 872
 873         set_bit(FLAG_EXPORT, &desc->flags);
 874         mutex_unlock(&sysfs_lock);
 875         return 0;
 876
 877 fail_unregister_device:
 878         device_unregister(dev);
 879 fail_unlock:
 880         mutex_unlock(&sysfs_lock);
 881         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 882         return status;
 883 }
 884 EXPORT_SYMBOL_GPL(gpiod_export);
 885
 886 static int match_export(struct device *dev, const void *data)
 887 {
 888         return dev_get_drvdata(dev) == data;
 889 }
 890
 891 /**
 892  * gpiod_export_link - create a sysfs link to an exported GPIO node
 893  * @dev: device under which to create symlink
 894  * @name: name of the symlink
 895  * @gpio: gpio to create symlink to, already exported
 896  *
 897  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 898  * node. Caller is responsible for unlinking.
 899  *
 900  * Returns zero on success, else an error.
 901  */
 902 int gpiod_export_link(struct device *dev, const char *name,
 903                       struct gpio_desc *desc)
 904 {
 905         int                     status = -EINVAL;
 906
 907         if (!desc) {
 908                 pr_warn("%s: invalid GPIO\n", __func__);
 909                 return -EINVAL;
 910         }
 911
 912         mutex_lock(&sysfs_lock);
 913
 914         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 915                 struct device *tdev;
 916
 917                 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
 918                 if (tdev != NULL) {
 919                         status = sysfs_create_link(&dev->kobj, &tdev->kobj,
 920                                                 name);
 921                 } else {
 922                         status = -ENODEV;
 923                 }
 924         }
 925
 926         mutex_unlock(&sysfs_lock);
 927
 928         if (status)
 929                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 930
 931         return status;
 932 }
 933 EXPORT_SYMBOL_GPL(gpiod_export_link);
 934
 935 /**
 936  * gpiod_sysfs_set_active_low - set the polarity of gpio sysfs value
 937  * @gpio: gpio to change
 938  * @value: non-zero to use active low, i.e. inverted values
 939  *
 940  * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
 941  * The GPIO does not have to be exported yet.  If poll(2) support has
 942  * been enabled for either rising or falling edge, it will be
 943  * reconfigured to follow the new polarity.
 944  *
 945  * Returns zero on success, else an error.
 946  */
 947 int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
 948 {
 949         struct device           *dev = NULL;
 950         int                     status = -EINVAL;
 951
 952         if (!desc) {
 953                 pr_warn("%s: invalid GPIO\n", __func__);
 954                 return -EINVAL;
 955         }
 956
 957         mutex_lock(&sysfs_lock);
 958
 959         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 960                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
 961                 if (dev == NULL) {
 962                         status = -ENODEV;
 963                         goto unlock;
 964                 }
 965         }
 966
 967         status = sysfs_set_active_low(desc, dev, value);
 968
 969 unlock:
 970         mutex_unlock(&sysfs_lock);
 971
 972         if (status)
 973                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 974
 975         return status;
 976 }
 977 EXPORT_SYMBOL_GPL(gpiod_sysfs_set_active_low);
 978
 979 /**
 980  * gpiod_unexport - reverse effect of gpio_export()
 981  * @gpio: gpio to make unavailable
 982  *
 983  * This is implicit on gpio_free().
 984  */
 985 void gpiod_unexport(struct gpio_desc *desc)
 986 {
 987         int                     status = 0;
 988         struct device           *dev = NULL;
 989
 990         if (!desc) {
 991                 pr_warn("%s: invalid GPIO\n", __func__);
 992                 return;
 993         }
 994
 995         mutex_lock(&sysfs_lock);
 996
 997         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 998
 999                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
1000                 if (dev) {
1001                         gpio_setup_irq(desc, dev, 0);
1002                         clear_bit(FLAG_EXPORT, &desc->flags);
1003                 } else
1004                         status = -ENODEV;
1005         }
1006
1007         mutex_unlock(&sysfs_lock);
1008
1009         if (dev) {
1010                 device_unregister(dev);
1011                 put_device(dev);
1012         }
1013
1014         if (status)
1015                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1016 }
1017 EXPORT_SYMBOL_GPL(gpiod_unexport);
1018
1019 static int gpiochip_export(struct gpio_chip *chip)
1020 {
1021         int             status;
1022         struct device   *dev;
1023
1024         /* Many systems register gpio chips for SOC support very early,
1025          * before driver model support is available.  In those cases we
1026          * export this later, in gpiolib_sysfs_init() ... here we just
1027          * verify that _some_ field of gpio_class got initialized.
1028          */
1029         if (!gpio_class.p)
1030                 return 0;
1031
1032         /* use chip->base for the ID; it's already known to be unique */
1033         mutex_lock(&sysfs_lock);
1034         dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
1035                                 "gpiochip%d", chip->base);
1036         if (!IS_ERR(dev)) {
1037                 status = sysfs_create_group(&dev->kobj,
1038                                 &gpiochip_attr_group);
1039         } else
1040                 status = PTR_ERR(dev);
1041         chip->exported = (status == 0);
1042         mutex_unlock(&sysfs_lock);
1043
1044         if (status) {
1045                 unsigned long   flags;
1046                 unsigned        gpio;
1047
1048                 spin_lock_irqsave(&gpio_lock, flags);
1049                 gpio = 0;
1050                 while (gpio < chip->ngpio)
1051                         chip->desc[gpio++].chip = NULL;
1052                 spin_unlock_irqrestore(&gpio_lock, flags);
1053
1054                 chip_dbg(chip, "%s: status %d\n", __func__, status);
1055         }
1056
1057         return status;
1058 }
1059
1060 static void gpiochip_unexport(struct gpio_chip *chip)
1061 {
1062         int                     status;
1063         struct device           *dev;
1064
1065         mutex_lock(&sysfs_lock);
1066         dev = class_find_device(&gpio_class, NULL, chip, match_export);
1067         if (dev) {
1068                 put_device(dev);
1069                 device_unregister(dev);
1070                 chip->exported = false;
1071                 status = 0;
1072         } else
1073                 status = -ENODEV;
1074         mutex_unlock(&sysfs_lock);
1075
1076         if (status)
1077                 chip_dbg(chip, "%s: status %d\n", __func__, status);
1078 }
1079
1080 static int __init gpiolib_sysfs_init(void)
1081 {
1082         int             status;
1083         unsigned long   flags;
1084         struct gpio_chip *chip;
1085
1086         status = class_register(&gpio_class);
1087         if (status < 0)
1088                 return status;
1089
1090         /* Scan and register the gpio_chips which registered very
1091          * early (e.g. before the class_register above was called).
1092          *
1093          * We run before arch_initcall() so chip->dev nodes can have
1094          * registered, and so arch_initcall() can always gpio_export().
1095          */
1096         spin_lock_irqsave(&gpio_lock, flags);
1097         list_for_each_entry(chip, &gpio_chips, list) {
1098                 if (!chip || chip->exported)
1099                         continue;
1100
1101                 spin_unlock_irqrestore(&gpio_lock, flags);
1102                 status = gpiochip_export(chip);
1103                 spin_lock_irqsave(&gpio_lock, flags);
1104         }
1105         spin_unlock_irqrestore(&gpio_lock, flags);
1106
1107
1108         return status;
1109 }
1110 postcore_initcall(gpiolib_sysfs_init);
1111
1112 #else
1113 static inline int gpiochip_export(struct gpio_chip *chip)
1114 {
1115         return 0;
1116 }
1117
1118 static inline void gpiochip_unexport(struct gpio_chip *chip)
1119 {
1120 }
1121
1122 #endif /* CONFIG_GPIO_SYSFS */
1123
1124 /*
1125  * Add a new chip to the global chips list, keeping the list of chips sorted
1126  * by base order.
1127  *
1128  * Return -EBUSY if the new chip overlaps with some other chip's integer
1129  * space.
1130  */
1131 static int gpiochip_add_to_list(struct gpio_chip *chip)
1132 {
1133         struct list_head *pos = &gpio_chips;
1134         struct gpio_chip *_chip;
1135         int err = 0;
1136
1137         /* find where to insert our chip */
1138         list_for_each(pos, &gpio_chips) {
1139                 _chip = list_entry(pos, struct gpio_chip, list);
1140                 /* shall we insert before _chip? */
1141                 if (_chip->base >= chip->base + chip->ngpio)
1142                         break;
1143         }
1144
1145         /* are we stepping on the chip right before? */
1146         if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1147                 _chip = list_entry(pos->prev, struct gpio_chip, list);
1148                 if (_chip->base + _chip->ngpio > chip->base) {
1149                         dev_err(chip->dev,
1150                                "GPIO integer space overlap, cannot add chip\n");
1151                         err = -EBUSY;
1152                 }
1153         }
1154
1155         if (!err)
1156                 list_add_tail(&chip->list, pos);
1157
1158         return err;
1159 }
1160
1161 /**
1162  * gpiochip_add() - register a gpio_chip
1163  * @chip: the chip to register, with chip->base initialized
1164  * Context: potentially before irqs or kmalloc will work
1165  *
1166  * Returns a negative errno if the chip can't be registered, such as
1167  * because the chip->base is invalid or already associated with a
1168  * different chip.  Otherwise it returns zero as a success code.
1169  *
1170  * When gpiochip_add() is called very early during boot, so that GPIOs
1171  * can be freely used, the chip->dev device must be registered before
1172  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
1173  * for GPIOs will fail rudely.
1174  *
1175  * If chip->base is negative, this requests dynamic assignment of
1176  * a range of valid GPIOs.
1177  */
1178 int gpiochip_add(struct gpio_chip *chip)
1179 {
1180         unsigned long   flags;
1181         int             status = 0;
1182         unsigned        id;
1183         int             base = chip->base;
1184
1185         if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
1186                         && base >= 0) {
1187                 status = -EINVAL;
1188                 goto fail;
1189         }
1190
1191         spin_lock_irqsave(&gpio_lock, flags);
1192
1193         if (base < 0) {
1194                 base = gpiochip_find_base(chip->ngpio);
1195                 if (base < 0) {
1196                         status = base;
1197                         goto unlock;
1198                 }
1199                 chip->base = base;
1200         }
1201
1202         status = gpiochip_add_to_list(chip);
1203
1204         if (status == 0) {
1205                 chip->desc = &gpio_desc[chip->base];
1206
1207                 for (id = 0; id < chip->ngpio; id++) {
1208                         struct gpio_desc *desc = &chip->desc[id];
1209                         desc->chip = chip;
1210
1211                         /* REVISIT:  most hardware initializes GPIOs as
1212                          * inputs (often with pullups enabled) so power
1213                          * usage is minimized.  Linux code should set the
1214                          * gpio direction first thing; but until it does,
1215                          * and in case chip->get_direction is not set,
1216                          * we may expose the wrong direction in sysfs.
1217                          */
1218                         desc->flags = !chip->direction_input
1219                                 ? (1 << FLAG_IS_OUT)
1220                                 : 0;
1221                 }
1222         }
1223
1224         spin_unlock_irqrestore(&gpio_lock, flags);
1225
1226 #ifdef CONFIG_PINCTRL
1227         INIT_LIST_HEAD(&chip->pin_ranges);
1228 #endif
1229
1230         of_gpiochip_add(chip);
1231         acpi_gpiochip_add(chip);
1232
1233         if (status)
1234                 goto fail;
1235
1236         status = gpiochip_export(chip);
1237         if (status)
1238                 goto fail;
1239
1240         pr_debug("%s: registered GPIOs %d to %d on device: %s\n", __func__,
1241                 chip->base, chip->base + chip->ngpio - 1,
1242                 chip->label ? : "generic");
1243
1244         return 0;
1245
1246 unlock:
1247         spin_unlock_irqrestore(&gpio_lock, flags);
1248 fail:
1249         /* failures here can mean systems won't boot... */
1250         pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1251                 chip->base, chip->base + chip->ngpio - 1,
1252                 chip->label ? : "generic");
1253         return status;
1254 }
1255 EXPORT_SYMBOL_GPL(gpiochip_add);
1256
1257 /**
1258  * gpiochip_remove() - unregister a gpio_chip
1259  * @chip: the chip to unregister
1260  *
1261  * A gpio_chip with any GPIOs still requested may not be removed.
1262  */
1263 int gpiochip_remove(struct gpio_chip *chip)
1264 {
1265         unsigned long   flags;
1266         int             status = 0;
1267         unsigned        id;
1268
1269         spin_lock_irqsave(&gpio_lock, flags);
1270
1271         gpiochip_remove_pin_ranges(chip);
1272         of_gpiochip_remove(chip);
1273         acpi_gpiochip_remove(chip);
1274
1275         for (id = 0; id < chip->ngpio; id++) {
1276                 if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
1277                         status = -EBUSY;
1278                         break;
1279                 }
1280         }
1281         if (status == 0) {
1282                 for (id = 0; id < chip->ngpio; id++)
1283                         chip->desc[id].chip = NULL;
1284
1285                 list_del(&chip->list);
1286         }
1287
1288         spin_unlock_irqrestore(&gpio_lock, flags);
1289
1290         if (status == 0)
1291                 gpiochip_unexport(chip);
1292
1293         return status;
1294 }
1295 EXPORT_SYMBOL_GPL(gpiochip_remove);
1296
1297 /**
1298  * gpiochip_find() - iterator for locating a specific gpio_chip
1299  * @data: data to pass to match function
1300  * @callback: Callback function to check gpio_chip
1301  *
1302  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1303  * determined by a user supplied @match callback.  The callback should return
1304  * 0 if the device doesn't match and non-zero if it does.  If the callback is
1305  * non-zero, this function will return to the caller and not iterate over any
1306  * more gpio_chips.
1307  */
1308 struct gpio_chip *gpiochip_find(void *data,
1309                                 int (*match)(struct gpio_chip *chip,
1310                                              void *data))
1311 {
1312         struct gpio_chip *chip;
1313         unsigned long flags;
1314
1315         spin_lock_irqsave(&gpio_lock, flags);
1316         list_for_each_entry(chip, &gpio_chips, list)
1317                 if (match(chip, data))
1318                         break;
1319
1320         /* No match? */
1321         if (&chip->list == &gpio_chips)
1322                 chip = NULL;
1323         spin_unlock_irqrestore(&gpio_lock, flags);
1324
1325         return chip;
1326 }
1327 EXPORT_SYMBOL_GPL(gpiochip_find);
1328
1329 static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1330 {
1331         const char *name = data;
1332
1333         return !strcmp(chip->label, name);
1334 }
1335
1336 static struct gpio_chip *find_chip_by_name(const char *name)
1337 {
1338         return gpiochip_find((void *)name, gpiochip_match_name);
1339 }
1340
1341 #ifdef CONFIG_PINCTRL
1342
1343 /**
1344  * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
1345  * @chip: the gpiochip to add the range for
1346  * @pinctrl: the dev_name() of the pin controller to map to
1347  * @gpio_offset: the start offset in the current gpio_chip number space
1348  * @pin_group: name of the pin group inside the pin controller
1349  */
1350 int gpiochip_add_pingroup_range(struct gpio_chip *chip,
1351                         struct pinctrl_dev *pctldev,
1352                         unsigned int gpio_offset, const char *pin_group)
1353 {
1354         struct gpio_pin_range *pin_range;
1355         int ret;
1356
1357         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1358         if (!pin_range) {
1359                 chip_err(chip, "failed to allocate pin ranges\n");
1360                 return -ENOMEM;
1361         }
1362
1363         /* Use local offset as range ID */
1364         pin_range->range.id = gpio_offset;
1365         pin_range->range.gc = chip;
1366         pin_range->range.name = chip->label;
1367         pin_range->range.base = chip->base + gpio_offset;
1368         pin_range->pctldev = pctldev;
1369
1370         ret = pinctrl_get_group_pins(pctldev, pin_group,
1371                                         &pin_range->range.pins,
1372                                         &pin_range->range.npins);
1373         if (ret < 0) {
1374                 kfree(pin_range);
1375                 return ret;
1376         }
1377
1378         pinctrl_add_gpio_range(pctldev, &pin_range->range);
1379
1380         chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
1381                  gpio_offset, gpio_offset + pin_range->range.npins - 1,
1382                  pinctrl_dev_get_devname(pctldev), pin_group);
1383
1384         list_add_tail(&pin_range->node, &chip->pin_ranges);
1385
1386         return 0;
1387 }
1388 EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
1389
1390 /**
1391  * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1392  * @chip: the gpiochip to add the range for
1393  * @pinctrl_name: the dev_name() of the pin controller to map to
1394  * @gpio_offset: the start offset in the current gpio_chip number space
1395  * @pin_offset: the start offset in the pin controller number space
1396  * @npins: the number of pins from the offset of each pin space (GPIO and
1397  *      pin controller) to accumulate in this range
1398  */
1399 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1400                            unsigned int gpio_offset, unsigned int pin_offset,
1401                            unsigned int npins)
1402 {
1403         struct gpio_pin_range *pin_range;
1404         int ret;
1405
1406         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1407         if (!pin_range) {
1408                 chip_err(chip, "failed to allocate pin ranges\n");
1409                 return -ENOMEM;
1410         }
1411
1412         /* Use local offset as range ID */
1413         pin_range->range.id = gpio_offset;
1414         pin_range->range.gc = chip;
1415         pin_range->range.name = chip->label;
1416         pin_range->range.base = chip->base + gpio_offset;
1417         pin_range->range.pin_base = pin_offset;
1418         pin_range->range.npins = npins;
1419         pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1420                         &pin_range->range);
1421         if (IS_ERR(pin_range->pctldev)) {
1422                 ret = PTR_ERR(pin_range->pctldev);
1423                 chip_err(chip, "could not create pin range\n");
1424                 kfree(pin_range);
1425                 return ret;
1426         }
1427         chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
1428                  gpio_offset, gpio_offset + npins - 1,
1429                  pinctl_name,
1430                  pin_offset, pin_offset + npins - 1);
1431
1432         list_add_tail(&pin_range->node, &chip->pin_ranges);
1433
1434         return 0;
1435 }
1436 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1437
1438 /**
1439  * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1440  * @chip: the chip to remove all the mappings for
1441  */
1442 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1443 {
1444         struct gpio_pin_range *pin_range, *tmp;
1445
1446         list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1447                 list_del(&pin_range->node);
1448                 pinctrl_remove_gpio_range(pin_range->pctldev,
1449                                 &pin_range->range);
1450                 kfree(pin_range);
1451         }
1452 }
1453 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1454
1455 #endif /* CONFIG_PINCTRL */
1456
1457 /* These "optional" allocation calls help prevent drivers from stomping
1458  * on each other, and help provide better diagnostics in debugfs.
1459  * They're called even less than the "set direction" calls.
1460  */
1461 static int gpiod_request(struct gpio_desc *desc, const char *label)
1462 {
1463         struct gpio_chip        *chip;
1464         int                     status = -EPROBE_DEFER;
1465         unsigned long           flags;
1466
1467         if (!desc) {
1468                 pr_warn("%s: invalid GPIO\n", __func__);
1469                 return -EINVAL;
1470         }
1471
1472         spin_lock_irqsave(&gpio_lock, flags);
1473
1474         chip = desc->chip;
1475         if (chip == NULL)
1476                 goto done;
1477
1478         if (!try_module_get(chip->owner))
1479                 goto done;
1480
1481         /* NOTE:  gpio_request() can be called in early boot,
1482          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1483          */
1484
1485         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1486                 desc_set_label(desc, label ? : "?");
1487                 status = 0;
1488         } else {
1489                 status = -EBUSY;
1490                 module_put(chip->owner);
1491                 goto done;
1492         }
1493
1494         if (chip->request) {
1495                 /* chip->request may sleep */
1496                 spin_unlock_irqrestore(&gpio_lock, flags);
1497                 status = chip->request(chip, gpio_chip_hwgpio(desc));
1498                 spin_lock_irqsave(&gpio_lock, flags);
1499
1500                 if (status < 0) {
1501                         desc_set_label(desc, NULL);
1502                         module_put(chip->owner);
1503                         clear_bit(FLAG_REQUESTED, &desc->flags);
1504                         goto done;
1505                 }
1506         }
1507         if (chip->get_direction) {
1508                 /* chip->get_direction may sleep */
1509                 spin_unlock_irqrestore(&gpio_lock, flags);
1510                 gpiod_get_direction(desc);
1511                 spin_lock_irqsave(&gpio_lock, flags);
1512         }
1513 done:
1514         if (status)
1515                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1516         spin_unlock_irqrestore(&gpio_lock, flags);
1517         return status;
1518 }
1519
1520 int gpio_request(unsigned gpio, const char *label)
1521 {
1522         return gpiod_request(gpio_to_desc(gpio), label);
1523 }
1524 EXPORT_SYMBOL_GPL(gpio_request);
1525
1526 static void gpiod_free(struct gpio_desc *desc)
1527 {
1528         unsigned long           flags;
1529         struct gpio_chip        *chip;
1530
1531         might_sleep();
1532
1533         if (!desc) {
1534                 WARN_ON(extra_checks);
1535                 return;
1536         }
1537
1538         gpiod_unexport(desc);
1539
1540         spin_lock_irqsave(&gpio_lock, flags);
1541
1542         chip = desc->chip;
1543         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1544                 if (chip->free) {
1545                         spin_unlock_irqrestore(&gpio_lock, flags);
1546                         might_sleep_if(chip->can_sleep);
1547                         chip->free(chip, gpio_chip_hwgpio(desc));
1548                         spin_lock_irqsave(&gpio_lock, flags);
1549                 }
1550                 desc_set_label(desc, NULL);
1551                 module_put(desc->chip->owner);
1552                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1553                 clear_bit(FLAG_REQUESTED, &desc->flags);
1554                 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1555                 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
1556         } else
1557                 WARN_ON(extra_checks);
1558
1559         spin_unlock_irqrestore(&gpio_lock, flags);
1560 }
1561
1562 void gpio_free(unsigned gpio)
1563 {
1564         gpiod_free(gpio_to_desc(gpio));
1565 }
1566 EXPORT_SYMBOL_GPL(gpio_free);
1567
1568 /**
1569  * gpio_request_one - request a single GPIO with initial configuration
1570  * @gpio:       the GPIO number
1571  * @flags:      GPIO configuration as specified by GPIOF_*
1572  * @label:      a literal description string of this GPIO
1573  */
1574 int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1575 {
1576         struct gpio_desc *desc;
1577         int err;
1578
1579         desc = gpio_to_desc(gpio);
1580
1581         err = gpiod_request(desc, label);
1582         if (err)
1583                 return err;
1584
1585         if (flags & GPIOF_OPEN_DRAIN)
1586                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
1587
1588         if (flags & GPIOF_OPEN_SOURCE)
1589                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
1590
1591         if (flags & GPIOF_DIR_IN)
1592                 err = gpiod_direction_input(desc);
1593         else
1594                 err = gpiod_direction_output_raw(desc,
1595                                 (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1596
1597         if (err)
1598                 goto free_gpio;
1599
1600         if (flags & GPIOF_EXPORT) {
1601                 err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
1602                 if (err)
1603                         goto free_gpio;
1604         }
1605
1606         return 0;
1607
1608  free_gpio:
1609         gpiod_free(desc);
1610         return err;
1611 }
1612 EXPORT_SYMBOL_GPL(gpio_request_one);
1613
1614 /**
1615  * gpio_request_array - request multiple GPIOs in a single call
1616  * @array:      array of the 'struct gpio'
1617  * @num:        how many GPIOs in the array
1618  */
1619 int gpio_request_array(const struct gpio *array, size_t num)
1620 {
1621         int i, err;
1622
1623         for (i = 0; i < num; i++, array++) {
1624                 err = gpio_request_one(array->gpio, array->flags, array->label);
1625                 if (err)
1626                         goto err_free;
1627         }
1628         return 0;
1629
1630 err_free:
1631         while (i--)
1632                 gpio_free((--array)->gpio);
1633         return err;
1634 }
1635 EXPORT_SYMBOL_GPL(gpio_request_array);
1636
1637 /**
1638  * gpio_free_array - release multiple GPIOs in a single call
1639  * @array:      array of the 'struct gpio'
1640  * @num:        how many GPIOs in the array
1641  */
1642 void gpio_free_array(const struct gpio *array, size_t num)
1643 {
1644         while (num--)
1645                 gpio_free((array++)->gpio);
1646 }
1647 EXPORT_SYMBOL_GPL(gpio_free_array);
1648
1649 /**
1650  * gpiochip_is_requested - return string iff signal was requested
1651  * @chip: controller managing the signal
1652  * @offset: of signal within controller's 0..(ngpio - 1) range
1653  *
1654  * Returns NULL if the GPIO is not currently requested, else a string.
1655  * If debugfs support is enabled, the string returned is the label passed
1656  * to gpio_request(); otherwise it is a meaningless constant.
1657  *
1658  * This function is for use by GPIO controller drivers.  The label can
1659  * help with diagnostics, and knowing that the signal is used as a GPIO
1660  * can help avoid accidentally multiplexing it to another controller.
1661  */
1662 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1663 {
1664         struct gpio_desc *desc;
1665
1666         if (!GPIO_OFFSET_VALID(chip, offset))
1667                 return NULL;
1668
1669         desc = &chip->desc[offset];
1670
1671         if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
1672                 return NULL;
1673 #ifdef CONFIG_DEBUG_FS
1674         return desc->label;
1675 #else
1676         return "?";
1677 #endif
1678 }
1679 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1680
1681
1682 /* Drivers MUST set GPIO direction before making get/set calls.  In
1683  * some cases this is done in early boot, before IRQs are enabled.
1684  *
1685  * As a rule these aren't called more than once (except for drivers
1686  * using the open-drain emulation idiom) so these are natural places
1687  * to accumulate extra debugging checks.  Note that we can't (yet)
1688  * rely on gpio_request() having been called beforehand.
1689  */
1690
1691 /**
1692  * gpiod_direction_input - set the GPIO direction to input
1693  * @desc:       GPIO to set to input
1694  *
1695  * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
1696  * be called safely on it.
1697  *
1698  * Return 0 in case of success, else an error code.
1699  */
1700 int gpiod_direction_input(struct gpio_desc *desc)
1701 {
1702         unsigned long           flags;
1703         struct gpio_chip        *chip;
1704         int                     status = -EINVAL;
1705         int                     offset;
1706
1707         if (!desc || !desc->chip) {
1708                 pr_warn("%s: invalid GPIO\n", __func__);
1709                 return -EINVAL;
1710         }
1711
1712         chip = desc->chip;
1713         if (!chip->get || !chip->direction_input) {
1714                 gpiod_warn(desc,
1715                         "%s: missing get() or direction_input() operations\n",
1716                         __func__);
1717                 return -EIO;
1718         }
1719
1720         spin_lock_irqsave(&gpio_lock, flags);
1721
1722         status = gpio_ensure_requested(desc);
1723         if (status < 0)
1724                 goto fail;
1725
1726         /* now we know the gpio is valid and chip won't vanish */
1727
1728         spin_unlock_irqrestore(&gpio_lock, flags);
1729
1730         might_sleep_if(chip->can_sleep);
1731
1732         offset = gpio_chip_hwgpio(desc);
1733         if (status) {
1734                 status = chip->request(chip, offset);
1735                 if (status < 0) {
1736                         gpiod_dbg(desc, "%s: chip request fail, %d\n",
1737                                         __func__, status);
1738                         /* and it's not available to anyone else ...
1739                          * gpio_request() is the fully clean solution.
1740                          */
1741                         goto lose;
1742                 }
1743         }
1744
1745         status = chip->direction_input(chip, offset);
1746         if (status == 0)
1747                 clear_bit(FLAG_IS_OUT, &desc->flags);
1748
1749         trace_gpio_direction(desc_to_gpio(desc), 1, status);
1750 lose:
1751         return status;
1752 fail:
1753         spin_unlock_irqrestore(&gpio_lock, flags);
1754         if (status)
1755                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1756         return status;
1757 }
1758 EXPORT_SYMBOL_GPL(gpiod_direction_input);
1759
1760 static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
1761 {
1762         unsigned long           flags;
1763         struct gpio_chip        *chip;
1764         int                     status = -EINVAL;
1765         int offset;
1766
1767         /* GPIOs used for IRQs shall not be set as output */
1768         if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
1769                 gpiod_err(desc,
1770                           "%s: tried to set a GPIO tied to an IRQ as output\n",
1771                           __func__);
1772                 return -EIO;
1773         }
1774
1775         /* Open drain pin should not be driven to 1 */
1776         if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
1777                 return gpiod_direction_input(desc);
1778
1779         /* Open source pin should not be driven to 0 */
1780         if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
1781                 return gpiod_direction_input(desc);
1782
1783         chip = desc->chip;
1784         if (!chip->set || !chip->direction_output) {
1785                 gpiod_warn(desc,
1786                        "%s: missing set() or direction_output() operations\n",
1787                        __func__);
1788                 return -EIO;
1789         }
1790
1791         spin_lock_irqsave(&gpio_lock, flags);
1792
1793         status = gpio_ensure_requested(desc);
1794         if (status < 0)
1795                 goto fail;
1796
1797         /* now we know the gpio is valid and chip won't vanish */
1798
1799         spin_unlock_irqrestore(&gpio_lock, flags);
1800
1801         might_sleep_if(chip->can_sleep);
1802
1803         offset = gpio_chip_hwgpio(desc);
1804         if (status) {
1805                 status = chip->request(chip, offset);
1806                 if (status < 0) {
1807                         gpiod_dbg(desc, "%s: chip request fail, %d\n",
1808                                         __func__, status);
1809                         /* and it's not available to anyone else ...
1810                          * gpio_request() is the fully clean solution.
1811                          */
1812                         goto lose;
1813                 }
1814         }
1815
1816         status = chip->direction_output(chip, offset, value);
1817         if (status == 0)
1818                 set_bit(FLAG_IS_OUT, &desc->flags);
1819         trace_gpio_value(desc_to_gpio(desc), 0, value);
1820         trace_gpio_direction(desc_to_gpio(desc), 0, status);
1821 lose:
1822         return status;
1823 fail:
1824         spin_unlock_irqrestore(&gpio_lock, flags);
1825         if (status)
1826                 gpiod_dbg(desc, "%s: gpio status %d\n", __func__, status);
1827         return status;
1828 }
1829
1830 /**
1831  * gpiod_direction_output_raw - set the GPIO direction to output
1832  * @desc:       GPIO to set to output
1833  * @value:      initial output value of the GPIO
1834  *
1835  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
1836  * be called safely on it. The initial value of the output must be specified
1837  * as raw value on the physical line without regard for the ACTIVE_LOW status.
1838  *
1839  * Return 0 in case of success, else an error code.
1840  */
1841 int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
1842 {
1843         if (!desc || !desc->chip) {
1844                 pr_warn("%s: invalid GPIO\n", __func__);
1845                 return -EINVAL;
1846         }
1847         return _gpiod_direction_output_raw(desc, value);
1848 }
1849 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
1850
1851 /**
1852  * gpiod_direction_output - set the GPIO direction to input
1853  * @desc:       GPIO to set to output
1854  * @value:      initial output value of the GPIO
1855  *
1856  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
1857  * be called safely on it. The initial value of the output must be specified
1858  * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
1859  * account.
1860  *
1861  * Return 0 in case of success, else an error code.
1862  */
1863 int gpiod_direction_output(struct gpio_desc *desc, int value)
1864 {
1865         if (!desc || !desc->chip) {
1866                 pr_warn("%s: invalid GPIO\n", __func__);
1867                 return -EINVAL;
1868         }
1869         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1870                 value = !value;
1871         return _gpiod_direction_output_raw(desc, value);
1872 }
1873 EXPORT_SYMBOL_GPL(gpiod_direction_output);
1874
1875 /**
1876  * gpiod_set_debounce - sets @debounce time for a @gpio
1877  * @gpio: the gpio to set debounce time
1878  * @debounce: debounce time is microseconds
1879  *
1880  * returns -ENOTSUPP if the controller does not support setting
1881  * debounce.
1882  */
1883 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
1884 {
1885         unsigned long           flags;
1886         struct gpio_chip        *chip;
1887         int                     status = -EINVAL;
1888         int                     offset;
1889
1890         if (!desc || !desc->chip) {
1891                 pr_warn("%s: invalid GPIO\n", __func__);
1892                 return -EINVAL;
1893         }
1894
1895         chip = desc->chip;
1896         if (!chip->set || !chip->set_debounce) {
1897                 gpiod_dbg(desc,
1898                           "%s: missing set() or set_debounce() operations\n",
1899                           __func__);
1900                 return -ENOTSUPP;
1901         }
1902
1903         spin_lock_irqsave(&gpio_lock, flags);
1904
1905         status = gpio_ensure_requested(desc);
1906         if (status < 0)
1907                 goto fail;
1908
1909         /* now we know the gpio is valid and chip won't vanish */
1910
1911         spin_unlock_irqrestore(&gpio_lock, flags);
1912
1913         might_sleep_if(chip->can_sleep);
1914
1915         offset = gpio_chip_hwgpio(desc);
1916         return chip->set_debounce(chip, offset, debounce);
1917
1918 fail:
1919         spin_unlock_irqrestore(&gpio_lock, flags);
1920         if (status)
1921                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1922
1923         return status;
1924 }
1925 EXPORT_SYMBOL_GPL(gpiod_set_debounce);
1926
1927 /**
1928  * gpiod_is_active_low - test whether a GPIO is active-low or not
1929  * @desc: the gpio descriptor to test
1930  *
1931  * Returns 1 if the GPIO is active-low, 0 otherwise.
1932  */
1933 int gpiod_is_active_low(const struct gpio_desc *desc)
1934 {
1935         return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
1936 }
1937 EXPORT_SYMBOL_GPL(gpiod_is_active_low);
1938
1939 /* I/O calls are only valid after configuration completed; the relevant
1940  * "is this a valid GPIO" error checks should already have been done.
1941  *
1942  * "Get" operations are often inlinable as reading a pin value register,
1943  * and masking the relevant bit in that register.
1944  *
1945  * When "set" operations are inlinable, they involve writing that mask to
1946  * one register to set a low value, or a different register to set it high.
1947  * Otherwise locking is needed, so there may be little value to inlining.
1948  *
1949  *------------------------------------------------------------------------
1950  *
1951  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
1952  * have requested the GPIO.  That can include implicit requesting by
1953  * a direction setting call.  Marking a gpio as requested locks its chip
1954  * in memory, guaranteeing that these table lookups need no more locking
1955  * and that gpiochip_remove() will fail.
1956  *
1957  * REVISIT when debugging, consider adding some instrumentation to ensure
1958  * that the GPIO was actually requested.
1959  */
1960
1961 static int _gpiod_get_raw_value(const struct gpio_desc *desc)
1962 {
1963         struct gpio_chip        *chip;
1964         int value;
1965         int offset;
1966
1967         chip = desc->chip;
1968         offset = gpio_chip_hwgpio(desc);
1969         value = chip->get ? chip->get(chip, offset) : 0;
1970         trace_gpio_value(desc_to_gpio(desc), 1, value);
1971         return value;
1972 }
1973
1974 /**
1975  * gpiod_get_raw_value() - return a gpio's raw value
1976  * @desc: gpio whose value will be returned
1977  *
1978  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
1979  * its ACTIVE_LOW status.
1980  *
1981  * This function should be called from contexts where we cannot sleep, and will
1982  * complain if the GPIO chip functions potentially sleep.
1983  */
1984 int gpiod_get_raw_value(const struct gpio_desc *desc)
1985 {
1986         if (!desc)
1987                 return 0;
1988         /* Should be using gpio_get_value_cansleep() */
1989         WARN_ON(desc->chip->can_sleep);
1990         return _gpiod_get_raw_value(desc);
1991 }
1992 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
1993
1994 /**
1995  * gpiod_get_value() - return a gpio's value
1996  * @desc: gpio whose value will be returned
1997  *
1998  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
1999  * account.
2000  *
2001  * This function should be called from contexts where we cannot sleep, and will
2002  * complain if the GPIO chip functions potentially sleep.
2003  */
2004 int gpiod_get_value(const struct gpio_desc *desc)
2005 {
2006         int value;
2007         if (!desc)
2008                 return 0;
2009         /* Should be using gpio_get_value_cansleep() */
2010         WARN_ON(desc->chip->can_sleep);
2011
2012         value = _gpiod_get_raw_value(desc);
2013         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2014                 value = !value;
2015
2016         return value;
2017 }
2018 EXPORT_SYMBOL_GPL(gpiod_get_value);
2019
2020 /*
2021  *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
2022  * @desc: gpio descriptor whose state need to be set.
2023  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2024  */
2025 static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
2026 {
2027         int err = 0;
2028         struct gpio_chip *chip = desc->chip;
2029         int offset = gpio_chip_hwgpio(desc);
2030
2031         if (value) {
2032                 err = chip->direction_input(chip, offset);
2033                 if (!err)
2034                         clear_bit(FLAG_IS_OUT, &desc->flags);
2035         } else {
2036                 err = chip->direction_output(chip, offset, 0);
2037                 if (!err)
2038                         set_bit(FLAG_IS_OUT, &desc->flags);
2039         }
2040         trace_gpio_direction(desc_to_gpio(desc), value, err);
2041         if (err < 0)
2042                 gpiod_err(desc,
2043                           "%s: Error in set_value for open drain err %d\n",
2044                           __func__, err);
2045 }
2046
2047 /*
2048  *  _gpio_set_open_source_value() - Set the open source gpio's value.
2049  * @desc: gpio descriptor whose state need to be set.
2050  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2051  */
2052 static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
2053 {
2054         int err = 0;
2055         struct gpio_chip *chip = desc->chip;
2056         int offset = gpio_chip_hwgpio(desc);
2057
2058         if (value) {
2059                 err = chip->direction_output(chip, offset, 1);
2060                 if (!err)
2061                         set_bit(FLAG_IS_OUT, &desc->flags);
2062         } else {
2063                 err = chip->direction_input(chip, offset);
2064                 if (!err)
2065                         clear_bit(FLAG_IS_OUT, &desc->flags);
2066         }
2067         trace_gpio_direction(desc_to_gpio(desc), !value, err);
2068         if (err < 0)
2069                 gpiod_err(desc,
2070                           "%s: Error in set_value for open source err %d\n",
2071                           __func__, err);
2072 }
2073
2074 static void _gpiod_set_raw_value(struct gpio_desc *desc, int value)
2075 {
2076         struct gpio_chip        *chip;
2077
2078         chip = desc->chip;
2079         trace_gpio_value(desc_to_gpio(desc), 0, value);
2080         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2081                 _gpio_set_open_drain_value(desc, value);
2082         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2083                 _gpio_set_open_source_value(desc, value);
2084         else
2085                 chip->set(chip, gpio_chip_hwgpio(desc), value);
2086 }
2087
2088 /**
2089  * gpiod_set_raw_value() - assign a gpio's raw value
2090  * @desc: gpio whose value will be assigned
2091  * @value: value to assign
2092  *
2093  * Set the raw value of the GPIO, i.e. the value of its physical line without
2094  * regard for its ACTIVE_LOW status.
2095  *
2096  * This function should be called from contexts where we cannot sleep, and will
2097  * complain if the GPIO chip functions potentially sleep.
2098  */
2099 void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2100 {
2101         if (!desc)
2102                 return;
2103         /* Should be using gpio_set_value_cansleep() */
2104         WARN_ON(desc->chip->can_sleep);
2105         _gpiod_set_raw_value(desc, value);
2106 }
2107 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2108
2109 /**
2110  * gpiod_set_value() - assign a gpio's value
2111  * @desc: gpio whose value will be assigned
2112  * @value: value to assign
2113  *
2114  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2115  * account
2116  *
2117  * This function should be called from contexts where we cannot sleep, and will
2118  * complain if the GPIO chip functions potentially sleep.
2119  */
2120 void gpiod_set_value(struct gpio_desc *desc, int value)
2121 {
2122         if (!desc)
2123                 return;
2124         /* Should be using gpio_set_value_cansleep() */
2125         WARN_ON(desc->chip->can_sleep);
2126         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2127                 value = !value;
2128         _gpiod_set_raw_value(desc, value);
2129 }
2130 EXPORT_SYMBOL_GPL(gpiod_set_value);
2131
2132 /**
2133  * gpiod_cansleep() - report whether gpio value access may sleep
2134  * @desc: gpio to check
2135  *
2136  */
2137 int gpiod_cansleep(const struct gpio_desc *desc)
2138 {
2139         if (!desc)
2140                 return 0;
2141         return desc->chip->can_sleep;
2142 }
2143 EXPORT_SYMBOL_GPL(gpiod_cansleep);
2144
2145 /**
2146  * gpiod_to_irq() - return the IRQ corresponding to a GPIO
2147  * @desc: gpio whose IRQ will be returned (already requested)
2148  *
2149  * Return the IRQ corresponding to the passed GPIO, or an error code in case of
2150  * error.
2151  */
2152 int gpiod_to_irq(const struct gpio_desc *desc)
2153 {
2154         struct gpio_chip        *chip;
2155         int                     offset;
2156
2157         if (!desc)
2158                 return -EINVAL;
2159         chip = desc->chip;
2160         offset = gpio_chip_hwgpio(desc);
2161         return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
2162 }
2163 EXPORT_SYMBOL_GPL(gpiod_to_irq);
2164
2165 /**
2166  * gpiod_lock_as_irq() - lock a GPIO to be used as IRQ
2167  * @gpio: the GPIO line to lock as used for IRQ
2168  *
2169  * This is used directly by GPIO drivers that want to lock down
2170  * a certain GPIO line to be used as IRQs, for example in the
2171  * .to_irq() callback of their gpio_chip, or in the .irq_enable()
2172  * of its irq_chip implementation if the GPIO is known from that
2173  * code.
2174  */
2175 int gpiod_lock_as_irq(struct gpio_desc *desc)
2176 {
2177         if (!desc)
2178                 return -EINVAL;
2179
2180         if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2181                 gpiod_err(desc,
2182                           "%s: tried to flag a GPIO set as output for IRQ\n",
2183                           __func__);
2184                 return -EIO;
2185         }
2186
2187         set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2188         return 0;
2189 }
2190 EXPORT_SYMBOL_GPL(gpiod_lock_as_irq);
2191
2192 int gpio_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2193 {
2194         return gpiod_lock_as_irq(gpiochip_get_desc(chip, offset));
2195 }
2196 EXPORT_SYMBOL_GPL(gpio_lock_as_irq);
2197
2198 /**
2199  * gpiod_unlock_as_irq() - unlock a GPIO used as IRQ
2200  * @gpio: the GPIO line to unlock from IRQ usage
2201  *
2202  * This is used directly by GPIO drivers that want to indicate
2203  * that a certain GPIO is no longer used exclusively for IRQ.
2204  */
2205 void gpiod_unlock_as_irq(struct gpio_desc *desc)
2206 {
2207         if (!desc)
2208                 return;
2209
2210         clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
2211 }
2212 EXPORT_SYMBOL_GPL(gpiod_unlock_as_irq);
2213
2214 void gpio_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2215 {
2216         return gpiod_unlock_as_irq(gpiochip_get_desc(chip, offset));
2217 }
2218 EXPORT_SYMBOL_GPL(gpio_unlock_as_irq);
2219
2220 /**
2221  * gpiod_get_raw_value_cansleep() - return a gpio's raw value
2222  * @desc: gpio whose value will be returned
2223  *
2224  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2225  * its ACTIVE_LOW status.
2226  *
2227  * This function is to be called from contexts that can sleep.
2228  */
2229 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2230 {
2231         might_sleep_if(extra_checks);
2232         if (!desc)
2233                 return 0;
2234         return _gpiod_get_raw_value(desc);
2235 }
2236 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2237
2238 /**
2239  * gpiod_get_value_cansleep() - return a gpio's value
2240  * @desc: gpio whose value will be returned
2241  *
2242  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2243  * account.
2244  *
2245  * This function is to be called from contexts that can sleep.
2246  */
2247 int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2248 {
2249         int value;
2250
2251         might_sleep_if(extra_checks);
2252         if (!desc)
2253                 return 0;
2254
2255         value = _gpiod_get_raw_value(desc);
2256         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2257                 value = !value;
2258
2259         return value;
2260 }
2261 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2262
2263 /**
2264  * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
2265  * @desc: gpio whose value will be assigned
2266  * @value: value to assign
2267  *
2268  * Set the raw value of the GPIO, i.e. the value of its physical line without
2269  * regard for its ACTIVE_LOW status.
2270  *
2271  * This function is to be called from contexts that can sleep.
2272  */
2273 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
2274 {
2275         might_sleep_if(extra_checks);
2276         if (!desc)
2277                 return;
2278         _gpiod_set_raw_value(desc, value);
2279 }
2280 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2281
2282 /**
2283  * gpiod_set_value_cansleep() - assign a gpio's value
2284  * @desc: gpio whose value will be assigned
2285  * @value: value to assign
2286  *
2287  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2288  * account
2289  *
2290  * This function is to be called from contexts that can sleep.
2291  */
2292 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2293 {
2294         might_sleep_if(extra_checks);
2295         if (!desc)
2296                 return;
2297
2298         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2299                 value = !value;
2300         _gpiod_set_raw_value(desc, value);
2301 }
2302 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2303
2304 /**
2305  * gpiod_add_lookup_table() - register GPIO device consumers
2306  * @table: table of consumers to register
2307  */
2308 void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
2309 {
2310         mutex_lock(&gpio_lookup_lock);
2311
2312         list_add_tail(&table->list, &gpio_lookup_list);
2313
2314         mutex_unlock(&gpio_lookup_lock);
2315 }
2316
2317 #ifdef CONFIG_OF
2318 static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2319                                       unsigned int idx,
2320                                       enum gpio_lookup_flags *flags)
2321 {
2322         char prop_name[32]; /* 32 is max size of property name */
2323         enum of_gpio_flags of_flags;
2324         struct gpio_desc *desc;
2325
2326         if (con_id)
2327                 snprintf(prop_name, 32, "%s-gpios", con_id);
2328         else
2329                 snprintf(prop_name, 32, "gpios");
2330
2331         desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
2332                                         &of_flags);
2333
2334         if (IS_ERR(desc))
2335                 return desc;
2336
2337         if (of_flags & OF_GPIO_ACTIVE_LOW)
2338                 *flags |= GPIO_ACTIVE_LOW;
2339
2340         return desc;
2341 }
2342 #else
2343 static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2344                                       unsigned int idx,
2345                                       enum gpio_lookup_flags *flags)
2346 {
2347         return ERR_PTR(-ENODEV);
2348 }
2349 #endif
2350
2351 static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
2352                                         unsigned int idx,
2353                                         enum gpio_lookup_flags *flags)
2354 {
2355         struct acpi_gpio_info info;
2356         struct gpio_desc *desc;
2357
2358         desc = acpi_get_gpiod_by_index(dev, idx, &info);
2359         if (IS_ERR(desc))
2360                 return desc;
2361
2362         if (info.gpioint && info.active_low)
2363                 *flags |= GPIO_ACTIVE_LOW;
2364
2365         return desc;
2366 }
2367
2368 static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2369 {
2370         const char *dev_id = dev ? dev_name(dev) : NULL;
2371         struct gpiod_lookup_table *table;
2372
2373         mutex_lock(&gpio_lookup_lock);
2374
2375         list_for_each_entry(table, &gpio_lookup_list, list) {
2376                 if (table->dev_id && dev_id) {
2377                         /*
2378                          * Valid strings on both ends, must be identical to have
2379                          * a match
2380                          */
2381                         if (!strcmp(table->dev_id, dev_id))
2382                                 goto found;
2383                 } else {
2384                         /*
2385                          * One of the pointers is NULL, so both must be to have
2386                          * a match
2387                          */
2388                         if (dev_id == table->dev_id)
2389                                 goto found;
2390                 }
2391         }
2392         table = NULL;
2393
2394 found:
2395         mutex_unlock(&gpio_lookup_lock);
2396         return table;
2397 }
2398
2399 static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
2400                                     unsigned int idx,
2401                                     enum gpio_lookup_flags *flags)
2402 {
2403         struct gpio_desc *desc = ERR_PTR(-ENOENT);
2404         struct gpiod_lookup_table *table;
2405         struct gpiod_lookup *p;
2406
2407         table = gpiod_find_lookup_table(dev);
2408         if (!table)
2409                 return desc;
2410
2411         for (p = &table->table[0]; p->chip_label; p++) {
2412                 struct gpio_chip *chip;
2413
2414                 /* idx must always match exactly */
2415                 if (p->idx != idx)
2416                         continue;
2417
2418                 /* If the lookup entry has a con_id, require exact match */
2419                 if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
2420                         continue;
2421
2422                 chip = find_chip_by_name(p->chip_label);
2423
2424                 if (!chip) {
2425                         dev_err(dev, "cannot find GPIO chip %s\n",
2426                                 p->chip_label);
2427                         return ERR_PTR(-ENODEV);
2428                 }
2429
2430                 if (chip->ngpio <= p->chip_hwnum) {
2431                         dev_err(dev,
2432                                 "requested GPIO %d is out of range [0..%d] for chip %s\n",
2433                                 idx, chip->ngpio, chip->label);
2434                         return ERR_PTR(-EINVAL);
2435                 }
2436
2437                 desc = gpiochip_get_desc(chip, p->chip_hwnum);
2438                 *flags = p->flags;
2439
2440                 return desc;
2441         }
2442
2443         return desc;
2444 }
2445
2446 /**
2447  * gpio_get - obtain a GPIO for a given GPIO function
2448  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
2449  * @con_id:     function within the GPIO consumer
2450  * @flags:      optional GPIO initialization flags
2451  *
2452  * Return the GPIO descriptor corresponding to the function con_id of device
2453  * dev, -ENOENT if no GPIO has been assigned to the requested function, or
2454  * another IS_ERR() code if an error occured while trying to acquire the GPIO.
2455  */
2456 struct gpio_desc *__must_check __gpiod_get(struct device *dev, const char *con_id,
2457                                          enum gpiod_flags flags)
2458 {
2459         return gpiod_get_index(dev, con_id, 0, flags);
2460 }
2461 EXPORT_SYMBOL_GPL(__gpiod_get);
2462
2463 /**
2464  * gpiod_get_optional - obtain an optional GPIO for a given GPIO function
2465  * @dev: GPIO consumer, can be NULL for system-global GPIOs
2466  * @con_id: function within the GPIO consumer
2467  * @flags: optional GPIO initialization flags
2468  *
2469  * This is equivalent to gpiod_get(), except that when no GPIO was assigned to
2470  * the requested function it will return NULL. This is convenient for drivers
2471  * that need to handle optional GPIOs.
2472  */
2473 struct gpio_desc *__must_check __gpiod_get_optional(struct device *dev,
2474                                                   const char *con_id,
2475                                                   enum gpiod_flags flags)
2476 {
2477         return gpiod_get_index_optional(dev, con_id, 0, flags);
2478 }
2479 EXPORT_SYMBOL_GPL(__gpiod_get_optional);
2480
2481 /**
2482  * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
2483  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
2484  * @con_id:     function within the GPIO consumer
2485  * @idx:        index of the GPIO to obtain in the consumer
2486  * @flags:      optional GPIO initialization flags
2487  *
2488  * This variant of gpiod_get() allows to access GPIOs other than the first
2489  * defined one for functions that define several GPIOs.
2490  *
2491  * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
2492  * requested function and/or index, or another IS_ERR() code if an error
2493  * occured while trying to acquire the GPIO.
2494  */
2495 struct gpio_desc *__must_check __gpiod_get_index(struct device *dev,
2496                                                const char *con_id,
2497                                                unsigned int idx,
2498                                                enum gpiod_flags flags)
2499 {
2500         struct gpio_desc *desc = NULL;
2501         int status;
2502         enum gpio_lookup_flags lookupflags = 0;
2503
2504         dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
2505
2506         /* Using device tree? */
2507         if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) {
2508                 dev_dbg(dev, "using device tree for GPIO lookup\n");
2509                 desc = of_find_gpio(dev, con_id, idx, &lookupflags);
2510         } else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev)) {
2511                 dev_dbg(dev, "using ACPI for GPIO lookup\n");
2512                 desc = acpi_find_gpio(dev, con_id, idx, &lookupflags);
2513         }
2514
2515         /*
2516          * Either we are not using DT or ACPI, or their lookup did not return
2517          * a result. In that case, use platform lookup as a fallback.
2518          */
2519         if (!desc || desc == ERR_PTR(-ENOENT)) {
2520                 dev_dbg(dev, "using lookup tables for GPIO lookup");
2521                 desc = gpiod_find(dev, con_id, idx, &lookupflags);
2522         }
2523
2524         if (IS_ERR(desc)) {
2525                 dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
2526                 return desc;
2527         }
2528
2529         status = gpiod_request(desc, con_id);
2530
2531         if (status < 0)
2532                 return ERR_PTR(status);
2533
2534         if (lookupflags & GPIO_ACTIVE_LOW)
2535                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
2536         if (lookupflags & GPIO_OPEN_DRAIN)
2537                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
2538         if (lookupflags & GPIO_OPEN_SOURCE)
2539                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
2540
2541         /* No particular flag request, return here... */
2542         if (flags & GPIOD_FLAGS_BIT_DIR_SET)
2543                 return desc;
2544
2545         /* Process flags */
2546         if (flags & GPIOD_FLAGS_BIT_DIR_OUT)
2547                 status = gpiod_direction_output(desc,
2548                                               flags & GPIOD_FLAGS_BIT_DIR_VAL);
2549         else
2550                 status = gpiod_direction_input(desc);
2551
2552         if (status < 0) {
2553                 dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
2554                 gpiod_put(desc);
2555                 return ERR_PTR(status);
2556         }
2557
2558         return desc;
2559 }
2560 EXPORT_SYMBOL_GPL(__gpiod_get_index);
2561
2562 /**
2563  * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
2564  *                            function
2565  * @dev: GPIO consumer, can be NULL for system-global GPIOs
2566  * @con_id: function within the GPIO consumer
2567  * @index: index of the GPIO to obtain in the consumer
2568  * @flags: optional GPIO initialization flags
2569  *
2570  * This is equivalent to gpiod_get_index(), except that when no GPIO with the
2571  * specified index was assigned to the requested function it will return NULL.
2572  * This is convenient for drivers that need to handle optional GPIOs.
2573  */
2574 struct gpio_desc *__must_check __gpiod_get_index_optional(struct device *dev,
2575                                                         const char *con_id,
2576                                                         unsigned int index,
2577                                                         enum gpiod_flags flags)
2578 {
2579         struct gpio_desc *desc;
2580
2581         desc = gpiod_get_index(dev, con_id, index, flags);
2582         if (IS_ERR(desc)) {
2583                 if (PTR_ERR(desc) == -ENOENT)
2584                         return NULL;
2585         }
2586
2587         return desc;
2588 }
2589 EXPORT_SYMBOL_GPL(__gpiod_get_index_optional);
2590
2591 /**
2592  * gpiod_put - dispose of a GPIO descriptor
2593  * @desc:       GPIO descriptor to dispose of
2594  *
2595  * No descriptor can be used after gpiod_put() has been called on it.
2596  */
2597 void gpiod_put(struct gpio_desc *desc)
2598 {
2599         gpiod_free(desc);
2600 }
2601 EXPORT_SYMBOL_GPL(gpiod_put);
2602
2603 #ifdef CONFIG_DEBUG_FS
2604
2605 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2606 {
2607         unsigned                i;
2608         unsigned                gpio = chip->base;
2609         struct gpio_desc        *gdesc = &chip->desc[0];
2610         int                     is_out;
2611         int                     is_irq;
2612
2613         for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2614                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2615                         continue;
2616
2617                 gpiod_get_direction(gdesc);
2618                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
2619                 is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
2620                 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s %s",
2621                         gpio, gdesc->label,
2622                         is_out ? "out" : "in ",
2623                         chip->get
2624                                 ? (chip->get(chip, i) ? "hi" : "lo")
2625                                 : "?  ",
2626                         is_irq ? "IRQ" : "   ");
2627                 seq_printf(s, "\n");
2628         }
2629 }
2630
2631 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
2632 {
2633         unsigned long flags;
2634         struct gpio_chip *chip = NULL;
2635         loff_t index = *pos;
2636
2637         s->private = "";
2638
2639         spin_lock_irqsave(&gpio_lock, flags);
2640         list_for_each_entry(chip, &gpio_chips, list)
2641                 if (index-- == 0) {
2642                         spin_unlock_irqrestore(&gpio_lock, flags);
2643                         return chip;
2644                 }
2645         spin_unlock_irqrestore(&gpio_lock, flags);
2646
2647         return NULL;
2648 }
2649
2650 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2651 {
2652         unsigned long flags;
2653         struct gpio_chip *chip = v;
2654         void *ret = NULL;
2655
2656         spin_lock_irqsave(&gpio_lock, flags);
2657         if (list_is_last(&chip->list, &gpio_chips))
2658                 ret = NULL;
2659         else
2660                 ret = list_entry(chip->list.next, struct gpio_chip, list);
2661         spin_unlock_irqrestore(&gpio_lock, flags);
2662
2663         s->private = "\n";
2664         ++*pos;
2665
2666         return ret;
2667 }
2668
2669 static void gpiolib_seq_stop(struct seq_file *s, void *v)
2670 {
2671 }
2672
2673 static int gpiolib_seq_show(struct seq_file *s, void *v)
2674 {
2675         struct gpio_chip *chip = v;
2676         struct device *dev;
2677
2678         seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2679                         chip->base, chip->base + chip->ngpio - 1);
2680         dev = chip->dev;
2681         if (dev)
2682                 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2683                         dev_name(dev));
2684         if (chip->label)
2685                 seq_printf(s, ", %s", chip->label);
2686         if (chip->can_sleep)
2687                 seq_printf(s, ", can sleep");
2688         seq_printf(s, ":\n");
2689
2690         if (chip->dbg_show)
2691                 chip->dbg_show(s, chip);
2692         else
2693                 gpiolib_dbg_show(s, chip);
2694
2695         return 0;
2696 }
2697
2698 static const struct seq_operations gpiolib_seq_ops = {
2699         .start = gpiolib_seq_start,
2700         .next = gpiolib_seq_next,
2701         .stop = gpiolib_seq_stop,
2702         .show = gpiolib_seq_show,
2703 };
2704
2705 static int gpiolib_open(struct inode *inode, struct file *file)
2706 {
2707         return seq_open(file, &gpiolib_seq_ops);
2708 }
2709
2710 static const struct file_operations gpiolib_operations = {
2711         .owner          = THIS_MODULE,
2712         .open           = gpiolib_open,
2713         .read           = seq_read,
2714         .llseek         = seq_lseek,
2715         .release        = seq_release,
2716 };
2717
2718 static int __init gpiolib_debugfs_init(void)
2719 {
2720         /* /sys/kernel/debug/gpio */
2721         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2722                                 NULL, NULL, &gpiolib_operations);
2723         return 0;
2724 }
2725 subsys_initcall(gpiolib_debugfs_init);
2726
2727 #endif  /* DEBUG_FS */