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

Commit 380639c7 authored by Russell King's avatar Russell King Committed by Linus Walleij
Browse files

gpio: add generic single-register fixed-direction GPIO driver 



Add a simple, generic, single register fixed-direction GPIO driver.
This is able to support a single register with a mixture of inputs
and outputs.

This is different from gpio-mmio and gpio-74xx-mmio:
* gpio-mmio doesn't allow a fixed direction, it assumes there is always
  a direction register.
* gpio-74xx-mmio only supports all-in or all-out setups
* gpio-74xx-mmio is DT only, this needs to support legacy too
* they don't double-read when getting the GPIO value, as required by
  some implementations that this driver supports
* we need to always do 32-bit reads, which bgpio doesn't guarantee
* the current output state may not be readable from the hardware
  register - reading may reflect input status but not output status.

Signed-off-by: default avatarRussell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: default avatarLinus Walleij <linus.walleij@linaro.org>
parent c65d1fd3

drivers/gpio/Kconfig

+6 −0
Original line number Diff line number Diff line
@@ -380,6 +380,12 @@ config GPIO_RCAR 
	help

	  Say yes here to support GPIO on Renesas R-Car SoCs.



config GPIO_REG

	bool

	help

	  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_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
@@ -98,6 +98,7 @@ obj-$(CONFIG_GPIO_PXA) += gpio-pxa.o 
obj-$(CONFIG_GPIO_RC5T583)	+= gpio-rc5t583.o

obj-$(CONFIG_GPIO_RDC321X)	+= gpio-rdc321x.o

obj-$(CONFIG_GPIO_RCAR)		+= gpio-rcar.o

obj-$(CONFIG_GPIO_REG)		+= gpio-reg.o

obj-$(CONFIG_ARCH_SA1100)	+= gpio-sa1100.o

obj-$(CONFIG_GPIO_SCH)		+= gpio-sch.o

obj-$(CONFIG_GPIO_SCH311X)	+= gpio-sch311x.o

drivers/gpio/gpio-reg.c

0 → 100644
+164 −0
Original line number Diff line number Diff line 
/*

 * gpio-reg: single register individually fixed-direction GPIOs

 *

 * Copyright (C) 2016 Russell King

 *

 * This software is licensed under the terms of the GNU General Public

 * License version 2, as published by the Free Software Foundation, and

 * may be copied, distributed, and modified under those terms.

 */

#include <linux/gpio/driver.h>

#include <linux/gpio/gpio-reg.h>

#include <linux/io.h>

#include <linux/slab.h>

#include <linux/spinlock.h>



struct gpio_reg {

	struct gpio_chip gc;

	spinlock_t lock;

	u32 direction;

	u32 out;

	void __iomem *reg;

};



#define to_gpio_reg(x) container_of(x, struct gpio_reg, gc)



static int gpio_reg_get_direction(struct gpio_chip *gc, unsigned offset)

{

	struct gpio_reg *r = to_gpio_reg(gc);



	return r->direction & BIT(offset) ? 1 : 0;

}



static int gpio_reg_direction_output(struct gpio_chip *gc, unsigned offset,

	int value)

{

	struct gpio_reg *r = to_gpio_reg(gc);



	if (r->direction & BIT(offset))

		return -ENOTSUPP;



	gc->set(gc, offset, value);

	return 0;

}



static int gpio_reg_direction_input(struct gpio_chip *gc, unsigned offset)

{

	struct gpio_reg *r = to_gpio_reg(gc);



	return r->direction & BIT(offset) ? 0 : -ENOTSUPP;

}



static void gpio_reg_set(struct gpio_chip *gc, unsigned offset, int value)

{

	struct gpio_reg *r = to_gpio_reg(gc);

	unsigned long flags;

	u32 val, mask = BIT(offset);



	spin_lock_irqsave(&r->lock, flags);

	val = r->out;

	if (value)

		val |= mask;

	else

		val &= ~mask;

	r->out = val;

	writel_relaxed(val, r->reg);

	spin_unlock_irqrestore(&r->lock, flags);

}



static int gpio_reg_get(struct gpio_chip *gc, unsigned offset)

{

	struct gpio_reg *r = to_gpio_reg(gc);

	u32 val, mask = BIT(offset);



	if (r->direction & mask) {

		/*

		 * double-read the value, some registers latch after the

		 * first read.

		 */

		readl_relaxed(r->reg);

		val = readl_relaxed(r->reg);

	} else {

		val = r->out;

	}

	return !!(val & mask);

}



static void gpio_reg_set_multiple(struct gpio_chip *gc, unsigned long *mask,

	unsigned long *bits)

{

	struct gpio_reg *r = to_gpio_reg(gc);

	unsigned long flags;



	spin_lock_irqsave(&r->lock, flags);

	r->out = (r->out & ~*mask) | (*bits & *mask);

	writel_relaxed(r->out, r->reg);

	spin_unlock_irqrestore(&r->lock, flags);

}



/**

 * gpio_reg_init - add a fixed in/out register as gpio

 * @dev: optional struct device associated with this register

 * @base: start gpio number, or -1 to allocate

 * @num: number of GPIOs, maximum 32

 * @label: GPIO chip label

 * @direction: bitmask of fixed direction, one per GPIO signal, 1 = in

 * @def_out: initial GPIO output value

 * @names: array of %num strings describing each GPIO signal

 *

 * Add a single-register GPIO device containing up to 32 GPIO signals,

 * where each GPIO has a fixed input or output configuration.  Only

 * input GPIOs are assumed to be readable from the register, and only

 * then after a double-read.  Output values are assumed not to be

 * readable.

 */

struct gpio_chip *gpio_reg_init(struct device *dev, void __iomem *reg,

	int base, int num, const char *label, u32 direction, u32 def_out,

	const char *const *names)

{

	struct gpio_reg *r;

	int ret;



	if (dev)

		r = devm_kzalloc(dev, sizeof(*r), GFP_KERNEL);

	else

		r = kzalloc(sizeof(*r), GFP_KERNEL);



	if (!r)

		return ERR_PTR(-ENOMEM);



	spin_lock_init(&r->lock);



	r->gc.label = label;

	r->gc.get_direction = gpio_reg_get_direction;

	r->gc.direction_input = gpio_reg_direction_input;

	r->gc.direction_output = gpio_reg_direction_output;

	r->gc.set = gpio_reg_set;

	r->gc.get = gpio_reg_get;

	r->gc.set_multiple = gpio_reg_set_multiple;

	r->gc.base = base;

	r->gc.ngpio = num;

	r->gc.names = names;

	r->direction = direction;

	r->out = def_out;

	r->reg = reg;



	if (dev)

		ret = devm_gpiochip_add_data(dev, &r->gc, r);

	else

		ret = gpiochip_add_data(&r->gc, r);



	return ret ? ERR_PTR(ret) : &r->gc;

}



int gpio_reg_resume(struct gpio_chip *gc)

{

	struct gpio_reg *r = to_gpio_reg(gc);

	unsigned long flags;



	spin_lock_irqsave(&r->lock, flags);

	writel_relaxed(r->out, r->reg);

	spin_unlock_irqrestore(&r->lock, flags);



	return 0;

}

include/linux/gpio/gpio-reg.h

0 → 100644
+12 −0
Original line number Diff line number Diff line 
#ifndef GPIO_REG_H

#define GPIO_REG_H



struct device;



struct gpio_chip *gpio_reg_init(struct device *dev, void __iomem *reg,

	int base, int num, const char *label, u32 direction, u32 def_out,

	const char *const *names);



int gpio_reg_resume(struct gpio_chip *gc);



#endif