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
  16 #define CREATE_TRACE_POINTS
  17 #include <trace/events/gpio.h>
  18
  19 /* Optional implementation infrastructure for GPIO interfaces.
  20  *
  21  * Platforms may want to use this if they tend to use very many GPIOs
  22  * that aren't part of a System-On-Chip core; or across I2C/SPI/etc.
  23  *
  24  * When kernel footprint or instruction count is an issue, simpler
  25  * implementations may be preferred.  The GPIO programming interface
  26  * allows for inlining speed-critical get/set operations for common
  27  * cases, so that access to SOC-integrated GPIOs can sometimes cost
  28  * only an instruction or two per bit.
  29  */
  30
  31
  32 /* When debugging, extend minimal trust to callers and platform code.
  33  * Also emit diagnostic messages that may help initial bringup, when
  34  * board setup or driver bugs are most common.
  35  *
  36  * Otherwise, minimize overhead in what may be bitbanging codepaths.
  37  */
  38 #ifdef  DEBUG
  39 #define extra_checks    1
  40 #else
  41 #define extra_checks    0
  42 #endif
  43
  44 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
  45  * While any GPIO is requested, its gpio_chip is not removable;
  46  * each GPIO's "requested" flag serves as a lock and refcount.
  47  */
  48 static DEFINE_SPINLOCK(gpio_lock);
  49
  50 struct gpio_desc {
  51         struct gpio_chip        *chip;
  52         unsigned long           flags;
  53 /* flag symbols are bit numbers */
  54 #define FLAG_REQUESTED  0
  55 #define FLAG_IS_OUT     1
  56 #define FLAG_EXPORT     2       /* protected by sysfs_lock */
  57 #define FLAG_SYSFS      3       /* exported via /sys/class/gpio/control */
  58 #define FLAG_TRIG_FALL  4       /* trigger on falling edge */
  59 #define FLAG_TRIG_RISE  5       /* trigger on rising edge */
  60 #define FLAG_ACTIVE_LOW 6       /* sysfs value has active low */
  61 #define FLAG_OPEN_DRAIN 7       /* Gpio is open drain type */
  62 #define FLAG_OPEN_SOURCE 8      /* Gpio is open source type */
  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 LIST_HEAD(gpio_chips);
  78
  79 #ifdef CONFIG_GPIO_SYSFS
  80 static DEFINE_IDR(dirent_idr);
  81 #endif
  82
  83 /*
  84  * Internal gpiod_* API using descriptors instead of the integer namespace.
  85  * Most of this should eventually go public.
  86  */
  87 static int gpiod_request(struct gpio_desc *desc, const char *label);
  88 static void gpiod_free(struct gpio_desc *desc);
  89 static int gpiod_direction_input(struct gpio_desc *desc);
  90 static int gpiod_direction_output(struct gpio_desc *desc, int value);
  91 static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
  92 static int gpiod_get_value_cansleep(struct gpio_desc *desc);
  93 static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
  94 static int gpiod_get_value(struct gpio_desc *desc);
  95 static void gpiod_set_value(struct gpio_desc *desc, int value);
  96 static int gpiod_cansleep(struct gpio_desc *desc);
  97 static int gpiod_to_irq(struct gpio_desc *desc);
  98 static int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
  99 static int gpiod_export_link(struct device *dev, const char *name,
 100                              struct gpio_desc *desc);
 101 static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
 102 static void gpiod_unexport(struct gpio_desc *desc);
 103
 104
 105 static inline void desc_set_label(struct gpio_desc *d, const char *label)
 106 {
 107 #ifdef CONFIG_DEBUG_FS
 108         d->label = label;
 109 #endif
 110 }
 111
 112 /*
 113  * Return the GPIO number of the passed descriptor relative to its chip
 114  */
 115 static int gpio_chip_hwgpio(const struct gpio_desc *desc)
 116 {
 117         return desc - &desc->chip->desc[0];
 118 }
 119
 120 /**
 121  * Convert a GPIO number to its descriptor
 122  */
 123 static struct gpio_desc *gpio_to_desc(unsigned gpio)
 124 {
 125         if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
 126                 return NULL;
 127         else
 128                 return &gpio_desc[gpio];
 129 }
 130
 131 /**
 132  * Convert a GPIO descriptor to the integer namespace.
 133  * This should disappear in the future but is needed since we still
 134  * use GPIO numbers for error messages and sysfs nodes
 135  */
 136 static int desc_to_gpio(const struct gpio_desc *desc)
 137 {
 138         return desc->chip->base + gpio_chip_hwgpio(desc);
 139 }
 140
 141
 142 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
 143  * when setting direction, and otherwise illegal.  Until board setup code
 144  * and drivers use explicit requests everywhere (which won't happen when
 145  * those calls have no teeth) we can't avoid autorequesting.  This nag
 146  * message should motivate switching to explicit requests... so should
 147  * the weaker cleanup after faults, compared to gpio_request().
 148  *
 149  * NOTE: the autorequest mechanism is going away; at this point it's
 150  * only "legal" in the sense that (old) code using it won't break yet,
 151  * but instead only triggers a WARN() stack dump.
 152  */
 153 static int gpio_ensure_requested(struct gpio_desc *desc)
 154 {
 155         const struct gpio_chip *chip = desc->chip;
 156         const int gpio = desc_to_gpio(desc);
 157
 158         if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
 159                         "autorequest GPIO-%d\n", gpio)) {
 160                 if (!try_module_get(chip->owner)) {
 161                         pr_err("GPIO-%d: module can't be gotten \n", gpio);
 162                         clear_bit(FLAG_REQUESTED, &desc->flags);
 163                         /* lose */
 164                         return -EIO;
 165                 }
 166                 desc_set_label(desc, "[auto]");
 167                 /* caller must chip->request() w/o spinlock */
 168                 if (chip->request)
 169                         return 1;
 170         }
 171         return 0;
 172 }
 173
 174 /* caller holds gpio_lock *OR* gpio is marked as requested */
 175 static struct gpio_chip *gpiod_to_chip(struct gpio_desc *desc)
 176 {
 177         return desc->chip;
 178 }
 179
 180 struct gpio_chip *gpio_to_chip(unsigned gpio)
 181 {
 182         return gpiod_to_chip(gpio_to_desc(gpio));
 183 }
 184
 185 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
 186 static int gpiochip_find_base(int ngpio)
 187 {
 188         struct gpio_chip *chip;
 189         int base = ARCH_NR_GPIOS - ngpio;
 190
 191         list_for_each_entry_reverse(chip, &gpio_chips, list) {
 192                 /* found a free space? */
 193                 if (chip->base + chip->ngpio <= base)
 194                         break;
 195                 else
 196                         /* nope, check the space right before the chip */
 197                         base = chip->base - ngpio;
 198         }
 199
 200         if (gpio_is_valid(base)) {
 201                 pr_debug("%s: found new base at %d\n", __func__, base);
 202                 return base;
 203         } else {
 204                 pr_err("%s: cannot find free range\n", __func__);
 205                 return -ENOSPC;
 206         }
 207 }
 208
 209 /* caller ensures gpio is valid and requested, chip->get_direction may sleep  */
 210 static int gpiod_get_direction(struct gpio_desc *desc)
 211 {
 212         struct gpio_chip        *chip;
 213         unsigned                offset;
 214         int                     status = -EINVAL;
 215
 216         chip = gpiod_to_chip(desc);
 217         offset = gpio_chip_hwgpio(desc);
 218
 219         if (!chip->get_direction)
 220                 return status;
 221
 222         status = chip->get_direction(chip, offset);
 223         if (status > 0) {
 224                 /* GPIOF_DIR_IN, or other positive */
 225                 status = 1;
 226                 clear_bit(FLAG_IS_OUT, &desc->flags);
 227         }
 228         if (status == 0) {
 229                 /* GPIOF_DIR_OUT */
 230                 set_bit(FLAG_IS_OUT, &desc->flags);
 231         }
 232         return status;
 233 }
 234
 235 #ifdef CONFIG_GPIO_SYSFS
 236
 237 /* lock protects against unexport_gpio() being called while
 238  * sysfs files are active.
 239  */
 240 static DEFINE_MUTEX(sysfs_lock);
 241
 242 /*
 243  * /sys/class/gpio/gpioN... only for GPIOs that are exported
 244  *   /direction
 245  *      * MAY BE OMITTED if kernel won't allow direction changes
 246  *      * is read/write as "in" or "out"
 247  *      * may also be written as "high" or "low", initializing
 248  *        output value as specified ("out" implies "low")
 249  *   /value
 250  *      * always readable, subject to hardware behavior
 251  *      * may be writable, as zero/nonzero
 252  *   /edge
 253  *      * configures behavior of poll(2) on /value
 254  *      * available only if pin can generate IRQs on input
 255  *      * is read/write as "none", "falling", "rising", or "both"
 256  *   /active_low
 257  *      * configures polarity of /value
 258  *      * is read/write as zero/nonzero
 259  *      * also affects existing and subsequent "falling" and "rising"
 260  *        /edge configuration
 261  */
 262
 263 static ssize_t gpio_direction_show(struct device *dev,
 264                 struct device_attribute *attr, char *buf)
 265 {
 266         struct gpio_desc        *desc = dev_get_drvdata(dev);
 267         ssize_t                 status;
 268
 269         mutex_lock(&sysfs_lock);
 270
 271         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
 272                 status = -EIO;
 273         } else {
 274                 gpiod_get_direction(desc);
 275                 status = sprintf(buf, "%s\n",
 276                         test_bit(FLAG_IS_OUT, &desc->flags)
 277                                 ? "out" : "in");
 278         }
 279
 280         mutex_unlock(&sysfs_lock);
 281         return status;
 282 }
 283
 284 static ssize_t gpio_direction_store(struct device *dev,
 285                 struct device_attribute *attr, const char *buf, size_t size)
 286 {
 287         struct gpio_desc        *desc = dev_get_drvdata(dev);
 288         ssize_t                 status;
 289
 290         mutex_lock(&sysfs_lock);
 291
 292         if (!test_bit(FLAG_EXPORT, &desc->flags))
 293                 status = -EIO;
 294         else if (sysfs_streq(buf, "high"))
 295                 status = gpiod_direction_output(desc, 1);
 296         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
 297                 status = gpiod_direction_output(desc, 0);
 298         else if (sysfs_streq(buf, "in"))
 299                 status = gpiod_direction_input(desc);
 300         else
 301                 status = -EINVAL;
 302
 303         mutex_unlock(&sysfs_lock);
 304         return status ? : size;
 305 }
 306
 307 static /* const */ DEVICE_ATTR(direction, 0644,
 308                 gpio_direction_show, gpio_direction_store);
 309
 310 static ssize_t gpio_value_show(struct device *dev,
 311                 struct device_attribute *attr, char *buf)
 312 {
 313         struct gpio_desc        *desc = dev_get_drvdata(dev);
 314         ssize_t                 status;
 315
 316         mutex_lock(&sysfs_lock);
 317
 318         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
 319                 status = -EIO;
 320         } else {
 321                 int value;
 322
 323                 value = !!gpiod_get_value_cansleep(desc);
 324                 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
 325                         value = !value;
 326
 327                 status = sprintf(buf, "%d\n", value);
 328         }
 329
 330         mutex_unlock(&sysfs_lock);
 331         return status;
 332 }
 333
 334 static ssize_t gpio_value_store(struct device *dev,
 335                 struct device_attribute *attr, const char *buf, size_t size)
 336 {
 337         struct gpio_desc        *desc = dev_get_drvdata(dev);
 338         ssize_t                 status;
 339
 340         mutex_lock(&sysfs_lock);
 341
 342         if (!test_bit(FLAG_EXPORT, &desc->flags))
 343                 status = -EIO;
 344         else if (!test_bit(FLAG_IS_OUT, &desc->flags))
 345                 status = -EPERM;
 346         else {
 347                 long            value;
 348
 349                 status = strict_strtol(buf, 0, &value);
 350                 if (status == 0) {
 351                         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
 352                                 value = !value;
 353                         gpiod_set_value_cansleep(desc, value != 0);
 354                         status = size;
 355                 }
 356         }
 357
 358         mutex_unlock(&sysfs_lock);
 359         return status;
 360 }
 361
 362 static const DEVICE_ATTR(value, 0644,
 363                 gpio_value_show, gpio_value_store);
 364
 365 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
 366 {
 367         struct sysfs_dirent     *value_sd = priv;
 368
 369         sysfs_notify_dirent(value_sd);
 370         return IRQ_HANDLED;
 371 }
 372
 373 static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
 374                 unsigned long gpio_flags)
 375 {
 376         struct sysfs_dirent     *value_sd;
 377         unsigned long           irq_flags;
 378         int                     ret, irq, id;
 379
 380         if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
 381                 return 0;
 382
 383         irq = gpiod_to_irq(desc);
 384         if (irq < 0)
 385                 return -EIO;
 386
 387         id = desc->flags >> ID_SHIFT;
 388         value_sd = idr_find(&dirent_idr, id);
 389         if (value_sd)
 390                 free_irq(irq, value_sd);
 391
 392         desc->flags &= ~GPIO_TRIGGER_MASK;
 393
 394         if (!gpio_flags) {
 395                 ret = 0;
 396                 goto free_id;
 397         }
 398
 399         irq_flags = IRQF_SHARED;
 400         if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
 401                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 402                         IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
 403         if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
 404                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 405                         IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
 406
 407         if (!value_sd) {
 408                 value_sd = sysfs_get_dirent(dev->kobj.sd, NULL, "value");
 409                 if (!value_sd) {
 410                         ret = -ENODEV;
 411                         goto err_out;
 412                 }
 413
 414                 do {
 415                         ret = -ENOMEM;
 416                         if (idr_pre_get(&dirent_idr, GFP_KERNEL))
 417                                 ret = idr_get_new_above(&dirent_idr, value_sd,
 418                                                         1, &id);
 419                 } while (ret == -EAGAIN);
 420
 421                 if (ret)
 422                         goto free_sd;
 423
 424                 desc->flags &= GPIO_FLAGS_MASK;
 425                 desc->flags |= (unsigned long)id << ID_SHIFT;
 426
 427                 if (desc->flags >> ID_SHIFT != id) {
 428                         ret = -ERANGE;
 429                         goto free_id;
 430                 }
 431         }
 432
 433         ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
 434                                 "gpiolib", value_sd);
 435         if (ret < 0)
 436                 goto free_id;
 437
 438         desc->flags |= gpio_flags;
 439         return 0;
 440
 441 free_id:
 442         idr_remove(&dirent_idr, id);
 443         desc->flags &= GPIO_FLAGS_MASK;
 444 free_sd:
 445         if (value_sd)
 446                 sysfs_put(value_sd);
 447 err_out:
 448         return ret;
 449 }
 450
 451 static const struct {
 452         const char *name;
 453         unsigned long flags;
 454 } trigger_types[] = {
 455         { "none",    0 },
 456         { "falling", BIT(FLAG_TRIG_FALL) },
 457         { "rising",  BIT(FLAG_TRIG_RISE) },
 458         { "both",    BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
 459 };
 460
 461 static ssize_t gpio_edge_show(struct device *dev,
 462                 struct device_attribute *attr, char *buf)
 463 {
 464         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 465         ssize_t                 status;
 466
 467         mutex_lock(&sysfs_lock);
 468
 469         if (!test_bit(FLAG_EXPORT, &desc->flags))
 470                 status = -EIO;
 471         else {
 472                 int i;
 473
 474                 status = 0;
 475                 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
 476                         if ((desc->flags & GPIO_TRIGGER_MASK)
 477                                         == trigger_types[i].flags) {
 478                                 status = sprintf(buf, "%s\n",
 479                                                  trigger_types[i].name);
 480                                 break;
 481                         }
 482         }
 483
 484         mutex_unlock(&sysfs_lock);
 485         return status;
 486 }
 487
 488 static ssize_t gpio_edge_store(struct device *dev,
 489                 struct device_attribute *attr, const char *buf, size_t size)
 490 {
 491         struct gpio_desc        *desc = dev_get_drvdata(dev);
 492         ssize_t                 status;
 493         int                     i;
 494
 495         for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
 496                 if (sysfs_streq(trigger_types[i].name, buf))
 497                         goto found;
 498         return -EINVAL;
 499
 500 found:
 501         mutex_lock(&sysfs_lock);
 502
 503         if (!test_bit(FLAG_EXPORT, &desc->flags))
 504                 status = -EIO;
 505         else {
 506                 status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
 507                 if (!status)
 508                         status = size;
 509         }
 510
 511         mutex_unlock(&sysfs_lock);
 512
 513         return status;
 514 }
 515
 516 static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
 517
 518 static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
 519                                 int value)
 520 {
 521         int                     status = 0;
 522
 523         if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
 524                 return 0;
 525
 526         if (value)
 527                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 528         else
 529                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
 530
 531         /* reconfigure poll(2) support if enabled on one edge only */
 532         if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
 533                                 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
 534                 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
 535
 536                 gpio_setup_irq(desc, dev, 0);
 537                 status = gpio_setup_irq(desc, dev, trigger_flags);
 538         }
 539
 540         return status;
 541 }
 542
 543 static ssize_t gpio_active_low_show(struct device *dev,
 544                 struct device_attribute *attr, char *buf)
 545 {
 546         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 547         ssize_t                 status;
 548
 549         mutex_lock(&sysfs_lock);
 550
 551         if (!test_bit(FLAG_EXPORT, &desc->flags))
 552                 status = -EIO;
 553         else
 554                 status = sprintf(buf, "%d\n",
 555                                 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
 556
 557         mutex_unlock(&sysfs_lock);
 558
 559         return status;
 560 }
 561
 562 static ssize_t gpio_active_low_store(struct device *dev,
 563                 struct device_attribute *attr, const char *buf, size_t size)
 564 {
 565         struct gpio_desc        *desc = dev_get_drvdata(dev);
 566         ssize_t                 status;
 567
 568         mutex_lock(&sysfs_lock);
 569
 570         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
 571                 status = -EIO;
 572         } else {
 573                 long            value;
 574
 575                 status = strict_strtol(buf, 0, &value);
 576                 if (status == 0)
 577                         status = sysfs_set_active_low(desc, dev, value != 0);
 578         }
 579
 580         mutex_unlock(&sysfs_lock);
 581
 582         return status ? : size;
 583 }
 584
 585 static const DEVICE_ATTR(active_low, 0644,
 586                 gpio_active_low_show, gpio_active_low_store);
 587
 588 static const struct attribute *gpio_attrs[] = {
 589         &dev_attr_value.attr,
 590         &dev_attr_active_low.attr,
 591         NULL,
 592 };
 593
 594 static const struct attribute_group gpio_attr_group = {
 595         .attrs = (struct attribute **) gpio_attrs,
 596 };
 597
 598 /*
 599  * /sys/class/gpio/gpiochipN/
 600  *   /base ... matching gpio_chip.base (N)
 601  *   /label ... matching gpio_chip.label
 602  *   /ngpio ... matching gpio_chip.ngpio
 603  */
 604
 605 static ssize_t chip_base_show(struct device *dev,
 606                                struct device_attribute *attr, char *buf)
 607 {
 608         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 609
 610         return sprintf(buf, "%d\n", chip->base);
 611 }
 612 static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
 613
 614 static ssize_t chip_label_show(struct device *dev,
 615                                struct device_attribute *attr, char *buf)
 616 {
 617         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 618
 619         return sprintf(buf, "%s\n", chip->label ? : "");
 620 }
 621 static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
 622
 623 static ssize_t chip_ngpio_show(struct device *dev,
 624                                struct device_attribute *attr, char *buf)
 625 {
 626         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 627
 628         return sprintf(buf, "%u\n", chip->ngpio);
 629 }
 630 static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
 631
 632 static const struct attribute *gpiochip_attrs[] = {
 633         &dev_attr_base.attr,
 634         &dev_attr_label.attr,
 635         &dev_attr_ngpio.attr,
 636         NULL,
 637 };
 638
 639 static const struct attribute_group gpiochip_attr_group = {
 640         .attrs = (struct attribute **) gpiochip_attrs,
 641 };
 642
 643 /*
 644  * /sys/class/gpio/export ... write-only
 645  *      integer N ... number of GPIO to export (full access)
 646  * /sys/class/gpio/unexport ... write-only
 647  *      integer N ... number of GPIO to unexport
 648  */
 649 static ssize_t export_store(struct class *class,
 650                                 struct class_attribute *attr,
 651                                 const char *buf, size_t len)
 652 {
 653         long                    gpio;
 654         struct gpio_desc        *desc;
 655         int                     status;
 656
 657         status = strict_strtol(buf, 0, &gpio);
 658         if (status < 0)
 659                 goto done;
 660
 661         desc = gpio_to_desc(gpio);
 662
 663         /* No extra locking here; FLAG_SYSFS just signifies that the
 664          * request and export were done by on behalf of userspace, so
 665          * they may be undone on its behalf too.
 666          */
 667
 668         status = gpiod_request(desc, "sysfs");
 669         if (status < 0) {
 670                 if (status == -EPROBE_DEFER)
 671                         status = -ENODEV;
 672                 goto done;
 673         }
 674         status = gpiod_export(desc, true);
 675         if (status < 0)
 676                 gpiod_free(desc);
 677         else
 678                 set_bit(FLAG_SYSFS, &desc->flags);
 679
 680 done:
 681         if (status)
 682                 pr_debug("%s: status %d\n", __func__, status);
 683         return status ? : len;
 684 }
 685
 686 static ssize_t unexport_store(struct class *class,
 687                                 struct class_attribute *attr,
 688                                 const char *buf, size_t len)
 689 {
 690         long                    gpio;
 691         struct gpio_desc        *desc;
 692         int                     status;
 693
 694         status = strict_strtol(buf, 0, &gpio);
 695         if (status < 0)
 696                 goto done;
 697
 698         status = -EINVAL;
 699
 700         desc = gpio_to_desc(gpio);
 701         /* reject bogus commands (gpio_unexport ignores them) */
 702         if (!desc)
 703                 goto done;
 704
 705         /* No extra locking here; FLAG_SYSFS just signifies that the
 706          * request and export were done by on behalf of userspace, so
 707          * they may be undone on its behalf too.
 708          */
 709         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
 710                 status = 0;
 711                 gpiod_free(desc);
 712         }
 713 done:
 714         if (status)
 715                 pr_debug("%s: status %d\n", __func__, status);
 716         return status ? : len;
 717 }
 718
 719 static struct class_attribute gpio_class_attrs[] = {
 720         __ATTR(export, 0200, NULL, export_store),
 721         __ATTR(unexport, 0200, NULL, unexport_store),
 722         __ATTR_NULL,
 723 };
 724
 725 static struct class gpio_class = {
 726         .name =         "gpio",
 727         .owner =        THIS_MODULE,
 728
 729         .class_attrs =  gpio_class_attrs,
 730 };
 731
 732
 733 /**
 734  * gpio_export - export a GPIO through sysfs
 735  * @gpio: gpio to make available, already requested
 736  * @direction_may_change: true if userspace may change gpio direction
 737  * Context: arch_initcall or later
 738  *
 739  * When drivers want to make a GPIO accessible to userspace after they
 740  * have requested it -- perhaps while debugging, or as part of their
 741  * public interface -- they may use this routine.  If the GPIO can
 742  * change direction (some can't) and the caller allows it, userspace
 743  * will see "direction" sysfs attribute which may be used to change
 744  * the gpio's direction.  A "value" attribute will always be provided.
 745  *
 746  * Returns zero on success, else an error.
 747  */
 748 static int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 749 {
 750         unsigned long           flags;
 751         int                     status;
 752         const char              *ioname = NULL;
 753         struct device           *dev;
 754         int                     offset;
 755
 756         /* can't export until sysfs is available ... */
 757         if (!gpio_class.p) {
 758                 pr_debug("%s: called too early!\n", __func__);
 759                 return -ENOENT;
 760         }
 761
 762         if (!desc) {
 763                 pr_debug("%s: invalid gpio descriptor\n", __func__);
 764                 return -EINVAL;
 765         }
 766
 767         mutex_lock(&sysfs_lock);
 768
 769         spin_lock_irqsave(&gpio_lock, flags);
 770         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
 771              test_bit(FLAG_EXPORT, &desc->flags)) {
 772                 spin_unlock_irqrestore(&gpio_lock, flags);
 773                 pr_debug("%s: gpio %d unavailable (requested=%d, exported=%d)\n",
 774                                 __func__, desc_to_gpio(desc),
 775                                 test_bit(FLAG_REQUESTED, &desc->flags),
 776                                 test_bit(FLAG_EXPORT, &desc->flags));
 777                 status = -EPERM;
 778                 goto fail_unlock;
 779         }
 780
 781         if (!desc->chip->direction_input || !desc->chip->direction_output)
 782                 direction_may_change = false;
 783         spin_unlock_irqrestore(&gpio_lock, flags);
 784
 785         offset = gpio_chip_hwgpio(desc);
 786         if (desc->chip->names && desc->chip->names[offset])
 787                 ioname = desc->chip->names[offset];
 788
 789         dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
 790                             desc, ioname ? ioname : "gpio%u",
 791                             desc_to_gpio(desc));
 792         if (IS_ERR(dev)) {
 793                 status = PTR_ERR(dev);
 794                 goto fail_unlock;
 795         }
 796
 797         status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
 798         if (status)
 799                 goto fail_unregister_device;
 800
 801         if (direction_may_change) {
 802                 status = device_create_file(dev, &dev_attr_direction);
 803                 if (status)
 804                         goto fail_unregister_device;
 805         }
 806
 807         if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
 808                                        !test_bit(FLAG_IS_OUT, &desc->flags))) {
 809                 status = device_create_file(dev, &dev_attr_edge);
 810                 if (status)
 811                         goto fail_unregister_device;
 812         }
 813
 814         set_bit(FLAG_EXPORT, &desc->flags);
 815         mutex_unlock(&sysfs_lock);
 816         return 0;
 817
 818 fail_unregister_device:
 819         device_unregister(dev);
 820 fail_unlock:
 821         mutex_unlock(&sysfs_lock);
 822         pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
 823                  status);
 824         return status;
 825 }
 826
 827 int gpio_export(unsigned gpio, bool direction_may_change)
 828 {
 829         return gpiod_export(gpio_to_desc(gpio), direction_may_change);
 830 }
 831 EXPORT_SYMBOL_GPL(gpio_export);
 832
 833 static int match_export(struct device *dev, const void *data)
 834 {
 835         return dev_get_drvdata(dev) == data;
 836 }
 837
 838 /**
 839  * gpio_export_link - create a sysfs link to an exported GPIO node
 840  * @dev: device under which to create symlink
 841  * @name: name of the symlink
 842  * @gpio: gpio to create symlink to, already exported
 843  *
 844  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 845  * node. Caller is responsible for unlinking.
 846  *
 847  * Returns zero on success, else an error.
 848  */
 849 static int gpiod_export_link(struct device *dev, const char *name,
 850                              struct gpio_desc *desc)
 851 {
 852         int                     status = -EINVAL;
 853
 854         if (!desc)
 855                 goto done;
 856
 857         mutex_lock(&sysfs_lock);
 858
 859         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 860                 struct device *tdev;
 861
 862                 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
 863                 if (tdev != NULL) {
 864                         status = sysfs_create_link(&dev->kobj, &tdev->kobj,
 865                                                 name);
 866                 } else {
 867                         status = -ENODEV;
 868                 }
 869         }
 870
 871         mutex_unlock(&sysfs_lock);
 872
 873 done:
 874         if (status)
 875                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
 876                          status);
 877
 878         return status;
 879 }
 880
 881 int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
 882 {
 883         return gpiod_export_link(dev, name, gpio_to_desc(gpio));
 884 }
 885 EXPORT_SYMBOL_GPL(gpio_export_link);
 886
 887 /**
 888  * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value
 889  * @gpio: gpio to change
 890  * @value: non-zero to use active low, i.e. inverted values
 891  *
 892  * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
 893  * The GPIO does not have to be exported yet.  If poll(2) support has
 894  * been enabled for either rising or falling edge, it will be
 895  * reconfigured to follow the new polarity.
 896  *
 897  * Returns zero on success, else an error.
 898  */
 899 static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
 900 {
 901         struct device           *dev = NULL;
 902         int                     status = -EINVAL;
 903
 904         if (!desc)
 905                 goto done;
 906
 907         mutex_lock(&sysfs_lock);
 908
 909         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 910                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
 911                 if (dev == NULL) {
 912                         status = -ENODEV;
 913                         goto unlock;
 914                 }
 915         }
 916
 917         status = sysfs_set_active_low(desc, dev, value);
 918
 919 unlock:
 920         mutex_unlock(&sysfs_lock);
 921
 922 done:
 923         if (status)
 924                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
 925                          status);
 926
 927         return status;
 928 }
 929
 930 int gpio_sysfs_set_active_low(unsigned gpio, int value)
 931 {
 932         return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
 933 }
 934 EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low);
 935
 936 /**
 937  * gpio_unexport - reverse effect of gpio_export()
 938  * @gpio: gpio to make unavailable
 939  *
 940  * This is implicit on gpio_free().
 941  */
 942 static void gpiod_unexport(struct gpio_desc *desc)
 943 {
 944         int                     status = 0;
 945         struct device           *dev = NULL;
 946
 947         if (!desc) {
 948                 status = -EINVAL;
 949                 goto done;
 950         }
 951
 952         mutex_lock(&sysfs_lock);
 953
 954         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 955
 956                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
 957                 if (dev) {
 958                         gpio_setup_irq(desc, dev, 0);
 959                         clear_bit(FLAG_EXPORT, &desc->flags);
 960                 } else
 961                         status = -ENODEV;
 962         }
 963
 964         mutex_unlock(&sysfs_lock);
 965
 966         if (dev) {
 967                 device_unregister(dev);
 968                 put_device(dev);
 969         }
 970 done:
 971         if (status)
 972                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
 973                          status);
 974 }
 975
 976 void gpio_unexport(unsigned gpio)
 977 {
 978         gpiod_unexport(gpio_to_desc(gpio));
 979 }
 980 EXPORT_SYMBOL_GPL(gpio_unexport);
 981
 982 static int gpiochip_export(struct gpio_chip *chip)
 983 {
 984         int             status;
 985         struct device   *dev;
 986
 987         /* Many systems register gpio chips for SOC support very early,
 988          * before driver model support is available.  In those cases we
 989          * export this later, in gpiolib_sysfs_init() ... here we just
 990          * verify that _some_ field of gpio_class got initialized.
 991          */
 992         if (!gpio_class.p)
 993                 return 0;
 994
 995         /* use chip->base for the ID; it's already known to be unique */
 996         mutex_lock(&sysfs_lock);
 997         dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
 998                                 "gpiochip%d", chip->base);
 999         if (!IS_ERR(dev)) {
1000                 status = sysfs_create_group(&dev->kobj,
1001                                 &gpiochip_attr_group);
1002         } else
1003                 status = PTR_ERR(dev);
1004         chip->exported = (status == 0);
1005         mutex_unlock(&sysfs_lock);
1006
1007         if (status) {
1008                 unsigned long   flags;
1009                 unsigned        gpio;
1010
1011                 spin_lock_irqsave(&gpio_lock, flags);
1012                 gpio = 0;
1013                 while (gpio < chip->ngpio)
1014                         chip->desc[gpio++].chip = NULL;
1015                 spin_unlock_irqrestore(&gpio_lock, flags);
1016
1017                 pr_debug("%s: chip %s status %d\n", __func__,
1018                                 chip->label, status);
1019         }
1020
1021         return status;
1022 }
1023
1024 static void gpiochip_unexport(struct gpio_chip *chip)
1025 {
1026         int                     status;
1027         struct device           *dev;
1028
1029         mutex_lock(&sysfs_lock);
1030         dev = class_find_device(&gpio_class, NULL, chip, match_export);
1031         if (dev) {
1032                 put_device(dev);
1033                 device_unregister(dev);
1034                 chip->exported = 0;
1035                 status = 0;
1036         } else
1037                 status = -ENODEV;
1038         mutex_unlock(&sysfs_lock);
1039
1040         if (status)
1041                 pr_debug("%s: chip %s status %d\n", __func__,
1042                                 chip->label, status);
1043 }
1044
1045 static int __init gpiolib_sysfs_init(void)
1046 {
1047         int             status;
1048         unsigned long   flags;
1049         struct gpio_chip *chip;
1050
1051         status = class_register(&gpio_class);
1052         if (status < 0)
1053                 return status;
1054
1055         /* Scan and register the gpio_chips which registered very
1056          * early (e.g. before the class_register above was called).
1057          *
1058          * We run before arch_initcall() so chip->dev nodes can have
1059          * registered, and so arch_initcall() can always gpio_export().
1060          */
1061         spin_lock_irqsave(&gpio_lock, flags);
1062         list_for_each_entry(chip, &gpio_chips, list) {
1063                 if (!chip || chip->exported)
1064                         continue;
1065
1066                 spin_unlock_irqrestore(&gpio_lock, flags);
1067                 status = gpiochip_export(chip);
1068                 spin_lock_irqsave(&gpio_lock, flags);
1069         }
1070         spin_unlock_irqrestore(&gpio_lock, flags);
1071
1072
1073         return status;
1074 }
1075 postcore_initcall(gpiolib_sysfs_init);
1076
1077 #else
1078 static inline int gpiochip_export(struct gpio_chip *chip)
1079 {
1080         return 0;
1081 }
1082
1083 static inline void gpiochip_unexport(struct gpio_chip *chip)
1084 {
1085 }
1086
1087 static inline int gpiod_export(struct gpio_desc *desc,
1088                                bool direction_may_change)
1089 {
1090         return -ENOSYS;
1091 }
1092
1093 static inline int gpiod_export_link(struct device *dev, const char *name,
1094                                     struct gpio_desc *desc)
1095 {
1096         return -ENOSYS;
1097 }
1098
1099 static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
1100 {
1101         return -ENOSYS;
1102 }
1103
1104 static inline void gpiod_unexport(struct gpio_desc *desc)
1105 {
1106 }
1107
1108 #endif /* CONFIG_GPIO_SYSFS */
1109
1110 /*
1111  * Add a new chip to the global chips list, keeping the list of chips sorted
1112  * by base order.
1113  *
1114  * Return -EBUSY if the new chip overlaps with some other chip's integer
1115  * space.
1116  */
1117 static int gpiochip_add_to_list(struct gpio_chip *chip)
1118 {
1119         struct list_head *pos = &gpio_chips;
1120         struct gpio_chip *_chip;
1121         int err = 0;
1122
1123         /* find where to insert our chip */
1124         list_for_each(pos, &gpio_chips) {
1125                 _chip = list_entry(pos, struct gpio_chip, list);
1126                 /* shall we insert before _chip? */
1127                 if (_chip->base >= chip->base + chip->ngpio)
1128                         break;
1129         }
1130
1131         /* are we stepping on the chip right before? */
1132         if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1133                 _chip = list_entry(pos->prev, struct gpio_chip, list);
1134                 if (_chip->base + _chip->ngpio > chip->base) {
1135                         dev_err(chip->dev,
1136                                "GPIO integer space overlap, cannot add chip\n");
1137                         err = -EBUSY;
1138                 }
1139         }
1140
1141         if (!err)
1142                 list_add_tail(&chip->list, pos);
1143
1144         return err;
1145 }
1146
1147 /**
1148  * gpiochip_add() - register a gpio_chip
1149  * @chip: the chip to register, with chip->base initialized
1150  * Context: potentially before irqs or kmalloc will work
1151  *
1152  * Returns a negative errno if the chip can't be registered, such as
1153  * because the chip->base is invalid or already associated with a
1154  * different chip.  Otherwise it returns zero as a success code.
1155  *
1156  * When gpiochip_add() is called very early during boot, so that GPIOs
1157  * can be freely used, the chip->dev device must be registered before
1158  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
1159  * for GPIOs will fail rudely.
1160  *
1161  * If chip->base is negative, this requests dynamic assignment of
1162  * a range of valid GPIOs.
1163  */
1164 int gpiochip_add(struct gpio_chip *chip)
1165 {
1166         unsigned long   flags;
1167         int             status = 0;
1168         unsigned        id;
1169         int             base = chip->base;
1170
1171         if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
1172                         && base >= 0) {
1173                 status = -EINVAL;
1174                 goto fail;
1175         }
1176
1177         spin_lock_irqsave(&gpio_lock, flags);
1178
1179         if (base < 0) {
1180                 base = gpiochip_find_base(chip->ngpio);
1181                 if (base < 0) {
1182                         status = base;
1183                         goto unlock;
1184                 }
1185                 chip->base = base;
1186         }
1187
1188         status = gpiochip_add_to_list(chip);
1189
1190         if (status == 0) {
1191                 chip->desc = &gpio_desc[chip->base];
1192
1193                 for (id = 0; id < chip->ngpio; id++) {
1194                         struct gpio_desc *desc = &chip->desc[id];
1195                         desc->chip = chip;
1196
1197                         /* REVISIT:  most hardware initializes GPIOs as
1198                          * inputs (often with pullups enabled) so power
1199                          * usage is minimized.  Linux code should set the
1200                          * gpio direction first thing; but until it does,
1201                          * and in case chip->get_direction is not set,
1202                          * we may expose the wrong direction in sysfs.
1203                          */
1204                         desc->flags = !chip->direction_input
1205                                 ? (1 << FLAG_IS_OUT)
1206                                 : 0;
1207                 }
1208         }
1209
1210 #ifdef CONFIG_PINCTRL
1211         INIT_LIST_HEAD(&chip->pin_ranges);
1212 #endif
1213
1214         of_gpiochip_add(chip);
1215
1216 unlock:
1217         spin_unlock_irqrestore(&gpio_lock, flags);
1218
1219         if (status)
1220                 goto fail;
1221
1222         status = gpiochip_export(chip);
1223         if (status)
1224                 goto fail;
1225
1226         pr_debug("gpiochip_add: registered GPIOs %d to %d on device: %s\n",
1227                 chip->base, chip->base + chip->ngpio - 1,
1228                 chip->label ? : "generic");
1229
1230         return 0;
1231 fail:
1232         /* failures here can mean systems won't boot... */
1233         pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
1234                 chip->base, chip->base + chip->ngpio - 1,
1235                 chip->label ? : "generic");
1236         return status;
1237 }
1238 EXPORT_SYMBOL_GPL(gpiochip_add);
1239
1240 /**
1241  * gpiochip_remove() - unregister a gpio_chip
1242  * @chip: the chip to unregister
1243  *
1244  * A gpio_chip with any GPIOs still requested may not be removed.
1245  */
1246 int gpiochip_remove(struct gpio_chip *chip)
1247 {
1248         unsigned long   flags;
1249         int             status = 0;
1250         unsigned        id;
1251
1252         spin_lock_irqsave(&gpio_lock, flags);
1253
1254         gpiochip_remove_pin_ranges(chip);
1255         of_gpiochip_remove(chip);
1256
1257         for (id = 0; id < chip->ngpio; id++) {
1258                 if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
1259                         status = -EBUSY;
1260                         break;
1261                 }
1262         }
1263         if (status == 0) {
1264                 for (id = 0; id < chip->ngpio; id++)
1265                         chip->desc[id].chip = NULL;
1266
1267                 list_del(&chip->list);
1268         }
1269
1270         spin_unlock_irqrestore(&gpio_lock, flags);
1271
1272         if (status == 0)
1273                 gpiochip_unexport(chip);
1274
1275         return status;
1276 }
1277 EXPORT_SYMBOL_GPL(gpiochip_remove);
1278
1279 /**
1280  * gpiochip_find() - iterator for locating a specific gpio_chip
1281  * @data: data to pass to match function
1282  * @callback: Callback function to check gpio_chip
1283  *
1284  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1285  * determined by a user supplied @match callback.  The callback should return
1286  * 0 if the device doesn't match and non-zero if it does.  If the callback is
1287  * non-zero, this function will return to the caller and not iterate over any
1288  * more gpio_chips.
1289  */
1290 struct gpio_chip *gpiochip_find(void *data,
1291                                 int (*match)(struct gpio_chip *chip,
1292                                              void *data))
1293 {
1294         struct gpio_chip *chip;
1295         unsigned long flags;
1296
1297         spin_lock_irqsave(&gpio_lock, flags);
1298         list_for_each_entry(chip, &gpio_chips, list)
1299                 if (match(chip, data))
1300                         break;
1301
1302         /* No match? */
1303         if (&chip->list == &gpio_chips)
1304                 chip = NULL;
1305         spin_unlock_irqrestore(&gpio_lock, flags);
1306
1307         return chip;
1308 }
1309 EXPORT_SYMBOL_GPL(gpiochip_find);
1310
1311 #ifdef CONFIG_PINCTRL
1312
1313 /**
1314  * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1315  * @chip: the gpiochip to add the range for
1316  * @pinctrl_name: the dev_name() of the pin controller to map to
1317  * @gpio_offset: the start offset in the current gpio_chip number space
1318  * @pin_offset: the start offset in the pin controller number space
1319  * @npins: the number of pins from the offset of each pin space (GPIO and
1320  *      pin controller) to accumulate in this range
1321  */
1322 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1323                            unsigned int gpio_offset, unsigned int pin_offset,
1324                            unsigned int npins)
1325 {
1326         struct gpio_pin_range *pin_range;
1327         int ret;
1328
1329         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1330         if (!pin_range) {
1331                 pr_err("%s: GPIO chip: failed to allocate pin ranges\n",
1332                                 chip->label);
1333                 return -ENOMEM;
1334         }
1335
1336         /* Use local offset as range ID */
1337         pin_range->range.id = gpio_offset;
1338         pin_range->range.gc = chip;
1339         pin_range->range.name = chip->label;
1340         pin_range->range.base = chip->base + gpio_offset;
1341         pin_range->range.pin_base = pin_offset;
1342         pin_range->range.npins = npins;
1343         pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1344                         &pin_range->range);
1345         if (IS_ERR(pin_range->pctldev)) {
1346                 ret = PTR_ERR(pin_range->pctldev);
1347                 pr_err("%s: GPIO chip: could not create pin range\n",
1348                        chip->label);
1349                 kfree(pin_range);
1350                 return ret;
1351         }
1352         pr_debug("GPIO chip %s: created GPIO range %d->%d ==> %s PIN %d->%d\n",
1353                  chip->label, gpio_offset, gpio_offset + npins - 1,
1354                  pinctl_name,
1355                  pin_offset, pin_offset + npins - 1);
1356
1357         list_add_tail(&pin_range->node, &chip->pin_ranges);
1358
1359         return 0;
1360 }
1361 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1362
1363 /**
1364  * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1365  * @chip: the chip to remove all the mappings for
1366  */
1367 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1368 {
1369         struct gpio_pin_range *pin_range, *tmp;
1370
1371         list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1372                 list_del(&pin_range->node);
1373                 pinctrl_remove_gpio_range(pin_range->pctldev,
1374                                 &pin_range->range);
1375                 kfree(pin_range);
1376         }
1377 }
1378 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1379
1380 #endif /* CONFIG_PINCTRL */
1381
1382 /* These "optional" allocation calls help prevent drivers from stomping
1383  * on each other, and help provide better diagnostics in debugfs.
1384  * They're called even less than the "set direction" calls.
1385  */
1386 static int gpiod_request(struct gpio_desc *desc, const char *label)
1387 {
1388         struct gpio_chip        *chip;
1389         int                     status = -EPROBE_DEFER;
1390         unsigned long           flags;
1391
1392         spin_lock_irqsave(&gpio_lock, flags);
1393
1394         if (!desc) {
1395                 status = -EINVAL;
1396                 goto done;
1397         }
1398         chip = desc->chip;
1399         if (chip == NULL)
1400                 goto done;
1401
1402         if (!try_module_get(chip->owner))
1403                 goto done;
1404
1405         /* NOTE:  gpio_request() can be called in early boot,
1406          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1407          */
1408
1409         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1410                 desc_set_label(desc, label ? : "?");
1411                 status = 0;
1412         } else {
1413                 status = -EBUSY;
1414                 module_put(chip->owner);
1415                 goto done;
1416         }
1417
1418         if (chip->request) {
1419                 /* chip->request may sleep */
1420                 spin_unlock_irqrestore(&gpio_lock, flags);
1421                 status = chip->request(chip, gpio_chip_hwgpio(desc));
1422                 spin_lock_irqsave(&gpio_lock, flags);
1423
1424                 if (status < 0) {
1425                         desc_set_label(desc, NULL);
1426                         module_put(chip->owner);
1427                         clear_bit(FLAG_REQUESTED, &desc->flags);
1428                         goto done;
1429                 }
1430         }
1431         if (chip->get_direction) {
1432                 /* chip->get_direction may sleep */
1433                 spin_unlock_irqrestore(&gpio_lock, flags);
1434                 gpiod_get_direction(desc);
1435                 spin_lock_irqsave(&gpio_lock, flags);
1436         }
1437 done:
1438         if (status)
1439                 pr_debug("_gpio_request: gpio-%d (%s) status %d\n",
1440                          desc ? desc_to_gpio(desc) : -1,
1441                          label ? : "?", status);
1442         spin_unlock_irqrestore(&gpio_lock, flags);
1443         return status;
1444 }
1445
1446 int gpio_request(unsigned gpio, const char *label)
1447 {
1448         return gpiod_request(gpio_to_desc(gpio), label);
1449 }
1450 EXPORT_SYMBOL_GPL(gpio_request);
1451
1452 static void gpiod_free(struct gpio_desc *desc)
1453 {
1454         unsigned long           flags;
1455         struct gpio_chip        *chip;
1456
1457         might_sleep();
1458
1459         if (!desc) {
1460                 WARN_ON(extra_checks);
1461                 return;
1462         }
1463
1464         gpiod_unexport(desc);
1465
1466         spin_lock_irqsave(&gpio_lock, flags);
1467
1468         chip = desc->chip;
1469         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1470                 if (chip->free) {
1471                         spin_unlock_irqrestore(&gpio_lock, flags);
1472                         might_sleep_if(chip->can_sleep);
1473                         chip->free(chip, gpio_chip_hwgpio(desc));
1474                         spin_lock_irqsave(&gpio_lock, flags);
1475                 }
1476                 desc_set_label(desc, NULL);
1477                 module_put(desc->chip->owner);
1478                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1479                 clear_bit(FLAG_REQUESTED, &desc->flags);
1480                 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1481                 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
1482         } else
1483                 WARN_ON(extra_checks);
1484
1485         spin_unlock_irqrestore(&gpio_lock, flags);
1486 }
1487
1488 void gpio_free(unsigned gpio)
1489 {
1490         gpiod_free(gpio_to_desc(gpio));
1491 }
1492 EXPORT_SYMBOL_GPL(gpio_free);
1493
1494 /**
1495  * gpio_request_one - request a single GPIO with initial configuration
1496  * @gpio:       the GPIO number
1497  * @flags:      GPIO configuration as specified by GPIOF_*
1498  * @label:      a literal description string of this GPIO
1499  */
1500 int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1501 {
1502         struct gpio_desc *desc;
1503         int err;
1504
1505         desc = gpio_to_desc(gpio);
1506
1507         err = gpiod_request(desc, label);
1508         if (err)
1509                 return err;
1510
1511         if (flags & GPIOF_OPEN_DRAIN)
1512                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
1513
1514         if (flags & GPIOF_OPEN_SOURCE)
1515                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
1516
1517         if (flags & GPIOF_DIR_IN)
1518                 err = gpiod_direction_input(desc);
1519         else
1520                 err = gpiod_direction_output(desc,
1521                                 (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1522
1523         if (err)
1524                 goto free_gpio;
1525
1526         if (flags & GPIOF_EXPORT) {
1527                 err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
1528                 if (err)
1529                         goto free_gpio;
1530         }
1531
1532         return 0;
1533
1534  free_gpio:
1535         gpiod_free(desc);
1536         return err;
1537 }
1538 EXPORT_SYMBOL_GPL(gpio_request_one);
1539
1540 /**
1541  * gpio_request_array - request multiple GPIOs in a single call
1542  * @array:      array of the 'struct gpio'
1543  * @num:        how many GPIOs in the array
1544  */
1545 int gpio_request_array(const struct gpio *array, size_t num)
1546 {
1547         int i, err;
1548
1549         for (i = 0; i < num; i++, array++) {
1550                 err = gpio_request_one(array->gpio, array->flags, array->label);
1551                 if (err)
1552                         goto err_free;
1553         }
1554         return 0;
1555
1556 err_free:
1557         while (i--)
1558                 gpio_free((--array)->gpio);
1559         return err;
1560 }
1561 EXPORT_SYMBOL_GPL(gpio_request_array);
1562
1563 /**
1564  * gpio_free_array - release multiple GPIOs in a single call
1565  * @array:      array of the 'struct gpio'
1566  * @num:        how many GPIOs in the array
1567  */
1568 void gpio_free_array(const struct gpio *array, size_t num)
1569 {
1570         while (num--)
1571                 gpio_free((array++)->gpio);
1572 }
1573 EXPORT_SYMBOL_GPL(gpio_free_array);
1574
1575 /**
1576  * gpiochip_is_requested - return string iff signal was requested
1577  * @chip: controller managing the signal
1578  * @offset: of signal within controller's 0..(ngpio - 1) range
1579  *
1580  * Returns NULL if the GPIO is not currently requested, else a string.
1581  * If debugfs support is enabled, the string returned is the label passed
1582  * to gpio_request(); otherwise it is a meaningless constant.
1583  *
1584  * This function is for use by GPIO controller drivers.  The label can
1585  * help with diagnostics, and knowing that the signal is used as a GPIO
1586  * can help avoid accidentally multiplexing it to another controller.
1587  */
1588 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1589 {
1590         struct gpio_desc *desc;
1591
1592         if (!GPIO_OFFSET_VALID(chip, offset))
1593                 return NULL;
1594
1595         desc = &chip->desc[offset];
1596
1597         if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
1598                 return NULL;
1599 #ifdef CONFIG_DEBUG_FS
1600         return desc->label;
1601 #else
1602         return "?";
1603 #endif
1604 }
1605 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1606
1607
1608 /* Drivers MUST set GPIO direction before making get/set calls.  In
1609  * some cases this is done in early boot, before IRQs are enabled.
1610  *
1611  * As a rule these aren't called more than once (except for drivers
1612  * using the open-drain emulation idiom) so these are natural places
1613  * to accumulate extra debugging checks.  Note that we can't (yet)
1614  * rely on gpio_request() having been called beforehand.
1615  */
1616
1617 static int gpiod_direction_input(struct gpio_desc *desc)
1618 {
1619         unsigned long           flags;
1620         struct gpio_chip        *chip;
1621         int                     status = -EINVAL;
1622         int                     offset;
1623
1624         spin_lock_irqsave(&gpio_lock, flags);
1625
1626         if (!desc)
1627                 goto fail;
1628         chip = desc->chip;
1629         if (!chip || !chip->get || !chip->direction_input)
1630                 goto fail;
1631         status = gpio_ensure_requested(desc);
1632         if (status < 0)
1633                 goto fail;
1634
1635         /* now we know the gpio is valid and chip won't vanish */
1636
1637         spin_unlock_irqrestore(&gpio_lock, flags);
1638
1639         might_sleep_if(chip->can_sleep);
1640
1641         offset = gpio_chip_hwgpio(desc);
1642         if (status) {
1643                 status = chip->request(chip, offset);
1644                 if (status < 0) {
1645                         pr_debug("GPIO-%d: chip request fail, %d\n",
1646                                 desc_to_gpio(desc), status);
1647                         /* and it's not available to anyone else ...
1648                          * gpio_request() is the fully clean solution.
1649                          */
1650                         goto lose;
1651                 }
1652         }
1653
1654         status = chip->direction_input(chip, offset);
1655         if (status == 0)
1656                 clear_bit(FLAG_IS_OUT, &desc->flags);
1657
1658         trace_gpio_direction(desc_to_gpio(desc), 1, status);
1659 lose:
1660         return status;
1661 fail:
1662         spin_unlock_irqrestore(&gpio_lock, flags);
1663         if (status) {
1664                 int gpio = -1;
1665                 if (desc)
1666                         gpio = desc_to_gpio(desc);
1667                 pr_debug("%s: gpio-%d status %d\n",
1668                         __func__, gpio, status);
1669         }
1670         return status;
1671 }
1672
1673 int gpio_direction_input(unsigned gpio)
1674 {
1675         return gpiod_direction_input(gpio_to_desc(gpio));
1676 }
1677 EXPORT_SYMBOL_GPL(gpio_direction_input);
1678
1679 static int gpiod_direction_output(struct gpio_desc *desc, int value)
1680 {
1681         unsigned long           flags;
1682         struct gpio_chip        *chip;
1683         int                     status = -EINVAL;
1684         int offset;
1685
1686         /* Open drain pin should not be driven to 1 */
1687         if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
1688                 return gpiod_direction_input(desc);
1689
1690         /* Open source pin should not be driven to 0 */
1691         if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
1692                 return gpiod_direction_input(desc);
1693
1694         spin_lock_irqsave(&gpio_lock, flags);
1695
1696         if (!desc)
1697                 goto fail;
1698         chip = desc->chip;
1699         if (!chip || !chip->set || !chip->direction_output)
1700                 goto fail;
1701         status = gpio_ensure_requested(desc);
1702         if (status < 0)
1703                 goto fail;
1704
1705         /* now we know the gpio is valid and chip won't vanish */
1706
1707         spin_unlock_irqrestore(&gpio_lock, flags);
1708
1709         might_sleep_if(chip->can_sleep);
1710
1711         offset = gpio_chip_hwgpio(desc);
1712         if (status) {
1713                 status = chip->request(chip, offset);
1714                 if (status < 0) {
1715                         pr_debug("GPIO-%d: chip request fail, %d\n",
1716                                 desc_to_gpio(desc), status);
1717                         /* and it's not available to anyone else ...
1718                          * gpio_request() is the fully clean solution.
1719                          */
1720                         goto lose;
1721                 }
1722         }
1723
1724         status = chip->direction_output(chip, offset, value);
1725         if (status == 0)
1726                 set_bit(FLAG_IS_OUT, &desc->flags);
1727         trace_gpio_value(desc_to_gpio(desc), 0, value);
1728         trace_gpio_direction(desc_to_gpio(desc), 0, status);
1729 lose:
1730         return status;
1731 fail:
1732         spin_unlock_irqrestore(&gpio_lock, flags);
1733         if (status) {
1734                 int gpio = -1;
1735                 if (desc)
1736                         gpio = desc_to_gpio(desc);
1737                 pr_debug("%s: gpio-%d status %d\n",
1738                         __func__, gpio, status);
1739         }
1740         return status;
1741 }
1742
1743 int gpio_direction_output(unsigned gpio, int value)
1744 {
1745         return gpiod_direction_output(gpio_to_desc(gpio), value);
1746 }
1747 EXPORT_SYMBOL_GPL(gpio_direction_output);
1748
1749 /**
1750  * gpio_set_debounce - sets @debounce time for a @gpio
1751  * @gpio: the gpio to set debounce time
1752  * @debounce: debounce time is microseconds
1753  */
1754 static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
1755 {
1756         unsigned long           flags;
1757         struct gpio_chip        *chip;
1758         int                     status = -EINVAL;
1759         int                     offset;
1760
1761         spin_lock_irqsave(&gpio_lock, flags);
1762
1763         if (!desc)
1764                 goto fail;
1765         chip = desc->chip;
1766         if (!chip || !chip->set || !chip->set_debounce)
1767                 goto fail;
1768
1769         status = gpio_ensure_requested(desc);
1770         if (status < 0)
1771                 goto fail;
1772
1773         /* now we know the gpio is valid and chip won't vanish */
1774
1775         spin_unlock_irqrestore(&gpio_lock, flags);
1776
1777         might_sleep_if(chip->can_sleep);
1778
1779         offset = gpio_chip_hwgpio(desc);
1780         return chip->set_debounce(chip, offset, debounce);
1781
1782 fail:
1783         spin_unlock_irqrestore(&gpio_lock, flags);
1784         if (status) {
1785                 int gpio = -1;
1786                 if (desc)
1787                         gpio = desc_to_gpio(desc);
1788                 pr_debug("%s: gpio-%d status %d\n",
1789                         __func__, gpio, status);
1790         }
1791
1792         return status;
1793 }
1794
1795 int gpio_set_debounce(unsigned gpio, unsigned debounce)
1796 {
1797         return gpiod_set_debounce(gpio_to_desc(gpio), debounce);
1798 }
1799 EXPORT_SYMBOL_GPL(gpio_set_debounce);
1800
1801 /* I/O calls are only valid after configuration completed; the relevant
1802  * "is this a valid GPIO" error checks should already have been done.
1803  *
1804  * "Get" operations are often inlinable as reading a pin value register,
1805  * and masking the relevant bit in that register.
1806  *
1807  * When "set" operations are inlinable, they involve writing that mask to
1808  * one register to set a low value, or a different register to set it high.
1809  * Otherwise locking is needed, so there may be little value to inlining.
1810  *
1811  *------------------------------------------------------------------------
1812  *
1813  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
1814  * have requested the GPIO.  That can include implicit requesting by
1815  * a direction setting call.  Marking a gpio as requested locks its chip
1816  * in memory, guaranteeing that these table lookups need no more locking
1817  * and that gpiochip_remove() will fail.
1818  *
1819  * REVISIT when debugging, consider adding some instrumentation to ensure
1820  * that the GPIO was actually requested.
1821  */
1822
1823 /**
1824  * __gpio_get_value() - return a gpio's value
1825  * @gpio: gpio whose value will be returned
1826  * Context: any
1827  *
1828  * This is used directly or indirectly to implement gpio_get_value().
1829  * It returns the zero or nonzero value provided by the associated
1830  * gpio_chip.get() method; or zero if no such method is provided.
1831  */
1832 static int gpiod_get_value(struct gpio_desc *desc)
1833 {
1834         struct gpio_chip        *chip;
1835         int value;
1836         int offset;
1837
1838         chip = desc->chip;
1839         offset = gpio_chip_hwgpio(desc);
1840         /* Should be using gpio_get_value_cansleep() */
1841         WARN_ON(chip->can_sleep);
1842         value = chip->get ? chip->get(chip, offset) : 0;
1843         trace_gpio_value(desc_to_gpio(desc), 1, value);
1844         return value;
1845 }
1846
1847 int __gpio_get_value(unsigned gpio)
1848 {
1849         return gpiod_get_value(gpio_to_desc(gpio));
1850 }
1851 EXPORT_SYMBOL_GPL(__gpio_get_value);
1852
1853 /*
1854  *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
1855  * @gpio: Gpio whose state need to be set.
1856  * @chip: Gpio chip.
1857  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1858  */
1859 static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
1860 {
1861         int err = 0;
1862         struct gpio_chip *chip = desc->chip;
1863         int offset = gpio_chip_hwgpio(desc);
1864
1865         if (value) {
1866                 err = chip->direction_input(chip, offset);
1867                 if (!err)
1868                         clear_bit(FLAG_IS_OUT, &desc->flags);
1869         } else {
1870                 err = chip->direction_output(chip, offset, 0);
1871                 if (!err)
1872                         set_bit(FLAG_IS_OUT, &desc->flags);
1873         }
1874         trace_gpio_direction(desc_to_gpio(desc), value, err);
1875         if (err < 0)
1876                 pr_err("%s: Error in set_value for open drain gpio%d err %d\n",
1877                                         __func__, desc_to_gpio(desc), err);
1878 }
1879
1880 /*
1881  *  _gpio_set_open_source() - Set the open source gpio's value.
1882  * @gpio: Gpio whose state need to be set.
1883  * @chip: Gpio chip.
1884  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1885  */
1886 static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
1887 {
1888         int err = 0;
1889         struct gpio_chip *chip = desc->chip;
1890         int offset = gpio_chip_hwgpio(desc);
1891
1892         if (value) {
1893                 err = chip->direction_output(chip, offset, 1);
1894                 if (!err)
1895                         set_bit(FLAG_IS_OUT, &desc->flags);
1896         } else {
1897                 err = chip->direction_input(chip, offset);
1898                 if (!err)
1899                         clear_bit(FLAG_IS_OUT, &desc->flags);
1900         }
1901         trace_gpio_direction(desc_to_gpio(desc), !value, err);
1902         if (err < 0)
1903                 pr_err("%s: Error in set_value for open source gpio%d err %d\n",
1904                                         __func__, desc_to_gpio(desc), err);
1905 }
1906
1907 /**
1908  * __gpio_set_value() - assign a gpio's value
1909  * @gpio: gpio whose value will be assigned
1910  * @value: value to assign
1911  * Context: any
1912  *
1913  * This is used directly or indirectly to implement gpio_set_value().
1914  * It invokes the associated gpio_chip.set() method.
1915  */
1916 static void gpiod_set_value(struct gpio_desc *desc, int value)
1917 {
1918         struct gpio_chip        *chip;
1919
1920         chip = desc->chip;
1921         /* Should be using gpio_set_value_cansleep() */
1922         WARN_ON(chip->can_sleep);
1923         trace_gpio_value(desc_to_gpio(desc), 0, value);
1924         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1925                 _gpio_set_open_drain_value(desc, value);
1926         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1927                 _gpio_set_open_source_value(desc, value);
1928         else
1929                 chip->set(chip, gpio_chip_hwgpio(desc), value);
1930 }
1931
1932 void __gpio_set_value(unsigned gpio, int value)
1933 {
1934         return gpiod_set_value(gpio_to_desc(gpio), value);
1935 }
1936 EXPORT_SYMBOL_GPL(__gpio_set_value);
1937
1938 /**
1939  * __gpio_cansleep() - report whether gpio value access will sleep
1940  * @gpio: gpio in question
1941  * Context: any
1942  *
1943  * This is used directly or indirectly to implement gpio_cansleep().  It
1944  * returns nonzero if access reading or writing the GPIO value can sleep.
1945  */
1946 static int gpiod_cansleep(struct gpio_desc *desc)
1947 {
1948         /* only call this on GPIOs that are valid! */
1949         return desc->chip->can_sleep;
1950 }
1951
1952 int __gpio_cansleep(unsigned gpio)
1953 {
1954         return gpiod_cansleep(gpio_to_desc(gpio));
1955 }
1956 EXPORT_SYMBOL_GPL(__gpio_cansleep);
1957
1958 /**
1959  * __gpio_to_irq() - return the IRQ corresponding to a GPIO
1960  * @gpio: gpio whose IRQ will be returned (already requested)
1961  * Context: any
1962  *
1963  * This is used directly or indirectly to implement gpio_to_irq().
1964  * It returns the number of the IRQ signaled by this (input) GPIO,
1965  * or a negative errno.
1966  */
1967 static int gpiod_to_irq(struct gpio_desc *desc)
1968 {
1969         struct gpio_chip        *chip;
1970         int                     offset;
1971
1972         chip = desc->chip;
1973         offset = gpio_chip_hwgpio(desc);
1974         return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
1975 }
1976
1977 int __gpio_to_irq(unsigned gpio)
1978 {
1979         return gpiod_to_irq(gpio_to_desc(gpio));
1980 }
1981 EXPORT_SYMBOL_GPL(__gpio_to_irq);
1982
1983
1984 /* There's no value in making it easy to inline GPIO calls that may sleep.
1985  * Common examples include ones connected to I2C or SPI chips.
1986  */
1987
1988 static int gpiod_get_value_cansleep(struct gpio_desc *desc)
1989 {
1990         struct gpio_chip        *chip;
1991         int value;
1992         int offset;
1993
1994         might_sleep_if(extra_checks);
1995         chip = desc->chip;
1996         offset = gpio_chip_hwgpio(desc);
1997         value = chip->get ? chip->get(chip, offset) : 0;
1998         trace_gpio_value(desc_to_gpio(desc), 1, value);
1999         return value;
2000 }
2001
2002 int gpio_get_value_cansleep(unsigned gpio)
2003 {
2004         return gpiod_get_value_cansleep(gpio_to_desc(gpio));
2005 }
2006 EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
2007
2008 static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2009 {
2010         struct gpio_chip        *chip;
2011
2012         might_sleep_if(extra_checks);
2013         chip = desc->chip;
2014         trace_gpio_value(desc_to_gpio(desc), 0, value);
2015         if (test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
2016                 _gpio_set_open_drain_value(desc, value);
2017         else if (test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
2018                 _gpio_set_open_source_value(desc, value);
2019         else
2020                 chip->set(chip, gpio_chip_hwgpio(desc), value);
2021 }
2022
2023 void gpio_set_value_cansleep(unsigned gpio, int value)
2024 {
2025         return gpiod_set_value_cansleep(gpio_to_desc(gpio), value);
2026 }
2027 EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
2028
2029 #ifdef CONFIG_DEBUG_FS
2030
2031 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2032 {
2033         unsigned                i;
2034         unsigned                gpio = chip->base;
2035         struct gpio_desc        *gdesc = &chip->desc[0];
2036         int                     is_out;
2037
2038         for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2039                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2040                         continue;
2041
2042                 gpiod_get_direction(gdesc);
2043                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
2044                 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
2045                         gpio, gdesc->label,
2046                         is_out ? "out" : "in ",
2047                         chip->get
2048                                 ? (chip->get(chip, i) ? "hi" : "lo")
2049                                 : "?  ");
2050                 seq_printf(s, "\n");
2051         }
2052 }
2053
2054 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
2055 {
2056         unsigned long flags;
2057         struct gpio_chip *chip = NULL;
2058         loff_t index = *pos;
2059
2060         s->private = "";
2061
2062         spin_lock_irqsave(&gpio_lock, flags);
2063         list_for_each_entry(chip, &gpio_chips, list)
2064                 if (index-- == 0) {
2065                         spin_unlock_irqrestore(&gpio_lock, flags);
2066                         return chip;
2067                 }
2068         spin_unlock_irqrestore(&gpio_lock, flags);
2069
2070         return NULL;
2071 }
2072
2073 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2074 {
2075         unsigned long flags;
2076         struct gpio_chip *chip = v;
2077         void *ret = NULL;
2078
2079         spin_lock_irqsave(&gpio_lock, flags);
2080         if (list_is_last(&chip->list, &gpio_chips))
2081                 ret = NULL;
2082         else
2083                 ret = list_entry(chip->list.next, struct gpio_chip, list);
2084         spin_unlock_irqrestore(&gpio_lock, flags);
2085
2086         s->private = "\n";
2087         ++*pos;
2088
2089         return ret;
2090 }
2091
2092 static void gpiolib_seq_stop(struct seq_file *s, void *v)
2093 {
2094 }
2095
2096 static int gpiolib_seq_show(struct seq_file *s, void *v)
2097 {
2098         struct gpio_chip *chip = v;
2099         struct device *dev;
2100
2101         seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2102                         chip->base, chip->base + chip->ngpio - 1);
2103         dev = chip->dev;
2104         if (dev)
2105                 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2106                         dev_name(dev));
2107         if (chip->label)
2108                 seq_printf(s, ", %s", chip->label);
2109         if (chip->can_sleep)
2110                 seq_printf(s, ", can sleep");
2111         seq_printf(s, ":\n");
2112
2113         if (chip->dbg_show)
2114                 chip->dbg_show(s, chip);
2115         else
2116                 gpiolib_dbg_show(s, chip);
2117
2118         return 0;
2119 }
2120
2121 static const struct seq_operations gpiolib_seq_ops = {
2122         .start = gpiolib_seq_start,
2123         .next = gpiolib_seq_next,
2124         .stop = gpiolib_seq_stop,
2125         .show = gpiolib_seq_show,
2126 };
2127
2128 static int gpiolib_open(struct inode *inode, struct file *file)
2129 {
2130         return seq_open(file, &gpiolib_seq_ops);
2131 }
2132
2133 static const struct file_operations gpiolib_operations = {
2134         .owner          = THIS_MODULE,
2135         .open           = gpiolib_open,
2136         .read           = seq_read,
2137         .llseek         = seq_lseek,
2138         .release        = seq_release,
2139 };
2140
2141 static int __init gpiolib_debugfs_init(void)
2142 {
2143         /* /sys/kernel/debug/gpio */
2144         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2145                                 NULL, NULL, &gpiolib_operations);
2146         return 0;
2147 }
2148 subsys_initcall(gpiolib_debugfs_init);
2149
2150 #endif  /* DEBUG_FS */