Commit 40b37008 authored by Linus Walleij's avatar Linus Walleij
Browse files

Merge tag 'gpio-updates-for-v5.11' of... 

Merge tag 'gpio-updates-for-v5.11' of git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux into devel

gpio updates for v5.11-rc1

- several refactoring patches of the core gpiolib code
- add support for NXP PCAL9554B/C to gpio-pca953x
- allow probing mockup devices from device tree
- refactoring and improvements to gpio-rcar
- improvements to locking in gpio-tegra
- code shrink in gpiolib devres
- get the irq offset from device tree in gpio-sifive
- major refactoring of gpio-exar
- convert gpio-mvebu pwm access to regmap
- create a new submenu for virtual GPIO drivers
- fix clang fall-through warnings treewide
- minor driver refactoring and tweaks sprinkled all over
parents a0db197f b5252196

Documentation/devicetree/bindings/gpio/gpio-pca95xx.yaml

+1 −0
Original line number Diff line number Diff line
@@ -48,6 +48,7 @@ properties: 
      - nxp,pcal6416

      - nxp,pcal6524

      - nxp,pcal9535

      - nxp,pcal9554b

      - nxp,pcal9555a

      - onnn,cat9554

      - onnn,pca9654

drivers/gpio/Kconfig

+5 −0
Original line number Diff line number Diff line
@@ -256,6 +256,7 @@ config GPIO_EP93XX 
config GPIO_EXAR

	tristate "Support for GPIO pins on XR17V352/354/358"

	depends on SERIAL_8250_EXAR

	select REGMAP_MMIO

	help

	  Selecting this option will enable handling of GPIO pins present

	  on Exar XR17V352/354/358 chips.
@@ -1602,6 +1603,8 @@ config GPIO_VIPERBOARD 


endmenu



menu "Virtual GPIO drivers"



config GPIO_AGGREGATOR

	tristate "GPIO Aggregator"

	help
@@ -1625,4 +1628,6 @@ config GPIO_MOCKUP 
	  tools/testing/selftests/gpio/gpio-mockup.sh. Reference the usage in

	  it.



endmenu



endif

drivers/gpio/gpio-ath79.c

+1 −0
Original line number Diff line number Diff line
@@ -123,6 +123,7 @@ static int ath79_gpio_irq_set_type(struct irq_data *data, 
	switch (flow_type) {

	case IRQ_TYPE_EDGE_RISING:

		polarity |= mask;

		fallthrough;

	case IRQ_TYPE_EDGE_FALLING:

	case IRQ_TYPE_EDGE_BOTH:

		break;

drivers/gpio/gpio-dwapb.c

+3 −4
Original line number Diff line number Diff line
@@ -616,10 +616,9 @@ static int dwapb_get_reset(struct dwapb_gpio *gpio) 
	int err;



	gpio->rst = devm_reset_control_get_optional_shared(gpio->dev, NULL);

	if (IS_ERR(gpio->rst)) {

		dev_err(gpio->dev, "Cannot get reset descriptor\n");

		return PTR_ERR(gpio->rst);

	}

	if (IS_ERR(gpio->rst))

		return dev_err_probe(gpio->dev, PTR_ERR(gpio->rst),

				     "Cannot get reset descriptor\n");



	err = reset_control_deassert(gpio->rst);

	if (err) {

drivers/gpio/gpio-exar.c

+76 −79
Original line number Diff line number Diff line
@@ -4,14 +4,17 @@ 
 *

 * Copyright (C) 2015 Sudip Mukherjee <sudip.mukherjee@codethink.co.uk>

 */



#include <linux/bitops.h>

#include <linux/device.h>

#include <linux/gpio/driver.h>

#include <linux/idr.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/pci.h>

#include <linux/platform_device.h>

#include <linux/regmap.h>



#define EXAR_OFFSET_MPIOLVL_LO 0x90

#define EXAR_OFFSET_MPIOSEL_LO 0x93
@@ -24,60 +27,39 @@ static DEFINE_IDA(ida_index); 


struct exar_gpio_chip {

	struct gpio_chip gpio_chip;

	struct mutex lock;

	struct regmap *regmap;

	int index;

	void __iomem *regs;

	char name[20];

	unsigned int first_pin;

};



static void exar_update(struct gpio_chip *chip, unsigned int reg, int val,

			unsigned int offset)

static unsigned int

exar_offset_to_sel_addr(struct exar_gpio_chip *exar_gpio, unsigned int offset)

{

	struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip);

	int temp;



	mutex_lock(&exar_gpio->lock);

	temp = readb(exar_gpio->regs + reg);

	temp &= ~BIT(offset);

	if (val)

		temp |= BIT(offset);

	writeb(temp, exar_gpio->regs + reg);

	mutex_unlock(&exar_gpio->lock);

	return (offset + exar_gpio->first_pin) / 8 ? EXAR_OFFSET_MPIOSEL_HI

						   : EXAR_OFFSET_MPIOSEL_LO;

}



static int exar_set_direction(struct gpio_chip *chip, int direction,

			      unsigned int offset)

static unsigned int

exar_offset_to_lvl_addr(struct exar_gpio_chip *exar_gpio, unsigned int offset)

{

	struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip);

	unsigned int addr = (offset + exar_gpio->first_pin) / 8 ?

		EXAR_OFFSET_MPIOSEL_HI : EXAR_OFFSET_MPIOSEL_LO;

	unsigned int bit  = (offset + exar_gpio->first_pin) % 8;



	exar_update(chip, addr, direction, bit);

	return 0;

	return (offset + exar_gpio->first_pin) / 8 ? EXAR_OFFSET_MPIOLVL_HI

						   : EXAR_OFFSET_MPIOLVL_LO;

}



static int exar_get(struct gpio_chip *chip, unsigned int reg)

static unsigned int

exar_offset_to_bit(struct exar_gpio_chip *exar_gpio, unsigned int offset)

{

	struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip);

	int value;



	mutex_lock(&exar_gpio->lock);

	value = readb(exar_gpio->regs + reg);

	mutex_unlock(&exar_gpio->lock);



	return value;

	return (offset + exar_gpio->first_pin) % 8;

}



