Commit a0912083 authored by Linus Walleij's avatar Linus Walleij
Browse files

Merge tag 'intel-gpio-v5.19-1' of... 

Merge tag 'intel-gpio-v5.19-1' of git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-gpio-intel into devel

intel-gpio for v5.19-1

* Introduce helpers to iterate over GPIO chip nodes and covert some drivers

The following is an automated git shortlog grouped by driver:

gpiolib:
 -  Introduce a helper to get first GPIO controller node
 -  Introduce gpiochip_node_count() helper
 -  Introduce for_each_gpiochip_node() loop helper

pinctrl:
 -  meson: Replace custom code by gpiochip_node_count() call
 -  meson: Enable COMPILE_TEST
 -  meson: Rename REG_* to MESON_REG_*
 -  armada-37xx: Reuse GPIO fwnode in armada_37xx_irqchip_register()
 -  armada-37xx: Switch to use fwnode instead of of_node
 -  samsung: Switch to use for_each_gpiochip_node() helper
 -  samsung: Drop redundant node parameter in samsung_banks_of_node_get()
 -  npcm7xx: Switch to use for_each_gpiochip_node() helper
 -  renesas: rza1: Switch to use for_each_gpiochip_node() helper
 -  renesas: rza1: Replace custom code by gpiochip_node_count() call
 -  stm32: Switch to use for_each_gpiochip_node() helper
 -  stm32: Replace custom code by gpiochip_node_count() call
parents c954531b edc5601d

drivers/pinctrl/meson/Kconfig

+1 −1
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

menuconfig PINCTRL_MESON

	tristate "Amlogic SoC pinctrl drivers"

	depends on ARCH_MESON

	depends on ARCH_MESON || COMPILE_TEST

	depends on OF

	default y

	select PINMUX

drivers/pinctrl/meson/pinctrl-meson.c

+24 −28
Original line number Diff line number Diff line
@@ -49,6 +49,7 @@ 
#include <linux/pinctrl/pinctrl.h>

#include <linux/pinctrl/pinmux.h>

#include <linux/platform_device.h>

#include <linux/property.h>

#include <linux/regmap.h>

#include <linux/seq_file.h>
@@ -218,13 +219,13 @@ static int meson_pinconf_set_output(struct meson_pinctrl *pc, 
				    unsigned int pin,

				    bool out)

{

	return meson_pinconf_set_gpio_bit(pc, pin, REG_DIR, !out);

	return meson_pinconf_set_gpio_bit(pc, pin, MESON_REG_DIR, !out);

}



static int meson_pinconf_get_output(struct meson_pinctrl *pc,

				    unsigned int pin)

