Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit be8c8fac authored by Uwe Kleine-König's avatar Uwe Kleine-König Committed by Linus Walleij
Browse files

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: default avatarGavin Schenk <g.schenk@eckelmann.de>
Signed-off-by: default avatarUwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: default avatarLinus Walleij <linus.walleij@linaro.org>
parent 9aa64f0b

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -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

drivers/gpio/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -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

drivers/gpio/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -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

drivers/gpio/gpio-siox.c

0 → 100644
+293 −0
Original line number Diff line number Diff line 
// 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");