Pileus Git - ~andy/linux/blob - drivers/gpio/gpiolib.c

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