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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Driver for BCM6318 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 BCM6318_NUM_GPIOS	50
#define BCM6318_NUM_MUX		48

#define BCM6318_MODE_REG	0x18
#define BCM6318_MUX_REG		0x1c
#define  BCM6328_MUX_MASK	GENMASK(1, 0)
#define BCM6318_PAD_REG		0x54
#define  BCM6328_PAD_MASK	GENMASK(3, 0)

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

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

	unsigned mode_val:1;
	unsigned mux_val:2;
};

static const struct pinctrl_pin_desc bcm6318_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"),
	PINCTRL_PIN(8, "gpio8"),
	PINCTRL_PIN(9, "gpio9"),
	PINCTRL_PIN(10, "gpio10"),
	PINCTRL_PIN(11, "gpio11"),
	PINCTRL_PIN(12, "gpio12"),
	PINCTRL_PIN(13, "gpio13"),
	PINCTRL_PIN(14, "gpio14"),
	PINCTRL_PIN(15, "gpio15"),
	PINCTRL_PIN(16, "gpio16"),
	PINCTRL_PIN(17, "gpio17"),
	PINCTRL_PIN(18, "gpio18"),
	PINCTRL_PIN(19, "gpio19"),
	PINCTRL_PIN(20, "gpio20"),
	PINCTRL_PIN(21, "gpio21"),
	PINCTRL_PIN(22, "gpio22"),
	PINCTRL_PIN(23, "gpio23"),
	PINCTRL_PIN(24, "gpio24"),
	PINCTRL_PIN(25, "gpio25"),
	PINCTRL_PIN(26, "gpio26"),
	PINCTRL_PIN(27, "gpio27"),
	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"),
	PINCTRL_PIN(48, "gpio48"),
	PINCTRL_PIN(49, "gpio49"),
};

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 gpio48_pins[] = { 48 };
static unsigned gpio49_pins[] = { 49 };

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

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

/* GPIO_MODE */
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",
};