{

	int ret = meson_pinconf_get_gpio_bit(pc, pin, REG_DIR);

	int ret = meson_pinconf_get_gpio_bit(pc, pin, MESON_REG_DIR);



	if (ret < 0)

		return ret;
@@ -236,13 +237,13 @@ static int meson_pinconf_set_drive(struct meson_pinctrl *pc, 
				   unsigned int pin,

				   bool high)

{

	return meson_pinconf_set_gpio_bit(pc, pin, REG_OUT, high);

	return meson_pinconf_set_gpio_bit(pc, pin, MESON_REG_OUT, high);

}



static int meson_pinconf_get_drive(struct meson_pinctrl *pc,

				   unsigned int pin)

{

	return meson_pinconf_get_gpio_bit(pc, pin, REG_OUT);

	return meson_pinconf_get_gpio_bit(pc, pin, MESON_REG_OUT);

}



static int meson_pinconf_set_output_drive(struct meson_pinctrl *pc,
@@ -269,7 +270,7 @@ static int meson_pinconf_disable_bias(struct meson_pinctrl *pc, 
	if (ret)

		return ret;



	meson_calc_reg_and_bit(bank, pin, REG_PULLEN, &reg, &bit);

	meson_calc_reg_and_bit(bank, pin, MESON_REG_PULLEN, &reg, &bit);

	ret = regmap_update_bits(pc->reg_pullen, reg, BIT(bit), 0);

	if (ret)

		return ret;
@@ -288,7 +289,7 @@ static int meson_pinconf_enable_bias(struct meson_pinctrl *pc, unsigned int pin, 
	if (ret)

		return ret;



	meson_calc_reg_and_bit(bank, pin, REG_PULL, &reg, &bit);

	meson_calc_reg_and_bit(bank, pin, MESON_REG_PULL, &reg, &bit);

	if (pull_up)

		val = BIT(bit);
@@ -296,7 +297,7 @@ static int meson_pinconf_enable_bias(struct meson_pinctrl *pc, unsigned int pin, 
	if (ret)

		return ret;



	meson_calc_reg_and_bit(bank, pin, REG_PULLEN, &reg, &bit);

	meson_calc_reg_and_bit(bank, pin, MESON_REG_PULLEN, &reg, &bit);

	ret = regmap_update_bits(pc->reg_pullen, reg, BIT(bit),	BIT(bit));

	if (ret)

		return ret;
@@ -321,7 +322,7 @@ static int meson_pinconf_set_drive_strength(struct meson_pinctrl *pc, 
	if (ret)

		return ret;



	meson_calc_reg_and_bit(bank, pin, REG_DS, &reg, &bit);

	meson_calc_reg_and_bit(bank, pin, MESON_REG_DS, &reg, &bit);



	if (drive_strength_ua <= 500) {

		ds_val = MESON_PINCONF_DRV_500UA;
@@ -407,7 +408,7 @@ static int meson_pinconf_get_pull(struct meson_pinctrl *pc, unsigned int pin) 
	if (ret)

		return ret;



	meson_calc_reg_and_bit(bank, pin, REG_PULLEN, &reg, &bit);

	meson_calc_reg_and_bit(bank, pin, MESON_REG_PULLEN, &reg, &bit);



	ret = regmap_read(pc->reg_pullen, reg, &val);

	if (ret)
@@ -416,7 +417,7 @@ static int meson_pinconf_get_pull(struct meson_pinctrl *pc, unsigned int pin) 
	if (!(val & BIT(bit))) {

		conf = PIN_CONFIG_BIAS_DISABLE;

	} else {

		meson_calc_reg_and_bit(bank, pin, REG_PULL, &reg, &bit);

		meson_calc_reg_and_bit(bank, pin, MESON_REG_PULL, &reg, &bit);



		ret = regmap_read(pc->reg_pull, reg, &val);

		if (ret)
@@ -447,7 +448,7 @@ static int meson_pinconf_get_drive_strength(struct meson_pinctrl *pc, 
	if (ret)

		return ret;



	meson_calc_reg_and_bit(bank, pin, REG_DS, &reg, &bit);

	meson_calc_reg_and_bit(bank, pin, MESON_REG_DS, &reg, &bit);



	ret = regmap_read(pc->reg_ds, reg, &val);

	if (ret)
@@ -595,7 +596,7 @@ static int meson_gpio_get(struct gpio_chip *chip, unsigned gpio) 
	if (ret)

		return ret;



	meson_calc_reg_and_bit(bank, gpio, REG_IN, &reg, &bit);

	meson_calc_reg_and_bit(bank, gpio, MESON_REG_IN, &reg, &bit);

	regmap_read(pc->reg_gpio, reg, &val);



	return !!(val & BIT(bit));
@@ -662,27 +663,22 @@ static struct regmap *meson_map_resource(struct meson_pinctrl *pc, 
	return devm_regmap_init_mmio(pc->dev, base, &meson_regmap_config);

}



static int meson_pinctrl_parse_dt(struct meson_pinctrl *pc,

				  struct device_node *node)

static int meson_pinctrl_parse_dt(struct meson_pinctrl *pc)

{

	struct device_node *np, *gpio_np = NULL;

	struct device_node *gpio_np;

	unsigned int chips;



	for_each_child_of_node(node, np) {

		if (!of_find_property(np, "gpio-controller", NULL))

			continue;

		if (gpio_np) {

			dev_err(pc->dev, "multiple gpio nodes\n");

			of_node_put(np);

	chips = gpiochip_node_count(pc->dev);

	if (!chips) {

		dev_err(pc->dev, "no gpio node found\n");

		return -EINVAL;

	}

		gpio_np = np;

	}



	if (!gpio_np) {

		dev_err(pc->dev, "no gpio node found\n");

	if (chips > 1) {

		dev_err(pc->dev, "multiple gpio nodes\n");

		return -EINVAL;

	}



	gpio_np = to_of_node(gpiochip_node_get_first(pc->dev));

	pc->of_node = gpio_np;



	pc->reg_mux = meson_map_resource(pc, gpio_np, "mux");
@@ -751,7 +747,7 @@ int meson_pinctrl_probe(struct platform_device *pdev) 
	pc->dev = dev;

	pc->data = (struct meson_pinctrl_data *) of_device_get_match_data(dev);



	ret = meson_pinctrl_parse_dt(pc, dev->of_node);

	ret = meson_pinctrl_parse_dt(pc);

	if (ret)

		return ret;

drivers/pinctrl/meson/pinctrl-meson.h

+14 −14
Original line number Diff line number Diff line
@@ -63,13 +63,13 @@ struct meson_reg_desc { 
 * enum meson_reg_type - type of registers encoded in @meson_reg_desc

 */

enum meson_reg_type {

	REG_PULLEN,

	REG_PULL,

	REG_DIR,

	REG_OUT,

	REG_IN,

	REG_DS,

	NUM_REG,

	MESON_REG_PULLEN,

	MESON_REG_PULL,

	MESON_REG_DIR,

	MESON_REG_OUT,

	MESON_REG_IN,

	MESON_REG_DS,

	MESON_NUM_REG,

};



/**
@@ -102,7 +102,7 @@ struct meson_bank { 
	unsigned int last;

	int irq_first;

	int irq_last;

	struct meson_reg_desc regs[NUM_REG];

	struct meson_reg_desc regs[MESON_NUM_REG];

};



struct meson_pinctrl_data {
@@ -150,12 +150,12 @@ struct meson_pinctrl { 
		.irq_first	= fi,					\

		.irq_last	= li,					\

		.regs = {						\

			[REG_PULLEN]	= { per, peb },			\

			[REG_PULL]	= { pr, pb },			\

			[REG_DIR]	= { dr, db },			\

			[REG_OUT]	= { or, ob },			\

			[REG_IN]	= { ir, ib },			\

			[REG_DS]	= { dsr, dsb },			\

			[MESON_REG_PULLEN]	= { per, peb },		\

			[MESON_REG_PULL]	= { pr, pb },		\

			[MESON_REG_DIR]		= { dr, db },		\

			[MESON_REG_OUT]		= { or, ob },		\

			[MESON_REG_IN]		= { ir, ib },		\

			[MESON_REG_DS]		= { dsr, dsb },		\

		},							\

	 }

drivers/pinctrl/mvebu/pinctrl-armada-37xx.c

+10 −24
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <linux/pinctrl/pinctrl.h>

#include <linux/pinctrl/pinmux.h>

#include <linux/platform_device.h>

#include <linux/property.h>

#include <linux/regmap.h>

#include <linux/slab.h>

#include <linux/string_helpers.h>
@@ -726,23 +727,13 @@ static int armada_37xx_irqchip_register(struct platform_device *pdev, 
	struct gpio_chip *gc = &info->gpio_chip;

	struct irq_chip *irqchip = &info->irq_chip;

	struct gpio_irq_chip *girq = &gc->irq;

	struct device_node *np = to_of_node(gc->fwnode);

	struct device *dev = &pdev->dev;

	struct device_node *np;

	int ret = -ENODEV, i, nr_irq_parent;

	unsigned int i, nr_irq_parent;



	/* Check if we have at least one gpio-controller child node */

	for_each_child_of_node(dev->of_node, np) {

		if (of_property_read_bool(np, "gpio-controller")) {

			ret = 0;

			break;

		}

	}

	if (ret)

		return dev_err_probe(dev, ret, "no gpio-controller child node\n");



	nr_irq_parent = of_irq_count(np);

	spin_lock_init(&info->irq_lock);



	nr_irq_parent = of_irq_count(np);

	if (!nr_irq_parent) {

		dev_err(dev, "invalid or no IRQ\n");

		return 0;
@@ -787,18 +778,13 @@ static int armada_37xx_gpiochip_register(struct platform_device *pdev, 
					struct armada_37xx_pinctrl *info)

{

	struct device *dev = &pdev->dev;

	struct device_node *np;

	struct fwnode_handle *fwnode;

	struct gpio_chip *gc;

	int ret = -ENODEV;

	int ret;



	for_each_child_of_node(dev->of_node, np) {

		if (of_find_property(np, "gpio-controller", NULL)) {

			ret = 0;

			break;

		}

	}

	if (ret)

		return ret;

	fwnode = gpiochip_node_get_first(dev);

	if (!fwnode)

		return -ENODEV;



	info->gpio_chip = armada_37xx_gpiolib_chip;
@@ -806,7 +792,7 @@ static int armada_37xx_gpiochip_register(struct platform_device *pdev, 
	gc->ngpio = info->data->nr_pins;

	gc->parent = dev;

	gc->base = -1;

	gc->of_node = np;

	gc->fwnode = fwnode;

	gc->label = info->data->name;



	ret = armada_37xx_irqchip_register(pdev, info);

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

+62 −80
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include <linux/pinctrl/pinctrl.h>

#include <linux/pinctrl/pinmux.h>

#include <linux/platform_device.h>

#include <linux/property.h>

#include <linux/regmap.h>



/* GCR registers */
@@ -1862,85 +1863,66 @@ static int npcm7xx_gpio_of(struct npcm7xx_pinctrl *pctrl) 
{

	int ret = -ENXIO;

	struct resource res;

	int id = 0, irq;

	struct device_node *np;

	struct of_phandle_args pinspec;

	struct device *dev = pctrl->dev;

	struct fwnode_reference_args args;

	struct fwnode_handle *child;

	int id = 0;



	for_each_gpiochip_node(dev, child) {

		struct device_node *np = to_of_node(child);



	for_each_available_child_of_node(pctrl->dev->of_node, np)

		if (of_find_property(np, "gpio-controller", NULL)) {

		ret = of_address_to_resource(np, 0, &res);

		if (ret < 0) {

				dev_err(pctrl->dev,

					"Resource fail for GPIO bank %u\n", id);

			dev_err(dev, "Resource fail for GPIO bank %u\n", id);

			return ret;

		}



			pctrl->gpio_bank[id].base =

				ioremap(res.start, resource_size(&res));



			irq = irq_of_parse_and_map(np, 0);

			if (irq < 0) {

				dev_err(pctrl->dev,

					"No IRQ for GPIO bank %u\n", id);

				ret = irq;

				return ret;

			}

		pctrl->gpio_bank[id].base = ioremap(res.start, resource_size(&res));



			ret = bgpio_init(&pctrl->gpio_bank[id].gc,

					 pctrl->dev, 4,

					 pctrl->gpio_bank[id].base +

					 NPCM7XX_GP_N_DIN,

					 pctrl->gpio_bank[id].base +

					 NPCM7XX_GP_N_DOUT,

		ret = bgpio_init(&pctrl->gpio_bank[id].gc, dev, 4,

				 pctrl->gpio_bank[id].base + NPCM7XX_GP_N_DIN,

				 pctrl->gpio_bank[id].base + NPCM7XX_GP_N_DOUT,

				 NULL,

				 NULL,

					 pctrl->gpio_bank[id].base +

					 NPCM7XX_GP_N_IEM,

				 pctrl->gpio_bank[id].base + NPCM7XX_GP_N_IEM,

				 BGPIOF_READ_OUTPUT_REG_SET);

		if (ret) {

				dev_err(pctrl->dev, "bgpio_init() failed\n");

			dev_err(dev, "bgpio_init() failed\n");

			return ret;

		}



			ret = of_parse_phandle_with_fixed_args(np,

							       "gpio-ranges", 3,

							       0, &pinspec);

		ret = fwnode_property_get_reference_args(child, "gpio-ranges", NULL, 3, 0, &args);

		if (ret < 0) {

				dev_err(pctrl->dev,

					"gpio-ranges fail for GPIO bank %u\n",

					id);

			dev_err(dev, "gpio-ranges fail for GPIO bank %u\n", id);

			return ret;

		}



			pctrl->gpio_bank[id].irq = irq;

		ret = irq_of_parse_and_map(np, 0);

		if (ret < 0) {

			dev_err(dev, "No IRQ for GPIO bank %u\n", id);

			return ret;

		}

		pctrl->gpio_bank[id].irq = ret;

		pctrl->gpio_bank[id].irq_chip = npcmgpio_irqchip;

			pctrl->gpio_bank[id].gc.parent = pctrl->dev;

			pctrl->gpio_bank[id].irqbase =

				id * NPCM7XX_GPIO_PER_BANK;

			pctrl->gpio_bank[id].pinctrl_id = pinspec.args[0];

			pctrl->gpio_bank[id].gc.base = pinspec.args[1];

			pctrl->gpio_bank[id].gc.ngpio = pinspec.args[2];

		pctrl->gpio_bank[id].irqbase = id * NPCM7XX_GPIO_PER_BANK;

		pctrl->gpio_bank[id].pinctrl_id = args.args[0];

		pctrl->gpio_bank[id].gc.base = args.args[1];

		pctrl->gpio_bank[id].gc.ngpio = args.args[2];

		pctrl->gpio_bank[id].gc.owner = THIS_MODULE;

			pctrl->gpio_bank[id].gc.label =

				devm_kasprintf(pctrl->dev, GFP_KERNEL, "%pOF",

					       np);

		pctrl->gpio_bank[id].gc.parent = dev;

		pctrl->gpio_bank[id].gc.fwnode = child;

		pctrl->gpio_bank[id].gc.label = devm_kasprintf(dev, GFP_KERNEL, "%pfw", child);

		if (pctrl->gpio_bank[id].gc.label == NULL)

			return -ENOMEM;



		pctrl->gpio_bank[id].gc.dbg_show = npcmgpio_dbg_show;

			pctrl->gpio_bank[id].direction_input =

				pctrl->gpio_bank[id].gc.direction_input;

			pctrl->gpio_bank[id].gc.direction_input =

				npcmgpio_direction_input;

			pctrl->gpio_bank[id].direction_output =

				pctrl->gpio_bank[id].gc.direction_output;

			pctrl->gpio_bank[id].gc.direction_output =

				npcmgpio_direction_output;

			pctrl->gpio_bank[id].request =

				pctrl->gpio_bank[id].gc.request;

		pctrl->gpio_bank[id].direction_input = pctrl->gpio_bank[id].gc.direction_input;

		pctrl->gpio_bank[id].gc.direction_input = npcmgpio_direction_input;

		pctrl->gpio_bank[id].direction_output = pctrl->gpio_bank[id].gc.direction_output;

		pctrl->gpio_bank[id].gc.direction_output = npcmgpio_direction_output;

		pctrl->gpio_bank[id].request = pctrl->gpio_bank[id].gc.request;

		pctrl->gpio_bank[id].gc.request = npcmgpio_gpio_request;

		pctrl->gpio_bank[id].gc.free = npcmgpio_gpio_free;

			pctrl->gpio_bank[id].gc.of_node = np;

		id++;

	}