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