linux/drivers/gpio/gpiolib.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2#include <linux/bitmap.h>
   3#include <linux/kernel.h>
   4#include <linux/module.h>
   5#include <linux/interrupt.h>
   6#include <linux/irq.h>
   7#include <linux/spinlock.h>
   8#include <linux/list.h>
   9#include <linux/device.h>
  10#include <linux/err.h>
  11#include <linux/debugfs.h>
  12#include <linux/seq_file.h>
  13#include <linux/gpio.h>
  14#include <linux/of_gpio.h>
  15#include <linux/idr.h>
  16#include <linux/slab.h>
  17#include <linux/acpi.h>
  18#include <linux/gpio/driver.h>
  19#include <linux/gpio/machine.h>
  20#include <linux/pinctrl/consumer.h>
  21#include <linux/cdev.h>
  22#include <linux/fs.h>
  23#include <linux/uaccess.h>
  24#include <linux/compat.h>
  25#include <linux/anon_inodes.h>
  26#include <linux/file.h>
  27#include <linux/kfifo.h>
  28#include <linux/poll.h>
  29#include <linux/timekeeping.h>
  30#include <uapi/linux/gpio.h>
  31
  32#include "gpiolib.h"
  33
  34#define CREATE_TRACE_POINTS
  35#include <trace/events/gpio.h>
  36
  37/* Implementation infrastructure for GPIO interfaces.
  38 *
  39 * The GPIO programming interface allows for inlining speed-critical
  40 * get/set operations for common cases, so that access to SOC-integrated
  41 * GPIOs can sometimes cost only an instruction or two per bit.
  42 */
  43
  44
  45/* When debugging, extend minimal trust to callers and platform code.
  46 * Also emit diagnostic messages that may help initial bringup, when
  47 * board setup or driver bugs are most common.
  48 *
  49 * Otherwise, minimize overhead in what may be bitbanging codepaths.
  50 */
  51#ifdef  DEBUG
  52#define extra_checks    1
  53#else
  54#define extra_checks    0
  55#endif
  56
  57/* Device and char device-related information */
  58static DEFINE_IDA(gpio_ida);
  59static dev_t gpio_devt;
  60#define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */
  61static struct bus_type gpio_bus_type = {
  62        .name = "gpio",
  63};
  64
  65/*
  66 * Number of GPIOs to use for the fast path in set array
  67 */
  68#define FASTPATH_NGPIO CONFIG_GPIOLIB_FASTPATH_LIMIT
  69
  70/* gpio_lock prevents conflicts during gpio_desc[] table updates.
  71 * While any GPIO is requested, its gpio_chip is not removable;
  72 * each GPIO's "requested" flag serves as a lock and refcount.
  73 */
  74DEFINE_SPINLOCK(gpio_lock);
  75
  76static DEFINE_MUTEX(gpio_lookup_lock);
  77static LIST_HEAD(gpio_lookup_list);
  78LIST_HEAD(gpio_devices);
  79
  80static DEFINE_MUTEX(gpio_machine_hogs_mutex);
  81static LIST_HEAD(gpio_machine_hogs);
  82
  83static void gpiochip_free_hogs(struct gpio_chip *chip);
  84static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
  85                                struct lock_class_key *lock_key,
  86                                struct lock_class_key *request_key);
  87static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
  88static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
  89static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
  90
  91static bool gpiolib_initialized;
  92
  93static inline void desc_set_label(struct gpio_desc *d, const char *label)
  94{
  95        d->label = label;
  96}
  97
  98/**
  99 * gpio_to_desc - Convert a GPIO number to its descriptor
 100 * @gpio: global GPIO number
 101 *
 102 * Returns:
 103 * The GPIO descriptor associated with the given GPIO, or %NULL if no GPIO
 104 * with the given number exists in the system.
 105 */
 106struct gpio_desc *gpio_to_desc(unsigned gpio)
 107{
 108        struct gpio_device *gdev;
 109        unsigned long flags;
 110
 111        spin_lock_irqsave(&gpio_lock, flags);
 112
 113        list_for_each_entry(gdev, &gpio_devices, list) {
 114                if (gdev->base <= gpio &&
 115                    gdev->base + gdev->ngpio > gpio) {
 116                        spin_unlock_irqrestore(&gpio_lock, flags);
 117                        return &gdev->descs[gpio - gdev->base];
 118                }
 119        }
 120
 121        spin_unlock_irqrestore(&gpio_lock, flags);
 122
 123        if (!gpio_is_valid(gpio))
 124                WARN(1, "invalid GPIO %d\n", gpio);
 125
 126        return NULL;
 127}
 128EXPORT_SYMBOL_GPL(gpio_to_desc);
 129
 130/**
 131 * gpiochip_get_desc - get the GPIO descriptor corresponding to the given
 132 *                     hardware number for this chip
 133 * @chip: GPIO chip
 134 * @hwnum: hardware number of the GPIO for this chip
 135 *
 136 * Returns:
 137 * A pointer to the GPIO descriptor or %ERR_PTR(-EINVAL) if no GPIO exists
 138 * in the given chip for the specified hardware number.
 139 */
 140struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
 141                                    u16 hwnum)
 142{
 143        struct gpio_device *gdev = chip->gpiodev;
 144
 145        if (hwnum >= gdev->ngpio)
 146                return ERR_PTR(-EINVAL);
 147
 148        return &gdev->descs[hwnum];
 149}
 150
 151/**
 152 * desc_to_gpio - convert a GPIO descriptor to the integer namespace
 153 * @desc: GPIO descriptor
 154 *
 155 * This should disappear in the future but is needed since we still
 156 * use GPIO numbers for error messages and sysfs nodes.
 157 *
 158 * Returns:
 159 * The global GPIO number for the GPIO specified by its descriptor.
 160 */
 161int desc_to_gpio(const struct gpio_desc *desc)
 162{
 163        return desc->gdev->base + (desc - &desc->gdev->descs[0]);
 164}
 165EXPORT_SYMBOL_GPL(desc_to_gpio);
 166
 167
 168/**
 169 * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
 170 * @desc:       descriptor to return the chip of
 171 */
 172struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
 173{
 174        if (!desc || !desc->gdev)
 175                return NULL;
 176        return desc->gdev->chip;
 177}
 178EXPORT_SYMBOL_GPL(gpiod_to_chip);
 179
 180/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
 181static int gpiochip_find_base(int ngpio)
 182{
 183        struct gpio_device *gdev;
 184        int base = ARCH_NR_GPIOS - ngpio;
 185
 186        list_for_each_entry_reverse(gdev, &gpio_devices, list) {
 187                /* found a free space? */
 188                if (gdev->base + gdev->ngpio <= base)
 189                        break;
 190                else
 191                        /* nope, check the space right before the chip */
 192                        base = gdev->base - ngpio;
 193        }
 194
 195        if (gpio_is_valid(base)) {
 196                pr_debug("%s: found new base at %d\n", __func__, base);
 197                return base;
 198        } else {
 199                pr_err("%s: cannot find free range\n", __func__);
 200                return -ENOSPC;
 201        }
 202}
 203
 204/**
 205 * gpiod_get_direction - return the current direction of a GPIO
 206 * @desc:       GPIO to get the direction of
 207 *
 208 * Returns 0 for output, 1 for input, or an error code in case of error.
 209 *
 210 * This function may sleep if gpiod_cansleep() is true.
 211 */
 212int gpiod_get_direction(struct gpio_desc *desc)
 213{
 214        struct gpio_chip *chip;
 215        unsigned offset;
 216        int status;
 217
 218        chip = gpiod_to_chip(desc);
 219        offset = gpio_chip_hwgpio(desc);
 220
 221        if (!chip->get_direction)
 222                return -ENOTSUPP;
 223
 224        status = chip->get_direction(chip, offset);
 225        if (status > 0) {
 226                /* GPIOF_DIR_IN, or other positive */
 227                status = 1;
 228                clear_bit(FLAG_IS_OUT, &desc->flags);
 229        }
 230        if (status == 0) {
 231                /* GPIOF_DIR_OUT */
 232                set_bit(FLAG_IS_OUT, &desc->flags);
 233        }
 234        return status;
 235}
 236EXPORT_SYMBOL_GPL(gpiod_get_direction);
 237
 238/*
 239 * Add a new chip to the global chips list, keeping the list of chips sorted
 240 * by range(means [base, base + ngpio - 1]) order.
 241 *
 242 * Return -EBUSY if the new chip overlaps with some other chip's integer
 243 * space.
 244 */
 245static int gpiodev_add_to_list(struct gpio_device *gdev)
 246{
 247        struct gpio_device *prev, *next;
 248
 249        if (list_empty(&gpio_devices)) {
 250                /* initial entry in list */
 251                list_add_tail(&gdev->list, &gpio_devices);
 252                return 0;
 253        }
 254
 255        next = list_entry(gpio_devices.next, struct gpio_device, list);
 256        if (gdev->base + gdev->ngpio <= next->base) {
 257                /* add before first entry */
 258                list_add(&gdev->list, &gpio_devices);
 259                return 0;
 260        }
 261
 262        prev = list_entry(gpio_devices.prev, struct gpio_device, list);
 263        if (prev->base + prev->ngpio <= gdev->base) {
 264                /* add behind last entry */
 265                list_add_tail(&gdev->list, &gpio_devices);
 266                return 0;
 267        }
 268
 269        list_for_each_entry_safe(prev, next, &gpio_devices, list) {
 270                /* at the end of the list */
 271                if (&next->list == &gpio_devices)
 272                        break;
 273
 274                /* add between prev and next */
 275                if (prev->base + prev->ngpio <= gdev->base
 276                                && gdev->base + gdev->ngpio <= next->base) {
 277                        list_add(&gdev->list, &prev->list);
 278                        return 0;
 279                }
 280        }
 281
 282        dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
 283        return -EBUSY;
 284}
 285
 286/*
 287 * Convert a GPIO name to its descriptor
 288 */
 289static struct gpio_desc *gpio_name_to_desc(const char * const name)
 290{
 291        struct gpio_device *gdev;
 292        unsigned long flags;
 293
 294        spin_lock_irqsave(&gpio_lock, flags);
 295
 296        list_for_each_entry(gdev, &gpio_devices, list) {
 297                int i;
 298
 299                for (i = 0; i != gdev->ngpio; ++i) {
 300                        struct gpio_desc *desc = &gdev->descs[i];
 301
 302                        if (!desc->name || !name)
 303                                continue;
 304
 305                        if (!strcmp(desc->name, name)) {
 306                                spin_unlock_irqrestore(&gpio_lock, flags);
 307                                return desc;
 308                        }
 309                }
 310        }
 311
 312        spin_unlock_irqrestore(&gpio_lock, flags);
 313
 314        return NULL;
 315}
 316
 317/*
 318 * Takes the names from gc->names and checks if they are all unique. If they
 319 * are, they are assigned to their gpio descriptors.
 320 *
 321 * Warning if one of the names is already used for a different GPIO.
 322 */
 323static int gpiochip_set_desc_names(struct gpio_chip *gc)
 324{
 325        struct gpio_device *gdev = gc->gpiodev;
 326        int i;
 327
 328        if (!gc->names)
 329                return 0;
 330
 331        /* First check all names if they are unique */
 332        for (i = 0; i != gc->ngpio; ++i) {
 333                struct gpio_desc *gpio;
 334
 335                gpio = gpio_name_to_desc(gc->names[i]);
 336                if (gpio)
 337                        dev_warn(&gdev->dev,
 338                                 "Detected name collision for GPIO name '%s'\n",
 339                                 gc->names[i]);
 340        }
 341
 342        /* Then add all names to the GPIO descriptors */
 343        for (i = 0; i != gc->ngpio; ++i)
 344                gdev->descs[i].name = gc->names[i];
 345
 346        return 0;
 347}
 348
 349static unsigned long *gpiochip_allocate_mask(struct gpio_chip *chip)
 350{
 351        unsigned long *p;
 352
 353        p = kmalloc_array(BITS_TO_LONGS(chip->ngpio), sizeof(*p), GFP_KERNEL);
 354        if (!p)
 355                return NULL;
 356
 357        /* Assume by default all GPIOs are valid */
 358        bitmap_fill(p, chip->ngpio);
 359
 360        return p;
 361}
 362
 363static int gpiochip_alloc_valid_mask(struct gpio_chip *gpiochip)
 364{
 365#ifdef CONFIG_OF_GPIO
 366        int size;
 367        struct device_node *np = gpiochip->of_node;
 368
 369        size = of_property_count_u32_elems(np,  "gpio-reserved-ranges");
 370        if (size > 0 && size % 2 == 0)
 371                gpiochip->need_valid_mask = true;
 372#endif
 373
 374        if (!gpiochip->need_valid_mask)
 375                return 0;
 376
 377        gpiochip->valid_mask = gpiochip_allocate_mask(gpiochip);
 378        if (!gpiochip->valid_mask)
 379                return -ENOMEM;
 380
 381        return 0;
 382}
 383
 384static int gpiochip_init_valid_mask(struct gpio_chip *gpiochip)
 385{
 386        if (gpiochip->init_valid_mask)
 387                return gpiochip->init_valid_mask(gpiochip);
 388
 389        return 0;
 390}
 391
 392static void gpiochip_free_valid_mask(struct gpio_chip *gpiochip)
 393{
 394        kfree(gpiochip->valid_mask);
 395        gpiochip->valid_mask = NULL;
 396}
 397
 398bool gpiochip_line_is_valid(const struct gpio_chip *gpiochip,
 399                                unsigned int offset)
 400{
 401        /* No mask means all valid */
 402        if (likely(!gpiochip->valid_mask))
 403                return true;
 404        return test_bit(offset, gpiochip->valid_mask);
 405}
 406EXPORT_SYMBOL_GPL(gpiochip_line_is_valid);
 407
 408/*
 409 * GPIO line handle management
 410 */
 411
 412/**
 413 * struct linehandle_state - contains the state of a userspace handle
 414 * @gdev: the GPIO device the handle pertains to
 415 * @label: consumer label used to tag descriptors
 416 * @descs: the GPIO descriptors held by this handle
 417 * @numdescs: the number of descriptors held in the descs array
 418 */
 419struct linehandle_state {
 420        struct gpio_device *gdev;
 421        const char *label;
 422        struct gpio_desc *descs[GPIOHANDLES_MAX];
 423        u32 numdescs;
 424};
 425
 426#define GPIOHANDLE_REQUEST_VALID_FLAGS \
 427        (GPIOHANDLE_REQUEST_INPUT | \
 428        GPIOHANDLE_REQUEST_OUTPUT | \
 429        GPIOHANDLE_REQUEST_ACTIVE_LOW | \
 430        GPIOHANDLE_REQUEST_OPEN_DRAIN | \
 431        GPIOHANDLE_REQUEST_OPEN_SOURCE)
 432
 433static long linehandle_ioctl(struct file *filep, unsigned int cmd,
 434                             unsigned long arg)
 435{
 436        struct linehandle_state *lh = filep->private_data;
 437        void __user *ip = (void __user *)arg;
 438        struct gpiohandle_data ghd;
 439        DECLARE_BITMAP(vals, GPIOHANDLES_MAX);
 440        int i;
 441
 442        if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
 443                /* NOTE: It's ok to read values of output lines. */
 444                int ret = gpiod_get_array_value_complex(false,
 445                                                        true,
 446                                                        lh->numdescs,
 447                                                        lh->descs,
 448                                                        NULL,
 449                                                        vals);
 450                if (ret)
 451                        return ret;
 452
 453                memset(&ghd, 0, sizeof(ghd));
 454                for (i = 0; i < lh->numdescs; i++)
 455                        ghd.values[i] = test_bit(i, vals);
 456
 457                if (copy_to_user(ip, &ghd, sizeof(ghd)))
 458                        return -EFAULT;
 459
 460                return 0;
 461        } else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
 462                /*
 463                 * All line descriptors were created at once with the same
 464                 * flags so just check if the first one is really output.
 465                 */
 466                if (!test_bit(FLAG_IS_OUT, &lh->descs[0]->flags))
 467                        return -EPERM;
 468
 469                if (copy_from_user(&ghd, ip, sizeof(ghd)))
 470                        return -EFAULT;
 471
 472                /* Clamp all values to [0,1] */
 473                for (i = 0; i < lh->numdescs; i++)
 474                        __assign_bit(i, vals, ghd.values[i]);
 475
 476                /* Reuse the array setting function */
 477                return gpiod_set_array_value_complex(false,
 478                                              true,
 479                                              lh->numdescs,
 480                                              lh->descs,
 481                                              NULL,
 482                                              vals);
 483        }
 484        return -EINVAL;
 485}
 486
 487#ifdef CONFIG_COMPAT
 488static long linehandle_ioctl_compat(struct file *filep, unsigned int cmd,
 489                             unsigned long arg)
 490{
 491        return linehandle_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
 492}
 493#endif
 494
 495static int linehandle_release(struct inode *inode, struct file *filep)
 496{
 497        struct linehandle_state *lh = filep->private_data;
 498        struct gpio_device *gdev = lh->gdev;
 499        int i;
 500
 501        for (i = 0; i < lh->numdescs; i++)
 502                gpiod_free(lh->descs[i]);
 503        kfree(lh->label);
 504        kfree(lh);
 505        put_device(&gdev->dev);
 506        return 0;
 507}
 508
 509static const struct file_operations linehandle_fileops = {
 510        .release = linehandle_release,
 511        .owner = THIS_MODULE,
 512        .llseek = noop_llseek,
 513        .unlocked_ioctl = linehandle_ioctl,
 514#ifdef CONFIG_COMPAT
 515        .compat_ioctl = linehandle_ioctl_compat,
 516#endif
 517};
 518
 519static int linehandle_create(struct gpio_device *gdev, void __user *ip)
 520{
 521        struct gpiohandle_request handlereq;
 522        struct linehandle_state *lh;
 523        struct file *file;
 524        int fd, i, count = 0, ret;
 525        u32 lflags;
 526
 527        if (copy_from_user(&handlereq, ip, sizeof(handlereq)))
 528                return -EFAULT;
 529        if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX))
 530                return -EINVAL;
 531
 532        lflags = handlereq.flags;
 533
 534        /* Return an error if an unknown flag is set */
 535        if (lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS)
 536                return -EINVAL;
 537
 538        /*
 539         * Do not allow OPEN_SOURCE & OPEN_DRAIN flags in a single request. If
 540         * the hardware actually supports enabling both at the same time the
 541         * electrical result would be disastrous.
 542         */
 543        if ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) &&
 544            (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE))
 545                return -EINVAL;
 546
 547        /* OPEN_DRAIN and OPEN_SOURCE flags only make sense for output mode. */
 548        if (!(lflags & GPIOHANDLE_REQUEST_OUTPUT) &&
 549            ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
 550             (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)))
 551                return -EINVAL;
 552
 553        lh = kzalloc(sizeof(*lh), GFP_KERNEL);
 554        if (!lh)
 555                return -ENOMEM;
 556        lh->gdev = gdev;
 557        get_device(&gdev->dev);
 558
 559        /* Make sure this is terminated */
 560        handlereq.consumer_label[sizeof(handlereq.consumer_label)-1] = '\0';
 561        if (strlen(handlereq.consumer_label)) {
 562                lh->label = kstrdup(handlereq.consumer_label,
 563                                    GFP_KERNEL);
 564                if (!lh->label) {
 565                        ret = -ENOMEM;
 566                        goto out_free_lh;
 567                }
 568        }
 569
 570        /* Request each GPIO */
 571        for (i = 0; i < handlereq.lines; i++) {
 572                u32 offset = handlereq.lineoffsets[i];
 573                struct gpio_desc *desc;
 574
 575                if (offset >= gdev->ngpio) {
 576                        ret = -EINVAL;
 577                        goto out_free_descs;
 578                }
 579
 580                desc = &gdev->descs[offset];
 581                ret = gpiod_request(desc, lh->label);
 582                if (ret)
 583                        goto out_free_descs;
 584                lh->descs[i] = desc;
 585                count = i + 1;
 586
 587                if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
 588                        set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 589                if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
 590                        set_bit(FLAG_OPEN_DRAIN, &desc->flags);
 591                if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
 592                        set_bit(FLAG_OPEN_SOURCE, &desc->flags);
 593
 594                ret = gpiod_set_transitory(desc, false);
 595                if (ret < 0)
 596                        goto out_free_descs;
 597
 598                /*
 599                 * Lines have to be requested explicitly for input
 600                 * or output, else the line will be treated "as is".
 601                 */
 602                if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
 603                        int val = !!handlereq.default_values[i];
 604
 605                        ret = gpiod_direction_output(desc, val);
 606                        if (ret)
 607                                goto out_free_descs;
 608                } else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
 609                        ret = gpiod_direction_input(desc);
 610                        if (ret)
 611                                goto out_free_descs;
 612                }
 613                dev_dbg(&gdev->dev, "registered chardev handle for line %d\n",
 614                        offset);
 615        }
 616        /* Let i point at the last handle */
 617        i--;
 618        lh->numdescs = handlereq.lines;
 619
 620        fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
 621        if (fd < 0) {
 622                ret = fd;
 623                goto out_free_descs;
 624        }
 625
 626        file = anon_inode_getfile("gpio-linehandle",
 627                                  &linehandle_fileops,
 628                                  lh,
 629                                  O_RDONLY | O_CLOEXEC);
 630        if (IS_ERR(file)) {
 631                ret = PTR_ERR(file);
 632                goto out_put_unused_fd;
 633        }
 634
 635        handlereq.fd = fd;
 636        if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
 637                /*
 638                 * fput() will trigger the release() callback, so do not go onto
 639                 * the regular error cleanup path here.
 640                 */
 641                fput(file);
 642                put_unused_fd(fd);
 643                return -EFAULT;
 644        }
 645
 646        fd_install(fd, file);
 647
 648        dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n",
 649                lh->numdescs);
 650
 651        return 0;
 652
 653out_put_unused_fd:
 654        put_unused_fd(fd);
 655out_free_descs:
 656        for (i = 0; i < count; i++)
 657                gpiod_free(lh->descs[i]);
 658        kfree(lh->label);
 659out_free_lh:
 660        kfree(lh);
 661        put_device(&gdev->dev);
 662        return ret;
 663}
 664
 665/*
 666 * GPIO line event management
 667 */
 668
 669/**
 670 * struct lineevent_state - contains the state of a userspace event
 671 * @gdev: the GPIO device the event pertains to
 672 * @label: consumer label used to tag descriptors
 673 * @desc: the GPIO descriptor held by this event
 674 * @eflags: the event flags this line was requested with
 675 * @irq: the interrupt that trigger in response to events on this GPIO
 676 * @wait: wait queue that handles blocking reads of events
 677 * @events: KFIFO for the GPIO events
 678 * @read_lock: mutex lock to protect reads from colliding with adding
 679 * new events to the FIFO
 680 * @timestamp: cache for the timestamp storing it between hardirq
 681 * and IRQ thread, used to bring the timestamp close to the actual
 682 * event
 683 */
 684struct lineevent_state {
 685        struct gpio_device *gdev;
 686        const char *label;
 687        struct gpio_desc *desc;
 688        u32 eflags;
 689        int irq;
 690        wait_queue_head_t wait;
 691        DECLARE_KFIFO(events, struct gpioevent_data, 16);
 692        struct mutex read_lock;
 693        u64 timestamp;
 694};
 695
 696#define GPIOEVENT_REQUEST_VALID_FLAGS \
 697        (GPIOEVENT_REQUEST_RISING_EDGE | \
 698        GPIOEVENT_REQUEST_FALLING_EDGE)
 699
 700static __poll_t lineevent_poll(struct file *filep,
 701                                   struct poll_table_struct *wait)
 702{
 703        struct lineevent_state *le = filep->private_data;
 704        __poll_t events = 0;
 705
 706        poll_wait(filep, &le->wait, wait);
 707
 708        if (!kfifo_is_empty(&le->events))
 709                events = EPOLLIN | EPOLLRDNORM;
 710
 711        return events;
 712}
 713
 714
 715static ssize_t lineevent_read(struct file *filep,
 716                              char __user *buf,
 717                              size_t count,
 718                              loff_t *f_ps)
 719{
 720        struct lineevent_state *le = filep->private_data;
 721        unsigned int copied;
 722        int ret;
 723
 724        if (count < sizeof(struct gpioevent_data))
 725                return -EINVAL;
 726
 727        do {
 728                if (kfifo_is_empty(&le->events)) {
 729                        if (filep->f_flags & O_NONBLOCK)
 730                                return -EAGAIN;
 731
 732                        ret = wait_event_interruptible(le->wait,
 733                                        !kfifo_is_empty(&le->events));
 734                        if (ret)
 735                                return ret;
 736                }
 737
 738                if (mutex_lock_interruptible(&le->read_lock))
 739                        return -ERESTARTSYS;
 740                ret = kfifo_to_user(&le->events, buf, count, &copied);
 741                mutex_unlock(&le->read_lock);
 742
 743                if (ret)
 744                        return ret;
 745
 746                /*
 747                 * If we couldn't read anything from the fifo (a different
 748                 * thread might have been faster) we either return -EAGAIN if
 749                 * the file descriptor is non-blocking, otherwise we go back to
 750                 * sleep and wait for more data to arrive.
 751                 */
 752                if (copied == 0 && (filep->f_flags & O_NONBLOCK))
 753                        return -EAGAIN;
 754
 755        } while (copied == 0);
 756
 757        return copied;
 758}
 759
 760static int lineevent_release(struct inode *inode, struct file *filep)
 761{
 762        struct lineevent_state *le = filep->private_data;
 763        struct gpio_device *gdev = le->gdev;
 764
 765        free_irq(le->irq, le);
 766        gpiod_free(le->desc);
 767        kfree(le->label);
 768        kfree(le);
 769        put_device(&gdev->dev);
 770        return 0;
 771}
 772
 773static long lineevent_ioctl(struct file *filep, unsigned int cmd,
 774                            unsigned long arg)
 775{
 776        struct lineevent_state *le = filep->private_data;
 777        void __user *ip = (void __user *)arg;
 778        struct gpiohandle_data ghd;
 779
 780        /*
 781         * We can get the value for an event line but not set it,
 782         * because it is input by definition.
 783         */
 784        if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
 785                int val;
 786
 787                memset(&ghd, 0, sizeof(ghd));
 788
 789                val = gpiod_get_value_cansleep(le->desc);
 790                if (val < 0)
 791                        return val;
 792                ghd.values[0] = val;
 793
 794                if (copy_to_user(ip, &ghd, sizeof(ghd)))
 795                        return -EFAULT;
 796
 797                return 0;
 798        }
 799        return -EINVAL;
 800}
 801
 802#ifdef CONFIG_COMPAT
 803static long lineevent_ioctl_compat(struct file *filep, unsigned int cmd,
 804                                   unsigned long arg)
 805{
 806        return lineevent_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
 807}
 808#endif
 809
 810static const struct file_operations lineevent_fileops = {
 811        .release = lineevent_release,
 812        .read = lineevent_read,
 813        .poll = lineevent_poll,
 814        .owner = THIS_MODULE,
 815        .llseek = noop_llseek,
 816        .unlocked_ioctl = lineevent_ioctl,
 817#ifdef CONFIG_COMPAT
 818        .compat_ioctl = lineevent_ioctl_compat,
 819#endif
 820};
 821
 822static irqreturn_t lineevent_irq_thread(int irq, void *p)
 823{
 824        struct lineevent_state *le = p;
 825        struct gpioevent_data ge;
 826        int ret;
 827
 828        /* Do not leak kernel stack to userspace */
 829        memset(&ge, 0, sizeof(ge));
 830
 831        /*
 832         * We may be running from a nested threaded interrupt in which case
 833         * we didn't get the timestamp from lineevent_irq_handler().
 834         */
 835        if (!le->timestamp)
 836                ge.timestamp = ktime_get_real_ns();
 837        else
 838                ge.timestamp = le->timestamp;
 839
 840        if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE
 841            && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
 842                int level = gpiod_get_value_cansleep(le->desc);
 843                if (level)
 844                        /* Emit low-to-high event */
 845                        ge.id = GPIOEVENT_EVENT_RISING_EDGE;
 846                else
 847                        /* Emit high-to-low event */
 848                        ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
 849        } else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE) {
 850                /* Emit low-to-high event */
 851                ge.id = GPIOEVENT_EVENT_RISING_EDGE;
 852        } else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
 853                /* Emit high-to-low event */
 854                ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
 855        } else {
 856                return IRQ_NONE;
 857        }
 858
 859        ret = kfifo_put(&le->events, ge);
 860        if (ret != 0)
 861                wake_up_poll(&le->wait, EPOLLIN);
 862
 863        return IRQ_HANDLED;
 864}
 865
 866static irqreturn_t lineevent_irq_handler(int irq, void *p)
 867{
 868        struct lineevent_state *le = p;
 869
 870        /*
 871         * Just store the timestamp in hardirq context so we get it as
 872         * close in time as possible to the actual event.
 873         */
 874        le->timestamp = ktime_get_real_ns();
 875
 876        return IRQ_WAKE_THREAD;
 877}
 878
 879static int lineevent_create(struct gpio_device *gdev, void __user *ip)
 880{
 881        struct gpioevent_request eventreq;
 882        struct lineevent_state *le;
 883        struct gpio_desc *desc;
 884        struct file *file;
 885        u32 offset;
 886        u32 lflags;
 887        u32 eflags;
 888        int fd;
 889        int ret;
 890        int irqflags = 0;
 891
 892        if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
 893                return -EFAULT;
 894
 895        le = kzalloc(sizeof(*le), GFP_KERNEL);
 896        if (!le)
 897                return -ENOMEM;
 898        le->gdev = gdev;
 899        get_device(&gdev->dev);
 900
 901        /* Make sure this is terminated */
 902        eventreq.consumer_label[sizeof(eventreq.consumer_label)-1] = '\0';
 903        if (strlen(eventreq.consumer_label)) {
 904                le->label = kstrdup(eventreq.consumer_label,
 905                                    GFP_KERNEL);
 906                if (!le->label) {
 907                        ret = -ENOMEM;
 908                        goto out_free_le;
 909                }
 910        }
 911
 912        offset = eventreq.lineoffset;
 913        lflags = eventreq.handleflags;
 914        eflags = eventreq.eventflags;
 915
 916        if (offset >= gdev->ngpio) {
 917                ret = -EINVAL;
 918                goto out_free_label;
 919        }
 920
 921        /* Return an error if a unknown flag is set */
 922        if ((lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) ||
 923            (eflags & ~GPIOEVENT_REQUEST_VALID_FLAGS)) {
 924                ret = -EINVAL;
 925                goto out_free_label;
 926        }
 927
 928        /* This is just wrong: we don't look for events on output lines */
 929        if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
 930                ret = -EINVAL;
 931                goto out_free_label;
 932        }
 933
 934        desc = &gdev->descs[offset];
 935        ret = gpiod_request(desc, le->label);
 936        if (ret)
 937                goto out_free_label;
 938        le->desc = desc;
 939        le->eflags = eflags;
 940
 941        if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
 942                set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 943        if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
 944                set_bit(FLAG_OPEN_DRAIN, &desc->flags);
 945        if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
 946                set_bit(FLAG_OPEN_SOURCE, &desc->flags);
 947
 948        ret = gpiod_direction_input(desc);
 949        if (ret)
 950                goto out_free_desc;
 951
 952        le->irq = gpiod_to_irq(desc);
 953        if (le->irq <= 0) {
 954                ret = -ENODEV;
 955                goto out_free_desc;
 956        }
 957
 958        if (eflags & GPIOEVENT_REQUEST_RISING_EDGE)
 959                irqflags |= IRQF_TRIGGER_RISING;
 960        if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
 961                irqflags |= IRQF_TRIGGER_FALLING;
 962        irqflags |= IRQF_ONESHOT;
 963
 964        INIT_KFIFO(le->events);
 965        init_waitqueue_head(&le->wait);
 966        mutex_init(&le->read_lock);
 967
 968        /* Request a thread to read the events */
 969        ret = request_threaded_irq(le->irq,
 970                        lineevent_irq_handler,
 971                        lineevent_irq_thread,
 972                        irqflags,
 973                        le->label,
 974                        le);
 975        if (ret)
 976                goto out_free_desc;
 977
 978        fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
 979        if (fd < 0) {
 980                ret = fd;
 981                goto out_free_irq;
 982        }
 983
 984        file = anon_inode_getfile("gpio-event",
 985                                  &lineevent_fileops,
 986                                  le,
 987                                  O_RDONLY | O_CLOEXEC);
 988        if (IS_ERR(file)) {
 989                ret = PTR_ERR(file);
 990                goto out_put_unused_fd;
 991        }
 992
 993        eventreq.fd = fd;
 994        if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
 995                /*
 996                 * fput() will trigger the release() callback, so do not go onto
 997                 * the regular error cleanup path here.
 998                 */
 999                fput(file);