static int exar_get_direction(struct gpio_chip *chip, unsigned int offset)

{

	struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip);

	unsigned int addr = (offset + exar_gpio->first_pin) / 8 ?

		EXAR_OFFSET_MPIOSEL_HI : EXAR_OFFSET_MPIOSEL_LO;

	unsigned int bit  = (offset + exar_gpio->first_pin) % 8;

	unsigned int addr = exar_offset_to_sel_addr(exar_gpio, offset);

	unsigned int bit = exar_offset_to_bit(exar_gpio, offset);



	if (exar_get(chip, addr) & BIT(bit))

	if (regmap_test_bits(exar_gpio->regmap, addr, BIT(bit)))

		return GPIO_LINE_DIRECTION_IN;



	return GPIO_LINE_DIRECTION_OUT;
@@ -86,39 +68,66 @@ static int exar_get_direction(struct gpio_chip *chip, unsigned int offset) 
static int exar_get_value(struct gpio_chip *chip, unsigned int offset)

{

	struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip);

	unsigned int addr = (offset + exar_gpio->first_pin) / 8 ?

		EXAR_OFFSET_MPIOLVL_HI : EXAR_OFFSET_MPIOLVL_LO;

	unsigned int bit  = (offset + exar_gpio->first_pin) % 8;

	unsigned int addr = exar_offset_to_lvl_addr(exar_gpio, offset);

	unsigned int bit = exar_offset_to_bit(exar_gpio, offset);



	return !!(exar_get(chip, addr) & BIT(bit));

	return !!(regmap_test_bits(exar_gpio->regmap, addr, BIT(bit)));

}



static void exar_set_value(struct gpio_chip *chip, unsigned int offset,

			   int value)

{

	struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip);

	unsigned int addr = (offset + exar_gpio->first_pin) / 8 ?

		EXAR_OFFSET_MPIOLVL_HI : EXAR_OFFSET_MPIOLVL_LO;

	unsigned int bit  = (offset + exar_gpio->first_pin) % 8;

	unsigned int addr = exar_offset_to_lvl_addr(exar_gpio, offset);

	unsigned int bit = exar_offset_to_bit(exar_gpio, offset);



	exar_update(chip, addr, value, bit);

	if (value)

		regmap_set_bits(exar_gpio->regmap, addr, BIT(bit));

	else

		regmap_clear_bits(exar_gpio->regmap, addr, BIT(bit));

}



static int exar_direction_output(struct gpio_chip *chip, unsigned int offset,

				 int value)

{

	struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip);

	unsigned int addr = exar_offset_to_sel_addr(exar_gpio, offset);

	unsigned int bit = exar_offset_to_bit(exar_gpio, offset);



	exar_set_value(chip, offset, value);

	return exar_set_direction(chip, 0, offset);

	regmap_clear_bits(exar_gpio->regmap, addr, BIT(bit));



	return 0;

}



static int exar_direction_input(struct gpio_chip *chip, unsigned int offset)

