Merge tag 'gpio-v4.15-1' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio

Pull GPIO updates from Linus Walleij:
 "This is the bulk of GPIO changes for the v4.15 kernel cycle:

  Core:

   - Fix the semantics of raw GPIO to actually be raw. No inversion
     semantics as before, but also no open draining, and allow the raw
     operations to affect lines used for interrupts as the caller
     supposedly knows what they are doing if they are getting the big
     hammer.

   - Rewrote the __inner_function() notation calls to names that make
     more sense. I just find this kind of code disturbing.

   - Drop the .irq_base() field from the gpiochip since now all IRQs are
     mapped dynamically. This is nice.

   - Support for .get_multiple() in the core driver API. This allows us
     to read several GPIO lines with a single register read. This has
     high value for some usecases: it can be used to create
     oscilloscopes and signal analyzers and other things that rely on
     reading several lines at exactly the same instant. Also a generally
     nice optimization. This uses the new assign_bit() macro from the
     bitops lib that was ACKed by Andrew Morton and is implemented for
     two drivers, one of them being the generic MMIO driver so everyone
     using that will be able to benefit from this.

   - Do not allow requests of Open Drain and Open Source setting of a
     GPIO line simultaneously. If the hardware actually supports
     enabling both at the same time the electrical result would be
     disastrous.

   - A new interrupt chip core helper. This will be helpful to deal with
     "banked" GPIOs, which means GPIO controllers with several logical
     blocks of GPIO inside them. This is several gpiochips per device in
     the device model, in contrast to the case when there is a 1-to-1
     relationship between a device and a gpiochip.

  New drivers:

   - Maxim MAX3191x industrial serializer, a very interesting piece of
     professional I/O hardware.

   - Uniphier GPIO driver. This is the GPIO block from the recent
     Socionext (ex Fujitsu and Panasonic) platform.

   - Tegra 186 driver. This is based on the new banked GPIO
     infrastructure.

  Other improvements:

   - Some documentation improvements.

   - Wakeup support for the DesignWare DWAPB GPIO controller.

   - Reset line support on the DesignWare DWAPB GPIO controller.

   - Several non-critical bug fixes and improvements for the Broadcom
     BRCMSTB driver.

   - Misc non-critical bug fixes like exotic errorpaths, removal of dead
     code etc.

   - Explicit comments on fall-through switch() statements"

* tag 'gpio-v4.15-1' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio: (65 commits)
  gpio: tegra186: Remove tegra186_gpio_lock_class
  gpio: rcar: Add r8a77995 (R-Car D3) support
  pinctrl: bcm2835: Fix some merge fallout
  gpio: Fix undefined lock_dep_class
  gpio: Automatically add lockdep keys
  gpio: Introduce struct gpio_irq_chip.first
  gpio: Disambiguate struct gpio_irq_chip.nested
  gpio: Add Tegra186 support
  gpio: Export gpiochip_irq_{map,unmap}()
  gpio: Implement tighter IRQ chip integration
  gpio: Move lock_key into struct gpio_irq_chip
  gpio: Move irq_valid_mask into struct gpio_irq_chip
  gpio: Move irq_nested into struct gpio_irq_chip
  gpio: Move irq_chained_parent to struct gpio_irq_chip
  gpio: Move irq_default_type to struct gpio_irq_chip
  gpio: Move irq_handler to struct gpio_irq_chip
  gpio: Move irqdomain into struct gpio_irq_chip
  gpio: Move irqchip into struct gpio_irq_chip
  gpio: Introduce struct gpio_irq_chip
  pinctrl: armada-37xx: remove unused variable
  ...

1 files changed, 423 insertions, 159 deletions

diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index eb80dac4e26a..86dcd02cf602 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -72,6 +72,8 @@ static LIST_HEAD(gpio_lookup_list);
 LIST_HEAD(gpio_devices);
 
 static void gpiochip_free_hogs(struct gpio_chip *chip);
+static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
+                                struct lock_class_key *key);
 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
@@ -365,28 +367,28 @@ static long linehandle_ioctl(struct file *filep, unsigned int cmd,
         struct linehandle_state *lh = filep->private_data;
         void __user *ip = (void __user *)arg;
         struct gpiohandle_data ghd;
+        int vals[GPIOHANDLES_MAX];
         int i;
 
         if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
-                int val;
+                /* TODO: check if descriptors are really input */
+                int ret = gpiod_get_array_value_complex(false,
+                                                        true,
+                                                        lh->numdescs,
+                                                        lh->descs,
+                                                        vals);
+                if (ret)
+                        return ret;
 
                 memset(&ghd, 0, sizeof(ghd));
-
-                /* TODO: check if descriptors are really input */
-                for (i = 0; i < lh->numdescs; i++) {
-                        val = gpiod_get_value_cansleep(lh->descs[i]);
-                        if (val < 0)
-                                return val;
-                        ghd.values[i] = val;
-                }
+                for (i = 0; i < lh->numdescs; i++)
+                        ghd.values[i] = vals[i];
 
                 if (copy_to_user(ip, &ghd, sizeof(ghd)))
                         return -EFAULT;
 
                 return 0;
         } else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
