lkml.org 
[lkml]   [2017]   [Dec]   [7]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v1 4/5] gpio: new driver to work with a 8x12 siox
    Date
    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>
    ---
    drivers/gpio/Kconfig | 8 ++
    drivers/gpio/Makefile | 1 +
    drivers/gpio/gpio-siox.c | 293 +++++++++++++++++++++++++++++++++++++++++++++++
    3 files changed, 302 insertions(+)
    create mode 100644 drivers/gpio/gpio-siox.c

    diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
    index d6a8e851ad13..0a0a15aa95ac 100644
    --- a/drivers/gpio/Kconfig
    +++ b/drivers/gpio/Kconfig
    @@ -397,6 +397,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 4bc24febb889..d25ab1244242 100644
    --- a/drivers/gpio/Makefile
    +++ b/drivers/gpio/Makefile
    @@ -119,6 +119,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..5b4d858fe954
    --- /dev/null
    +++ b/drivers/gpio/gpio-siox.c
    @@ -0,0 +1,293 @@
    +// SPDX-License-Identifier: GPL-2.0
    +/*
    + * Copyright (C) 2015-2017 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");
    --
    2.11.0
    \
     
     \ /
      Last update: 2017-12-07 10:33    [W:3.100 / U:0.204 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site