drivers/gpio/gpiolib.c

   1 #include <linux/kernel.h>
   2 #include <linux/module.h>
   3 #include <linux/irq.h>
   4 #include <linux/spinlock.h>
   5 #include <linux/device.h>
   6 #include <linux/err.h>
   7 #include <linux/debugfs.h>
   8 #include <linux/seq_file.h>
   9 #include <linux/gpio.h>
  10
  11
  12 /* Optional implementation infrastructure for GPIO interfaces.
  13  *
  14  * Platforms may want to use this if they tend to use very many GPIOs
  15  * that aren't part of a System-On-Chip core; or across I2C/SPI/etc.
  16  *
  17  * When kernel footprint or instruction count is an issue, simpler
  18  * implementations may be preferred.  The GPIO programming interface
  19  * allows for inlining speed-critical get/set operations for common
  20  * cases, so that access to SOC-integrated GPIOs can sometimes cost
  21  * only an instruction or two per bit.
  22  */
  23
  24
  25 /* When debugging, extend minimal trust to callers and platform code.
  26  * Also emit diagnostic messages that may help initial bringup, when
  27  * board setup or driver bugs are most common.
  28  *
  29  * Otherwise, minimize overhead in what may be bitbanging codepaths.
  30  */
  31 #ifdef  DEBUG
  32 #define extra_checks    1
  33 #else
  34 #define extra_checks    0
  35 #endif
  36
  37 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
  38  * While any GPIO is requested, its gpio_chip is not removable;
  39  * each GPIO's "requested" flag serves as a lock and refcount.
  40  */
  41 static DEFINE_SPINLOCK(gpio_lock);
  42
  43 struct gpio_desc {
  44         struct gpio_chip        *chip;
  45         unsigned long           flags;
  46 /* flag symbols are bit numbers */
  47 #define FLAG_REQUESTED  0
  48 #define FLAG_IS_OUT     1
  49 #define FLAG_RESERVED   2
  50 #define FLAG_EXPORT     3       /* protected by sysfs_lock */
  51 #define FLAG_SYSFS      4       /* exported via /sys/class/gpio/control */
  52
  53 #ifdef CONFIG_DEBUG_FS
  54         const char              *label;
  55 #endif
  56 };
  57 static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
  58
  59 static inline void desc_set_label(struct gpio_desc *d, const char *label)
  60 {
  61 #ifdef CONFIG_DEBUG_FS
  62         d->label = label;
  63 #endif
  64 }
  65
  66 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
  67  * when setting direction, and otherwise illegal.  Until board setup code
  68  * and drivers use explicit requests everywhere (which won't happen when
  69  * those calls have no teeth) we can't avoid autorequesting.  This nag
  70  * message should motivate switching to explicit requests... so should
  71  * the weaker cleanup after faults, compared to gpio_request().
  72  *
  73  * NOTE: the autorequest mechanism is going away; at this point it's
  74  * only "legal" in the sense that (old) code using it won't break yet,
  75  * but instead only triggers a WARN() stack dump.
  76  */
  77 static int gpio_ensure_requested(struct gpio_desc *desc, unsigned offset)
  78 {
  79         const struct gpio_chip *chip = desc->chip;
  80         const int gpio = chip->base + offset;
  81
  82         if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
  83                         "autorequest GPIO-%d\n", gpio)) {
  84                 if (!try_module_get(chip->owner)) {
  85                         pr_err("GPIO-%d: module can't be gotten \n", gpio);
  86                         clear_bit(FLAG_REQUESTED, &desc->flags);
  87                         /* lose */
  88                         return -EIO;
  89                 }
  90                 desc_set_label(desc, "[auto]");
  91                 /* caller must chip->request() w/o spinlock */
  92                 if (chip->request)
  93                         return 1;
  94         }
  95         return 0;
  96 }
  97
  98 /* caller holds gpio_lock *OR* gpio is marked as requested */
  99 static inline struct gpio_chip *gpio_to_chip(unsigned gpio)
 100 {
 101         return gpio_desc[gpio].chip;
 102 }
 103
 104 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
 105 static int gpiochip_find_base(int ngpio)
 106 {
 107         int i;
 108         int spare = 0;
 109         int base = -ENOSPC;
 110
 111         for (i = ARCH_NR_GPIOS - 1; i >= 0 ; i--) {
 112                 struct gpio_desc *desc = &gpio_desc[i];
 113                 struct gpio_chip *chip = desc->chip;
 114
 115                 if (!chip && !test_bit(FLAG_RESERVED, &desc->flags)) {
 116                         spare++;
 117                         if (spare == ngpio) {
 118                                 base = i;
 119                                 break;
 120                         }
 121                 } else {
 122                         spare = 0;
 123                         if (chip)
 124                                 i -= chip->ngpio - 1;
 125                 }
 126         }
 127
 128         if (gpio_is_valid(base))
 129                 pr_debug("%s: found new base at %d\n", __func__, base);
 130         return base;
 131 }
 132
 133 /**
 134  * gpiochip_reserve() - reserve range of gpios to use with platform code only
 135  * @start: starting gpio number
 136  * @ngpio: number of gpios to reserve
 137  * Context: platform init, potentially before irqs or kmalloc will work
 138  *
 139  * Returns a negative errno if any gpio within the range is already reserved
 140  * or registered, else returns zero as a success code.  Use this function
 141  * to mark a range of gpios as unavailable for dynamic gpio number allocation,
 142  * for example because its driver support is not yet loaded.
 143  */
 144 int __init gpiochip_reserve(int start, int ngpio)
 145 {
 146         int ret = 0;
 147         unsigned long flags;
 148         int i;
 149
 150         if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio - 1))
 151                 return -EINVAL;
 152
 153         spin_lock_irqsave(&gpio_lock, flags);
 154
 155         for (i = start; i < start + ngpio; i++) {
 156                 struct gpio_desc *desc = &gpio_desc[i];
 157
 158                 if (desc->chip || test_bit(FLAG_RESERVED, &desc->flags)) {
 159                         ret = -EBUSY;
 160                         goto err;
 161                 }
 162
 163                 set_bit(FLAG_RESERVED, &desc->flags);
 164         }
 165
 166         pr_debug("%s: reserved gpios from %d to %d\n",
 167                  __func__, start, start + ngpio - 1);
 168 err:
 169         spin_unlock_irqrestore(&gpio_lock, flags);
 170
 171         return ret;
 172 }
 173
 174 #ifdef CONFIG_GPIO_SYSFS
 175
 176 /* lock protects against unexport_gpio() being called while
 177  * sysfs files are active.
 178  */
 179 static DEFINE_MUTEX(sysfs_lock);
 180
 181 /*
 182  * /sys/class/gpio/gpioN... only for GPIOs that are exported
 183  *   /direction
 184  *      * MAY BE OMITTED if kernel won't allow direction changes
 185  *      * is read/write as "in" or "out"
 186  *      * may also be written as "high" or "low", initializing
 187  *        output value as specified ("out" implies "low")
 188  *   /value
 189  *      * always readable, subject to hardware behavior
 190  *      * may be writable, as zero/nonzero
 191  *
 192  * REVISIT there will likely be an attribute for configuring async
 193  * notifications, e.g. to specify polling interval or IRQ trigger type
 194  * that would for example trigger a poll() on the "value".
 195  */
 196
 197 static ssize_t gpio_direction_show(struct device *dev,
 198                 struct device_attribute *attr, char *buf)
 199 {
 200         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 201         ssize_t                 status;
 202
 203         mutex_lock(&sysfs_lock);
 204
 205         if (!test_bit(FLAG_EXPORT, &desc->flags))
 206                 status = -EIO;
 207         else
 208                 status = sprintf(buf, "%s\n",
 209                         test_bit(FLAG_IS_OUT, &desc->flags)
 210                                 ? "out" : "in");
 211
 212         mutex_unlock(&sysfs_lock);
 213         return status;
 214 }
 215
 216 static ssize_t gpio_direction_store(struct device *dev,
 217                 struct device_attribute *attr, const char *buf, size_t size)
 218 {
 219         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 220         unsigned                gpio = desc - gpio_desc;
 221         ssize_t                 status;
 222
 223         mutex_lock(&sysfs_lock);
 224
 225         if (!test_bit(FLAG_EXPORT, &desc->flags))
 226                 status = -EIO;
 227         else if (sysfs_streq(buf, "high"))
 228                 status = gpio_direction_output(gpio, 1);
 229         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
 230                 status = gpio_direction_output(gpio, 0);
 231         else if (sysfs_streq(buf, "in"))
 232                 status = gpio_direction_input(gpio);
 233         else
 234                 status = -EINVAL;
 235
 236         mutex_unlock(&sysfs_lock);
 237         return status ? : size;
 238 }
 239
 240 static const DEVICE_ATTR(direction, 0644,
 241                 gpio_direction_show, gpio_direction_store);
 242
 243 static ssize_t gpio_value_show(struct device *dev,
 244                 struct device_attribute *attr, char *buf)
 245 {
 246         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 247         unsigned                gpio = desc - gpio_desc;
 248         ssize_t                 status;
 249
 250         mutex_lock(&sysfs_lock);
 251
 252         if (!test_bit(FLAG_EXPORT, &desc->flags))
 253                 status = -EIO;
 254         else
 255                 status = sprintf(buf, "%d\n", !!gpio_get_value_cansleep(gpio));
 256
 257         mutex_unlock(&sysfs_lock);
 258         return status;
 259 }
 260
 261 static ssize_t gpio_value_store(struct device *dev,
 262                 struct device_attribute *attr, const char *buf, size_t size)
 263 {
 264         const struct gpio_desc  *desc = dev_get_drvdata(dev);
 265         unsigned                gpio = desc - gpio_desc;
 266         ssize_t                 status;
 267
 268         mutex_lock(&sysfs_lock);
 269
 270         if (!test_bit(FLAG_EXPORT, &desc->flags))
 271                 status = -EIO;
 272         else if (!test_bit(FLAG_IS_OUT, &desc->flags))
 273                 status = -EPERM;
 274         else {
 275                 long            value;
 276
 277                 status = strict_strtol(buf, 0, &value);
 278                 if (status == 0) {
 279                         gpio_set_value_cansleep(gpio, value != 0);
 280                         status = size;
 281                 }
 282         }
 283
 284         mutex_unlock(&sysfs_lock);
 285         return status;
 286 }
 287
 288 static /*const*/ DEVICE_ATTR(value, 0644,
 289                 gpio_value_show, gpio_value_store);
 290
 291 static const struct attribute *gpio_attrs[] = {
 292         &dev_attr_direction.attr,
 293         &dev_attr_value.attr,
 294         NULL,
 295 };
 296
 297 static const struct attribute_group gpio_attr_group = {
 298         .attrs = (struct attribute **) gpio_attrs,
 299 };
 300
 301 /*
 302  * /sys/class/gpio/gpiochipN/
 303  *   /base ... matching gpio_chip.base (N)
 304  *   /label ... matching gpio_chip.label
 305  *   /ngpio ... matching gpio_chip.ngpio
 306  */
 307
 308 static ssize_t chip_base_show(struct device *dev,
 309                                struct device_attribute *attr, char *buf)
 310 {
 311         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 312
 313         return sprintf(buf, "%d\n", chip->base);
 314 }
 315 static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
 316
 317 static ssize_t chip_label_show(struct device *dev,
 318                                struct device_attribute *attr, char *buf)
 319 {
 320         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 321
 322         return sprintf(buf, "%s\n", chip->label ? : "");
 323 }
 324 static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
 325
 326 static ssize_t chip_ngpio_show(struct device *dev,
 327                                struct device_attribute *attr, char *buf)
 328 {
 329         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 330
 331         return sprintf(buf, "%u\n", chip->ngpio);
 332 }
 333 static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
 334
 335 static const struct attribute *gpiochip_attrs[] = {
 336         &dev_attr_base.attr,
 337         &dev_attr_label.attr,
 338         &dev_attr_ngpio.attr,
 339         NULL,
 340 };
 341
 342 static const struct attribute_group gpiochip_attr_group = {
 343         .attrs = (struct attribute **) gpiochip_attrs,
 344 };
 345
 346 /*
 347  * /sys/class/gpio/export ... write-only
 348  *      integer N ... number of GPIO to export (full access)
 349  * /sys/class/gpio/unexport ... write-only
 350  *      integer N ... number of GPIO to unexport
 351  */
 352 static ssize_t export_store(struct class *class, const char *buf, size_t len)
 353 {
 354         long    gpio;
 355         int     status;
 356
 357         status = strict_strtol(buf, 0, &gpio);
 358         if (status < 0)
 359                 goto done;
 360
 361         /* No extra locking here; FLAG_SYSFS just signifies that the
 362          * request and export were done by on behalf of userspace, so
 363          * they may be undone on its behalf too.
 364          */
 365
 366         status = gpio_request(gpio, "sysfs");
 367         if (status < 0)
 368                 goto done;
 369
 370         status = gpio_export(gpio, true);
 371         if (status < 0)
 372                 gpio_free(gpio);
 373         else
 374                 set_bit(FLAG_SYSFS, &gpio_desc[gpio].flags);
 375
 376 done:
 377         if (status)
 378                 pr_debug("%s: status %d\n", __func__, status);
 379         return status ? : len;
 380 }
 381
 382 static ssize_t unexport_store(struct class *class, const char *buf, size_t len)
 383 {
 384         long    gpio;
 385         int     status;
 386
 387         status = strict_strtol(buf, 0, &gpio);
 388         if (status < 0)
 389                 goto done;
 390
 391         status = -EINVAL;
 392
 393         /* reject bogus commands (gpio_unexport ignores them) */
 394         if (!gpio_is_valid(gpio))
 395                 goto done;
 396
 397         /* No extra locking here; FLAG_SYSFS just signifies that the
 398          * request and export were done by on behalf of userspace, so
 399          * they may be undone on its behalf too.
 400          */
 401         if (test_and_clear_bit(FLAG_SYSFS, &gpio_desc[gpio].flags)) {
 402                 status = 0;
 403                 gpio_free(gpio);
 404         }
 405 done:
 406         if (status)
 407                 pr_debug("%s: status %d\n", __func__, status);
 408         return status ? : len;
 409 }
 410
 411 static struct class_attribute gpio_class_attrs[] = {
 412         __ATTR(export, 0200, NULL, export_store),
 413         __ATTR(unexport, 0200, NULL, unexport_store),
 414         __ATTR_NULL,
 415 };
 416
 417 static struct class gpio_class = {
 418         .name =         "gpio",
 419         .owner =        THIS_MODULE,
 420
 421         .class_attrs =  gpio_class_attrs,
 422 };
 423
 424
 425 /**
 426  * gpio_export - export a GPIO through sysfs
 427  * @gpio: gpio to make available, already requested
 428  * @direction_may_change: true if userspace may change gpio direction
 429  * Context: arch_initcall or later
 430  *
 431  * When drivers want to make a GPIO accessible to userspace after they
 432  * have requested it -- perhaps while debugging, or as part of their
 433  * public interface -- they may use this routine.  If the GPIO can
 434  * change direction (some can't) and the caller allows it, userspace
 435  * will see "direction" sysfs attribute which may be used to change
 436  * the gpio's direction.  A "value" attribute will always be provided.
 437  *
 438  * Returns zero on success, else an error.
 439  */
 440 int gpio_export(unsigned gpio, bool direction_may_change)
 441 {
 442         unsigned long           flags;
 443         struct gpio_desc        *desc;
 444         int                     status = -EINVAL;
 445         char                    *ioname = NULL;
 446
 447         /* can't export until sysfs is available ... */
 448         if (!gpio_class.p) {
 449                 pr_debug("%s: called too early!\n", __func__);
 450                 return -ENOENT;
 451         }
 452
 453         if (!gpio_is_valid(gpio))
 454                 goto done;
 455
 456         mutex_lock(&sysfs_lock);
 457
 458         spin_lock_irqsave(&gpio_lock, flags);
 459         desc = &gpio_desc[gpio];
 460         if (test_bit(FLAG_REQUESTED, &desc->flags)
 461                         && !test_bit(FLAG_EXPORT, &desc->flags)) {
 462                 status = 0;
 463                 if (!desc->chip->direction_input
 464                                 || !desc->chip->direction_output)
 465                         direction_may_change = false;
 466         }
 467         spin_unlock_irqrestore(&gpio_lock, flags);
 468
 469         if (desc->chip->names && desc->chip->names[gpio - desc->chip->base])
 470                 ioname = desc->chip->names[gpio - desc->chip->base];
 471
 472         if (status == 0) {
 473                 struct device   *dev;
 474
 475                 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
 476                                     desc, ioname ? ioname : "gpio%d", gpio);
 477                 if (dev) {
 478                         if (direction_may_change)
 479                                 status = sysfs_create_group(&dev->kobj,
 480                                                 &gpio_attr_group);
 481                         else
 482                                 status = device_create_file(dev,
 483                                                 &dev_attr_value);
 484                         if (status != 0)
 485                                 device_unregister(dev);
 486                 } else
 487                         status = -ENODEV;
 488                 if (status == 0)
 489                         set_bit(FLAG_EXPORT, &desc->flags);
 490         }
 491
 492         mutex_unlock(&sysfs_lock);
 493
 494 done:
 495         if (status)
 496                 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
 497
 498         return status;
 499 }
 500 EXPORT_SYMBOL_GPL(gpio_export);
 501
 502 static int match_export(struct device *dev, void *data)
 503 {
 504         return dev_get_drvdata(dev) == data;
 505 }
 506
 507 /**
 508  * gpio_unexport - reverse effect of gpio_export()
 509  * @gpio: gpio to make unavailable
 510  *
 511  * This is implicit on gpio_free().
 512  */
 513 void gpio_unexport(unsigned gpio)
 514 {
 515         struct gpio_desc        *desc;
 516         int                     status = -EINVAL;
 517
 518         if (!gpio_is_valid(gpio))
 519                 goto done;
 520
 521         mutex_lock(&sysfs_lock);
 522
 523         desc = &gpio_desc[gpio];
 524
 525         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 526                 struct device   *dev = NULL;
 527
 528                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
 529                 if (dev) {
 530                         clear_bit(FLAG_EXPORT, &desc->flags);
 531                         put_device(dev);
 532                         device_unregister(dev);
 533                         status = 0;
 534                 } else
 535                         status = -ENODEV;
 536         }
 537
 538         mutex_unlock(&sysfs_lock);
 539 done:
 540         if (status)
 541                 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
 542 }
 543 EXPORT_SYMBOL_GPL(gpio_unexport);
 544
 545 static int gpiochip_export(struct gpio_chip *chip)
 546 {
 547         int             status;
 548         struct device   *dev;
 549
 550         /* Many systems register gpio chips for SOC support very early,
 551          * before driver model support is available.  In those cases we
 552          * export this later, in gpiolib_sysfs_init() ... here we just
 553          * verify that _some_ field of gpio_class got initialized.
 554          */
 555         if (!gpio_class.p)
 556                 return 0;
 557
 558         /* use chip->base for the ID; it's already known to be unique */
 559         mutex_lock(&sysfs_lock);
 560         dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
 561                                 "gpiochip%d", chip->base);
 562         if (dev) {
 563                 status = sysfs_create_group(&dev->kobj,
 564                                 &gpiochip_attr_group);
 565         } else
 566                 status = -ENODEV;
 567         chip->exported = (status == 0);
 568         mutex_unlock(&sysfs_lock);
 569
 570         if (status) {
 571                 unsigned long   flags;
 572                 unsigned        gpio;
 573
 574                 spin_lock_irqsave(&gpio_lock, flags);
 575                 gpio = chip->base;
 576                 while (gpio_desc[gpio].chip == chip)
 577                         gpio_desc[gpio++].chip = NULL;
 578                 spin_unlock_irqrestore(&gpio_lock, flags);
 579
 580                 pr_debug("%s: chip %s status %d\n", __func__,
 581                                 chip->label, status);
 582         }
 583
 584         return status;
 585 }
 586
 587 static void gpiochip_unexport(struct gpio_chip *chip)
 588 {
 589         int                     status;
 590         struct device           *dev;
 591
 592         mutex_lock(&sysfs_lock);
 593         dev = class_find_device(&gpio_class, NULL, chip, match_export);
 594         if (dev) {
 595                 put_device(dev);
 596                 device_unregister(dev);
 597                 chip->exported = 0;
 598                 status = 0;
 599         } else
 600                 status = -ENODEV;
 601         mutex_unlock(&sysfs_lock);
 602
 603         if (status)
 604                 pr_debug("%s: chip %s status %d\n", __func__,
 605                                 chip->label, status);
 606 }
 607
 608 static int __init gpiolib_sysfs_init(void)
 609 {
 610         int             status;
 611         unsigned long   flags;
 612         unsigned        gpio;
 613
 614         status = class_register(&gpio_class);
 615         if (status < 0)
 616                 return status;
 617
 618         /* Scan and register the gpio_chips which registered very
 619          * early (e.g. before the class_register above was called).
 620          *
 621          * We run before arch_initcall() so chip->dev nodes can have
 622          * registered, and so arch_initcall() can always gpio_export().
 623          */
 624         spin_lock_irqsave(&gpio_lock, flags);
 625         for (gpio = 0; gpio < ARCH_NR_GPIOS; gpio++) {
 626                 struct gpio_chip        *chip;
 627
 628                 chip = gpio_desc[gpio].chip;
 629                 if (!chip || chip->exported)
 630                         continue;
 631
 632                 spin_unlock_irqrestore(&gpio_lock, flags);
 633                 status = gpiochip_export(chip);
 634                 spin_lock_irqsave(&gpio_lock, flags);
 635         }
 636         spin_unlock_irqrestore(&gpio_lock, flags);
 637
 638
 639         return status;
 640 }
 641 postcore_initcall(gpiolib_sysfs_init);
 642
 643 #else
 644 static inline int gpiochip_export(struct gpio_chip *chip)
 645 {
 646         return 0;
 647 }
 648
 649 static inline void gpiochip_unexport(struct gpio_chip *chip)
 650 {
 651 }
 652
 653 #endif /* CONFIG_GPIO_SYSFS */
 654
 655 /**
 656  * gpiochip_add() - register a gpio_chip
 657  * @chip: the chip to register, with chip->base initialized
 658  * Context: potentially before irqs or kmalloc will work
 659  *
 660  * Returns a negative errno if the chip can't be registered, such as
 661  * because the chip->base is invalid or already associated with a
 662  * different chip.  Otherwise it returns zero as a success code.
 663  *
 664  * When gpiochip_add() is called very early during boot, so that GPIOs
 665  * can be freely used, the chip->dev device must be registered before
 666  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
 667  * for GPIOs will fail rudely.
 668  *
 669  * If chip->base is negative, this requests dynamic assignment of
 670  * a range of valid GPIOs.
 671  */
 672 int gpiochip_add(struct gpio_chip *chip)
 673 {
 674         unsigned long   flags;
 675         int             status = 0;
 676         unsigned        id;
 677         int             base = chip->base;
 678
 679         if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
 680                         && base >= 0) {
 681                 status = -EINVAL;
 682                 goto fail;
 683         }
 684
 685         spin_lock_irqsave(&gpio_lock, flags);
 686
 687         if (base < 0) {
 688                 base = gpiochip_find_base(chip->ngpio);
 689                 if (base < 0) {
 690                         status = base;
 691                         goto unlock;
 692                 }
 693                 chip->base = base;
 694         }
 695
 696         /* these GPIO numbers must not be managed by another gpio_chip */
 697         for (id = base; id < base + chip->ngpio; id++) {
 698                 if (gpio_desc[id].chip != NULL) {
 699                         status = -EBUSY;
 700                         break;
 701                 }
 702         }
 703         if (status == 0) {
 704                 for (id = base; id < base + chip->ngpio; id++) {
 705                         gpio_desc[id].chip = chip;
 706
 707                         /* REVISIT:  most hardware initializes GPIOs as
 708                          * inputs (often with pullups enabled) so power
 709                          * usage is minimized.  Linux code should set the
 710                          * gpio direction first thing; but until it does,
 711                          * we may expose the wrong direction in sysfs.
 712                          */
 713                         gpio_desc[id].flags = !chip->direction_input
 714                                 ? (1 << FLAG_IS_OUT)
 715                                 : 0;
 716                 }
 717         }
 718
 719 unlock:
 720         spin_unlock_irqrestore(&gpio_lock, flags);
 721         if (status == 0)
 722                 status = gpiochip_export(chip);
 723 fail:
 724         /* failures here can mean systems won't boot... */
 725         if (status)
 726                 pr_err("gpiochip_add: gpios %d..%d (%s) not registered\n",
 727                         chip->base, chip->base + chip->ngpio - 1,
 728                         chip->label ? : "generic");
 729         return status;
 730 }
 731 EXPORT_SYMBOL_GPL(gpiochip_add);
 732
 733 /**
 734  * gpiochip_remove() - unregister a gpio_chip
 735  * @chip: the chip to unregister
 736  *
 737  * A gpio_chip with any GPIOs still requested may not be removed.
 738  */
 739 int gpiochip_remove(struct gpio_chip *chip)
 740 {
 741         unsigned long   flags;
 742         int             status = 0;
 743         unsigned        id;
 744
 745         spin_lock_irqsave(&gpio_lock, flags);
 746
 747         for (id = chip->base; id < chip->base + chip->ngpio; id++) {
 748                 if (test_bit(FLAG_REQUESTED, &gpio_desc[id].flags)) {
 749                         status = -EBUSY;
 750                         break;
 751                 }
 752         }
 753         if (status == 0) {
 754                 for (id = chip->base; id < chip->base + chip->ngpio; id++)
 755                         gpio_desc[id].chip = NULL;
 756         }
 757
 758         spin_unlock_irqrestore(&gpio_lock, flags);
 759
 760         if (status == 0)
 761                 gpiochip_unexport(chip);
 762
 763         return status;
 764 }
 765 EXPORT_SYMBOL_GPL(gpiochip_remove);
 766
 767
 768 /* These "optional" allocation calls help prevent drivers from stomping
 769  * on each other, and help provide better diagnostics in debugfs.
 770  * They're called even less than the "set direction" calls.
 771  */
 772 int gpio_request(unsigned gpio, const char *label)
 773 {
 774         struct gpio_desc        *desc;
 775         struct gpio_chip        *chip;
 776         int                     status = -EINVAL;
 777         unsigned long           flags;
 778
 779         spin_lock_irqsave(&gpio_lock, flags);
 780
 781         if (!gpio_is_valid(gpio))
 782                 goto done;
 783         desc = &gpio_desc[gpio];
 784         chip = desc->chip;
 785         if (chip == NULL)
 786                 goto done;
 787
 788         if (!try_module_get(chip->owner))
 789                 goto done;
 790
 791         /* NOTE:  gpio_request() can be called in early boot,
 792          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
 793          */
 794
 795         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
 796                 desc_set_label(desc, label ? : "?");
 797                 status = 0;
 798         } else {
 799                 status = -EBUSY;
 800                 module_put(chip->owner);
 801                 goto done;
 802         }
 803
 804         if (chip->request) {
 805                 /* chip->request may sleep */
 806                 spin_unlock_irqrestore(&gpio_lock, flags);
 807                 status = chip->request(chip, gpio - chip->base);
 808                 spin_lock_irqsave(&gpio_lock, flags);
 809
 810                 if (status < 0) {
 811                         desc_set_label(desc, NULL);
 812                         module_put(chip->owner);
 813                         clear_bit(FLAG_REQUESTED, &desc->flags);
 814                 }
 815         }
 816
 817 done:
 818         if (status)
 819                 pr_debug("gpio_request: gpio-%d (%s) status %d\n",
 820                         gpio, label ? : "?", status);
 821         spin_unlock_irqrestore(&gpio_lock, flags);
 822         return status;
 823 }
 824 EXPORT_SYMBOL_GPL(gpio_request);
 825
 826 void gpio_free(unsigned gpio)
 827 {
 828         unsigned long           flags;
 829         struct gpio_desc        *desc;
 830         struct gpio_chip        *chip;
 831
 832         might_sleep();
 833
 834         if (!gpio_is_valid(gpio)) {
 835                 WARN_ON(extra_checks);
 836                 return;
 837         }
 838
 839         gpio_unexport(gpio);
 840
 841         spin_lock_irqsave(&gpio_lock, flags);
 842
 843         desc = &gpio_desc[gpio];
 844         chip = desc->chip;
 845         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
 846                 if (chip->free) {
 847                         spin_unlock_irqrestore(&gpio_lock, flags);
 848                         might_sleep_if(extra_checks && chip->can_sleep);
 849                         chip->free(chip, gpio - chip->base);
 850                         spin_lock_irqsave(&gpio_lock, flags);
 851                 }
 852                 desc_set_label(desc, NULL);
 853                 module_put(desc->chip->owner);
 854                 clear_bit(FLAG_REQUESTED, &desc->flags);
 855         } else
 856                 WARN_ON(extra_checks);
 857
 858         spin_unlock_irqrestore(&gpio_lock, flags);
 859 }
 860 EXPORT_SYMBOL_GPL(gpio_free);
 861
 862
 863 /**
 864  * gpiochip_is_requested - return string iff signal was requested
 865  * @chip: controller managing the signal
 866  * @offset: of signal within controller's 0..(ngpio - 1) range
 867  *
 868  * Returns NULL if the GPIO is not currently requested, else a string.
 869  * If debugfs support is enabled, the string returned is the label passed
 870  * to gpio_request(); otherwise it is a meaningless constant.
 871  *
 872  * This function is for use by GPIO controller drivers.  The label can
 873  * help with diagnostics, and knowing that the signal is used as a GPIO
 874  * can help avoid accidentally multiplexing it to another controller.
 875  */
 876 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
 877 {
 878         unsigned gpio = chip->base + offset;
 879
 880         if (!gpio_is_valid(gpio) || gpio_desc[gpio].chip != chip)
 881                 return NULL;
 882         if (test_bit(FLAG_REQUESTED, &gpio_desc[gpio].flags) == 0)
 883                 return NULL;
 884 #ifdef CONFIG_DEBUG_FS
 885         return gpio_desc[gpio].label;
 886 #else
 887         return "?";
 888 #endif
 889 }
 890 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
 891
 892
 893 /* Drivers MUST set GPIO direction before making get/set calls.  In
 894  * some cases this is done in early boot, before IRQs are enabled.
 895  *
 896  * As a rule these aren't called more than once (except for drivers
 897  * using the open-drain emulation idiom) so these are natural places
 898  * to accumulate extra debugging checks.  Note that we can't (yet)
 899  * rely on gpio_request() having been called beforehand.
 900  */
 901
 902 int gpio_direction_input(unsigned gpio)
 903 {
 904         unsigned long           flags;
 905         struct gpio_chip        *chip;
 906         struct gpio_desc        *desc = &gpio_desc[gpio];
 907         int                     status = -EINVAL;
 908
 909         spin_lock_irqsave(&gpio_lock, flags);
 910
 911         if (!gpio_is_valid(gpio))
 912                 goto fail;
 913         chip = desc->chip;
 914         if (!chip || !chip->get || !chip->direction_input)
 915                 goto fail;
 916         gpio -= chip->base;
 917         if (gpio >= chip->ngpio)
 918                 goto fail;
 919         status = gpio_ensure_requested(desc, gpio);
 920         if (status < 0)
 921                 goto fail;
 922
 923         /* now we know the gpio is valid and chip won't vanish */
 924
 925         spin_unlock_irqrestore(&gpio_lock, flags);
 926
 927         might_sleep_if(extra_checks && chip->can_sleep);
 928
 929         if (status) {
 930                 status = chip->request(chip, gpio);
 931                 if (status < 0) {
 932                         pr_debug("GPIO-%d: chip request fail, %d\n",
 933                                 chip->base + gpio, status);
 934                         /* and it's not available to anyone else ...
 935                          * gpio_request() is the fully clean solution.
 936                          */
 937                         goto lose;
 938                 }
 939         }
 940
 941         status = chip->direction_input(chip, gpio);
 942         if (status == 0)
 943                 clear_bit(FLAG_IS_OUT, &desc->flags);
 944 lose:
 945         return status;
 946 fail:
 947         spin_unlock_irqrestore(&gpio_lock, flags);
 948         if (status)
 949                 pr_debug("%s: gpio-%d status %d\n",
 950                         __func__, gpio, status);
 951         return status;
 952 }
 953 EXPORT_SYMBOL_GPL(gpio_direction_input);
 954
 955 int gpio_direction_output(unsigned gpio, int value)
 956 {
 957         unsigned long           flags;
 958         struct gpio_chip        *chip;
 959         struct gpio_desc        *desc = &gpio_desc[gpio];
 960         int                     status = -EINVAL;
 961
 962         spin_lock_irqsave(&gpio_lock, flags);
 963
 964         if (!gpio_is_valid(gpio))
 965                 goto fail;
 966         chip = desc->chip;
 967         if (!chip || !chip->set || !chip->direction_output)
 968                 goto fail;
 969         gpio -= chip->base;
 970         if (gpio >= chip->ngpio)
 971                 goto fail;
 972         status = gpio_ensure_requested(desc, gpio);
 973         if (status < 0)
 974                 goto fail;
 975
 976         /* now we know the gpio is valid and chip won't vanish */
 977
 978         spin_unlock_irqrestore(&gpio_lock, flags);
 979
 980         might_sleep_if(extra_checks && chip->can_sleep);
 981
 982         if (status) {
 983                 status = chip->request(chip, gpio);
 984                 if (status < 0) {
 985                         pr_debug("GPIO-%d: chip request fail, %d\n",
 986                                 chip->base + gpio, status);
 987                         /* and it's not available to anyone else ...
 988                          * gpio_request() is the fully clean solution.
 989                          */
 990                         goto lose;
 991                 }
 992         }
 993
 994         status = chip->direction_output(chip, gpio, value);
 995         if (status == 0)
 996                 set_bit(FLAG_IS_OUT, &desc->flags);
 997 lose:
 998         return status;
 999 fail:
1000         spin_unlock_irqrestore(&gpio_lock, flags);
1001         if (status)
1002                 pr_debug("%s: gpio-%d status %d\n",
1003                         __func__, gpio, status);
1004         return status;
1005 }
1006 EXPORT_SYMBOL_GPL(gpio_direction_output);
1007
1008
1009 /* I/O calls are only valid after configuration completed; the relevant
1010  * "is this a valid GPIO" error checks should already have been done.
1011  *
1012  * "Get" operations are often inlinable as reading a pin value register,
1013  * and masking the relevant bit in that register.
1014  *
1015  * When "set" operations are inlinable, they involve writing that mask to
1016  * one register to set a low value, or a different register to set it high.
1017  * Otherwise locking is needed, so there may be little value to inlining.
1018  *
1019  *------------------------------------------------------------------------
1020  *
1021  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
1022  * have requested the GPIO.  That can include implicit requesting by
1023  * a direction setting call.  Marking a gpio as requested locks its chip
1024  * in memory, guaranteeing that these table lookups need no more locking
1025  * and that gpiochip_remove() will fail.
1026  *
1027  * REVISIT when debugging, consider adding some instrumentation to ensure
1028  * that the GPIO was actually requested.
1029  */
1030
1031 /**
1032  * __gpio_get_value() - return a gpio's value
1033  * @gpio: gpio whose value will be returned
1034  * Context: any
1035  *
1036  * This is used directly or indirectly to implement gpio_get_value().
1037  * It returns the zero or nonzero value provided by the associated
1038  * gpio_chip.get() method; or zero if no such method is provided.
1039  */
1040 int __gpio_get_value(unsigned gpio)
1041 {
1042         struct gpio_chip        *chip;
1043
1044         chip = gpio_to_chip(gpio);
1045         WARN_ON(extra_checks && chip->can_sleep);
1046         return chip->get ? chip->get(chip, gpio - chip->base) : 0;
1047 }
1048 EXPORT_SYMBOL_GPL(__gpio_get_value);
1049
1050 /**
1051  * __gpio_set_value() - assign a gpio's value
1052  * @gpio: gpio whose value will be assigned
1053  * @value: value to assign
1054  * Context: any
1055  *
1056  * This is used directly or indirectly to implement gpio_set_value().
1057  * It invokes the associated gpio_chip.set() method.
1058  */
1059 void __gpio_set_value(unsigned gpio, int value)
1060 {
1061         struct gpio_chip        *chip;
1062
1063         chip = gpio_to_chip(gpio);
1064         WARN_ON(extra_checks && chip->can_sleep);
1065         chip->set(chip, gpio - chip->base, value);
1066 }
1067 EXPORT_SYMBOL_GPL(__gpio_set_value);
1068
1069 /**
1070  * __gpio_cansleep() - report whether gpio value access will sleep
1071  * @gpio: gpio in question
1072  * Context: any
1073  *
1074  * This is used directly or indirectly to implement gpio_cansleep().  It
1075  * returns nonzero if access reading or writing the GPIO value can sleep.
1076  */
1077 int __gpio_cansleep(unsigned gpio)
1078 {
1079         struct gpio_chip        *chip;
1080
1081         /* only call this on GPIOs that are valid! */
1082         chip = gpio_to_chip(gpio);
1083
1084         return chip->can_sleep;
1085 }
1086 EXPORT_SYMBOL_GPL(__gpio_cansleep);
1087
1088 /**
1089  * __gpio_to_irq() - return the IRQ corresponding to a GPIO
1090  * @gpio: gpio whose IRQ will be returned (already requested)
1091  * Context: any
1092  *
1093  * This is used directly or indirectly to implement gpio_to_irq().
1094  * It returns the number of the IRQ signaled by this (input) GPIO,
1095  * or a negative errno.
1096  */
1097 int __gpio_to_irq(unsigned gpio)
1098 {
1099         struct gpio_chip        *chip;
1100
1101         chip = gpio_to_chip(gpio);
1102         return chip->to_irq ? chip->to_irq(chip, gpio - chip->base) : -ENXIO;
1103 }
1104 EXPORT_SYMBOL_GPL(__gpio_to_irq);
1105
1106
1107
1108 /* There's no value in making it easy to inline GPIO calls that may sleep.
1109  * Common examples include ones connected to I2C or SPI chips.
1110  */
1111
1112 int gpio_get_value_cansleep(unsigned gpio)
1113 {
1114         struct gpio_chip        *chip;
1115
1116         might_sleep_if(extra_checks);
1117         chip = gpio_to_chip(gpio);
1118         return chip->get ? chip->get(chip, gpio - chip->base) : 0;
1119 }
1120 EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
1121
1122 void gpio_set_value_cansleep(unsigned gpio, int value)
1123 {
1124         struct gpio_chip        *chip;
1125
1126         might_sleep_if(extra_checks);
1127         chip = gpio_to_chip(gpio);
1128         chip->set(chip, gpio - chip->base, value);
1129 }
1130 EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
1131
1132
1133 #ifdef CONFIG_DEBUG_FS
1134
1135 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
1136 {
1137         unsigned                i;
1138         unsigned                gpio = chip->base;
1139         struct gpio_desc        *gdesc = &gpio_desc[gpio];
1140         int                     is_out;
1141
1142         for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
1143                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
1144                         continue;
1145
1146                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
1147                 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
1148                         gpio, gdesc->label,
1149                         is_out ? "out" : "in ",
1150                         chip->get
1151                                 ? (chip->get(chip, i) ? "hi" : "lo")
1152                                 : "?  ");
1153
1154                 if (!is_out) {
1155                         int             irq = gpio_to_irq(gpio);
1156                         struct irq_desc *desc = irq_to_desc(irq);
1157
1158                         /* This races with request_irq(), set_irq_type(),
1159                          * and set_irq_wake() ... but those are "rare".
1160                          *
1161                          * More significantly, trigger type flags aren't
1162                          * currently maintained by genirq.
1163                          */
1164                         if (irq >= 0 && desc->action) {
1165                                 char *trigger;
1166
1167                                 switch (desc->status & IRQ_TYPE_SENSE_MASK) {
1168                                 case IRQ_TYPE_NONE:
1169                                         trigger = "(default)";
1170                                         break;
1171                                 case IRQ_TYPE_EDGE_FALLING:
1172                                         trigger = "edge-falling";
1173                                         break;
1174                                 case IRQ_TYPE_EDGE_RISING:
1175                                         trigger = "edge-rising";
1176                                         break;
1177                                 case IRQ_TYPE_EDGE_BOTH:
1178                                         trigger = "edge-both";
1179                                         break;
1180                                 case IRQ_TYPE_LEVEL_HIGH:
1181                                         trigger = "level-high";
1182                                         break;
1183                                 case IRQ_TYPE_LEVEL_LOW:
1184                                         trigger = "level-low";
1185                                         break;
1186                                 default:
1187                                         trigger = "?trigger?";
1188                                         break;
1189                                 }
1190
1191                                 seq_printf(s, " irq-%d %s%s",
1192                                         irq, trigger,
1193                                         (desc->status & IRQ_WAKEUP)
1194                                                 ? " wakeup" : "");
1195                         }
1196                 }
1197
1198                 seq_printf(s, "\n");
1199         }
1200 }
1201
1202 static int gpiolib_show(struct seq_file *s, void *unused)
1203 {
1204         struct gpio_chip        *chip = NULL;
1205         unsigned                gpio;
1206         int                     started = 0;
1207
1208         /* REVISIT this isn't locked against gpio_chip removal ... */
1209
1210         for (gpio = 0; gpio_is_valid(gpio); gpio++) {
1211                 struct device *dev;
1212
1213                 if (chip == gpio_desc[gpio].chip)
1214                         continue;
1215                 chip = gpio_desc[gpio].chip;
1216                 if (!chip)
1217                         continue;
1218
1219                 seq_printf(s, "%sGPIOs %d-%d",
1220                                 started ? "\n" : "",
1221                                 chip->base, chip->base + chip->ngpio - 1);
1222                 dev = chip->dev;
1223                 if (dev)
1224                         seq_printf(s, ", %s/%s",
1225                                 dev->bus ? dev->bus->name : "no-bus",
1226                                 dev_name(dev));
1227                 if (chip->label)
1228                         seq_printf(s, ", %s", chip->label);
1229                 if (chip->can_sleep)
1230                         seq_printf(s, ", can sleep");
1231                 seq_printf(s, ":\n");
1232
1233                 started = 1;
1234                 if (chip->dbg_show)
1235                         chip->dbg_show(s, chip);
1236                 else
1237                         gpiolib_dbg_show(s, chip);
1238         }
1239         return 0;
1240 }
1241
1242 static int gpiolib_open(struct inode *inode, struct file *file)
1243 {
1244         return single_open(file, gpiolib_show, NULL);
1245 }
1246
1247 static struct file_operations gpiolib_operations = {
1248         .open           = gpiolib_open,
1249         .read           = seq_read,
1250         .llseek         = seq_lseek,
1251         .release        = single_release,
1252 };
1253
1254 static int __init gpiolib_debugfs_init(void)
1255 {
1256         /* /sys/kernel/debug/gpio */
1257         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
1258                                 NULL, NULL, &gpiolib_operations);
1259         return 0;
1260 }
1261 subsys_initcall(gpiolib_debugfs_init);
1262
1263 #endif  /* DEBUG_FS */