drivers/pinctrl/bcm/pinctrl-brcmstb.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Driver for Broadcom brcmstb GPIO units (pinctrl only)
 *
 * Copyright (C) 2024-2025 Ivan T. Ivanov, Andrea della Porta
 * Copyright (C) 2021-3 Raspberry Pi Ltd.
 * Copyright (C) 2012 Chris Boot, Simon Arlott, Stephen Warren
 *
 * Based heavily on the BCM2835 GPIO & pinctrl driver, which was inspired by:
 * pinctrl-nomadik.c, please see original file for copyright information
 * pinctrl-tegra.c, please see original file for copyright information
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/pinctrl/pinconf.h>
#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinmux.h>
#include <linux/pinctrl/pinconf-generic.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/cleanup.h>

#include "pinctrl-brcmstb.h"

#define BRCMSTB_PULL_NONE	0
#define BRCMSTB_PULL_DOWN	1
#define BRCMSTB_PULL_UP		2
#define BRCMSTB_PULL_MASK	0x3

#define BIT_TO_REG(b)		(((b) >> 5) << 2)
#define BIT_TO_SHIFT(b)		((b) & 0x1f)

struct brcmstb_pinctrl {
	struct device *dev;
	void __iomem *base;
	struct pinctrl_dev *pctl_dev;
	struct pinctrl_desc pctl_desc;
	const struct pin_regs *pin_regs;
	const struct brcmstb_pin_funcs *pin_funcs;
	const char * const *func_names;
	unsigned int func_count;
	unsigned int func_gpio;
	const char *const *gpio_groups;
	struct pinctrl_gpio_range gpio_range;
	/* Protect FSEL registers */
	spinlock_t fsel_lock;
};

static unsigned int brcmstb_pinctrl_fsel_get(struct brcmstb_pinctrl *pc,
					     unsigned int pin)
{
	u32 bit = pc->pin_regs[pin].mux_bit;
	unsigned int func;
	int fsel;
	u32 val;

	if (!bit)
		return pc->func_gpio;

	bit &= ~MUX_BIT_VALID;

	val = readl(pc->base + BIT_TO_REG(bit));
	fsel = (val >> BIT_TO_SHIFT(bit)) & pc->pin_funcs[pin].func_mask;
	func = pc->pin_funcs[pin].funcs[fsel];

	if (func >= pc->func_count)
		func = fsel;

	dev_dbg(pc->dev, "get %04x: %08x (%u => %s)\n",
		BIT_TO_REG(bit), val, pin,
		pc->func_names[func]);

	return func;
}

static int brcmstb_pinctrl_fsel_set(struct brcmstb_pinctrl *pc,
				    unsigned int pin, unsigned int func)
{
	u32 bit = pc->pin_regs[pin].mux_bit, val, fsel_mask;
	const u8 *pin_funcs;
	int fsel;
	int cur;
	int i;

	if (!bit || func >= pc->func_count)
		return -EINVAL;

	bit &= ~MUX_BIT_VALID;

	fsel = pc->pin_funcs[pin].n_funcs + 1;
	fsel_mask = pc->pin_funcs[pin].func_mask;

	if (func >= fsel) {
		/* Convert to an fsel number */
		pin_funcs = pc->pin_funcs[pin].funcs;
		for (i = 1; i < fsel; i++) {
			if (pin_funcs[i - 1] == func) {
				fsel = i;
				break;
			}
		}
	} else {
		fsel = func;
	}

	if (fsel >= pc->pin_funcs[pin].n_funcs + 1)
		return -EINVAL;

	guard(spinlock_irqsave)(&pc->fsel_lock);

	val = readl(pc->base + BIT_TO_REG(bit));
	cur = (val >> BIT_TO_SHIFT(bit)) & fsel_mask;

	dev_dbg(pc->dev, "read %04x: %08x (%u => %s)\n",
		BIT_TO_REG(bit), val, pin,
		pc->func_names[cur]);

	if (cur != fsel) {
		val &= ~(fsel_mask << BIT_TO_SHIFT(bit));
		val |= fsel << BIT_TO_SHIFT(bit);

		dev_dbg(pc->dev, "write %04x: %08x (%u <= %s)\n",
			BIT_TO_REG(bit), val, pin,
			pc->func_names[fsel]);
		writel(val, pc->base + BIT_TO_REG(bit));
	}

	return 0;
}

static int brcmstb_pctl_get_groups_count(struct pinctrl_dev *pctldev)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	return pc->pctl_desc.npins;
}

static const char *brcmstb_pctl_get_group_name(struct pinctrl_dev *pctldev,
					       unsigned int selector)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	return pc->gpio_groups[selector];
}

static int brcmstb_pctl_get_group_pins(struct pinctrl_dev *pctldev,
				       unsigned int selector,
				       const unsigned int **pins,
				       unsigned int *num_pins)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	*pins = &pc->pctl_desc.pins[selector].number;
	*num_pins = 1;

	return 0;
}

