Merge tag 'gpio-v4.8-1' of git://git.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.8 kernel cycle.  The big
  news is the completion of the chardev ABI which I'm very happy about
  and apart from that it's an ordinary, quite busy cycle.  The details
  are below.

  The patches are tested in linux-next for some time, patches to other
  subsystem mostly have ACKs.

  I got overly ambitious with configureing lines as input for IRQ lines
  but it turns out that some controllers have their interrupt-enable and
  input-enabling in orthogonal settings so the assumption that all IRQ
  lines are input lines does not hold.  Oh well, revert and back to the
  drawing board with that.

  Core changes:

   - The big item is of course the completion of the character device
     ABI.  It has now replaced and surpassed the former unmaintainable
     sysfs ABI: we can now hammer (bitbang) individual lines or sets of
     lines and read individual lines or sets of lines from userspace,
     and we can also register to listen to GPIO events from userspace.

     As a tie-in we have two new tools in tools/gpio: gpio-hammer and
     gpio-event-mon that illustrate the proper use of the new ABI.  As
     someone said: the wild west days of GPIO are now over.

   - Continued to remove the pointless ARCH_[WANT_OPTIONAL|REQUIRE]_GPIOLIB
     Kconfig symbols.  I'm patching hexagon, openrisc, powerpc, sh,
     unicore, ia64 and microblaze.  These are either ACKed by their
     maintainers or patched anyways after a grace period and no response
     from maintainers.

     Some archs (ARM) come in from their trees, and others (x86) are
     still not fixed, so I might send a second pull request to root it
     out later in this merge window, or just defer to v4.9.

   - The GPIO tools are moved to the tools build system.

  New drivers:

   - New driver for the MAX77620/MAX20024.

   - New driver for the Intel Merrifield.

   - Enabled PCA953x for the TI PCA9536.

   - Enabled PCA953x for the Intel Edison.

   - Enabled R8A7792 in the RCAR driver.

  Driver improvements:

   - The STMPE and F7188x now supports the .get_direction() callback.

   - The Xilinx driver supports setting multiple lines at once.

   - ACPI support for the Vulcan GPIO controller.

   - The MMIO GPIO driver supports device tree probing.

   - The Acer One 10 is supported through the _DEP ACPI attribute.

  Cleanups:

   - A major cleanup of the OF/DT support code.  It is way easier to
     read and understand now, probably this improves performance too.

   - Drop a few redundant .owner assignments.

   - Remove CLPS711x boardfile support: we are 100% DT"

* tag 'gpio-v4.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio: (67 commits)
  MAINTAINERS: Add INTEL MERRIFIELD GPIO entry
  gpio: dwapb: add missing fwnode_handle_put() in dwapb_gpio_get_pdata()
  gpio: merrifield: Protect irq_ack() and gpio_set() by lock
  gpio: merrifield: Introduce GPIO driver to support Merrifield
  gpio: intel-mid: Make it depend to X86_INTEL_MID
  gpio: intel-mid: Sort header block alphabetically
  gpio: intel-mid: Remove potentially harmful code
  gpio: rcar: add R8A7792 support
  gpiolib: remove duplicated include from gpiolib.c
  Revert "gpio: convince line to become input in irq helper"
  gpiolib: of_find_gpio(): Don't discard errors
  gpio: of: Allow overriding the device node
  gpio: free handles in fringe cases
  gpio: tps65218: Add platform_device_id table
  gpio: max77620: get gpio value based on direction
  gpio: lynxpoint: avoid potential warning on error path
  tools/gpio: add install section
  tools/gpio: move to tools buildsystem
  gpio: intel-mid: switch to devm_gpiochip_add_data()
  gpio: 74x164: Use spi_write() helper instead of open coding
  ...

1 files changed, 505 insertions, 6 deletions

diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index be74bd370f1f..53ff25ac66d8 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -16,11 +16,14 @@
 #include <linux/gpio/driver.h>
 #include <linux/gpio/machine.h>
 #include <linux/pinctrl/consumer.h>
