[linux-block.git] / drivers / pinctrl / bcm / pinctrl-bcm6362.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Driver for BCM6362 GPIO unit (pinctrl + GPIO)
 *
 * Copyright (C) 2021 Álvaro Fernández Rojas <noltari@gmail.com>
 * Copyright (C) 2016 Jonas Gorski <jonas.gorski@gmail.com>
 */

#include <linux/bits.h>
#include <linux/gpio/driver.h>
#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/pinctrl/pinmux.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

#include "../pinctrl-utils.h"

#include "pinctrl-bcm63xx.h"

#define BCM6362_BANK_GPIOS	32
#define BCM6362_NUM_GPIOS	48
#define BCM6362_NUM_LEDS	24

#define BCM6362_LED_REG		0x10
#define BCM6362_MODE_REG	0x18
#define BCM6362_CTRL_REG	0x1c
#define BCM6362_BASEMODE_REG	0x38
#define  BASEMODE_NAND		BIT(2)

enum bcm6362_pinctrl_reg {
	BCM6362_LEDCTRL,
	BCM6362_MODE,
	BCM6362_CTRL,
	BCM6362_BASEMODE,
};

struct bcm6362_pingroup {
	const char *name;
	const unsigned * const pins;
	const unsigned num_pins;
};

struct bcm6362_function {
	const char *name;
	const char * const *groups;
	const unsigned num_groups;

	enum bcm6362_pinctrl_reg reg;
	uint32_t basemode_mask;
};

#define BCM6362_PIN(a, b, mask)			\
	{					\
		.number = a,			\
		.name = b,			\
		.drv_data = (void *)(mask),	\
	}

static const struct pinctrl_pin_desc bcm6362_pins[] = {
	PINCTRL_PIN(0, "gpio0"),
	PINCTRL_PIN(1, "gpio1"),
	PINCTRL_PIN(2, "gpio2"),
	PINCTRL_PIN(3, "gpio3"),
	PINCTRL_PIN(4, "gpio4"),
	PINCTRL_PIN(5, "gpio5"),
	PINCTRL_PIN(6, "gpio6"),
	PINCTRL_PIN(7, "gpio7"),
	BCM6362_PIN(8, "gpio8", BASEMODE_NAND),
	PINCTRL_PIN(9, "gpio9"),
	PINCTRL_PIN(10, "gpio10"),
	PINCTRL_PIN(11, "gpio11"),
	BCM6362_PIN(12, "gpio12", BASEMODE_NAND),
	BCM6362_PIN(13, "gpio13", BASEMODE_NAND),
	BCM6362_PIN(14, "gpio14", BASEMODE_NAND),
	BCM6362_PIN(15, "gpio15", BASEMODE_NAND),
	BCM6362_PIN(16, "gpio16", BASEMODE_NAND),
	BCM6362_PIN(17, "gpio17", BASEMODE_NAND),
	BCM6362_PIN(18, "gpio18", BASEMODE_NAND),
	BCM6362_PIN(19, "gpio19", BASEMODE_NAND),
	BCM6362_PIN(20, "gpio20", BASEMODE_NAND),
	BCM6362_PIN(21, "gpio21", BASEMODE_NAND),
	BCM6362_PIN(22, "gpio22", BASEMODE_NAND),
	BCM6362_PIN(23, "gpio23", BASEMODE_NAND),
	PINCTRL_PIN(24, "gpio24"),
	PINCTRL_PIN(25, "gpio25"),
	PINCTRL_PIN(26, "gpio26"),
	BCM6362_PIN(27, "gpio27", BASEMODE_NAND),
	PINCTRL_PIN(28, "gpio28"),
	PINCTRL_PIN(29, "gpio29"),
	PINCTRL_PIN(30, "gpio30"),
	PINCTRL_PIN(31, "gpio31"),
	PINCTRL_PIN(32, "gpio32"),
	PINCTRL_PIN(33, "gpio33"),
	PINCTRL_PIN(34, "gpio34"),
	PINCTRL_PIN(35, "gpio35"),
	PINCTRL_PIN(36, "gpio36"),
	PINCTRL_PIN(37, "gpio37"),
	PINCTRL_PIN(38, "gpio38"),
	PINCTRL_PIN(39, "gpio39"),
	PINCTRL_PIN(40, "gpio40"),
	PINCTRL_PIN(41, "gpio41"),
	PINCTRL_PIN(42, "gpio42"),
	PINCTRL_PIN(43, "gpio43"),
	PINCTRL_PIN(44, "gpio44"),
	PINCTRL_PIN(45, "gpio45"),
	PINCTRL_PIN(46, "gpio46"),
	PINCTRL_PIN(47, "gpio47"),
};