-                int vals[GPIOHANDLES_MAX];
-
                 /* TODO: check if descriptors are really output */
                 if (copy_from_user(&ghd, ip, sizeof(ghd)))
                         return -EFAULT;
@@ -444,12 +446,25 @@ static int linehandle_create(struct gpio_device *gdev, void __user *ip)
         struct linehandle_state *lh;
         struct file *file;
         int fd, i, ret;
+        u32 lflags;
 
         if (copy_from_user(&handlereq, ip, sizeof(handlereq)))
                 return -EFAULT;
         if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX))
                 return -EINVAL;
 
+        lflags = handlereq.flags;
+
+        /* Return an error if an unknown flag is set */
+        if (lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS)
+                return -EINVAL;
+
+        /* OPEN_DRAIN and OPEN_SOURCE flags only make sense for output mode. */
+        if (!(lflags & GPIOHANDLE_REQUEST_OUTPUT) &&
+            ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
+             (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)))
+                return -EINVAL;
+
         lh = kzalloc(sizeof(*lh), GFP_KERNEL);
         if (!lh)
                 return -ENOMEM;
@@ -470,7 +485,6 @@ static int linehandle_create(struct gpio_device *gdev, void __user *ip)
         /* Request each GPIO */
         for (i = 0; i < handlereq.lines; i++) {
                 u32 offset = handlereq.lineoffsets[i];
-                u32 lflags = handlereq.flags;
                 struct gpio_desc *desc;
 
                 if (offset >= gdev->ngpio) {
@@ -478,12 +492,6 @@ static int linehandle_create(struct gpio_device *gdev, void __user *ip)
                         goto out_free_descs;
                 }
 
-                /* Return an error if a unknown flag is set */
-                if (lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) {
-                        ret = -EINVAL;
-                        goto out_free_descs;
-                }
-
                 desc = &gdev->descs[offset];
                 ret = gpiod_request(desc, lh->label);
                 if (ret)
@@ -1091,30 +1099,8 @@ static void gpiochip_setup_devs(void)
         }
 }
 
-/**
- * gpiochip_add_data() - register a gpio_chip
- * @chip: the chip to register, with chip->base initialized
- * @data: driver-private data associated with this chip
- *
- * Context: potentially before irqs will work
- *
- * When gpiochip_add_data() is called very early during boot, so that GPIOs
- * can be freely used, the chip->parent device must be registered before
- * the gpio framework's arch_initcall().  Otherwise sysfs initialization
- * for GPIOs will fail rudely.
- *
- * gpiochip_add_data() must only be called after gpiolib initialization,
- * ie after core_initcall().
- *
- * If chip->base is negative, this requests dynamic assignment of
- * a range of valid GPIOs.
- *
- * Returns:
- * A negative errno if the chip can't be registered, such as because the
- * chip->base is invalid or already associated with a different chip.
- * Otherwise it returns zero as a success code.
- */
-int gpiochip_add_data(struct gpio_chip *chip, void *data)
+int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
+                               struct lock_class_key *key)
 {
         unsigned long   flags;
         int             status = 0;
@@ -1260,6 +1246,10 @@ int gpiochip_add_data(struct gpio_chip *chip, void *data)
         if (status)
                 goto err_remove_from_list;
 
+        status = gpiochip_add_irqchip(chip, key);
+        if (status)
+                goto err_remove_chip;
+
         status = of_gpiochip_add(chip);
         if (status)
                 goto err_remove_chip;
@@ -1303,7 +1293,7 @@ err_free_gdev:
         kfree(gdev);
         return status;
 }
-EXPORT_SYMBOL_GPL(gpiochip_add_data);
+EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);
 
 /**
  * gpiochip_get_data() - get per-subdriver data for the chip
@@ -1498,33 +1488,33 @@ static struct gpio_chip *find_chip_by_name(const char *name)
 
 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
 {
-        if (!gpiochip->irq_need_valid_mask)
+        if (!gpiochip->irq.need_valid_mask)
                 return 0;
 
-        gpiochip->irq_valid_mask = kcalloc(BITS_TO_LONGS(gpiochip->ngpio),
+        gpiochip->irq.valid_mask = kcalloc(BITS_TO_LONGS(gpiochip->ngpio),
                                            sizeof(long), GFP_KERNEL);
-        if (!gpiochip->irq_valid_mask)
+        if (!gpiochip->irq.valid_mask)
                 return -ENOMEM;
 
         /* Assume by default all GPIOs are valid */