/* PINMUX_SEL */
static const char * const ephy0_spd_led_groups[] = {
	"gpio0",
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static const char * const usb_active_groups[] = {
	"gpio40",
};

#define BCM6318_MODE_FUN(n)				\
	{						\
		.name = #n,				\
		.groups = n##_groups,			\
		.num_groups = ARRAY_SIZE(n##_groups),	\
		.mode_val = 1,				\
	}

#define BCM6318_MUX_FUN(n, mux)				\
	{						\
		.name = #n,				\
		.groups = n##_groups,			\
		.num_groups = ARRAY_SIZE(n##_groups),	\
		.mux_val = mux,				\
	}

static const struct bcm6318_function bcm6318_funcs[] = {
	BCM6318_MODE_FUN(led),
	BCM6318_MUX_FUN(ephy0_spd_led, 1),
	BCM6318_MUX_FUN(ephy1_spd_led, 1),
	BCM6318_MUX_FUN(ephy2_spd_led, 1),
	BCM6318_MUX_FUN(ephy3_spd_led, 1),
	BCM6318_MUX_FUN(ephy0_act_led, 1),
	BCM6318_MUX_FUN(ephy1_act_led, 1),
	BCM6318_MUX_FUN(ephy2_act_led, 1),
	BCM6318_MUX_FUN(ephy3_act_led, 1),
	BCM6318_MUX_FUN(serial_led_data, 3),
	BCM6318_MUX_FUN(serial_led_clk, 3),
	BCM6318_MUX_FUN(inet_act_led, 1),
	BCM6318_MUX_FUN(inet_fail_led, 1),
	BCM6318_MUX_FUN(dsl_led, 1),
	BCM6318_MUX_FUN(post_fail_led, 1),
	BCM6318_MUX_FUN(wlan_wps_led, 1),
	BCM6318_MUX_FUN(usb_pwron, 1),
	BCM6318_MUX_FUN(usb_device_led, 2),
	BCM6318_MUX_FUN(usb_active, 2),
};

static inline unsigned int bcm6318_mux_off(unsigned int pin)
{
	return BCM6318_MUX_REG + (pin / 16) * 4;
}

static inline unsigned int bcm6318_pad_off(unsigned int pin)
{
	return BCM6318_PAD_REG + (pin / 8) * 4;
}

static int bcm6318_pinctrl_get_group_count(struct pinctrl_dev *pctldev)
{
	return ARRAY_SIZE(bcm6318_groups);
}

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

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

	return 0;
}

static int bcm6318_pinctrl_get_func_count(struct pinctrl_dev *pctldev)
{
	return ARRAY_SIZE(bcm6318_funcs);
}

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

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

	return 0;
}

static inline void bcm6318_rmw_mux(struct bcm63xx_pinctrl *pc, unsigned pin,
				   unsigned int mode, unsigned int mux)
{
	if (pin < BCM63XX_BANK_GPIOS)
		regmap_update_bits(pc->regs, BCM6318_MODE_REG, BIT(pin),
				   mode ? BIT(pin) : 0);

	if (pin < BCM6318_NUM_MUX)
		regmap_update_bits(pc->regs,
				   bcm6318_mux_off(pin),
				   BCM6328_MUX_MASK << ((pin % 16) * 2),
				   mux << ((pin % 16) * 2));
}

static inline void bcm6318_set_pad(struct bcm63xx_pinctrl *pc, unsigned pin,
				   uint8_t val)
{
	regmap_update_bits(pc->regs, bcm6318_pad_off(pin),
			   BCM6328_PAD_MASK << ((pin % 8) * 4),
			   val << ((pin % 8) * 4));
}

static int bcm6318_pinctrl_set_mux(struct pinctrl_dev *pctldev,
				   unsigned selector, unsigned group)
{
	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
	const struct bcm6318_pingroup *pg = &bcm6318_groups[group];
	const struct bcm6318_function *f = &bcm6318_funcs[selector];

	bcm6318_rmw_mux(pc, pg->pins[0], f->mode_val, f->mux_val);

	return 0;
}

static int bcm6318_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 */
	if (offset < 13) {
		/* GPIOs 0-12 use mux 0 as GPIO function */
		bcm6318_rmw_mux(pc, offset, 0, 0);
	} else if (offset < 42) {
		/* GPIOs 13-41 use mux 3 as GPIO function */
		bcm6318_rmw_mux(pc, offset, 0, 3);

		bcm6318_set_pad(pc, offset, 0);
	}

	return 0;
}

static const struct pinctrl_ops bcm6318_pctl_ops = {
	.dt_free_map = pinctrl_utils_free_map,
	.dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
	.get_group_name = bcm6318_pinctrl_get_group_name,
	.get_group_pins = bcm6318_pinctrl_get_group_pins,
	.get_groups_count = bcm6318_pinctrl_get_group_count,
};

static const struct pinmux_ops bcm6318_pmx_ops = {
	.get_function_groups = bcm6318_pinctrl_get_groups,
	.get_function_name = bcm6318_pinctrl_get_func_name,
	.get_functions_count = bcm6318_pinctrl_get_func_count,
	.gpio_request_enable = bcm6318_gpio_request_enable,
	.set_mux = bcm6318_pinctrl_set_mux,
	.strict = true,
};

static const struct bcm63xx_pinctrl_soc bcm6318_soc = {
	.ngpios = BCM6318_NUM_GPIOS,
	.npins = ARRAY_SIZE(bcm6318_pins),
	.pctl_ops = &bcm6318_pctl_ops,
	.pins = bcm6318_pins,
	.pmx_ops = &bcm6318_pmx_ops,
};

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

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

static struct platform_driver bcm6318_pinctrl_driver = {
	.probe = bcm6318_pinctrl_probe,
	.driver = {
		.name = "bcm6318-pinctrl",
		.of_match_table = bcm6318_pinctrl_match,
	},
};

