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 #include <linux/gpio/machine.h>
  18 #include <linux/pinctrl/consumer.h>
  19 #include <linux/cdev.h>
  20 #include <linux/fs.h>
  21 #include <linux/uaccess.h>
  22 #include <linux/compat.h>
  23 #include <linux/anon_inodes.h>
  24 #include <linux/file.h>
  25 #include <linux/kfifo.h>
  26 #include <linux/poll.h>
  27 #include <linux/timekeeping.h>
  28 #include <uapi/linux/gpio.h>
  29
  30 #include "gpiolib.h"
  31
  32 #define CREATE_TRACE_POINTS
  33 #include <trace/events/gpio.h>
  34
  35 /* Implementation infrastructure for GPIO interfaces.
  36  *
  37  * The GPIO programming interface allows for inlining speed-critical
  38  * get/set operations for common cases, so that access to SOC-integrated
  39  * GPIOs can sometimes cost only an instruction or two per bit.
  40  */
  41
  42
  43 /* When debugging, extend minimal trust to callers and platform code.
  44  * Also emit diagnostic messages that may help initial bringup, when
  45  * board setup or driver bugs are most common.
  46  *
  47  * Otherwise, minimize overhead in what may be bitbanging codepaths.
  48  */
  49 #ifdef  DEBUG
  50 #define extra_checks    1
  51 #else
  52 #define extra_checks    0
  53 #endif
  54
  55 /* Device and char device-related information */
  56 static DEFINE_IDA(gpio_ida);
  57 static dev_t gpio_devt;
  58 #define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */
  59 static struct bus_type gpio_bus_type = {
  60         .name = "gpio",
  61 };
  62
  63 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
  64  * While any GPIO is requested, its gpio_chip is not removable;
  65  * each GPIO's "requested" flag serves as a lock and refcount.
  66  */
  67 DEFINE_SPINLOCK(gpio_lock);
  68
  69 static DEFINE_MUTEX(gpio_lookup_lock);
  70 static LIST_HEAD(gpio_lookup_list);
  71 LIST_HEAD(gpio_devices);
  72
  73 static void gpiochip_free_hogs(struct gpio_chip *chip);
  74 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
  75 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
  76 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
  77
  78 static bool gpiolib_initialized;
  79
  80 static inline void desc_set_label(struct gpio_desc *d, const char *label)
  81 {
  82         d->label = label;
  83 }
  84
  85 /**
  86  * Convert a GPIO number to its descriptor
  87  */
  88 struct gpio_desc *gpio_to_desc(unsigned gpio)
  89 {
  90         struct gpio_device *gdev;
  91         unsigned long flags;
  92
  93         spin_lock_irqsave(&gpio_lock, flags);
  94
  95         list_for_each_entry(gdev, &gpio_devices, list) {
  96                 if (gdev->base <= gpio &&
  97                     gdev->base + gdev->ngpio > gpio) {
  98                         spin_unlock_irqrestore(&gpio_lock, flags);
  99                         return &gdev->descs[gpio - gdev->base];
 100                 }
 101         }
 102
 103         spin_unlock_irqrestore(&gpio_lock, flags);
 104
 105         if (!gpio_is_valid(gpio))
 106                 WARN(1, "invalid GPIO %d\n", gpio);
 107
 108         return NULL;
 109 }
 110 EXPORT_SYMBOL_GPL(gpio_to_desc);
 111
 112 /**
 113  * Get the GPIO descriptor corresponding to the given hw number for this chip.
 114  */
 115 struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
 116                                     u16 hwnum)
 117 {
 118         struct gpio_device *gdev = chip->gpiodev;
 119
 120         if (hwnum >= gdev->ngpio)
 121                 return ERR_PTR(-EINVAL);
 122
 123         return &gdev->descs[hwnum];
 124 }
 125
 126 /**
 127  * Convert a GPIO descriptor to the integer namespace.
 128  * This should disappear in the future but is needed since we still
 129  * use GPIO numbers for error messages and sysfs nodes
 130  */
 131 int desc_to_gpio(const struct gpio_desc *desc)
 132 {
 133         return desc->gdev->base + (desc - &desc->gdev->descs[0]);
 134 }
 135 EXPORT_SYMBOL_GPL(desc_to_gpio);
 136
 137
 138 /**
 139  * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
 140  * @desc:       descriptor to return the chip of
 141  */
 142 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
 143 {
 144         if (!desc || !desc->gdev || !desc->gdev->chip)
 145                 return NULL;
 146         return desc->gdev->chip;
 147 }
 148 EXPORT_SYMBOL_GPL(gpiod_to_chip);
 149
 150 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
 151 static int gpiochip_find_base(int ngpio)
 152 {
 153         struct gpio_device *gdev;
 154         int base = ARCH_NR_GPIOS - ngpio;
 155
 156         list_for_each_entry_reverse(gdev, &gpio_devices, list) {
 157                 /* found a free space? */
 158                 if (gdev->base + gdev->ngpio <= base)
 159                         break;
 160                 else
 161                         /* nope, check the space right before the chip */
 162                         base = gdev->base - ngpio;
 163         }
 164
 165         if (gpio_is_valid(base)) {
 166                 pr_debug("%s: found new base at %d\n", __func__, base);
 167                 return base;
 168         } else {
 169                 pr_err("%s: cannot find free range\n", __func__);
 170                 return -ENOSPC;
 171         }
 172 }
 173
 174 /**
 175  * gpiod_get_direction - return the current direction of a GPIO
 176  * @desc:       GPIO to get the direction of
 177  *
 178  * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
 179  *
 180  * This function may sleep if gpiod_cansleep() is true.
 181  */
 182 int gpiod_get_direction(struct gpio_desc *desc)
 183 {
 184         struct gpio_chip        *chip;
 185         unsigned                offset;
 186         int                     status = -EINVAL;
 187
 188         chip = gpiod_to_chip(desc);
 189         offset = gpio_chip_hwgpio(desc);
 190
 191         if (!chip->get_direction)
 192                 return status;
 193
 194         status = chip->get_direction(chip, offset);
 195         if (status > 0) {
 196                 /* GPIOF_DIR_IN, or other positive */
 197                 status = 1;
 198                 clear_bit(FLAG_IS_OUT, &desc->flags);
 199         }
 200         if (status == 0) {
 201                 /* GPIOF_DIR_OUT */
 202                 set_bit(FLAG_IS_OUT, &desc->flags);
 203         }
 204         return status;
 205 }
 206 EXPORT_SYMBOL_GPL(gpiod_get_direction);
 207
 208 /*
 209  * Add a new chip to the global chips list, keeping the list of chips sorted
 210  * by range(means [base, base + ngpio - 1]) order.
 211  *
 212  * Return -EBUSY if the new chip overlaps with some other chip's integer
 213  * space.
 214  */
 215 static int gpiodev_add_to_list(struct gpio_device *gdev)
 216 {
 217         struct gpio_device *prev, *next;
 218
 219         if (list_empty(&gpio_devices)) {
 220                 /* initial entry in list */
 221                 list_add_tail(&gdev->list, &gpio_devices);
 222                 return 0;
 223         }
 224
 225         next = list_entry(gpio_devices.next, struct gpio_device, list);
 226         if (gdev->base + gdev->ngpio <= next->base) {
 227                 /* add before first entry */
 228                 list_add(&gdev->list, &gpio_devices);
 229                 return 0;
 230         }
 231
 232         prev = list_entry(gpio_devices.prev, struct gpio_device, list);
 233         if (prev->base + prev->ngpio <= gdev->base) {
 234                 /* add behind last entry */
 235                 list_add_tail(&gdev->list, &gpio_devices);
 236                 return 0;
 237         }
 238
 239         list_for_each_entry_safe(prev, next, &gpio_devices, list) {
 240                 /* at the end of the list */
 241                 if (&next->list == &gpio_devices)
 242                         break;
 243
 244                 /* add between prev and next */
 245                 if (prev->base + prev->ngpio <= gdev->base
 246                                 && gdev->base + gdev->ngpio <= next->base) {
 247                         list_add(&gdev->list, &prev->list);
 248                         return 0;
 249                 }
 250         }
 251
 252         dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
 253         return -EBUSY;
 254 }
 255
 256 /**
 257  * Convert a GPIO name to its descriptor
 258  */
 259 static struct gpio_desc *gpio_name_to_desc(const char * const name)
 260 {
 261         struct gpio_device *gdev;
 262         unsigned long flags;
 263
 264         spin_lock_irqsave(&gpio_lock, flags);
 265
 266         list_for_each_entry(gdev, &gpio_devices, list) {
 267                 int i;
 268
 269                 for (i = 0; i != gdev->ngpio; ++i) {
 270                         struct gpio_desc *desc = &gdev->descs[i];
 271
 272                         if (!desc->name || !name)
 273                                 continue;
 274
 275                         if (!strcmp(desc->name, name)) {
 276                                 spin_unlock_irqrestore(&gpio_lock, flags);
 277                                 return desc;
 278                         }
 279                 }
 280         }
 281
 282         spin_unlock_irqrestore(&gpio_lock, flags);
 283
 284         return NULL;
 285 }
 286
 287 /*
 288  * Takes the names from gc->names and checks if they are all unique. If they
 289  * are, they are assigned to their gpio descriptors.
 290  *
 291  * Warning if one of the names is already used for a different GPIO.
 292  */
 293 static int gpiochip_set_desc_names(struct gpio_chip *gc)
 294 {
 295         struct gpio_device *gdev = gc->gpiodev;
 296         int i;
 297
 298         if (!gc->names)
 299                 return 0;
 300
 301         /* First check all names if they are unique */
 302         for (i = 0; i != gc->ngpio; ++i) {
 303                 struct gpio_desc *gpio;
 304
 305                 gpio = gpio_name_to_desc(gc->names[i]);
 306                 if (gpio)
 307                         dev_warn(&gdev->dev,
 308                                  "Detected name collision for GPIO name '%s'\n",
 309                                  gc->names[i]);
 310         }
 311
 312         /* Then add all names to the GPIO descriptors */
 313         for (i = 0; i != gc->ngpio; ++i)
 314                 gdev->descs[i].name = gc->names[i];
 315
 316         return 0;
 317 }
 318
 319 /*
 320  * GPIO line handle management
 321  */
 322
 323 /**
 324  * struct linehandle_state - contains the state of a userspace handle
 325  * @gdev: the GPIO device the handle pertains to
 326  * @label: consumer label used to tag descriptors
 327  * @descs: the GPIO descriptors held by this handle
 328  * @numdescs: the number of descriptors held in the descs array
 329  */
 330 struct linehandle_state {
 331         struct gpio_device *gdev;
 332         const char *label;
 333         struct gpio_desc *descs[GPIOHANDLES_MAX];
 334         u32 numdescs;
 335 };
 336
 337 #define GPIOHANDLE_REQUEST_VALID_FLAGS \
 338         (GPIOHANDLE_REQUEST_INPUT | \
 339         GPIOHANDLE_REQUEST_OUTPUT | \
 340         GPIOHANDLE_REQUEST_ACTIVE_LOW | \
 341         GPIOHANDLE_REQUEST_OPEN_DRAIN | \
 342         GPIOHANDLE_REQUEST_OPEN_SOURCE)
 343
 344 static long linehandle_ioctl(struct file *filep, unsigned int cmd,
 345                              unsigned long arg)
 346 {
 347         struct linehandle_state *lh = filep->private_data;
 348         void __user *ip = (void __user *)arg;
 349         struct gpiohandle_data ghd;
 350         int i;
 351
 352         if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
 353                 int val;
 354
 355                 memset(&ghd, 0, sizeof(ghd));
 356
 357                 /* TODO: check if descriptors are really input */
 358                 for (i = 0; i < lh->numdescs; i++) {
 359                         val = gpiod_get_value_cansleep(lh->descs[i]);
 360                         if (val < 0)
 361                                 return val;
 362                         ghd.values[i] = val;
 363                 }
 364
 365                 if (copy_to_user(ip, &ghd, sizeof(ghd)))
 366                         return -EFAULT;
 367
 368                 return 0;
 369         } else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
 370                 int vals[GPIOHANDLES_MAX];
 371
 372                 /* TODO: check if descriptors are really output */
 373                 if (copy_from_user(&ghd, ip, sizeof(ghd)))
 374                         return -EFAULT;
 375
 376                 /* Clamp all values to [0,1] */
 377                 for (i = 0; i < lh->numdescs; i++)
 378                         vals[i] = !!ghd.values[i];
 379
 380                 /* Reuse the array setting function */
 381                 gpiod_set_array_value_complex(false,
 382                                               true,
 383                                               lh->numdescs,
 384                                               lh->descs,
 385                                               vals);
 386                 return 0;
 387         }
 388         return -EINVAL;
 389 }
 390
 391 #ifdef CONFIG_COMPAT
 392 static long linehandle_ioctl_compat(struct file *filep, unsigned int cmd,
 393                              unsigned long arg)
 394 {
 395         return linehandle_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
 396 }
 397 #endif
 398
 399 static int linehandle_release(struct inode *inode, struct file *filep)
 400 {
 401         struct linehandle_state *lh = filep->private_data;
 402         struct gpio_device *gdev = lh->gdev;
 403         int i;
 404
 405         for (i = 0; i < lh->numdescs; i++)
 406                 gpiod_free(lh->descs[i]);
 407         kfree(lh->label);
 408         kfree(lh);
 409         put_device(&gdev->dev);
 410         return 0;
 411 }
 412
 413 static const struct file_operations linehandle_fileops = {
 414         .release = linehandle_release,
 415         .owner = THIS_MODULE,
 416         .llseek = noop_llseek,
 417         .unlocked_ioctl = linehandle_ioctl,
 418 #ifdef CONFIG_COMPAT
 419         .compat_ioctl = linehandle_ioctl_compat,
 420 #endif
 421 };
 422
 423 static int linehandle_create(struct gpio_device *gdev, void __user *ip)
 424 {
 425         struct gpiohandle_request handlereq;
 426         struct linehandle_state *lh;
 427         struct file *file;
 428         int fd, i, ret;
 429
 430         if (copy_from_user(&handlereq, ip, sizeof(handlereq)))
 431                 return -EFAULT;
 432         if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX))
 433                 return -EINVAL;
 434
 435         lh = kzalloc(sizeof(*lh), GFP_KERNEL);
 436         if (!lh)
 437                 return -ENOMEM;
 438         lh->gdev = gdev;
 439         get_device(&gdev->dev);
 440
 441         /* Make sure this is terminated */
 442         handlereq.consumer_label[sizeof(handlereq.consumer_label)-1] = '\0';
 443         if (strlen(handlereq.consumer_label)) {
 444                 lh->label = kstrdup(handlereq.consumer_label,
 445                                     GFP_KERNEL);
 446                 if (!lh->label) {
 447                         ret = -ENOMEM;
 448                         goto out_free_lh;
 449                 }
 450         }
 451
 452         /* Request each GPIO */
 453         for (i = 0; i < handlereq.lines; i++) {
 454                 u32 offset = handlereq.lineoffsets[i];
 455                 u32 lflags = handlereq.flags;
 456                 struct gpio_desc *desc;
 457
 458                 if (offset >= gdev->ngpio) {
 459                         ret = -EINVAL;
 460                         goto out_free_descs;
 461                 }
 462
 463                 /* Return an error if a unknown flag is set */
 464                 if (lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) {
 465                         ret = -EINVAL;
 466                         goto out_free_descs;
 467                 }
 468
 469                 desc = &gdev->descs[offset];
 470                 ret = gpiod_request(desc, lh->label);
 471                 if (ret)
 472                         goto out_free_descs;
 473                 lh->descs[i] = desc;
 474
 475                 if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
 476                         set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 477                 if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
 478                         set_bit(FLAG_OPEN_DRAIN, &desc->flags);
 479                 if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
 480                         set_bit(FLAG_OPEN_SOURCE, &desc->flags);
 481
 482                 /*
 483                  * Lines have to be requested explicitly for input
 484                  * or output, else the line will be treated "as is".
 485                  */
 486                 if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
 487                         int val = !!handlereq.default_values[i];
 488
 489                         ret = gpiod_direction_output(desc, val);
 490                         if (ret)
 491                                 goto out_free_descs;
 492                 } else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
 493                         ret = gpiod_direction_input(desc);
 494                         if (ret)
 495                                 goto out_free_descs;
 496                 }
 497                 dev_dbg(&gdev->dev, "registered chardev handle for line %d\n",
 498                         offset);
 499         }
 500         /* Let i point at the last handle */
 501         i--;
 502         lh->numdescs = handlereq.lines;
 503
 504         fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
 505         if (fd < 0) {
 506                 ret = fd;
 507                 goto out_free_descs;
 508         }
 509
 510         file = anon_inode_getfile("gpio-linehandle",
 511                                   &linehandle_fileops,
 512                                   lh,
 513                                   O_RDONLY | O_CLOEXEC);
 514         if (IS_ERR(file)) {
 515                 ret = PTR_ERR(file);
 516                 goto out_put_unused_fd;
 517         }
 518
 519         handlereq.fd = fd;
 520         if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
 521                 /*
 522                  * fput() will trigger the release() callback, so do not go onto
 523                  * the regular error cleanup path here.
 524                  */
 525                 fput(file);
 526                 put_unused_fd(fd);
 527                 return -EFAULT;
 528         }
 529
 530         fd_install(fd, file);
 531
 532         dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n",
 533                 lh->numdescs);
 534
 535         return 0;
 536
 537 out_put_unused_fd:
 538         put_unused_fd(fd);
 539 out_free_descs:
 540         for (; i >= 0; i--)
 541                 gpiod_free(lh->descs[i]);
 542         kfree(lh->label);
 543 out_free_lh:
 544         kfree(lh);
 545         put_device(&gdev->dev);
 546         return ret;
 547 }
 548
 549 /*
 550  * GPIO line event management
 551  */
 552
 553 /**
 554  * struct lineevent_state - contains the state of a userspace event
 555  * @gdev: the GPIO device the event pertains to
 556  * @label: consumer label used to tag descriptors
 557  * @desc: the GPIO descriptor held by this event
 558  * @eflags: the event flags this line was requested with
 559  * @irq: the interrupt that trigger in response to events on this GPIO
 560  * @wait: wait queue that handles blocking reads of events
 561  * @events: KFIFO for the GPIO events
 562  * @read_lock: mutex lock to protect reads from colliding with adding
 563  * new events to the FIFO
 564  */
 565 struct lineevent_state {
 566         struct gpio_device *gdev;
 567         const char *label;
 568         struct gpio_desc *desc;
 569         u32 eflags;
 570         int irq;
 571         wait_queue_head_t wait;
 572         DECLARE_KFIFO(events, struct gpioevent_data, 16);
 573         struct mutex read_lock;
 574 };
 575
 576 #define GPIOEVENT_REQUEST_VALID_FLAGS \
 577         (GPIOEVENT_REQUEST_RISING_EDGE | \
 578         GPIOEVENT_REQUEST_FALLING_EDGE)
 579
 580 static unsigned int lineevent_poll(struct file *filep,
 581                                    struct poll_table_struct *wait)
 582 {
 583         struct lineevent_state *le = filep->private_data;
 584         unsigned int events = 0;
 585
 586         poll_wait(filep, &le->wait, wait);
 587
 588         if (!kfifo_is_empty(&le->events))
 589                 events = POLLIN | POLLRDNORM;
 590
 591         return events;
 592 }
 593
 594
 595 static ssize_t lineevent_read(struct file *filep,
 596                               char __user *buf,
 597                               size_t count,
 598                               loff_t *f_ps)
 599 {
 600         struct lineevent_state *le = filep->private_data;
 601         unsigned int copied;
 602         int ret;
 603
 604         if (count < sizeof(struct gpioevent_data))
 605                 return -EINVAL;
 606
 607         do {
 608                 if (kfifo_is_empty(&le->events)) {
 609                         if (filep->f_flags & O_NONBLOCK)
 610                                 return -EAGAIN;
 611
 612                         ret = wait_event_interruptible(le->wait,
 613                                         !kfifo_is_empty(&le->events));
 614                         if (ret)
 615                                 return ret;
 616                 }
 617
 618                 if (mutex_lock_interruptible(&le->read_lock))
 619                         return -ERESTARTSYS;
 620                 ret = kfifo_to_user(&le->events, buf, count, &copied);
 621                 mutex_unlock(&le->read_lock);
 622
 623                 if (ret)
 624                         return ret;
 625
 626                 /*
 627                  * If we couldn't read anything from the fifo (a different
 628                  * thread might have been faster) we either return -EAGAIN if
 629                  * the file descriptor is non-blocking, otherwise we go back to
 630                  * sleep and wait for more data to arrive.
 631                  */
 632                 if (copied == 0 && (filep->f_flags & O_NONBLOCK))
 633                         return -EAGAIN;
 634
 635         } while (copied == 0);
 636
 637         return copied;
 638 }
 639
 640 static int lineevent_release(struct inode *inode, struct file *filep)
 641 {
 642         struct lineevent_state *le = filep->private_data;
 643         struct gpio_device *gdev = le->gdev;
 644
 645         free_irq(le->irq, le);
 646         gpiod_free(le->desc);
 647         kfree(le->label);
 648         kfree(le);
 649         put_device(&gdev->dev);
 650         return 0;
 651 }
 652
 653 static long lineevent_ioctl(struct file *filep, unsigned int cmd,
 654                             unsigned long arg)
 655 {
 656         struct lineevent_state *le = filep->private_data;
 657         void __user *ip = (void __user *)arg;
 658         struct gpiohandle_data ghd;
 659
 660         /*
 661          * We can get the value for an event line but not set it,
 662          * because it is input by definition.
 663          */
 664         if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
 665                 int val;
 666
 667                 memset(&ghd, 0, sizeof(ghd));
 668
 669                 val = gpiod_get_value_cansleep(le->desc);
 670                 if (val < 0)
 671                         return val;
 672                 ghd.values[0] = val;
 673
 674                 if (copy_to_user(ip, &ghd, sizeof(ghd)))
 675                         return -EFAULT;
 676
 677                 return 0;
 678         }
 679         return -EINVAL;
 680 }
 681
 682 #ifdef CONFIG_COMPAT
 683 static long lineevent_ioctl_compat(struct file *filep, unsigned int cmd,
 684                                    unsigned long arg)
 685 {
 686         return lineevent_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
 687 }
 688 #endif
 689
 690 static const struct file_operations lineevent_fileops = {
 691         .release = lineevent_release,
 692         .read = lineevent_read,
 693         .poll = lineevent_poll,
 694         .owner = THIS_MODULE,
 695         .llseek = noop_llseek,
 696         .unlocked_ioctl = lineevent_ioctl,
 697 #ifdef CONFIG_COMPAT
 698         .compat_ioctl = lineevent_ioctl_compat,
 699 #endif
 700 };
 701
 702 static irqreturn_t lineevent_irq_thread(int irq, void *p)
 703 {
 704         struct lineevent_state *le = p;
 705         struct gpioevent_data ge;
 706         int ret;
 707
 708         ge.timestamp = ktime_get_real_ns();
 709
 710         if (le->eflags & GPIOEVENT_REQUEST_BOTH_EDGES) {
 711                 int level = gpiod_get_value_cansleep(le->desc);
 712
 713                 if (level)
 714                         /* Emit low-to-high event */
 715                         ge.id = GPIOEVENT_EVENT_RISING_EDGE;
 716                 else
 717                         /* Emit high-to-low event */
 718                         ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
 719         } else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE) {
 720                 /* Emit low-to-high event */
 721                 ge.id = GPIOEVENT_EVENT_RISING_EDGE;
 722         } else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
 723                 /* Emit high-to-low event */
 724                 ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
 725         } else {
 726                 return IRQ_NONE;
 727         }
 728
 729         ret = kfifo_put(&le->events, ge);
 730         if (ret != 0)
 731                 wake_up_poll(&le->wait, POLLIN);
 732
 733         return IRQ_HANDLED;
 734 }
 735
 736 static int lineevent_create(struct gpio_device *gdev, void __user *ip)
 737 {
 738         struct gpioevent_request eventreq;
 739         struct lineevent_state *le;
 740         struct gpio_desc *desc;
 741         struct file *file;
 742         u32 offset;
 743         u32 lflags;
 744         u32 eflags;
 745         int fd;
 746         int ret;
 747         int irqflags = 0;
 748
 749         if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
 750                 return -EFAULT;
 751
 752         le = kzalloc(sizeof(*le), GFP_KERNEL);
 753         if (!le)
 754                 return -ENOMEM;
 755         le->gdev = gdev;
 756         get_device(&gdev->dev);
 757
 758         /* Make sure this is terminated */
 759         eventreq.consumer_label[sizeof(eventreq.consumer_label)-1] = '\0';
 760         if (strlen(eventreq.consumer_label)) {
 761                 le->label = kstrdup(eventreq.consumer_label,
 762                                     GFP_KERNEL);
 763                 if (!le->label) {
 764                         ret = -ENOMEM;
 765                         goto out_free_le;
 766                 }
 767         }
 768
 769         offset = eventreq.lineoffset;
 770         lflags = eventreq.handleflags;
 771         eflags = eventreq.eventflags;
 772
 773         if (offset >= gdev->ngpio) {
 774                 ret = -EINVAL;
 775                 goto out_free_label;
 776         }
 777
 778         /* Return an error if a unknown flag is set */
 779         if ((lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) ||
 780             (eflags & ~GPIOEVENT_REQUEST_VALID_FLAGS)) {
 781                 ret = -EINVAL;
 782                 goto out_free_label;
 783         }
 784
 785         /* This is just wrong: we don't look for events on output lines */
 786         if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
 787                 ret = -EINVAL;
 788                 goto out_free_label;
 789         }
 790
 791         desc = &gdev->descs[offset];
 792         ret = gpiod_request(desc, le->label);
 793         if (ret)
 794                 goto out_free_desc;
 795         le->desc = desc;
 796         le->eflags = eflags;
 797
 798         if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
 799                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 800         if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
 801                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
 802         if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
 803                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
 804
 805         ret = gpiod_direction_input(desc);
 806         if (ret)
 807                 goto out_free_desc;
 808
 809         le->irq = gpiod_to_irq(desc);
 810         if (le->irq <= 0) {
 811                 ret = -ENODEV;
 812                 goto out_free_desc;
 813         }
 814
 815         if (eflags & GPIOEVENT_REQUEST_RISING_EDGE)
 816                 irqflags |= IRQF_TRIGGER_RISING;
 817         if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
 818                 irqflags |= IRQF_TRIGGER_FALLING;
 819         irqflags |= IRQF_ONESHOT;
 820         irqflags |= IRQF_SHARED;
 821
 822         INIT_KFIFO(le->events);
 823         init_waitqueue_head(&le->wait);
 824         mutex_init(&le->read_lock);
 825
 826         /* Request a thread to read the events */
 827         ret = request_threaded_irq(le->irq,
 828                         NULL,
 829                         lineevent_irq_thread,
 830                         irqflags,
 831                         le->label,
 832                         le);
 833         if (ret)
 834                 goto out_free_desc;
 835
 836         fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
 837         if (fd < 0) {
 838                 ret = fd;
 839                 goto out_free_irq;
 840         }
 841
 842         file = anon_inode_getfile("gpio-event",
 843                                   &lineevent_fileops,
 844                                   le,
 845                                   O_RDONLY | O_CLOEXEC);
 846         if (IS_ERR(file)) {
 847                 ret = PTR_ERR(file);
 848                 goto out_put_unused_fd;
 849         }
 850
 851         eventreq.fd = fd;
 852         if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
 853                 /*
 854                  * fput() will trigger the release() callback, so do not go onto
 855                  * the regular error cleanup path here.
 856                  */
 857                 fput(file);
 858                 put_unused_fd(fd);
 859                 return -EFAULT;
 860         }
 861
 862         fd_install(fd, file);
 863
 864         return 0;
 865
 866 out_put_unused_fd:
 867         put_unused_fd(fd);
 868 out_free_irq:
 869         free_irq(le->irq, le);
 870 out_free_desc:
 871         gpiod_free(le->desc);
 872 out_free_label:
 873         kfree(le->label);
 874 out_free_le:
 875         kfree(le);
 876         put_device(&gdev->dev);
 877         return ret;
 878 }
 879
 880 /**
 881  * gpio_ioctl() - ioctl handler for the GPIO chardev
 882  */
 883 static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 884 {
 885         struct gpio_device *gdev = filp->private_data;
 886         struct gpio_chip *chip = gdev->chip;
 887         void __user *ip = (void __user *)arg;
 888
 889         /* We fail any subsequent ioctl():s when the chip is gone */
 890         if (!chip)
 891                 return -ENODEV;
 892
 893         /* Fill in the struct and pass to userspace */
 894         if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
 895                 struct gpiochip_info chipinfo;
 896
 897                 memset(&chipinfo, 0, sizeof(chipinfo));
 898
 899                 strncpy(chipinfo.name, dev_name(&gdev->dev),
 900                         sizeof(chipinfo.name));
 901                 chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
 902                 strncpy(chipinfo.label, gdev->label,
 903                         sizeof(chipinfo.label));
 904                 chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
 905                 chipinfo.lines = gdev->ngpio;
 906                 if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
 907                         return -EFAULT;
 908                 return 0;
 909         } else if (cmd == GPIO_GET_LINEINFO_IOCTL) {
 910                 struct gpioline_info lineinfo;
 911                 struct gpio_desc *desc;
 912
 913                 if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
 914                         return -EFAULT;
 915                 if (lineinfo.line_offset >= gdev->ngpio)
 916                         return -EINVAL;
 917
 918                 desc = &gdev->descs[lineinfo.line_offset];
 919                 if (desc->name) {
 920                         strncpy(lineinfo.name, desc->name,
 921                                 sizeof(lineinfo.name));
 922                         lineinfo.name[sizeof(lineinfo.name)-1] = '\0';
 923                 } else {
 924                         lineinfo.name[0] = '\0';
 925                 }
 926                 if (desc->label) {
 927                         strncpy(lineinfo.consumer, desc->label,
 928                                 sizeof(lineinfo.consumer));
 929                         lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
 930                 } else {
 931                         lineinfo.consumer[0] = '\0';
 932                 }
 933
 934                 /*
 935                  * Userspace only need to know that the kernel is using
 936                  * this GPIO so it can't use it.
 937                  */
 938                 lineinfo.flags = 0;
 939                 if (test_bit(FLAG_REQUESTED, &desc->flags) ||
 940                     test_bit(FLAG_IS_HOGGED, &desc->flags) ||
 941                     test_bit(FLAG_USED_AS_IRQ, &desc->flags) ||
 942                     test_bit(FLAG_EXPORT, &desc->flags) ||
 943                     test_bit(FLAG_SYSFS, &desc->flags))
 944                         lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
 945                 if (test_bit(FLAG_IS_OUT, &desc->flags))
 946                         lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
 947                 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
 948                         lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
 949                 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
 950                         lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
 951                 if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
 952                         lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;
 953
 954                 if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
 955                         return -EFAULT;
 956                 return 0;
 957         } else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
 958                 return linehandle_create(gdev, ip);
 959         } else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
 960                 return lineevent_create(gdev, ip);
 961         }
 962         return -EINVAL;
 963 }
 964
 965 #ifdef CONFIG_COMPAT
 966 static long gpio_ioctl_compat(struct file *filp, unsigned int cmd,
 967                               unsigned long arg)
 968 {
 969         return gpio_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
 970 }
 971 #endif
 972
 973 /**
 974  * gpio_chrdev_open() - open the chardev for ioctl operations
 975  * @inode: inode for this chardev
 976  * @filp: file struct for storing private data
 977  * Returns 0 on success
 978  */
 979 static int gpio_chrdev_open(struct inode *inode, struct file *filp)
 980 {
 981         struct gpio_device *gdev = container_of(inode->i_cdev,
 982                                               struct gpio_device, chrdev);
 983
 984         /* Fail on open if the backing gpiochip is gone */
 985         if (!gdev || !gdev->chip)
 986                 return -ENODEV;
 987         get_device(&gdev->dev);
 988         filp->private_data = gdev;
 989         return 0;
 990 }
 991
 992 /**
 993  * gpio_chrdev_release() - close chardev after ioctl operations
 994  * @inode: inode for this chardev
 995  * @filp: file struct for storing private data
 996  * Returns 0 on success
 997  */
 998 static int gpio_chrdev_release(struct inode *inode, struct file *filp)
 999 {
1000         struct gpio_device *gdev = container_of(inode->i_cdev,
1001                                               struct gpio_device, chrdev);
1002
1003         if (!gdev)
1004                 return -ENODEV;
1005         put_device(&gdev->dev);
1006         return 0;
1007 }
1008
1009
1010 static const struct file_operations gpio_fileops = {
1011         .release = gpio_chrdev_release,
1012         .open = gpio_chrdev_open,
1013         .owner = THIS_MODULE,
1014         .llseek = noop_llseek,
1015         .unlocked_ioctl = gpio_ioctl,
1016 #ifdef CONFIG_COMPAT
1017         .compat_ioctl = gpio_ioctl_compat,
1018 #endif
1019 };
1020
1021 static void gpiodevice_release(struct device *dev)
1022 {
1023         struct gpio_device *gdev = dev_get_drvdata(dev);
1024
1025         list_del(&gdev->list);
1026         ida_simple_remove(&gpio_ida, gdev->id);
1027         kfree(gdev->label);
1028         kfree(gdev->descs);
1029         kfree(gdev);
1030 }
1031
1032 static int gpiochip_setup_dev(struct gpio_device *gdev)
1033 {
1034         int status;
1035
1036         cdev_init(&gdev->chrdev, &gpio_fileops);
1037         gdev->chrdev.owner = THIS_MODULE;
1038         gdev->chrdev.kobj.parent = &gdev->dev.kobj;
1039         gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
1040         status = cdev_add(&gdev->chrdev, gdev->dev.devt, 1);
1041         if (status < 0)
1042                 chip_warn(gdev->chip, "failed to add char device %d:%d\n",
1043                           MAJOR(gpio_devt), gdev->id);
1044         else
1045                 chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
1046                          MAJOR(gpio_devt), gdev->id);
1047         status = device_add(&gdev->dev);
1048         if (status)
1049                 goto err_remove_chardev;
1050
1051         status = gpiochip_sysfs_register(gdev);
1052         if (status)
1053                 goto err_remove_device;
1054
1055         /* From this point, the .release() function cleans up gpio_device */
1056         gdev->dev.release = gpiodevice_release;
1057         pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
1058                  __func__, gdev->base, gdev->base + gdev->ngpio - 1,
1059                  dev_name(&gdev->dev), gdev->chip->label ? : "generic");
1060
1061         return 0;
1062
1063 err_remove_device:
1064         device_del(&gdev->dev);
1065 err_remove_chardev:
1066         cdev_del(&gdev->chrdev);
1067         return status;
1068 }
1069
1070 static void gpiochip_setup_devs(void)
1071 {
1072         struct gpio_device *gdev;
1073         int err;
1074
1075         list_for_each_entry(gdev, &gpio_devices, list) {
1076                 err = gpiochip_setup_dev(gdev);
1077                 if (err)
1078                         pr_err("%s: Failed to initialize gpio device (%d)\n",
1079                                dev_name(&gdev->dev), err);
1080         }
1081 }
1082
1083 /**
1084  * gpiochip_add_data() - register a gpio_chip
1085  * @chip: the chip to register, with chip->base initialized
1086  * Context: potentially before irqs will work
1087  *
1088  * Returns a negative errno if the chip can't be registered, such as
1089  * because the chip->base is invalid or already associated with a
1090  * different chip.  Otherwise it returns zero as a success code.
1091  *
1092  * When gpiochip_add_data() is called very early during boot, so that GPIOs
1093  * can be freely used, the chip->parent device must be registered before
1094  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
1095  * for GPIOs will fail rudely.
1096  *
1097  * gpiochip_add_data() must only be called after gpiolib initialization,
1098  * ie after core_initcall().
1099  *
1100  * If chip->base is negative, this requests dynamic assignment of
1101  * a range of valid GPIOs.
1102  */
1103 int gpiochip_add_data(struct gpio_chip *chip, void *data)
1104 {
1105         unsigned long   flags;
1106         int             status = 0;
1107         unsigned        i;
1108         int             base = chip->base;
1109         struct gpio_device *gdev;
1110
1111         /*
1112          * First: allocate and populate the internal stat container, and
1113          * set up the struct device.
1114          */
1115         gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1116         if (!gdev)
1117                 return -ENOMEM;
1118         gdev->dev.bus = &gpio_bus_type;
1119         gdev->chip = chip;
1120         chip->gpiodev = gdev;
1121         if (chip->parent) {
1122                 gdev->dev.parent = chip->parent;
1123                 gdev->dev.of_node = chip->parent->of_node;
1124         }
1125
1126 #ifdef CONFIG_OF_GPIO
1127         /* If the gpiochip has an assigned OF node this takes precedence */
1128         if (chip->of_node)
1129                 gdev->dev.of_node = chip->of_node;
1130 #endif
1131
1132         gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
1133         if (gdev->id < 0) {
1134                 status = gdev->id;
1135                 goto err_free_gdev;
1136         }
1137         dev_set_name(&gdev->dev, "gpiochip%d", gdev->id);
1138         device_initialize(&gdev->dev);
1139         dev_set_drvdata(&gdev->dev, gdev);
1140         if (chip->parent && chip->parent->driver)
1141                 gdev->owner = chip->parent->driver->owner;
1142         else if (chip->owner)
1143                 /* TODO: remove chip->owner */
1144                 gdev->owner = chip->owner;
1145         else
1146                 gdev->owner = THIS_MODULE;
1147
1148         gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1149         if (!gdev->descs) {
1150                 status = -ENOMEM;
1151                 goto err_free_gdev;
1152         }
1153
1154         if (chip->ngpio == 0) {
1155                 chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1156                 status = -EINVAL;
1157                 goto err_free_descs;
1158         }
1159
1160         if (chip->label)
1161                 gdev->label = kstrdup(chip->label, GFP_KERNEL);
1162         else
1163                 gdev->label = kstrdup("unknown", GFP_KERNEL);
1164         if (!gdev->label) {
1165                 status = -ENOMEM;
1166                 goto err_free_descs;
1167         }
1168
1169         gdev->ngpio = chip->ngpio;
1170         gdev->data = data;
1171
1172         spin_lock_irqsave(&gpio_lock, flags);
1173
1174         /*
1175          * TODO: this allocates a Linux GPIO number base in the global
1176          * GPIO numberspace for this chip. In the long run we want to
1177          * get *rid* of this numberspace and use only descriptors, but
1178          * it may be a pipe dream. It will not happen before we get rid
1179          * of the sysfs interface anyways.
1180          */
1181         if (base < 0) {
1182                 base = gpiochip_find_base(chip->ngpio);
1183                 if (base < 0) {
1184                         status = base;
1185                         spin_unlock_irqrestore(&gpio_lock, flags);
1186                         goto err_free_label;
1187                 }
1188                 /*
1189                  * TODO: it should not be necessary to reflect the assigned
1190                  * base outside of the GPIO subsystem. Go over drivers and
1191                  * see if anyone makes use of this, else drop this and assign
1192                  * a poison instead.
1193                  */
1194                 chip->base = base;
1195         }
1196         gdev->base = base;
1197
1198         status = gpiodev_add_to_list(gdev);
1199         if (status) {
1200                 spin_unlock_irqrestore(&gpio_lock, flags);
1201                 goto err_free_label;
1202         }
1203
1204         spin_unlock_irqrestore(&gpio_lock, flags);
1205
1206         for (i = 0; i < chip->ngpio; i++) {
1207                 struct gpio_desc *desc = &gdev->descs[i];
1208
1209                 desc->gdev = gdev;
1210                 /*
1211                  * REVISIT: most hardware initializes GPIOs as inputs
1212                  * (often with pullups enabled) so power usage is
1213                  * minimized. Linux code should set the gpio direction
1214                  * first thing; but until it does, and in case
1215                  * chip->get_direction is not set, we may expose the
1216                  * wrong direction in sysfs.
1217                  */
1218
1219                 if (chip->get_direction) {
1220                         /*
1221                          * If we have .get_direction, set up the initial
1222                          * direction flag from the hardware.
1223                          */
1224                         int dir = chip->get_direction(chip, i);
1225
1226                         if (!dir)
1227                                 set_bit(FLAG_IS_OUT, &desc->flags);
1228                 } else if (!chip->direction_input) {
1229                         /*
1230                          * If the chip lacks the .direction_input callback
1231                          * we logically assume all lines are outputs.
1232                          */
1233                         set_bit(FLAG_IS_OUT, &desc->flags);
1234                 }
1235         }
1236
1237 #ifdef CONFIG_PINCTRL
1238         INIT_LIST_HEAD(&gdev->pin_ranges);
1239 #endif
1240
1241         status = gpiochip_set_desc_names(chip);
1242         if (status)
1243                 goto err_remove_from_list;
1244
1245         status = gpiochip_irqchip_init_valid_mask(chip);
1246         if (status)
1247                 goto err_remove_from_list;
1248
1249         status = of_gpiochip_add(chip);
1250         if (status)
1251                 goto err_remove_chip;
1252
1253         acpi_gpiochip_add(chip);
1254
1255         /*
1256          * By first adding the chardev, and then adding the device,
1257          * we get a device node entry in sysfs under
1258          * /sys/bus/gpio/devices/gpiochipN/dev that can be used for
1259          * coldplug of device nodes and other udev business.
1260          * We can do this only if gpiolib has been initialized.
1261          * Otherwise, defer until later.
1262          */
1263         if (gpiolib_initialized) {
1264                 status = gpiochip_setup_dev(gdev);
1265                 if (status)
1266                         goto err_remove_chip;
1267         }
1268         return 0;
1269
1270 err_remove_chip:
1271         acpi_gpiochip_remove(chip);
1272         gpiochip_free_hogs(chip);
1273         of_gpiochip_remove(chip);
1274         gpiochip_irqchip_free_valid_mask(chip);
1275 err_remove_from_list:
1276         spin_lock_irqsave(&gpio_lock, flags);
1277         list_del(&gdev->list);
1278         spin_unlock_irqrestore(&gpio_lock, flags);
1279 err_free_label:
1280         kfree(gdev->label);
1281 err_free_descs:
1282         kfree(gdev->descs);
1283 err_free_gdev:
1284         ida_simple_remove(&gpio_ida, gdev->id);
1285         /* failures here can mean systems won't boot... */
1286         pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1287                gdev->base, gdev->base + gdev->ngpio - 1,
1288                chip->label ? : "generic");
1289         kfree(gdev);
1290         return status;
1291 }
1292 EXPORT_SYMBOL_GPL(gpiochip_add_data);
1293
1294 /**
1295  * gpiochip_get_data() - get per-subdriver data for the chip
1296  */
1297 void *gpiochip_get_data(struct gpio_chip *chip)
1298 {
1299         return chip->gpiodev->data;
1300 }
1301 EXPORT_SYMBOL_GPL(gpiochip_get_data);
1302
1303 /**
1304  * gpiochip_remove() - unregister a gpio_chip
1305  * @chip: the chip to unregister
1306  *
1307  * A gpio_chip with any GPIOs still requested may not be removed.
1308  */
1309 void gpiochip_remove(struct gpio_chip *chip)
1310 {
1311         struct gpio_device *gdev = chip->gpiodev;
1312         struct gpio_desc *desc;
1313         unsigned long   flags;
1314         unsigned        i;
1315         bool            requested = false;
1316
1317         /* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1318         gpiochip_sysfs_unregister(gdev);
1319         /* Numb the device, cancelling all outstanding operations */
1320         gdev->chip = NULL;
1321         gpiochip_irqchip_remove(chip);
1322         acpi_gpiochip_remove(chip);
1323         gpiochip_remove_pin_ranges(chip);
1324         gpiochip_free_hogs(chip);
1325         of_gpiochip_remove(chip);
1326         /*
1327          * We accept no more calls into the driver from this point, so
1328          * NULL the driver data pointer
1329          */
1330         gdev->data = NULL;
1331
1332         spin_lock_irqsave(&gpio_lock, flags);
1333         for (i = 0; i < gdev->ngpio; i++) {
1334                 desc = &gdev->descs[i];
1335                 if (test_bit(FLAG_REQUESTED, &desc->flags))
1336                         requested = true;
1337         }
1338         spin_unlock_irqrestore(&gpio_lock, flags);
1339
1340         if (requested)
1341                 dev_crit(&gdev->dev,
1342                          "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
1343
1344         /*
1345          * The gpiochip side puts its use of the device to rest here:
1346          * if there are no userspace clients, the chardev and device will
1347          * be removed, else it will be dangling until the last user is
1348          * gone.
1349          */
1350         cdev_del(&gdev->chrdev);
1351         device_del(&gdev->dev);
1352         put_device(&gdev->dev);
1353 }
1354 EXPORT_SYMBOL_GPL(gpiochip_remove);
1355
1356 static void devm_gpio_chip_release(struct device *dev, void *res)
1357 {
1358         struct gpio_chip *chip = *(struct gpio_chip **)res;
1359
1360         gpiochip_remove(chip);
1361 }
1362
1363 static int devm_gpio_chip_match(struct device *dev, void *res, void *data)
1364
1365 {
1366         struct gpio_chip **r = res;
1367
1368         if (!r || !*r) {
1369                 WARN_ON(!r || !*r);
1370                 return 0;
1371         }
1372
1373         return *r == data;
1374 }
1375
1376 /**
1377  * devm_gpiochip_add_data() - Resource manager piochip_add_data()
1378  * @dev: the device pointer on which irq_chip belongs to.
1379  * @chip: the chip to register, with chip->base initialized
1380  * Context: potentially before irqs will work
1381  *
1382  * Returns a negative errno if the chip can't be registered, such as
1383  * because the chip->base is invalid or already associated with a
1384  * different chip.  Otherwise it returns zero as a success code.
1385  *
1386  * The gpio chip automatically be released when the device is unbound.
1387  */
1388 int devm_gpiochip_add_data(struct device *dev, struct gpio_chip *chip,
1389                            void *data)
1390 {
1391         struct gpio_chip **ptr;
1392         int ret;
1393
1394         ptr = devres_alloc(devm_gpio_chip_release, sizeof(*ptr),
1395                              GFP_KERNEL);
1396         if (!ptr)
1397                 return -ENOMEM;
1398
1399         ret = gpiochip_add_data(chip, data);
1400         if (ret < 0) {
1401                 devres_free(ptr);
1402                 return ret;
1403         }
1404
1405         *ptr = chip;
1406         devres_add(dev, ptr);
1407
1408         return 0;
1409 }
1410 EXPORT_SYMBOL_GPL(devm_gpiochip_add_data);
1411
1412 /**
1413  * devm_gpiochip_remove() - Resource manager of gpiochip_remove()
1414  * @dev: device for which which resource was allocated
1415  * @chip: the chip to remove
1416  *
1417  * A gpio_chip with any GPIOs still requested may not be removed.
1418  */
1419 void devm_gpiochip_remove(struct device *dev, struct gpio_chip *chip)
1420 {
1421         int ret;
1422
1423         ret = devres_release(dev, devm_gpio_chip_release,
1424                              devm_gpio_chip_match, chip);
1425         if (!ret)
1426                 WARN_ON(ret);
1427 }
1428 EXPORT_SYMBOL_GPL(devm_gpiochip_remove);
1429
1430 /**
1431  * gpiochip_find() - iterator for locating a specific gpio_chip
1432  * @data: data to pass to match function
1433  * @callback: Callback function to check gpio_chip
1434  *
1435  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1436  * determined by a user supplied @match callback.  The callback should return
1437  * 0 if the device doesn't match and non-zero if it does.  If the callback is
1438  * non-zero, this function will return to the caller and not iterate over any
1439  * more gpio_chips.
1440  */
1441 struct gpio_chip *gpiochip_find(void *data,
1442                                 int (*match)(struct gpio_chip *chip,
1443                                              void *data))
1444 {
1445         struct gpio_device *gdev;
1446         struct gpio_chip *chip = NULL;
1447         unsigned long flags;
1448
1449         spin_lock_irqsave(&gpio_lock, flags);
1450         list_for_each_entry(gdev, &gpio_devices, list)
1451                 if (gdev->chip && match(gdev->chip, data)) {
1452                         chip = gdev->chip;
1453                         break;
1454                 }
1455
1456         spin_unlock_irqrestore(&gpio_lock, flags);
1457
1458         return chip;
1459 }
1460 EXPORT_SYMBOL_GPL(gpiochip_find);
1461
1462 static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1463 {
1464         const char *name = data;
1465
1466         return !strcmp(chip->label, name);
1467 }
1468
1469 static struct gpio_chip *find_chip_by_name(const char *name)
1470 {
1471         return gpiochip_find((void *)name, gpiochip_match_name);
1472 }
1473
1474 #ifdef CONFIG_GPIOLIB_IRQCHIP
1475
1476 /*
1477  * The following is irqchip helper code for gpiochips.
1478  */
1479
1480 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
1481 {
1482         int i;
1483
1484         if (!gpiochip->irq_need_valid_mask)
1485                 return 0;
1486
1487         gpiochip->irq_valid_mask = kcalloc(BITS_TO_LONGS(gpiochip->ngpio),
1488                                            sizeof(long), GFP_KERNEL);
1489         if (!gpiochip->irq_valid_mask)
1490                 return -ENOMEM;
1491
1492         /* Assume by default all GPIOs are valid */
1493         for (i = 0; i < gpiochip->ngpio; i++)
1494                 set_bit(i, gpiochip->irq_valid_mask);
1495
1496         return 0;
1497 }
1498
1499 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
1500 {
1501         kfree(gpiochip->irq_valid_mask);
1502         gpiochip->irq_valid_mask = NULL;
1503 }
1504
1505 static bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
1506                                        unsigned int offset)
1507 {
1508         /* No mask means all valid */
1509         if (likely(!gpiochip->irq_valid_mask))
1510                 return true;
1511         return test_bit(offset, gpiochip->irq_valid_mask);
1512 }
1513
1514 /**
1515  * gpiochip_set_chained_irqchip() - sets a chained irqchip to a gpiochip
1516  * @gpiochip: the gpiochip to set the irqchip chain to
1517  * @irqchip: the irqchip to chain to the gpiochip
1518  * @parent_irq: the irq number corresponding to the parent IRQ for this
1519  * chained irqchip
1520  * @parent_handler: the parent interrupt handler for the accumulated IRQ
1521  * coming out of the gpiochip. If the interrupt is nested rather than
1522  * cascaded, pass NULL in this handler argument
1523  */
1524 void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
1525                                   struct irq_chip *irqchip,
1526                                   int parent_irq,
1527                                   irq_flow_handler_t parent_handler)
1528 {
1529         unsigned int offset;
1530
1531         if (!gpiochip->irqdomain) {
1532                 chip_err(gpiochip, "called %s before setting up irqchip\n",
1533                          __func__);
1534                 return;
1535         }
1536
1537         if (parent_handler) {
1538                 if (gpiochip->can_sleep) {
1539                         chip_err(gpiochip,
1540                                  "you cannot have chained interrupts on a "
1541                                  "chip that may sleep\n");
1542                         return;
1543                 }
1544                 /*
1545                  * The parent irqchip is already using the chip_data for this
1546                  * irqchip, so our callbacks simply use the handler_data.
1547                  */
1548                 irq_set_chained_handler_and_data(parent_irq, parent_handler,
1549                                                  gpiochip);
1550
1551                 gpiochip->irq_parent = parent_irq;
1552         }
1553
1554         /* Set the parent IRQ for all affected IRQs */
1555         for (offset = 0; offset < gpiochip->ngpio; offset++) {
1556                 if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
1557                         continue;
1558                 irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
1559                                parent_irq);
1560         }
1561 }
1562 EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);
1563
1564 /**
1565  * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
1566  * @d: the irqdomain used by this irqchip
1567  * @irq: the global irq number used by this GPIO irqchip irq
1568  * @hwirq: the local IRQ/GPIO line offset on this gpiochip
1569  *
1570  * This function will set up the mapping for a certain IRQ line on a
1571  * gpiochip by assigning the gpiochip as chip data, and using the irqchip
1572  * stored inside the gpiochip.
1573  */
1574 static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
1575                             irq_hw_number_t hwirq)
1576 {
1577         struct gpio_chip *chip = d->host_data;
1578
1579         irq_set_chip_data(irq, chip);
1580         /*
1581          * This lock class tells lockdep that GPIO irqs are in a different
1582          * category than their parents, so it won't report false recursion.
1583          */
1584         irq_set_lockdep_class(irq, chip->lock_key);
1585         irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
1586         /* Chips that can sleep need nested thread handlers */
1587         if (chip->can_sleep && !chip->irq_not_threaded)
1588                 irq_set_nested_thread(irq, 1);
1589         irq_set_noprobe(irq);
1590
1591         /*
1592          * No set-up of the hardware will happen if IRQ_TYPE_NONE
1593          * is passed as default type.
1594          */
1595         if (chip->irq_default_type != IRQ_TYPE_NONE)
1596                 irq_set_irq_type(irq, chip->irq_default_type);
1597
1598         return 0;
1599 }
1600
1601 static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
1602 {
1603         struct gpio_chip *chip = d->host_data;
1604
1605         if (chip->can_sleep)
1606                 irq_set_nested_thread(irq, 0);
1607         irq_set_chip_and_handler(irq, NULL, NULL);
1608         irq_set_chip_data(irq, NULL);
1609 }
1610
1611 static const struct irq_domain_ops gpiochip_domain_ops = {
1612         .map    = gpiochip_irq_map,
1613         .unmap  = gpiochip_irq_unmap,
1614         /* Virtually all GPIO irqchips are twocell:ed */
1615         .xlate  = irq_domain_xlate_twocell,
1616 };
1617
1618 static int gpiochip_irq_reqres(struct irq_data *d)
1619 {
1620         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1621
1622         if (!try_module_get(chip->gpiodev->owner))
1623                 return -ENODEV;
1624
1625         if (gpiochip_lock_as_irq(chip, d->hwirq)) {
1626                 chip_err(chip,
1627                         "unable to lock HW IRQ %lu for IRQ\n",
1628                         d->hwirq);
1629                 module_put(chip->gpiodev->owner);
1630                 return -EINVAL;
1631         }
1632         return 0;
1633 }
1634
1635 static void gpiochip_irq_relres(struct irq_data *d)
1636 {
1637         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1638
1639         gpiochip_unlock_as_irq(chip, d->hwirq);
1640         module_put(chip->gpiodev->owner);
1641 }
1642
1643 static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
1644 {
1645         return irq_find_mapping(chip->irqdomain, offset);
1646 }
1647
1648 /**
1649  * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
1650  * @gpiochip: the gpiochip to remove the irqchip from
1651  *
1652  * This is called only from gpiochip_remove()
1653  */
1654 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
1655 {
1656         unsigned int offset;
1657
1658         acpi_gpiochip_free_interrupts(gpiochip);
1659
1660         if (gpiochip->irq_parent) {
1661                 irq_set_chained_handler(gpiochip->irq_parent, NULL);
1662                 irq_set_handler_data(gpiochip->irq_parent, NULL);
1663         }
1664
1665         /* Remove all IRQ mappings and delete the domain */
1666         if (gpiochip->irqdomain) {
1667                 for (offset = 0; offset < gpiochip->ngpio; offset++) {
1668                         if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
1669                                 continue;
1670                         irq_dispose_mapping(
1671                                 irq_find_mapping(gpiochip->irqdomain, offset));
1672                 }
1673                 irq_domain_remove(gpiochip->irqdomain);
1674         }
1675
1676         if (gpiochip->irqchip) {
1677                 gpiochip->irqchip->irq_request_resources = NULL;
1678                 gpiochip->irqchip->irq_release_resources = NULL;
1679                 gpiochip->irqchip = NULL;
1680         }
1681
1682         gpiochip_irqchip_free_valid_mask(gpiochip);
1683 }
1684
1685 /**
1686  * gpiochip_irqchip_add() - adds an irqchip to a gpiochip
1687  * @gpiochip: the gpiochip to add the irqchip to
1688  * @irqchip: the irqchip to add to the gpiochip
1689  * @first_irq: if not dynamically assigned, the base (first) IRQ to
1690  * allocate gpiochip irqs from
1691  * @handler: the irq handler to use (often a predefined irq core function)
1692  * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
1693  * to have the core avoid setting up any default type in the hardware.
1694  * @lock_key: lockdep class
1695  *
1696  * This function closely associates a certain irqchip with a certain
1697  * gpiochip, providing an irq domain to translate the local IRQs to
1698  * global irqs in the gpiolib core, and making sure that the gpiochip
1699  * is passed as chip data to all related functions. Driver callbacks
1700  * need to use gpiochip_get_data() to get their local state containers back
1701  * from the gpiochip passed as chip data. An irqdomain will be stored
1702  * in the gpiochip that shall be used by the driver to handle IRQ number
1703  * translation. The gpiochip will need to be initialized and registered
1704  * before calling this function.
1705  *
1706  * This function will handle two cell:ed simple IRQs and assumes all
1707  * the pins on the gpiochip can generate a unique IRQ. Everything else
1708  * need to be open coded.
1709  */
1710 int _gpiochip_irqchip_add(struct gpio_chip *gpiochip,
1711                           struct irq_chip *irqchip,
1712                           unsigned int first_irq,
1713                           irq_flow_handler_t handler,
1714                           unsigned int type,
1715                           struct lock_class_key *lock_key)
1716 {
1717         struct device_node *of_node;
1718         bool irq_base_set = false;
1719         unsigned int offset;
1720         unsigned irq_base = 0;
1721
1722         if (!gpiochip || !irqchip)
1723                 return -EINVAL;
1724
1725         if (!gpiochip->parent) {
1726                 pr_err("missing gpiochip .dev parent pointer\n");
1727                 return -EINVAL;
1728         }
1729         of_node = gpiochip->parent->of_node;
1730 #ifdef CONFIG_OF_GPIO
1731         /*
1732          * If the gpiochip has an assigned OF node this takes precedence
1733          * FIXME: get rid of this and use gpiochip->parent->of_node
1734          * everywhere
1735          */
1736         if (gpiochip->of_node)
1737                 of_node = gpiochip->of_node;
1738 #endif
1739         /*
1740          * Specifying a default trigger is a terrible idea if DT or ACPI is
1741          * used to configure the interrupts, as you may end-up with
1742          * conflicting triggers. Tell the user, and reset to NONE.
1743          */
1744         if (WARN(of_node && type != IRQ_TYPE_NONE,
1745                  "%s: Ignoring %d default trigger\n", of_node->full_name, type))
1746                 type = IRQ_TYPE_NONE;
1747         if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
1748                 acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
1749                                  "Ignoring %d default trigger\n", type);
1750                 type = IRQ_TYPE_NONE;
1751         }
1752
1753         gpiochip->irqchip = irqchip;
1754         gpiochip->irq_handler = handler;
1755         gpiochip->irq_default_type = type;
1756         gpiochip->to_irq = gpiochip_to_irq;
1757         gpiochip->lock_key = lock_key;
1758         gpiochip->irqdomain = irq_domain_add_simple(of_node,
1759                                         gpiochip->ngpio, first_irq,
1760                                         &gpiochip_domain_ops, gpiochip);
1761         if (!gpiochip->irqdomain) {
1762                 gpiochip->irqchip = NULL;
1763                 return -EINVAL;
1764         }
1765
1766         /*
1767          * It is possible for a driver to override this, but only if the
1768          * alternative functions are both implemented.
1769          */
1770         if (!irqchip->irq_request_resources &&
1771             !irqchip->irq_release_resources) {
1772                 irqchip->irq_request_resources = gpiochip_irq_reqres;
1773                 irqchip->irq_release_resources = gpiochip_irq_relres;
1774         }
1775
1776         /*
1777          * Prepare the mapping since the irqchip shall be orthogonal to
1778          * any gpiochip calls. If the first_irq was zero, this is
1779          * necessary to allocate descriptors for all IRQs.
1780          */
1781         for (offset = 0; offset < gpiochip->ngpio; offset++) {
1782                 if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
1783                         continue;
1784                 irq_base = irq_create_mapping(gpiochip->irqdomain, offset);
1785                 if (!irq_base_set) {
1786                         /*
1787                          * Store the base into the gpiochip to be used when
1788                          * unmapping the irqs.
1789                          */
1790                         gpiochip->irq_base = irq_base;
1791                         irq_base_set = true;
1792                 }
1793         }
1794
1795         acpi_gpiochip_request_interrupts(gpiochip);
1796
1797         return 0;
1798 }
1799 EXPORT_SYMBOL_GPL(_gpiochip_irqchip_add);
1800
1801 #else /* CONFIG_GPIOLIB_IRQCHIP */
1802
1803 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
1804 static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
1805 {
1806         return 0;
1807 }
1808 static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
1809 { }
1810
1811 #endif /* CONFIG_GPIOLIB_IRQCHIP */
1812
1813 /**
1814  * gpiochip_generic_request() - request the gpio function for a pin
1815  * @chip: the gpiochip owning the GPIO
1816  * @offset: the offset of the GPIO to request for GPIO function
1817  */
1818 int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
1819 {
1820         return pinctrl_request_gpio(chip->gpiodev->base + offset);
1821 }
1822 EXPORT_SYMBOL_GPL(gpiochip_generic_request);
1823
1824 /**
1825  * gpiochip_generic_free() - free the gpio function from a pin
1826  * @chip: the gpiochip to request the gpio function for
1827  * @offset: the offset of the GPIO to free from GPIO function
1828  */
1829 void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset)
1830 {
1831         pinctrl_free_gpio(chip->gpiodev->base + offset);
1832 }
1833 EXPORT_SYMBOL_GPL(gpiochip_generic_free);
1834
1835 #ifdef CONFIG_PINCTRL
1836
1837 /**
1838  * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
1839  * @chip: the gpiochip to add the range for
1840  * @pctldev: the pin controller to map to
1841  * @gpio_offset: the start offset in the current gpio_chip number space
1842  * @pin_group: name of the pin group inside the pin controller
1843  */
1844 int gpiochip_add_pingroup_range(struct gpio_chip *chip,
1845                         struct pinctrl_dev *pctldev,
1846                         unsigned int gpio_offset, const char *pin_group)
1847 {
1848         struct gpio_pin_range *pin_range;
1849         struct gpio_device *gdev = chip->gpiodev;
1850         int ret;
1851
1852         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1853         if (!pin_range) {
1854                 chip_err(chip, "failed to allocate pin ranges\n");
1855                 return -ENOMEM;
1856         }
1857
1858         /* Use local offset as range ID */
1859         pin_range->range.id = gpio_offset;
1860         pin_range->range.gc = chip;
1861         pin_range->range.name = chip->label;
1862         pin_range->range.base = gdev->base + gpio_offset;
1863         pin_range->pctldev = pctldev;
1864
1865         ret = pinctrl_get_group_pins(pctldev, pin_group,
1866                                         &pin_range->range.pins,
1867                                         &pin_range->range.npins);
1868         if (ret < 0) {
1869                 kfree(pin_range);
1870                 return ret;
1871         }
1872
1873         pinctrl_add_gpio_range(pctldev, &pin_range->range);
1874
1875         chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
1876                  gpio_offset, gpio_offset + pin_range->range.npins - 1,
1877                  pinctrl_dev_get_devname(pctldev), pin_group);
1878
1879         list_add_tail(&pin_range->node, &gdev->pin_ranges);
1880
1881         return 0;
1882 }
1883 EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
1884
1885 /**
1886  * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1887  * @chip: the gpiochip to add the range for
1888  * @pinctrl_name: the dev_name() of the pin controller to map to
1889  * @gpio_offset: the start offset in the current gpio_chip number space
1890  * @pin_offset: the start offset in the pin controller number space
1891  * @npins: the number of pins from the offset of each pin space (GPIO and
1892  *      pin controller) to accumulate in this range
1893  */
1894 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1895                            unsigned int gpio_offset, unsigned int pin_offset,
1896                            unsigned int npins)
1897 {
1898         struct gpio_pin_range *pin_range;
1899         struct gpio_device *gdev = chip->gpiodev;
1900         int ret;
1901
1902         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1903         if (!pin_range) {
1904                 chip_err(chip, "failed to allocate pin ranges\n");
1905                 return -ENOMEM;
1906         }
1907
1908         /* Use local offset as range ID */
1909         pin_range->range.id = gpio_offset;
1910         pin_range->range.gc = chip;
1911         pin_range->range.name = chip->label;
1912         pin_range->range.base = gdev->base + gpio_offset;
1913         pin_range->range.pin_base = pin_offset;
1914         pin_range->range.npins = npins;
1915         pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1916                         &pin_range->range);
1917         if (IS_ERR(pin_range->pctldev)) {
1918                 ret = PTR_ERR(pin_range->pctldev);
1919                 chip_err(chip, "could not create pin range\n");
1920                 kfree(pin_range);
1921                 return ret;
1922         }
1923         chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
1924                  gpio_offset, gpio_offset + npins - 1,
1925                  pinctl_name,
1926                  pin_offset, pin_offset + npins - 1);
1927
1928         list_add_tail(&pin_range->node, &gdev->pin_ranges);
1929
1930         return 0;
1931 }
1932 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1933
1934 /**
1935  * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1936  * @chip: the chip to remove all the mappings for
1937  */
1938 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1939 {
1940         struct gpio_pin_range *pin_range, *tmp;
1941         struct gpio_device *gdev = chip->gpiodev;
1942
1943         list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
1944                 list_del(&pin_range->node);
1945                 pinctrl_remove_gpio_range(pin_range->pctldev,
1946                                 &pin_range->range);
1947                 kfree(pin_range);
1948         }
1949 }
1950 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1951
1952 #endif /* CONFIG_PINCTRL */
1953
1954 /* These "optional" allocation calls help prevent drivers from stomping
1955  * on each other, and help provide better diagnostics in debugfs.
1956  * They're called even less than the "set direction" calls.
1957  */
1958 static int __gpiod_request(struct gpio_desc *desc, const char *label)
1959 {
1960         struct gpio_chip        *chip = desc->gdev->chip;
1961         int                     status;
1962         unsigned long           flags;
1963
1964         spin_lock_irqsave(&gpio_lock, flags);
1965
1966         /* NOTE:  gpio_request() can be called in early boot,
1967          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1968          */
1969
1970         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1971                 desc_set_label(desc, label ? : "?");
1972                 status = 0;
1973         } else {
1974                 status = -EBUSY;
1975                 goto done;
1976         }
1977
1978         if (chip->request) {
1979                 /* chip->request may sleep */
1980                 spin_unlock_irqrestore(&gpio_lock, flags);
1981                 status = chip->request(chip, gpio_chip_hwgpio(desc));
1982                 spin_lock_irqsave(&gpio_lock, flags);
1983
1984                 if (status < 0) {
1985                         desc_set_label(desc, NULL);
1986                         clear_bit(FLAG_REQUESTED, &desc->flags);
1987                         goto done;
1988                 }
1989         }
1990         if (chip->get_direction) {
1991                 /* chip->get_direction may sleep */
1992                 spin_unlock_irqrestore(&gpio_lock, flags);
1993                 gpiod_get_direction(desc);
1994                 spin_lock_irqsave(&gpio_lock, flags);
1995         }
1996 done:
1997         spin_unlock_irqrestore(&gpio_lock, flags);
1998         return status;
1999 }
2000
2001 /*
2002  * This descriptor validation needs to be inserted verbatim into each
2003  * function taking a descriptor, so we need to use a preprocessor
2004  * macro to avoid endless duplication. If the desc is NULL it is an
2005  * optional GPIO and calls should just bail out.
2006  */
2007 #define VALIDATE_DESC(desc) do { \
2008         if (!desc) \
2009                 return 0; \
2010         if (IS_ERR(desc)) {                                             \
2011                 pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
2012                 return PTR_ERR(desc); \
2013         } \
2014         if (!desc->gdev) { \
2015                 pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2016                 return -EINVAL; \
2017         } \
2018         if ( !desc->gdev->chip ) { \
2019                 dev_warn(&desc->gdev->dev, \
2020                          "%s: backing chip is gone\n", __func__); \
2021                 return 0; \
2022         } } while (0)
2023
2024 #define VALIDATE_DESC_VOID(desc) do { \
2025         if (!desc) \
2026                 return; \
2027         if (IS_ERR(desc)) {                                             \
2028                 pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
2029                 return; \
2030         } \
2031         if (!desc->gdev) { \
2032                 pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2033                 return; \
2034         } \
2035         if (!desc->gdev->chip) { \
2036                 dev_warn(&desc->gdev->dev, \
2037                          "%s: backing chip is gone\n", __func__); \
2038                 return; \
2039         } } while (0)
2040
2041
2042 int gpiod_request(struct gpio_desc *desc, const char *label)
2043 {
2044         int status = -EPROBE_DEFER;
2045         struct gpio_device *gdev;
2046
2047         VALIDATE_DESC(desc);
2048         gdev = desc->gdev;
2049
2050         if (try_module_get(gdev->owner)) {
2051                 status = __gpiod_request(desc, label);
2052                 if (status < 0)
2053                         module_put(gdev->owner);
2054                 else
2055                         get_device(&gdev->dev);
2056         }
2057
2058         if (status)
2059                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2060
2061         return status;
2062 }
2063
2064 static bool __gpiod_free(struct gpio_desc *desc)
2065 {
2066         bool                    ret = false;
2067         unsigned long           flags;
2068         struct gpio_chip        *chip;
2069
2070         might_sleep();
2071
2072         gpiod_unexport(desc);
2073
2074         spin_lock_irqsave(&gpio_lock, flags);
2075
2076         chip = desc->gdev->chip;
2077         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
2078                 if (chip->free) {
2079                         spin_unlock_irqrestore(&gpio_lock, flags);
2080                         might_sleep_if(chip->can_sleep);
2081                         chip->free(chip, gpio_chip_hwgpio(desc));
2082                         spin_lock_irqsave(&gpio_lock, flags);
2083                 }
2084                 desc_set_label(desc, NULL);
2085                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
2086                 clear_bit(FLAG_REQUESTED, &desc->flags);
2087                 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2088                 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
2089                 clear_bit(FLAG_IS_HOGGED, &desc->flags);
2090                 ret = true;
2091         }
2092
2093         spin_unlock_irqrestore(&gpio_lock, flags);
2094         return ret;
2095 }
2096
2097 void gpiod_free(struct gpio_desc *desc)
2098 {
2099         if (desc && desc->gdev && __gpiod_free(desc)) {
2100                 module_put(desc->gdev->owner);
2101                 put_device(&desc->gdev->dev);
2102         } else {
2103                 WARN_ON(extra_checks);
2104         }
2105 }
2106
2107 /**
2108  * gpiochip_is_requested - return string iff signal was requested
2109  * @chip: controller managing the signal
2110  * @offset: of signal within controller's 0..(ngpio - 1) range
2111  *
2112  * Returns NULL if the GPIO is not currently requested, else a string.
2113  * The string returned is the label passed to gpio_request(); if none has been
2114  * passed it is a meaningless, non-NULL constant.
2115  *
2116  * This function is for use by GPIO controller drivers.  The label can
2117  * help with diagnostics, and knowing that the signal is used as a GPIO
2118  * can help avoid accidentally multiplexing it to another controller.
2119  */
2120 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
2121 {
2122         struct gpio_desc *desc;
2123
2124         if (offset >= chip->ngpio)
2125                 return NULL;
2126
2127         desc = &chip->gpiodev->descs[offset];
2128
2129         if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2130                 return NULL;
2131         return desc->label;
2132 }
2133 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
2134
2135 /**
2136  * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
2137  * @desc: GPIO descriptor to request
2138  * @label: label for the GPIO
2139  *
2140  * Function allows GPIO chip drivers to request and use their own GPIO
2141  * descriptors via gpiolib API. Difference to gpiod_request() is that this
2142  * function will not increase reference count of the GPIO chip module. This
2143  * allows the GPIO chip module to be unloaded as needed (we assume that the
2144  * GPIO chip driver handles freeing the GPIOs it has requested).
2145  */
2146 struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
2147                                             const char *label)
2148 {
2149         struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
2150         int err;
2151
2152         if (IS_ERR(desc)) {
2153                 chip_err(chip, "failed to get GPIO descriptor\n");
2154                 return desc;
2155         }
2156
2157         err = __gpiod_request(desc, label);
2158         if (err < 0)
2159                 return ERR_PTR(err);
2160
2161         return desc;
2162 }
2163 EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2164
2165 /**
2166  * gpiochip_free_own_desc - Free GPIO requested by the chip driver
2167  * @desc: GPIO descriptor to free
2168  *
2169  * Function frees the given GPIO requested previously with
2170  * gpiochip_request_own_desc().
2171  */
2172 void gpiochip_free_own_desc(struct gpio_desc *desc)
2173 {
2174         if (desc)
2175                 __gpiod_free(desc);
2176 }
2177 EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2178
2179 /*
2180  * Drivers MUST set GPIO direction before making get/set calls.  In
2181  * some cases this is done in early boot, before IRQs are enabled.
2182  *
2183  * As a rule these aren't called more than once (except for drivers
2184  * using the open-drain emulation idiom) so these are natural places
2185  * to accumulate extra debugging checks.  Note that we can't (yet)
2186  * rely on gpio_request() having been called beforehand.
2187  */
2188
2189 /**
2190  * gpiod_direction_input - set the GPIO direction to input
2191  * @desc:       GPIO to set to input
2192  *
2193  * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
2194  * be called safely on it.
2195  *
2196  * Return 0 in case of success, else an error code.
2197  */
2198 int gpiod_direction_input(struct gpio_desc *desc)
2199 {
2200         struct gpio_chip        *chip;
2201         int                     status = -EINVAL;
2202
2203         VALIDATE_DESC(desc);
2204         chip = desc->gdev->chip;
2205
2206         if (!chip->get || !chip->direction_input) {
2207                 gpiod_warn(desc,
2208                         "%s: missing get() or direction_input() operations\n",
2209                         __func__);
2210                 return -EIO;
2211         }
2212
2213         status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2214         if (status == 0)
2215                 clear_bit(FLAG_IS_OUT, &desc->flags);
2216
2217         trace_gpio_direction(desc_to_gpio(desc), 1, status);
2218
2219         return status;
2220 }
2221 EXPORT_SYMBOL_GPL(gpiod_direction_input);
2222
2223 static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2224 {
2225         struct gpio_chip *gc = desc->gdev->chip;
2226         int ret;
2227
2228         /* GPIOs used for IRQs shall not be set as output */
2229         if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
2230                 gpiod_err(desc,
2231                           "%s: tried to set a GPIO tied to an IRQ as output\n",
2232                           __func__);
2233                 return -EIO;
2234         }
2235
2236         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
2237                 /* First see if we can enable open drain in hardware */
2238                 if (gc->set_single_ended) {
2239                         ret = gc->set_single_ended(gc, gpio_chip_hwgpio(desc),
2240                                                    LINE_MODE_OPEN_DRAIN);
2241                         if (!ret)
2242                                 goto set_output_value;
2243                 }
2244                 /* Emulate open drain by not actively driving the line high */
2245                 if (value)
2246                         return gpiod_direction_input(desc);
2247         }
2248         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
2249                 if (gc->set_single_ended) {
2250                         ret = gc->set_single_ended(gc, gpio_chip_hwgpio(desc),
2251                                                    LINE_MODE_OPEN_SOURCE);
2252                         if (!ret)
2253                                 goto set_output_value;
2254                 }
2255                 /* Emulate open source by not actively driving the line low */
2256                 if (!value)
2257                         return gpiod_direction_input(desc);
2258         } else {
2259                 /* Make sure to disable open drain/source hardware, if any */
2260                 if (gc->set_single_ended)
2261                         gc->set_single_ended(gc,
2262                                              gpio_chip_hwgpio(desc),
2263                                              LINE_MODE_PUSH_PULL);
2264         }
2265
2266 set_output_value:
2267         if (!gc->set || !gc->direction_output) {
2268                 gpiod_warn(desc,
2269                        "%s: missing set() or direction_output() operations\n",
2270                        __func__);
2271                 return -EIO;
2272         }
2273
2274         ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), value);
2275         if (!ret)
2276                 set_bit(FLAG_IS_OUT, &desc->flags);
2277         trace_gpio_value(desc_to_gpio(desc), 0, value);
2278         trace_gpio_direction(desc_to_gpio(desc), 0, ret);
2279         return ret;
2280 }
2281
2282 /**
2283  * gpiod_direction_output_raw - set the GPIO direction to output
2284  * @desc:       GPIO to set to output
2285  * @value:      initial output value of the GPIO
2286  *
2287  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2288  * be called safely on it. The initial value of the output must be specified
2289  * as raw value on the physical line without regard for the ACTIVE_LOW status.
2290  *
2291  * Return 0 in case of success, else an error code.
2292  */
2293 int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2294 {
2295         VALIDATE_DESC(desc);
2296         return _gpiod_direction_output_raw(desc, value);
2297 }
2298 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
2299
2300 /**
2301  * gpiod_direction_output - set the GPIO direction to output
2302  * @desc:       GPIO to set to output
2303  * @value:      initial output value of the GPIO
2304  *
2305  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2306  * be called safely on it. The initial value of the output must be specified
2307  * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2308  * account.
2309  *
2310  * Return 0 in case of success, else an error code.
2311  */
2312 int gpiod_direction_output(struct gpio_desc *desc, int value)
2313 {
2314         VALIDATE_DESC(desc);
2315         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2316                 value = !value;
2317         return _gpiod_direction_output_raw(desc, value);
2318 }
2319 EXPORT_SYMBOL_GPL(gpiod_direction_output);
2320
2321 /**
2322  * gpiod_set_debounce - sets @debounce time for a @gpio
2323  * @gpio: the gpio to set debounce time
2324  * @debounce: debounce time is microseconds
2325  *
2326  * returns -ENOTSUPP if the controller does not support setting
2327  * debounce.
2328  */
2329 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2330 {
2331         struct gpio_chip        *chip;
2332
2333         VALIDATE_DESC(desc);
2334         chip = desc->gdev->chip;
2335         if (!chip->set || !chip->set_debounce) {
2336                 gpiod_dbg(desc,
2337                           "%s: missing set() or set_debounce() operations\n",
2338                           __func__);
2339                 return -ENOTSUPP;
2340         }
2341
2342         return chip->set_debounce(chip, gpio_chip_hwgpio(desc), debounce);
2343 }
2344 EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2345
2346 /**
2347  * gpiod_is_active_low - test whether a GPIO is active-low or not
2348  * @desc: the gpio descriptor to test
2349  *
2350  * Returns 1 if the GPIO is active-low, 0 otherwise.
2351  */
2352 int gpiod_is_active_low(const struct gpio_desc *desc)
2353 {
2354         VALIDATE_DESC(desc);
2355         return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2356 }
2357 EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2358
2359 /* I/O calls are only valid after configuration completed; the relevant
2360  * "is this a valid GPIO" error checks should already have been done.
2361  *
2362  * "Get" operations are often inlinable as reading a pin value register,
2363  * and masking the relevant bit in that register.
2364  *
2365  * When "set" operations are inlinable, they involve writing that mask to
2366  * one register to set a low value, or a different register to set it high.
2367  * Otherwise locking is needed, so there may be little value to inlining.
2368  *
2369  *------------------------------------------------------------------------
2370  *
2371  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
2372  * have requested the GPIO.  That can include implicit requesting by
2373  * a direction setting call.  Marking a gpio as requested locks its chip
2374  * in memory, guaranteeing that these table lookups need no more locking
2375  * and that gpiochip_remove() will fail.
2376  *
2377  * REVISIT when debugging, consider adding some instrumentation to ensure
2378  * that the GPIO was actually requested.
2379  */
2380
2381 static int _gpiod_get_raw_value(const struct gpio_desc *desc)
2382 {
2383         struct gpio_chip        *chip;
2384         int offset;
2385         int value;
2386
2387         chip = desc->gdev->chip;
2388         offset = gpio_chip_hwgpio(desc);
2389         value = chip->get ? chip->get(chip, offset) : -EIO;
2390         value = value < 0 ? value : !!value;
2391         trace_gpio_value(desc_to_gpio(desc), 1, value);
2392         return value;
2393 }
2394
2395 /**
2396  * gpiod_get_raw_value() - return a gpio's raw value
2397  * @desc: gpio whose value will be returned
2398  *
2399  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2400  * its ACTIVE_LOW status, or negative errno on failure.
2401  *
2402  * This function should be called from contexts where we cannot sleep, and will
2403  * complain if the GPIO chip functions potentially sleep.
2404  */
2405 int gpiod_get_raw_value(const struct gpio_desc *desc)
2406 {
2407         VALIDATE_DESC(desc);
2408         /* Should be using gpio_get_value_cansleep() */
2409         WARN_ON(desc->gdev->chip->can_sleep);
2410         return _gpiod_get_raw_value(desc);
2411 }
2412 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2413
2414 /**
2415  * gpiod_get_value() - return a gpio's value
2416  * @desc: gpio whose value will be returned
2417  *
2418  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2419  * account, or negative errno on failure.
2420  *
2421  * This function should be called from contexts where we cannot sleep, and will
2422  * complain if the GPIO chip functions potentially sleep.
2423  */
2424 int gpiod_get_value(const struct gpio_desc *desc)
2425 {
2426         int value;
2427
2428         VALIDATE_DESC(desc);
2429         /* Should be using gpio_get_value_cansleep() */
2430         WARN_ON(desc->gdev->chip->can_sleep);
2431
2432         value = _gpiod_get_raw_value(desc);
2433         if (value < 0)
2434                 return value;
2435
2436         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2437                 value = !value;
2438
2439         return value;
2440 }
2441 EXPORT_SYMBOL_GPL(gpiod_get_value);
2442
2443 /*
2444  *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
2445  * @desc: gpio descriptor whose state need to be set.
2446  * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2447  */
2448 static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
2449 {
2450         int err = 0;
2451         struct gpio_chip *chip = desc->gdev->chip;
2452         int offset = gpio_chip_hwgpio(desc);
2453
2454         if (value) {
2455                 err = chip->direction_input(chip, offset);
2456                 if (!err)
2457                         clear_bit(FLAG_IS_OUT, &desc->flags);
2458         } else {
2459                 err = chip->direction_output(chip, offset, 0);
2460                 if (!err)
2461                         set_bit(FLAG_IS_OUT, &desc->flags);
2462         }
2463         trace_gpio_direction(desc_to_gpio(desc), value, err);
2464         if (err < 0)
2465                 gpiod_err(desc,
2466                           "%s: Error in set_value for open drain err %d\n",
2467                           __func__, err);
2468 }
2469
2470 /*
2471  *  _gpio_set_open_source_value() - Set the open source gpio's value.
2472  * @desc: gpio descriptor whose state need to be set.
2473  * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2474  */
2475 static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
2476 {
2477         int err = 0;
2478         struct gpio_chip *chip = desc->gdev->chip;
2479         int offset = gpio_chip_hwgpio(desc);
2480
2481         if (value) {
2482                 err = chip->direction_output(chip, offset, 1);
2483                 if (!err)
2484                         set_bit(FLAG_IS_OUT, &desc->flags);
2485         } else {
2486                 err = chip->direction_input(chip, offset);
2487                 if (!err)
2488                         clear_bit(FLAG_IS_OUT, &desc->flags);
2489         }
2490         trace_gpio_direction(desc_to_gpio(desc), !value, err);
2491         if (err < 0)
2492                 gpiod_err(desc,
2493                           "%s: Error in set_value for open source err %d\n",
2494                           __func__, err);
2495 }
2496
2497 static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
2498 {
2499         struct gpio_chip        *chip;
2500
2501         chip = desc->gdev->chip;
2502         trace_gpio_value(desc_to_gpio(desc), 0, value);
2503         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2504                 _gpio_set_open_drain_value(desc, value);
2505         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2506                 _gpio_set_open_source_value(desc, value);
2507         else
2508                 chip->set(chip, gpio_chip_hwgpio(desc), value);
2509 }
2510
2511 /*
2512  * set multiple outputs on the same chip;
2513  * use the chip's set_multiple function if available;
2514  * otherwise set the outputs sequentially;
2515  * @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word
2516  *        defines which outputs are to be changed
2517  * @bits: bit value array; one bit per output; BITS_PER_LONG bits per word
2518  *        defines the values the outputs specified by mask are to be set to
2519  */
2520 static void gpio_chip_set_multiple(struct gpio_chip *chip,
2521                                    unsigned long *mask, unsigned long *bits)
2522 {
2523         if (chip->set_multiple) {
2524                 chip->set_multiple(chip, mask, bits);
2525         } else {
2526                 int i;
2527                 for (i = 0; i < chip->ngpio; i++) {
2528                         if (mask[BIT_WORD(i)] == 0) {
2529                                 /* no more set bits in this mask word;
2530                                  * skip ahead to the next word */
2531                                 i = (BIT_WORD(i) + 1) * BITS_PER_LONG - 1;
2532                                 continue;
2533                         }
2534                         /* set outputs if the corresponding mask bit is set */
2535                         if (__test_and_clear_bit(i, mask))
2536                                 chip->set(chip, i, test_bit(i, bits));
2537                 }
2538         }
2539 }
2540
2541 void gpiod_set_array_value_complex(bool raw, bool can_sleep,
2542                                    unsigned int array_size,
2543                                    struct gpio_desc **desc_array,
2544                                    int *value_array)
2545 {
2546         int i = 0;
2547
2548         while (i < array_size) {
2549                 struct gpio_chip *chip = desc_array[i]->gdev->chip;
2550                 unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
2551                 unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
2552                 int count = 0;
2553
2554                 if (!can_sleep)
2555                         WARN_ON(chip->can_sleep);
2556
2557                 memset(mask, 0, sizeof(mask));
2558                 do {
2559                         struct gpio_desc *desc = desc_array[i];
2560                         int hwgpio = gpio_chip_hwgpio(desc);
2561                         int value = value_array[i];
2562
2563                         if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2564                                 value = !value;
2565                         trace_gpio_value(desc_to_gpio(desc), 0, value);
2566                         /*
2567                          * collect all normal outputs belonging to the same chip
2568                          * open drain and open source outputs are set individually
2569                          */
2570                         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
2571                                 _gpio_set_open_drain_value(desc, value);
2572                         } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
2573                                 _gpio_set_open_source_value(desc, value);
2574                         } else {
2575                                 __set_bit(hwgpio, mask);
2576                                 if (value)
2577                                         __set_bit(hwgpio, bits);
2578                                 else
2579                                         __clear_bit(hwgpio, bits);
2580                                 count++;
2581                         }
2582                         i++;
2583                 } while ((i < array_size) &&
2584                          (desc_array[i]->gdev->chip == chip));
2585                 /* push collected bits to outputs */
2586                 if (count != 0)
2587                         gpio_chip_set_multiple(chip, mask, bits);
2588         }
2589 }
2590
2591 /**
2592  * gpiod_set_raw_value() - assign a gpio's raw value
2593  * @desc: gpio whose value will be assigned
2594  * @value: value to assign
2595  *
2596  * Set the raw value of the GPIO, i.e. the value of its physical line without
2597  * regard for its ACTIVE_LOW status.
2598  *
2599  * This function should be called from contexts where we cannot sleep, and will
2600  * complain if the GPIO chip functions potentially sleep.
2601  */
2602 void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2603 {
2604         VALIDATE_DESC_VOID(desc);
2605         /* Should be using gpiod_set_value_cansleep() */
2606         WARN_ON(desc->gdev->chip->can_sleep);
2607         _gpiod_set_raw_value(desc, value);
2608 }
2609 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2610
2611 /**
2612  * gpiod_set_value() - assign a gpio's value
2613  * @desc: gpio whose value will be assigned
2614  * @value: value to assign
2615  *
2616  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2617  * account
2618  *
2619  * This function should be called from contexts where we cannot sleep, and will
2620  * complain if the GPIO chip functions potentially sleep.
2621  */
2622 void gpiod_set_value(struct gpio_desc *desc, int value)
2623 {
2624         VALIDATE_DESC_VOID(desc);
2625         /* Should be using gpiod_set_value_cansleep() */
2626         WARN_ON(desc->gdev->chip->can_sleep);
2627         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2628                 value = !value;
2629         _gpiod_set_raw_value(desc, value);
2630 }
2631 EXPORT_SYMBOL_GPL(gpiod_set_value);
2632
2633 /**
2634  * gpiod_set_raw_array_value() - assign values to an array of GPIOs
2635  * @array_size: number of elements in the descriptor / value arrays
2636  * @desc_array: array of GPIO descriptors whose values will be assigned
2637  * @value_array: array of values to assign
2638  *
2639  * Set the raw values of the GPIOs, i.e. the values of the physical lines
2640  * without regard for their ACTIVE_LOW status.
2641  *
2642  * This function should be called from contexts where we cannot sleep, and will
2643  * complain if the GPIO chip functions potentially sleep.
2644  */
2645 void gpiod_set_raw_array_value(unsigned int array_size,
2646                          struct gpio_desc **desc_array, int *value_array)
2647 {
2648         if (!desc_array)
2649                 return;
2650         gpiod_set_array_value_complex(true, false, array_size, desc_array,
2651                                       value_array);
2652 }
2653 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
2654
2655 /**
2656  * gpiod_set_array_value() - assign values to an array of GPIOs
2657  * @array_size: number of elements in the descriptor / value arrays
2658  * @desc_array: array of GPIO descriptors whose values will be assigned
2659  * @value_array: array of values to assign
2660  *
2661  * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
2662  * into account.
2663  *
2664  * This function should be called from contexts where we cannot sleep, and will
2665  * complain if the GPIO chip functions potentially sleep.
2666  */
2667 void gpiod_set_array_value(unsigned int array_size,
2668                            struct gpio_desc **desc_array, int *value_array)
2669 {
2670         if (!desc_array)
2671                 return;
2672         gpiod_set_array_value_complex(false, false, array_size, desc_array,
2673                                       value_array);
2674 }
2675 EXPORT_SYMBOL_GPL(gpiod_set_array_value);
2676
2677 /**
2678  * gpiod_cansleep() - report whether gpio value access may sleep
2679  * @desc: gpio to check
2680  *
2681  */
2682 int gpiod_cansleep(const struct gpio_desc *desc)
2683 {
2684         VALIDATE_DESC(desc);
2685         return desc->gdev->chip->can_sleep;
2686 }
2687 EXPORT_SYMBOL_GPL(gpiod_cansleep);
2688
2689 /**
2690  * gpiod_to_irq() - return the IRQ corresponding to a GPIO
2691  * @desc: gpio whose IRQ will be returned (already requested)
2692  *
2693  * Return the IRQ corresponding to the passed GPIO, or an error code in case of
2694  * error.
2695  */
2696 int gpiod_to_irq(const struct gpio_desc *desc)
2697 {
2698         struct gpio_chip *chip;
2699         int offset;
2700
2701         /*
2702          * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics
2703          * requires this function to not return zero on an invalid descriptor
2704          * but rather a negative error number.
2705          */
2706         if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
2707                 return -EINVAL;
2708
2709         chip = desc->gdev->chip;
2710         offset = gpio_chip_hwgpio(desc);
2711         if (chip->to_irq) {
2712                 int retirq = chip->to_irq(chip, offset);
2713
2714                 /* Zero means NO_IRQ */
2715                 if (!retirq)
2716                         return -ENXIO;
2717
2718                 return retirq;
2719         }
2720         return -ENXIO;
2721 }
2722 EXPORT_SYMBOL_GPL(gpiod_to_irq);
2723
2724 /**
2725  * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
2726  * @chip: the chip the GPIO to lock belongs to
2727  * @offset: the offset of the GPIO to lock as IRQ
2728  *
2729  * This is used directly by GPIO drivers that want to lock down
2730  * a certain GPIO line to be used for IRQs.
2731  */
2732 int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2733 {
2734         struct gpio_desc *desc;
2735
2736         desc = gpiochip_get_desc(chip, offset);
2737         if (IS_ERR(desc))
2738                 return PTR_ERR(desc);
2739
2740         /*
2741          * If it's fast: flush the direction setting if something changed
2742          * behind our back
2743          */
2744         if (!chip->can_sleep && chip->get_direction) {
2745                 int dir = chip->get_direction(chip, offset);
2746
2747                 if (dir)
2748                         clear_bit(FLAG_IS_OUT, &desc->flags);
2749                 else
2750                         set_bit(FLAG_IS_OUT, &desc->flags);
2751         }
2752
2753         if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2754                 chip_err(chip,
2755                           "%s: tried to flag a GPIO set as output for IRQ\n",
2756                           __func__);
2757                 return -EIO;
2758         }
2759
2760         set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2761         return 0;
2762 }
2763 EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
2764
2765 /**
2766  * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
2767  * @chip: the chip the GPIO to lock belongs to
2768  * @offset: the offset of the GPIO to lock as IRQ
2769  *
2770  * This is used directly by GPIO drivers that want to indicate
2771  * that a certain GPIO is no longer used exclusively for IRQ.
2772  */
2773 void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2774 {
2775         if (offset >= chip->ngpio)
2776                 return;
2777
2778         clear_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
2779 }
2780 EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
2781
2782 bool gpiochip_line_is_irq(struct gpio_chip *chip, unsigned int offset)
2783 {
2784         if (offset >= chip->ngpio)
2785                 return false;
2786
2787         return test_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
2788 }
2789 EXPORT_SYMBOL_GPL(gpiochip_line_is_irq);
2790
2791 bool gpiochip_line_is_open_drain(struct gpio_chip *chip, unsigned int offset)
2792 {
2793         if (offset >= chip->ngpio)
2794                 return false;
2795
2796         return test_bit(FLAG_OPEN_DRAIN, &chip->gpiodev->descs[offset].flags);
2797 }
2798 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain);
2799
2800 bool gpiochip_line_is_open_source(struct gpio_chip *chip, unsigned int offset)
2801 {
2802         if (offset >= chip->ngpio)
2803                 return false;
2804
2805         return test_bit(FLAG_OPEN_SOURCE, &chip->gpiodev->descs[offset].flags);
2806 }
2807 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source);
2808
2809 /**
2810  * gpiod_get_raw_value_cansleep() - return a gpio's raw value
2811  * @desc: gpio whose value will be returned
2812  *
2813  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2814  * its ACTIVE_LOW status, or negative errno on failure.
2815  *
2816  * This function is to be called from contexts that can sleep.
2817  */
2818 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2819 {
2820         might_sleep_if(extra_checks);
2821         VALIDATE_DESC(desc);
2822         return _gpiod_get_raw_value(desc);
2823 }
2824 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2825
2826 /**
2827  * gpiod_get_value_cansleep() - return a gpio's value
2828  * @desc: gpio whose value will be returned
2829  *
2830  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2831  * account, or negative errno on failure.
2832  *
2833  * This function is to be called from contexts that can sleep.
2834  */
2835 int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2836 {
2837         int value;
2838
2839         might_sleep_if(extra_checks);
2840         VALIDATE_DESC(desc);
2841         value = _gpiod_get_raw_value(desc);
2842         if (value < 0)
2843                 return value;
2844
2845         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2846                 value = !value;
2847
2848         return value;
2849 }
2850 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2851
2852 /**
2853  * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
2854  * @desc: gpio whose value will be assigned
2855  * @value: value to assign
2856  *
2857  * Set the raw value of the GPIO, i.e. the value of its physical line without
2858  * regard for its ACTIVE_LOW status.
2859  *
2860  * This function is to be called from contexts that can sleep.
2861  */
2862 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
2863 {
2864         might_sleep_if(extra_checks);
2865         VALIDATE_DESC_VOID(desc);
2866         _gpiod_set_raw_value(desc, value);
2867 }
2868 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2869
2870 /**
2871  * gpiod_set_value_cansleep() - assign a gpio's value
2872  * @desc: gpio whose value will be assigned
2873  * @value: value to assign
2874  *
2875  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2876  * account
2877  *
2878  * This function is to be called from contexts that can sleep.
2879  */
2880 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2881 {
2882         might_sleep_if(extra_checks);
2883         VALIDATE_DESC_VOID(desc);
2884         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2885                 value = !value;
2886         _gpiod_set_raw_value(desc, value);
2887 }
2888 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2889
2890 /**
2891  * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
2892  * @array_size: number of elements in the descriptor / value arrays
2893  * @desc_array: array of GPIO descriptors whose values will be assigned
2894  * @value_array: array of values to assign
2895  *
2896  * Set the raw values of the GPIOs, i.e. the values of the physical lines
2897  * without regard for their ACTIVE_LOW status.
2898  *
2899  * This function is to be called from contexts that can sleep.
2900  */
2901 void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
2902                                         struct gpio_desc **desc_array,
2903                                         int *value_array)
2904 {
2905         might_sleep_if(extra_checks);
2906         if (!desc_array)
2907                 return;
2908         gpiod_set_array_value_complex(true, true, array_size, desc_array,
2909                                       value_array);
2910 }
2911 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
2912
2913 /**
2914  * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
2915  * @array_size: number of elements in the descriptor / value arrays
2916  * @desc_array: array of GPIO descriptors whose values will be assigned
2917  * @value_array: array of values to assign
2918  *
2919  * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
2920  * into account.
2921  *
2922  * This function is to be called from contexts that can sleep.
2923  */
2924 void gpiod_set_array_value_cansleep(unsigned int array_size,
2925                                     struct gpio_desc **desc_array,
2926                                     int *value_array)
2927 {
2928         might_sleep_if(extra_checks);
2929         if (!desc_array)
2930                 return;
2931         gpiod_set_array_value_complex(false, true, array_size, desc_array,
2932                                       value_array);
2933 }
2934 EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
2935
2936 /**
2937  * gpiod_add_lookup_table() - register GPIO device consumers
2938  * @table: table of consumers to register
2939  */
2940 void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
2941 {
2942         mutex_lock(&gpio_lookup_lock);
2943
2944         list_add_tail(&table->list, &gpio_lookup_list);
2945
2946         mutex_unlock(&gpio_lookup_lock);
2947 }
2948
2949 /**
2950  * gpiod_remove_lookup_table() - unregister GPIO device consumers
2951  * @table: table of consumers to unregister
2952  */
2953 void gpiod_remove_lookup_table(struct gpiod_lookup_table *table)
2954 {
2955         mutex_lock(&gpio_lookup_lock);
2956
2957         list_del(&table->list);
2958
2959         mutex_unlock(&gpio_lookup_lock);
2960 }
2961
2962 static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2963 {
2964         const char *dev_id = dev ? dev_name(dev) : NULL;
2965         struct gpiod_lookup_table *table;
2966
2967         mutex_lock(&gpio_lookup_lock);
2968
2969         list_for_each_entry(table, &gpio_lookup_list, list) {
2970                 if (table->dev_id && dev_id) {
2971                         /*
2972                          * Valid strings on both ends, must be identical to have
2973                          * a match
2974                          */
2975                         if (!strcmp(table->dev_id, dev_id))
2976                                 goto found;
2977                 } else {
2978                         /*
2979                          * One of the pointers is NULL, so both must be to have
2980                          * a match
2981                          */
2982                         if (dev_id == table->dev_id)
2983                                 goto found;
2984                 }
2985         }
2986         table = NULL;
2987
2988 found:
2989         mutex_unlock(&gpio_lookup_lock);
2990         return table;
2991 }
2992
2993 static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
2994                                     unsigned int idx,
2995                                     enum gpio_lookup_flags *flags)
2996 {
2997         struct gpio_desc *desc = ERR_PTR(-ENOENT);
2998         struct gpiod_lookup_table *table;
2999         struct gpiod_lookup *p;
3000
3001         table = gpiod_find_lookup_table(dev);
3002         if (!table)
3003                 return desc;
3004
3005         for (p = &table->table[0]; p->chip_label; p++) {
3006                 struct gpio_chip *chip;
3007
3008                 /* idx must always match exactly */
3009                 if (p->idx != idx)
3010                         continue;
3011
3012                 /* If the lookup entry has a con_id, require exact match */
3013                 if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
3014                         continue;
3015
3016                 chip = find_chip_by_name(p->chip_label);
3017
3018                 if (!chip) {
3019                         dev_err(dev, "cannot find GPIO chip %s\n",
3020                                 p->chip_label);
3021                         return ERR_PTR(-ENODEV);
3022                 }
3023
3024                 if (chip->ngpio <= p->chip_hwnum) {
3025                         dev_err(dev,
3026                                 "requested GPIO %d is out of range [0..%d] for chip %s\n",
3027                                 idx, chip->ngpio, chip->label);
3028                         return ERR_PTR(-EINVAL);
3029                 }
3030
3031                 desc = gpiochip_get_desc(chip, p->chip_hwnum);
3032                 *flags = p->flags;
3033
3034                 return desc;
3035         }
3036
3037         return desc;
3038 }
3039
3040 static int dt_gpio_count(struct device *dev, const char *con_id)
3041 {
3042         int ret;
3043         char propname[32];
3044         unsigned int i;
3045
3046         for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
3047                 if (con_id)
3048                         snprintf(propname, sizeof(propname), "%s-%s",
3049                                  con_id, gpio_suffixes[i]);
3050                 else
3051                         snprintf(propname, sizeof(propname), "%s",
3052                                  gpio_suffixes[i]);
3053
3054                 ret = of_gpio_named_count(dev->of_node, propname);
3055                 if (ret >= 0)
3056                         break;
3057         }
3058         return ret;
3059 }
3060
3061 static int platform_gpio_count(struct device *dev, const char *con_id)
3062 {
3063         struct gpiod_lookup_table *table;
3064         struct gpiod_lookup *p;
3065         unsigned int count = 0;
3066
3067         table = gpiod_find_lookup_table(dev);
3068         if (!table)
3069                 return -ENOENT;
3070
3071         for (p = &table->table[0]; p->chip_label; p++) {
3072                 if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) ||
3073                     (!con_id && !p->con_id))
3074                         count++;
3075         }
3076         if (!count)
3077                 return -ENOENT;
3078
3079         return count;
3080 }
3081
3082 /**
3083  * gpiod_count - return the number of GPIOs associated with a device / function
3084  *              or -ENOENT if no GPIO has been assigned to the requested function
3085  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
3086  * @con_id:     function within the GPIO consumer
3087  */
3088 int gpiod_count(struct device *dev, const char *con_id)
3089 {
3090         int count = -ENOENT;
3091
3092         if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
3093                 count = dt_gpio_count(dev, con_id);
3094         else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev))
3095                 count = acpi_gpio_count(dev, con_id);
3096
3097         if (count < 0)
3098                 count = platform_gpio_count(dev, con_id);
3099
3100         return count;
3101 }
3102 EXPORT_SYMBOL_GPL(gpiod_count);
3103
3104 /**
3105  * gpiod_get - obtain a GPIO for a given GPIO function
3106  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
3107  * @con_id:     function within the GPIO consumer
3108  * @flags:      optional GPIO initialization flags
3109  *
3110  * Return the GPIO descriptor corresponding to the function con_id of device
3111  * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3112  * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3113  */
3114 struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3115                                          enum gpiod_flags flags)
3116 {
3117         return gpiod_get_index(dev, con_id, 0, flags);
3118 }
3119 EXPORT_SYMBOL_GPL(gpiod_get);
3120
3121 /**
3122  * gpiod_get_optional - obtain an optional GPIO for a given GPIO function
3123  * @dev: GPIO consumer, can be NULL for system-global GPIOs
3124  * @con_id: function within the GPIO consumer
3125  * @flags: optional GPIO initialization flags
3126  *
3127  * This is equivalent to gpiod_get(), except that when no GPIO was assigned to
3128  * the requested function it will return NULL. This is convenient for drivers
3129  * that need to handle optional GPIOs.
3130  */
3131 struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
3132                                                   const char *con_id,
3133                                                   enum gpiod_flags flags)
3134 {
3135         return gpiod_get_index_optional(dev, con_id, 0, flags);
3136 }
3137 EXPORT_SYMBOL_GPL(gpiod_get_optional);
3138
3139
3140 /**
3141  * gpiod_configure_flags - helper function to configure a given GPIO
3142  * @desc:       gpio whose value will be assigned
3143  * @con_id:     function within the GPIO consumer
3144  * @lflags:     gpio_lookup_flags - returned from of_find_gpio() or
3145  *              of_get_gpio_hog()
3146  * @dflags:     gpiod_flags - optional GPIO initialization flags
3147  *
3148  * Return 0 on success, -ENOENT if no GPIO has been assigned to the
3149  * requested function and/or index, or another IS_ERR() code if an error
3150  * occurred while trying to acquire the GPIO.
3151  */
3152 static int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
3153                 unsigned long lflags, enum gpiod_flags dflags)
3154 {
3155         int status;
3156
3157         if (lflags & GPIO_ACTIVE_LOW)
3158                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
3159         if (lflags & GPIO_OPEN_DRAIN)
3160                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
3161         if (lflags & GPIO_OPEN_SOURCE)
3162                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
3163
3164         /* No particular flag request, return here... */
3165         if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
3166                 pr_debug("no flags found for %s\n", con_id);
3167                 return 0;
3168         }
3169
3170         /* Process flags */
3171         if (dflags & GPIOD_FLAGS_BIT_DIR_OUT)
3172                 status = gpiod_direction_output(desc,
3173                                               dflags & GPIOD_FLAGS_BIT_DIR_VAL);
3174         else
3175                 status = gpiod_direction_input(desc);
3176
3177         return status;
3178 }
3179
3180 /**
3181  * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
3182  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
3183  * @con_id:     function within the GPIO consumer
3184  * @idx:        index of the GPIO to obtain in the consumer
3185  * @flags:      optional GPIO initialization flags
3186  *
3187  * This variant of gpiod_get() allows to access GPIOs other than the first
3188  * defined one for functions that define several GPIOs.
3189  *
3190  * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
3191  * requested function and/or index, or another IS_ERR() code if an error
3192  * occurred while trying to acquire the GPIO.
3193  */
3194 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
3195                                                const char *con_id,
3196                                                unsigned int idx,
3197                                                enum gpiod_flags flags)
3198 {
3199         struct gpio_desc *desc = NULL;
3200         int status;
3201         enum gpio_lookup_flags lookupflags = 0;
3202
3203         dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
3204
3205         if (dev) {
3206                 /* Using device tree? */
3207                 if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
3208                         dev_dbg(dev, "using device tree for GPIO lookup\n");
3209                         desc = of_find_gpio(dev, con_id, idx, &lookupflags);
3210                 } else if (ACPI_COMPANION(dev)) {
3211                         dev_dbg(dev, "using ACPI for GPIO lookup\n");
3212                         desc = acpi_find_gpio(dev, con_id, idx, flags, &lookupflags);
3213                 }
3214         }
3215
3216         /*
3217          * Either we are not using DT or ACPI, or their lookup did not return
3218          * a result. In that case, use platform lookup as a fallback.
3219          */
3220         if (!desc || desc == ERR_PTR(-ENOENT)) {
3221                 dev_dbg(dev, "using lookup tables for GPIO lookup\n");
3222                 desc = gpiod_find(dev, con_id, idx, &lookupflags);
3223         }
3224
3225         if (IS_ERR(desc)) {
3226                 dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
3227                 return desc;
3228         }
3229
3230         status = gpiod_request(desc, con_id);
3231         if (status < 0)
3232                 return ERR_PTR(status);
3233
3234         status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
3235         if (status < 0) {
3236                 dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
3237                 gpiod_put(desc);
3238                 return ERR_PTR(status);
3239         }
3240
3241         return desc;
3242 }
3243 EXPORT_SYMBOL_GPL(gpiod_get_index);
3244
3245 /**
3246  * fwnode_get_named_gpiod - obtain a GPIO from firmware node
3247  * @fwnode:     handle of the firmware node
3248  * @propname:   name of the firmware property representing the GPIO
3249  *
3250  * This function can be used for drivers that get their configuration
3251  * from firmware.
3252  *
3253  * Function properly finds the corresponding GPIO using whatever is the
3254  * underlying firmware interface and then makes sure that the GPIO
3255  * descriptor is requested before it is returned to the caller.
3256  *
3257  * In case of error an ERR_PTR() is returned.
3258  */
3259 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
3260                                          const char *propname)
3261 {
3262         struct gpio_desc *desc = ERR_PTR(-ENODEV);
3263         bool active_low = false;
3264         bool single_ended = false;
3265         int ret;
3266
3267         if (!fwnode)
3268                 return ERR_PTR(-EINVAL);
3269
3270         if (is_of_node(fwnode)) {
3271                 enum of_gpio_flags flags;
3272
3273                 desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname, 0,
3274                                                 &flags);
3275                 if (!IS_ERR(desc)) {
3276                         active_low = flags & OF_GPIO_ACTIVE_LOW;
3277                         single_ended = flags & OF_GPIO_SINGLE_ENDED;
3278                 }
3279         } else if (is_acpi_node(fwnode)) {
3280                 struct acpi_gpio_info info;
3281
3282                 desc = acpi_node_get_gpiod(fwnode, propname, 0, &info);
3283                 if (!IS_ERR(desc))
3284                         active_low = info.polarity == GPIO_ACTIVE_LOW;
3285         }
3286
3287         if (IS_ERR(desc))
3288                 return desc;
3289
3290         ret = gpiod_request(desc, NULL);
3291         if (ret)
3292                 return ERR_PTR(ret);
3293
3294         if (active_low)
3295                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
3296
3297         if (single_ended) {
3298                 if (active_low)
3299                         set_bit(FLAG_OPEN_DRAIN, &desc->flags);
3300                 else
3301                         set_bit(FLAG_OPEN_SOURCE, &desc->flags);
3302         }
3303
3304         return desc;
3305 }
3306 EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);
3307
3308 /**
3309  * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
3310  *                            function
3311  * @dev: GPIO consumer, can be NULL for system-global GPIOs
3312  * @con_id: function within the GPIO consumer
3313  * @index: index of the GPIO to obtain in the consumer
3314  * @flags: optional GPIO initialization flags
3315  *
3316  * This is equivalent to gpiod_get_index(), except that when no GPIO with the
3317  * specified index was assigned to the requested function it will return NULL.
3318  * This is convenient for drivers that need to handle optional GPIOs.
3319  */
3320 struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
3321                                                         const char *con_id,
3322                                                         unsigned int index,
3323                                                         enum gpiod_flags flags)
3324 {
3325         struct gpio_desc *desc;
3326
3327         desc = gpiod_get_index(dev, con_id, index, flags);
3328         if (IS_ERR(desc)) {
3329                 if (PTR_ERR(desc) == -ENOENT)
3330                         return NULL;
3331         }
3332
3333         return desc;
3334 }
3335 EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
3336
3337 /**
3338  * gpiod_hog - Hog the specified GPIO desc given the provided flags
3339  * @desc:       gpio whose value will be assigned
3340  * @name:       gpio line name
3341  * @lflags:     gpio_lookup_flags - returned from of_find_gpio() or
3342  *              of_get_gpio_hog()
3343  * @dflags:     gpiod_flags - optional GPIO initialization flags
3344  */
3345 int gpiod_hog(struct gpio_desc *desc, const char *name,
3346               unsigned long lflags, enum gpiod_flags dflags)
3347 {
3348         struct gpio_chip *chip;
3349         struct gpio_desc *local_desc;
3350         int hwnum;
3351         int status;
3352
3353         chip = gpiod_to_chip(desc);
3354         hwnum = gpio_chip_hwgpio(desc);
3355
3356         local_desc = gpiochip_request_own_desc(chip, hwnum, name);
3357         if (IS_ERR(local_desc)) {
3358                 status = PTR_ERR(local_desc);
3359                 pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n",
3360                        name, chip->label, hwnum, status);
3361                 return status;
3362         }
3363
3364         status = gpiod_configure_flags(desc, name, lflags, dflags);
3365         if (status < 0) {
3366                 pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
3367                        name, chip->label, hwnum, status);
3368                 gpiochip_free_own_desc(desc);
3369                 return status;
3370         }
3371
3372         /* Mark GPIO as hogged so it can be identified and removed later */
3373         set_bit(FLAG_IS_HOGGED, &desc->flags);
3374
3375         pr_info("GPIO line %d (%s) hogged as %s%s\n",
3376                 desc_to_gpio(desc), name,
3377                 (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
3378                 (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ?
3379                   (dflags&GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low":"");
3380
3381         return 0;
3382 }
3383
3384 /**
3385  * gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog
3386  * @chip:       gpio chip to act on
3387  *
3388  * This is only used by of_gpiochip_remove to free hogged gpios
3389  */
3390 static void gpiochip_free_hogs(struct gpio_chip *chip)
3391 {
3392         int id;
3393
3394         for (id = 0; id < chip->ngpio; id++) {
3395                 if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
3396                         gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
3397         }
3398 }
3399
3400 /**
3401  * gpiod_get_array - obtain multiple GPIOs from a multi-index GPIO function
3402  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
3403  * @con_id:     function within the GPIO consumer
3404  * @flags:      optional GPIO initialization flags
3405  *
3406  * This function acquires all the GPIOs defined under a given function.
3407  *
3408  * Return a struct gpio_descs containing an array of descriptors, -ENOENT if
3409  * no GPIO has been assigned to the requested function, or another IS_ERR()
3410  * code if an error occurred while trying to acquire the GPIOs.
3411  */
3412 struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
3413                                                 const char *con_id,
3414                                                 enum gpiod_flags flags)
3415 {
3416         struct gpio_desc *desc;
3417         struct gpio_descs *descs;
3418         int count;
3419
3420         count = gpiod_count(dev, con_id);
3421         if (count < 0)
3422                 return ERR_PTR(count);
3423
3424         descs = kzalloc(sizeof(*descs) + sizeof(descs->desc[0]) * count,
3425                         GFP_KERNEL);
3426         if (!descs)
3427                 return ERR_PTR(-ENOMEM);
3428
3429         for (descs->ndescs = 0; descs->ndescs < count; ) {
3430                 desc = gpiod_get_index(dev, con_id, descs->ndescs, flags);
3431                 if (IS_ERR(desc)) {
3432                         gpiod_put_array(descs);
3433                         return ERR_CAST(desc);
3434                 }
3435                 descs->desc[descs->ndescs] = desc;
3436                 descs->ndescs++;
3437         }
3438         return descs;
3439 }
3440 EXPORT_SYMBOL_GPL(gpiod_get_array);
3441
3442 /**
3443  * gpiod_get_array_optional - obtain multiple GPIOs from a multi-index GPIO
3444  *                            function
3445  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
3446  * @con_id:     function within the GPIO consumer
3447  * @flags:      optional GPIO initialization flags
3448  *
3449  * This is equivalent to gpiod_get_array(), except that when no GPIO was
3450  * assigned to the requested function it will return NULL.
3451  */
3452 struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
3453                                                         const char *con_id,
3454                                                         enum gpiod_flags flags)
3455 {
3456         struct gpio_descs *descs;
3457
3458         descs = gpiod_get_array(dev, con_id, flags);
3459         if (IS_ERR(descs) && (PTR_ERR(descs) == -ENOENT))
3460                 return NULL;
3461
3462         return descs;
3463 }
3464 EXPORT_SYMBOL_GPL(gpiod_get_array_optional);
3465
3466 /**
3467  * gpiod_put - dispose of a GPIO descriptor
3468  * @desc:       GPIO descriptor to dispose of
3469  *
3470  * No descriptor can be used after gpiod_put() has been called on it.
3471  */
3472 void gpiod_put(struct gpio_desc *desc)
3473 {
3474         gpiod_free(desc);
3475 }
3476 EXPORT_SYMBOL_GPL(gpiod_put);
3477
3478 /**
3479  * gpiod_put_array - dispose of multiple GPIO descriptors
3480  * @descs:      struct gpio_descs containing an array of descriptors
3481  */
3482 void gpiod_put_array(struct gpio_descs *descs)
3483 {
3484         unsigned int i;
3485
3486         for (i = 0; i < descs->ndescs; i++)
3487                 gpiod_put(descs->desc[i]);
3488
3489         kfree(descs);
3490 }
3491 EXPORT_SYMBOL_GPL(gpiod_put_array);
3492
3493 static int __init gpiolib_dev_init(void)
3494 {
3495         int ret;
3496
3497         /* Register GPIO sysfs bus */
3498         ret  = bus_register(&gpio_bus_type);
3499         if (ret < 0) {
3500                 pr_err("gpiolib: could not register GPIO bus type\n");
3501                 return ret;
3502         }
3503
3504         ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, "gpiochip");
3505         if (ret < 0) {
3506                 pr_err("gpiolib: failed to allocate char dev region\n");
3507                 bus_unregister(&gpio_bus_type);
3508         } else {
3509                 gpiolib_initialized = true;
3510                 gpiochip_setup_devs();
3511         }
3512         return ret;
3513 }
3514 core_initcall(gpiolib_dev_init);
3515
3516 #ifdef CONFIG_DEBUG_FS
3517
3518 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
3519 {
3520         unsigned                i;
3521         struct gpio_chip        *chip = gdev->chip;
3522         unsigned                gpio = gdev->base;
3523         struct gpio_desc        *gdesc = &gdev->descs[0];
3524         int                     is_out;
3525         int                     is_irq;
3526
3527         for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
3528                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
3529                         if (gdesc->name) {
3530                                 seq_printf(s, " gpio-%-3d (%-20.20s)\n",
3531                                            gpio, gdesc->name);
3532                         }
3533                         continue;
3534                 }
3535
3536                 gpiod_get_direction(gdesc);
3537                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
3538                 is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
3539                 seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
3540                         gpio, gdesc->name ? gdesc->name : "", gdesc->label,
3541                         is_out ? "out" : "in ",
3542                         chip->get
3543                                 ? (chip->get(chip, i) ? "hi" : "lo")
3544                                 : "?  ",
3545                         is_irq ? "IRQ" : "   ");
3546                 seq_printf(s, "\n");
3547         }
3548 }
3549
3550 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
3551 {
3552         unsigned long flags;
3553         struct gpio_device *gdev = NULL;
3554         loff_t index = *pos;
3555
3556         s->private = "";
3557
3558         spin_lock_irqsave(&gpio_lock, flags);
3559         list_for_each_entry(gdev, &gpio_devices, list)
3560                 if (index-- == 0) {
3561                         spin_unlock_irqrestore(&gpio_lock, flags);
3562                         return gdev;
3563                 }
3564         spin_unlock_irqrestore(&gpio_lock, flags);
3565
3566         return NULL;
3567 }
3568
3569 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
3570 {
3571         unsigned long flags;
3572         struct gpio_device *gdev = v;
3573         void *ret = NULL;
3574
3575         spin_lock_irqsave(&gpio_lock, flags);
3576         if (list_is_last(&gdev->list, &gpio_devices))
3577                 ret = NULL;
3578         else
3579                 ret = list_entry(gdev->list.next, struct gpio_device, list);
3580         spin_unlock_irqrestore(&gpio_lock, flags);
3581
3582         s->private = "\n";
3583         ++*pos;
3584
3585         return ret;
3586 }
3587
3588 static void gpiolib_seq_stop(struct seq_file *s, void *v)
3589 {
3590 }
3591
3592 static int gpiolib_seq_show(struct seq_file *s, void *v)
3593 {
3594         struct gpio_device *gdev = v;
3595         struct gpio_chip *chip = gdev->chip;
3596         struct device *parent;
3597
3598         if (!chip) {
3599                 seq_printf(s, "%s%s: (dangling chip)", (char *)s->private,
3600                            dev_name(&gdev->dev));
3601                 return 0;
3602         }
3603
3604         seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
3605                    dev_name(&gdev->dev),
3606                    gdev->base, gdev->base + gdev->ngpio - 1);
3607         parent = chip->parent;
3608         if (parent)
3609                 seq_printf(s, ", parent: %s/%s",
3610                            parent->bus ? parent->bus->name : "no-bus",
3611                            dev_name(parent));
3612         if (chip->label)
3613                 seq_printf(s, ", %s", chip->label);
3614         if (chip->can_sleep)
3615                 seq_printf(s, ", can sleep");
3616         seq_printf(s, ":\n");
3617
3618         if (chip->dbg_show)
3619                 chip->dbg_show(s, chip);
3620         else
3621                 gpiolib_dbg_show(s, gdev);
3622
3623         return 0;
3624 }
3625
3626 static const struct seq_operations gpiolib_seq_ops = {
3627         .start = gpiolib_seq_start,
3628         .next = gpiolib_seq_next,
3629         .stop = gpiolib_seq_stop,
3630         .show = gpiolib_seq_show,
3631 };
3632
3633 static int gpiolib_open(struct inode *inode, struct file *file)
3634 {
3635         return seq_open(file, &gpiolib_seq_ops);
3636 }
3637
3638 static const struct file_operations gpiolib_operations = {
3639         .owner          = THIS_MODULE,
3640         .open           = gpiolib_open,
3641         .read           = seq_read,
3642         .llseek         = seq_lseek,
3643         .release        = seq_release,
3644 };
3645
3646 static int __init gpiolib_debugfs_init(void)
3647 {
3648         /* /sys/kernel/debug/gpio */
3649         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
3650                                 NULL, NULL, &gpiolib_operations);
3651         return 0;
3652 }
3653 subsys_initcall(gpiolib_debugfs_init);
3654
3655 #endif  /* DEBUG_FS */