-        bitmap_fill(gpiochip->irq_valid_mask, gpiochip->ngpio);
+        bitmap_fill(gpiochip->irq.valid_mask, gpiochip->ngpio);
 
         return 0;
 }
 
 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
 {
-        kfree(gpiochip->irq_valid_mask);
-        gpiochip->irq_valid_mask = NULL;
+        kfree(gpiochip->irq.valid_mask);
+        gpiochip->irq.valid_mask = NULL;
 }
 
 static bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
                                        unsigned int offset)
 {
         /* No mask means all valid */
-        if (likely(!gpiochip->irq_valid_mask))
+        if (likely(!gpiochip->irq.valid_mask))
                 return true;
-        return test_bit(offset, gpiochip->irq_valid_mask);
+        return test_bit(offset, gpiochip->irq.valid_mask);
 }
 
 /**
@@ -1544,7 +1534,7 @@ static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
 {
         unsigned int offset;
 
-        if (!gpiochip->irqdomain) {
+        if (!gpiochip->irq.domain) {
                 chip_err(gpiochip, "called %s before setting up irqchip\n",
                          __func__);
                 return;
@@ -1564,14 +1554,15 @@ static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
                 irq_set_chained_handler_and_data(parent_irq, parent_handler,
                                                  gpiochip);
 
-                gpiochip->irq_chained_parent = parent_irq;
+                gpiochip->irq.parents = &parent_irq;
+                gpiochip->irq.num_parents = 1;
         }
 
         /* Set the parent IRQ for all affected IRQs */
         for (offset = 0; offset < gpiochip->ngpio; offset++) {
                 if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
                         continue;
-                irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
+                irq_set_parent(irq_find_mapping(gpiochip->irq.domain, offset),
                                parent_irq);
         }
 }
@@ -1591,6 +1582,11 @@ void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
                                   unsigned int parent_irq,
                                   irq_flow_handler_t parent_handler)
 {
+        if (gpiochip->irq.threaded) {
+                chip_err(gpiochip, "tried to chain a threaded gpiochip\n");
+                return;
+        }
+
         gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
                                       parent_handler);
 }
@@ -1607,10 +1603,6 @@ void gpiochip_set_nested_irqchip(struct gpio_chip *gpiochip,
                                  struct irq_chip *irqchip,
                                  unsigned int parent_irq)
 {
-        if (!gpiochip->irq_nested) {
-                chip_err(gpiochip, "tried to nest a chained gpiochip\n");
-                return;
-        }
         gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
                                       NULL);
 }
@@ -1626,10 +1618,11 @@ EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);
  * gpiochip by assigning the gpiochip as chip data, and using the irqchip
  * stored inside the gpiochip.
  */
