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

Merge tag 'intel-pinctrl-v5.17-2' of... 

Merge tag 'intel-pinctrl-v5.17-2' of gitolite.kernel.org:pub/scm/linux/kernel/git/pinctrl/intel into devel

intel-pinctrl for v5.17-2

* Introduce new generic kasprintf_strarray() API
* Clean up and convert existing drivers to use the above

The API will be needed in the future for new comers, including Intel ones.

The following is an automated git shortlog grouped by driver:

armada-37xx:
 -  Switch to use devm_kasprintf_strarray()
 -  Convert to use dev_err_probe()
 -  Make use of the devm_platform_ioremap_resource()
 -  Use temporary variable for struct device
 -  Fix function name in the kernel doc

gpio:
 -  mockup: Switch to use kasprintf_strarray()

lib/string_helpers:
 -  Introduce managed variant of kasprintf_strarray()
 -  Introduce kasprintf_strarray()

pinctrl/rockchip:
 -  Switch to use devm_kasprintf_strarray()
 -  Convert to use dev_err_probe()
 -  Make use of the devm_platform_get_and_ioremap_resource()
 -  Use temporary variable for struct device
 -  Drop wrong kernel doc annotation

st:
 -  Switch to use devm_kasprintf_strarray()
 -  Convert to use dev_err_probe()
 -  Make use of the devm_platform_ioremap_resource_byname()
 -  Use temporary variable for struct device
 -  Drop wrong kernel doc annotations

zynqmp:
 -  Unify pin naming
parents fa55b7dc f7c151d8

drivers/gpio/gpio-mockup.c

+1 −22
Original line number Diff line number Diff line
@@ -491,27 +491,6 @@ static void gpio_mockup_unregister_pdevs(void) 
	}

}



static __init char **gpio_mockup_make_line_names(const char *label,

						 unsigned int num_lines)

{

	unsigned int i;

	char **names;



	names = kcalloc(num_lines + 1, sizeof(char *), GFP_KERNEL);

	if (!names)

		return NULL;



	for (i = 0; i < num_lines; i++) {

		names[i] = kasprintf(GFP_KERNEL, "%s-%u", label, i);

		if (!names[i]) {

			kfree_strarray(names, i);

			return NULL;

		}

	}



	return names;

}



static int __init gpio_mockup_register_chip(int idx)

