// 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 #include #include #include #include #include #include #include #include #include #include #include #include #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");