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 = desc->chip;
1464         int                     status;
1465         unsigned long           flags;
1466
1467         spin_lock_irqsave(&gpio_lock, flags);
1468
1469         /* NOTE:  gpio_request() can be called in early boot,
1470          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1471          */
1472
1473         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1474                 desc_set_label(desc, label ? : "?");
1475                 status = 0;
1476         } else {
1477                 status = -EBUSY;
1478                 goto done;
1479         }
1480
1481         if (chip->request) {
1482                 /* chip->request may sleep */
1483                 spin_unlock_irqrestore(&gpio_lock, flags);
1484                 status = chip->request(chip, gpio_chip_hwgpio(desc));
1485                 spin_lock_irqsave(&gpio_lock, flags);
1486
1487                 if (status < 0) {
1488                         desc_set_label(desc, NULL);
1489                         clear_bit(FLAG_REQUESTED, &desc->flags);
1490                         goto done;
1491                 }
1492         }
1493         if (chip->get_direction) {
1494                 /* chip->get_direction may sleep */
1495                 spin_unlock_irqrestore(&gpio_lock, flags);
1496                 gpiod_get_direction(desc);
1497                 spin_lock_irqsave(&gpio_lock, flags);
1498         }
1499 done:
1500         spin_unlock_irqrestore(&gpio_lock, flags);
1501         return status;
1502 }
1503
1504 static int gpiod_request(struct gpio_desc *desc, const char *label)
1505 {
1506         int status = -EPROBE_DEFER;
1507         struct gpio_chip *chip;
1508
1509         if (!desc) {
1510                 pr_warn("%s: invalid GPIO\n", __func__);
1511                 return -EINVAL;
1512         }
1513
1514         chip = desc->chip;
1515         if (!chip)
1516                 goto done;
1517
1518         if (try_module_get(chip->owner)) {
1519                 status = __gpiod_request(desc, label);
1520                 if (status < 0)
1521                         module_put(chip->owner);
1522         }
1523
1524 done:
1525         if (status)
1526                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1527
1528         return status;
1529 }
1530
1531 int gpio_request(unsigned gpio, const char *label)
1532 {
1533         return gpiod_request(gpio_to_desc(gpio), label);
1534 }
1535 EXPORT_SYMBOL_GPL(gpio_request);
1536
1537 static bool __gpiod_free(struct gpio_desc *desc)
1538 {
1539         bool                    ret = false;
1540         unsigned long           flags;
1541         struct gpio_chip        *chip;
1542
1543         might_sleep();
1544
1545         gpiod_unexport(desc);
1546
1547         spin_lock_irqsave(&gpio_lock, flags);
1548
1549         chip = desc->chip;
1550         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1551                 if (chip->free) {
1552                         spin_unlock_irqrestore(&gpio_lock, flags);
1553                         might_sleep_if(chip->can_sleep);
1554                         chip->free(chip, gpio_chip_hwgpio(desc));
1555                         spin_lock_irqsave(&gpio_lock, flags);
1556                 }
1557                 desc_set_label(desc, NULL);
1558                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1559                 clear_bit(FLAG_REQUESTED, &desc->flags);
1560                 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1561                 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
1562                 ret = true;
1563         }
1564
1565         spin_unlock_irqrestore(&gpio_lock, flags);
1566         return ret;
1567 }
1568
1569 static void gpiod_free(struct gpio_desc *desc)
1570 {
1571         if (desc && __gpiod_free(desc))
1572                 module_put(desc->chip->owner);
1573         else
1574                 WARN_ON(extra_checks);
1575 }
1576
1577 void gpio_free(unsigned gpio)
1578 {
1579         gpiod_free(gpio_to_desc(gpio));
1580 }
1581 EXPORT_SYMBOL_GPL(gpio_free);
1582
1583 /**
1584  * gpio_request_one - request a single GPIO with initial configuration
1585  * @gpio:       the GPIO number
1586  * @flags:      GPIO configuration as specified by GPIOF_*
1587  * @label:      a literal description string of this GPIO
1588  */
1589 int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1590 {
1591         struct gpio_desc *desc;
1592         int err;
1593
1594         desc = gpio_to_desc(gpio);
1595
1596         err = gpiod_request(desc, label);
1597         if (err)
1598                 return err;
1599
1600         if (flags & GPIOF_OPEN_DRAIN)
1601                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
1602
1603         if (flags & GPIOF_OPEN_SOURCE)
1604                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
1605
1606         if (flags & GPIOF_DIR_IN)
1607                 err = gpiod_direction_input(desc);
1608         else
1609                 err = gpiod_direction_output_raw(desc,
1610                                 (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1611
1612         if (err)
1613                 goto free_gpio;
1614
1615         if (flags & GPIOF_EXPORT) {
1616                 err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
1617                 if (err)
1618                         goto free_gpio;
1619         }
1620
1621         return 0;
1622
1623  free_gpio:
1624         gpiod_free(desc);
1625         return err;
1626 }
1627 EXPORT_SYMBOL_GPL(gpio_request_one);
1628
1629 /**
1630  * gpio_request_array - request multiple GPIOs in a single call
1631  * @array:      array of the 'struct gpio'
1632  * @num:        how many GPIOs in the array
1633  */
1634 int gpio_request_array(const struct gpio *array, size_t num)
1635 {
1636         int i, err;
1637
1638         for (i = 0; i < num; i++, array++) {
1639                 err = gpio_request_one(array->gpio, array->flags, array->label);
1640                 if (err)
1641                         goto err_free;
1642         }
1643         return 0;
1644
1645 err_free:
1646         while (i--)
1647                 gpio_free((--array)->gpio);
1648         return err;
1649 }
1650 EXPORT_SYMBOL_GPL(gpio_request_array);
1651
1652 /**
1653  * gpio_free_array - release multiple GPIOs in a single call
1654  * @array:      array of the 'struct gpio'
1655  * @num:        how many GPIOs in the array
1656  */
1657 void gpio_free_array(const struct gpio *array, size_t num)
1658 {
1659         while (num--)
1660                 gpio_free((array++)->gpio);
1661 }
1662 EXPORT_SYMBOL_GPL(gpio_free_array);
1663
1664 /**
1665  * gpiochip_is_requested - return string iff signal was requested
1666  * @chip: controller managing the signal
1667  * @offset: of signal within controller's 0..(ngpio - 1) range
1668  *
1669  * Returns NULL if the GPIO is not currently requested, else a string.
1670  * If debugfs support is enabled, the string returned is the label passed
1671  * to gpio_request(); otherwise it is a meaningless constant.
1672  *
1673  * This function is for use by GPIO controller drivers.  The label can
1674  * help with diagnostics, and knowing that the signal is used as a GPIO
1675  * can help avoid accidentally multiplexing it to another controller.
1676  */
1677 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1678 {
1679         struct gpio_desc *desc;
1680
1681         if (!GPIO_OFFSET_VALID(chip, offset))
1682                 return NULL;
1683
1684         desc = &chip->desc[offset];
1685
1686         if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
1687                 return NULL;
1688 #ifdef CONFIG_DEBUG_FS
1689         return desc->label;
1690 #else
1691         return "?";
1692 #endif
1693 }
1694 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1695
1696 /**
1697  * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
1698  * @desc: GPIO descriptor to request
1699  * @label: label for the GPIO
1700  *
1701  * Function allows GPIO chip drivers to request and use their own GPIO
1702  * descriptors via gpiolib API. Difference to gpiod_request() is that this
1703  * function will not increase reference count of the GPIO chip module. This
1704  * allows the GPIO chip module to be unloaded as needed (we assume that the
1705  * GPIO chip driver handles freeing the GPIOs it has requested).
1706  */
1707 int gpiochip_request_own_desc(struct gpio_desc *desc, const char *label)
1708 {
1709         if (!desc || !desc->chip)
1710                 return -EINVAL;
1711
1712         return __gpiod_request(desc, label);
1713 }
1714
1715 /**
1716  * gpiochip_free_own_desc - Free GPIO requested by the chip driver
1717  * @desc: GPIO descriptor to free
1718  *
1719  * Function frees the given GPIO requested previously with
1720  * gpiochip_request_own_desc().
1721  */
1722 void gpiochip_free_own_desc(struct gpio_desc *desc)
1723 {
1724         if (desc)
1725                 __gpiod_free(desc);
1726 }
1727
1728 /* Drivers MUST set GPIO direction before making get/set calls.  In
1729  * some cases this is done in early boot, before IRQs are enabled.
1730  *
1731  * As a rule these aren't called more than once (except for drivers
1732  * using the open-drain emulation idiom) so these are natural places
1733  * to accumulate extra debugging checks.  Note that we can't (yet)
1734  * rely on gpio_request() having been called beforehand.
1735  */
1736
1737 /**
1738  * gpiod_direction_input - set the GPIO direction to input
1739  * @desc:       GPIO to set to input
1740  *
1741  * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
1742  * be called safely on it.
1743  *
1744  * Return 0 in case of success, else an error code.
1745  */
1746 int gpiod_direction_input(struct gpio_desc *desc)
1747 {
1748         unsigned long           flags;
1749         struct gpio_chip        *chip;
1750         int                     status = -EINVAL;
1751         int                     offset;
1752
1753         if (!desc || !desc->chip) {
1754                 pr_warn("%s: invalid GPIO\n", __func__);
1755                 return -EINVAL;
1756         }
1757
1758         chip = desc->chip;
1759         if (!chip->get || !chip->direction_input) {
1760                 gpiod_warn(desc,
1761                         "%s: missing get() or direction_input() operations\n",
1762                         __func__);
1763                 return -EIO;
1764         }
1765
1766         spin_lock_irqsave(&gpio_lock, flags);
1767
1768         status = gpio_ensure_requested(desc);
1769         if (status < 0)
1770                 goto fail;
1771
1772         /* now we know the gpio is valid and chip won't vanish */
1773
1774         spin_unlock_irqrestore(&gpio_lock, flags);
1775
1776         might_sleep_if(chip->can_sleep);
1777
1778         offset = gpio_chip_hwgpio(desc);
1779         if (status) {
1780                 status = chip->request(chip, offset);
1781                 if (status < 0) {
1782                         gpiod_dbg(desc, "%s: chip request fail, %d\n",
1783                                         __func__, status);
1784                         /* and it's not available to anyone else ...
1785                          * gpio_request() is the fully clean solution.
1786                          */
1787                         goto lose;
1788                 }
1789         }
1790
1791         status = chip->direction_input(chip, offset);
1792         if (status == 0)
1793                 clear_bit(FLAG_IS_OUT, &desc->flags);
1794
1795         trace_gpio_direction(desc_to_gpio(desc), 1, status);
1796 lose:
1797         return status;
1798 fail:
1799         spin_unlock_irqrestore(&gpio_lock, flags);
1800         if (status)
1801                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1802         return status;
1803 }
1804 EXPORT_SYMBOL_GPL(gpiod_direction_input);
1805
1806 static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
1807 {
1808         unsigned long           flags;
1809         struct gpio_chip        *chip;
1810         int                     status = -EINVAL;
1811         int offset;
1812
1813         /* GPIOs used for IRQs shall not be set as output */
1814         if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
1815                 gpiod_err(desc,
1816                           "%s: tried to set a GPIO tied to an IRQ as output\n",
1817                           __func__);
1818                 return -EIO;
1819         }
1820
1821         /* Open drain pin should not be driven to 1 */
1822         if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
1823                 return gpiod_direction_input(desc);
1824
1825         /* Open source pin should not be driven to 0 */
1826         if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
1827                 return gpiod_direction_input(desc);
1828
1829         chip = desc->chip;
1830         if (!chip->set || !chip->direction_output) {
1831                 gpiod_warn(desc,
1832                        "%s: missing set() or direction_output() operations\n",
1833                        __func__);
1834                 return -EIO;
1835         }
1836
1837         spin_lock_irqsave(&gpio_lock, flags);
1838
1839         status = gpio_ensure_requested(desc);
1840         if (status < 0)
1841                 goto fail;
1842
1843         /* now we know the gpio is valid and chip won't vanish */
1844
1845         spin_unlock_irqrestore(&gpio_lock, flags);
1846
1847         might_sleep_if(chip->can_sleep);
1848
1849         offset = gpio_chip_hwgpio(desc);
1850         if (status) {
1851                 status = chip->request(chip, offset);
1852                 if (status < 0) {
1853                         gpiod_dbg(desc, "%s: chip request fail, %d\n",
1854                                         __func__, status);
1855                         /* and it's not available to anyone else ...
1856                          * gpio_request() is the fully clean solution.
1857                          */
1858                         goto lose;
1859                 }
1860         }
1861
1862         status = chip->direction_output(chip, offset, value);
1863         if (status == 0)
1864                 set_bit(FLAG_IS_OUT, &desc->flags);
1865         trace_gpio_value(desc_to_gpio(desc), 0, value);
1866         trace_gpio_direction(desc_to_gpio(desc), 0, status);
1867 lose:
1868         return status;
1869 fail:
1870         spin_unlock_irqrestore(&gpio_lock, flags);
1871         if (status)
1872                 gpiod_dbg(desc, "%s: gpio status %d\n", __func__, status);
1873         return status;
1874 }
1875
1876 /**
1877  * gpiod_direction_output_raw - set the GPIO direction to output
1878  * @desc:       GPIO to set to output
1879  * @value:      initial output value of the GPIO
1880  *
1881  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
1882  * be called safely on it. The initial value of the output must be specified
1883  * as raw value on the physical line without regard for the ACTIVE_LOW status.
1884  *
1885  * Return 0 in case of success, else an error code.
1886  */
1887 int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
1888 {
1889         if (!desc || !desc->chip) {
1890                 pr_warn("%s: invalid GPIO\n", __func__);
1891                 return -EINVAL;
1892         }
1893         return _gpiod_direction_output_raw(desc, value);
1894 }
1895 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
1896
1897 /**
1898  * gpiod_direction_output - set the GPIO direction to output
1899  * @desc:       GPIO to set to output
1900  * @value:      initial output value of the GPIO
1901  *
1902  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
1903  * be called safely on it. The initial value of the output must be specified
1904  * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
1905  * account.
1906  *
1907  * Return 0 in case of success, else an error code.
1908  */
1909 int gpiod_direction_output(struct gpio_desc *desc, int value)
1910 {
1911         if (!desc || !desc->chip) {
1912                 pr_warn("%s: invalid GPIO\n", __func__);
1913                 return -EINVAL;
1914         }
1915         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1916                 value = !value;
1917         return _gpiod_direction_output_raw(desc, value);
1918 }
1919 EXPORT_SYMBOL_GPL(gpiod_direction_output);
1920
1921 /**
1922  * gpiod_set_debounce - sets @debounce time for a @gpio
1923  * @gpio: the gpio to set debounce time
1924  * @debounce: debounce time is microseconds
1925  *
1926  * returns -ENOTSUPP if the controller does not support setting
1927  * debounce.
1928  */
1929 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
1930 {
1931         unsigned long           flags;
1932         struct gpio_chip        *chip;
1933         int                     status = -EINVAL;
1934         int                     offset;
1935
1936         if (!desc || !desc->chip) {
1937                 pr_warn("%s: invalid GPIO\n", __func__);
1938                 return -EINVAL;
1939         }
1940
1941         chip = desc->chip;
1942         if (!chip->set || !chip->set_debounce) {
1943                 gpiod_dbg(desc,
1944                           "%s: missing set() or set_debounce() operations\n",
1945                           __func__);
1946                 return -ENOTSUPP;
1947         }
1948
1949         spin_lock_irqsave(&gpio_lock, flags);
1950
1951         status = gpio_ensure_requested(desc);
1952         if (status < 0)
1953                 goto fail;
1954
1955         /* now we know the gpio is valid and chip won't vanish */
1956
1957         spin_unlock_irqrestore(&gpio_lock, flags);
1958
1959         might_sleep_if(chip->can_sleep);
1960
1961         offset = gpio_chip_hwgpio(desc);
1962         return chip->set_debounce(chip, offset, debounce);
1963
1964 fail:
1965         spin_unlock_irqrestore(&gpio_lock, flags);
1966         if (status)
1967                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1968
1969         return status;
1970 }
1971 EXPORT_SYMBOL_GPL(gpiod_set_debounce);
1972
1973 /**
1974  * gpiod_is_active_low - test whether a GPIO is active-low or not
1975  * @desc: the gpio descriptor to test
1976  *
1977  * Returns 1 if the GPIO is active-low, 0 otherwise.
1978  */
1979 int gpiod_is_active_low(const struct gpio_desc *desc)
1980 {
1981         return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
1982 }
1983 EXPORT_SYMBOL_GPL(gpiod_is_active_low);
1984
1985 /* I/O calls are only valid after configuration completed; the relevant
1986  * "is this a valid GPIO" error checks should already have been done.
1987  *
1988  * "Get" operations are often inlinable as reading a pin value register,
1989  * and masking the relevant bit in that register.
1990  *
1991  * When "set" operations are inlinable, they involve writing that mask to
1992  * one register to set a low value, or a different register to set it high.
1993  * Otherwise locking is needed, so there may be little value to inlining.
1994  *
1995  *------------------------------------------------------------------------
1996  *
1997  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
1998  * have requested the GPIO.  That can include implicit requesting by
1999  * a direction setting call.  Marking a gpio as requested locks its chip
2000  * in memory, guaranteeing that these table lookups need no more locking
2001  * and that gpiochip_remove() will fail.
2002  *
2003  * REVISIT when debugging, consider adding some instrumentation to ensure
2004  * that the GPIO was actually requested.
2005  */
2006
2007 static int _gpiod_get_raw_value(const struct gpio_desc *desc)
2008 {
2009         struct gpio_chip        *chip;
2010         int value;
2011         int offset;
2012
2013         chip = desc->chip;
2014         offset = gpio_chip_hwgpio(desc);
2015         value = chip->get ? chip->get(chip, offset) : 0;
2016         trace_gpio_value(desc_to_gpio(desc), 1, value);
2017         return value;
2018 }
2019
2020 /**
2021  * gpiod_get_raw_value() - return a gpio's raw value
2022  * @desc: gpio whose value will be returned
2023  *
2024  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2025  * its ACTIVE_LOW status.
2026  *
2027  * This function should be called from contexts where we cannot sleep, and will
2028  * complain if the GPIO chip functions potentially sleep.
2029  */
2030 int gpiod_get_raw_value(const struct gpio_desc *desc)
2031 {
2032         if (!desc)
2033                 return 0;
2034         /* Should be using gpio_get_value_cansleep() */
2035         WARN_ON(desc->chip->can_sleep);
2036         return _gpiod_get_raw_value(desc);
2037 }
2038 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2039
2040 /**
2041  * gpiod_get_value() - return a gpio's value
2042  * @desc: gpio whose value will be returned
2043  *
2044  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2045  * account.
2046  *
2047  * This function should be called from contexts where we cannot sleep, and will
2048  * complain if the GPIO chip functions potentially sleep.
2049  */
2050 int gpiod_get_value(const struct gpio_desc *desc)
2051 {
2052         int value;
2053         if (!desc)
2054                 return 0;
2055         /* Should be using gpio_get_value_cansleep() */
2056         WARN_ON(desc->chip->can_sleep);
2057
2058         value = _gpiod_get_raw_value(desc);
2059         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2060                 value = !value;
2061
2062         return value;
2063 }
2064 EXPORT_SYMBOL_GPL(gpiod_get_value);
2065
2066 /*
2067  *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
2068  * @desc: gpio descriptor whose state need to be set.
2069  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2070  */
2071 static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
2072 {
2073         int err = 0;
2074         struct gpio_chip *chip = desc->chip;
2075         int offset = gpio_chip_hwgpio(desc);
2076
2077         if (value) {
2078                 err = chip->direction_input(chip, offset);
2079                 if (!err)
2080                         clear_bit(FLAG_IS_OUT, &desc->flags);
2081         } else {
2082                 err = chip->direction_output(chip, offset, 0);
2083                 if (!err)
2084                         set_bit(FLAG_IS_OUT, &desc->flags);
2085         }
2086         trace_gpio_direction(desc_to_gpio(desc), value, err);
2087         if (err < 0)
2088                 gpiod_err(desc,
2089                           "%s: Error in set_value for open drain err %d\n",
2090                           __func__, err);
2091 }
2092
2093 /*
2094  *  _gpio_set_open_source_value() - Set the open source gpio's value.
2095  * @desc: gpio descriptor whose state need to be set.
2096  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2097  */
2098 static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
2099 {
2100         int err = 0;
2101         struct gpio_chip *chip = desc->chip;
2102         int offset = gpio_chip_hwgpio(desc);
2103
2104         if (value) {
2105                 err = chip->direction_output(chip, offset, 1);
2106                 if (!err)
2107                         set_bit(FLAG_IS_OUT, &desc->flags);
2108         } else {
2109                 err = chip->direction_input(chip, offset);
2110                 if (!err)
2111                         clear_bit(FLAG_IS_OUT, &desc->flags);
2112         }
2113         trace_gpio_direction(desc_to_gpio(desc), !value, err);
2114         if (err < 0)
2115                 gpiod_err(desc,
2116                           "%s: Error in set_value for open source err %d\n",
2117                           __func__, err);
2118 }
2119
2120 static void _gpiod_set_raw_value(struct gpio_desc *desc, int value)
2121 {
2122         struct gpio_chip        *chip;
2123
2124         chip = desc->chip;
2125         trace_gpio_value(desc_to_gpio(desc), 0, value);
2126         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2127                 _gpio_set_open_drain_value(desc, value);
2128         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2129                 _gpio_set_open_source_value(desc, value);
2130         else
2131                 chip->set(chip, gpio_chip_hwgpio(desc), value);
2132 }
2133
2134 /**
2135  * gpiod_set_raw_value() - assign a gpio's raw value
2136  * @desc: gpio whose value will be assigned
2137  * @value: value to assign
2138  *
2139  * Set the raw value of the GPIO, i.e. the value of its physical line without
2140  * regard for its ACTIVE_LOW status.
2141  *
2142  * This function should be called from contexts where we cannot sleep, and will
2143  * complain if the GPIO chip functions potentially sleep.
2144  */
2145 void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2146 {
2147         if (!desc)
2148                 return;
2149         /* Should be using gpio_set_value_cansleep() */
2150         WARN_ON(desc->chip->can_sleep);
2151         _gpiod_set_raw_value(desc, value);
2152 }
2153 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2154
2155 /**
2156  * gpiod_set_value() - assign a gpio's value
2157  * @desc: gpio whose value will be assigned
2158  * @value: value to assign
2159  *
2160  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2161  * account
2162  *
2163  * This function should be called from contexts where we cannot sleep, and will
2164  * complain if the GPIO chip functions potentially sleep.
2165  */
2166 void gpiod_set_value(struct gpio_desc *desc, int value)
2167 {
2168         if (!desc)
2169                 return;
2170         /* Should be using gpio_set_value_cansleep() */
2171         WARN_ON(desc->chip->can_sleep);
2172         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2173                 value = !value;
2174         _gpiod_set_raw_value(desc, value);
2175 }
2176 EXPORT_SYMBOL_GPL(gpiod_set_value);
2177
2178 /**
2179  * gpiod_cansleep() - report whether gpio value access may sleep
2180  * @desc: gpio to check
2181  *
2182  */
2183 int gpiod_cansleep(const struct gpio_desc *desc)
2184 {
2185         if (!desc)
2186                 return 0;
2187         return desc->chip->can_sleep;
2188 }
2189 EXPORT_SYMBOL_GPL(gpiod_cansleep);
2190
2191 /**
2192  * gpiod_to_irq() - return the IRQ corresponding to a GPIO
2193  * @desc: gpio whose IRQ will be returned (already requested)
2194  *
2195  * Return the IRQ corresponding to the passed GPIO, or an error code in case of
2196  * error.
2197  */
2198 int gpiod_to_irq(const struct gpio_desc *desc)
2199 {
2200         struct gpio_chip        *chip;
2201         int                     offset;
2202
2203         if (!desc)
2204                 return -EINVAL;
2205         chip = desc->chip;
2206         offset = gpio_chip_hwgpio(desc);
2207         return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
2208 }
2209 EXPORT_SYMBOL_GPL(gpiod_to_irq);
2210
2211 /**
2212  * gpiod_lock_as_irq() - lock a GPIO to be used as IRQ
2213  * @gpio: the GPIO line to lock as used for IRQ
2214  *
2215  * This is used directly by GPIO drivers that want to lock down
2216  * a certain GPIO line to be used for IRQs.
2217  */
2218 int gpiod_lock_as_irq(struct gpio_desc *desc)
2219 {
2220         if (!desc)
2221                 return -EINVAL;
2222
2223         if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2224                 gpiod_err(desc,
2225                           "%s: tried to flag a GPIO set as output for IRQ\n",
2226                           __func__);
2227                 return -EIO;
2228         }
2229
2230         set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2231         return 0;
2232 }
2233 EXPORT_SYMBOL_GPL(gpiod_lock_as_irq);
2234
2235 int gpio_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2236 {
2237         return gpiod_lock_as_irq(gpiochip_get_desc(chip, offset));
2238 }
2239 EXPORT_SYMBOL_GPL(gpio_lock_as_irq);
2240
2241 /**
2242  * gpiod_unlock_as_irq() - unlock a GPIO used as IRQ
2243  * @gpio: the GPIO line to unlock from IRQ usage
2244  *
2245  * This is used directly by GPIO drivers that want to indicate
2246  * that a certain GPIO is no longer used exclusively for IRQ.
2247  */
2248 void gpiod_unlock_as_irq(struct gpio_desc *desc)
2249 {
2250         if (!desc)
2251                 return;
2252
2253         clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
2254 }
2255 EXPORT_SYMBOL_GPL(gpiod_unlock_as_irq);
2256
2257 void gpio_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2258 {
2259         return gpiod_unlock_as_irq(gpiochip_get_desc(chip, offset));
2260 }
2261 EXPORT_SYMBOL_GPL(gpio_unlock_as_irq);
2262
2263 /**
2264  * gpiod_get_raw_value_cansleep() - return a gpio's raw value
2265  * @desc: gpio whose value will be returned
2266  *
2267  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2268  * its ACTIVE_LOW status.
2269  *
2270  * This function is to be called from contexts that can sleep.
2271  */
2272 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2273 {
2274         might_sleep_if(extra_checks);
2275         if (!desc)
2276                 return 0;
2277         return _gpiod_get_raw_value(desc);
2278 }
2279 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2280
2281 /**
2282  * gpiod_get_value_cansleep() - return a gpio's value
2283  * @desc: gpio whose value will be returned
2284  *
2285  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2286  * account.
2287  *
2288  * This function is to be called from contexts that can sleep.
2289  */
2290 int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2291 {
2292         int value;
2293
2294         might_sleep_if(extra_checks);
2295         if (!desc)
2296                 return 0;
2297
2298         value = _gpiod_get_raw_value(desc);
2299         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2300                 value = !value;
2301
2302         return value;
2303 }
2304 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2305
2306 /**
2307  * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
2308  * @desc: gpio whose value will be assigned
2309  * @value: value to assign
2310  *
2311  * Set the raw value of the GPIO, i.e. the value of its physical line without
2312  * regard for its ACTIVE_LOW status.
2313  *
2314  * This function is to be called from contexts that can sleep.
2315  */
2316 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
2317 {
2318         might_sleep_if(extra_checks);
2319         if (!desc)
2320                 return;
2321         _gpiod_set_raw_value(desc, value);
2322 }
2323 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2324
2325 /**
2326  * gpiod_set_value_cansleep() - assign a gpio's value
2327  * @desc: gpio whose value will be assigned
2328  * @value: value to assign
2329  *
2330  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2331  * account
2332  *
2333  * This function is to be called from contexts that can sleep.
2334  */
2335 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2336 {
2337         might_sleep_if(extra_checks);
2338         if (!desc)
2339                 return;
2340
2341         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2342                 value = !value;
2343         _gpiod_set_raw_value(desc, value);
2344 }
2345 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2346
2347 /**
2348  * gpiod_add_lookup_table() - register GPIO device consumers
2349  * @table: table of consumers to register
2350  */
2351 void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
2352 {
2353         mutex_lock(&gpio_lookup_lock);
2354
2355         list_add_tail(&table->list, &gpio_lookup_list);
2356
2357         mutex_unlock(&gpio_lookup_lock);
2358 }
2359
2360 #ifdef CONFIG_OF
2361 static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2362                                       unsigned int idx,
2363                                       enum gpio_lookup_flags *flags)
2364 {
2365         char prop_name[32]; /* 32 is max size of property name */
2366         enum of_gpio_flags of_flags;
2367         struct gpio_desc *desc;
2368
2369         if (con_id)
2370                 snprintf(prop_name, 32, "%s-gpios", con_id);
2371         else
2372                 snprintf(prop_name, 32, "gpios");
2373
2374         desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
2375                                         &of_flags);
2376
2377         if (IS_ERR(desc))
2378                 return desc;
2379
2380         if (of_flags & OF_GPIO_ACTIVE_LOW)
2381                 *flags |= GPIO_ACTIVE_LOW;
2382
2383         return desc;
2384 }
2385 #else
2386 static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2387                                       unsigned int idx,
2388                                       enum gpio_lookup_flags *flags)
2389 {
2390         return ERR_PTR(-ENODEV);
2391 }
2392 #endif
2393
2394 static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
2395                                         unsigned int idx,
2396                                         enum gpio_lookup_flags *flags)
2397 {
2398         struct acpi_gpio_info info;
2399         struct gpio_desc *desc;
2400
2401         desc = acpi_get_gpiod_by_index(dev, idx, &info);
2402         if (IS_ERR(desc))
2403                 return desc;
2404
2405         if (info.gpioint && info.active_low)
2406                 *flags |= GPIO_ACTIVE_LOW;
2407
2408         return desc;
2409 }
2410
2411 static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2412 {
2413         const char *dev_id = dev ? dev_name(dev) : NULL;
2414         struct gpiod_lookup_table *table;
2415
2416         mutex_lock(&gpio_lookup_lock);
2417
2418         list_for_each_entry(table, &gpio_lookup_list, list) {
2419                 if (table->dev_id && dev_id) {
2420                         /*
2421                          * Valid strings on both ends, must be identical to have
2422                          * a match
2423                          */
2424                         if (!strcmp(table->dev_id, dev_id))
2425                                 goto found;
2426                 } else {
2427                         /*
2428                          * One of the pointers is NULL, so both must be to have
2429                          * a match
2430                          */
2431                         if (dev_id == table->dev_id)
2432                                 goto found;
2433                 }
2434         }
2435         table = NULL;
2436
2437 found:
2438         mutex_unlock(&gpio_lookup_lock);
2439         return table;
2440 }
2441
2442 static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
2443                                     unsigned int idx,
2444                                     enum gpio_lookup_flags *flags)
2445 {
2446         struct gpio_desc *desc = ERR_PTR(-ENOENT);
2447         struct gpiod_lookup_table *table;
2448         struct gpiod_lookup *p;
2449
2450         table = gpiod_find_lookup_table(dev);
2451         if (!table)
2452                 return desc;
2453
2454         for (p = &table->table[0]; p->chip_label; p++) {
2455                 struct gpio_chip *chip;
2456
2457                 /* idx must always match exactly */
2458                 if (p->idx != idx)
2459                         continue;
2460
2461                 /* If the lookup entry has a con_id, require exact match */
2462                 if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
2463                         continue;
2464
2465                 chip = find_chip_by_name(p->chip_label);
2466
2467                 if (!chip) {
2468                         dev_err(dev, "cannot find GPIO chip %s\n",
2469                                 p->chip_label);
2470                         return ERR_PTR(-ENODEV);
2471                 }
2472
2473                 if (chip->ngpio <= p->chip_hwnum) {
2474                         dev_err(dev,
2475                                 "requested GPIO %d is out of range [0..%d] for chip %s\n",
2476                                 idx, chip->ngpio, chip->label);
2477                         return ERR_PTR(-EINVAL);
2478                 }
2479
2480                 desc = gpiochip_get_desc(chip, p->chip_hwnum);
2481                 *flags = p->flags;
2482
2483                 return desc;
2484         }
2485
2486         return desc;
2487 }
2488
2489 /**
2490  * gpio_get - obtain a GPIO for a given GPIO function
2491  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
2492  * @con_id:     function within the GPIO consumer
2493  *
2494  * Return the GPIO descriptor corresponding to the function con_id of device
2495  * dev, -ENOENT if no GPIO has been assigned to the requested function, or
2496  * another IS_ERR() code if an error occured while trying to acquire the GPIO.
2497  */
2498 struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id)
2499 {
2500         return gpiod_get_index(dev, con_id, 0);
2501 }
2502 EXPORT_SYMBOL_GPL(gpiod_get);
2503
2504 /**
2505  * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
2506  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
2507  * @con_id:     function within the GPIO consumer
2508  * @idx:        index of the GPIO to obtain in the consumer
2509  *
2510  * This variant of gpiod_get() allows to access GPIOs other than the first
2511  * defined one for functions that define several GPIOs.
2512  *
2513  * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
2514  * requested function and/or index, or another IS_ERR() code if an error
2515  * occured while trying to acquire the GPIO.
2516  */
2517 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
2518                                                const char *con_id,
2519                                                unsigned int idx)
2520 {
2521         struct gpio_desc *desc = NULL;
2522         int status;
2523         enum gpio_lookup_flags flags = 0;
2524
2525         dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
2526
2527         /* Using device tree? */
2528         if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) {
2529                 dev_dbg(dev, "using device tree for GPIO lookup\n");
2530                 desc = of_find_gpio(dev, con_id, idx, &flags);
2531         } else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev)) {
2532                 dev_dbg(dev, "using ACPI for GPIO lookup\n");
2533                 desc = acpi_find_gpio(dev, con_id, idx, &flags);
2534         }
2535
2536         /*
2537          * Either we are not using DT or ACPI, or their lookup did not return
2538          * a result. In that case, use platform lookup as a fallback.
2539          */
2540         if (!desc || desc == ERR_PTR(-ENOENT)) {
2541                 dev_dbg(dev, "using lookup tables for GPIO lookup");
2542                 desc = gpiod_find(dev, con_id, idx, &flags);
2543         }
2544
2545         if (IS_ERR(desc)) {
2546                 dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
2547                 return desc;
2548         }
2549
2550         status = gpiod_request(desc, con_id);
2551
2552         if (status < 0)
2553                 return ERR_PTR(status);
2554
2555         if (flags & GPIO_ACTIVE_LOW)
2556                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
2557         if (flags & GPIO_OPEN_DRAIN)
2558                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
2559         if (flags & GPIO_OPEN_SOURCE)
2560                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
2561
2562         return desc;
2563 }
2564 EXPORT_SYMBOL_GPL(gpiod_get_index);
2565
2566 /**
2567  * gpiod_put - dispose of a GPIO descriptor
2568  * @desc:       GPIO descriptor to dispose of
2569  *
2570  * No descriptor can be used after gpiod_put() has been called on it.
2571  */
2572 void gpiod_put(struct gpio_desc *desc)
2573 {
2574         gpiod_free(desc);
2575 }
2576 EXPORT_SYMBOL_GPL(gpiod_put);
2577
2578 #ifdef CONFIG_DEBUG_FS
2579
2580 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2581 {
2582         unsigned                i;
2583         unsigned                gpio = chip->base;
2584         struct gpio_desc        *gdesc = &chip->desc[0];
2585         int                     is_out;
2586         int                     is_irq;
2587
2588         for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2589                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2590                         continue;
2591
2592                 gpiod_get_direction(gdesc);
2593                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
2594                 is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
2595                 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s %s",
2596                         gpio, gdesc->label,
2597                         is_out ? "out" : "in ",
2598                         chip->get
2599                                 ? (chip->get(chip, i) ? "hi" : "lo")
2600                                 : "?  ",
2601                         is_irq ? "IRQ" : "   ");
2602                 seq_printf(s, "\n");
2603         }
2604 }
2605
2606 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
2607 {
2608         unsigned long flags;
2609         struct gpio_chip *chip = NULL;
2610         loff_t index = *pos;
2611
2612         s->private = "";
2613
2614         spin_lock_irqsave(&gpio_lock, flags);
2615         list_for_each_entry(chip, &gpio_chips, list)
2616                 if (index-- == 0) {
2617                         spin_unlock_irqrestore(&gpio_lock, flags);
2618                         return chip;
2619                 }
2620         spin_unlock_irqrestore(&gpio_lock, flags);
2621
2622         return NULL;
2623 }
2624
2625 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2626 {
2627         unsigned long flags;
2628         struct gpio_chip *chip = v;
2629         void *ret = NULL;
2630
2631         spin_lock_irqsave(&gpio_lock, flags);
2632         if (list_is_last(&chip->list, &gpio_chips))
2633                 ret = NULL;
2634         else
2635                 ret = list_entry(chip->list.next, struct gpio_chip, list);
2636         spin_unlock_irqrestore(&gpio_lock, flags);
2637
2638         s->private = "\n";
2639         ++*pos;
2640
2641         return ret;
2642 }
2643
2644 static void gpiolib_seq_stop(struct seq_file *s, void *v)
2645 {
2646 }
2647
2648 static int gpiolib_seq_show(struct seq_file *s, void *v)
2649 {
2650         struct gpio_chip *chip = v;
2651         struct device *dev;
2652
2653         seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2654                         chip->base, chip->base + chip->ngpio - 1);
2655         dev = chip->dev;
2656         if (dev)
2657                 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2658                         dev_name(dev));
2659         if (chip->label)
2660                 seq_printf(s, ", %s", chip->label);
2661         if (chip->can_sleep)
2662                 seq_printf(s, ", can sleep");
2663         seq_printf(s, ":\n");
2664
2665         if (chip->dbg_show)
2666                 chip->dbg_show(s, chip);
2667         else
2668                 gpiolib_dbg_show(s, chip);
2669
2670         return 0;
2671 }
2672
2673 static const struct seq_operations gpiolib_seq_ops = {
2674         .start = gpiolib_seq_start,
2675         .next = gpiolib_seq_next,
2676         .stop = gpiolib_seq_stop,
2677         .show = gpiolib_seq_show,
2678 };
2679
2680 static int gpiolib_open(struct inode *inode, struct file *file)
2681 {
2682         return seq_open(file, &gpiolib_seq_ops);
2683 }
2684
2685 static const struct file_operations gpiolib_operations = {
2686         .owner          = THIS_MODULE,
2687         .open           = gpiolib_open,
2688         .read           = seq_read,
2689         .llseek         = seq_lseek,
2690         .release        = seq_release,
2691 };
2692
2693 static int __init gpiolib_debugfs_init(void)
2694 {
2695         /* /sys/kernel/debug/gpio */
2696         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2697                                 NULL, NULL, &gpiolib_operations);
2698         return 0;
2699 }
2700 subsys_initcall(gpiolib_debugfs_init);
2701
2702 #endif  /* DEBUG_FS */