-static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
-                            irq_hw_number_t hwirq)
+int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
+                     irq_hw_number_t hwirq)
 {
         struct gpio_chip *chip = d->host_data;
+        int err = 0;
 
         if (!gpiochip_irqchip_irq_valid(chip, hwirq))
                 return -ENXIO;
@@ -1639,32 +1632,42 @@ static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
          * This lock class tells lockdep that GPIO irqs are in a different
          * category than their parents, so it won't report false recursion.
          */
-        irq_set_lockdep_class(irq, chip->lock_key);
-        irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
+        irq_set_lockdep_class(irq, chip->irq.lock_key);
+        irq_set_chip_and_handler(irq, chip->irq.chip, chip->irq.handler);
         /* Chips that use nested thread handlers have them marked */
-        if (chip->irq_nested)
+        if (chip->irq.threaded)
                 irq_set_nested_thread(irq, 1);
         irq_set_noprobe(irq);
 
+        if (chip->irq.num_parents == 1)
+                err = irq_set_parent(irq, chip->irq.parents[0]);
+        else if (chip->irq.map)
+                err = irq_set_parent(irq, chip->irq.map[hwirq]);
+
+        if (err < 0)
+                return err;
+
         /*
          * No set-up of the hardware will happen if IRQ_TYPE_NONE
          * is passed as default type.
          */
-        if (chip->irq_default_type != IRQ_TYPE_NONE)
-                irq_set_irq_type(irq, chip->irq_default_type);
+        if (chip->irq.default_type != IRQ_TYPE_NONE)
+                irq_set_irq_type(irq, chip->irq.default_type);
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(gpiochip_irq_map);
 
-static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
+void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
 {
         struct gpio_chip *chip = d->host_data;
 
-        if (chip->irq_nested)
+        if (chip->irq.threaded)
                 irq_set_nested_thread(irq, 0);
         irq_set_chip_and_handler(irq, NULL, NULL);
         irq_set_chip_data(irq, NULL);
 }
+EXPORT_SYMBOL_GPL(gpiochip_irq_unmap);
 
 static const struct irq_domain_ops gpiochip_domain_ops = {
         .map    = gpiochip_irq_map,
@@ -1702,7 +1705,94 @@ static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
 {
         if (!gpiochip_irqchip_irq_valid(chip, offset))
                 return -ENXIO;
-        return irq_create_mapping(chip->irqdomain, offset);
+
+        return irq_create_mapping(chip->irq.domain, offset);
+}
+
+/**
+ * gpiochip_add_irqchip() - adds an IRQ chip to a GPIO chip
+ * @gpiochip: the GPIO chip to add the IRQ chip to
+ * @lock_key: lockdep class
+ */
+static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
+                                struct lock_class_key *lock_key)
+{
+        struct irq_chip *irqchip = gpiochip->irq.chip;
+        const struct irq_domain_ops *ops;
+        struct device_node *np;
+        unsigned int type;
+        unsigned int i;
+
+        if (!irqchip)
+                return 0;
+
+        if (gpiochip->irq.parent_handler && gpiochip->can_sleep) {
+                chip_err(gpiochip, "you cannot have chained interrupts on a "
+                         "chip that may sleep\n");
+                return -EINVAL;
+        }
+
+        np = gpiochip->gpiodev->dev.of_node;
+        type = gpiochip->irq.default_type;
+
+        /*
+         * Specifying a default trigger is a terrible idea if DT or ACPI is
+         * used to configure the interrupts, as you may end up with
+         * conflicting triggers. Tell the user, and reset to NONE.
+         */
+        if (WARN(np && type != IRQ_TYPE_NONE,
+                 "%s: Ignoring %u default trigger\n", np->full_name, type))
+                type = IRQ_TYPE_NONE;
+
+        if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
+                acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
+                                 "Ignoring %u default trigger\n", type);
+                type = IRQ_TYPE_NONE;
+        }
+
+        gpiochip->to_irq = gpiochip_to_irq;
+        gpiochip->irq.default_type = type;
+        gpiochip->irq.lock_key = lock_key;
+
+        if (gpiochip->irq.domain_ops)
+                ops = gpiochip->irq.domain_ops;
+        else
+                ops = &gpiochip_domain_ops;
+
+        gpiochip->irq.domain = irq_domain_add_simple(np, gpiochip->ngpio,
+                                                     gpiochip->irq.first,
+                                                     ops, gpiochip);
+        if (!gpiochip->irq.domain)
+                return -EINVAL;
+
+        /*
+         * It is possible for a driver to override this, but only if the
+         * alternative functions are both implemented.
+         */
+        if (!irqchip->irq_request_resources &&
+            !irqchip->irq_release_resources) {
+                irqchip->irq_request_resources = gpiochip_irq_reqres;
+                irqchip->irq_release_resources = gpiochip_irq_relres;
+        }
+
+        if (gpiochip->irq.parent_handler) {
+                void *data = gpiochip->irq.parent_handler_data ?: gpiochip;
+
+                for (i = 0; i < gpiochip->irq.num_parents; i++) {
+                        /*
+                         * The parent IRQ chip is already using the chip_data
+                         * for this IRQ chip, so our callbacks simply use the
+                         * handler_data.
+                         */
+                        irq_set_chained_handler_and_data(gpiochip->irq.parents[i],
+                                                         gpiochip->irq.parent_handler,
+                                                         data);
+                }
+        }
+
+        acpi_gpiochip_request_interrupts(gpiochip);
+
+        return 0;
 }
 
 /**
@@ -1717,26 +1807,34 @@ static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
 
         acpi_gpiochip_free_interrupts(gpiochip);
 
-        if (gpiochip->irq_chained_parent) {
-                irq_set_chained_handler(gpiochip->irq_chained_parent, NULL);
-                irq_set_handler_data(gpiochip->irq_chained_parent, NULL);
+        if (gpiochip->irq.chip && gpiochip->irq.parent_handler) {
+                struct gpio_irq_chip *irq = &gpiochip->irq;
+                unsigned int i;
+
+                for (i = 0; i < irq->num_parents; i++)
+                        irq_set_chained_handler_and_data(irq->parents[i],
+                                                         NULL, NULL);
         }
 
         /* Remove all IRQ mappings and delete the domain */
