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