static void brcmstb_pctl_pin_dbg_show(struct pinctrl_dev *pctldev,
				      struct seq_file *s, unsigned int offset)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
	unsigned int fsel = brcmstb_pinctrl_fsel_get(pc, offset);
	const char *fname = pc->func_names[fsel];

	seq_printf(s, "function %s", fname);
}

static void brcmstb_pctl_dt_free_map(struct pinctrl_dev *pctldev,
				     struct pinctrl_map *maps,
				     unsigned int num_maps)
{
	int i;

	for (i = 0; i < num_maps; i++)
		if (maps[i].type == PIN_MAP_TYPE_CONFIGS_PIN)
			kfree(maps[i].data.configs.configs);

	kfree(maps);
}

static const struct pinctrl_ops brcmstb_pctl_ops = {
	.get_groups_count = brcmstb_pctl_get_groups_count,
	.get_group_name = brcmstb_pctl_get_group_name,
	.get_group_pins = brcmstb_pctl_get_group_pins,
	.pin_dbg_show = brcmstb_pctl_pin_dbg_show,
	.dt_node_to_map = pinconf_generic_dt_node_to_map_all,
	.dt_free_map = brcmstb_pctl_dt_free_map,
};

static int brcmstb_pmx_free(struct pinctrl_dev *pctldev, unsigned int offset)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	/* disable by setting to GPIO */
	return brcmstb_pinctrl_fsel_set(pc, offset, pc->func_gpio);
}

static int brcmstb_pmx_get_functions_count(struct pinctrl_dev *pctldev)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	return pc->func_count;
}

static const char *brcmstb_pmx_get_function_name(struct pinctrl_dev *pctldev,
						 unsigned int selector)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	return (selector < pc->func_count) ? pc->func_names[selector] : NULL;
}

static int brcmstb_pmx_get_function_groups(struct pinctrl_dev *pctldev,
					   unsigned int selector,
					   const char *const **groups,
					   unsigned *const num_groups)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	*groups = pc->gpio_groups;
	*num_groups = pc->pctl_desc.npins;

	return 0;
}

static int brcmstb_pmx_set(struct pinctrl_dev *pctldev,
			   unsigned int func_selector,
			   unsigned int group_selector)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
	const struct pinctrl_desc *pctldesc = &pc->pctl_desc;
	const struct pinctrl_pin_desc *pindesc;

	if (group_selector >= pctldesc->npins)
		return -EINVAL;

	pindesc = &pctldesc->pins[group_selector];
	return brcmstb_pinctrl_fsel_set(pc, pindesc->number, func_selector);
}

static int brcmstb_pmx_gpio_request_enable(struct pinctrl_dev *pctldev,
					   struct pinctrl_gpio_range *range,
					   unsigned int pin)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	return brcmstb_pinctrl_fsel_set(pc, pin, pc->func_gpio);
}

static void brcmstb_pmx_gpio_disable_free(struct pinctrl_dev *pctldev,
					  struct pinctrl_gpio_range *range,
					  unsigned int offset)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	/* disable by setting to GPIO */
	(void)brcmstb_pinctrl_fsel_set(pc, offset, pc->func_gpio);
}

static bool brcmstb_pmx_function_is_gpio(struct pinctrl_dev *pctldev,
					 unsigned int selector)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	return pc->func_gpio == selector;
}

static const struct pinmux_ops brcmstb_pmx_ops = {
	.free = brcmstb_pmx_free,
	.get_functions_count = brcmstb_pmx_get_functions_count,
	.get_function_name = brcmstb_pmx_get_function_name,
	.get_function_groups = brcmstb_pmx_get_function_groups,
	.set_mux = brcmstb_pmx_set,
	.gpio_request_enable = brcmstb_pmx_gpio_request_enable,
	.gpio_disable_free = brcmstb_pmx_gpio_disable_free,
	.function_is_gpio = brcmstb_pmx_function_is_gpio,
	.strict = true,
};

static unsigned int brcmstb_pull_config_get(struct brcmstb_pinctrl *pc,
					    unsigned int pin)
{
	u32 bit = pc->pin_regs[pin].pad_bit, val;

	if (bit == PAD_BIT_INVALID)
		return BRCMSTB_PULL_NONE;

	val = readl(pc->base + BIT_TO_REG(bit));
	return (val >> BIT_TO_SHIFT(bit)) & BRCMSTB_PULL_MASK;
}

static int brcmstb_pull_config_set(struct brcmstb_pinctrl *pc,
				   unsigned int pin, unsigned int arg)
{
	u32 bit = pc->pin_regs[pin].pad_bit, val;

	if (bit == PAD_BIT_INVALID) {
		dev_warn(pc->dev, "Can't set pulls for %s\n",
			 pc->gpio_groups[pin]);
		return -EINVAL;
	}

	guard(spinlock_irqsave)(&pc->fsel_lock);

	val = readl(pc->base + BIT_TO_REG(bit));
	val &= ~(BRCMSTB_PULL_MASK << BIT_TO_SHIFT(bit));
	val |= (arg << BIT_TO_SHIFT(bit));
	writel(val, pc->base + BIT_TO_REG(bit));

	return 0;
}