builtin_platform_driver(bcm6318_pinctrl_driver);
Commit	Line	Data
d28039fc ÁFR	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Driver for BCM6318 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 BCM6318_NUM_GPIOS 50
	22	#define BCM6318_NUM_MUX 48
	23
	24	#define BCM6318_MODE_REG 0x18
	25	#define BCM6318_MUX_REG 0x1c
	26	#define BCM6328_MUX_MASK GENMASK(1, 0)
	27	#define BCM6318_PAD_REG 0x54
	28	#define BCM6328_PAD_MASK GENMASK(3, 0)
	29
	30	struct bcm6318_pingroup {
	31	const char *name;
	32	const unsigned * const pins;
	33	const unsigned num_pins;
	34	};
	35
	36	struct bcm6318_function {
	37	const char *name;
	38	const char * const *groups;
	39	const unsigned num_groups;
	40
	41	unsigned mode_val:1;
	42	unsigned mux_val:2;
	43	};
	44
	45	static const struct pinctrl_pin_desc bcm6318_pins[] = {
	46	PINCTRL_PIN(0, "gpio0"),
	47	PINCTRL_PIN(1, "gpio1"),
	48	PINCTRL_PIN(2, "gpio2"),
	49	PINCTRL_PIN(3, "gpio3"),
	50	PINCTRL_PIN(4, "gpio4"),
	51	PINCTRL_PIN(5, "gpio5"),
	52	PINCTRL_PIN(6, "gpio6"),
	53	PINCTRL_PIN(7, "gpio7"),
	54	PINCTRL_PIN(8, "gpio8"),
	55	PINCTRL_PIN(9, "gpio9"),
	56	PINCTRL_PIN(10, "gpio10"),
	57	PINCTRL_PIN(11, "gpio11"),
	58	PINCTRL_PIN(12, "gpio12"),
	59	PINCTRL_PIN(13, "gpio13"),
	60	PINCTRL_PIN(14, "gpio14"),
	61	PINCTRL_PIN(15, "gpio15"),
	62	PINCTRL_PIN(16, "gpio16"),
	63	PINCTRL_PIN(17, "gpio17"),
	64	PINCTRL_PIN(18, "gpio18"),
65	PINCTRL_PIN(19, "gpio19"),
66	PINCTRL_PIN(20, "gpio20"),
67	PINCTRL_PIN(21, "gpio21"),
68	PINCTRL_PIN(22, "gpio22"),
69	PINCTRL_PIN(23, "gpio23"),
70	PINCTRL_PIN(24, "gpio24"),
71	PINCTRL_PIN(25, "gpio25"),
72	PINCTRL_PIN(26, "gpio26"),
73	PINCTRL_PIN(27, "gpio27"),
74	PINCTRL_PIN(28, "gpio28"),
75	PINCTRL_PIN(29, "gpio29"),
76	PINCTRL_PIN(30, "gpio30"),
77	PINCTRL_PIN(31, "gpio31"),
78	PINCTRL_PIN(32, "gpio32"),
79	PINCTRL_PIN(33, "gpio33"),
80	PINCTRL_PIN(34, "gpio34"),
81	PINCTRL_PIN(35, "gpio35"),
82	PINCTRL_PIN(36, "gpio36"),
83	PINCTRL_PIN(37, "gpio37"),
84	PINCTRL_PIN(38, "gpio38"),
85	PINCTRL_PIN(39, "gpio39"),
86	PINCTRL_PIN(40, "gpio40"),
87	PINCTRL_PIN(41, "gpio41"),
88	PINCTRL_PIN(42, "gpio42"),
89	PINCTRL_PIN(43, "gpio43"),
90	PINCTRL_PIN(44, "gpio44"),
91	PINCTRL_PIN(45, "gpio45"),
92	PINCTRL_PIN(46, "gpio46"),
93	PINCTRL_PIN(47, "gpio47"),
94	PINCTRL_PIN(48, "gpio48"),
95	PINCTRL_PIN(49, "gpio49"),
96	};
97
98	static unsigned gpio0_pins[] = { 0 };
99	static unsigned gpio1_pins[] = { 1 };
100	static unsigned gpio2_pins[] = { 2 };
101	static unsigned gpio3_pins[] = { 3 };
102	static unsigned gpio4_pins[] = { 4 };
103	static unsigned gpio5_pins[] = { 5 };
104	static unsigned gpio6_pins[] = { 6 };
105	static unsigned gpio7_pins[] = { 7 };
106	static unsigned gpio8_pins[] = { 8 };
107	static unsigned gpio9_pins[] = { 9 };
108	static unsigned gpio10_pins[] = { 10 };
109	static unsigned gpio11_pins[] = { 11 };
110	static unsigned gpio12_pins[] = { 12 };
111	static unsigned gpio13_pins[] = { 13 };
112	static unsigned gpio14_pins[] = { 14 };
113	static unsigned gpio15_pins[] = { 15 };
114	static unsigned gpio16_pins[] = { 16 };
115	static unsigned gpio17_pins[] = { 17 };
116	static unsigned gpio18_pins[] = { 18 };
117	static unsigned gpio19_pins[] = { 19 };
118	static unsigned gpio20_pins[] = { 20 };
119	static unsigned gpio21_pins[] = { 21 };
120	static unsigned gpio22_pins[] = { 22 };
121	static unsigned gpio23_pins[] = { 23 };
122	static unsigned gpio24_pins[] = { 24 };
123	static unsigned gpio25_pins[] = { 25 };
124	static unsigned gpio26_pins[] = { 26 };
125	static unsigned gpio27_pins[] = { 27 };
126	static unsigned gpio28_pins[] = { 28 };
127	static unsigned gpio29_pins[] = { 29 };
128	static unsigned gpio30_pins[] = { 30 };
129	static unsigned gpio31_pins[] = { 31 };
130	static unsigned gpio32_pins[] = { 32 };
131	static unsigned gpio33_pins[] = { 33 };
132	static unsigned gpio34_pins[] = { 34 };
133	static unsigned gpio35_pins[] = { 35 };
134	static unsigned gpio36_pins[] = { 36 };
135	static unsigned gpio37_pins[] = { 37 };
136	static unsigned gpio38_pins[] = { 38 };
137	static unsigned gpio39_pins[] = { 39 };
138	static unsigned gpio40_pins[] = { 40 };
139	static unsigned gpio41_pins[] = { 41 };
140	static unsigned gpio42_pins[] = { 42 };
141	static unsigned gpio43_pins[] = { 43 };
142	static unsigned gpio44_pins[] = { 44 };
143	static unsigned gpio45_pins[] = { 45 };
144	static unsigned gpio46_pins[] = { 46 };
145	static unsigned gpio47_pins[] = { 47 };
146	static unsigned gpio48_pins[] = { 48 };
147	static unsigned gpio49_pins[] = { 49 };
148
149	#define BCM6318_GROUP(n) \
150	{ \
151	.name = #n, \
152	.pins = n##_pins, \
153	.num_pins = ARRAY_SIZE(n##_pins), \
154	}
155
156	static struct bcm6318_pingroup bcm6318_groups[] = {
157	BCM6318_GROUP(gpio0),
158	BCM6318_GROUP(gpio1),
159	BCM6318_GROUP(gpio2),
160	BCM6318_GROUP(gpio3),
161	BCM6318_GROUP(gpio4),
162	BCM6318_GROUP(gpio5),
163	BCM6318_GROUP(gpio6),
164	BCM6318_GROUP(gpio7),
165	BCM6318_GROUP(gpio8),
166	BCM6318_GROUP(gpio9),
167	BCM6318_GROUP(gpio10),
168	BCM6318_GROUP(gpio11),
169	BCM6318_GROUP(gpio12),
170	BCM6318_GROUP(gpio13),
171	BCM6318_GROUP(gpio14),
172	BCM6318_GROUP(gpio15),
173	BCM6318_GROUP(gpio16),
174	BCM6318_GROUP(gpio17),
175	BCM6318_GROUP(gpio18),
176	BCM6318_GROUP(gpio19),
177	BCM6318_GROUP(gpio20),
178	BCM6318_GROUP(gpio21),
179	BCM6318_GROUP(gpio22),
180	BCM6318_GROUP(gpio23),
181	BCM6318_GROUP(gpio24),
182	BCM6318_GROUP(gpio25),
183	BCM6318_GROUP(gpio26),
184	BCM6318_GROUP(gpio27),
185	BCM6318_GROUP(gpio28),
186	BCM6318_GROUP(gpio29),
187	BCM6318_GROUP(gpio30),
188	BCM6318_GROUP(gpio31),
189	BCM6318_GROUP(gpio32),
190	BCM6318_GROUP(gpio33),
191	BCM6318_GROUP(gpio34),
192	BCM6318_GROUP(gpio35),
193	BCM6318_GROUP(gpio36),
194	BCM6318_GROUP(gpio37),
195	BCM6318_GROUP(gpio38),
196	BCM6318_GROUP(gpio39),
197	BCM6318_GROUP(gpio40),
198	BCM6318_GROUP(gpio41),
199	BCM6318_GROUP(gpio42),
200	BCM6318_GROUP(gpio43),
201	BCM6318_GROUP(gpio44),
202	BCM6318_GROUP(gpio45),
203	BCM6318_GROUP(gpio46),
204	BCM6318_GROUP(gpio47),
205	BCM6318_GROUP(gpio48),
206	BCM6318_GROUP(gpio49),
207	};
208
209	/* GPIO_MODE */
210	static const char * const led_groups[] = {
211	"gpio0",
212	"gpio1",
213	"gpio2",
214	"gpio3",
215	"gpio4",
216	"gpio5",
217	"gpio6",
218	"gpio7",
219	"gpio8",
220	"gpio9",
221	"gpio10",
222	"gpio11",
223	"gpio12",
224	"gpio13",
225	"gpio14",
226	"gpio15",
227	"gpio16",
228	"gpio17",
229	"gpio18",
230	"gpio19",
231	"gpio20",
232	"gpio21",
233	"gpio22",
234	"gpio23",
235	};
236
237	/* PINMUX_SEL */
238	static const char * const ephy0_spd_led_groups[] = {
239	"gpio0",
240	};
241
242	static const char * const ephy1_spd_led_groups[] = {
243	"gpio1",
244	};
245
246	static const char * const ephy2_spd_led_groups[] = {
247	"gpio2",
248	};
249
250	static const char * const ephy3_spd_led_groups[] = {
251	"gpio3",
252	};
253
254	static const char * const ephy0_act_led_groups[] = {
255	"gpio4",
256	};
257
258	static const char * const ephy1_act_led_groups[] = {
259	"gpio5",
260	};
261
262	static const char * const ephy2_act_led_groups[] = {
263	"gpio6",
264	};
265
266	static const char * const ephy3_act_led_groups[] = {
267	"gpio7",
268	};
269
270	static const char * const serial_led_data_groups[] = {
271	"gpio6",
272	};
273
274	static const char * const serial_led_clk_groups[] = {
275	"gpio7",
276	};
277
278	static const char * const inet_act_led_groups[] = {
279	"gpio8",
280	};
281
282	static const char * const inet_fail_led_groups[] = {
283	"gpio9",
284	};
285
286	static const char * const dsl_led_groups[] = {
287	"gpio10",
288	};
289
290	static const char * const post_fail_led_groups[] = {
291	"gpio11",
292	};
293
294	static const char * const wlan_wps_led_groups[] = {
295	"gpio12",
296	};
297
298	static const char * const usb_pwron_groups[] = {
299	"gpio13",
300	};
301
302	static const char * const usb_device_led_groups[] = {
303	"gpio13",
304	};
305
306	static const char * const usb_active_groups[] = {
307	"gpio40",
308	};
309
310	#define BCM6318_MODE_FUN(n) \
311	{ \
312	.name = #n, \
313	.groups = n##_groups, \
314	.num_groups = ARRAY_SIZE(n##_groups), \
315	.mode_val = 1, \
316	}
317
318	#define BCM6318_MUX_FUN(n, mux) \
319	{ \
320	.name = #n, \
321	.groups = n##_groups, \
322	.num_groups = ARRAY_SIZE(n##_groups), \
323	.mux_val = mux, \
324	}
325
326	static const struct bcm6318_function bcm6318_funcs[] = {
327	BCM6318_MODE_FUN(led),
328	BCM6318_MUX_FUN(ephy0_spd_led, 1),
329	BCM6318_MUX_FUN(ephy1_spd_led, 1),
330	BCM6318_MUX_FUN(ephy2_spd_led, 1),
331	BCM6318_MUX_FUN(ephy3_spd_led, 1),
332	BCM6318_MUX_FUN(ephy0_act_led, 1),
333	BCM6318_MUX_FUN(ephy1_act_led, 1),
334	BCM6318_MUX_FUN(ephy2_act_led, 1),
335	BCM6318_MUX_FUN(ephy3_act_led, 1),
336	BCM6318_MUX_FUN(serial_led_data, 3),
337	BCM6318_MUX_FUN(serial_led_clk, 3),
338	BCM6318_MUX_FUN(inet_act_led, 1),
339	BCM6318_MUX_FUN(inet_fail_led, 1),
340	BCM6318_MUX_FUN(dsl_led, 1),
341	BCM6318_MUX_FUN(post_fail_led, 1),
342	BCM6318_MUX_FUN(wlan_wps_led, 1),
343	BCM6318_MUX_FUN(usb_pwron, 1),
344	BCM6318_MUX_FUN(usb_device_led, 2),
345	BCM6318_MUX_FUN(usb_active, 2),
346	};
347
348	static inline unsigned int bcm6318_mux_off(unsigned int pin)
349	{
350	return BCM6318_MUX_REG + (pin / 16) * 4;
351	}
352
353	static inline unsigned int bcm6318_pad_off(unsigned int pin)
354	{
355	return BCM6318_PAD_REG + (pin / 8) * 4;
356	}
357
358	static int bcm6318_pinctrl_get_group_count(struct pinctrl_dev *pctldev)
359	{
360	return ARRAY_SIZE(bcm6318_groups);
361	}
362
363	static const char bcm6318_pinctrl_get_group_name(struct pinctrl_dev pctldev,
364	unsigned group)
365	{
366	return bcm6318_groups[group].name;
367	}
368
369	static int bcm6318_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
370	unsigned group, const unsigned **pins,
371	unsigned *num_pins)
372	{
373	*pins = bcm6318_groups[group].pins;
374	*num_pins = bcm6318_groups[group].num_pins;
375
376	return 0;
377	}
378
379	static int bcm6318_pinctrl_get_func_count(struct pinctrl_dev *pctldev)
380	{
381	return ARRAY_SIZE(bcm6318_funcs);
382	}
383
384	static const char bcm6318_pinctrl_get_func_name(struct pinctrl_dev pctldev,
385	unsigned selector)
386	{
387	return bcm6318_funcs[selector].name;
388	}
389
390	static int bcm6318_pinctrl_get_groups(struct pinctrl_dev *pctldev,
391	unsigned selector,
392	const char * const **groups,
393	unsigned * const num_groups)
394	{
395	*groups = bcm6318_funcs[selector].groups;
396	*num_groups = bcm6318_funcs[selector].num_groups;
397
398	return 0;
399	}
400
401	static inline void bcm6318_rmw_mux(struct bcm63xx_pinctrl *pc, unsigned pin,
402	unsigned int mode, unsigned int mux)
403	{
404	if (pin < BCM63XX_BANK_GPIOS)
405	regmap_update_bits(pc->regs, BCM6318_MODE_REG, BIT(pin),
406	mode ? BIT(pin) : 0);
407
408	if (pin < BCM6318_NUM_MUX)
409	regmap_update_bits(pc->regs,
410	bcm6318_mux_off(pin),
411	BCM6328_MUX_MASK << ((pin % 16) * 2),
412	mux << ((pin % 16) * 2));
413	}
414
415	static inline void bcm6318_set_pad(struct bcm63xx_pinctrl *pc, unsigned pin,
416	uint8_t val)
417	{
418	regmap_update_bits(pc->regs, bcm6318_pad_off(pin),
419	BCM6328_PAD_MASK << ((pin % 8) * 4),
420	val << ((pin % 8) * 4));
421	}
422
423	static int bcm6318_pinctrl_set_mux(struct pinctrl_dev *pctldev,
424	unsigned selector, unsigned group)
425	{
426	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
427	const struct bcm6318_pingroup *pg = &bcm6318_groups[group];
428	const struct bcm6318_function *f = &bcm6318_funcs[selector];
429
430	bcm6318_rmw_mux(pc, pg->pins[0], f->mode_val, f->mux_val);
431
432	return 0;
433	}
434
435	static int bcm6318_gpio_request_enable(struct pinctrl_dev *pctldev,
436	struct pinctrl_gpio_range *range,
437	unsigned offset)
438	{
439	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
440
441	/* disable all functions using this pin */
442	if (offset < 13) {
443	/* GPIOs 0-12 use mux 0 as GPIO function */
444	bcm6318_rmw_mux(pc, offset, 0, 0);
445	} else if (offset < 42) {
446	/* GPIOs 13-41 use mux 3 as GPIO function */
447	bcm6318_rmw_mux(pc, offset, 0, 3);
448
449	bcm6318_set_pad(pc, offset, 0);
450	}
451
452	return 0;
453	}
454
d9779093	455	static const struct pinctrl_ops bcm6318_pctl_ops = {
d28039fc ÁFR	456	.dt_free_map = pinctrl_utils_free_map,
	457	.dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
	458	.get_group_name = bcm6318_pinctrl_get_group_name,
	459	.get_group_pins = bcm6318_pinctrl_get_group_pins,
	460	.get_groups_count = bcm6318_pinctrl_get_group_count,
	461	};
	462
0c683876	463	static const struct pinmux_ops bcm6318_pmx_ops = {
d28039fc ÁFR	464	.get_function_groups = bcm6318_pinctrl_get_groups,
	465	.get_function_name = bcm6318_pinctrl_get_func_name,
	466	.get_functions_count = bcm6318_pinctrl_get_func_count,
	467	.gpio_request_enable = bcm6318_gpio_request_enable,
	468	.set_mux = bcm6318_pinctrl_set_mux,
	469	.strict = true,
	470	};
	471
	472	static const struct bcm63xx_pinctrl_soc bcm6318_soc = {
	473	.ngpios = BCM6318_NUM_GPIOS,
	474	.npins = ARRAY_SIZE(bcm6318_pins),
	475	.pctl_ops = &bcm6318_pctl_ops,
	476	.pins = bcm6318_pins,
	477	.pmx_ops = &bcm6318_pmx_ops,
	478	};
	479
	480	static int bcm6318_pinctrl_probe(struct platform_device *pdev)
	481	{
	482	return bcm63xx_pinctrl_probe(pdev, &bcm6318_soc, NULL);
	483	}
	484
	485	static const struct of_device_id bcm6318_pinctrl_match[] = {
	486	{ .compatible = "brcm,bcm6318-pinctrl", },
	487	{ /* sentinel */ }
	488	};
	489
	490	static struct platform_driver bcm6318_pinctrl_driver = {
	491	.probe = bcm6318_pinctrl_probe,
	492	.driver = {
	493	.name = "bcm6318-pinctrl",
	494	.of_match_table = bcm6318_pinctrl_match,
	495	},
	496	};
	497
	498	builtin_platform_driver(bcm6318_pinctrl_driver);