{

	return exar_set_direction(chip, 1, offset);

	struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip);

	unsigned int addr = exar_offset_to_sel_addr(exar_gpio, offset);

	unsigned int bit = exar_offset_to_bit(exar_gpio, offset);



	regmap_set_bits(exar_gpio->regmap, addr, BIT(bit));



	return 0;

}



static void exar_devm_ida_free(void *data)

{

	struct exar_gpio_chip *exar_gpio = data;



	ida_free(&ida_index, exar_gpio->index);

}



static const struct regmap_config exar_regmap_config = {

	.name		= "exar-gpio",

	.reg_bits	= 16,

	.val_bits	= 8,

};



static int gpio_exar_probe(struct platform_device *pdev)

{

	struct pci_dev *pcidev = to_pci_dev(pdev->dev.parent);

	struct device *dev = &pdev->dev;

	struct pci_dev *pcidev = to_pci_dev(dev->parent);

	struct exar_gpio_chip *exar_gpio;

	u32 first_pin, ngpios;

	void __iomem *p;
@@ -132,30 +141,37 @@ static int gpio_exar_probe(struct platform_device *pdev) 
	if (!p)

		return -ENOMEM;



	ret = device_property_read_u32(&pdev->dev, "exar,first-pin",

				       &first_pin);

	ret = device_property_read_u32(dev, "exar,first-pin", &first_pin);

	if (ret)

		return ret;



	ret = device_property_read_u32(&pdev->dev, "ngpios", &ngpios);

	ret = device_property_read_u32(dev, "ngpios", &ngpios);

	if (ret)

		return ret;



	exar_gpio = devm_kzalloc(&pdev->dev, sizeof(*exar_gpio), GFP_KERNEL);

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

	if (!exar_gpio)

		return -ENOMEM;



	mutex_init(&exar_gpio->lock);

	/*

	 * We don't need to check the return values of mmio regmap operations (unless

	 * the regmap has a clock attached which is not the case here).

	 */

	exar_gpio->regmap = devm_regmap_init_mmio(dev, p, &exar_regmap_config);

	if (IS_ERR(exar_gpio->regmap))

		return PTR_ERR(exar_gpio->regmap);



	index = ida_simple_get(&ida_index, 0, 0, GFP_KERNEL);

	if (index < 0) {

		ret = index;

		goto err_mutex_destroy;

	}

	index = ida_alloc(&ida_index, GFP_KERNEL);

	if (index < 0)

		return index;



	ret = devm_add_action_or_reset(dev, exar_devm_ida_free, exar_gpio);

	if (ret)

		return ret;



	sprintf(exar_gpio->name, "exar_gpio%d", index);

	exar_gpio->gpio_chip.label = exar_gpio->name;

	exar_gpio->gpio_chip.parent = &pdev->dev;

	exar_gpio->gpio_chip.parent = dev;

	exar_gpio->gpio_chip.direction_output = exar_direction_output;

	exar_gpio->gpio_chip.direction_input = exar_direction_input;

	exar_gpio->gpio_chip.get_direction = exar_get_direction;
@@ -163,39 +179,20 @@ static int gpio_exar_probe(struct platform_device *pdev) 
	exar_gpio->gpio_chip.set = exar_set_value;

	exar_gpio->gpio_chip.base = -1;

	exar_gpio->gpio_chip.ngpio = ngpios;

	exar_gpio->regs = p;

	exar_gpio->index = index;

	exar_gpio->first_pin = first_pin;



	ret = devm_gpiochip_add_data(&pdev->dev,

				     &exar_gpio->gpio_chip, exar_gpio);

	ret = devm_gpiochip_add_data(dev, &exar_gpio->gpio_chip, exar_gpio);

	if (ret)

		goto err_destroy;



	platform_set_drvdata(pdev, exar_gpio);



	return 0;



err_destroy:

	ida_simple_remove(&ida_index, index);

err_mutex_destroy:

	mutex_destroy(&exar_gpio->lock);

		return ret;

}



static int gpio_exar_remove(struct platform_device *pdev)

{

	struct exar_gpio_chip *exar_gpio = platform_get_drvdata(pdev);



	ida_simple_remove(&ida_index, exar_gpio->index);

	mutex_destroy(&exar_gpio->lock);

	platform_set_drvdata(pdev, exar_gpio);



	return 0;

}



static struct platform_driver gpio_exar_driver = {

	.probe	= gpio_exar_probe,

	.remove	= gpio_exar_remove,

	.driver	= {

		.name = DRIVER_NAME,

	},

CRA Git | Maintained and supported by SUSTech CRA and CCSE