-        if (gpiochip->irqdomain) {
+        if (gpiochip->irq.domain) {
+                unsigned int irq;
+
                 for (offset = 0; offset < gpiochip->ngpio; offset++) {
                         if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
                                 continue;
-                        irq_dispose_mapping(
-                                irq_find_mapping(gpiochip->irqdomain, offset));
+
+                        irq = irq_find_mapping(gpiochip->irq.domain, offset);
+                        irq_dispose_mapping(irq);
                 }
-                irq_domain_remove(gpiochip->irqdomain);
+
+                irq_domain_remove(gpiochip->irq.domain);
         }
 
-        if (gpiochip->irqchip) {
-                gpiochip->irqchip->irq_request_resources = NULL;
-                gpiochip->irqchip->irq_release_resources = NULL;
-                gpiochip->irqchip = NULL;
+        if (gpiochip->irq.chip) {
+                gpiochip->irq.chip->irq_request_resources = NULL;
+                gpiochip->irq.chip->irq_release_resources = NULL;
+                gpiochip->irq.chip = NULL;
         }
 
         gpiochip_irqchip_free_valid_mask(gpiochip);
@@ -1751,8 +1849,7 @@ static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
  * @handler: the irq handler to use (often a predefined irq core function)
  * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
  * to have the core avoid setting up any default type in the hardware.
- * @nested: whether this is a nested irqchip calling handle_nested_irq()
- * in its IRQ handler
+ * @threaded: whether this irqchip uses a nested thread handler
  * @lock_key: lockdep class
  *
  * This function closely associates a certain irqchip with a certain
@@ -1774,7 +1871,7 @@ int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
                              unsigned int first_irq,
                              irq_flow_handler_t handler,
                              unsigned int type,
-                             bool nested,
+                             bool threaded,
                              struct lock_class_key *lock_key)
 {
         struct device_node *of_node;
@@ -1786,7 +1883,7 @@ int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
                 pr_err("missing gpiochip .dev parent pointer\n");
                 return -EINVAL;
         }
-        gpiochip->irq_nested = nested;
+        gpiochip->irq.threaded = threaded;
         of_node = gpiochip->parent->of_node;
 #ifdef CONFIG_OF_GPIO
         /*
@@ -1811,16 +1908,16 @@ int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
                 type = IRQ_TYPE_NONE;
         }
 
-        gpiochip->irqchip = irqchip;
-        gpiochip->irq_handler = handler;
-        gpiochip->irq_default_type = type;
+        gpiochip->irq.chip = irqchip;
+        gpiochip->irq.handler = handler;
+        gpiochip->irq.default_type = type;
         gpiochip->to_irq = gpiochip_to_irq;
-        gpiochip->lock_key = lock_key;
-        gpiochip->irqdomain = irq_domain_add_simple(of_node,
+        gpiochip->irq.lock_key = lock_key;
+        gpiochip->irq.domain = irq_domain_add_simple(of_node,
                                         gpiochip->ngpio, first_irq,
                                         &gpiochip_domain_ops, gpiochip);
-        if (!gpiochip->irqdomain) {
-                gpiochip->irqchip = NULL;
+        if (!gpiochip->irq.domain) {
+                gpiochip->irq.chip = NULL;
                 return -EINVAL;
         }
 
@@ -1842,6 +1939,12 @@ EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
 
 #else /* CONFIG_GPIOLIB_IRQCHIP */
 
+static inline int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
+                                       struct lock_class_key *key)
+{
+        return 0;
+}
+
 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
 static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
 {
@@ -2013,7 +2116,7 @@ EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
  * on each other, and help provide better diagnostics in debugfs.
  * They're called even less than the "set direction" calls.
  */
-static int __gpiod_request(struct gpio_desc *desc, const char *label)
+static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
 {
         struct gpio_chip        *chip = desc->gdev->chip;
         int                     status;
@@ -2106,7 +2209,7 @@ int gpiod_request(struct gpio_desc *desc, const char *label)
         gdev = desc->gdev;
 
         if (try_module_get(gdev->owner)) {
-                status = __gpiod_request(desc, label);
+                status = gpiod_request_commit(desc, label);
                 if (status < 0)
                         module_put(gdev->owner);
                 else
@@ -2119,7 +2222,7 @@ int gpiod_request(struct gpio_desc *desc, const char *label)
         return status;
 }
 
-static bool __gpiod_free(struct gpio_desc *desc)
+static bool gpiod_free_commit(struct gpio_desc *desc)
 {
         bool                    ret = false;
         unsigned long           flags;
@@ -2154,7 +2257,7 @@ static bool __gpiod_free(struct gpio_desc *desc)
 
 void gpiod_free(struct gpio_desc *desc)
 {
-        if (desc && desc->gdev && __gpiod_free(desc)) {
+        if (desc && desc->gdev && gpiod_free_commit(desc)) {
                 module_put(desc->gdev->owner);
                 put_device(&desc->gdev->dev);
         } else {
@@ -2217,7 +2320,7 @@ struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
                 return desc;
         }
 
-        err = __gpiod_request(desc, label);
+        err = gpiod_request_commit(desc, label);
         if (err < 0)
                 return ERR_PTR(err);
 
@@ -2235,7 +2338,7 @@ EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
 void gpiochip_free_own_desc(struct gpio_desc *desc)
 {
         if (desc)
-                __gpiod_free(desc);
+                gpiod_free_commit(desc);
 }
 EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
 
@@ -2291,44 +2394,12 @@ static int gpio_set_drive_single_ended(struct gpio_chip *gc, unsigned offset,
         return gc->set_config ? gc->set_config(gc, offset, config) : -ENOTSUPP;
 }
 
-static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
+static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
 {
         struct gpio_chip *gc = desc->gdev->chip;
         int val = !!value;
         int ret;
 
-        /* GPIOs used for IRQs shall not be set as output */
-        if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
-                gpiod_err(desc,
-                          "%s: tried to set a GPIO tied to an IRQ as output\n",
-                          __func__);
-                return -EIO;
-        }
-
-        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
-                /* First see if we can enable open drain in hardware */
-                ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
-                                                  PIN_CONFIG_DRIVE_OPEN_DRAIN);
-                if (!ret)
-                        goto set_output_value;
-                /* Emulate open drain by not actively driving the line high */
-                if (val)
-                        return gpiod_direction_input(desc);
-        }
-        else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
-                ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
-                                                  PIN_CONFIG_DRIVE_OPEN_SOURCE);
-                if (!ret)
-                        goto set_output_value;
-                /* Emulate open source by not actively driving the line low */
-                if (!val)
-                        return gpiod_direction_input(desc);
-        } else {
-                gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
-                                            PIN_CONFIG_DRIVE_PUSH_PULL);
-        }
-
-set_output_value:
         if (!gc->set || !gc->direction_output) {
                 gpiod_warn(desc,
                        "%s: missing set() or direction_output() operations\n",
@@ -2358,7 +2429,7 @@ set_output_value:
 int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 {
         VALIDATE_DESC(desc);
-        return _gpiod_direction_output_raw(desc, value);
+        return gpiod_direction_output_raw_commit(desc, value);
 }
 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
 
@@ -2376,12 +2447,48 @@ EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
  */
 int gpiod_direction_output(struct gpio_desc *desc, int value)
 {
+        struct gpio_chip *gc = desc->gdev->chip;
+        int ret;
+
         VALIDATE_DESC(desc);
         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
                 value = !value;
         else
                 value = !!value;
-        return _gpiod_direction_output_raw(desc, value);
+
+        /* GPIOs used for IRQs shall not be set as output */
+        if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
+                gpiod_err(desc,
+                          "%s: tried to set a GPIO tied to an IRQ as output\n",
+                          __func__);
+                return -EIO;
+        }
+
+        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
+                /* First see if we can enable open drain in hardware */
+                ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
+                                                  PIN_CONFIG_DRIVE_OPEN_DRAIN);
+                if (!ret)
+                        goto set_output_value;
+                /* Emulate open drain by not actively driving the line high */
+                if (value)
+                        return gpiod_direction_input(desc);
+        }
+        else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
+                ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
+                                                  PIN_CONFIG_DRIVE_OPEN_SOURCE);
+                if (!ret)
+                        goto set_output_value;
+                /* Emulate open source by not actively driving the line low */
+                if (!value)
+                        return gpiod_direction_input(desc);
+        } else {
+                gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
+                                            PIN_CONFIG_DRIVE_PUSH_PULL);
+        }
+
+set_output_value:
+        return gpiod_direction_output_raw_commit(desc, value);
 }
 EXPORT_SYMBOL_GPL(gpiod_direction_output);
 