{

	struct property_entry properties[GPIO_MOCKUP_MAX_PROP];
@@ -538,7 +517,7 @@ static int __init gpio_mockup_register_chip(int idx) 
	properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios", ngpio);



	if (gpio_mockup_named_lines) {

		line_names = gpio_mockup_make_line_names(chip_label, ngpio);

		line_names = kasprintf_strarray(GFP_KERNEL, chip_label, ngpio);

		if (!line_names)

			return -ENOMEM;

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

+34 −51
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
#include <linux/platform_device.h>

#include <linux/regmap.h>

#include <linux/slab.h>

#include <linux/string_helpers.h>



#include "../pinctrl-utils.h"
@@ -341,12 +342,12 @@ static int armada_37xx_pmx_set_by_name(struct pinctrl_dev *pctldev, 
				       struct armada_37xx_pin_group *grp)

{

	struct armada_37xx_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);

	struct device *dev = info->dev;

	unsigned int reg = SELECTION;

	unsigned int mask = grp->reg_mask;

	int func, val;



	dev_dbg(info->dev, "enable function %s group %s\n",

		name, grp->name);

	dev_dbg(dev, "enable function %s group %s\n", name, grp->name);



	func = match_string(grp->funcs, NB_FUNCS, name);

	if (func < 0)
@@ -722,25 +723,22 @@ static unsigned int armada_37xx_irq_startup(struct irq_data *d) 
static int armada_37xx_irqchip_register(struct platform_device *pdev,

					struct armada_37xx_pinctrl *info)

{

	struct device_node *np = info->dev->of_node;

	struct gpio_chip *gc = &info->gpio_chip;

	struct irq_chip *irqchip = &info->irq_chip;

	struct gpio_irq_chip *girq = &gc->irq;

	struct device *dev = &pdev->dev;

	struct resource res;

	struct device_node *np;

	int ret = -ENODEV, i, nr_irq_parent;



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

	for_each_child_of_node(info->dev->of_node, np) {

	for_each_child_of_node(dev->of_node, np) {

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

			ret = 0;

			break;

		}

	}

	if (ret) {

		dev_err(dev, "no gpio-controller child node\n");

		return ret;

	}

	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);
@@ -750,12 +748,7 @@ static int armada_37xx_irqchip_register(struct platform_device *pdev, 
		return 0;

	}



	if (of_address_to_resource(info->dev->of_node, 1, &res)) {

		dev_err(dev, "cannot find IO resource\n");

		return -ENOENT;

	}



	info->base = devm_ioremap_resource(info->dev, &res);

	info->base = devm_platform_ioremap_resource(pdev, 1);

	if (IS_ERR(info->base))

		return PTR_ERR(info->base);
@@ -774,8 +767,7 @@ static int armada_37xx_irqchip_register(struct platform_device *pdev, 
	 * the chained irq with all of them.

	 */

	girq->num_parents = nr_irq_parent;

	girq->parents = devm_kcalloc(&pdev->dev, nr_irq_parent,

				     sizeof(*girq->parents), GFP_KERNEL);

	girq->parents = devm_kcalloc(dev, nr_irq_parent, sizeof(*girq->parents), GFP_KERNEL);

	if (!girq->parents)

		return -ENOMEM;

	for (i = 0; i < nr_irq_parent; i++) {
@@ -794,11 +786,12 @@ static int armada_37xx_irqchip_register(struct platform_device *pdev, 
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 gpio_chip *gc;

	int ret = -ENODEV;



	for_each_child_of_node(info->dev->of_node, np) {

	for_each_child_of_node(dev->of_node, np) {

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

			ret = 0;

			break;
@@ -811,19 +804,16 @@ static int armada_37xx_gpiochip_register(struct platform_device *pdev, 


	gc = &info->gpio_chip;

	gc->ngpio = info->data->nr_pins;

	gc->parent = &pdev->dev;

	gc->parent = dev;

	gc->base = -1;

	gc->of_node = np;

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



	ret = armada_37xx_irqchip_register(pdev, info);

	if (ret)

		return ret;

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

	if (ret)

		return ret;



	return 0;

	return devm_gpiochip_add_data(dev, gc, info);

}



/**
@@ -874,13 +864,13 @@ static int armada_37xx_add_function(struct armada_37xx_pmx_func *funcs, 
static int armada_37xx_fill_group(struct armada_37xx_pinctrl *info)

{

	int n, num = 0, funcsize = info->data->nr_pins;

	struct device *dev = info->dev;



	for (n = 0; n < info->ngroups; n++) {

		struct armada_37xx_pin_group *grp = &info->groups[n];

		int i, j, f;



		grp->pins = devm_kcalloc(info->dev,

					 grp->npins + grp->extra_npins,

		grp->pins = devm_kcalloc(dev, grp->npins + grp->extra_npins,

					 sizeof(*grp->pins),

					 GFP_KERNEL);

		if (!grp->pins)
@@ -898,8 +888,7 @@ static int armada_37xx_fill_group(struct armada_37xx_pinctrl *info) 
			ret = armada_37xx_add_function(info->funcs, &funcsize,

					    grp->funcs[f]);

			if (ret == -EOVERFLOW)

				dev_err(info->dev,

					"More functions than pins(%d)\n",

				dev_err(dev, "More functions than pins(%d)\n",

					info->data->nr_pins);

			if (ret < 0)

				continue;
@@ -913,7 +902,7 @@ static int armada_37xx_fill_group(struct armada_37xx_pinctrl *info) 
}



/**

 * armada_37xx_fill_funcs() - complete the funcs array

 * armada_37xx_fill_func() - complete the funcs array

 * @info: info driver instance

 *

 * Based on the data available from the armada_37xx_pin_group array
@@ -925,6 +914,7 @@ static int armada_37xx_fill_group(struct armada_37xx_pinctrl *info) 
static int armada_37xx_fill_func(struct armada_37xx_pinctrl *info)

{

	struct armada_37xx_pmx_func *funcs = info->funcs;

	struct device *dev = info->dev;

	int n;



	for (n = 0; n < info->nfuncs; n++) {
@@ -932,8 +922,7 @@ static int armada_37xx_fill_func(struct armada_37xx_pinctrl *info) 
		const char **groups;

		int g;



		funcs[n].groups = devm_kcalloc(info->dev,

					       funcs[n].ngroups,

		funcs[n].groups = devm_kcalloc(dev, funcs[n].ngroups,

					       sizeof(*(funcs[n].groups)),

					       GFP_KERNEL);

		if (!funcs[n].groups)
@@ -962,6 +951,8 @@ static int armada_37xx_pinctrl_register(struct platform_device *pdev, 
	const struct armada_37xx_pin_data *pin_data = info->data;

	struct pinctrl_desc *ctrldesc = &info->pctl;

	struct pinctrl_pin_desc *pindesc, *pdesc;

	struct device *dev = &pdev->dev;

	char **pin_names;

	int pin, ret;



	info->groups = pin_data->groups;
@@ -973,20 +964,21 @@ static int armada_37xx_pinctrl_register(struct platform_device *pdev, 
	ctrldesc->pmxops = &armada_37xx_pmx_ops;

	ctrldesc->confops = &armada_37xx_pinconf_ops;



	pindesc = devm_kcalloc(&pdev->dev,

			       pin_data->nr_pins, sizeof(*pindesc),

			       GFP_KERNEL);

	pindesc = devm_kcalloc(dev, pin_data->nr_pins, sizeof(*pindesc), GFP_KERNEL);

	if (!pindesc)

		return -ENOMEM;



	ctrldesc->pins = pindesc;

	ctrldesc->npins = pin_data->nr_pins;



	pin_names = devm_kasprintf_strarray(dev, pin_data->name, pin_data->nr_pins);

	if (IS_ERR(pin_names))

		return PTR_ERR(pin_names);



	pdesc = pindesc;

	for (pin = 0; pin < pin_data->nr_pins; pin++) {

		pdesc->number = pin;

		pdesc->name = kasprintf(GFP_KERNEL, "%s-%d",

					pin_data->name, pin);

		pdesc->name = pin_names[pin];

		pdesc++;

	}
@@ -994,14 +986,10 @@ static int armada_37xx_pinctrl_register(struct platform_device *pdev, 
	 * we allocate functions for number of pins and hope there are

	 * fewer unique functions than pins available

	 */

	info->funcs = devm_kcalloc(&pdev->dev,

				   pin_data->nr_pins,

				   sizeof(struct armada_37xx_pmx_func),

				   GFP_KERNEL);

	info->funcs = devm_kcalloc(dev, pin_data->nr_pins, sizeof(*info->funcs), GFP_KERNEL);

	if (!info->funcs)

		return -ENOMEM;





	ret = armada_37xx_fill_group(info);

	if (ret)

		return ret;
@@ -1010,11 +998,9 @@ static int armada_37xx_pinctrl_register(struct platform_device *pdev, 
	if (ret)

		return ret;



	info->pctl_dev = devm_pinctrl_register(&pdev->dev, ctrldesc, info);

	if (IS_ERR(info->pctl_dev)) {

		dev_err(&pdev->dev, "could not register pinctrl driver\n");

		return PTR_ERR(info->pctl_dev);

	}

	info->pctl_dev = devm_pinctrl_register(dev, ctrldesc, info);

	if (IS_ERR(info->pctl_dev))

		return dev_err_probe(dev, PTR_ERR(info->pctl_dev), "could not register pinctrl driver\n");



	return 0;

}
@@ -1143,18 +1129,15 @@ static int __init armada_37xx_pinctrl_probe(struct platform_device *pdev) 
	struct regmap *regmap;

	int ret;



	info = devm_kzalloc(dev, sizeof(struct armada_37xx_pinctrl),

			    GFP_KERNEL);

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

	if (!info)

		return -ENOMEM;



	info->dev = dev;



	regmap = syscon_node_to_regmap(np);

	if (IS_ERR(regmap)) {

		dev_err(&pdev->dev, "cannot get regmap\n");

		return PTR_ERR(regmap);

	}

	if (IS_ERR(regmap))

		return dev_err_probe(dev, PTR_ERR(regmap), "cannot get regmap\n");

	info->regmap = regmap;



	info->data = of_device_get_match_data(dev);

drivers/pinctrl/pinctrl-rockchip.c

+72 −87
Original line number Diff line number Diff line
@@ -33,13 +33,15 @@ 
#include <linux/clk.h>

#include <linux/regmap.h>

#include <linux/mfd/syscon.h>

#include <linux/string_helpers.h>



#include <dt-bindings/pinctrl/rockchip.h>



#include "core.h"

#include "pinconf.h"

#include "pinctrl-rockchip.h"



/**

/*

 * Generate a bitmask for setting a value (v) with a write mask bit in hiword

 * register 31:16 area.

 */
@@ -285,6 +287,7 @@ static int rockchip_dt_node_to_map(struct pinctrl_dev *pctldev, 
{

	struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);

	const struct rockchip_pin_group *grp;

	struct device *dev = info->dev;

	struct pinctrl_map *new_map;

	struct device_node *parent;

	int map_num = 1;
@@ -296,8 +299,7 @@ static int rockchip_dt_node_to_map(struct pinctrl_dev *pctldev, 
	 */

	grp = pinctrl_name_to_group(info, np->name);

	if (!grp) {

		dev_err(info->dev, "unable to find group for node %pOFn\n",

			np);

		dev_err(dev, "unable to find group for node %pOFn\n", np);

		return -EINVAL;

	}
@@ -331,7 +333,7 @@ static int rockchip_dt_node_to_map(struct pinctrl_dev *pctldev, 
		new_map[i].data.configs.num_configs = grp->data[i].nconfigs;

	}



	dev_dbg(pctldev->dev, "maps: function %s group %s num %d\n",

	dev_dbg(dev, "maps: function %s group %s num %d\n",

		(*map)->data.mux.function, (*map)->data.mux.group, map_num);



	return 0;
@@ -872,20 +874,20 @@ static int rockchip_verify_mux(struct rockchip_pin_bank *bank, 
			       int pin, int mux)

{

	struct rockchip_pinctrl *info = bank->drvdata;

	struct device *dev = info->dev;

	int iomux_num = (pin / 8);



	if (iomux_num > 3)

		return -EINVAL;



	if (bank->iomux[iomux_num].type & IOMUX_UNROUTED) {

		dev_err(info->dev, "pin %d is unrouted\n", pin);

		dev_err(dev, "pin %d is unrouted\n", pin);

		return -EINVAL;

	}



	if (bank->iomux[iomux_num].type & IOMUX_GPIO_ONLY) {

		if (mux != RK_FUNC_GPIO) {

			dev_err(info->dev,

				"pin %d only supports a gpio mux\n", pin);

			dev_err(dev, "pin %d only supports a gpio mux\n", pin);

			return -ENOTSUPP;

		}

	}
@@ -909,6 +911,7 @@ static int rockchip_verify_mux(struct rockchip_pin_bank *bank, 
static int rockchip_set_mux(struct rockchip_pin_bank *bank, int pin, int mux)

{

	struct rockchip_pinctrl *info = bank->drvdata;

	struct device *dev = info->dev;

	int iomux_num = (pin / 8);

	struct regmap *regmap;

	int reg, ret, mask, mux_type;
@@ -922,8 +925,7 @@ static int rockchip_set_mux(struct rockchip_pin_bank *bank, int pin, int mux) 
	if (bank->iomux[iomux_num].type & IOMUX_GPIO_ONLY)

		return 0;



	dev_dbg(info->dev, "setting mux of GPIO%d-%d to %d\n",

						bank->bank_num, pin, mux);

	dev_dbg(dev, "setting mux of GPIO%d-%d to %d\n", bank->bank_num, pin, mux);



	regmap = (bank->iomux[iomux_num].type & IOMUX_SOURCE_PMU)

				? info->regmap_pmu : info->regmap_base;
@@ -1575,6 +1577,7 @@ static int rockchip_get_drive_perpin(struct rockchip_pin_bank *bank, 
{

	struct rockchip_pinctrl *info = bank->drvdata;

	struct rockchip_pin_ctrl *ctrl = info->ctrl;

	struct device *dev = info->dev;

	struct regmap *regmap;

	int reg, ret;

	u32 data, temp, rmask_bits;
@@ -1620,7 +1623,7 @@ static int rockchip_get_drive_perpin(struct rockchip_pin_bank *bank, 
			bit -= 16;

			break;

		default:

			dev_err(info->dev, "unsupported bit: %d for pinctrl drive type: %d\n",

			dev_err(dev, "unsupported bit: %d for pinctrl drive type: %d\n",

				bit, drv_type);

			return -EINVAL;

		}
@@ -1632,8 +1635,7 @@ static int rockchip_get_drive_perpin(struct rockchip_pin_bank *bank, 
		rmask_bits = RK3288_DRV_BITS_PER_PIN;

		break;

	default:

		dev_err(info->dev, "unsupported pinctrl drive type: %d\n",

			drv_type);

		dev_err(dev, "unsupported pinctrl drive type: %d\n", drv_type);

		return -EINVAL;

	}
@@ -1652,13 +1654,14 @@ static int rockchip_set_drive_perpin(struct rockchip_pin_bank *bank, 
{

	struct rockchip_pinctrl *info = bank->drvdata;

	struct rockchip_pin_ctrl *ctrl = info->ctrl;

	struct device *dev = info->dev;

	struct regmap *regmap;

	int reg, ret, i;

	u32 data, rmask, rmask_bits, temp;

	u8 bit;

	int drv_type = bank->drv[pin_num / 8].drv_type;



	dev_dbg(info->dev, "setting drive of GPIO%d-%d to %d\n",

	dev_dbg(dev, "setting drive of GPIO%d-%d to %d\n",

		bank->bank_num, pin_num, strength);



	ctrl->drv_calc_reg(bank, pin_num, &regmap, &reg, &bit);
@@ -1680,8 +1683,7 @@ static int rockchip_set_drive_perpin(struct rockchip_pin_bank *bank, 
	}



	if (ret < 0) {

		dev_err(info->dev, "unsupported driver strength %d\n",

			strength);

		dev_err(dev, "unsupported driver strength %d\n", strength);

		return ret;

	}
@@ -1720,7 +1722,7 @@ static int rockchip_set_drive_perpin(struct rockchip_pin_bank *bank, 
			bit -= 16;

			break;

		default:

			dev_err(info->dev, "unsupported bit: %d for pinctrl drive type: %d\n",

			dev_err(dev, "unsupported bit: %d for pinctrl drive type: %d\n",

				bit, drv_type);

			return -EINVAL;

		}
@@ -1731,8 +1733,7 @@ static int rockchip_set_drive_perpin(struct rockchip_pin_bank *bank, 
		rmask_bits = RK3288_DRV_BITS_PER_PIN;

		break;

	default:

		dev_err(info->dev, "unsupported pinctrl drive type: %d\n",

			drv_type);

		dev_err(dev, "unsupported pinctrl drive type: %d\n", drv_type);

		return -EINVAL;

	}
@@ -1766,6 +1767,7 @@ static int rockchip_get_pull(struct rockchip_pin_bank *bank, int pin_num) 
{

	struct rockchip_pinctrl *info = bank->drvdata;

	struct rockchip_pin_ctrl *ctrl = info->ctrl;

	struct device *dev = info->dev;

	struct regmap *regmap;

	int reg, ret, pull_type;

	u8 bit;
@@ -1800,7 +1802,7 @@ static int rockchip_get_pull(struct rockchip_pin_bank *bank, int pin_num) 


		return rockchip_pull_list[pull_type][data];

	default:

		dev_err(info->dev, "unsupported pinctrl type\n");

		dev_err(dev, "unsupported pinctrl type\n");

		return -EINVAL;

	};

}
@@ -1810,13 +1812,13 @@ static int rockchip_set_pull(struct rockchip_pin_bank *bank, 
{

	struct rockchip_pinctrl *info = bank->drvdata;

	struct rockchip_pin_ctrl *ctrl = info->ctrl;

	struct device *dev = info->dev;

	struct regmap *regmap;

	int reg, ret, i, pull_type;

	u8 bit;

	u32 data, rmask;



	dev_dbg(info->dev, "setting pull of GPIO%d-%d to %d\n",

		 bank->bank_num, pin_num, pull);

	dev_dbg(dev, "setting pull of GPIO%d-%d to %d\n", bank->bank_num, pin_num, pull);



	/* rk3066b does support any pulls */

	if (ctrl->type == RK3066B)
@@ -1859,8 +1861,7 @@ static int rockchip_set_pull(struct rockchip_pin_bank *bank, 
		}



		if (ret < 0) {

			dev_err(info->dev, "unsupported pull setting %d\n",

				pull);

			dev_err(dev, "unsupported pull setting %d\n", pull);

			return ret;

		}
@@ -1872,7 +1873,7 @@ static int rockchip_set_pull(struct rockchip_pin_bank *bank, 
		ret = regmap_update_bits(regmap, reg, rmask, data);

		break;

	default:

		dev_err(info->dev, "unsupported pinctrl type\n");

		dev_err(dev, "unsupported pinctrl type\n");

		return -EINVAL;

	}
@@ -1963,12 +1964,13 @@ static int rockchip_set_schmitt(struct rockchip_pin_bank *bank, 
{

	struct rockchip_pinctrl *info = bank->drvdata;

	struct rockchip_pin_ctrl *ctrl = info->ctrl;

	struct device *dev = info->dev;

	struct regmap *regmap;

	int reg, ret;

	u8 bit;

	u32 data, rmask;



	dev_dbg(info->dev, "setting input schmitt of GPIO%d-%d to %d\n",

	dev_dbg(dev, "setting input schmitt of GPIO%d-%d to %d\n",

		bank->bank_num, pin_num, enable);



	ret = ctrl->schmitt_calc_reg(bank, pin_num, &regmap, &reg, &bit);
@@ -2028,10 +2030,11 @@ static int rockchip_pmx_set(struct pinctrl_dev *pctldev, unsigned selector, 
	struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);

	const unsigned int *pins = info->groups[group].pins;

	const struct rockchip_pin_config *data = info->groups[group].data;

	struct device *dev = info->dev;

	struct rockchip_pin_bank *bank;

	int cnt, ret = 0;



	dev_dbg(info->dev, "enable function %s group %s\n",

	dev_dbg(dev, "enable function %s group %s\n",

		info->functions[selector].name, info->groups[group].name);



	/*
@@ -2310,6 +2313,7 @@ static int rockchip_pinctrl_parse_groups(struct device_node *np, 
					      struct rockchip_pinctrl *info,

					      u32 index)

{

	struct device *dev = info->dev;

	struct rockchip_pin_bank *bank;

	int size;

	const __be32 *list;
@@ -2317,7 +2321,7 @@ static int rockchip_pinctrl_parse_groups(struct device_node *np, 
	int i, j;

	int ret;



	dev_dbg(info->dev, "group(%d): %pOFn\n", index, np);

	dev_dbg(dev, "group(%d): %pOFn\n", index, np);



	/* Initialise group */

	grp->name = np->name;
@@ -2329,19 +2333,13 @@ static int rockchip_pinctrl_parse_groups(struct device_node *np, 
	list = of_get_property(np, "rockchip,pins", &size);

	/* we do not check return since it's safe node passed down */

	size /= sizeof(*list);

	if (!size || size % 4) {

		dev_err(info->dev, "wrong pins number or pins and configs should be by 4\n");

		return -EINVAL;

	}

	if (!size || size % 4)

		return dev_err_probe(dev, -EINVAL, "wrong pins number or pins and configs should be by 4\n");



	grp->npins = size / 4;



	grp->pins = devm_kcalloc(info->dev, grp->npins, sizeof(unsigned int),

						GFP_KERNEL);

	grp->data = devm_kcalloc(info->dev,

					grp->npins,

					sizeof(struct rockchip_pin_config),

					GFP_KERNEL);

	grp->pins = devm_kcalloc(dev, grp->npins, sizeof(*grp->pins), GFP_KERNEL);

	grp->data = devm_kcalloc(dev, grp->npins, sizeof(*grp->data), GFP_KERNEL);

	if (!grp->pins || !grp->data)

		return -ENOMEM;
@@ -2375,6 +2373,7 @@ static int rockchip_pinctrl_parse_functions(struct device_node *np, 
						struct rockchip_pinctrl *info,

						u32 index)

{

	struct device *dev = info->dev;

	struct device_node *child;

	struct rockchip_pmx_func *func;

	struct rockchip_pin_group *grp;
@@ -2382,7 +2381,7 @@ static int rockchip_pinctrl_parse_functions(struct device_node *np, 
	static u32 grp_index;

	u32 i = 0;



	dev_dbg(info->dev, "parse function(%d): %pOFn\n", index, np);

	dev_dbg(dev, "parse function(%d): %pOFn\n", index, np);



	func = &info->functions[index];
@@ -2392,8 +2391,7 @@ static int rockchip_pinctrl_parse_functions(struct device_node *np, 
	if (func->ngroups <= 0)

		return 0;



	func->groups = devm_kcalloc(info->dev,

			func->ngroups, sizeof(char *), GFP_KERNEL);

	func->groups = devm_kcalloc(dev, func->ngroups, sizeof(*func->groups), GFP_KERNEL);

	if (!func->groups)

		return -ENOMEM;
@@ -2421,20 +2419,14 @@ static int rockchip_pinctrl_parse_dt(struct platform_device *pdev, 


	rockchip_pinctrl_child_count(info, np);



	dev_dbg(&pdev->dev, "nfunctions = %d\n", info->nfunctions);

	dev_dbg(&pdev->dev, "ngroups = %d\n", info->ngroups);

	dev_dbg(dev, "nfunctions = %d\n", info->nfunctions);

	dev_dbg(dev, "ngroups = %d\n", info->ngroups);



	info->functions = devm_kcalloc(dev,

					      info->nfunctions,

					      sizeof(struct rockchip_pmx_func),

					      GFP_KERNEL);

	info->functions = devm_kcalloc(dev, info->nfunctions, sizeof(*info->functions), GFP_KERNEL);

	if (!info->functions)

		return -ENOMEM;



	info->groups = devm_kcalloc(dev,

					    info->ngroups,

					    sizeof(struct rockchip_pin_group),

					    GFP_KERNEL);

	info->groups = devm_kcalloc(dev, info->ngroups, sizeof(*info->groups), GFP_KERNEL);

	if (!info->groups)

		return -ENOMEM;
@@ -2446,7 +2438,7 @@ static int rockchip_pinctrl_parse_dt(struct platform_device *pdev, 


		ret = rockchip_pinctrl_parse_functions(child, info, i++);

		if (ret) {

			dev_err(&pdev->dev, "failed to parse function\n");

			dev_err(dev, "failed to parse function\n");

			of_node_put(child);

			return ret;

		}
@@ -2461,6 +2453,8 @@ static int rockchip_pinctrl_register(struct platform_device *pdev, 
	struct pinctrl_desc *ctrldesc = &info->pctl;

	struct pinctrl_pin_desc *pindesc, *pdesc;

	struct rockchip_pin_bank *pin_bank;

	struct device *dev = &pdev->dev;

	char **pin_names;

	int pin, bank, ret;

	int k;
@@ -2470,9 +2464,7 @@ static int rockchip_pinctrl_register(struct platform_device *pdev, 
	ctrldesc->pmxops = &rockchip_pmx_ops;

	ctrldesc->confops = &rockchip_pinconf_ops;



	pindesc = devm_kcalloc(&pdev->dev,

			       info->ctrl->nr_pins, sizeof(*pindesc),

			       GFP_KERNEL);

	pindesc = devm_kcalloc(dev, info->ctrl->nr_pins, sizeof(*pindesc), GFP_KERNEL);

	if (!pindesc)

		return -ENOMEM;
@@ -2482,10 +2474,14 @@ static int rockchip_pinctrl_register(struct platform_device *pdev, 
	pdesc = pindesc;

	for (bank = 0, k = 0; bank < info->ctrl->nr_banks; bank++) {

		pin_bank = &info->ctrl->pin_banks[bank];



		pin_names = devm_kasprintf_strarray(dev, pin_bank->name, pin_bank->nr_pins);

		if (IS_ERR(pin_names))

			return PTR_ERR(pin_names);



		for (pin = 0; pin < pin_bank->nr_pins; pin++, k++) {

			pdesc->number = k;

			pdesc->name = kasprintf(GFP_KERNEL, "%s-%d",

						pin_bank->name, pin);

			pdesc->name = pin_names[pin];

			pdesc++;

		}
@@ -2497,11 +2493,9 @@ static int rockchip_pinctrl_register(struct platform_device *pdev, 
	if (ret)

		return ret;



	info->pctl_dev = devm_pinctrl_register(&pdev->dev, ctrldesc, info);

	if (IS_ERR(info->pctl_dev)) {

		dev_err(&pdev->dev, "could not register pinctrl driver\n");

		return PTR_ERR(info->pctl_dev);

	}

	info->pctl_dev = devm_pinctrl_register(dev, ctrldesc, info);

	if (IS_ERR(info->pctl_dev))

		return dev_err_probe(dev, PTR_ERR(info->pctl_dev), "could not register pinctrl driver\n");



	return 0;

}
@@ -2513,8 +2507,9 @@ static struct rockchip_pin_ctrl *rockchip_pinctrl_get_soc_data( 
						struct rockchip_pinctrl *d,

						struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct device_node *node = dev->of_node;

	const struct of_device_id *match;

	struct device_node *node = pdev->dev.of_node;

	struct rockchip_pin_ctrl *ctrl;

	struct rockchip_pin_bank *bank;

	int grf_offs, pmu_offs, drv_grf_offs, drv_pmu_offs, i, j;
@@ -2566,7 +2561,7 @@ static struct rockchip_pin_ctrl *rockchip_pinctrl_get_soc_data( 
						drv_pmu_offs : drv_grf_offs;

			}



			dev_dbg(d->dev, "bank %d, iomux %d has iom_offset 0x%x drv_offset 0x%x\n",

			dev_dbg(dev, "bank %d, iomux %d has iom_offset 0x%x drv_offset 0x%x\n",

				i, j, iom->offset, drv->offset);



			/*
@@ -2675,16 +2670,14 @@ static int rockchip_pinctrl_probe(struct platform_device *pdev) 
{

	struct rockchip_pinctrl *info;

	struct device *dev = &pdev->dev;

	struct device_node *np = dev->of_node, *node;

	struct rockchip_pin_ctrl *ctrl;

	struct device_node *np = pdev->dev.of_node, *node;

	struct resource *res;

	void __iomem *base;

	int ret;



	if (!dev->of_node) {

		dev_err(dev, "device tree node not found\n");

		return -ENODEV;

	}

	if (!dev->of_node)

		return dev_err_probe(dev, -ENODEV, "device tree node not found\n");



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

	if (!info)
@@ -2693,10 +2686,8 @@ static int rockchip_pinctrl_probe(struct platform_device *pdev) 
	info->dev = dev;



	ctrl = rockchip_pinctrl_get_soc_data(info, pdev);

	if (!ctrl) {

		dev_err(dev, "driver data not available\n");

		return -EINVAL;

	}

	if (!ctrl)

		return dev_err_probe(dev, -EINVAL, "driver data not available\n");

	info->ctrl = ctrl;



	node = of_parse_phandle(np, "rockchip,grf", 0);
@@ -2705,32 +2696,28 @@ static int rockchip_pinctrl_probe(struct platform_device *pdev) 
		if (IS_ERR(info->regmap_base))

			return PTR_ERR(info->regmap_base);

	} else {

		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

		base = devm_ioremap_resource(&pdev->dev, res);

		base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);

		if (IS_ERR(base))

			return PTR_ERR(base);



		rockchip_regmap_config.max_register = resource_size(res) - 4;

		rockchip_regmap_config.name = "rockchip,pinctrl";

		info->regmap_base = devm_regmap_init_mmio(&pdev->dev, base,

						    &rockchip_regmap_config);

		info->regmap_base =

			devm_regmap_init_mmio(dev, base, &rockchip_regmap_config);



		/* to check for the old dt-bindings */

		info->reg_size = resource_size(res);



		/* Honor the old binding, with pull registers as 2nd resource */

		if (ctrl->type == RK3188 && info->reg_size < 0x200) {

			res = platform_get_resource(pdev, IORESOURCE_MEM, 1);

			base = devm_ioremap_resource(&pdev->dev, res);

			base = devm_platform_get_and_ioremap_resource(pdev, 1, &res);

			if (IS_ERR(base))

				return PTR_ERR(base);



			rockchip_regmap_config.max_register =

							resource_size(res) - 4;

			rockchip_regmap_config.max_register = resource_size(res) - 4;

			rockchip_regmap_config.name = "rockchip,pinctrl-pull";

			info->regmap_pull = devm_regmap_init_mmio(&pdev->dev,

						    base,

						    &rockchip_regmap_config);

			info->regmap_pull =

				devm_regmap_init_mmio(dev, base, &rockchip_regmap_config);

		}

	}
@@ -2749,10 +2736,8 @@ static int rockchip_pinctrl_probe(struct platform_device *pdev) 
	platform_set_drvdata(pdev, info);



	ret = of_platform_populate(np, rockchip_bank_match, NULL, NULL);

	if (ret) {

		dev_err(&pdev->dev, "failed to register gpio device\n");

		return ret;

	}

	if (ret)

		return dev_err_probe(dev, ret, "failed to register gpio device\n");



	return 0;

}

drivers/pinctrl/pinctrl-st.c

+52 −64

File changed.

Preview size limit exceeded, changes collapsed.

drivers/pinctrl/pinctrl-zynqmp.c

+6 −4
Original line number Diff line number Diff line
@@ -809,6 +809,7 @@ static int zynqmp_pinctrl_prepare_pin_desc(struct device *dev, 
					   unsigned int *npins)

{

	struct pinctrl_pin_desc *pins, *pin;

	char **pin_names;

	int ret;

	int i;
@@ -820,13 +821,14 @@ static int zynqmp_pinctrl_prepare_pin_desc(struct device *dev, 
	if (!pins)

		return -ENOMEM;



	pin_names = devm_kasprintf_strarray(dev, ZYNQMP_PIN_PREFIX, *npins);

	if (IS_ERR(pin_names))

		return PTR_ERR(pin_names);



	for (i = 0; i < *npins; i++) {

		pin = &pins[i];

		pin->number = i;

		pin->name = devm_kasprintf(dev, GFP_KERNEL, "%s%d",

					   ZYNQMP_PIN_PREFIX, i);

		if (!pin->name)

			return -ENOMEM;

		pin->name = pin_names[i];

	}



	*zynqmp_pins = pins;