1000                put_unused_fd(fd);
1001                return -EFAULT;
1002        }
1003
1004        fd_install(fd, file);
1005
1006        return 0;
1007
1008out_put_unused_fd:
1009        put_unused_fd(fd);
1010out_free_irq:
1011        free_irq(le->irq, le);
1012out_free_desc:
1013        gpiod_free(le->desc);
1014out_free_label:
1015        kfree(le->label);
1016out_free_le:
1017        kfree(le);
1018        put_device(&gdev->dev);
1019        return ret;
1020}
1021
1022/*
1023 * gpio_ioctl() - ioctl handler for the GPIO chardev
1024 */
1025static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1026{
1027        struct gpio_device *gdev = filp->private_data;
1028        struct gpio_chip *chip = gdev->chip;
1029        void __user *ip = (void __user *)arg;
1030
1031        /* We fail any subsequent ioctl():s when the chip is gone */
1032        if (!chip)
1033                return -ENODEV;
1034
1035        /* Fill in the struct and pass to userspace */
1036        if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
1037                struct gpiochip_info chipinfo;
1038
1039                memset(&chipinfo, 0, sizeof(chipinfo));
1040
1041                strncpy(chipinfo.name, dev_name(&gdev->dev),
1042                        sizeof(chipinfo.name));
1043                chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
1044                strncpy(chipinfo.label, gdev->label,
1045                        sizeof(chipinfo.label));
1046                chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
1047                chipinfo.lines = gdev->ngpio;
1048                if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
1049                        return -EFAULT;
1050                return 0;
1051        } else if (cmd == GPIO_GET_LINEINFO_IOCTL) {
1052                struct gpioline_info lineinfo;
1053                struct gpio_desc *desc;
1054
1055                if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
1056                        return -EFAULT;
1057                if (lineinfo.line_offset >= gdev->ngpio)
1058                        return -EINVAL;
1059
1060                desc = &gdev->descs[lineinfo.line_offset];
1061                if (desc->name) {
1062                        strncpy(lineinfo.name, desc->name,
1063                                sizeof(lineinfo.name));
1064                        lineinfo.name[sizeof(lineinfo.name)-1] = '\0';
1065                } else {
1066                        lineinfo.name[0] = '\0';
1067                }
1068                if (desc->label) {
1069                        strncpy(lineinfo.consumer, desc->label,
1070                                sizeof(lineinfo.consumer));
1071                        lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
1072                } else {
1073                        lineinfo.consumer[0] = '\0';
1074                }
1075
1076                /*
1077                 * Userspace only need to know that the kernel is using
1078                 * this GPIO so it can't use it.
1079                 */
1080                lineinfo.flags = 0;
1081                if (test_bit(FLAG_REQUESTED, &desc->flags) ||
1082                    test_bit(FLAG_IS_HOGGED, &desc->flags) ||
1083                    test_bit(FLAG_USED_AS_IRQ, &desc->flags) ||
1084                    test_bit(FLAG_EXPORT, &desc->flags) ||
1085                    test_bit(FLAG_SYSFS, &desc->flags))
1086                        lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
1087                if (test_bit(FLAG_IS_OUT, &desc->flags))
1088                        lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
1089                if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1090                        lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
1091                if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1092                        lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
1093                if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1094                        lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;
1095
1096                if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
1097                        return -EFAULT;
1098                return 0;
1099        } else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
1100                return linehandle_create(gdev, ip);
1101        } else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
1102                return lineevent_create(gdev, ip);
1103        }
1104        return -EINVAL;
1105}
1106
1107#ifdef CONFIG_COMPAT
1108static long gpio_ioctl_compat(struct file *filp, unsigned int cmd,
1109                              unsigned long arg)
1110{
1111        return gpio_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
1112}
1113#endif
1114
1115/**
1116 * gpio_chrdev_open() - open the chardev for ioctl operations
1117 * @inode: inode for this chardev
1118 * @filp: file struct for storing private data
1119 * Returns 0 on success
1120 */
1121static int gpio_chrdev_open(struct inode *inode, struct file *filp)
1122{
1123        struct gpio_device *gdev = container_of(inode->i_cdev,
1124                                              struct gpio_device, chrdev);
1125
1126        /* Fail on open if the backing gpiochip is gone */
1127        if (!gdev->chip)
1128                return -ENODEV;
1129        get_device(&gdev->dev);
1130        filp->private_data = gdev;
1131
1132        return nonseekable_open(inode, filp);
1133}
1134
1135/**
1136 * gpio_chrdev_release() - close chardev after ioctl operations
1137 * @inode: inode for this chardev
1138 * @filp: file struct for storing private data
1139 * Returns 0 on success
1140 */
1141static int gpio_chrdev_release(struct inode *inode, struct file *filp)
1142{
1143        struct gpio_device *gdev = container_of(inode->i_cdev,
1144                                              struct gpio_device, chrdev);
1145
1146        put_device(&gdev->dev);
1147        return 0;
1148}
1149
1150
1151static const struct file_operations gpio_fileops = {
1152        .release = gpio_chrdev_release,
1153        .open = gpio_chrdev_open,
1154        .owner = THIS_MODULE,
1155        .llseek = no_llseek,
1156        .unlocked_ioctl = gpio_ioctl,
1157#ifdef CONFIG_COMPAT
1158        .compat_ioctl = gpio_ioctl_compat,
1159#endif
1160};
1161
1162static void gpiodevice_release(struct device *dev)
1163{
1164        struct gpio_device *gdev = dev_get_drvdata(dev);
1165
1166        list_del(&gdev->list);
1167        ida_simple_remove(&gpio_ida, gdev->id);
1168        kfree_const(gdev->label);
1169        kfree(gdev->descs);
1170        kfree(gdev);
1171}
1172
1173static int gpiochip_setup_dev(struct gpio_device *gdev)
1174{
1175        int status;
1176
1177        cdev_init(&gdev->chrdev, &gpio_fileops);
1178        gdev->chrdev.owner = THIS_MODULE;
1179        gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
1180
1181        status = cdev_device_add(&gdev->chrdev, &gdev->dev);
1182        if (status)
1183                return status;
1184
1185        chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
1186                 MAJOR(gpio_devt), gdev->id);
1187
1188        status = gpiochip_sysfs_register(gdev);
1189        if (status)
1190                goto err_remove_device;
1191
1192        /* From this point, the .release() function cleans up gpio_device */
1193        gdev->dev.release = gpiodevice_release;
1194        pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
1195                 __func__, gdev->base, gdev->base + gdev->ngpio - 1,
1196                 dev_name(&gdev->dev), gdev->chip->label ? : "generic");
1197
1198        return 0;
1199
1200err_remove_device:
1201        cdev_device_del(&gdev->chrdev, &gdev->dev);
1202        return status;
1203}
1204
1205static void gpiochip_machine_hog(struct gpio_chip *chip, struct gpiod_hog *hog)
1206{
1207        struct gpio_desc *desc;
1208        int rv;
1209
1210        desc = gpiochip_get_desc(chip, hog->chip_hwnum);
1211        if (IS_ERR(desc)) {
1212                pr_err("%s: unable to get GPIO desc: %ld\n",
1213                       __func__, PTR_ERR(desc));
1214                return;
1215        }
1216
1217        if (test_bit(FLAG_IS_HOGGED, &desc->flags))
1218                return;
1219
1220        rv = gpiod_hog(desc, hog->line_name, hog->lflags, hog->dflags);
1221        if (rv)
1222                pr_err("%s: unable to hog GPIO line (%s:%u): %d\n",
1223                       __func__, chip->label, hog->chip_hwnum, rv);
1224}
1225
1226static void machine_gpiochip_add(struct gpio_chip *chip)
1227{
1228        struct gpiod_hog *hog;
1229
1230        mutex_lock(&gpio_machine_hogs_mutex);
1231
1232        list_for_each_entry(hog, &gpio_machine_hogs, list) {
1233                if (!strcmp(chip->label, hog->chip_label))
1234                        gpiochip_machine_hog(chip, hog);
1235        }
1236
1237        mutex_unlock(&gpio_machine_hogs_mutex);
1238}
1239
1240static void gpiochip_setup_devs(void)
1241{
1242        struct gpio_device *gdev;
1243        int err;
1244
1245        list_for_each_entry(gdev, &gpio_devices, list) {
1246                err = gpiochip_setup_dev(gdev);
1247                if (err)
1248                        pr_err("%s: Failed to initialize gpio device (%d)\n",
1249                               dev_name(&gdev->dev), err);
1250        }
1251}
1252
1253int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
1254                               struct lock_class_key *lock_key,
1255                               struct lock_class_key *request_key)
1256{
1257        unsigned long   flags;
1258        int             status = 0;
1259        unsigned        i;
1260        int             base = chip->base;
1261        struct gpio_device *gdev;
1262
1263        /*
1264         * First: allocate and populate the internal stat container, and
1265         * set up the struct device.
1266         */
1267        gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1268        if (!gdev)
1269                return -ENOMEM;
1270        gdev->dev.bus = &gpio_bus_type;
1271        gdev->chip = chip;
1272        chip->gpiodev = gdev;
1273        if (chip->parent) {
1274                gdev->dev.parent = chip->parent;
1275                gdev->dev.of_node = chip->parent->of_node;
1276        }
1277
1278#ifdef CONFIG_OF_GPIO
1279        /* If the gpiochip has an assigned OF node this takes precedence */
1280        if (chip->of_node)
1281                gdev->dev.of_node = chip->of_node;
1282        else
1283                chip->of_node = gdev->dev.of_node;
1284#endif
1285
1286        gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
1287        if (gdev->id < 0) {
1288                status = gdev->id;
1289                goto err_free_gdev;
1290        }
1291        dev_set_name(&gdev->dev, "gpiochip%d", gdev->id);
1292        device_initialize(&gdev->dev);
1293        dev_set_drvdata(&gdev->dev, gdev);
1294        if (chip->parent && chip->parent->driver)
1295                gdev->owner = chip->parent->driver->owner;
1296        else if (chip->owner)
1297                /* TODO: remove chip->owner */
1298                gdev->owner = chip->owner;
1299        else
1300                gdev->owner = THIS_MODULE;
1301
1302        gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1303        if (!gdev->descs) {
1304                status = -ENOMEM;
1305                goto err_free_ida;
1306        }
1307
1308        if (chip->ngpio == 0) {
1309                chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1310                status = -EINVAL;
1311                goto err_free_descs;
1312        }
1313
1314        if (chip->ngpio > FASTPATH_NGPIO)
1315                chip_warn(chip, "line cnt %u is greater than fast path cnt %u\n",
1316                chip->ngpio, FASTPATH_NGPIO);
1317
1318        gdev->label = kstrdup_const(chip->label ?: "unknown", GFP_KERNEL);
1319        if (!gdev->label) {
1320                status = -ENOMEM;
1321                goto err_free_descs;
1322        }
1323
1324        gdev->ngpio = chip->ngpio;
1325        gdev->data = data;
1326
1327        spin_lock_irqsave(&gpio_lock, flags);
1328
1329        /*
1330         * TODO: this allocates a Linux GPIO number base in the global
1331         * GPIO numberspace for this chip. In the long run we want to
1332         * get *rid* of this numberspace and use only descriptors, but
1333         * it may be a pipe dream. It will not happen before we get rid
1334         * of the sysfs interface anyways.
1335         */
1336        if (base < 0) {
1337                base = gpiochip_find_base(chip->ngpio);
1338                if (base < 0) {
1339                        status = base;
1340                        spin_unlock_irqrestore(&gpio_lock, flags);
1341                        goto err_free_label;
1342                }
1343                /*
1344                 * TODO: it should not be necessary to reflect the assigned
1345                 * base outside of the GPIO subsystem. Go over drivers and
1346                 * see if anyone makes use of this, else drop this and assign
1347                 * a poison instead.
1348                 */
1349                chip->base = base;
1350        }
1351        gdev->base = base;
1352
1353        status = gpiodev_add_to_list(gdev);
1354        if (status) {
1355                spin_unlock_irqrestore(&gpio_lock, flags);
1356                goto err_free_label;
1357        }
1358
1359        spin_unlock_irqrestore(&gpio_lock, flags);
1360
1361        for (i = 0; i < chip->ngpio; i++)
1362                gdev->descs[i].gdev = gdev;
1363
1364#ifdef CONFIG_PINCTRL
1365        INIT_LIST_HEAD(&gdev->pin_ranges);
1366#endif
1367
1368        status = gpiochip_set_desc_names(chip);
1369        if (status)
1370                goto err_remove_from_list;
1371
1372        status = gpiochip_irqchip_init_valid_mask(chip);
1373        if (status)
1374                goto err_remove_from_list;
1375
1376        status = gpiochip_alloc_valid_mask(chip);
1377        if (status)
1378                goto err_remove_irqchip_mask;
1379
1380        status = gpiochip_add_irqchip(chip, lock_key, request_key);
1381        if (status)
1382                goto err_free_gpiochip_mask;
1383
1384        status = of_gpiochip_add(chip);
1385        if (status)
1386                goto err_remove_chip;
1387
1388        status = gpiochip_init_valid_mask(chip);
1389        if (status)
1390                goto err_remove_of_chip;
1391
1392        for (i = 0; i < chip->ngpio; i++) {
1393                struct gpio_desc *desc = &gdev->descs[i];
1394
1395                if (chip->get_direction && gpiochip_line_is_valid(chip, i))
1396                        desc->flags = !chip->get_direction(chip, i) ?
1397                                        (1 << FLAG_IS_OUT) : 0;
1398                else
1399                        desc->flags = !chip->direction_input ?
1400                                        (1 << FLAG_IS_OUT) : 0;
1401        }
1402
1403        acpi_gpiochip_add(chip);
1404
1405        machine_gpiochip_add(chip);
1406
1407        /*
1408         * By first adding the chardev, and then adding the device,
1409         * we get a device node entry in sysfs under
1410         * /sys/bus/gpio/devices/gpiochipN/dev that can be used for
1411         * coldplug of device nodes and other udev business.
1412         * We can do this only if gpiolib has been initialized.
1413         * Otherwise, defer until later.
1414         */
1415        if (gpiolib_initialized) {
1416                status = gpiochip_setup_dev(gdev);
1417                if (status)
1418                        goto err_remove_acpi_chip;
1419        }
1420        return 0;
1421
1422err_remove_acpi_chip:
1423        acpi_gpiochip_remove(chip);
1424err_remove_of_chip:
1425        gpiochip_free_hogs(chip);
1426        of_gpiochip_remove(chip);
1427err_remove_chip:
1428        gpiochip_irqchip_remove(chip);
1429err_free_gpiochip_mask:
1430        gpiochip_free_valid_mask(chip);
1431err_remove_irqchip_mask:
1432        gpiochip_irqchip_free_valid_mask(chip);
1433err_remove_from_list:
1434        spin_lock_irqsave(&gpio_lock, flags);
1435        list_del(&gdev->list);
1436        spin_unlock_irqrestore(&gpio_lock, flags);
1437err_free_label:
1438        kfree_const(gdev->label);
1439err_free_descs:
1440        kfree(gdev->descs);
1441err_free_ida:
1442        ida_simple_remove(&gpio_ida, gdev->id);
1443err_free_gdev:
1444        /* failures here can mean systems won't boot... */
1445        pr_err("%s: GPIOs %d..%d (%s) failed to register, %d\n", __func__,
1446               gdev->base, gdev->base + gdev->ngpio - 1,
1447               chip->label ? : "generic", status);
1448        kfree(gdev);
1449        return status;
1450}
1451EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);
1452
1453/**
1454 * gpiochip_get_data() - get per-subdriver data for the chip
1455 * @chip: GPIO chip
1456 *
1457 * Returns:
1458 * The per-subdriver data for the chip.
1459 */
1460void *gpiochip_get_data(struct gpio_chip *chip)
1461{
1462        return chip->gpiodev->data;
1463}
1464EXPORT_SYMBOL_GPL(gpiochip_get_data);
1465
1466/**
1467 * gpiochip_remove() - unregister a gpio_chip
1468 * @chip: the chip to unregister
1469 *
1470 * A gpio_chip with any GPIOs still requested may not be removed.
1471 */
1472void gpiochip_remove(struct gpio_chip *chip)
1473{
1474        struct gpio_device *gdev = chip->gpiodev;
1475        struct gpio_desc *desc;
1476        unsigned long   flags;
1477        unsigned        i;
1478        bool            requested = false;
1479
1480        /* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1481        gpiochip_sysfs_unregister(gdev);
1482        gpiochip_free_hogs(chip);
1483        /* Numb the device, cancelling all outstanding operations */
1484        gdev->chip = NULL;
1485        gpiochip_irqchip_remove(chip);
1486        acpi_gpiochip_remove(chip);
1487        gpiochip_remove_pin_ranges(chip);
1488        of_gpiochip_remove(chip);
1489        gpiochip_free_valid_mask(chip);
1490        /*
1491         * We accept no more calls into the driver from this point, so
1492         * NULL the driver data pointer
1493         */
1494        gdev->data = NULL;
1495
1496        spin_lock_irqsave(&gpio_lock, flags);
1497        for (i = 0; i < gdev->ngpio; i++) {
1498                desc = &gdev->descs[i];
1499                if (test_bit(FLAG_REQUESTED, &desc->flags))
1500                        requested = true;
1501        }
1502        spin_unlock_irqrestore(&gpio_lock, flags);
1503
1504        if (requested)
1505                dev_crit(&gdev->dev,
1506                         "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
1507
1508        /*
1509         * The gpiochip side puts its use of the device to rest here:
1510         * if there are no userspace clients, the chardev and device will
1511         * be removed, else it will be dangling until the last user is
1512         * gone.
1513         */
1514        cdev_device_del(&gdev->chrdev, &gdev->dev);
1515        put_device(&gdev->dev);
1516}
1517EXPORT_SYMBOL_GPL(gpiochip_remove);
1518
1519static void devm_gpio_chip_release(struct device *dev, void *res)
1520{
1521        struct gpio_chip *chip = *(struct gpio_chip **)res;
1522
1523        gpiochip_remove(chip);
1524}
1525
1526/**
1527 * devm_gpiochip_add_data() - Resource manager gpiochip_add_data()
1528 * @dev: pointer to the device that gpio_chip belongs to.
1529 * @chip: the chip to register, with chip->base initialized
1530 * @data: driver-private data associated with this chip
1531 *
1532 * Context: potentially before irqs will work
1533 *
1534 * The gpio chip automatically be released when the device is unbound.
1535 *
1536 * Returns:
1537 * A negative errno if the chip can't be registered, such as because the
1538 * chip->base is invalid or already associated with a different chip.
1539 * Otherwise it returns zero as a success code.
1540 */
1541int devm_gpiochip_add_data(struct device *dev, struct gpio_chip *chip,
1542                           void *data)
1543{
1544        struct gpio_chip **ptr;
1545        int ret;
1546
1547        ptr = devres_alloc(devm_gpio_chip_release, sizeof(*ptr),
1548                             GFP_KERNEL);
1549        if (!ptr)
1550                return -ENOMEM;
1551
1552        ret = gpiochip_add_data(chip, data);
1553        if (ret < 0) {
1554                devres_free(ptr);
1555                return ret;
1556        }
1557
1558        *ptr = chip;
1559        devres_add(dev, ptr);
1560
1561        return 0;
1562}
1563EXPORT_SYMBOL_GPL(devm_gpiochip_add_data);
1564
1565/**
1566 * gpiochip_find() - iterator for locating a specific gpio_chip
1567 * @data: data to pass to match function
1568 * @match: Callback function to check gpio_chip
1569 *
1570 * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1571 * determined by a user supplied @match callback.  The callback should return
1572 * 0 if the device doesn't match and non-zero if it does.  If the callback is
1573 * non-zero, this function will return to the caller and not iterate over any
1574 * more gpio_chips.
1575 */
1576struct gpio_chip *gpiochip_find(void *data,
1577                                int (*match)(struct gpio_chip *chip,
1578                                             void *data))
1579{
1580        struct gpio_device *gdev;
1581        struct gpio_chip *chip = NULL;
1582        unsigned long flags;
1583
1584        spin_lock_irqsave(&gpio_lock, flags);
1585        list_for_each_entry(gdev, &gpio_devices, list)
1586                if (gdev->chip && match(gdev->chip, data)) {
1587                        chip = gdev->chip;
1588                        break;
1589                }
1590
1591        spin_unlock_irqrestore(&gpio_lock, flags);
1592
1593        return chip;
1594}
1595EXPORT_SYMBOL_GPL(gpiochip_find);
1596
1597static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1598{
1599        const char *name = data;
1600
1601        return !strcmp(chip->label, name);
1602}
1603
1604static struct gpio_chip *find_chip_by_name(const char *name)
1605{
1606        return gpiochip_find((void *)name, gpiochip_match_name);
1607}
1608
1609#ifdef CONFIG_GPIOLIB_IRQCHIP
1610
1611/*
1612 * The following is irqchip helper code for gpiochips.
1613 */
1614
1615static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
1616{
1617        if (!gpiochip->irq.need_valid_mask)
1618                return 0;
1619
1620        gpiochip->irq.valid_mask = gpiochip_allocate_mask(gpiochip);
1621        if (!gpiochip->irq.valid_mask)
1622                return -ENOMEM;
1623
1624        return 0;
1625}
1626
1627static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
1628{
1629        kfree(gpiochip->irq.valid_mask);
1630        gpiochip->irq.valid_mask = NULL;
1631}
1632
1633bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
1634                                unsigned int offset)
1635{
1636        if (!gpiochip_line_is_valid(gpiochip, offset))
1637                return false;
1638        /* No mask means all valid */
1639        if (likely(!gpiochip->irq.valid_mask))
1640                return true;
1641        return test_bit(offset, gpiochip->irq.valid_mask);
1642}
1643EXPORT_SYMBOL_GPL(gpiochip_irqchip_irq_valid);
1644
1645/**
1646 * gpiochip_set_cascaded_irqchip() - connects a cascaded irqchip to a gpiochip
1647 * @gpiochip: the gpiochip to set the irqchip chain to
1648 * @parent_irq: the irq number corresponding to the parent IRQ for this
1649 * chained irqchip
1650 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1651 * coming out of the gpiochip. If the interrupt is nested rather than
1652 * cascaded, pass NULL in this handler argument
1653 */
1654static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
1655                                          unsigned int parent_irq,
1656                                          irq_flow_handler_t parent_handler)
1657{
1658        if (!gpiochip->irq.domain) {
1659                chip_err(gpiochip, "called %s before setting up irqchip\n",
1660                         __func__);
1661                return;
1662        }
1663
1664        if (parent_handler) {
1665                if (gpiochip->can_sleep) {
1666                        chip_err(gpiochip,
1667                                 "you cannot have chained interrupts on a chip that may sleep\n");
1668                        return;
1669                }
1670                /*
1671                 * The parent irqchip is already using the chip_data for this
1672                 * irqchip, so our callbacks simply use the handler_data.
1673                 */
1674                irq_set_chained_handler_and_data(parent_irq, parent_handler,
1675                                                 gpiochip);
1676
1677                gpiochip->irq.parent_irq = parent_irq;
1678                gpiochip->irq.parents = &gpiochip->irq.parent_irq;
1679                gpiochip->irq.num_parents = 1;
1680        }
1681}
1682
1683/**
1684 * gpiochip_set_chained_irqchip() - connects a chained irqchip to a gpiochip
1685 * @gpiochip: the gpiochip to set the irqchip chain to
1686 * @irqchip: the irqchip to chain to the gpiochip
1687 * @parent_irq: the irq number corresponding to the parent IRQ for this
1688 * chained irqchip
1689 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1690 * coming out of the gpiochip.
1691 */
1692void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
1693                                  struct irq_chip *irqchip,
1694                                  unsigned int parent_irq,
1695                                  irq_flow_handler_t parent_handler)
1696{
1697        if (gpiochip->irq.threaded) {
1698                chip_err(gpiochip, "tried to chain a threaded gpiochip\n");
1699                return;
1700        }
1701
1702        gpiochip_set_cascaded_irqchip(gpiochip, parent_irq, parent_handler);
1703}
1704EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);
1705
1706/**
1707 * gpiochip_set_nested_irqchip() - connects a nested irqchip to a gpiochip
1708 * @gpiochip: the gpiochip to set the irqchip nested handler to
1709 * @irqchip: the irqchip to nest to the gpiochip
1710 * @parent_irq: the irq number corresponding to the parent IRQ for this
1711 * nested irqchip
1712 */
1713void gpiochip_set_nested_irqchip(struct gpio_chip *gpiochip,
1714                                 struct irq_chip *irqchip,
1715                                 unsigned int parent_irq)
1716{
1717        gpiochip_set_cascaded_irqchip(gpiochip, parent_irq, NULL);
1718}
1719EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);
1720
1721/**
1722 * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
1723 * @d: the irqdomain used by this irqchip
1724 * @irq: the global irq number used by this GPIO irqchip irq
1725 * @hwirq: the local IRQ/GPIO line offset on this gpiochip
1726 *
1727 * This function will set up the mapping for a certain IRQ line on a
1728 * gpiochip by assigning the gpiochip as chip data, and using the irqchip
1729 * stored inside the gpiochip.
1730 */
1731int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
1732                     irq_hw_number_t hwirq)
1733{
1734        struct gpio_chip *chip = d->host_data;
1735        int err = 0;
1736
1737        if (!gpiochip_irqchip_irq_valid(chip, hwirq))
1738                return -ENXIO;
1739
1740        irq_set_chip_data(irq, chip);
1741        /*
1742         * This lock class tells lockdep that GPIO irqs are in a different
1743         * category than their parents, so it won't report false recursion.
1744         */
1745        irq_set_lockdep_class(irq, chip->irq.lock_key, chip->irq.request_key);
1746        irq_set_chip_and_handler(irq, chip->irq.chip, chip->irq.handler);
1747        /* Chips that use nested thread handlers have them marked */
1748        if (chip->irq.threaded)
1749                irq_set_nested_thread(irq, 1);
1750        irq_set_noprobe(irq);
1751
1752        if (chip->irq.num_parents == 1)
1753                err = irq_set_parent(irq, chip->irq.parents[0]);
1754        else if (chip->irq.map)
1755                err = irq_set_parent(irq, chip->irq.map[hwirq]);
1756
1757        if (err < 0)
1758                return err;
1759
1760        /*
1761         * No set-up of the hardware will happen if IRQ_TYPE_NONE
1762         * is passed as default type.
1763         */
1764        if (chip->irq.default_type != IRQ_TYPE_NONE)
1765                irq_set_irq_type(irq, chip->irq.default_type);
1766
1767        return 0;
1768}
1769EXPORT_SYMBOL_GPL(gpiochip_irq_map);
1770
1771void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
1772{
1773        struct gpio_chip *chip = d->host_data;
1774
1775        if (chip->irq.threaded)
1776                irq_set_nested_thread(irq, 0);
1777        irq_set_chip_and_handler(irq, NULL, NULL);
1778        irq_set_chip_data(irq, NULL);
1779}
1780EXPORT_SYMBOL_GPL(gpiochip_irq_unmap);
1781
1782static const struct irq_domain_ops gpiochip_domain_ops = {
1783        .map    = gpiochip_irq_map,
1784        .unmap  = gpiochip_irq_unmap,
1785        /* Virtually all GPIO irqchips are twocell:ed */
1786        .xlate  = irq_domain_xlate_twocell,
1787};
1788
1789/**
1790 * gpiochip_irq_domain_activate() - Lock a GPIO to be used as an IRQ
1791 * @domain: The IRQ domain used by this IRQ chip
1792 * @data: Outermost irq_data associated with the IRQ
1793 * @reserve: If set, only reserve an interrupt vector instead of assigning one
1794 *
1795 * This function is a wrapper that calls gpiochip_lock_as_irq() and is to be
1796 * used as the activate function for the &struct irq_domain_ops. The host_data
1797 * for the IRQ domain must be the &struct gpio_chip.
1798 */
1799int gpiochip_irq_domain_activate(struct irq_domain *domain,
1800                                 struct irq_data *data, bool reserve)
1801{
1802        struct gpio_chip *chip = domain->host_data;
1803
1804        return gpiochip_lock_as_irq(chip, data->hwirq);
1805}
1806EXPORT_SYMBOL_GPL(gpiochip_irq_domain_activate);
1807
1808/**
1809 * gpiochip_irq_domain_deactivate() - Unlock a GPIO used as an IRQ
1810 * @domain: The IRQ domain used by this IRQ chip
1811 * @data: Outermost irq_data associated with the IRQ
1812 *
1813 * This function is a wrapper that will call gpiochip_unlock_as_irq() and is to
1814 * be used as the deactivate function for the &struct irq_domain_ops. The
1815 * host_data for the IRQ domain must be the &struct gpio_chip.
1816 */
1817void gpiochip_irq_domain_deactivate(struct irq_domain *domain,
1818                                    struct irq_data *data)
1819{
1820        struct gpio_chip *chip = domain->host_data;
1821
1822        return gpiochip_unlock_as_irq(chip, data->hwirq);
1823}
1824EXPORT_SYMBOL_GPL(gpiochip_irq_domain_deactivate);
1825
1826static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
1827{
1828        if (!gpiochip_irqchip_irq_valid(chip, offset))
1829                return -ENXIO;
1830
1831        return irq_create_mapping(chip->irq.domain, offset);
1832}
1833
1834static int gpiochip_irq_reqres(struct irq_data *d)
1835{
1836        struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1837
1838        return gpiochip_reqres_irq(chip, d->hwirq);
1839}
1840
1841static void gpiochip_irq_relres(struct irq_data *d)
1842{
1843        struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1844
1845        gpiochip_relres_irq(chip, d->hwirq);
1846}
1847
1848static void gpiochip_irq_enable(struct irq_data *d)
1849{
1850        struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1851
1852        gpiochip_enable_irq(chip, d->hwirq);
1853        if (chip->irq.irq_enable)
1854                chip->irq.irq_enable(d);
1855        else
1856                chip->irq.chip->irq_unmask(d);
1857}
1858
1859static void gpiochip_irq_disable(struct irq_data *d)
1860{
1861        struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1862
1863        if (chip->irq.irq_disable)
1864                chip->irq.irq_disable(d);
1865        else
1866                chip->irq.chip->irq_mask(d);
1867        gpiochip_disable_irq(chip, d->hwirq);
1868}
1869
1870static void gpiochip_set_irq_hooks(struct gpio_chip *gpiochip)
1871{
1872        struct irq_chip *irqchip = gpiochip->irq.chip;
1873
1874        if (!irqchip->irq_request_resources &&
1875            !irqchip->irq_release_resources) {
1876                irqchip->irq_request_resources = gpiochip_irq_reqres;
1877                irqchip->irq_release_resources = gpiochip_irq_relres;
1878        }
1879        if (WARN_ON(gpiochip->irq.irq_enable))
1880                return;
1881        /* Check if the irqchip already has this hook... */
1882        if (irqchip->irq_enable == gpiochip_irq_enable) {
1883                /*
1884                 * ...and if so, give a gentle warning that this is bad
1885                 * practice.
1886                 */
1887                chip_info(gpiochip,
1888                          "detected irqchip that is shared with multiple gpiochips: please fix the driver.\n");
1889                return;
1890        }
1891        gpiochip->irq.irq_enable = irqchip->irq_enable;
1892        gpiochip->irq.irq_disable = irqchip->irq_disable;
1893        irqchip->irq_enable = gpiochip_irq_enable;
1894        irqchip->irq_disable = gpiochip_irq_disable;
1895}
1896
1897/**
1898 * gpiochip_add_irqchip() - adds an IRQ chip to a GPIO chip
1899 * @gpiochip: the GPIO chip to add the IRQ chip to
1900 * @lock_key: lockdep class for IRQ lock
1901 * @request_key: lockdep class for IRQ request
1902 */
1903static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
1904                                struct lock_class_key *lock_key,
1905                                struct lock_class_key *request_key)
1906{
1907        struct irq_chip *irqchip = gpiochip->irq.chip;
1908        const struct irq_domain_ops *ops;
1909        struct device_node *np;
1910        unsigned int type;
1911        unsigned int i;
1912
1913        if (!irqchip)
1914                return 0;
1915
1916        if (gpiochip->irq.parent_handler && gpiochip->can_sleep) {
1917                chip_err(gpiochip, "you cannot have chained interrupts on a chip that may sleep\n");
1918                return -EINVAL;
1919        }
1920
1921        np = gpiochip->gpiodev->dev.of_node;
1922        type = gpiochip->irq.default_type;
1923
1924        /*
1925         * Specifying a default trigger is a terrible idea if DT or ACPI is
1926         * used to configure the interrupts, as you may end up with
1927         * conflicting triggers. Tell the user, and reset to NONE.
1928         */
1929        if (WARN(np && type != IRQ_TYPE_NONE,
1930                 "%s: Ignoring %u default trigger\n", np->full_name, type))
1931                type = IRQ_TYPE_NONE;
1932
1933        if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
1934                acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
1935                                 "Ignoring %u default trigger\n", type);
1936                type = IRQ_TYPE_NONE;
1937        }
1938
1939        gpiochip->to_irq = gpiochip_to_irq;
1940        gpiochip->irq.default_type = type;
1941        gpiochip->irq.lock_key = lock_key;
1942        gpiochip->irq.request_key = request_key;
1943
1944        if (gpiochip->irq.domain_ops)
1945                ops = gpiochip->irq.domain_ops;
1946        else
1947                ops = &gpiochip_domain_ops;
1948
1949        gpiochip->irq.domain = irq_domain_add_simple(np, gpiochip->ngpio,
1950                                                     gpiochip->irq.first,
1951                                                     ops, gpiochip);
1952        if (!gpiochip->irq.domain)
1953                return -EINVAL;
1954
1955        if (gpiochip->irq.parent_handler) {
1956                void *data = gpiochip->irq.parent_handler_data ?: gpiochip;
1957
1958                for (i = 0; i < gpiochip->irq.num_parents; i++) {
1959                        /*
1960                         * The parent IRQ chip is already using the chip_data
1961                         * for this IRQ chip, so our callbacks simply use the
1962                         * handler_data.
1963                         */
1964                        irq_set_chained_handler_and_data(gpiochip->irq.parents[i],
1965                                                         gpiochip->irq.parent_handler,
1966                                                         data);
1967                }
1968        }
1969
1970        gpiochip_set_irq_hooks(gpiochip);
1971
1972        acpi_gpiochip_request_interrupts(gpiochip);
1973
1974        return 0;
1975}
1976
1977/**
1978 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
1979 * @gpiochip: the gpiochip to remove the irqchip from
1980 *
1981 * This is called only from gpiochip_remove()
1982 */
1983static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
1984{
1985        struct irq_chip *irqchip = gpiochip->irq.chip;
1986        unsigned int offset;
1987
1988        acpi_gpiochip_free_interrupts(gpiochip);
1989
1990        if (irqchip && gpiochip->irq.parent_handler) {
1991                struct gpio_irq_chip *irq = &gpiochip->irq;
1992                unsigned int i;
1993
1994                for (i = 0; i < irq->num_parents; i++)
1995                        irq_set_chained_handler_and_data(irq->parents[i],
1996                                                         NULL, NULL);
1997        }
1998
1999        /* Remove all IRQ mappings and delete the domain */
2000        if (gpiochip->irq.domain) {
2001                unsigned int irq;
2002
2003                for (offset = 0; offset < gpiochip->ngpio; offset++) {
2004                        if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
2005                                continue;
2006
2007                        irq = irq_find_mapping(gpiochip->irq.domain, offset);
2008                        irq_dispose_mapping(irq);
2009                }
2010
2011                irq_domain_remove(gpiochip->irq.domain);
2012        }
2013
2014        if (irqchip) {
2015                if (irqchip->irq_request_resources == gpiochip_irq_reqres) {
2016                        irqchip->irq_request_resources = NULL;
2017                        irqchip->irq_release_resources = NULL;
2018                }
2019                if (irqchip->irq_enable == gpiochip_irq_enable) {
2020                        irqchip->irq_enable = gpiochip->irq.irq_enable;
2021                        irqchip->irq_disable = gpiochip->irq.irq_disable;
2022                }
2023        }
2024        gpiochip->irq.irq_enable = NULL;
2025        gpiochip->irq.irq_disable = NULL;
2026        gpiochip->irq.chip = NULL;
2027
2028        gpiochip_irqchip_free_valid_mask(gpiochip);
2029}
2030
2031/**
2032 * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
2033 * @gpiochip: the gpiochip to add the irqchip to
2034 * @irqchip: the irqchip to add to the gpiochip
2035 * @first_irq: if not dynamically assigned, the base (first) IRQ to
2036 * allocate gpiochip irqs from
2037 * @handler: the irq handler to use (often a predefined irq core function)
2038 * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
2039 * to have the core avoid setting up any default type in the hardware.
2040 * @threaded: whether this irqchip uses a nested thread handler
2041 * @lock_key: lockdep class for IRQ lock
2042 * @request_key: lockdep class for IRQ request
2043 *
2044 * This function closely associates a certain irqchip with a certain
2045 * gpiochip, providing an irq domain to translate the local IRQs to
2046 * global irqs in the gpiolib core, and making sure that the gpiochip
2047 * is passed as chip data to all related functions. Driver callbacks
2048 * need to use gpiochip_get_data() to get their local state containers back
2049 * from the gpiochip passed as chip data. An irqdomain will be stored
2050 * in the gpiochip that shall be used by the driver to handle IRQ number
2051 * translation. The gpiochip will need to be initialized and registered
2052 * before calling this function.
2053 *
2054 * This function will handle two cell:ed simple IRQs and assumes all
2055 * the pins on the gpiochip can generate a unique IRQ. Everything else
2056 * need to be open coded.
2057 */
2058int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
2059                             struct irq_chip *irqchip,
2060                             unsigned int first_irq,
2061                             irq_flow_handler_t handler,
2062                             unsigned int type,
2063                             bool threaded,
2064                             struct lock_class_key *lock_key,
2065                             struct lock_class_key *request_key)
2066{
2067        struct device_node *of_node;
2068
2069        if (!gpiochip || !irqchip)
2070                return -EINVAL;
2071
2072        if (!gpiochip->parent) {
2073                pr_err("missing gpiochip .dev parent pointer\n");
2074                return -EINVAL;
2075        }
2076        gpiochip->irq.threaded = threaded;
2077        of_node = gpiochip->parent->of_node;
2078#ifdef CONFIG_OF_GPIO
2079        /*
2080         * If the gpiochip has an assigned OF node this takes precedence
2081         * FIXME: get rid of this and use gpiochip->parent->of_node
2082         * everywhere
2083         */
2084        if (gpiochip->of_node)
2085                of_node = gpiochip->of_node;
2086#endif
2087        /*
2088         * Specifying a default trigger is a terrible idea if DT or ACPI is
2089         * used to configure the interrupts, as you may end-up with
2090         * conflicting triggers. Tell the user, and reset to NONE.
2091         */
2092        if (WARN(of_node && type != IRQ_TYPE_NONE,
2093                 "%pOF: Ignoring %d default trigger\n", of_node, type))
2094                type = IRQ_TYPE_NONE;
2095        if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
2096                acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
2097                                 "Ignoring %d default trigger\n", type);
2098                type = IRQ_TYPE_NONE;
2099        }
2100
2101        gpiochip->irq.chip = irqchip;
2102        gpiochip->irq.handler = handler;
2103        gpiochip->irq.default_type = type;
2104        gpiochip->to_irq = gpiochip_to_irq;
2105        gpiochip->irq.lock_key = lock_key;
2106        gpiochip->irq.request_key = request_key;
2107        gpiochip->irq.domain = irq_domain_add_simple(of_node,
2108                                        gpiochip->ngpio, first_irq,
2109                                        &gpiochip_domain_ops, gpiochip);
2110        if (!gpiochip->irq.domain) {
2111                gpiochip->irq.chip = NULL;
2112                return -EINVAL;
2113        }
2114
2115        gpiochip_set_irq_hooks(gpiochip);
2116
2117        acpi_gpiochip_request_interrupts(gpiochip);
2118
2119        return 0;
2120}
2121EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
2122
2123#else /* CONFIG_GPIOLIB_IRQCHIP */
2124
2125static inline int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
2126                                       struct lock_class_key *lock_key,
2127                                       struct lock_class_key *request_key)
2128{
2129        return 0;
2130}
2131
2132static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
2133static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
2134{
2135        return 0;
2136}
2137static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
2138{ }
2139
2140#endif /* CONFIG_GPIOLIB_IRQCHIP */
2141
2142/**
2143 * gpiochip_generic_request() - request the gpio function for a pin
2144 * @chip: the gpiochip owning the GPIO
2145 * @offset: the offset of the GPIO to request for GPIO function
2146 */
2147int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
2148{
2149        return pinctrl_gpio_request(chip->gpiodev->base + offset);
2150}
2151EXPORT_SYMBOL_GPL(gpiochip_generic_request);
2152
2153/**
2154 * gpiochip_generic_free() - free the gpio function from a pin
2155 * @chip: the gpiochip to request the gpio function for
2156 * @offset: the offset of the GPIO to free from GPIO function
2157 */
2158void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset)
2159{
2160        pinctrl_gpio_free(chip->gpiodev->base + offset);
2161}
2162EXPORT_SYMBOL_GPL(gpiochip_generic_free);
2163
2164/**
2165 * gpiochip_generic_config() - apply configuration for a pin
2166 * @chip: the gpiochip owning the GPIO
2167 * @offset: the offset of the GPIO to apply the configuration
2168 * @config: the configuration to be applied
2169 */
2170int gpiochip_generic_config(struct gpio_chip *chip, unsigned offset,
2171                            unsigned long config)
2172{
2173        return pinctrl_gpio_set_config(chip->gpiodev->base + offset, config);
2174}
2175EXPORT_SYMBOL_GPL(gpiochip_generic_config);
2176
2177#ifdef CONFIG_PINCTRL
2178
2179/**
2180 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
2181 * @chip: the gpiochip to add the range for
2182 * @pctldev: the pin controller to map to
2183 * @gpio_offset: the start offset in the current gpio_chip number space
2184 * @pin_group: name of the pin group inside the pin controller
2185 *
2186 * Calling this function directly from a DeviceTree-supported
2187 * pinctrl driver is DEPRECATED. Please see Section 2.1 of
2188 * Documentation/devicetree/bindings/gpio/gpio.txt on how to
2189 * bind pinctrl and gpio drivers via the "gpio-ranges" property.
2190 */
2191int gpiochip_add_pingroup_range(struct gpio_chip *chip,
2192                        struct pinctrl_dev *pctldev,
2193                        unsigned int gpio_offset, const char *pin_group)
2194{
2195        struct gpio_pin_range *pin_range;
2196        struct gpio_device *gdev = chip->gpiodev;
2197        int ret;
2198
2199        pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2200        if (!pin_range) {
2201                chip_err(chip, "failed to allocate pin ranges\n");
2202                return -ENOMEM;
2203        }
2204
2205        /* Use local offset as range ID */
2206        pin_range->range.id = gpio_offset;
2207        pin_range->range.gc = chip;
2208        pin_range->range.name = chip->label;
2209        pin_range->range.base = gdev->base + gpio_offset;
2210        pin_range->pctldev = pctldev;
2211
2212        ret = pinctrl_get_group_pins(pctldev, pin_group,
2213                                        &pin_range->range.pins,
2214                                        &pin_range->range.npins);
2215        if (ret < 0) {
2216                kfree(pin_range);
2217                return ret;
2218        }
2219
2220        pinctrl_add_gpio_range(pctldev, &pin_range->range);
2221
2222        chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
2223                 gpio_offset, gpio_offset + pin_range->range.npins - 1,
2224                 pinctrl_dev_get_devname(pctldev), pin_group);
2225
2226        list_add_tail(&pin_range->node, &gdev->pin_ranges);
2227
2228        return 0;
2229}
2230EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
2231
2232/**
2233 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
2234 * @chip: the gpiochip to add the range for
2235 * @pinctl_name: the dev_name() of the pin controller to map to
2236 * @gpio_offset: the start offset in the current gpio_chip number space
2237 * @pin_offset: the start offset in the pin controller number space
2238 * @npins: the number of pins from the offset of each pin space (GPIO and
2239 *      pin controller) to accumulate in this range
2240 *
2241 * Returns:
2242 * 0 on success, or a negative error-code on failure.
2243 *
2244 * Calling this function directly from a DeviceTree-supported
2245 * pinctrl driver is DEPRECATED. Please see Section 2.1 of
2246 * Documentation/devicetree/bindings/gpio/gpio.txt on how to
2247 * bind pinctrl and gpio drivers via the "gpio-ranges" property.
2248 */
2249int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
2250                           unsigned int gpio_offset, unsigned int pin_offset,
2251                           unsigned int npins)
2252{
2253        struct gpio_pin_range *pin_range;
2254        struct gpio_device *gdev = chip->gpiodev;
2255        int ret;
2256
2257        pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2258        if (!pin_range) {
2259                chip_err(chip, "failed to allocate pin ranges\n");
2260                return -ENOMEM;
2261        }
2262
2263        /* Use local offset as range ID */
2264        pin_range->range.id = gpio_offset;
2265        pin_range->range.gc = chip;
2266        pin_range->range.name = chip->label;
2267        pin_range->range.base = gdev->base + gpio_offset;
2268        pin_range->range.pin_base = pin_offset;
2269        pin_range->range.npins = npins;
2270        pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
2271                        &pin_range->range);
2272        if (IS_ERR(pin_range->pctldev)) {
2273                ret = PTR_ERR(pin_range->pctldev);
2274                chip_err(chip, "could not create pin range\n");
2275                kfree(pin_range);
2276                return ret;
2277        }
2278        chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
2279                 gpio_offset, gpio_offset + npins - 1,
2280                 pinctl_name,
2281                 pin_offset, pin_offset + npins - 1);
2282
2283        list_add_tail(&pin_range->node, &gdev->pin_ranges);
2284
2285        return 0;
2286}
2287EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
2288
2289/**
2290 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
2291 * @chip: the chip to remove all the mappings for
2292 */
2293void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
2294{
2295        struct gpio_pin_range *pin_range, *tmp;
2296        struct gpio_device *gdev = chip->gpiodev;
2297
2298        list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2299                list_del(&pin_range->node);
2300                pinctrl_remove_gpio_range(pin_range->pctldev,
2301                                &pin_range->range);
2302                kfree(pin_range);
2303        }
2304}
2305EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
2306
2307#endif /* CONFIG_PINCTRL */
2308
2309/* These "optional" allocation calls help prevent drivers from stomping
2310 * on each other, and help provide better diagnostics in debugfs.
2311 * They're called even less than the "set direction" calls.
2312 */
2313static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2314{
2315        struct gpio_chip        *chip = desc->gdev->chip;
2316        int                     status;
2317        unsigned long           flags;
2318        unsigned                offset;
2319
2320        if (label) {
2321                label = kstrdup_const(label, GFP_KERNEL);
2322                if (!label)
2323                        return -ENOMEM;
2324        }
2325
2326        spin_lock_irqsave(&gpio_lock, flags);
2327
2328        /* NOTE:  gpio_request() can be called in early boot,
2329         * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
2330         */
2331
2332        if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
2333                desc_set_label(desc, label ? : "?");
2334                status = 0;
2335        } else {
2336                kfree_const(label);
2337                status = -EBUSY;
2338                goto done;
2339        }
2340
2341        if (chip->request) {
2342                /* chip->request may sleep */
2343                spin_unlock_irqrestore(&gpio_lock, flags);
2344                offset = gpio_chip_hwgpio(desc);
2345                if (gpiochip_line_is_valid(chip, offset))
2346                        status = chip->request(chip, offset);
2347                else
2348                        status = -EINVAL;
2349                spin_lock_irqsave(&gpio_lock, flags);
2350
2351                if (status < 0) {
2352                        desc_set_label(desc, NULL);
2353                        kfree_const(label);
2354                        clear_bit(FLAG_REQUESTED, &desc->flags);
2355                        goto done;
2356                }
2357        }
2358        if (chip->get_direction) {
2359                /* chip->get_direction may sleep */
2360                spin_unlock_irqrestore(&gpio_lock, flags);
2361                gpiod_get_direction(desc);
2362                spin_lock_irqsave(&gpio_lock, flags);
2363        }
2364done:
2365        spin_unlock_irqrestore(&gpio_lock, flags);
2366        return status;
2367}
2368
2369/*
2370 * This descriptor validation needs to be inserted verbatim into each
2371 * function taking a descriptor, so we need to use a preprocessor
2372 * macro to avoid endless duplication. If the desc is NULL it is an
2373 * optional GPIO and calls should just bail out.
2374 */
2375static int validate_desc(const struct gpio_desc *desc, const char *func)
2376{
2377        if (!desc)
2378                return 0;
2379        if (IS_ERR(desc)) {
2380                pr_warn("%s: invalid GPIO (errorpointer)\n", func);
2381                return PTR_ERR(desc);
2382        }
2383        if (!desc->gdev) {
2384                pr_warn("%s: invalid GPIO (no device)\n", func);
2385                return -EINVAL;
2386        }
2387        if (!desc->gdev->chip) {
2388                dev_warn(&desc->gdev->dev,
2389                         "%s: backing chip is gone\n", func);
2390                return 0;
2391        }
2392        return 1;
2393}
2394
2395#define VALIDATE_DESC(desc) do { \
2396        int __valid = validate_desc(desc, __func__); \
2397        if (__valid <= 0) \
2398                return __valid; \
2399        } while (0)
2400
2401#define VALIDATE_DESC_VOID(desc) do { \
2402        int __valid = validate_desc(desc, __func__); \
2403        if (__valid <= 0) \
2404                return; \
2405        } while (0)
2406
2407int gpiod_request(struct gpio_desc *desc, const char *label)
2408{
2409        int status = -EPROBE_DEFER;
2410        struct gpio_device *gdev;
2411
2412        VALIDATE_DESC(desc);
2413        gdev = desc->gdev;
2414
2415        if (try_module_get(gdev->owner)) {
2416                status = gpiod_request_commit(desc, label);
2417                if (status < 0)
2418                        module_put(gdev->owner);
2419                else
2420                        get_device(&gdev->dev);
2421        }
2422
2423        if (status)
2424                gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2425
2426        return status;
2427}
2428
2429static bool gpiod_free_commit(struct gpio_desc *desc)
2430{
2431        bool                    ret = false;
2432        unsigned long           flags;
2433        struct gpio_chip        *chip;
2434
2435        might_sleep();
2436
2437        gpiod_unexport(desc);
2438
2439        spin_lock_irqsave(&gpio_lock, flags);
2440
2441        chip = desc->gdev->chip;
2442        if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
2443                if (chip->free) {
2444                        spin_unlock_irqrestore(&gpio_lock, flags);
2445                        might_sleep_if(chip->can_sleep);
2446                        chip->free(chip, gpio_chip_hwgpio(desc));
2447                        spin_lock_irqsave(&gpio_lock, flags);
2448                }
2449                kfree_const(desc->label);
2450                desc_set_label(desc, NULL);
2451                clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
2452                clear_bit(FLAG_REQUESTED, &desc->flags);
2453                clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2454                clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
2455                clear_bit(FLAG_IS_HOGGED, &desc->flags);
2456                ret = true;
2457        }
2458
2459        spin_unlock_irqrestore(&gpio_lock, flags);
2460        return ret;
2461}
2462
2463void gpiod_free(struct gpio_desc *desc)
2464{
2465        if (desc && desc->gdev && gpiod_free_commit(desc)) {
2466                module_put(desc->gdev->owner);
2467                put_device(&desc->gdev->dev);
2468        } else {
2469                WARN_ON(extra_checks);
2470        }
2471}
2472
2473/**
2474 * gpiochip_is_requested - return string iff signal was requested
2475 * @chip: controller managing the signal
2476 * @offset: of signal within controller's 0..(ngpio - 1) range
2477 *
2478 * Returns NULL if the GPIO is not currently requested, else a string.
2479 * The string returned is the label passed to gpio_request(); if none has been
2480 * passed it is a meaningless, non-NULL constant.
2481 *
2482 * This function is for use by GPIO controller drivers.  The label can
2483 * help with diagnostics, and knowing that the signal is used as a GPIO
2484 * can help avoid accidentally multiplexing it to another controller.
2485 */
2486const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
2487{
2488        struct gpio_desc *desc;
2489
2490        if (offset >= chip->ngpio)
2491                return NULL;
2492
2493        desc = &chip->gpiodev->descs[offset];
2494
2495        if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2496                return NULL;
2497        return desc->label;
2498}
2499EXPORT_SYMBOL_GPL(gpiochip_is_requested);
2500
2501/**
2502 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
2503 * @chip: GPIO chip
2504 * @hwnum: hardware number of the GPIO for which to request the descriptor
2505 * @label: label for the GPIO
2506 * @flags: flags for this GPIO or 0 if default
2507 *
2508 * Function allows GPIO chip drivers to request and use their own GPIO
2509 * descriptors via gpiolib API. Difference to gpiod_request() is that this
2510 * function will not increase reference count of the GPIO chip module. This
2511 * allows the GPIO chip module to be unloaded as needed (we assume that the
2512 * GPIO chip driver handles freeing the GPIOs it has requested).
2513 *
2514 * Returns:
2515 * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error
2516 * code on failure.
2517 */
2518struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
2519                                            const char *label,
2520                                            enum gpiod_flags flags)
2521{
2522        struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
2523        int err;
2524
2525        if (IS_ERR(desc)) {
2526                chip_err(chip, "failed to get GPIO descriptor\n");
2527                return desc;
2528        }
2529
2530        err = gpiod_request_commit(desc, label);
2531        if (err < 0)
2532                return ERR_PTR(err);
2533
2534        err = gpiod_configure_flags(desc, label, 0, flags);
2535        if (err) {
2536                chip_err(chip, "setup of own GPIO %s failed\n", label);
2537                gpiod_free_commit(desc);
2538                return ERR_PTR(err);
2539        }
2540
2541        return desc;
2542}
2543EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2544
2545/**
2546 * gpiochip_free_own_desc - Free GPIO requested by the chip driver
2547 * @desc: GPIO descriptor to free
2548 *
2549 * Function frees the given GPIO requested previously with
2550 * gpiochip_request_own_desc().
2551 */
2552void gpiochip_free_own_desc(struct gpio_desc *desc)
2553{
2554        if (desc)
2555                gpiod_free_commit(desc);
2556}
2557EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2558
2559/*
2560 * Drivers MUST set GPIO direction before making get/set calls.  In
2561 * some cases this is done in early boot, before IRQs are enabled.
2562 *
2563 * As a rule these aren't called more than once (except for drivers
2564 * using the open-drain emulation idiom) so these are natural places
2565 * to accumulate extra debugging checks.  Note that we can't (yet)
2566 * rely on gpio_request() having been called beforehand.
2567 */
2568
2569static int gpio_set_config(struct gpio_chip *gc, unsigned offset,
2570                           enum pin_config_param mode)
2571{
2572        unsigned long config = { PIN_CONF_PACKED(mode, 0) };
2573
2574        return gc->set_config ? gc->set_config(gc, offset, config) : -ENOTSUPP;
2575}
2576
2577/**
2578 * gpiod_direction_input - set the GPIO direction to input
2579 * @desc:       GPIO to set to input
2580 *
2581 * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
2582 * be called safely on it.
2583 *
2584 * Return 0 in case of success, else an error code.
2585 */
2586int gpiod_direction_input(struct gpio_desc *desc)
2587{
2588        struct gpio_chip        *chip;
2589        int                     status = 0;
2590
2591        VALIDATE_DESC(desc);
2592        chip = desc->gdev->chip;
2593
2594        /*
2595         * It is legal to have no .get() and .direction_input() specified if
2596         * the chip is output-only, but you can't specify .direction_input()
2597         * and not support the .get() operation, that doesn't make sense.
2598         */
2599        if (!chip->get && chip->direction_input) {
2600                gpiod_warn(desc,
2601                           "%s: missing get() but have direction_input()\n",
2602                           __func__);
2603                return -EIO;
2604        }
2605
2606        /*
2607         * If we have a .direction_input() callback, things are simple,
2608         * just call it. Else we are some input-only chip so try to check the
2609         * direction (if .get_direction() is supported) else we silently
2610         * assume we are in input mode after this.
2611         */
2612        if (chip->direction_input) {
2613                status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2614        } else if (chip->get_direction &&
2615                  (chip->get_direction(chip, gpio_chip_hwgpio(desc)) != 1)) {
2616                gpiod_warn(desc,
2617                           "%s: missing direction_input() operation and line is output\n",
2618                           __func__);
2619                return -EIO;
2620        }
2621        if (status == 0)
2622                clear_bit(FLAG_IS_OUT, &desc->flags);
2623
2624        if (test_bit(FLAG_PULL_UP, &desc->flags))
2625                gpio_set_config(chip, gpio_chip_hwgpio(desc),
2626                                PIN_CONFIG_BIAS_PULL_UP);
2627        else if (test_bit(FLAG_PULL_DOWN, &desc->flags))
2628                gpio_set_config(chip, gpio_chip_hwgpio(desc),
2629                                PIN_CONFIG_BIAS_PULL_DOWN);
2630
2631        trace_gpio_direction(desc_to_gpio(desc), 1, status);
2632
2633        return status;
2634}
2635EXPORT_SYMBOL_GPL(gpiod_direction_input);
2636
2637static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
2638{
2639        struct gpio_chip *gc = desc->gdev->chip;
2640        int val = !!value;
2641        int ret = 0;
2642
2643        /*
2644         * It's OK not to specify .direction_output() if the gpiochip is
2645         * output-only, but if there is then not even a .set() operation it
2646         * is pretty tricky to drive the output line.
2647         */
2648        if (!gc->set && !gc->direction_output) {
2649                gpiod_warn(desc,
2650                           "%s: missing set() and direction_output() operations\n",
2651                           __func__);
2652                return -EIO;
2653        }
2654
2655        if (gc->direction_output) {
2656                ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
2657        } else {
2658                /* Check that we are in output mode if we can */
2659                if (gc->get_direction &&
2660                    gc->get_direction(gc, gpio_chip_hwgpio(desc))) {
2661                        gpiod_warn(desc,
2662                                "%s: missing direction_output() operation\n",
2663                                __func__);
2664                        return -EIO;
2665                }
2666                /*
2667                 * If we can't actively set the direction, we are some
2668                 * output-only chip, so just drive the output as desired.
2669                 */
2670                gc->set(gc, gpio_chip_hwgpio(desc), val);
2671        }
2672
2673        if (!ret)
2674                set_bit(FLAG_IS_OUT, &desc->flags);
2675        trace_gpio_value(desc_to_gpio(desc), 0, val);
2676        trace_gpio_direction(desc_to_gpio(desc), 0, ret);
2677        return ret;
2678}
2679
2680/**
2681 * gpiod_direction_output_raw - set the GPIO direction to output
2682 * @desc:       GPIO to set to output
2683 * @value:      initial output value of the GPIO
2684 *
2685 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2686 * be called safely on it. The initial value of the output must be specified
2687 * as raw value on the physical line without regard for the ACTIVE_LOW status.
2688 *
2689 * Return 0 in case of success, else an error code.
2690 */
2691int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2692{
2693        VALIDATE_DESC(desc);
2694        return gpiod_direction_output_raw_commit(desc, value);
2695}
2696EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
2697
2698/**
2699 * gpiod_direction_output - set the GPIO direction to output
2700 * @desc:       GPIO to set to output
2701 * @value:      initial output value of the GPIO
2702 *
2703 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2704 * be called safely on it. The initial value of the output must be specified
2705 * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2706 * account.
2707 *
2708 * Return 0 in case of success, else an error code.
2709 */
2710int gpiod_direction_output(struct gpio_desc *desc, int value)
2711{
2712        struct gpio_chip *gc;
2713        int ret;
2714
2715        VALIDATE_DESC(desc);
2716        if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2717                value = !value;
2718        else
2719                value = !!value;
2720
2721        /* GPIOs used for enabled IRQs shall not be set as output */
2722        if (test_bit(FLAG_USED_AS_IRQ, &desc->flags) &&
2723            test_bit(FLAG_IRQ_IS_ENABLED, &desc->flags)) {
2724                gpiod_err(desc,
2725                          "%s: tried to set a GPIO tied to an IRQ as output\n",
2726                          __func__);
2727                return -EIO;
2728        }
2729
2730        gc = desc->gdev->chip;
2731        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
2732                /* First see if we can enable open drain in hardware */
2733                ret = gpio_set_config(gc, gpio_chip_hwgpio(desc),
2734                                      PIN_CONFIG_DRIVE_OPEN_DRAIN);
2735                if (!ret)
2736                        goto set_output_value;
2737                /* Emulate open drain by not actively driving the line high */
2738                if (value)
2739                        return gpiod_direction_input(desc);
2740        }
2741        else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
2742                ret = gpio_set_config(gc, gpio_chip_hwgpio(desc),
2743                                      PIN_CONFIG_DRIVE_OPEN_SOURCE);
2744                if (!ret)
2745                        goto set_output_value;
2746                /* Emulate open source by not actively driving the line low */
2747                if (!value)
2748                        return gpiod_direction_input(desc);
2749        } else {
2750                gpio_set_config(gc, gpio_chip_hwgpio(desc),
2751                                PIN_CONFIG_DRIVE_PUSH_PULL);
2752        }
2753
2754set_output_value:
2755        return gpiod_direction_output_raw_commit(desc, value);
2756}
2757EXPORT_SYMBOL_GPL(gpiod_direction_output);
2758
2759/**
2760 * gpiod_set_debounce - sets @debounce time for a GPIO
2761 * @desc: descriptor of the GPIO for which to set debounce time
2762 * @debounce: debounce time in microseconds
2763 *
2764 * Returns:
2765 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
2766 * debounce time.
2767 */
2768int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2769{
2770        struct gpio_chip        *chip;
2771        unsigned long           config;
2772
2773        VALIDATE_DESC(desc);
2774        chip = desc->gdev->chip;
2775        if (!chip->set || !chip->set_config) {
2776                gpiod_dbg(desc,
2777                          "%s: missing set() or set_config() operations\n",
2778                          __func__);
2779                return -ENOTSUPP;
2780        }
2781
2782        config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
2783        return chip->set_config(chip, gpio_chip_hwgpio(desc), config);
2784}
2785EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2786
2787/**
2788 * gpiod_set_transitory - Lose or retain GPIO state on suspend or reset
2789 * @desc: descriptor of the GPIO for which to configure persistence
2790 * @transitory: True to lose state on suspend or reset, false for persistence
2791 *
2792 * Returns:
2793 * 0 on success, otherwise a negative error code.
2794 */
2795int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
2796{
2797        struct gpio_chip *chip;
2798        unsigned long packed;
2799        int gpio;
2800        int rc;
2801
2802        VALIDATE_DESC(desc);
2803        /*
2804         * Handle FLAG_TRANSITORY first, enabling queries to gpiolib for
2805         * persistence state.
2806         */
2807        if (transitory)
2808                set_bit(FLAG_TRANSITORY, &desc->flags);
2809        else
2810                clear_bit(FLAG_TRANSITORY, &desc->flags);
2811
2812        /* If the driver supports it, set the persistence state now */
2813        chip = desc->gdev->chip;
2814        if (!chip->set_config)
2815                return 0;
2816
2817        packed = pinconf_to_config_packed(PIN_CONFIG_PERSIST_STATE,
2818                                          !transitory);
2819        gpio = gpio_chip_hwgpio(desc);
2820        rc = chip->set_config(chip, gpio, packed);
2821        if (rc == -ENOTSUPP) {
2822                dev_dbg(&desc->gdev->dev, "Persistence not supported for GPIO %d\n",
2823                                gpio);
2824                return 0;
2825        }
2826
2827        return rc;
2828}
2829EXPORT_SYMBOL_GPL(gpiod_set_transitory);
2830
2831/**
2832 * gpiod_is_active_low - test whether a GPIO is active-low or not
2833 * @desc: the gpio descriptor to test
2834 *
2835 * Returns 1 if the GPIO is active-low, 0 otherwise.
2836 */
2837int gpiod_is_active_low(const struct gpio_desc *desc)
2838{
2839        VALIDATE_DESC(desc);
2840        return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2841}
2842EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2843
2844/* I/O calls are only valid after configuration completed; the relevant
2845 * "is this a valid GPIO" error checks should already have been done.
2846 *
2847 * "Get" operations are often inlinable as reading a pin value register,
2848 * and masking the relevant bit in that register.
2849 *
2850 * When "set" operations are inlinable, they involve writing that mask to
2851 * one register to set a low value, or a different register to set it high.
2852 * Otherwise locking is needed, so there may be little value to inlining.
2853 *
2854 *------------------------------------------------------------------------
2855 *
2856 * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
2857 * have requested the GPIO.  That can include implicit requesting by
2858 * a direction setting call.  Marking a gpio as requested locks its chip
2859 * in memory, guaranteeing that these table lookups need no more locking
2860 * and that gpiochip_remove() will fail.
2861 *
2862 * REVISIT when debugging, consider adding some instrumentation to ensure
2863 * that the GPIO was actually requested.
2864 */
2865
2866static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
2867{
2868        struct gpio_chip        *chip;
2869        int offset;
2870        int value;
2871
2872        chip = desc->gdev->chip;
2873        offset = gpio_chip_hwgpio(desc);
2874        value = chip->get ? chip->get(chip, offset) : -EIO;
2875        value = value < 0 ? value : !!value;
2876        trace_gpio_value(desc_to_gpio(desc), 1, value);
2877        return value;
2878}
2879
2880static int gpio_chip_get_multiple(struct gpio_chip *chip,
2881                                  unsigned long *mask, unsigned long *bits)
2882{
2883        if (chip->get_multiple) {
2884                return chip->get_multiple(chip, mask, bits);
2885        } else if (chip->get) {
2886                int i, value;
2887
2888                for_each_set_bit(i, mask, chip->ngpio) {
2889                        value = chip->get(chip, i);
2890                        if (value < 0)
2891                                return value;
2892                        __assign_bit(i, bits, value);
2893                }
2894                return 0;
2895        }
2896        return -EIO;
2897}
2898
2899int gpiod_get_array_value_complex(bool raw, bool can_sleep,
2900                                  unsigned int array_size,
2901                                  struct gpio_desc **desc_array,
2902                                  struct gpio_array *array_info,
2903                                  unsigned long *value_bitmap)
2904{
2905        int err, i = 0;
2906
2907        /*
2908         * Validate array_info against desc_array and its size.
2909         * It should immediately follow desc_array if both
2910         * have been obtained from the same gpiod_get_array() call.
2911         */
2912        if (array_info && array_info->desc == desc_array &&
2913            array_size <= array_info->size &&
2914            (void *)array_info == desc_array + array_info->size) {
2915                if (!can_sleep)
2916                        WARN_ON(array_info->chip->can_sleep);
2917
2918                err = gpio_chip_get_multiple(array_info->chip,
2919                                             array_info->get_mask,
2920                                             value_bitmap);
2921                if (err)
2922                        return err;
2923
2924                if (!raw && !bitmap_empty(array_info->invert_mask, array_size))
2925                        bitmap_xor(value_bitmap, value_bitmap,
2926                                   array_info->invert_mask, array_size);
2927
2928                if (bitmap_full(array_info->get_mask, array_size))
2929                        return 0;
2930
2931                i = find_first_zero_bit(array_info->get_mask, array_size);
2932        } else {
2933                array_info = NULL;
2934        }
2935
2936        while (i < array_size) {
2937                struct gpio_chip *chip = desc_array[i]->gdev->chip;
2938                unsigned long fastpath[2 * BITS_TO_LONGS(FASTPATH_NGPIO)];
2939                unsigned long *mask, *bits;
2940                int first, j, ret;
2941
2942                if (likely(chip->ngpio <= FASTPATH_NGPIO)) {
2943                        mask = fastpath;
2944                } else {
2945                        mask = kmalloc_array(2 * BITS_TO_LONGS(chip->ngpio),
2946                                           sizeof(*mask),
2947                                           can_sleep ? GFP_KERNEL : GFP_ATOMIC);
2948                        if (!mask)
2949                                return -ENOMEM;
2950                }
2951
2952                bits = mask + BITS_TO_LONGS(chip->ngpio);
2953                bitmap_zero(mask, chip->ngpio);
2954
2955                if (!can_sleep)
2956                        WARN_ON(chip->can_sleep);
2957
2958                /* collect all inputs belonging to the same chip */
2959                first = i;
2960                do {
2961                        const struct gpio_desc *desc = desc_array[i];
2962                        int hwgpio = gpio_chip_hwgpio(desc);
2963
2964                        __set_bit(hwgpio, mask);
2965                        i++;
2966
2967                        if (array_info)
2968                                i = find_next_zero_bit(array_info->get_mask,
2969                                                       array_size, i);
2970                } while ((i < array_size) &&
2971                         (desc_array[i]->gdev->chip == chip));
2972
2973                ret = gpio_chip_get_multiple(chip, mask, bits);
2974                if (ret) {
2975                        if (mask != fastpath)
2976                                kfree(mask);
2977                        return ret;
2978                }
2979
2980                for (j = first; j < i; ) {
2981                        const struct gpio_desc *desc = desc_array[j];
2982                        int hwgpio = gpio_chip_hwgpio(desc);
2983                        int value = test_bit(hwgpio, bits);
2984
2985                        if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2986                                value = !value;
2987                        __assign_bit(j, value_bitmap, value);
2988                        trace_gpio_value(desc_to_gpio(desc), 1, value);
2989                        j++;
2990
2991                        if (array_info)
2992                                j = find_next_zero_bit(array_info->get_mask, i,
2993                                                       j);
2994                }
2995
2996                if (mask != fastpath)
2997                        kfree(mask);
2998        }
2999        return 0;
3000}
3001
3002/**
3003 * gpiod_get_raw_value() - return a gpio's raw value
3004 * @desc: gpio whose value will be returned
3005 *
3006 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
3007 * its ACTIVE_LOW status, or negative errno on failure.
3008 *
3009 * This function should be called from contexts where we cannot sleep, and will
3010 * complain if the GPIO chip functions potentially sleep.
3011 */
3012int gpiod_get_raw_value(const struct gpio_desc *desc)
3013{
3014        VALIDATE_DESC(desc);
3015        /* Should be using gpio_get_value_cansleep() */
3016        WARN_ON(desc->gdev->chip->can_sleep);
3017        return gpiod_get_raw_value_commit(desc);
3018}
3019EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
3020
3021/**
3022 * gpiod_get_value() - return a gpio's value
3023 * @desc: gpio whose value will be returned
3024 *
3025 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
3026 * account, or negative errno on failure.
3027 *
3028 * This function should be called from contexts where we cannot sleep, and will
3029 * complain if the GPIO chip functions potentially sleep.
3030 */
3031int gpiod_get_value(const struct gpio_desc *desc)
3032{
3033        int value;
3034
3035        VALIDATE_DESC(desc);
3036        /* Should be using gpio_get_value_cansleep() */
3037        WARN_ON(desc->gdev->chip->can_sleep);
3038
3039        value = gpiod_get_raw_value_commit(desc);
3040        if (value < 0)
3041                return value;
3042
3043        if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3044                value = !value;
3045
3046        return value;
3047}
3048EXPORT_SYMBOL_GPL(gpiod_get_value);
3049
3050/**
3051 * gpiod_get_raw_array_value() - read raw values from an array of GPIOs
3052 * @array_size: number of elements in the descriptor array / value bitmap
3053 * @desc_array: array of GPIO descriptors whose values will be read
3054 * @array_info: information on applicability of fast bitmap processing path
3055 * @value_bitmap: bitmap to store the read values
3056 *
3057 * Read the raw values of the GPIOs, i.e. the values of the physical lines
3058 * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
3059 * else an error code.
3060 *
3061 * This function should be called from contexts where we cannot sleep,
3062 * and it will complain if the GPIO chip functions potentially sleep.
3063 */
3064int gpiod_get_raw_array_value(unsigned int array_size,
3065                              struct gpio_desc **desc_array,
3066                              struct gpio_array *array_info,
3067                              unsigned long *value_bitmap)
3068{
3069        if (!desc_array)
3070                return -EINVAL;
3071        return gpiod_get_array_value_complex(true, false, array_size,
3072                                             desc_array, array_info,
3073                                             value_bitmap);
3074}
3075EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);
3076
3077/**
3078 * gpiod_get_array_value() - read values from an array of GPIOs
3079 * @array_size: number of elements in the descriptor array / value bitmap
3080 * @desc_array: array of GPIO descriptors whose values will be read
3081 * @array_info: information on applicability of fast bitmap processing path
3082 * @value_bitmap: bitmap to store the read values
3083 *
3084 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3085 * into account.  Return 0 in case of success, else an error code.
3086 *
3087 * This function should be called from contexts where we cannot sleep,
3088 * and it will complain if the GPIO chip functions potentially sleep.
3089 */
3090int gpiod_get_array_value(unsigned int array_size,
3091                          struct gpio_desc **desc_array,
3092                          struct gpio_array *array_info,
3093                          unsigned long *value_bitmap)
3094{
3095        if (!desc_array)
3096                return -EINVAL;
3097        return gpiod_get_array_value_complex(false, false, array_size,
3098                                             desc_array, array_info,
3099                                             value_bitmap);
3100}
3101EXPORT_SYMBOL_GPL(gpiod_get_array_value);
3102
3103/*
3104 *  gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
3105 * @desc: gpio descriptor whose state need to be set.
3106 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
3107 */
3108static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
3109{
3110        int err = 0;
3111        struct gpio_chip *chip = desc->gdev->chip;
3112        int offset = gpio_chip_hwgpio(desc);
3113
3114        if (value) {
3115                err = chip->direction_input(chip, offset);
3116                if (!err)
3117                        clear_bit(FLAG_IS_OUT, &desc->flags);
3118        } else {
3119                err = chip->direction_output(chip, offset, 0);
3120                if (!err)
3121                        set_bit(FLAG_IS_OUT, &desc->flags);
3122        }
3123        trace_gpio_direction(desc_to_gpio(desc), value, err);
3124        if (err < 0)
3125                gpiod_err(desc,
3126                          "%s: Error in set_value for open drain err %d\n",
3127                          __func__, err);
3128}
3129
3130/*
3131 *  _gpio_set_open_source_value() - Set the open source gpio's value.
3132 * @desc: gpio descriptor whose state need to be set.
3133 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
3134 */
3135static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
3136{
3137        int err = 0;
3138        struct gpio_chip *chip = desc->gdev->chip;
3139        int offset = gpio_chip_hwgpio(desc);
3140
3141        if (value) {
3142                err = chip->direction_output(chip, offset, 1);
3143                if (!err)
3144                        set_bit(FLAG_IS_OUT, &desc->flags);
3145        } else {
3146                err = chip->direction_input(chip, offset);
3147                if (!err)
3148                        clear_bit(FLAG_IS_OUT, &desc->flags);
3149        }
3150        trace_gpio_direction(desc_to_gpio(desc), !value, err);
3151        if (err < 0)
3152                gpiod_err(desc,
3153                          "%s: Error in set_value for open source err %d\n",
3154                          __func__, err);
3155}
3156
3157static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
3158{
3159        struct gpio_chip        *chip;
3160
3161        chip = desc->gdev->chip;
3162        trace_gpio_value(desc_to_gpio(desc), 0, value);
3163        chip->set(chip, gpio_chip_hwgpio(desc), value);
3164}
3165
3166/*
3167 * set multiple outputs on the same chip;
3168 * use the chip's set_multiple function if available;
3169 * otherwise set the outputs sequentially;
3170 * @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word
3171 *        defines which outputs are to be changed
3172 * @bits: bit value array; one bit per output; BITS_PER_LONG bits per word
3173 *        defines the values the outputs specified by mask are to be set to
3174 */
3175static void gpio_chip_set_multiple(struct gpio_chip *chip,
3176                                   unsigned long *mask, unsigned long *bits)
3177{
3178        if (chip->set_multiple) {
3179                chip->set_multiple(chip, mask, bits);
3180        } else {
3181                unsigned int i;
3182
3183                /* set outputs if the corresponding mask bit is set */
3184                for_each_set_bit(i, mask, chip->ngpio)
3185                        chip->set(chip, i, test_bit(i, bits));
3186        }
3187}
3188
3189int gpiod_set_array_value_complex(bool raw, bool can_sleep,
3190                                  unsigned int array_size,
3191                                  struct gpio_desc **desc_array,
3192                                  struct gpio_array *array_info,
3193                                  unsigned long *value_bitmap)
3194{
3195        int i = 0;
3196
3197        /*
3198         * Validate array_info against desc_array and its size.
3199         * It should immediately follow desc_array if both
3200         * have been obtained from the same gpiod_get_array() call.
3201         */
3202        if (array_info && array_info->desc == desc_array &&
3203            array_size <= array_info->size &&
3204            (void *)array_info == desc_array + array_info->size) {
3205                if (!can_sleep)
3206                        WARN_ON(array_info->chip->can_sleep);
3207
3208                if (!raw && !bitmap_empty(array_info->invert_mask, array_size))
3209                        bitmap_xor(value_bitmap, value_bitmap,
3210                                   array_info->invert_mask, array_size);
3211
3212                gpio_chip_set_multiple(array_info->chip, array_info->set_mask,
3213                                       value_bitmap);
3214
3215                if (bitmap_full(array_info->set_mask, array_size))
3216                        return 0;
3217
3218                i = find_first_zero_bit(array_info->set_mask, array_size);
3219        } else {
3220                array_info = NULL;
3221        }
3222
3223        while (i < array_size) {
3224                struct gpio_chip *chip = desc_array[i]->gdev->chip;
3225                unsigned long fastpath[2 * BITS_TO_LONGS(FASTPATH_NGPIO)];
3226                unsigned long *mask, *bits;
3227                int count = 0;
3228
3229                if (likely(chip->ngpio <= FASTPATH_NGPIO)) {
3230                        mask = fastpath;
3231                } else {
3232                        mask = kmalloc_array(2 * BITS_TO_LONGS(chip->ngpio),
3233                                           sizeof(*mask),
3234                                           can_sleep ? GFP_KERNEL : GFP_ATOMIC);
3235                        if (!mask)
3236                                return -ENOMEM;
3237                }
3238
3239                bits = mask + BITS_TO_LONGS(chip->ngpio);
3240                bitmap_zero(mask, chip->ngpio);
3241
3242                if (!can_sleep)
3243                        WARN_ON(chip->can_sleep);
3244
3245                do {
3246                        struct gpio_desc *desc = desc_array[i];
3247                        int hwgpio = gpio_chip_hwgpio(desc);
3248                        int value = test_bit(i, value_bitmap);
3249
3250                        /*
3251                         * Pins applicable for fast input but not for
3252                         * fast output processing may have been already
3253                         * inverted inside the fast path, skip them.
3254                         */
3255                        if (!raw && !(array_info &&
3256                            test_bit(i, array_info->invert_mask)) &&
3257                            test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3258                                value = !value;
3259                        trace_gpio_value(desc_to_gpio(desc), 0, value);
3260                        /*
3261                         * collect all normal outputs belonging to the same chip
3262                         * open drain and open source outputs are set individually
3263                         */
3264                        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
3265                                gpio_set_open_drain_value_commit(desc, value);
3266                        } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
3267                                gpio_set_open_source_value_commit(desc, value);
3268                        } else {
3269                                __set_bit(hwgpio, mask);
3270                                if (value)
3271                                        __set_bit(hwgpio, bits);
3272                                else
3273                                        __clear_bit(hwgpio, bits);
3274                                count++;
3275                        }
3276                        i++;
3277
3278                        if (array_info)
3279                                i = find_next_zero_bit(array_info->set_mask,
3280                                                       array_size, i);
3281                } while ((i < array_size) &&
3282                         (desc_array[i]->gdev->chip == chip));
3283                /* push collected bits to outputs */
3284                if (count != 0)
3285                        gpio_chip_set_multiple(chip, mask, bits);
3286
3287                if (mask != fastpath)
3288                        kfree(mask);
3289        }
3290        return 0;
3291}
3292
3293/**
3294 * gpiod_set_raw_value() - assign a gpio's raw value
3295 * @desc: gpio whose value will be assigned
3296 * @value: value to assign
3297 *
3298 * Set the raw value of the GPIO, i.e. the value of its physical line without
3299 * regard for its ACTIVE_LOW status.
3300 *
3301 * This function should be called from contexts where we cannot sleep, and will
3302 * complain if the GPIO chip functions potentially sleep.
3303 */
3304void gpiod_set_raw_value(struct gpio_desc *desc, int value)
3305{
3306        VALIDATE_DESC_VOID(desc);
3307        /* Should be using gpiod_set_value_cansleep() */
3308        WARN_ON(desc->gdev->chip->can_sleep);
3309        gpiod_set_raw_value_commit(desc, value);
3310}
3311EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
3312
3313/**
3314 * gpiod_set_value_nocheck() - set a GPIO line value without checking
3315 * @desc: the descriptor to set the value on
3316 * @value: value to set
3317 *
3318 * This sets the value of a GPIO line backing a descriptor, applying
3319 * different semantic quirks like active low and open drain/source
3320 * handling.
3321 */
3322static void gpiod_set_value_nocheck(struct gpio_desc *desc, int value)
3323{
3324        if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3325                value = !value;
3326        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
3327                gpio_set_open_drain_value_commit(desc, value);
3328        else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
3329                gpio_set_open_source_value_commit(desc, value);
3330        else
3331                gpiod_set_raw_value_commit(desc, value);
3332}
3333
3334/**
3335 * gpiod_set_value() - assign a gpio's value
3336 * @desc: gpio whose value will be assigned
3337 * @value: value to assign
3338 *
3339 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
3340 * OPEN_DRAIN and OPEN_SOURCE flags into account.
3341 *
3342 * This function should be called from contexts where we cannot sleep, and will
3343 * complain if the GPIO chip functions potentially sleep.
3344 */
3345void gpiod_set_value(struct gpio_desc *desc, int value)
3346{
3347        VALIDATE_DESC_VOID(desc);
3348        WARN_ON(desc->gdev->chip->can_sleep);
3349        gpiod_set_value_nocheck(desc, value);
3350}
3351EXPORT_SYMBOL_GPL(gpiod_set_value);
3352
3353/**
3354 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
3355 * @array_size: number of elements in the descriptor array / value bitmap
3356 * @desc_array: array of GPIO descriptors whose values will be assigned
3357 * @array_info: information on applicability of fast bitmap processing path
3358 * @value_bitmap: bitmap of values to assign
3359 *
3360 * Set the raw values of the GPIOs, i.e. the values of the physical lines
3361 * without regard for their ACTIVE_LOW status.
3362 *
3363 * This function should be called from contexts where we cannot sleep, and will
3364 * complain if the GPIO chip functions potentially sleep.
3365 */
3366int gpiod_set_raw_array_value(unsigned int array_size,
3367                              struct gpio_desc **desc_array,
3368                              struct gpio_array *array_info,
3369                              unsigned long *value_bitmap)
3370{
3371        if (!desc_array)
3372                return -EINVAL;
3373        return gpiod_set_array_value_complex(true, false, array_size,
3374                                        desc_array, array_info, value_bitmap);
3375}
3376EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
3377
3378/**
3379 * gpiod_set_array_value() - assign values to an array of GPIOs
3380 * @array_size: number of elements in the descriptor array / value bitmap
3381 * @desc_array: array of GPIO descriptors whose values will be assigned
3382 * @array_info: information on applicability of fast bitmap processing path
3383 * @value_bitmap: bitmap of values to assign
3384 *
3385 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3386 * into account.
3387 *
3388 * This function should be called from contexts where we cannot sleep, and will
3389 * complain if the GPIO chip functions potentially sleep.
3390 */
3391int gpiod_set_array_value(unsigned int array_size,
3392                          struct gpio_desc **desc_array,
3393                          struct gpio_array *array_info,
3394                          unsigned long *value_bitmap)
3395{
3396        if (!desc_array)
3397                return -EINVAL;
3398        return gpiod_set_array_value_complex(false, false, array_size,
3399                                             desc_array, array_info,
3400                                             value_bitmap);
3401}
3402EXPORT_SYMBOL_GPL(gpiod_set_array_value);
3403
3404/**
3405 * gpiod_cansleep() - report whether gpio value access may sleep
3406 * @desc: gpio to check
3407 *
3408 */
3409int gpiod_cansleep(const struct gpio_desc *desc)
3410{
3411        VALIDATE_DESC(desc);
3412        return desc->gdev->chip->can_sleep;
3413}
3414EXPORT_SYMBOL_GPL(gpiod_cansleep);
3415
3416/**
3417 * gpiod_set_consumer_name() - set the consumer name for the descriptor
3418 * @desc: gpio to set the consumer name on
3419 * @name: the new consumer name
3420 */
3421int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name)
3422{
3423        VALIDATE_DESC(desc);
3424        if (name) {
3425                name = kstrdup_const(name, GFP_KERNEL);
3426                if (!name)
3427                        return -ENOMEM;
3428        }
3429
3430        kfree_const(desc->label);
3431        desc_set_label(desc, name);
3432
3433        return 0;
3434}
3435EXPORT_SYMBOL_GPL(gpiod_set_consumer_name);
3436
3437/**
3438 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
3439 * @desc: gpio whose IRQ will be returned (already requested)
3440 *
3441 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
3442 * error.
3443 */
3444int gpiod_to_irq(const struct gpio_desc *desc)
3445{
3446        struct gpio_chip *chip;
3447        int offset;
3448
3449        /*
3450         * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics
3451         * requires this function to not return zero on an invalid descriptor
3452         * but rather a negative error number.
3453         */
3454        if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
3455                return -EINVAL;
3456
3457        chip = desc->gdev->chip;
3458        offset = gpio_chip_hwgpio(desc);
3459        if (chip->to_irq) {
3460                int retirq = chip->to_irq(chip, offset);
3461
3462                /* Zero means NO_IRQ */
3463                if (!retirq)
3464                        return -ENXIO;
3465
3466                return retirq;
3467        }
3468        return -ENXIO;
3469}
3470EXPORT_SYMBOL_GPL(gpiod_to_irq);
3471
3472/**
3473 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
3474 * @chip: the chip the GPIO to lock belongs to
3475 * @offset: the offset of the GPIO to lock as IRQ
3476 *
3477 * This is used directly by GPIO drivers that want to lock down
3478 * a certain GPIO line to be used for IRQs.
3479 */
3480int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
3481{
3482        struct gpio_desc *desc;
3483
3484        desc = gpiochip_get_desc(chip, offset);
3485        if (IS_ERR(desc))
3486                return PTR_ERR(desc);
3487
3488        /*
3489         * If it's fast: flush the direction setting if something changed
3490         * behind our back
3491         */
3492        if (!chip->can_sleep && chip->get_direction) {
3493                int dir = gpiod_get_direction(desc);
3494
3495                if (dir < 0) {
3496                        chip_err(chip, "%s: cannot get GPIO direction\n",
3497                                 __func__);
3498                        return dir;
3499                }
3500        }
3501
3502        if (test_bit(FLAG_IS_OUT, &desc->flags)) {
3503                chip_err(chip,
3504                         "%s: tried to flag a GPIO set as output for IRQ\n",
3505                         __func__);
3506                return -EIO;
3507        }
3508
3509        set_bit(FLAG_USED_AS_IRQ, &desc->flags);
3510        set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
3511
3512        /*
3513         * If the consumer has not set up a label (such as when the
3514         * IRQ is referenced from .to_irq()) we set up a label here
3515         * so it is clear this is used as an interrupt.
3516         */
3517        if (!desc->label)
3518                desc_set_label(desc, "interrupt");
3519
3520        return 0;
3521}
3522EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
3523
3524/**
3525 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
3526 * @chip: the chip the GPIO to lock belongs to
3527 * @offset: the offset of the GPIO to lock as IRQ
3528 *
3529 * This is used directly by GPIO drivers that want to indicate
3530 * that a certain GPIO is no longer used exclusively for IRQ.
3531 */
3532void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
3533{
3534        struct gpio_desc *desc;
3535
3536        desc = gpiochip_get_desc(chip, offset);
3537        if (IS_ERR(desc))
3538                return;
3539
3540        clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
3541        clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
3542
3543        /* If we only had this marking, erase it */
3544        if (desc->label && !strcmp(desc->label, "interrupt"))
3545                desc_set_label(desc, NULL);
3546}
3547EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
3548
3549void gpiochip_disable_irq(struct gpio_chip *chip, unsigned int offset)
3550{
3551        struct gpio_desc *desc = gpiochip_get_desc(chip, offset);
3552
3553        if (!IS_ERR(desc) &&
3554            !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags)))
3555                clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
3556}
3557EXPORT_SYMBOL_GPL(gpiochip_disable_irq);
3558
3559void gpiochip_enable_irq(struct gpio_chip *chip, unsigned int offset)
3560{
3561        struct gpio_desc *desc = gpiochip_get_desc(chip, offset);
3562
3563        if (!IS_ERR(desc) &&
3564            !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) {
3565                WARN_ON(test_bit(FLAG_IS_OUT, &desc->flags));
3566                set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
3567        }
3568}
3569EXPORT_SYMBOL_GPL(gpiochip_enable_irq);
3570
3571bool gpiochip_line_is_irq(struct gpio_chip *chip, unsigned int offset)
3572{
3573        if (offset >= chip->ngpio)
3574                return false;
3575
3576        return test_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
3577}
3578EXPORT_SYMBOL_GPL(gpiochip_line_is_irq);
3579
3580int gpiochip_reqres_irq(struct gpio_chip *chip, unsigned int offset)
3581{
3582        int ret;
3583
3584        if (!try_module_get(chip->gpiodev->owner))
3585                return -ENODEV;
3586
3587        ret = gpiochip_lock_as_irq(chip, offset);
3588        if (ret) {
3589                chip_err(chip, "unable to lock HW IRQ %u for IRQ\n", offset);
3590                module_put(chip->gpiodev->owner);
3591                return ret;
3592        }
3593        return 0;
3594}
3595EXPORT_SYMBOL_GPL(gpiochip_reqres_irq);
3596
3597void gpiochip_relres_irq(struct gpio_chip *chip, unsigned int offset)
3598{
3599        gpiochip_unlock_as_irq(chip, offset);
3600        module_put(chip->gpiodev->owner);
3601}
3602EXPORT_SYMBOL_GPL(gpiochip_relres_irq);
3603
3604bool gpiochip_line_is_open_drain(struct gpio_chip *chip, unsigned int offset)
3605{
3606        if (offset >= chip->ngpio)
3607                return false;
3608
3609        return test_bit(FLAG_OPEN_DRAIN, &chip->gpiodev->descs[offset].flags);
3610}
3611EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain);
3612
3613bool gpiochip_line_is_open_source(struct gpio_chip *chip, unsigned int offset)
3614{
3615        if (offset >= chip->ngpio)
3616                return false;
3617
3618        return test_bit(FLAG_OPEN_SOURCE, &chip->gpiodev->descs[offset].flags);
3619}
3620EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source);
3621
3622bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
3623{
3624        if (offset >= chip->ngpio)
3625                return false;
3626
3627        return !test_bit(FLAG_TRANSITORY, &chip->gpiodev->descs[offset].flags);
3628}
3629EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);
3630
3631/**
3632 * gpiod_get_raw_value_cansleep() - return a gpio's raw value
3633 * @desc: gpio whose value will be returned
3634 *
3635 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
3636 * its ACTIVE_LOW status, or negative errno on failure.
3637 *
3638 * This function is to be called from contexts that can sleep.
3639 */
3640int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
3641{
3642        might_sleep_if(extra_checks);
3643        VALIDATE_DESC(desc);
3644        return gpiod_get_raw_value_commit(desc);
3645}
3646EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
3647
3648/**
3649 * gpiod_get_value_cansleep() - return a gpio's value
3650 * @desc: gpio whose value will be returned
3651 *
3652 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
3653 * account, or negative errno on failure.
3654 *
3655 * This function is to be called from contexts that can sleep.
3656 */
3657int gpiod_get_value_cansleep(const struct gpio_desc *desc)
3658{
3659        int value;
3660
3661        might_sleep_if(extra_checks);
3662        VALIDATE_DESC(desc);
3663        value = gpiod_get_raw_value_commit(desc);
3664        if (value < 0)
3665                return value;
3666
3667        if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3668                value = !value;
3669
3670        return value;
3671}
3672EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
3673
3674/**
3675 * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs
3676 * @array_size: number of elements in the descriptor array / value bitmap
3677 * @desc_array: array of GPIO descriptors whose values will be read
3678 * @array_info: information on applicability of fast bitmap processing path
3679 * @value_bitmap: bitmap to store the read values
3680 *
3681 * Read the raw values of the GPIOs, i.e. the values of the physical lines
3682 * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
3683 * else an error code.
3684 *
3685 * This function is to be called from contexts that can sleep.
3686 */
3687int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
3688                                       struct gpio_desc **desc_array,
3689                                       struct gpio_array *array_info,
3690                                       unsigned long *value_bitmap)
3691{
3692        might_sleep_if(extra_checks);
3693        if (!desc_array)
3694                return -EINVAL;
3695        return gpiod_get_array_value_complex(true, true, array_size,
3696                                             desc_array, array_info,
3697                                             value_bitmap);
3698}
3699EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);
3700
3701/**
3702 * gpiod_get_array_value_cansleep() - read values from an array of GPIOs
3703 * @array_size: number of elements in the descriptor array / value bitmap
3704 * @desc_array: array of GPIO descriptors whose values will be read
3705 * @array_info: information on applicability of fast bitmap processing path
3706 * @value_bitmap: bitmap to store the read values
3707 *
3708 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3709 * into account.  Return 0 in case of success, else an error code.
3710 *
3711 * This function is to be called from contexts that can sleep.
3712 */
3713int gpiod_get_array_value_cansleep(unsigned int array_size,
3714                                   struct gpio_desc **desc_array,
3715                                   struct gpio_array *array_info,
3716                                   unsigned long *value_bitmap)
3717{
3718        might_sleep_if(extra_checks);
3719        if (!desc_array)
3720                return -EINVAL;
3721        return gpiod_get_array_value_complex(false, true, array_size,
3722                                             desc_array, array_info,
3723                                             value_bitmap);
3724}
3725EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep);
3726
3727/**
3728 * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
3729 * @desc: gpio whose value will be assigned
3730 * @value: value to assign
3731 *
3732 * Set the raw value of the GPIO, i.e. the value of its physical line without
3733 * regard for its ACTIVE_LOW status.
3734 *
3735 * This function is to be called from contexts that can sleep.
3736 */
3737void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
3738{
3739        might_sleep_if(extra_checks);
3740        VALIDATE_DESC_VOID(desc);
3741        gpiod_set_raw_value_commit(desc, value);
3742}
3743EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
3744
3745/**
3746 * gpiod_set_value_cansleep() - assign a gpio's value
3747 * @desc: gpio whose value will be assigned
3748 * @value: value to assign
3749 *
3750 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
3751 * account
3752 *
3753 * This function is to be called from contexts that can sleep.
3754 */
3755void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
3756{
3757        might_sleep_if(extra_checks);
3758        VALIDATE_DESC_VOID(desc);
3759        gpiod_set_value_nocheck(desc, value);
3760}
3761EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
3762
3763/**
3764 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
3765 * @array_size: number of elements in the descriptor array / value bitmap
3766 * @desc_array: array of GPIO descriptors whose values will be assigned
3767 * @array_info: information on applicability of fast bitmap processing path
3768 * @value_bitmap: bitmap of values to assign
3769 *
3770 * Set the raw values of the GPIOs, i.e. the values of the physical lines
3771 * without regard for their ACTIVE_LOW status.
3772 *
3773 * This function is to be called from contexts that can sleep.
3774 */
3775int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
3776                                       struct gpio_desc **desc_array,
3777                                       struct gpio_array *array_info,
3778                                       unsigned long *value_bitmap)
3779{
3780        might_sleep_if(extra_checks);
3781        if (!desc_array)
3782                return -EINVAL;
3783        return gpiod_set_array_value_complex(true, true, array_size, desc_array,
3784                                      array_info, value_bitmap);
3785}
3786EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
3787
3788/**
3789 * gpiod_add_lookup_tables() - register GPIO device consumers
3790 * @tables: list of tables of consumers to register
3791 * @n: number of tables in the list
3792 */
3793void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n)
3794{
3795        unsigned int i;
3796
3797        mutex_lock(&gpio_lookup_lock);
3798
3799        for (i = 0; i < n; i++)
3800                list_add_tail(&tables[i]->list, &gpio_lookup_list);
3801
3802        mutex_unlock(&gpio_lookup_lock);
3803}
3804
3805/**
3806 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
3807 * @array_size: number of elements in the descriptor array / value bitmap
3808 * @desc_array: array of GPIO descriptors whose values will be assigned
3809 * @array_info: information on applicability of fast bitmap processing path
3810 * @value_bitmap: bitmap of values to assign
3811 *
3812 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3813 * into account.
3814 *
3815 * This function is to be called from contexts that can sleep.
3816 */
3817int gpiod_set_array_value_cansleep(unsigned int array_size,
3818                                   struct gpio_desc **desc_array,
3819                                   struct gpio_array *array_info,
3820                                   unsigned long *value_bitmap)
3821{
3822        might_sleep_if(extra_checks);
3823        if (!desc_array)
3824                return -EINVAL;
3825        return gpiod_set_array_value_complex(false, true, array_size,
3826                                             desc_array, array_info,
3827                                             value_bitmap);
3828}
3829EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
3830
3831/**
3832 * gpiod_add_lookup_table() - register GPIO device consumers
3833 * @table: table of consumers to register
3834 */
3835void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
3836{
3837        mutex_lock(&gpio_lookup_lock);
3838
3839        list_add_tail(&table->list, &gpio_lookup_list);
3840
3841        mutex_unlock(&gpio_lookup_lock);
3842}
3843EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
3844
3845/**
3846 * gpiod_remove_lookup_table() - unregister GPIO device consumers
3847 * @table: table of consumers to unregister
3848 */
3849void gpiod_remove_lookup_table(struct gpiod_lookup_table *table)
3850{
3851        mutex_lock(&gpio_lookup_lock);
3852
3853        list_del(&table->list);
3854
3855        mutex_unlock(&gpio_lookup_lock);
3856}
3857EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table);
3858
3859/**
3860 * gpiod_add_hogs() - register a set of GPIO hogs from machine code
3861 * @hogs: table of gpio hog entries with a zeroed sentinel at the end
3862 */
3863void gpiod_add_hogs(struct gpiod_hog *hogs)
3864{
3865        struct gpio_chip *chip;
3866        struct gpiod_hog *hog;
3867
3868        mutex_lock(&gpio_machine_hogs_mutex);
3869
3870        for (hog = &hogs[0]; hog->chip_label; hog++) {
3871                list_add_tail(&hog->list, &gpio_machine_hogs);
3872
3873                /*
3874                 * The chip may have been registered earlier, so check if it
3875                 * exists and, if so, try to hog the line now.
3876                 */
3877                chip = find_chip_by_name(hog->chip_label);
3878                if (chip)
3879                        gpiochip_machine_hog(chip, hog);
3880        }
3881
3882        mutex_unlock(&gpio_machine_hogs_mutex);
3883}
3884EXPORT_SYMBOL_GPL(gpiod_add_hogs);
3885
3886static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
3887{
3888        const char *dev_id = dev ? dev_name(dev) : NULL;
3889        struct gpiod_lookup_table *table;
3890
3891        mutex_lock(&gpio_lookup_lock);
3892
3893        list_for_each_entry(table, &gpio_lookup_list, list) {
3894                if (table->dev_id && dev_id) {
3895                        /*
3896                         * Valid strings on both ends, must be identical to have
3897                         * a match
3898                         */
3899                        if (!strcmp(table->dev_id, dev_id))
3900                                goto found;
3901                } else {
3902                        /*
3903                         * One of the pointers is NULL, so both must be to have
3904                         * a match
3905                         */
3906                        if (dev_id == table->dev_id)
3907                                goto found;
3908                }
3909        }
3910        table = NULL;
3911
3912found:
3913        mutex_unlock(&gpio_lookup_lock);
3914        return table;
3915}
3916
3917static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
3918                                    unsigned int idx,
3919                                    enum gpio_lookup_flags *flags)
3920{
3921        struct gpio_desc *desc = ERR_PTR(-ENOENT);
3922        struct gpiod_lookup_table *table;
3923        struct gpiod_lookup *p;
3924
3925        table = gpiod_find_lookup_table(dev);
3926        if (!table)
3927                return desc;
3928
3929        for (p = &table->table[0]; p->chip_label; p++) {
3930                struct gpio_chip *chip;
3931
3932                /* idx must always match exactly */
3933                if (p->idx != idx)
3934                        continue;
3935
3936                /* If the lookup entry has a con_id, require exact match */
3937                if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
3938                        continue;
3939
3940                chip = find_chip_by_name(p->chip_label);
3941
3942                if (!chip) {
3943                        /*
3944                         * As the lookup table indicates a chip with
3945                         * p->chip_label should exist, assume it may
3946                         * still appear later and let the interested
3947                         * consumer be probed again or let the Deferred
3948                         * Probe infrastructure handle the error.
3949                         */
3950                        dev_warn(dev, "cannot find GPIO chip %s, deferring\n",
3951                                 p->chip_label);
3952                        return ERR_PTR(-EPROBE_DEFER);
3953                }
3954
3955                if (chip->ngpio <= p->chip_hwnum) {
3956                        dev_err(dev,
3957                                "requested GPIO %d is out of range [0..%d] for chip %s\n",
3958                                idx, chip->ngpio, chip->label);
3959                        return ERR_PTR(-EINVAL);
3960                }
3961
3962                desc = gpiochip_get_desc(chip, p->chip_hwnum);
3963                *flags = p->flags;
3964
3965                return desc;
3966        }
3967
3968        return desc;
3969}
3970
3971static int dt_gpio_count(struct device *dev, const char *con_id)
3972{
3973        int ret;
3974        char propname[32];
3975        unsigned int i;
3976
3977        for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
3978                if (con_id)
3979                        snprintf(propname, sizeof(propname), "%s-%s",
3980                                 con_id, gpio_suffixes[i]);
3981                else
3982                        snprintf(propname, sizeof(propname), "%s",
3983                                 gpio_suffixes[i]);
3984
3985                ret = of_gpio_named_count(dev->of_node, propname);
3986                if (ret > 0)
3987                        break;
3988        }
3989        return ret ? ret : -ENOENT;
3990}
3991
3992static int platform_gpio_count(struct device *dev, const char *con_id)
3993{
3994        struct gpiod_lookup_table *table;
3995        struct gpiod_lookup *p;
3996        unsigned int count = 0;
3997
3998        table = gpiod_find_lookup_table(dev);
3999        if (!table)
4000                return -ENOENT;
4001
4002        for (p = &table->table[0]; p->chip_label; p++) {
4003                if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) ||
4004                    (!con_id && !p->con_id))
4005                        count++;
4006        }
4007        if (!count)
4008                return -ENOENT;
4009
4010        return count;
4011}
4012
4013/**
4014 * gpiod_count - return the number of GPIOs associated with a device / function
4015 *              or -ENOENT if no GPIO has been assigned to the requested function
4016 * @dev:        GPIO consumer, can be NULL for system-global GPIOs
4017 * @con_id:     function within the GPIO consumer
4018 */
4019int gpiod_count(struct device *dev, const char *con_id)
4020{
4021        int count = -ENOENT;
4022
4023        if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
4024                count = dt_gpio_count(dev, con_id);
4025        else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev))
4026                count = acpi_gpio_count(dev, con_id);
4027
4028        if (count < 0)
4029                count = platform_gpio_count(dev, con_id);
4030
4031        return count;
4032}
4033EXPORT_SYMBOL_GPL(gpiod_count);
4034
4035/**
4036 * gpiod_get - obtain a GPIO for a given GPIO function
4037 * @dev:        GPIO consumer, can be NULL for system-global GPIOs
4038 * @con_id:     function within the GPIO consumer
4039 * @flags:      optional GPIO initialization flags
4040 *
4041 * Return the GPIO descriptor corresponding to the function con_id of device
4042 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
4043 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
4044 */
4045struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
4046                                         enum gpiod_flags flags)
4047{
4048        return gpiod_get_index(dev, con_id, 0, flags);
4049}
4050EXPORT_SYMBOL_GPL(gpiod_get);
4051
4052/**
4053 * gpiod_get_optional - obtain an optional GPIO for a given GPIO function
4054 * @dev: GPIO consumer, can be NULL for system-global GPIOs
4055 * @con_id: function within the GPIO consumer
4056 * @flags: optional GPIO initialization flags
4057 *
4058 * This is equivalent to gpiod_get(), except that when no GPIO was assigned to
4059 * the requested function it will return NULL. This is convenient for drivers
4060 * that need to handle optional GPIOs.
4061 */
4062struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
4063                                                  const char *con_id,
4064                                                  enum gpiod_flags flags)
4065{
4066        return gpiod_get_index_optional(dev, con_id, 0, flags);
4067}
4068EXPORT_SYMBOL_GPL(gpiod_get_optional);
4069
4070
4071/**
4072 * gpiod_configure_flags - helper function to configure a given GPIO
4073 * @desc:       gpio whose value will be assigned
4074 * @con_id:     function within the GPIO consumer
4075 * @lflags:     gpio_lookup_flags - returned from of_find_gpio() or
4076 *              of_get_gpio_hog()
4077 * @dflags:     gpiod_flags - optional GPIO initialization flags
4078 *
4079 * Return 0 on success, -ENOENT if no GPIO has been assigned to the
4080 * requested function and/or index, or another IS_ERR() code if an error
4081 * occurred while trying to acquire the GPIO.
4082 */
4083int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
4084                unsigned long lflags, enum gpiod_flags dflags)
4085{
4086        int status;
4087
4088        if (lflags & GPIO_ACTIVE_LOW)
4089                set_bit(FLAG_ACTIVE_LOW, &desc->flags);
4090
4091        if (lflags & GPIO_OPEN_DRAIN)
4092                set_bit(FLAG_OPEN_DRAIN, &desc->flags);
4093        else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) {
4094                /*
4095                 * This enforces open drain mode from the consumer side.
4096                 * This is necessary for some busses like I2C, but the lookup
4097                 * should *REALLY* have specified them as open drain in the
4098                 * first place, so print a little warning here.
4099                 */
4100                set_bit(FLAG_OPEN_DRAIN, &desc->flags);
4101                gpiod_warn(desc,
4102                           "enforced open drain please flag it properly in DT/ACPI DSDT/board file\n");
4103        }
4104
4105        if (lflags & GPIO_OPEN_SOURCE)
4106                set_bit(FLAG_OPEN_SOURCE, &desc->flags);
4107
4108        if ((lflags & GPIO_PULL_UP) && (lflags & GPIO_PULL_DOWN)) {
4109                gpiod_err(desc,
4110                          "both pull-up and pull-down enabled, invalid configuration\n");
4111                return -EINVAL;
4112        }
4113
4114        if (lflags & GPIO_PULL_UP)
4115                set_bit(FLAG_PULL_UP, &desc->flags);
4116        else if (lflags & GPIO_PULL_DOWN)
4117                set_bit(FLAG_PULL_DOWN, &desc->flags);
4118
4119        status = gpiod_set_transitory(desc, (lflags & GPIO_TRANSITORY));
4120        if (status < 0)
4121                return status;
4122
4123        /* No particular flag request, return here... */
4124        if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
4125                pr_debug("no flags found for %s\n", con_id);
4126                return 0;
4127        }
4128
4129        /* Process flags */
4130        if (dflags & GPIOD_FLAGS_BIT_DIR_OUT)
4131                status = gpiod_direction_output(desc,
4132                                !!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
4133        else
4134                status = gpiod_direction_input(desc);
4135
4136        return status;
4137}
4138
4139/**
4140 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
4141 * @dev:        GPIO consumer, can be NULL for system-global GPIOs
4142 * @con_id:     function within the GPIO consumer
4143 * @idx:        index of the GPIO to obtain in the consumer
4144 * @flags:      optional GPIO initialization flags
4145 *
4146 * This variant of gpiod_get() allows to access GPIOs other than the first
4147 * defined one for functions that define several GPIOs.
4148 *
4149 * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
4150 * requested function and/or index, or another IS_ERR() code if an error
4151 * occurred while trying to acquire the GPIO.
4152 */
4153struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
4154                                               const char *con_id,
4155                                               unsigned int idx,
4156                                               enum gpiod_flags flags)
4157{
4158        struct gpio_desc *desc = NULL;
4159        int status;
4160        enum gpio_lookup_flags lookupflags = 0;
4161        /* Maybe we have a device name, maybe not */
4162        const char *devname = dev ? dev_name(dev) : "?";
4163
4164        dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
4165
4166        if (dev) {
4167                /* Using device tree? */
4168                if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
4169                        dev_dbg(dev, "using device tree for GPIO lookup\n");
4170                        desc = of_find_gpio(dev, con_id, idx, &lookupflags);
4171                } else if (ACPI_COMPANION(dev)) {
4172                        dev_dbg(dev, "using ACPI for GPIO lookup\n");
4173                        desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags);
4174                }
4175        }
4176
4177        /*
4178         * Either we are not using DT or ACPI, or their lookup did not return
4179         * a result. In that case, use platform lookup as a fallback.
4180         */
4181        if (!desc || desc == ERR_PTR(-ENOENT)) {
4182                dev_dbg(dev, "using lookup tables for GPIO lookup\n");
4183                desc = gpiod_find(dev, con_id, idx, &lookupflags);
4184        }
4185
4186        if (IS_ERR(desc)) {
4187                dev_dbg(dev, "No GPIO consumer %s found\n", con_id);
4188                return desc;
4189        }
4190
4191        /*
4192         * If a connection label was passed use that, else attempt to use
4193         * the device name as label
4194         */
4195        status = gpiod_request(desc, con_id ? con_id : devname);
4196        if (status < 0) {
4197                if (status == -EBUSY && flags & GPIOD_FLAGS_BIT_NONEXCLUSIVE) {
4198                        /*
4199                         * This happens when there are several consumers for
4200                         * the same GPIO line: we just return here without
4201                         * further initialization. It is a bit if a hack.
4202                         * This is necessary to support fixed regulators.
4203                         *
4204                         * FIXME: Make this more sane and safe.
4205                         */
4206                        dev_info(dev, "nonexclusive access to GPIO for %s\n",
4207                                 con_id ? con_id : devname);
4208                        return desc;
4209                } else {
4210                        return ERR_PTR(status);
4211                }
4212        }
4213
4214        status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
4215        if (status < 0) {
4216                dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
4217                gpiod_put(desc);
4218                return ERR_PTR(status);
4219        }
4220
4221        return desc;
4222}
4223EXPORT_SYMBOL_GPL(gpiod_get_index);
4224
4225/**
4226 * gpiod_get_from_of_node() - obtain a GPIO from an OF node
4227 * @node:       handle of the OF node
4228 * @propname:   name of the DT property representing the GPIO
4229 * @index:      index of the GPIO to obtain for the consumer
4230 * @dflags:     GPIO initialization flags
4231 * @label:      label to attach to the requested GPIO
4232 *
4233 * Returns:
4234 * On successful request the GPIO pin is configured in accordance with
4235 * provided @dflags. If the node does not have the requested GPIO
4236 * property, NULL is returned.
4237 *
4238 * In case of error an ERR_PTR() is returned.
4239 */
4240struct gpio_desc *gpiod_get_from_of_node(struct device_node *node,
4241                                         const char *propname, int index,
4242                                         enum gpiod_flags dflags,
4243                                         const char *label)
4244{
4245        struct gpio_desc *desc;
4246        unsigned long lflags = 0;
4247        enum of_gpio_flags flags;
4248        bool active_low = false;
4249        bool single_ended = false;
4250        bool open_drain = false;
4251        bool transitory = false;
4252        int ret;
4253
4254        desc = of_get_named_gpiod_flags(node, propname,
4255                                        index, &flags);
4256
4257        if (!desc || IS_ERR(desc)) {
4258                /* If it is not there, just return NULL */
4259                if (PTR_ERR(desc) == -ENOENT)
4260                        return NULL;
4261                return desc;
4262        }
4263
4264        active_low = flags & OF_GPIO_ACTIVE_LOW;
4265        single_ended = flags & OF_GPIO_SINGLE_ENDED;
4266        open_drain = flags & OF_GPIO_OPEN_DRAIN;
4267        transitory = flags & OF_GPIO_TRANSITORY;
4268
4269        ret = gpiod_request(desc, label);
4270        if (ret == -EBUSY && (flags & GPIOD_FLAGS_BIT_NONEXCLUSIVE))
4271                return desc;
4272        if (ret)
4273                return ERR_PTR(ret);
4274
4275        if (active_low)
4276                lflags |= GPIO_ACTIVE_LOW;
4277
4278        if (single_ended) {
4279                if (open_drain)
4280                        lflags |= GPIO_OPEN_DRAIN;
4281                else
4282                        lflags |= GPIO_OPEN_SOURCE;
4283        }
4284
4285        if (transitory)
4286                lflags |= GPIO_TRANSITORY;
4287
4288        ret = gpiod_configure_flags(desc, propname, lflags, dflags);
4289        if (ret < 0) {
4290                gpiod_put(desc);
4291                return ERR_PTR(ret);
4292        }
4293
4294        return desc;
4295}
4296EXPORT_SYMBOL(gpiod_get_from_of_node);
4297
4298/**
4299 * fwnode_get_named_gpiod - obtain a GPIO from firmware node
4300 * @fwnode:     handle of the firmware node
4301 * @propname:   name of the firmware property representing the GPIO
4302 * @index:      index of the GPIO to obtain for the consumer
4303 * @dflags:     GPIO initialization flags
4304 * @label:      label to attach to the requested GPIO
4305 *
4306 * This function can be used for drivers that get their configuration
4307 * from opaque firmware.
4308 *
4309 * The function properly finds the corresponding GPIO using whatever is the
4310 * underlying firmware interface and then makes sure that the GPIO
4311 * descriptor is requested before it is returned to the caller.
4312 *
4313 * Returns:
4314 * On successful request the GPIO pin is configured in accordance with
4315 * provided @dflags.
4316 *
4317 * In case of error an ERR_PTR() is returned.
4318 */
4319struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
4320                                         const char *propname, int index,
4321                                         enum gpiod_flags dflags,
4322                                         const char *label)
4323{
4324        struct gpio_desc *desc = ERR_PTR(-ENODEV);
4325        unsigned long lflags = 0;
4326        int ret;
4327
4328        if (!fwnode)
4329                return ERR_PTR(-EINVAL);
4330
4331        if (is_of_node(fwnode)) {
4332                desc = gpiod_get_from_of_node(to_of_node(fwnode),
4333                                              propname, index,
4334                                              dflags,
4335                                              label);
4336                return desc;
4337        } else if (is_acpi_node(fwnode)) {
4338                struct acpi_gpio_info info;
4339
4340                desc = acpi_node_get_gpiod(fwnode, propname, index, &info);
4341                if (IS_ERR(desc))
4342                        return desc;
4343
4344                acpi_gpio_update_gpiod_flags(&dflags, &info);
4345
4346                if (info.polarity == GPIO_ACTIVE_LOW)
4347                        lflags |= GPIO_ACTIVE_LOW;
4348        }
4349
4350        /* Currently only ACPI takes this path */
4351        ret = gpiod_request(desc, label);
4352        if (ret)
4353                return ERR_PTR(ret);
4354
4355        ret = gpiod_configure_flags(desc, propname, lflags, dflags);
4356        if (ret < 0) {
4357                gpiod_put(desc);
4358                return ERR_PTR(ret);
4359        }
4360
4361        return desc;
4362}
4363EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);
4364
4365/**
4366 * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
4367 *                            function
4368 * @dev: GPIO consumer, can be NULL for system-global GPIOs
4369 * @con_id: function within the GPIO consumer
4370 * @index: index of the GPIO to obtain in the consumer
4371 * @flags: optional GPIO initialization flags
4372 *
4373 * This is equivalent to gpiod_get_index(), except that when no GPIO with the
4374 * specified index was assigned to the requested function it will return NULL.
4375 * This is convenient for drivers that need to handle optional GPIOs.
4376 */
4377struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
4378                                                        const char *con_id,
4379                                                        unsigned int index,
4380                                                        enum gpiod_flags flags)
4381{
4382        struct gpio_desc *desc;
4383
4384        desc = gpiod_get_index(dev, con_id, index, flags);
4385        if (IS_ERR(desc)) {
4386                if (PTR_ERR(desc) == -ENOENT)
4387                        return NULL;
4388        }
4389
4390        return desc;
4391}
4392EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
4393
4394/**
4395 * gpiod_hog - Hog the specified GPIO desc given the provided flags
4396 * @desc:       gpio whose value will be assigned
4397 * @name:       gpio line name
4398 * @lflags:     gpio_lookup_flags - returned from of_find_gpio() or
4399 *              of_get_gpio_hog()
4400 * @dflags:     gpiod_flags - optional GPIO initialization flags
4401 */
4402int gpiod_hog(struct gpio_desc *desc, const char *name,
4403              unsigned long lflags, enum gpiod_flags dflags)
4404{
4405        struct gpio_chip *chip;
4406        struct gpio_desc *local_desc;
4407        int hwnum;
4408        int status;
4409
4410        chip = gpiod_to_chip(desc);
4411        hwnum = gpio_chip_hwgpio(desc);
4412
4413        /*
4414         * FIXME: not very elegant that we call gpiod_configure_flags()
4415         * twice here (once inside gpiochip_request_own_desc() and
4416         * again here), but the gpiochip_request_own_desc() is external
4417         * and cannot really pass the lflags so this is the lesser evil
4418         * at the moment. Pass zero as dflags on this first call so we
4419         * don't screw anything up.
4420         */
4421        local_desc = gpiochip_request_own_desc(chip, hwnum, name, 0);
4422        if (IS_ERR(local_desc)) {
4423                status = PTR_ERR(local_desc);
4424                pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n",
4425                       name, chip->label, hwnum, status);
4426                return status;
4427        }
4428
4429        status = gpiod_configure_flags(desc, name, lflags, dflags);
4430        if (status < 0) {
4431                pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
4432                       name, chip->label, hwnum, status);
4433                gpiochip_free_own_desc(desc);
4434                return status;
4435        }
4436
4437        /* Mark GPIO as hogged so it can be identified and removed later */
4438        set_bit(FLAG_IS_HOGGED, &desc->flags);
4439
4440        pr_info("GPIO line %d (%s) hogged as %s%s\n",
4441                desc_to_gpio(desc), name,
4442                (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
4443                (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ?
4444                  (dflags&GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low":"");
4445
4446        return 0;
4447}
4448
4449/**
4450 * gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog
4451 * @chip:       gpio chip to act on
4452 *
4453 * This is only used by of_gpiochip_remove to free hogged gpios
4454 */
4455static void gpiochip_free_hogs(struct gpio_chip *chip)
4456{
4457        int id;
4458
4459        for (id = 0; id < chip->ngpio; id++) {
4460                if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
4461                        gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
4462        }
4463}
4464
4465/**
4466 * gpiod_get_array - obtain multiple GPIOs from a multi-index GPIO function
4467 * @dev:        GPIO consumer, can be NULL for system-global GPIOs
4468 * @con_id:     function within the GPIO consumer
4469 * @flags:      optional GPIO initialization flags
4470 *
4471 * This function acquires all the GPIOs defined under a given function.
4472 *
4473 * Return a struct gpio_descs containing an array of descriptors, -ENOENT if
4474 * no GPIO has been assigned to the requested function, or another IS_ERR()
4475 * code if an error occurred while trying to acquire the GPIOs.
4476 */
4477struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
4478                                                const char *con_id,
4479                                                enum gpiod_flags flags)
4480{
4481        struct gpio_desc *desc;
4482        struct gpio_descs *descs;
4483        struct gpio_array *array_info = NULL;
4484        struct gpio_chip *chip;
4485        int count, bitmap_size;
4486
4487        count = gpiod_count(dev, con_id);
4488        if (count < 0)
4489                return ERR_PTR(count);
4490
4491        descs = kzalloc(struct_size(descs, desc, count), GFP_KERNEL);
4492        if (!descs)
4493                return ERR_PTR(-ENOMEM);
4494
4495        for (descs->ndescs = 0; descs->ndescs < count; ) {
4496                desc = gpiod_get_index(dev, con_id, descs->ndescs, flags);
4497                if (IS_ERR(desc)) {
4498                        gpiod_put_array(descs);
4499                        return ERR_CAST(desc);
4500                }
4501
4502                descs->desc[descs->ndescs] = desc;
4503
4504                chip = gpiod_to_chip(desc);
4505                /*
4506                 * If pin hardware number of array member 0 is also 0, select
4507                 * its chip as a candidate for fast bitmap processing path.
4508                 */
4509                if (descs->ndescs == 0 && gpio_chip_hwgpio(desc) == 0) {
4510                        struct gpio_descs *array;
4511
4512                        bitmap_size = BITS_TO_LONGS(chip->ngpio > count ?
4513                                                    chip->ngpio : count);
4514
4515                        array = kzalloc(struct_size(descs, desc, count) +
4516                                        struct_size(array_info, invert_mask,
4517                                        3 * bitmap_size), GFP_KERNEL);
4518                        if (!array) {
4519                                gpiod_put_array(descs);
4520                                return ERR_PTR(-ENOMEM);
4521                        }
4522
4523                        memcpy(array, descs,
4524                               struct_size(descs, desc, descs->ndescs + 1));
4525                        kfree(descs);
4526
4527                        descs = array;
4528                        array_info = (void *)(descs->desc + count);
4529                        array_info->get_mask = array_info->invert_mask +
4530                                                  bitmap_size;
4531                        array_info->set_mask = array_info->get_mask +
4532                                                  bitmap_size;
4533
4534                        array_info->desc = descs->desc;
4535                        array_info->size = count;
4536                        array_info->chip = chip;
4537                        bitmap_set(array_info->get_mask, descs->ndescs,
4538                                   count - descs->ndescs);
4539                        bitmap_set(array_info->set_mask, descs->ndescs,
4540                                   count - descs->ndescs);
4541                        descs->info = array_info;
4542                }
4543                /* Unmark array members which don't belong to the 'fast' chip */
4544                if (array_info && array_info->chip != chip) {
4545                        __clear_bit(descs->ndescs, array_info->get_mask);
4546                        __clear_bit(descs->ndescs, array_info->set_mask);
4547                }
4548                /*
4549                 * Detect array members which belong to the 'fast' chip
4550                 * but their pins are not in hardware order.
4551                 */
4552                else if (array_info &&
4553                           gpio_chip_hwgpio(desc) != descs->ndescs) {
4554                        /*
4555                         * Don't use fast path if all array members processed so
4556                         * far belong to the same chip as this one but its pin
4557                         * hardware number is different from its array index.
4558                         */
4559                        if (bitmap_full(array_info->get_mask, descs->ndescs)) {
4560                                array_info = NULL;
4561                        } else {
4562                                __clear_bit(descs->ndescs,
4563                                            array_info->get_mask);
4564                                __clear_bit(descs->ndescs,
4565                                            array_info->set_mask);
4566                        }
4567                } else if (array_info) {
4568                        /* Exclude open drain or open source from fast output */
4569                        if (gpiochip_line_is_open_drain(chip, descs->ndescs) ||
4570                            gpiochip_line_is_open_source(chip, descs->ndescs))
4571                                __clear_bit(descs->ndescs,
4572                                            array_info->set_mask);
4573                        /* Identify 'fast' pins which require invertion */
4574                        if (gpiod_is_active_low(desc))
4575                                __set_bit(descs->ndescs,
4576                                          array_info->invert_mask);
4577                }
4578
4579                descs->ndescs++;
4580        }
4581        if (array_info)
4582                dev_dbg(dev,
4583                        "GPIO array info: chip=%s, size=%d, get_mask=%lx, set_mask=%lx, invert_mask=%lx\n",
4584                        array_info->chip->label, array_info->size,
4585                        *array_info->get_mask, *array_info->set_mask,
4586                        *array_info->invert_mask);
4587        return descs;
4588}
4589EXPORT_SYMBOL_GPL(gpiod_get_array);
4590
4591/**
4592 * gpiod_get_array_optional - obtain multiple GPIOs from a multi-index GPIO
4593 *                            function
4594 * @dev:        GPIO consumer, can be NULL for system-global GPIOs
4595 * @con_id:     function within the GPIO consumer
4596 * @flags:      optional GPIO initialization flags
4597 *
4598 * This is equivalent to gpiod_get_array(), except that when no GPIO was
4599 * assigned to the requested function it will return NULL.
4600 */
4601struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
4602                                                        const char *con_id,
4603                                                        enum gpiod_flags flags)
4604{
4605        struct gpio_descs *descs;
4606
4607        descs = gpiod_get_array(dev, con_id, flags);
4608        if (IS_ERR(descs) && (PTR_ERR(descs) == -ENOENT))
4609                return NULL;
4610
4611        return descs;
4612}
4613EXPORT_SYMBOL_GPL(gpiod_get_array_optional);
4614
4615/**
4616 * gpiod_put - dispose of a GPIO descriptor
4617 * @desc:       GPIO descriptor to dispose of
4618 *
4619 * No descriptor can be used after gpiod_put() has been called on it.
4620 */
4621void gpiod_put(struct gpio_desc *desc)
4622{
4623        gpiod_free(desc);
4624}
4625EXPORT_SYMBOL_GPL(gpiod_put);
4626
4627/**
4628 * gpiod_put_array - dispose of multiple GPIO descriptors
4629 * @descs:      struct gpio_descs containing an array of descriptors
4630 */
4631void gpiod_put_array(struct gpio_descs *descs)
4632{
4633        unsigned int i;
4634
4635        for (i = 0; i < descs->ndescs; i++)
4636                gpiod_put(descs->desc[i]);
4637
4638        kfree(descs);
4639}
4640EXPORT_SYMBOL_GPL(gpiod_put_array);
4641
4642static int __init gpiolib_dev_init(void)
4643{
4644        int ret;
4645
4646        /* Register GPIO sysfs bus */
4647        ret = bus_register(&gpio_bus_type);
4648        if (ret < 0) {
4649                pr_err("gpiolib: could not register GPIO bus type\n");
4650                return ret;
4651        }
4652
4653        ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, "gpiochip");
4654        if (ret < 0) {
4655                pr_err("gpiolib: failed to allocate char dev region\n");
4656                bus_unregister(&gpio_bus_type);
4657        } else {
4658                gpiolib_initialized = true;
4659                gpiochip_setup_devs();
4660        }
4661        return ret;
4662}
4663core_initcall(gpiolib_dev_init);
4664
4665#ifdef CONFIG_DEBUG_FS
4666
4667static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
4668{
4669        unsigned                i;
4670        struct gpio_chip        *chip = gdev->chip;
4671        unsigned                gpio = gdev->base;
4672        struct gpio_desc        *gdesc = &gdev->descs[0];
4673        bool                    is_out;
4674        bool                    is_irq;
4675        bool                    active_low;
4676
4677        for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
4678                if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
4679                        if (gdesc->name) {
4680                                seq_printf(s, " gpio-%-3d (%-20.20s)\n",
4681                                           gpio, gdesc->name);
4682                        }
4683                        continue;
4684                }
4685
4686                gpiod_get_direction(gdesc);
4687                is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
4688                is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
4689                active_low = test_bit(FLAG_ACTIVE_LOW, &gdesc->flags);
4690                seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s%s",
4691                        gpio, gdesc->name ? gdesc->name : "", gdesc->label,
4692                        is_out ? "out" : "in ",
4693                        chip->get ? (chip->get(chip, i) ? "hi" : "lo") : "?  ",
4694                        is_irq ? "IRQ " : "",
4695                        active_low ? "ACTIVE LOW" : "");
4696                seq_printf(s, "\n");
4697        }
4698}
4699
4700static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
4701{
4702        unsigned long flags;
4703        struct gpio_device *gdev = NULL;
4704        loff_t index = *pos;
4705
4706        s->private = "";
4707
4708        spin_lock_irqsave(&gpio_lock, flags);
4709        list_for_each_entry(gdev, &gpio_devices, list)
4710                if (index-- == 0) {
4711                        spin_unlock_irqrestore(&gpio_lock, flags);
4712                        return gdev;
4713                }
4714        spin_unlock_irqrestore(&gpio_lock, flags);
4715
4716        return NULL;
4717}
4718
4719static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
4720{
4721        unsigned long flags;
4722        struct gpio_device *gdev = v;
4723        void *ret = NULL;
4724
4725        spin_lock_irqsave(&gpio_lock, flags);
4726        if (list_is_last(&gdev->list, &gpio_devices))
4727                ret = NULL;
4728        else
4729                ret = list_entry(gdev->list.next, struct gpio_device, list);
4730        spin_unlock_irqrestore(&gpio_lock, flags);
4731
4732        s->private = "\n";
4733        ++*pos;
4734
4735        return ret;
4736}
4737
4738static void gpiolib_seq_stop(struct seq_file *s, void *v)
4739{
4740}
4741
4742static int gpiolib_seq_show(struct seq_file *s, void *v)
4743{
4744        struct gpio_device *gdev = v;
4745        struct gpio_chip *chip = gdev->chip;
4746        struct device *parent;
4747
4748        if (!chip) {
4749                seq_printf(s, "%s%s: (dangling chip)", (char *)s->private,
4750                           dev_name(&gdev->dev));
4751                return 0;
4752        }
4753
4754        seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
4755                   dev_name(&gdev->dev),
4756                   gdev->base, gdev->base + gdev->ngpio - 1);
4757        parent = chip->parent;
4758        if (parent)
4759                seq_printf(s, ", parent: %s/%s",
4760                           parent->bus ? parent->bus->name : "no-bus",
4761                           dev_name(parent));
4762        if (chip->label)
4763                seq_printf(s, ", %s", chip->label);
4764        if (chip->can_sleep)
4765                seq_printf(s, ", can sleep");
4766        seq_printf(s, ":\n");
4767
4768        if (chip->dbg_show)
4769                chip->dbg_show(s, chip);
4770        else
4771                gpiolib_dbg_show(s, gdev);
4772
4773        return 0;
4774}
4775
4776static const struct seq_operations gpiolib_seq_ops = {
4777        .start = gpiolib_seq_start,
4778        .next = gpiolib_seq_next,
4779        .stop = gpiolib_seq_stop,
4780        .show = gpiolib_seq_show,
4781};
4782
4783static int gpiolib_open(struct inode *inode, struct file *file)
4784{
4785        return seq_open(file, &gpiolib_seq_ops);
4786}
4787
4788static const struct file_operations gpiolib_operations = {
4789        .owner          = THIS_MODULE,
4790        .open           = gpiolib_open,
4791        .read           = seq_read,
4792        .llseek         = seq_lseek,
4793        .release        = seq_release,
4794};
4795
4796static int __init gpiolib_debugfs_init(void)
4797{
4798        /* /sys/kernel/debug/gpio */
4799        (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
4800                                NULL, NULL, &gpiolib_operations);
4801        return 0;
4802}
4803subsys_initcall(gpiolib_debugfs_init);
4804
4805#endif  /* DEBUG_FS */
4806