static unsigned gpio0_pins[] = { 0 };
static unsigned gpio1_pins[] = { 1 };
static unsigned gpio2_pins[] = { 2 };
static unsigned gpio3_pins[] = { 3 };
static unsigned gpio4_pins[] = { 4 };
static unsigned gpio5_pins[] = { 5 };
static unsigned gpio6_pins[] = { 6 };
static unsigned gpio7_pins[] = { 7 };
static unsigned gpio8_pins[] = { 8 };
static unsigned gpio9_pins[] = { 9 };
static unsigned gpio10_pins[] = { 10 };
static unsigned gpio11_pins[] = { 11 };
static unsigned gpio12_pins[] = { 12 };
static unsigned gpio13_pins[] = { 13 };
static unsigned gpio14_pins[] = { 14 };
static unsigned gpio15_pins[] = { 15 };
static unsigned gpio16_pins[] = { 16 };
static unsigned gpio17_pins[] = { 17 };
static unsigned gpio18_pins[] = { 18 };
static unsigned gpio19_pins[] = { 19 };
static unsigned gpio20_pins[] = { 20 };
static unsigned gpio21_pins[] = { 21 };
static unsigned gpio22_pins[] = { 22 };
static unsigned gpio23_pins[] = { 23 };
static unsigned gpio24_pins[] = { 24 };
static unsigned gpio25_pins[] = { 25 };
static unsigned gpio26_pins[] = { 26 };
static unsigned gpio27_pins[] = { 27 };
static unsigned gpio28_pins[] = { 28 };
static unsigned gpio29_pins[] = { 29 };
static unsigned gpio30_pins[] = { 30 };
static unsigned gpio31_pins[] = { 31 };
static unsigned gpio32_pins[] = { 32 };
static unsigned gpio33_pins[] = { 33 };
static unsigned gpio34_pins[] = { 34 };
static unsigned gpio35_pins[] = { 35 };
static unsigned gpio36_pins[] = { 36 };
static unsigned gpio37_pins[] = { 37 };
static unsigned gpio38_pins[] = { 38 };
static unsigned gpio39_pins[] = { 39 };
static unsigned gpio40_pins[] = { 40 };
static unsigned gpio41_pins[] = { 41 };
static unsigned gpio42_pins[] = { 42 };
static unsigned gpio43_pins[] = { 43 };
static unsigned gpio44_pins[] = { 44 };
static unsigned gpio45_pins[] = { 45 };
static unsigned gpio46_pins[] = { 46 };
static unsigned gpio47_pins[] = { 47 };

static unsigned nand_grp_pins[] = {
	8, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 27,
};

