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)) {