@@ -2448,7 +2555,7 @@ EXPORT_SYMBOL_GPL(gpiod_is_active_low);
  * that the GPIO was actually requested.
  */
 
-static int _gpiod_get_raw_value(const struct gpio_desc *desc)
+static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
 {
         struct gpio_chip        *chip;
         int offset;
@@ -2462,6 +2569,71 @@ static int _gpiod_get_raw_value(const struct gpio_desc *desc)
         return value;
 }
 
+static int gpio_chip_get_multiple(struct gpio_chip *chip,
+                                  unsigned long *mask, unsigned long *bits)
+{
+        if (chip->get_multiple) {
+                return chip->get_multiple(chip, mask, bits);
+        } else if (chip->get) {
+                int i, value;
+
+                for_each_set_bit(i, mask, chip->ngpio) {
+                        value = chip->get(chip, i);
+                        if (value < 0)
+                                return value;
+                        __assign_bit(i, bits, value);
+                }
+                return 0;
+        }
+        return -EIO;
+}
+
+int gpiod_get_array_value_complex(bool raw, bool can_sleep,
+                                  unsigned int array_size,
+                                  struct gpio_desc **desc_array,
+                                  int *value_array)
+{
+        int i = 0;
+
+        while (i < array_size) {
+                struct gpio_chip *chip = desc_array[i]->gdev->chip;
+                unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
+                unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
+                int first, j, ret;
+
+                if (!can_sleep)
+                        WARN_ON(chip->can_sleep);
+
+                /* collect all inputs belonging to the same chip */
+                first = i;
+                memset(mask, 0, sizeof(mask));
+                do {
+                        const struct gpio_desc *desc = desc_array[i];
+                        int hwgpio = gpio_chip_hwgpio(desc);
+
+                        __set_bit(hwgpio, mask);
+                        i++;
+                } while ((i < array_size) &&
+                         (desc_array[i]->gdev->chip == chip));
+
+                ret = gpio_chip_get_multiple(chip, mask, bits);
+                if (ret)
+                        return ret;
+
+                for (j = first; j < i; j++) {
+                        const struct gpio_desc *desc = desc_array[j];
+                        int hwgpio = gpio_chip_hwgpio(desc);
+                        int value = test_bit(hwgpio, bits);
+
+                        if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
+                                value = !value;
+                        value_array[j] = value;
+                        trace_gpio_value(desc_to_gpio(desc), 1, value);
+                }
+        }
+        return 0;
+}
+
 /**
  * gpiod_get_raw_value() - return a gpio's raw value
  * @desc: gpio whose value will be returned
@@ -2477,7 +2649,7 @@ int gpiod_get_raw_value(const struct gpio_desc *desc)
         VALIDATE_DESC(desc);
         /* Should be using gpio_get_value_cansleep() */
         WARN_ON(desc->gdev->chip->can_sleep);