static int brcmstb_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin,
			       unsigned long *config)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
	enum pin_config_param param = pinconf_to_config_param(*config);
	u32 arg;

	switch (param) {
	case PIN_CONFIG_BIAS_DISABLE:
		arg = (brcmstb_pull_config_get(pc, pin) == BRCMSTB_PULL_NONE);
		break;
	case PIN_CONFIG_BIAS_PULL_DOWN:
		arg = (brcmstb_pull_config_get(pc, pin) == BRCMSTB_PULL_DOWN);
		break;
	case PIN_CONFIG_BIAS_PULL_UP:
		arg = (brcmstb_pull_config_get(pc, pin) == BRCMSTB_PULL_UP);
		break;
	default:
		return -ENOTSUPP;
	}

	*config = pinconf_to_config_packed(param, arg);

	return 0;
}

static int brcmstb_pinconf_set(struct pinctrl_dev *pctldev,
			       unsigned int pin, unsigned long *configs,
			       unsigned int num_configs)
{
	struct brcmstb_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
	int ret = 0;
	u32 param;
	int i;

	for (i = 0; i < num_configs; i++) {
		param = pinconf_to_config_param(configs[i]);

		switch (param) {
		case PIN_CONFIG_BIAS_DISABLE:
			ret = brcmstb_pull_config_set(pc, pin, BRCMSTB_PULL_NONE);
			break;
		case PIN_CONFIG_BIAS_PULL_DOWN:
			ret = brcmstb_pull_config_set(pc, pin, BRCMSTB_PULL_DOWN);
			break;
		case PIN_CONFIG_BIAS_PULL_UP:
			ret = brcmstb_pull_config_set(pc, pin, BRCMSTB_PULL_UP);
			break;
		default:
			return -ENOTSUPP;
		}
	}

	return ret;
}

static const struct pinconf_ops brcmstb_pinconf_ops = {
	.is_generic = true,
	.pin_config_get = brcmstb_pinconf_get,
	.pin_config_set = brcmstb_pinconf_set,
};

int brcmstb_pinctrl_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;
	const struct brcmstb_pdata *pdata;
	struct brcmstb_pinctrl *pc;
	const char **names;
	int num_pins, i;

	pdata = of_device_get_match_data(dev);

	pc = devm_kzalloc(dev, sizeof(*pc), GFP_KERNEL);
	if (!pc)
		return -ENOMEM;

	platform_set_drvdata(pdev, pc);
	pc->dev = dev;
	spin_lock_init(&pc->fsel_lock);

	pc->base = devm_of_iomap(dev, np, 0, NULL);
	if (IS_ERR(pc->base))
		return dev_err_probe(&pdev->dev, PTR_ERR(pc->base),
				     "Could not get IO memory\n");

	pc->pctl_desc = *pdata->pctl_desc;
	pc->pctl_desc.pctlops = &brcmstb_pctl_ops;
	pc->pctl_desc.pmxops = &brcmstb_pmx_ops;
	pc->pctl_desc.confops = &brcmstb_pinconf_ops;
	pc->pctl_desc.owner = THIS_MODULE;
	num_pins = pc->pctl_desc.npins;
	names = devm_kmalloc_array(dev, num_pins, sizeof(const char *),
				   GFP_KERNEL);
	if (!names)
		return -ENOMEM;

	for (i = 0; i < num_pins; i++)
		names[i] = pc->pctl_desc.pins[i].name;

	pc->gpio_groups = names;
	pc->pin_regs = pdata->pin_regs;
	pc->pin_funcs = pdata->pin_funcs;
	pc->func_count = pdata->func_count;
	pc->func_names = pdata->func_names;

	pc->pctl_dev = devm_pinctrl_register(dev, &pc->pctl_desc, pc);
	if (IS_ERR(pc->pctl_dev))
		return dev_err_probe(&pdev->dev, PTR_ERR(pc->pctl_dev),
				     "Failed to register pinctrl device\n");

	pc->gpio_range = *pdata->gpio_range;
	pinctrl_add_gpio_range(pc->pctl_dev, &pc->gpio_range);

	return 0;
}
EXPORT_SYMBOL(brcmstb_pinctrl_probe);

MODULE_AUTHOR("Phil Elwell");
MODULE_AUTHOR("Jonathan Bell");
MODULE_AUTHOR("Ivan T. Ivanov");
MODULE_AUTHOR("Andrea della Porta");
MODULE_DESCRIPTION("Broadcom brcmstb pinctrl driver");
MODULE_LICENSE("GPL");