#define BCM6362_GROUP(n)				\
	{						\
		.name = #n,				\
		.pins = n##_pins,			\
		.num_pins = ARRAY_SIZE(n##_pins),	\
	}

static struct bcm6362_pingroup bcm6362_groups[] = {
	BCM6362_GROUP(gpio0),
	BCM6362_GROUP(gpio1),
	BCM6362_GROUP(gpio2),
	BCM6362_GROUP(gpio3),
	BCM6362_GROUP(gpio4),
	BCM6362_GROUP(gpio5),
	BCM6362_GROUP(gpio6),
	BCM6362_GROUP(gpio7),
	BCM6362_GROUP(gpio8),
	BCM6362_GROUP(gpio9),
	BCM6362_GROUP(gpio10),
	BCM6362_GROUP(gpio11),
	BCM6362_GROUP(gpio12),
	BCM6362_GROUP(gpio13),
	BCM6362_GROUP(gpio14),
	BCM6362_GROUP(gpio15),
	BCM6362_GROUP(gpio16),
	BCM6362_GROUP(gpio17),
	BCM6362_GROUP(gpio18),
	BCM6362_GROUP(gpio19),
	BCM6362_GROUP(gpio20),
	BCM6362_GROUP(gpio21),
	BCM6362_GROUP(gpio22),
	BCM6362_GROUP(gpio23),
	BCM6362_GROUP(gpio24),
	BCM6362_GROUP(gpio25),
	BCM6362_GROUP(gpio26),
	BCM6362_GROUP(gpio27),
	BCM6362_GROUP(gpio28),
	BCM6362_GROUP(gpio29),
	BCM6362_GROUP(gpio30),
	BCM6362_GROUP(gpio31),
	BCM6362_GROUP(gpio32),
	BCM6362_GROUP(gpio33),
	BCM6362_GROUP(gpio34),
	BCM6362_GROUP(gpio35),
	BCM6362_GROUP(gpio36),
	BCM6362_GROUP(gpio37),
	BCM6362_GROUP(gpio38),
	BCM6362_GROUP(gpio39),
	BCM6362_GROUP(gpio40),
	BCM6362_GROUP(gpio41),
	BCM6362_GROUP(gpio42),
	BCM6362_GROUP(gpio43),
	BCM6362_GROUP(gpio44),
	BCM6362_GROUP(gpio45),
	BCM6362_GROUP(gpio46),
	BCM6362_GROUP(gpio47),
	BCM6362_GROUP(nand_grp),
};

static const char * const led_groups[] = {
	"gpio0",
	"gpio1",
	"gpio2",
	"gpio3",
	"gpio4",
	"gpio5",
	"gpio6",
	"gpio7",
	"gpio8",
	"gpio9",
	"gpio10",
	"gpio11",
	"gpio12",
	"gpio13",
	"gpio14",
	"gpio15",
	"gpio16",
	"gpio17",
	"gpio18",
	"gpio19",
	"gpio20",
	"gpio21",
	"gpio22",
	"gpio23",
};

static const char * const usb_device_led_groups[] = {
	"gpio0",
};

static const char * const sys_irq_groups[] = {
	"gpio1",
};

static const char * const serial_led_clk_groups[] = {
	"gpio2",
};

static const char * const serial_led_data_groups[] = {
	"gpio3",
};

static const char * const robosw_led_data_groups[] = {
	"gpio4",
};

static const char * const robosw_led_clk_groups[] = {
	"gpio5",
};

static const char * const robosw_led0_groups[] = {
	"gpio6",
};

static const char * const robosw_led1_groups[] = {
	"gpio7",
};

static const char * const inet_led_groups[] = {
	"gpio8",
};

static const char * const spi_cs2_groups[] = {
	"gpio9",
};

static const char * const spi_cs3_groups[] = {
	"gpio10",
};

static const char * const ntr_pulse_groups[] = {
	"gpio11",
};

static const char * const uart1_scts_groups[] = {
	"gpio12",
};

static const char * const uart1_srts_groups[] = {
	"gpio13",
};

static const char * const uart1_sdin_groups[] = {
	"gpio14",
};

static const char * const uart1_sdout_groups[] = {
	"gpio15",
};

static const char * const adsl_spi_miso_groups[] = {
	"gpio16",
};

static const char * const adsl_spi_mosi_groups[] = {
	"gpio17",
};

static const char * const adsl_spi_clk_groups[] = {
	"gpio18",
};

static const char * const adsl_spi_cs_groups[] = {
	"gpio19",
};

static const char * const ephy0_led_groups[] = {
	"gpio20",
};

static const char * const ephy1_led_groups[] = {
	"gpio21",
};

static const char * const ephy2_led_groups[] = {
	"gpio22",
};

static const char * const ephy3_led_groups[] = {
	"gpio23",
};

static const char * const ext_irq0_groups[] = {
	"gpio24",
};

static const char * const ext_irq1_groups[] = {
	"gpio25",
};

static const char * const ext_irq2_groups[] = {
	"gpio26",
};

static const char * const ext_irq3_groups[] = {
	"gpio27",
};

static const char * const wifi_groups[] = {
	"gpio32",
	"gpio33",
	"gpio34",
	"gpio35",
	"gpio36",
	"gpio37",
	"gpio38",
	"gpio39",
	"gpio40",
	"gpio41",
	"gpio42",
	"gpio43",
	"gpio44",
	"gpio45",
	"gpio46",
	"gpio47",
};

static const char * const nand_groups[] = {
	"nand_grp",
};

#define BCM6362_LED_FUN(n)				\
	{						\
		.name = #n,				\
		.groups = n##_groups,			\
		.num_groups = ARRAY_SIZE(n##_groups),	\
		.reg = BCM6362_LEDCTRL,			\
	}

#define BCM6362_MODE_FUN(n)				\
	{						\
		.name = #n,				\
		.groups = n##_groups,			\
		.num_groups = ARRAY_SIZE(n##_groups),	\
		.reg = BCM6362_MODE,			\
	}

#define BCM6362_CTRL_FUN(n)				\
	{						\
		.name = #n,				\
		.groups = n##_groups,			\
		.num_groups = ARRAY_SIZE(n##_groups),	\
		.reg = BCM6362_CTRL,			\
	}

#define BCM6362_BASEMODE_FUN(n, mask)			\
	{						\
		.name = #n,				\
		.groups = n##_groups,			\
		.num_groups = ARRAY_SIZE(n##_groups),	\
		.reg = BCM6362_BASEMODE,		\
		.basemode_mask = (mask),		\
	}

static const struct bcm6362_function bcm6362_funcs[] = {
	BCM6362_LED_FUN(led),
	BCM6362_MODE_FUN(usb_device_led),
	BCM6362_MODE_FUN(sys_irq),
	BCM6362_MODE_FUN(serial_led_clk),
	BCM6362_MODE_FUN(serial_led_data),
	BCM6362_MODE_FUN(robosw_led_data),
	BCM6362_MODE_FUN(robosw_led_clk),
	BCM6362_MODE_FUN(robosw_led0),
	BCM6362_MODE_FUN(robosw_led1),
	BCM6362_MODE_FUN(inet_led),
	BCM6362_MODE_FUN(spi_cs2),
	BCM6362_MODE_FUN(spi_cs3),
	BCM6362_MODE_FUN(ntr_pulse),
	BCM6362_MODE_FUN(uart1_scts),
	BCM6362_MODE_FUN(uart1_srts),
	BCM6362_MODE_FUN(uart1_sdin),
	BCM6362_MODE_FUN(uart1_sdout),
	BCM6362_MODE_FUN(adsl_spi_miso),
	BCM6362_MODE_FUN(adsl_spi_mosi),
	BCM6362_MODE_FUN(adsl_spi_clk),
	BCM6362_MODE_FUN(adsl_spi_cs),
	BCM6362_MODE_FUN(ephy0_led),
	BCM6362_MODE_FUN(ephy1_led),
	BCM6362_MODE_FUN(ephy2_led),
	BCM6362_MODE_FUN(ephy3_led),
	BCM6362_MODE_FUN(ext_irq0),
	BCM6362_MODE_FUN(ext_irq1),
	BCM6362_MODE_FUN(ext_irq2),
	BCM6362_MODE_FUN(ext_irq3),
	BCM6362_CTRL_FUN(wifi),
	BCM6362_BASEMODE_FUN(nand, BASEMODE_NAND),
};

static int bcm6362_pinctrl_get_group_count(struct pinctrl_dev *pctldev)
{
	return ARRAY_SIZE(bcm6362_groups);
}

static const char *bcm6362_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
						  unsigned group)
{
	return bcm6362_groups[group].name;
}

static int bcm6362_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
					  unsigned group, const unsigned **pins,
					  unsigned *num_pins)
{
	*pins = bcm6362_groups[group].pins;
	*num_pins = bcm6362_groups[group].num_pins;

	return 0;
}

static int bcm6362_pinctrl_get_func_count(struct pinctrl_dev *pctldev)
{
	return ARRAY_SIZE(bcm6362_funcs);
}

static const char *bcm6362_pinctrl_get_func_name(struct pinctrl_dev *pctldev,
						 unsigned selector)
{
	return bcm6362_funcs[selector].name;
}

static int bcm6362_pinctrl_get_groups(struct pinctrl_dev *pctldev,
				      unsigned selector,
				      const char * const **groups,
				      unsigned * const num_groups)
{
	*groups = bcm6362_funcs[selector].groups;
	*num_groups = bcm6362_funcs[selector].num_groups;

	return 0;
}

static void bcm6362_set_gpio(struct bcm63xx_pinctrl *pc, unsigned pin)
{
	const struct pinctrl_pin_desc *desc = &bcm6362_pins[pin];
	unsigned int basemode = (uintptr_t)desc->drv_data;
	unsigned int mask = bcm63xx_bank_pin(pin);

	if (basemode)
		regmap_update_bits(pc->regs, BCM6362_BASEMODE_REG, basemode, 0);

	if (pin < BCM63XX_BANK_GPIOS) {
		/* base mode 0 => gpio 1 => mux function */
		regmap_update_bits(pc->regs, BCM6362_MODE_REG, mask, 0);

		/* pins 0-23 might be muxed to led */
		if (pin < BCM6362_NUM_LEDS)
			regmap_update_bits(pc->regs, BCM6362_LED_REG, mask, 0);
	} else {
		/* ctrl reg 0 => wifi function 1 => gpio */
		regmap_update_bits(pc->regs, BCM6362_CTRL_REG, mask, mask);
	}
}

static int bcm6362_pinctrl_set_mux(struct pinctrl_dev *pctldev,
				   unsigned selector, unsigned group)
{
	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
	const struct bcm6362_pingroup *pg = &bcm6362_groups[group];
	const struct bcm6362_function *f = &bcm6362_funcs[selector];
	unsigned i;
	unsigned int reg;
	unsigned int val, mask;

	for (i = 0; i < pg->num_pins; i++)
		bcm6362_set_gpio(pc, pg->pins[i]);

	switch (f->reg) {
	case BCM6362_LEDCTRL:
		reg = BCM6362_LED_REG;
		mask = BIT(pg->pins[0]);
		val = BIT(pg->pins[0]);
		break;
	case BCM6362_MODE:
		reg = BCM6362_MODE_REG;
		mask = BIT(pg->pins[0]);
		val = BIT(pg->pins[0]);
		break;
	case BCM6362_CTRL:
		reg = BCM6362_CTRL_REG;
		mask = BIT(pg->pins[0]);
		val = 0;
		break;
	case BCM6362_BASEMODE:
		reg = BCM6362_BASEMODE_REG;
		mask = f->basemode_mask;
		val = f->basemode_mask;
		break;
	default:
		WARN_ON(1);
		return -EINVAL;
	}

	regmap_update_bits(pc->regs, reg, mask, val);

	return 0;
}

static int bcm6362_gpio_request_enable(struct pinctrl_dev *pctldev,
				       struct pinctrl_gpio_range *range,
				       unsigned offset)
{
	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);

	/* disable all functions using this pin */
	bcm6362_set_gpio(pc, offset);

	return 0;
}

static const struct pinctrl_ops bcm6362_pctl_ops = {
	.dt_free_map = pinctrl_utils_free_map,
	.dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
	.get_group_name = bcm6362_pinctrl_get_group_name,
	.get_group_pins = bcm6362_pinctrl_get_group_pins,
	.get_groups_count = bcm6362_pinctrl_get_group_count,
};

static const struct pinmux_ops bcm6362_pmx_ops = {
	.get_function_groups = bcm6362_pinctrl_get_groups,
	.get_function_name = bcm6362_pinctrl_get_func_name,
	.get_functions_count = bcm6362_pinctrl_get_func_count,
	.gpio_request_enable = bcm6362_gpio_request_enable,
	.set_mux = bcm6362_pinctrl_set_mux,
	.strict = true,
};

static const struct bcm63xx_pinctrl_soc bcm6362_soc = {
	.ngpios = BCM6362_NUM_GPIOS,
	.npins = ARRAY_SIZE(bcm6362_pins),
	.pctl_ops = &bcm6362_pctl_ops,
	.pins = bcm6362_pins,
	.pmx_ops = &bcm6362_pmx_ops,
};

static int bcm6362_pinctrl_probe(struct platform_device *pdev)
{
	return bcm63xx_pinctrl_probe(pdev, &bcm6362_soc, NULL);
}

static const struct of_device_id bcm6362_pinctrl_match[] = {
	{ .compatible = "brcm,bcm6362-pinctrl", },
	{ /* sentinel */ }
};

static struct platform_driver bcm6362_pinctrl_driver = {
	.probe = bcm6362_pinctrl_probe,
	.driver = {
		.name = "bcm6362-pinctrl",
		.of_match_table = bcm6362_pinctrl_match,
	},
};

builtin_platform_driver(bcm6362_pinctrl_driver);
Commit	Line	Data
705791e2 ÁFR	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Driver for BCM6362 GPIO unit (pinctrl + GPIO)
	4	*
	5	* Copyright (C) 2021 Álvaro Fernández Rojas <noltari@gmail.com>
	6	* Copyright (C) 2016 Jonas Gorski <jonas.gorski@gmail.com>
	7	*/
	8
	9	#include <linux/bits.h>
	10	#include <linux/gpio/driver.h>
	11	#include <linux/kernel.h>
	12	#include <linux/of.h>
	13	#include <linux/pinctrl/pinmux.h>
	14	#include <linux/platform_device.h>
	15	#include <linux/regmap.h>
	16
	17	#include "../pinctrl-utils.h"
	18
	19	#include "pinctrl-bcm63xx.h"
	20
	21	#define BCM6362_BANK_GPIOS 32
	22	#define BCM6362_NUM_GPIOS 48
	23	#define BCM6362_NUM_LEDS 24
	24
	25	#define BCM6362_LED_REG 0x10
	26	#define BCM6362_MODE_REG 0x18
	27	#define BCM6362_CTRL_REG 0x1c
	28	#define BCM6362_BASEMODE_REG 0x38
	29	#define BASEMODE_NAND BIT(2)
	30
	31	enum bcm6362_pinctrl_reg {
	32	BCM6362_LEDCTRL,
	33	BCM6362_MODE,
	34	BCM6362_CTRL,
	35	BCM6362_BASEMODE,
	36	};
	37
	38	struct bcm6362_pingroup {
	39	const char *name;
	40	const unsigned * const pins;
	41	const unsigned num_pins;
	42	};
	43
	44	struct bcm6362_function {
	45	const char *name;
	46	const char * const *groups;
	47	const unsigned num_groups;
	48
	49	enum bcm6362_pinctrl_reg reg;
	50	uint32_t basemode_mask;
	51	};
	52
	53	#define BCM6362_PIN(a, b, mask) \
	54	{ \
	55	.number = a, \
	56	.name = b, \
	57	.drv_data = (void *)(mask), \
	58	}
	59
	60	static const struct pinctrl_pin_desc bcm6362_pins[] = {
	61	PINCTRL_PIN(0, "gpio0"),
	62	PINCTRL_PIN(1, "gpio1"),
	63	PINCTRL_PIN(2, "gpio2"),
	64	PINCTRL_PIN(3, "gpio3"),
65	PINCTRL_PIN(4, "gpio4"),
66	PINCTRL_PIN(5, "gpio5"),
67	PINCTRL_PIN(6, "gpio6"),
68	PINCTRL_PIN(7, "gpio7"),
69	BCM6362_PIN(8, "gpio8", BASEMODE_NAND),
70	PINCTRL_PIN(9, "gpio9"),
71	PINCTRL_PIN(10, "gpio10"),
72	PINCTRL_PIN(11, "gpio11"),
73	BCM6362_PIN(12, "gpio12", BASEMODE_NAND),
74	BCM6362_PIN(13, "gpio13", BASEMODE_NAND),
75	BCM6362_PIN(14, "gpio14", BASEMODE_NAND),
76	BCM6362_PIN(15, "gpio15", BASEMODE_NAND),
77	BCM6362_PIN(16, "gpio16", BASEMODE_NAND),
78	BCM6362_PIN(17, "gpio17", BASEMODE_NAND),
79	BCM6362_PIN(18, "gpio18", BASEMODE_NAND),
80	BCM6362_PIN(19, "gpio19", BASEMODE_NAND),
81	BCM6362_PIN(20, "gpio20", BASEMODE_NAND),
82	BCM6362_PIN(21, "gpio21", BASEMODE_NAND),
83	BCM6362_PIN(22, "gpio22", BASEMODE_NAND),
84	BCM6362_PIN(23, "gpio23", BASEMODE_NAND),
85	PINCTRL_PIN(24, "gpio24"),
86	PINCTRL_PIN(25, "gpio25"),
87	PINCTRL_PIN(26, "gpio26"),
88	BCM6362_PIN(27, "gpio27", BASEMODE_NAND),
89	PINCTRL_PIN(28, "gpio28"),
90	PINCTRL_PIN(29, "gpio29"),
91	PINCTRL_PIN(30, "gpio30"),
92	PINCTRL_PIN(31, "gpio31"),
93	PINCTRL_PIN(32, "gpio32"),
94	PINCTRL_PIN(33, "gpio33"),
95	PINCTRL_PIN(34, "gpio34"),
96	PINCTRL_PIN(35, "gpio35"),
97	PINCTRL_PIN(36, "gpio36"),
98	PINCTRL_PIN(37, "gpio37"),
99	PINCTRL_PIN(38, "gpio38"),
100	PINCTRL_PIN(39, "gpio39"),
101	PINCTRL_PIN(40, "gpio40"),
102	PINCTRL_PIN(41, "gpio41"),
103	PINCTRL_PIN(42, "gpio42"),
104	PINCTRL_PIN(43, "gpio43"),
105	PINCTRL_PIN(44, "gpio44"),
106	PINCTRL_PIN(45, "gpio45"),
107	PINCTRL_PIN(46, "gpio46"),
108	PINCTRL_PIN(47, "gpio47"),
109	};
110
111	static unsigned gpio0_pins[] = { 0 };
112	static unsigned gpio1_pins[] = { 1 };
113	static unsigned gpio2_pins[] = { 2 };
114	static unsigned gpio3_pins[] = { 3 };
115	static unsigned gpio4_pins[] = { 4 };
116	static unsigned gpio5_pins[] = { 5 };
117	static unsigned gpio6_pins[] = { 6 };
118	static unsigned gpio7_pins[] = { 7 };
119	static unsigned gpio8_pins[] = { 8 };
120	static unsigned gpio9_pins[] = { 9 };
121	static unsigned gpio10_pins[] = { 10 };
122	static unsigned gpio11_pins[] = { 11 };
123	static unsigned gpio12_pins[] = { 12 };
124	static unsigned gpio13_pins[] = { 13 };
125	static unsigned gpio14_pins[] = { 14 };
126	static unsigned gpio15_pins[] = { 15 };
127	static unsigned gpio16_pins[] = { 16 };
128	static unsigned gpio17_pins[] = { 17 };
129	static unsigned gpio18_pins[] = { 18 };
130	static unsigned gpio19_pins[] = { 19 };
131	static unsigned gpio20_pins[] = { 20 };
132	static unsigned gpio21_pins[] = { 21 };
133	static unsigned gpio22_pins[] = { 22 };
134	static unsigned gpio23_pins[] = { 23 };
135	static unsigned gpio24_pins[] = { 24 };
136	static unsigned gpio25_pins[] = { 25 };
137	static unsigned gpio26_pins[] = { 26 };
138	static unsigned gpio27_pins[] = { 27 };
139	static unsigned gpio28_pins[] = { 28 };
140	static unsigned gpio29_pins[] = { 29 };
141	static unsigned gpio30_pins[] = { 30 };
142	static unsigned gpio31_pins[] = { 31 };
143	static unsigned gpio32_pins[] = { 32 };
144	static unsigned gpio33_pins[] = { 33 };
145	static unsigned gpio34_pins[] = { 34 };
146	static unsigned gpio35_pins[] = { 35 };
147	static unsigned gpio36_pins[] = { 36 };
148	static unsigned gpio37_pins[] = { 37 };
149	static unsigned gpio38_pins[] = { 38 };
150	static unsigned gpio39_pins[] = { 39 };
151	static unsigned gpio40_pins[] = { 40 };
152	static unsigned gpio41_pins[] = { 41 };
153	static unsigned gpio42_pins[] = { 42 };
154	static unsigned gpio43_pins[] = { 43 };
155	static unsigned gpio44_pins[] = { 44 };
156	static unsigned gpio45_pins[] = { 45 };
157	static unsigned gpio46_pins[] = { 46 };
158	static unsigned gpio47_pins[] = { 47 };
159
160	static unsigned nand_grp_pins[] = {
161	8, 12, 13, 14, 15, 16, 17,
162	18, 19, 20, 21, 22, 23, 27,
163	};
164
165	#define BCM6362_GROUP(n) \
166	{ \
167	.name = #n, \
168	.pins = n##_pins, \
169	.num_pins = ARRAY_SIZE(n##_pins), \
170	}
171
172	static struct bcm6362_pingroup bcm6362_groups[] = {
173	BCM6362_GROUP(gpio0),
174	BCM6362_GROUP(gpio1),
175	BCM6362_GROUP(gpio2),
176	BCM6362_GROUP(gpio3),
177	BCM6362_GROUP(gpio4),
178	BCM6362_GROUP(gpio5),
179	BCM6362_GROUP(gpio6),
180	BCM6362_GROUP(gpio7),
181	BCM6362_GROUP(gpio8),
182	BCM6362_GROUP(gpio9),
183	BCM6362_GROUP(gpio10),
184	BCM6362_GROUP(gpio11),
185	BCM6362_GROUP(gpio12),
186	BCM6362_GROUP(gpio13),
187	BCM6362_GROUP(gpio14),
188	BCM6362_GROUP(gpio15),
189	BCM6362_GROUP(gpio16),
190	BCM6362_GROUP(gpio17),
191	BCM6362_GROUP(gpio18),
192	BCM6362_GROUP(gpio19),
193	BCM6362_GROUP(gpio20),
194	BCM6362_GROUP(gpio21),
195	BCM6362_GROUP(gpio22),
196	BCM6362_GROUP(gpio23),
197	BCM6362_GROUP(gpio24),
198	BCM6362_GROUP(gpio25),
199	BCM6362_GROUP(gpio26),
200	BCM6362_GROUP(gpio27),
201	BCM6362_GROUP(gpio28),
202	BCM6362_GROUP(gpio29),
203	BCM6362_GROUP(gpio30),
204	BCM6362_GROUP(gpio31),
205	BCM6362_GROUP(gpio32),
206	BCM6362_GROUP(gpio33),
207	BCM6362_GROUP(gpio34),
208	BCM6362_GROUP(gpio35),
209	BCM6362_GROUP(gpio36),
210	BCM6362_GROUP(gpio37),
211	BCM6362_GROUP(gpio38),
212	BCM6362_GROUP(gpio39),
213	BCM6362_GROUP(gpio40),
214	BCM6362_GROUP(gpio41),
215	BCM6362_GROUP(gpio42),
216	BCM6362_GROUP(gpio43),
217	BCM6362_GROUP(gpio44),
218	BCM6362_GROUP(gpio45),
219	BCM6362_GROUP(gpio46),
220	BCM6362_GROUP(gpio47),
221	BCM6362_GROUP(nand_grp),
222	};
223
224	static const char * const led_groups[] = {
225	"gpio0",
226	"gpio1",
227	"gpio2",
228	"gpio3",
229	"gpio4",
230	"gpio5",
231	"gpio6",
232	"gpio7",
233	"gpio8",
234	"gpio9",
235	"gpio10",
236	"gpio11",
237	"gpio12",
238	"gpio13",
239	"gpio14",
240	"gpio15",
241	"gpio16",
242	"gpio17",
243	"gpio18",
244	"gpio19",
245	"gpio20",
246	"gpio21",
247	"gpio22",
248	"gpio23",
249	};
250
251	static const char * const usb_device_led_groups[] = {
252	"gpio0",
253	};
254
255	static const char * const sys_irq_groups[] = {
256	"gpio1",
257	};
258
259	static const char * const serial_led_clk_groups[] = {
260	"gpio2",
261	};
262
263	static const char * const serial_led_data_groups[] = {
264	"gpio3",
265	};
266
267	static const char * const robosw_led_data_groups[] = {
268	"gpio4",
269	};
270
271	static const char * const robosw_led_clk_groups[] = {
272	"gpio5",
273	};
274
275	static const char * const robosw_led0_groups[] = {
276	"gpio6",
277	};
278
279	static const char * const robosw_led1_groups[] = {
280	"gpio7",
281	};
282
283	static const char * const inet_led_groups[] = {
284	"gpio8",
285	};
286
287	static const char * const spi_cs2_groups[] = {
288	"gpio9",
289	};
290
291	static const char * const spi_cs3_groups[] = {
292	"gpio10",
293	};
294
295	static const char * const ntr_pulse_groups[] = {
296	"gpio11",
297	};
298
299	static const char * const uart1_scts_groups[] = {
300	"gpio12",
301	};
302
303	static const char * const uart1_srts_groups[] = {
304	"gpio13",
305	};
306
307	static const char * const uart1_sdin_groups[] = {
308	"gpio14",
309	};
310
311	static const char * const uart1_sdout_groups[] = {
312	"gpio15",
313	};
314
315	static const char * const adsl_spi_miso_groups[] = {
316	"gpio16",
317	};
318
319	static const char * const adsl_spi_mosi_groups[] = {
320	"gpio17",
321	};
322
323	static const char * const adsl_spi_clk_groups[] = {
324	"gpio18",
325	};
326
327	static const char * const adsl_spi_cs_groups[] = {
328	"gpio19",
329	};
330
331	static const char * const ephy0_led_groups[] = {
332	"gpio20",
333	};
334
335	static const char * const ephy1_led_groups[] = {
336	"gpio21",
337	};
338
339	static const char * const ephy2_led_groups[] = {
340	"gpio22",
341	};
342
343	static const char * const ephy3_led_groups[] = {
344	"gpio23",
345	};
346
347	static const char * const ext_irq0_groups[] = {
348	"gpio24",
349	};
350
351	static const char * const ext_irq1_groups[] = {
352	"gpio25",
353	};
354
355	static const char * const ext_irq2_groups[] = {
356	"gpio26",
357	};
358
359	static const char * const ext_irq3_groups[] = {
360	"gpio27",
361	};
362
363	static const char * const wifi_groups[] = {
364	"gpio32",
365	"gpio33",
366	"gpio34",
367	"gpio35",
368	"gpio36",
369	"gpio37",
370	"gpio38",
371	"gpio39",
372	"gpio40",
373	"gpio41",
374	"gpio42",
375	"gpio43",
376	"gpio44",
377	"gpio45",
378	"gpio46",
379	"gpio47",
380	};
381
382	static const char * const nand_groups[] = {
383	"nand_grp",
384	};
385
386	#define BCM6362_LED_FUN(n) \
387	{ \
388	.name = #n, \
389	.groups = n##_groups, \
390	.num_groups = ARRAY_SIZE(n##_groups), \
391	.reg = BCM6362_LEDCTRL, \
392	}
393
394	#define BCM6362_MODE_FUN(n) \
395	{ \
396	.name = #n, \
397	.groups = n##_groups, \
398	.num_groups = ARRAY_SIZE(n##_groups), \
399	.reg = BCM6362_MODE, \
400	}
401
402	#define BCM6362_CTRL_FUN(n) \
403	{ \
404	.name = #n, \
405	.groups = n##_groups, \
406	.num_groups = ARRAY_SIZE(n##_groups), \
407	.reg = BCM6362_CTRL, \
408	}
409
410	#define BCM6362_BASEMODE_FUN(n, mask) \
411	{ \
412	.name = #n, \
413	.groups = n##_groups, \
414	.num_groups = ARRAY_SIZE(n##_groups), \
415	.reg = BCM6362_BASEMODE, \
416	.basemode_mask = (mask), \
417	}
418
419	static const struct bcm6362_function bcm6362_funcs[] = {
420	BCM6362_LED_FUN(led),
421	BCM6362_MODE_FUN(usb_device_led),
422	BCM6362_MODE_FUN(sys_irq),
423	BCM6362_MODE_FUN(serial_led_clk),
424	BCM6362_MODE_FUN(serial_led_data),
425	BCM6362_MODE_FUN(robosw_led_data),
426	BCM6362_MODE_FUN(robosw_led_clk),
427	BCM6362_MODE_FUN(robosw_led0),
428	BCM6362_MODE_FUN(robosw_led1),
429	BCM6362_MODE_FUN(inet_led),
430	BCM6362_MODE_FUN(spi_cs2),
431	BCM6362_MODE_FUN(spi_cs3),
432	BCM6362_MODE_FUN(ntr_pulse),
433	BCM6362_MODE_FUN(uart1_scts),
434	BCM6362_MODE_FUN(uart1_srts),
435	BCM6362_MODE_FUN(uart1_sdin),
436	BCM6362_MODE_FUN(uart1_sdout),
437	BCM6362_MODE_FUN(adsl_spi_miso),
438	BCM6362_MODE_FUN(adsl_spi_mosi),
439	BCM6362_MODE_FUN(adsl_spi_clk),
440	BCM6362_MODE_FUN(adsl_spi_cs),
441	BCM6362_MODE_FUN(ephy0_led),
442	BCM6362_MODE_FUN(ephy1_led),
443	BCM6362_MODE_FUN(ephy2_led),
444	BCM6362_MODE_FUN(ephy3_led),
445	BCM6362_MODE_FUN(ext_irq0),
446	BCM6362_MODE_FUN(ext_irq1),
447	BCM6362_MODE_FUN(ext_irq2),
448	BCM6362_MODE_FUN(ext_irq3),
449	BCM6362_CTRL_FUN(wifi),
450	BCM6362_BASEMODE_FUN(nand, BASEMODE_NAND),
451	};
452
453	static int bcm6362_pinctrl_get_group_count(struct pinctrl_dev *pctldev)
454	{
455	return ARRAY_SIZE(bcm6362_groups);
456	}
457
458	static const char bcm6362_pinctrl_get_group_name(struct pinctrl_dev pctldev,
459	unsigned group)
460	{
461	return bcm6362_groups[group].name;
462	}
463
464	static int bcm6362_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
465	unsigned group, const unsigned **pins,
466	unsigned *num_pins)
467	{
468	*pins = bcm6362_groups[group].pins;
469	*num_pins = bcm6362_groups[group].num_pins;
470
471	return 0;
472	}
473
474	static int bcm6362_pinctrl_get_func_count(struct pinctrl_dev *pctldev)
475	{
476	return ARRAY_SIZE(bcm6362_funcs);
477	}
478
479	static const char bcm6362_pinctrl_get_func_name(struct pinctrl_dev pctldev,
480	unsigned selector)
481	{
482	return bcm6362_funcs[selector].name;
483	}
484
485	static int bcm6362_pinctrl_get_groups(struct pinctrl_dev *pctldev,
486	unsigned selector,
487	const char * const **groups,
488	unsigned * const num_groups)
489	{
490	*groups = bcm6362_funcs[selector].groups;
491	*num_groups = bcm6362_funcs[selector].num_groups;
492
493	return 0;
494	}
495
496	static void bcm6362_set_gpio(struct bcm63xx_pinctrl *pc, unsigned pin)
497	{
498	const struct pinctrl_pin_desc *desc = &bcm6362_pins[pin];
1978d88c	499	unsigned int basemode = (uintptr_t)desc->drv_data;
705791e2 ÁFR	500	unsigned int mask = bcm63xx_bank_pin(pin);
705791e2 ÁFR	501
1978d88c ÁFR	502	if (basemode)
1978d88c ÁFR	503	regmap_update_bits(pc->regs, BCM6362_BASEMODE_REG, basemode, 0);
705791e2 ÁFR	504
	505	if (pin < BCM63XX_BANK_GPIOS) {
	506	/* base mode 0 => gpio 1 => mux function */
	507	regmap_update_bits(pc->regs, BCM6362_MODE_REG, mask, 0);
	508
	509	/* pins 0-23 might be muxed to led */
	510	if (pin < BCM6362_NUM_LEDS)
	511	regmap_update_bits(pc->regs, BCM6362_LED_REG, mask, 0);
	512	} else {
	513	/* ctrl reg 0 => wifi function 1 => gpio */
	514	regmap_update_bits(pc->regs, BCM6362_CTRL_REG, mask, mask);
	515	}
	516	}
	517
	518	static int bcm6362_pinctrl_set_mux(struct pinctrl_dev *pctldev,
	519	unsigned selector, unsigned group)
	520	{
	521	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
	522	const struct bcm6362_pingroup *pg = &bcm6362_groups[group];
	523	const struct bcm6362_function *f = &bcm6362_funcs[selector];
	524	unsigned i;
	525	unsigned int reg;
	526	unsigned int val, mask;
	527
	528	for (i = 0; i < pg->num_pins; i++)
	529	bcm6362_set_gpio(pc, pg->pins[i]);
	530
	531	switch (f->reg) {
	532	case BCM6362_LEDCTRL:
	533	reg = BCM6362_LED_REG;
	534	mask = BIT(pg->pins[0]);
	535	val = BIT(pg->pins[0]);
	536	break;
	537	case BCM6362_MODE:
	538	reg = BCM6362_MODE_REG;
	539	mask = BIT(pg->pins[0]);
	540	val = BIT(pg->pins[0]);
	541	break;
	542	case BCM6362_CTRL:
	543	reg = BCM6362_CTRL_REG;
	544	mask = BIT(pg->pins[0]);
	545	val = 0;
	546	break;
	547	case BCM6362_BASEMODE:
	548	reg = BCM6362_BASEMODE_REG;
	549	mask = f->basemode_mask;
	550	val = f->basemode_mask;
	551	break;
	552	default:
	553	WARN_ON(1);
	554	return -EINVAL;
	555	}
	556
	557	regmap_update_bits(pc->regs, reg, mask, val);
	558
	559	return 0;
	560	}
	561
	562	static int bcm6362_gpio_request_enable(struct pinctrl_dev *pctldev,
	563	struct pinctrl_gpio_range *range,
	564	unsigned offset)
	565	{
	566	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
	567
568	/* disable all functions using this pin */
569	bcm6362_set_gpio(pc, offset);
570
571	return 0;
572	}
573
d9779093	574	static const struct pinctrl_ops bcm6362_pctl_ops = {
705791e2 ÁFR	575	.dt_free_map = pinctrl_utils_free_map,
	576	.dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
	577	.get_group_name = bcm6362_pinctrl_get_group_name,
	578	.get_group_pins = bcm6362_pinctrl_get_group_pins,
	579	.get_groups_count = bcm6362_pinctrl_get_group_count,
	580	};
	581
0c683876	582	static const struct pinmux_ops bcm6362_pmx_ops = {
705791e2 ÁFR	583	.get_function_groups = bcm6362_pinctrl_get_groups,
	584	.get_function_name = bcm6362_pinctrl_get_func_name,
	585	.get_functions_count = bcm6362_pinctrl_get_func_count,
	586	.gpio_request_enable = bcm6362_gpio_request_enable,
	587	.set_mux = bcm6362_pinctrl_set_mux,
	588	.strict = true,
	589	};
	590
	591	static const struct bcm63xx_pinctrl_soc bcm6362_soc = {
	592	.ngpios = BCM6362_NUM_GPIOS,
	593	.npins = ARRAY_SIZE(bcm6362_pins),
	594	.pctl_ops = &bcm6362_pctl_ops,
	595	.pins = bcm6362_pins,
	596	.pmx_ops = &bcm6362_pmx_ops,
	597	};
	598
	599	static int bcm6362_pinctrl_probe(struct platform_device *pdev)
	600	{
	601	return bcm63xx_pinctrl_probe(pdev, &bcm6362_soc, NULL);
	602	}
	603
	604	static const struct of_device_id bcm6362_pinctrl_match[] = {
	605	{ .compatible = "brcm,bcm6362-pinctrl", },
	606	{ /* sentinel */ }
	607	};
	608
	609	static struct platform_driver bcm6362_pinctrl_driver = {
	610	.probe = bcm6362_pinctrl_probe,
	611	.driver = {
	612	.name = "bcm6362-pinctrl",
	613	.of_match_table = bcm6362_pinctrl_match,
	614	},
	615	};
	616
	617	builtin_platform_driver(bcm6362_pinctrl_driver);