-        return _gpiod_get_raw_value(desc);
+        return gpiod_get_raw_value_commit(desc);
 }
 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
 
@@ -2499,7 +2671,7 @@ int gpiod_get_value(const struct gpio_desc *desc)
         /* Should be using gpio_get_value_cansleep() */
         WARN_ON(desc->gdev->chip->can_sleep);
 
-        value = _gpiod_get_raw_value(desc);
+        value = gpiod_get_raw_value_commit(desc);
         if (value < 0)
                 return value;
 
@@ -2510,12 +2682,57 @@ int gpiod_get_value(const struct gpio_desc *desc)
 }
 EXPORT_SYMBOL_GPL(gpiod_get_value);
 
+/**
+ * gpiod_get_raw_array_value() - read raw values from an array of GPIOs
+ * @array_size: number of elements in the descriptor / value arrays
+ * @desc_array: array of GPIO descriptors whose values will be read
+ * @value_array: array to store the read values
+ *
+ * Read the raw values of the GPIOs, i.e. the values of the physical lines
+ * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
+ * else an error code.
+ *
+ * This function should be called from contexts where we cannot sleep,
+ * and it will complain if the GPIO chip functions potentially sleep.
+ */
+int gpiod_get_raw_array_value(unsigned int array_size,
+                              struct gpio_desc **desc_array, int *value_array)
+{
+        if (!desc_array)
+                return -EINVAL;
+        return gpiod_get_array_value_complex(true, false, array_size,
+                                             desc_array, value_array);
+}
+EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);
+
+/**
+ * gpiod_get_array_value() - read values from an array of GPIOs
+ * @array_size: number of elements in the descriptor / value arrays
+ * @desc_array: array of GPIO descriptors whose values will be read
+ * @value_array: array to store the read values
+ *
+ * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
+ * into account.  Return 0 in case of success, else an error code.
+ *
+ * This function should be called from contexts where we cannot sleep,
+ * and it will complain if the GPIO chip functions potentially sleep.
+ */
+int gpiod_get_array_value(unsigned int array_size,
+                          struct gpio_desc **desc_array, int *value_array)
+{
+        if (!desc_array)
+                return -EINVAL;
+        return gpiod_get_array_value_complex(false, false, array_size,
+                                             desc_array, value_array);
+}
+EXPORT_SYMBOL_GPL(gpiod_get_array_value);
+
 /*
- *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
+ *  gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
  * @desc: gpio descriptor whose state need to be set.
  * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
  */
-static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
+static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
 {
         int err = 0;
         struct gpio_chip *chip = desc->gdev->chip;
@@ -2542,7 +2759,7 @@ static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
  * @desc: gpio descriptor whose state need to be set.
  * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
  */
-static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
+static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
 {
         int err = 0;
         struct gpio_chip *chip = desc->gdev->chip;
@@ -2564,18 +2781,13 @@ static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
                           __func__, err);
 }
 
-static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
+static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
 {
         struct gpio_chip        *chip;
 
         chip = desc->gdev->chip;
         trace_gpio_value(desc_to_gpio(desc), 0, value);
-        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
-                _gpio_set_open_drain_value(desc, value);
-        else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
-                _gpio_set_open_source_value(desc, value);
-        else
-                chip->set(chip, gpio_chip_hwgpio(desc), value);
+        chip->set(chip, gpio_chip_hwgpio(desc), value);
 }
 
 /*
@@ -2630,10 +2842,10 @@ void gpiod_set_array_value_complex(bool raw, bool can_sleep,
                          * collect all normal outputs belonging to the same chip
                          * open drain and open source outputs are set individually
                          */
-                        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
-                                _gpio_set_open_drain_value(desc, value);
-                        } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
-                                _gpio_set_open_source_value(desc, value);
+                        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
+                                gpio_set_open_drain_value_commit(desc, value);
+                        } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
+                                gpio_set_open_source_value_commit(desc, value);
                         } else {
                                 __set_bit(hwgpio, mask);
                                 if (value)
@@ -2667,7 +2879,7 @@ void gpiod_set_raw_value(struct gpio_desc *desc, int value)
         VALIDATE_DESC_VOID(desc);
         /* Should be using gpiod_set_value_cansleep() */
         WARN_ON(desc->gdev->chip->can_sleep);
-        _gpiod_set_raw_value(desc, value);
+        gpiod_set_raw_value_commit(desc, value);
 }
 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
 
