gpio: new driver to work with a 8x12 siox

This driver controls a SIOX device that provides 20 I/O lines. The first
twelve are fixed inputs, the remaining eight are outputs.

Acked-by: Gavin Schenk <g.schenk@eckelmann.de>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

4 files changed, 303 insertions, 0 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index 0937f2131f73..920c0f92bef4 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -13289,6 +13289,7 @@ M:	Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
 R:      Pengutronix Kernel Team <kernel@pengutronix.de>
 S:      Supported
 F:      drivers/siox/*
+F:      drivers/gpio/gpio-siox.c
 F:      include/trace/events/siox.h
 
 SIS 190 ETHERNET DRIVER
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index b8cbf5081389..88c25677eeff 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -429,6 +429,14 @@ config GPIO_REG
           A 32-bit single register GPIO fixed in/out implementation.  This
           can be used to represent any register as a set of GPIO signals.
 
+config GPIO_SIOX
+        tristate "SIOX GPIO support"
+        depends on SIOX
+        select GPIOLIB_IRQCHIP
+        help
+          Say yes here to support SIOX I/O devices. These are units connected
+          via a SIOX bus and have a number of fixed-direction I/O lines.
+
 config GPIO_SPEAR_SPICS
         bool "ST SPEAr13xx SPI Chip Select as GPIO support"
         depends on PLAT_SPEAR
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index f3a2efbf858b..e85e770045fb 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -124,6 +124,7 @@ obj-$(CONFIG_GPIO_TEGRA186)	+= gpio-tegra186.o
 obj-$(CONFIG_GPIO_THUNDERX)     += gpio-thunderx.o
 obj-$(CONFIG_GPIO_TIMBERDALE)   += gpio-timberdale.o
 obj-$(CONFIG_GPIO_PALMAS)       += gpio-palmas.o
+obj-$(CONFIG_GPIO_SIOX)         += gpio-siox.o
 obj-$(CONFIG_GPIO_TPIC2810)     += gpio-tpic2810.o
 obj-$(CONFIG_GPIO_TPS65086)     += gpio-tps65086.o
 obj-$(CONFIG_GPIO_TPS65218)     += gpio-tps65218.o
diff --git a/drivers/gpio/gpio-siox.c b/drivers/gpio/gpio-siox.c
new file mode 100644
index 000000000000..571b2a81c6de
--- /dev/null
+++ b/drivers/gpio/gpio-siox.c
@@ -0,0 +1,293 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2015-2018 Pengutronix, Uwe Kleine-König <kernel@pengutronix.de>
+ */
+
+#include <linux/module.h>
+#include <linux/siox.h>
+#include <linux/gpio/driver.h>
+#include <linux/of.h>
+
+struct gpio_siox_ddata {
+        struct gpio_chip gchip;
+        struct irq_chip ichip;
+        struct mutex lock;
+        u8 setdata[1];
+        u8 getdata[3];
+
+        spinlock_t irqlock;
+        u32 irq_enable;
+        u32 irq_status;
+        u32 irq_type[20];
+};
+
+/*
+ * Note that this callback only sets the value that is clocked out in the next
+ * cycle.
+ */
+static int gpio_siox_set_data(struct siox_device *sdevice, u8 status, u8 buf[])
+{
+        struct gpio_siox_ddata *ddata = dev_get_drvdata(&sdevice->dev);
+
+        mutex_lock(&ddata->lock);
+        buf[0] = ddata->setdata[0];
+        mutex_unlock(&ddata->lock);
+
+        return 0;
+}
+
+static int gpio_siox_get_data(struct siox_device *sdevice, const u8 buf[])
+{
+        struct gpio_siox_ddata *ddata = dev_get_drvdata(&sdevice->dev);
+        size_t offset;
+        u32 trigger;
+
+        mutex_lock(&ddata->lock);
+
+        spin_lock_irq(&ddata->irqlock);
+
+        for (offset = 0; offset < 12; ++offset) {
+                unsigned int bitpos = 11 - offset;
+                unsigned int gpiolevel = buf[bitpos / 8] & (1 << bitpos % 8);
+                unsigned int prev_level =
+                        ddata->getdata[bitpos / 8] & (1 << (bitpos % 8));
+                u32 irq_type = ddata->irq_type[offset];
+
+                if (gpiolevel) {
+                        if ((irq_type & IRQ_TYPE_LEVEL_HIGH) ||
+                            ((irq_type & IRQ_TYPE_EDGE_RISING) && !prev_level))
+                                ddata->irq_status |= 1 << offset;
+                } else {
+                        if ((irq_type & IRQ_TYPE_LEVEL_LOW) ||
+                            ((irq_type & IRQ_TYPE_EDGE_FALLING) && prev_level))
+                                ddata->irq_status |= 1 << offset;
+                }
+        }
+
+        trigger = ddata->irq_status & ddata->irq_enable;
+
+        spin_unlock_irq(&ddata->irqlock);
+
+        ddata->getdata[0] = buf[0];
+        ddata->getdata[1] = buf[1];
+        ddata->getdata[2] = buf[2];
+
+        mutex_unlock(&ddata->lock);
+
+        for (offset = 0; offset < 12; ++offset) {
+                if (trigger & (1 << offset)) {
+                        struct irq_domain *irqdomain = ddata->gchip.irq.domain;
+                        unsigned int irq = irq_find_mapping(irqdomain, offset);
+
+                        /*
+                         * Conceptually handle_nested_irq should call the flow
+                         * handler of the irq chip. But it doesn't, so we have
+                         * to clean the irq_status here.
+                         */
+                        spin_lock_irq(&ddata->irqlock);
+                        ddata->irq_status &= ~(1 << offset);
+                        spin_unlock_irq(&ddata->irqlock);
+
+                        handle_nested_irq(irq);
+                }
+        }
+
+        return 0;
+}
+
+static void gpio_siox_irq_ack(struct irq_data *d)
+{
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
+        struct gpio_siox_ddata *ddata =
+                container_of(ic, struct gpio_siox_ddata, ichip);
+
+        spin_lock_irq(&ddata->irqlock);
+        ddata->irq_status &= ~(1 << d->hwirq);
+        spin_unlock_irq(&ddata->irqlock);
+}
+
+static void gpio_siox_irq_mask(struct irq_data *d)
+{
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
+        struct gpio_siox_ddata *ddata =
+                container_of(ic, struct gpio_siox_ddata, ichip);
+
+        spin_lock_irq(&ddata->irqlock);
+        ddata->irq_enable &= ~(1 << d->hwirq);
+        spin_unlock_irq(&ddata->irqlock);
+}
+
+static void gpio_siox_irq_unmask(struct irq_data *d)
+{
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
+        struct gpio_siox_ddata *ddata =
+                container_of(ic, struct gpio_siox_ddata, ichip);
+
+        spin_lock_irq(&ddata->irqlock);
+        ddata->irq_enable |= 1 << d->hwirq;
+        spin_unlock_irq(&ddata->irqlock);
+}
+
+static int gpio_siox_irq_set_type(struct irq_data *d, u32 type)
+{
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
+        struct gpio_siox_ddata *ddata =
+                container_of(ic, struct gpio_siox_ddata, ichip);
+
+        spin_lock_irq(&ddata->irqlock);
+        ddata->irq_type[d->hwirq] = type;
+        spin_unlock_irq(&ddata->irqlock);
+
+        return 0;
+}
+
+static int gpio_siox_get(struct gpio_chip *chip, unsigned int offset)
+{
+        struct gpio_siox_ddata *ddata =
+                container_of(chip, struct gpio_siox_ddata, gchip);
+        int ret;
+
+        mutex_lock(&ddata->lock);
+
+        if (offset >= 12) {
+                unsigned int bitpos = 19 - offset;
+
+                ret = ddata->setdata[0] & (1 << bitpos);
+        } else {
+                unsigned int bitpos = 11 - offset;
+
+                ret = ddata->getdata[bitpos / 8] & (1 << (bitpos % 8));
+        }
+
+        mutex_unlock(&ddata->lock);
+
+        return ret;
+}
+
+static void gpio_siox_set(struct gpio_chip *chip,
+                          unsigned int offset, int value)
+{
+        struct gpio_siox_ddata *ddata =
+                container_of(chip, struct gpio_siox_ddata, gchip);
+        u8 mask = 1 << (19 - offset);
+
+        mutex_lock(&ddata->lock);
+
+        if (value)
+                ddata->setdata[0] |= mask;
+        else
+                ddata->setdata[0] &= ~mask;
+
+        mutex_unlock(&ddata->lock);
+}
+
+static int gpio_siox_direction_input(struct gpio_chip *chip,
+                                     unsigned int offset)
+{
+        if (offset >= 12)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int gpio_siox_direction_output(struct gpio_chip *chip,
+                                      unsigned int offset, int value)
+{
+        if (offset < 12)
+                return -EINVAL;
+
+        gpio_siox_set(chip, offset, value);
+        return 0;
+}
+
+static int gpio_siox_get_direction(struct gpio_chip *chip, unsigned int offset)
+{
+        if (offset < 12)
+                return 1; /* input */
+        else
+                return 0; /* output */
+}
+
+static int gpio_siox_probe(struct siox_device *sdevice)
+{
+        struct gpio_siox_ddata *ddata;
+        int ret;
+
+        ddata = devm_kzalloc(&sdevice->dev, sizeof(*ddata), GFP_KERNEL);
+        if (!ddata)
+                return -ENOMEM;
+
+        dev_set_drvdata(&sdevice->dev, ddata);
+
+        mutex_init(&ddata->lock);
+        spin_lock_init(&ddata->irqlock);
+
+        ddata->gchip.base = -1;
+        ddata->gchip.can_sleep = 1;
+        ddata->gchip.parent = &sdevice->dev;
+        ddata->gchip.owner = THIS_MODULE;
+        ddata->gchip.get = gpio_siox_get;
+        ddata->gchip.set = gpio_siox_set;
+        ddata->gchip.direction_input = gpio_siox_direction_input;
+        ddata->gchip.direction_output = gpio_siox_direction_output;
+        ddata->gchip.get_direction = gpio_siox_get_direction;
+        ddata->gchip.ngpio = 20;
+
+        ddata->ichip.name = "siox-gpio";
+        ddata->ichip.irq_ack = gpio_siox_irq_ack;
+        ddata->ichip.irq_mask = gpio_siox_irq_mask;
+        ddata->ichip.irq_unmask = gpio_siox_irq_unmask;
+        ddata->ichip.irq_set_type = gpio_siox_irq_set_type;
+
+        ret = gpiochip_add(&ddata->gchip);
+        if (ret) {
+                dev_err(&sdevice->dev,
+                        "Failed to register gpio chip (%d)\n", ret);
+                goto err_gpiochip;
+        }
+
+        ret = gpiochip_irqchip_add(&ddata->gchip, &ddata->ichip,
+                                   0, handle_level_irq, IRQ_TYPE_EDGE_RISING);
+        if (ret) {
+                dev_err(&sdevice->dev,
+                        "Failed to register irq chip (%d)\n", ret);
+err_gpiochip:
+                gpiochip_remove(&ddata->gchip);
+        }
+
+        return ret;
+}
+
+static int gpio_siox_remove(struct siox_device *sdevice)
+{
+        struct gpio_siox_ddata *ddata = dev_get_drvdata(&sdevice->dev);
+
+        gpiochip_remove(&ddata->gchip);
+        return 0;
+}
+
+static struct siox_driver gpio_siox_driver = {
+        .probe = gpio_siox_probe,
+        .remove = gpio_siox_remove,
+        .set_data = gpio_siox_set_data,
+        .get_data = gpio_siox_get_data,
+        .driver = {
+                .name = "gpio-siox",
+        },
+};
+
+static int __init gpio_siox_init(void)
+{
+        return siox_driver_register(&gpio_siox_driver);
+}
+module_init(gpio_siox_init);
+
+static void __exit gpio_siox_exit(void)
+{
+        siox_driver_unregister(&gpio_siox_driver);
+}
+module_exit(gpio_siox_exit);
+
+MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>");
+MODULE_DESCRIPTION("SIOX gpio driver");
+MODULE_LICENSE("GPL v2");