-#include <linux/idr.h>
 #include <linux/cdev.h>
 #include <linux/fs.h>
 #include <linux/uaccess.h>
 #include <linux/compat.h>
+#include <linux/anon_inodes.h>
+#include <linux/kfifo.h>
+#include <linux/poll.h>
+#include <linux/timekeeping.h>
 #include <uapi/linux/gpio.h>
 
 #include "gpiolib.h"
@@ -310,6 +313,497 @@ static int gpiochip_set_desc_names(struct gpio_chip *gc)
         return 0;
 }
 
+/*
+ * GPIO line handle management
+ */
+
+/**
+ * struct linehandle_state - contains the state of a userspace handle
+ * @gdev: the GPIO device the handle pertains to
+ * @label: consumer label used to tag descriptors
+ * @descs: the GPIO descriptors held by this handle
+ * @numdescs: the number of descriptors held in the descs array
+ */
+struct linehandle_state {
+        struct gpio_device *gdev;
+        const char *label;
+        struct gpio_desc *descs[GPIOHANDLES_MAX];
+        u32 numdescs;
+};
+
+static long linehandle_ioctl(struct file *filep, unsigned int cmd,
+                             unsigned long arg)
+{
+        struct linehandle_state *lh = filep->private_data;
+        void __user *ip = (void __user *)arg;
+        struct gpiohandle_data ghd;
+        int i;
+
+        if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
+                int val;
+
+                /* 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;
+                }
+
+                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;
+
+                /* Clamp all values to [0,1] */
+                for (i = 0; i < lh->numdescs; i++)
+                        vals[i] = !!ghd.values[i];
+
+                /* Reuse the array setting function */
+                gpiod_set_array_value_complex(false,
+                                              true,
+                                              lh->numdescs,
+                                              lh->descs,
+                                              vals);
+                return 0;
+        }
+        return -EINVAL;
+}
+
+#ifdef CONFIG_COMPAT
+static long linehandle_ioctl_compat(struct file *filep, unsigned int cmd,
+                             unsigned long arg)
+{
+        return linehandle_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
+}
+#endif
+
+static int linehandle_release(struct inode *inode, struct file *filep)
+{
+        struct linehandle_state *lh = filep->private_data;
+        struct gpio_device *gdev = lh->gdev;
+        int i;
+
+        for (i = 0; i < lh->numdescs; i++)
+                gpiod_free(lh->descs[i]);
+        kfree(lh->label);
+        kfree(lh);
+        put_device(&gdev->dev);
+        return 0;
+}
+
+static const struct file_operations linehandle_fileops = {
+        .release = linehandle_release,
+        .owner = THIS_MODULE,
+        .llseek = noop_llseek,
+        .unlocked_ioctl = linehandle_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl = linehandle_ioctl_compat,
+#endif
+};
+
+static int linehandle_create(struct gpio_device *gdev, void __user *ip)
+{
+        struct gpiohandle_request handlereq;
+        struct linehandle_state *lh;
+        int fd, i, ret;
+
+        if (copy_from_user(&handlereq, ip, sizeof(handlereq)))
+                return -EFAULT;
+        if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX))
+                return -EINVAL;
+
+        lh = kzalloc(sizeof(*lh), GFP_KERNEL);
+        if (!lh)
+                return -ENOMEM;
+        lh->gdev = gdev;
+        get_device(&gdev->dev);
+
+        /* Make sure this is terminated */
+        handlereq.consumer_label[sizeof(handlereq.consumer_label)-1] = '\0';
+        if (strlen(handlereq.consumer_label)) {
+                lh->label = kstrdup(handlereq.consumer_label,
+                                    GFP_KERNEL);
+                if (!lh->label) {
+                        ret = -ENOMEM;
+                        goto out_free_lh;
+                }
+        }
+
+        /* Request each GPIO */
+        for (i = 0; i < handlereq.lines; i++) {
+                u32 offset = handlereq.lineoffsets[i];
+                u32 lflags = handlereq.flags;
+                struct gpio_desc *desc;
+
+                desc = &gdev->descs[offset];
+                ret = gpiod_request(desc, lh->label);
+                if (ret)
+                        goto out_free_descs;
+                lh->descs[i] = desc;
+
+                if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
+                        set_bit(FLAG_ACTIVE_LOW, &desc->flags);
+                if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
+                        set_bit(FLAG_OPEN_DRAIN, &desc->flags);
+                if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
+                        set_bit(FLAG_OPEN_SOURCE, &desc->flags);
+
+                /*
+                 * Lines have to be requested explicitly for input
+                 * or output, else the line will be treated "as is".
+                 */
+                if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
+                        int val = !!handlereq.default_values[i];
+
+                        ret = gpiod_direction_output(desc, val);
+                        if (ret)
+                                goto out_free_descs;
+                } else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
+                        ret = gpiod_direction_input(desc);
+                        if (ret)
+                                goto out_free_descs;
+                }
+                dev_dbg(&gdev->dev, "registered chardev handle for line %d\n",
+                        offset);
+        }
+        /* Let i point at the last handle */
+        i--;
+        lh->numdescs = handlereq.lines;
+
+        fd = anon_inode_getfd("gpio-linehandle",
+                              &linehandle_fileops,
+                              lh,
+                              O_RDONLY | O_CLOEXEC);
+        if (fd < 0) {
+                ret = fd;
+                goto out_free_descs;
+        }
+
+        handlereq.fd = fd;
+        if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
+                ret = -EFAULT;
+                goto out_free_descs;
+        }
+
+        dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n",
+                lh->numdescs);
+
+        return 0;
+
+out_free_descs:
+        for (; i >= 0; i--)
+                gpiod_free(lh->descs[i]);
+        kfree(lh->label);
+out_free_lh:
+        kfree(lh);
+        put_device(&gdev->dev);
+        return ret;
+}
+
+/*
+ * GPIO line event management
+ */
+
+/**
+ * struct lineevent_state - contains the state of a userspace event
+ * @gdev: the GPIO device the event pertains to
+ * @label: consumer label used to tag descriptors
+ * @desc: the GPIO descriptor held by this event
+ * @eflags: the event flags this line was requested with
+ * @irq: the interrupt that trigger in response to events on this GPIO
+ * @wait: wait queue that handles blocking reads of events
+ * @events: KFIFO for the GPIO events
+ * @read_lock: mutex lock to protect reads from colliding with adding
+ * new events to the FIFO
+ */
+struct lineevent_state {
+        struct gpio_device *gdev;
+        const char *label;
+        struct gpio_desc *desc;
+        u32 eflags;
+        int irq;
+        wait_queue_head_t wait;
+        DECLARE_KFIFO(events, struct gpioevent_data, 16);
+        struct mutex read_lock;
+};
+
+static unsigned int lineevent_poll(struct file *filep,
+                                   struct poll_table_struct *wait)
+{
+        struct lineevent_state *le = filep->private_data;
+        unsigned int events = 0;
+
+        poll_wait(filep, &le->wait, wait);
+
+        if (!kfifo_is_empty(&le->events))
+                events = POLLIN | POLLRDNORM;
+
+        return events;
+}
+
+
+static ssize_t lineevent_read(struct file *filep,
+                              char __user *buf,
+                              size_t count,
+                              loff_t *f_ps)
+{
+        struct lineevent_state *le = filep->private_data;
+        unsigned int copied;
+        int ret;
+
+        if (count < sizeof(struct gpioevent_data))
+                return -EINVAL;
+
+        do {
+                if (kfifo_is_empty(&le->events)) {
+                        if (filep->f_flags & O_NONBLOCK)
+                                return -EAGAIN;
+
+                        ret = wait_event_interruptible(le->wait,
+                                        !kfifo_is_empty(&le->events));
+                        if (ret)
+                                return ret;
+                }
+
+                if (mutex_lock_interruptible(&le->read_lock))
+                        return -ERESTARTSYS;
+                ret = kfifo_to_user(&le->events, buf, count, &copied);
+                mutex_unlock(&le->read_lock);
+
+                if (ret)
+                        return ret;
+
+                /*
+                 * If we couldn't read anything from the fifo (a different
+                 * thread might have been faster) we either return -EAGAIN if
+                 * the file descriptor is non-blocking, otherwise we go back to
+                 * sleep and wait for more data to arrive.
+                 */
+                if (copied == 0 && (filep->f_flags & O_NONBLOCK))
+                        return -EAGAIN;
+
+        } while (copied == 0);
+
+        return copied;
+}
+
+static int lineevent_release(struct inode *inode, struct file *filep)
+{
+        struct lineevent_state *le = filep->private_data;
+        struct gpio_device *gdev = le->gdev;
+
+        free_irq(le->irq, le);
+        gpiod_free(le->desc);
+        kfree(le->label);
+        kfree(le);
+        put_device(&gdev->dev);
+        return 0;
+}
+
+static long lineevent_ioctl(struct file *filep, unsigned int cmd,
+                            unsigned long arg)
+{
+        struct lineevent_state *le = filep->private_data;
+        void __user *ip = (void __user *)arg;
+        struct gpiohandle_data ghd;
+
+        /*
+         * We can get the value for an event line but not set it,
+         * because it is input by definition.
+         */
+        if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
+                int val;
+
+                val = gpiod_get_value_cansleep(le->desc);
+                if (val < 0)
+                        return val;
+                ghd.values[0] = val;
+
+                if (copy_to_user(ip, &ghd, sizeof(ghd)))
+                        return -EFAULT;
+
+                return 0;
+        }
+        return -EINVAL;
+}
+
+#ifdef CONFIG_COMPAT
+static long lineevent_ioctl_compat(struct file *filep, unsigned int cmd,
+                                   unsigned long arg)
+{
+        return lineevent_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
+}
+#endif
+
+static const struct file_operations lineevent_fileops = {
+        .release = lineevent_release,
+        .read = lineevent_read,
+        .poll = lineevent_poll,
+        .owner = THIS_MODULE,
+        .llseek = noop_llseek,
+        .unlocked_ioctl = lineevent_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl = lineevent_ioctl_compat,
+#endif
+};
+
+static irqreturn_t lineevent_irq_thread(int irq, void *p)
+{
+        struct lineevent_state *le = p;
+        struct gpioevent_data ge;
+        int ret;
+
+        ge.timestamp = ktime_get_real_ns();
+
+        if (le->eflags & GPIOEVENT_REQUEST_BOTH_EDGES) {
+                int level = gpiod_get_value_cansleep(le->desc);
+
+                if (level)
+                        /* Emit low-to-high event */
+                        ge.id = GPIOEVENT_EVENT_RISING_EDGE;
+                else
+                        /* Emit high-to-low event */
+                        ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
+        } else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE) {
+                /* Emit low-to-high event */
+                ge.id = GPIOEVENT_EVENT_RISING_EDGE;
+        } else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
+                /* Emit high-to-low event */
+                ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
+        } else {
+                return IRQ_NONE;
+        }
+
+        ret = kfifo_put(&le->events, ge);
+        if (ret != 0)
+                wake_up_poll(&le->wait, POLLIN);
+
+        return IRQ_HANDLED;
+}
+
+static int lineevent_create(struct gpio_device *gdev, void __user *ip)
+{
+        struct gpioevent_request eventreq;
+        struct lineevent_state *le;
+        struct gpio_desc *desc;
+        u32 offset;
+        u32 lflags;
+        u32 eflags;
+        int fd;
+        int ret;
+        int irqflags = 0;
+
+        if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
+                return -EFAULT;
+
+        le = kzalloc(sizeof(*le), GFP_KERNEL);
+        if (!le)
+                return -ENOMEM;
+        le->gdev = gdev;
+        get_device(&gdev->dev);
+
+        /* Make sure this is terminated */
+        eventreq.consumer_label[sizeof(eventreq.consumer_label)-1] = '\0';
+        if (strlen(eventreq.consumer_label)) {
+                le->label = kstrdup(eventreq.consumer_label,
+                                    GFP_KERNEL);
+                if (!le->label) {
+                        ret = -ENOMEM;
+                        goto out_free_le;
+                }
+        }
+
+        offset = eventreq.lineoffset;
+        lflags = eventreq.handleflags;
+        eflags = eventreq.eventflags;
+
+        /* This is just wrong: we don't look for events on output lines */
+        if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
+                ret = -EINVAL;
+                goto out_free_label;
+        }
+
+        desc = &gdev->descs[offset];
+        ret = gpiod_request(desc, le->label);
+        if (ret)
+                goto out_free_desc;
+        le->desc = desc;
+        le->eflags = eflags;
+
+        if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
+                set_bit(FLAG_ACTIVE_LOW, &desc->flags);
+        if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
+                set_bit(FLAG_OPEN_DRAIN, &desc->flags);
+        if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
+                set_bit(FLAG_OPEN_SOURCE, &desc->flags);
+
+        ret = gpiod_direction_input(desc);
+        if (ret)
+                goto out_free_desc;
+
+        le->irq = gpiod_to_irq(desc);
+        if (le->irq <= 0) {
+                ret = -ENODEV;
+                goto out_free_desc;
+        }
+
+        if (eflags & GPIOEVENT_REQUEST_RISING_EDGE)
+                irqflags |= IRQF_TRIGGER_RISING;
+        if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
+                irqflags |= IRQF_TRIGGER_FALLING;
+        irqflags |= IRQF_ONESHOT;
+        irqflags |= IRQF_SHARED;
+
+        INIT_KFIFO(le->events);
+        init_waitqueue_head(&le->wait);
+        mutex_init(&le->read_lock);
+
+        /* Request a thread to read the events */
+        ret = request_threaded_irq(le->irq,
+                        NULL,
+                        lineevent_irq_thread,
+                        irqflags,
+                        le->label,
+                        le);
+        if (ret)
+                goto out_free_desc;
+
+        fd = anon_inode_getfd("gpio-event",
+                              &lineevent_fileops,
+                              le,
+                              O_RDONLY | O_CLOEXEC);
+        if (fd < 0) {
+                ret = fd;
+                goto out_free_irq;
+        }
+
+        eventreq.fd = fd;
+        if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
+                ret = -EFAULT;
+                goto out_free_irq;
+        }
+
+        return 0;
+
+out_free_irq:
+        free_irq(le->irq, le);
+out_free_desc:
+        gpiod_free(le->desc);
+out_free_label:
+        kfree(le->label);
+out_free_le:
+        kfree(le);
+        put_device(&gdev->dev);
+        return ret;
+}
+
 /**
  * gpio_ioctl() - ioctl handler for the GPIO chardev
  */
@@ -385,6 +879,10 @@ static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
                         return -EFAULT;
                 return 0;
+        } else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
+                return linehandle_create(gdev, ip);
+        } else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
+                return lineevent_create(gdev, ip);
         }
         return -EINVAL;
 }
@@ -548,13 +1046,14 @@ int gpiochip_add_data(struct gpio_chip *chip, void *data)
         if (chip->parent) {
                 gdev->dev.parent = chip->parent;
                 gdev->dev.of_node = chip->parent->of_node;
-        } else {
+        }
+
 #ifdef CONFIG_OF_GPIO
         /* If the gpiochip has an assigned OF node this takes precedence */
-                if (chip->of_node)
-                        gdev->dev.of_node = chip->of_node;
+        if (chip->of_node)
+                gdev->dev.of_node = chip->of_node;
 #endif
-        }
+
         gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
         if (gdev->id < 0) {
                 status = gdev->id;
@@ -2333,7 +2832,7 @@ static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
 
                 desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
                                                 &of_flags);
-                if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
+                if (!IS_ERR(desc) || (PTR_ERR(desc) != -ENOENT))
                         break;
         }