@@ -2676,8 +2888,8 @@ EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
  * @desc: gpio whose value will be assigned
  * @value: value to assign
  *
- * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
- * account
+ * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
+ * OPEN_DRAIN and OPEN_SOURCE flags into account.
  *
  * This function should be called from contexts where we cannot sleep, and will
  * complain if the GPIO chip functions potentially sleep.
@@ -2689,7 +2901,12 @@ void gpiod_set_value(struct gpio_desc *desc, int value)
         WARN_ON(desc->gdev->chip->can_sleep);
         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
                 value = !value;
-        _gpiod_set_raw_value(desc, value);
+        if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
+                gpio_set_open_drain_value_commit(desc, value);
+        else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
+                gpio_set_open_source_value_commit(desc, value);
+        else
+                gpiod_set_raw_value_commit(desc, value);
 }
 EXPORT_SYMBOL_GPL(gpiod_set_value);
 
@@ -2890,7 +3107,7 @@ bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
         if (offset >= chip->ngpio)
                 return false;
 
-        return !test_bit(FLAG_SLEEP_MAY_LOOSE_VALUE,
+        return !test_bit(FLAG_SLEEP_MAY_LOSE_VALUE,
                          &chip->gpiodev->descs[offset].flags);
 }
 EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);
@@ -2908,7 +3125,7 @@ int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 {
         might_sleep_if(extra_checks);
         VALIDATE_DESC(desc);
-        return _gpiod_get_raw_value(desc);
+        return gpiod_get_raw_value_commit(desc);
 }
 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
 
@@ -2927,7 +3144,7 @@ int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 
         might_sleep_if(extra_checks);
         VALIDATE_DESC(desc);
-        value = _gpiod_get_raw_value(desc);
+        value = gpiod_get_raw_value_commit(desc);
         if (value < 0)
                 return value;
 
@@ -2939,6 +3156,53 @@ int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
 
 /**
+ * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs
+ * @array_size: number of elements in the descriptor / value arrays
+ * @desc_array: array of GPIO descriptors whose values will be read
+ * @value_array: array to store the read values
+ *
+ * Read the raw values of the GPIOs, i.e. the values of the physical lines
+ * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
+ * else an error code.
+ *
+ * This function is to be called from contexts that can sleep.
+ */
+int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
+                                       struct gpio_desc **desc_array,
+                                       int *value_array)
+{
+        might_sleep_if(extra_checks);
+        if (!desc_array)
+                return -EINVAL;
+        return gpiod_get_array_value_complex(true, true, array_size,
+                                             desc_array, value_array);
+}
+EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);
+
+/**
+ * gpiod_get_array_value_cansleep() - read values from an array of GPIOs
+ * @array_size: number of elements in the descriptor / value arrays
+ * @desc_array: array of GPIO descriptors whose values will be read
+ * @value_array: array to store the read values
+ *
+ * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
+ * into account.  Return 0 in case of success, else an error code.
+ *
+ * This function is to be called from contexts that can sleep.
+ */
+int gpiod_get_array_value_cansleep(unsigned int array_size,
+                                   struct gpio_desc **desc_array,
+                                   int *value_array)
+{
+        might_sleep_if(extra_checks);
+        if (!desc_array)
+                return -EINVAL;
+        return gpiod_get_array_value_complex(false, true, array_size,
+                                             desc_array, value_array);
+}
+EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep);
+
+/**
  * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
  * @desc: gpio whose value will be assigned
  * @value: value to assign
@@ -2952,7 +3216,7 @@ void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
 {
         might_sleep_if(extra_checks);
         VALIDATE_DESC_VOID(desc);
-        _gpiod_set_raw_value(desc, value);
+        gpiod_set_raw_value_commit(desc, value);
 }
 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
 
@@ -2972,7 +3236,7 @@ void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
         VALIDATE_DESC_VOID(desc);
         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
                 value = !value;
-        _gpiod_set_raw_value(desc, value);
+        gpiod_set_raw_value_commit(desc, value);
 }
 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
 
@@ -3268,8 +3532,8 @@ int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
         if (lflags & GPIO_OPEN_SOURCE)
                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
-        if (lflags & GPIO_SLEEP_MAY_LOOSE_VALUE)
-                set_bit(FLAG_SLEEP_MAY_LOOSE_VALUE, &desc->flags);
+        if (lflags & GPIO_SLEEP_MAY_LOSE_VALUE)
+                set_bit(FLAG_SLEEP_MAY_LOSE_VALUE, &desc->flags);
 
         /* No particular flag request, return here... */
         if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {