1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Driver for BCM6328 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 BCM6328_NUM_GPIOS	32
22
23#define BCM6328_MODE_REG	0x18
24#define BCM6328_MUX_HI_REG	0x1c
25#define BCM6328_MUX_LO_REG	0x20
26#define BCM6328_MUX_OTHER_REG	0x24
27#define  BCM6328_MUX_MASK	GENMASK(1, 0)
28
29struct bcm6328_function {
30	const char *name;
31	const char * const *groups;
32	const unsigned num_groups;
33
34	unsigned mode_val:1;
35	unsigned mux_val:2;
36};
37
38static const unsigned int bcm6328_mux[] = {
39	BCM6328_MUX_LO_REG,
40	BCM6328_MUX_HI_REG,
41	BCM6328_MUX_OTHER_REG
42};
43
44static const struct pinctrl_pin_desc bcm6328_pins[] = {
45	PINCTRL_PIN(0, "gpio0"),
46	PINCTRL_PIN(1, "gpio1"),
47	PINCTRL_PIN(2, "gpio2"),
48	PINCTRL_PIN(3, "gpio3"),
49	PINCTRL_PIN(4, "gpio4"),
50	PINCTRL_PIN(5, "gpio5"),
51	PINCTRL_PIN(6, "gpio6"),
52	PINCTRL_PIN(7, "gpio7"),
53	PINCTRL_PIN(8, "gpio8"),
54	PINCTRL_PIN(9, "gpio9"),
55	PINCTRL_PIN(10, "gpio10"),
56	PINCTRL_PIN(11, "gpio11"),
57	PINCTRL_PIN(12, "gpio12"),
58	PINCTRL_PIN(13, "gpio13"),
59	PINCTRL_PIN(14, "gpio14"),
60	PINCTRL_PIN(15, "gpio15"),
61	PINCTRL_PIN(16, "gpio16"),
62	PINCTRL_PIN(17, "gpio17"),
63	PINCTRL_PIN(18, "gpio18"),
64	PINCTRL_PIN(19, "gpio19"),
65	PINCTRL_PIN(20, "gpio20"),
66	PINCTRL_PIN(21, "gpio21"),
67	PINCTRL_PIN(22, "gpio22"),
68	PINCTRL_PIN(23, "gpio23"),
69	PINCTRL_PIN(24, "gpio24"),
70	PINCTRL_PIN(25, "gpio25"),
71	PINCTRL_PIN(26, "gpio26"),
72	PINCTRL_PIN(27, "gpio27"),
73	PINCTRL_PIN(28, "gpio28"),
74	PINCTRL_PIN(29, "gpio29"),
75	PINCTRL_PIN(30, "gpio30"),
76	PINCTRL_PIN(31, "gpio31"),
77
78	/*
79	 * No idea where they really are; so let's put them according
80	 * to their mux offsets.
81	 */
82	PINCTRL_PIN(36, "hsspi_cs1"),
83	PINCTRL_PIN(38, "usb_p2"),
84};
85
86static unsigned gpio0_pins[] = { 0 };
87static unsigned gpio1_pins[] = { 1 };
88static unsigned gpio2_pins[] = { 2 };
89static unsigned gpio3_pins[] = { 3 };
90static unsigned gpio4_pins[] = { 4 };
91static unsigned gpio5_pins[] = { 5 };
92static unsigned gpio6_pins[] = { 6 };
93static unsigned gpio7_pins[] = { 7 };
94static unsigned gpio8_pins[] = { 8 };
95static unsigned gpio9_pins[] = { 9 };
96static unsigned gpio10_pins[] = { 10 };
97static unsigned gpio11_pins[] = { 11 };
98static unsigned gpio12_pins[] = { 12 };
99static unsigned gpio13_pins[] = { 13 };
100static unsigned gpio14_pins[] = { 14 };
101static unsigned gpio15_pins[] = { 15 };
102static unsigned gpio16_pins[] = { 16 };
103static unsigned gpio17_pins[] = { 17 };
104static unsigned gpio18_pins[] = { 18 };
105static unsigned gpio19_pins[] = { 19 };
106static unsigned gpio20_pins[] = { 20 };
107static unsigned gpio21_pins[] = { 21 };
108static unsigned gpio22_pins[] = { 22 };
109static unsigned gpio23_pins[] = { 23 };
110static unsigned gpio24_pins[] = { 24 };
111static unsigned gpio25_pins[] = { 25 };
112static unsigned gpio26_pins[] = { 26 };
113static unsigned gpio27_pins[] = { 27 };
114static unsigned gpio28_pins[] = { 28 };
115static unsigned gpio29_pins[] = { 29 };
116static unsigned gpio30_pins[] = { 30 };
117static unsigned gpio31_pins[] = { 31 };
118
119static unsigned hsspi_cs1_pins[] = { 36 };
120static unsigned usb_port1_pins[] = { 38 };
121
122static struct pingroup bcm6328_groups[] = {
123	BCM_PIN_GROUP(gpio0),
124	BCM_PIN_GROUP(gpio1),
125	BCM_PIN_GROUP(gpio2),
126	BCM_PIN_GROUP(gpio3),
127	BCM_PIN_GROUP(gpio4),
128	BCM_PIN_GROUP(gpio5),
129	BCM_PIN_GROUP(gpio6),
130	BCM_PIN_GROUP(gpio7),
131	BCM_PIN_GROUP(gpio8),
132	BCM_PIN_GROUP(gpio9),
133	BCM_PIN_GROUP(gpio10),
134	BCM_PIN_GROUP(gpio11),
135	BCM_PIN_GROUP(gpio12),
136	BCM_PIN_GROUP(gpio13),
137	BCM_PIN_GROUP(gpio14),
138	BCM_PIN_GROUP(gpio15),
139	BCM_PIN_GROUP(gpio16),
140	BCM_PIN_GROUP(gpio17),
141	BCM_PIN_GROUP(gpio18),
142	BCM_PIN_GROUP(gpio19),
143	BCM_PIN_GROUP(gpio20),
144	BCM_PIN_GROUP(gpio21),
145	BCM_PIN_GROUP(gpio22),
146	BCM_PIN_GROUP(gpio23),
147	BCM_PIN_GROUP(gpio24),
148	BCM_PIN_GROUP(gpio25),
149	BCM_PIN_GROUP(gpio26),
150	BCM_PIN_GROUP(gpio27),
151	BCM_PIN_GROUP(gpio28),
152	BCM_PIN_GROUP(gpio29),
153	BCM_PIN_GROUP(gpio30),
154	BCM_PIN_GROUP(gpio31),
155
156	BCM_PIN_GROUP(hsspi_cs1),
157	BCM_PIN_GROUP(usb_port1),
158};
159
160/* GPIO_MODE */
161static const char * const led_groups[] = {
162	"gpio0",
163	"gpio1",
164	"gpio2",
165	"gpio3",
166	"gpio4",
167	"gpio5",
168	"gpio6",
169	"gpio7",
170	"gpio8",
171	"gpio9",
172	"gpio10",
173	"gpio11",
174	"gpio12",
175	"gpio13",
176	"gpio14",
177	"gpio15",
178	"gpio16",
179	"gpio17",
180	"gpio18",
181	"gpio19",
182	"gpio20",
183	"gpio21",
184	"gpio22",
185	"gpio23",
186};
187
188/* PINMUX_SEL */
189static const char * const serial_led_data_groups[] = {
190	"gpio6",
191};
192
193static const char * const serial_led_clk_groups[] = {
194	"gpio7",
195};
196
197static const char * const inet_act_led_groups[] = {
198	"gpio11",
199};
200
201static const char * const pcie_clkreq_groups[] = {
202	"gpio16",
203};
204
205static const char * const ephy0_act_led_groups[] = {
206	"gpio25",
207};
208
209static const char * const ephy1_act_led_groups[] = {
210	"gpio26",
211};
212
213static const char * const ephy2_act_led_groups[] = {
214	"gpio27",
215};
216
217static const char * const ephy3_act_led_groups[] = {
218	"gpio28",
219};
220
221static const char * const hsspi_cs1_groups[] = {
222	"hsspi_cs1"
223};
224
225static const char * const usb_host_port_groups[] = {
226	"usb_port1",
227};
228
229static const char * const usb_device_port_groups[] = {
230	"usb_port1",
231};
232
233#define BCM6328_MODE_FUN(n)				\
234	{						\
235		.name = #n,				\
236		.groups = n##_groups,			\
237		.num_groups = ARRAY_SIZE(n##_groups),	\
238		.mode_val = 1,				\
239	}
240
241#define BCM6328_MUX_FUN(n, mux)				\
242	{						\
243		.name = #n,				\
244		.groups = n##_groups,			\
245		.num_groups = ARRAY_SIZE(n##_groups),	\
246		.mux_val = mux,				\
247	}
248
249static const struct bcm6328_function bcm6328_funcs[] = {
250	BCM6328_MODE_FUN(led),
251	BCM6328_MUX_FUN(serial_led_data, 2),
252	BCM6328_MUX_FUN(serial_led_clk, 2),
253	BCM6328_MUX_FUN(inet_act_led, 1),
254	BCM6328_MUX_FUN(pcie_clkreq, 2),
255	BCM6328_MUX_FUN(ephy0_act_led, 1),
256	BCM6328_MUX_FUN(ephy1_act_led, 1),
257	BCM6328_MUX_FUN(ephy2_act_led, 1),
258	BCM6328_MUX_FUN(ephy3_act_led, 1),
259	BCM6328_MUX_FUN(hsspi_cs1, 2),
260	BCM6328_MUX_FUN(usb_host_port, 1),
261	BCM6328_MUX_FUN(usb_device_port, 2),
262};
263
264static inline unsigned int bcm6328_mux_off(unsigned int pin)
265{
266	return bcm6328_mux[pin / 16];
267}
268
269static int bcm6328_pinctrl_get_group_count(struct pinctrl_dev *pctldev)
270{
271	return ARRAY_SIZE(bcm6328_groups);
272}
273
274static const char *bcm6328_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
275						  unsigned group)
276{
277	return bcm6328_groups[group].name;
278}
279
280static int bcm6328_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
281					  unsigned group, const unsigned **pins,
282					  unsigned *npins)
283{
284	*pins = bcm6328_groups[group].pins;
285	*npins = bcm6328_groups[group].npins;
286
287	return 0;
288}
289
290static int bcm6328_pinctrl_get_func_count(struct pinctrl_dev *pctldev)
291{
292	return ARRAY_SIZE(bcm6328_funcs);
293}
294
295static const char *bcm6328_pinctrl_get_func_name(struct pinctrl_dev *pctldev,
296						 unsigned selector)
297{
298	return bcm6328_funcs[selector].name;
299}
300
301static int bcm6328_pinctrl_get_groups(struct pinctrl_dev *pctldev,
302				      unsigned selector,
303				      const char * const **groups,
304				      unsigned * const num_groups)
305{
306	*groups = bcm6328_funcs[selector].groups;
307	*num_groups = bcm6328_funcs[selector].num_groups;
308
309	return 0;
310}
311
312static void bcm6328_rmw_mux(struct bcm63xx_pinctrl *pc, unsigned pin,
313			    unsigned int mode, unsigned int mux)
314{
315	if (pin < BCM6328_NUM_GPIOS)
316		regmap_update_bits(pc->regs, BCM6328_MODE_REG, BIT(pin),
317				   mode ? BIT(pin) : 0);
318
319	regmap_update_bits(pc->regs, bcm6328_mux_off(pin),
320			   BCM6328_MUX_MASK << ((pin % 16) * 2),
321			   mux << ((pin % 16) * 2));
322}
323
324static int bcm6328_pinctrl_set_mux(struct pinctrl_dev *pctldev,
325				   unsigned selector, unsigned group)
326{
327	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
328	const struct pingroup *pg = &bcm6328_groups[group];
329	const struct bcm6328_function *f = &bcm6328_funcs[selector];
330
331	bcm6328_rmw_mux(pc, pg->pins[0], f->mode_val, f->mux_val);
332
333	return 0;
334}
335
336static int bcm6328_gpio_request_enable(struct pinctrl_dev *pctldev,
337				       struct pinctrl_gpio_range *range,
338				       unsigned offset)
339{
340	struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
341
342	/* disable all functions using this pin */
343	bcm6328_rmw_mux(pc, offset, 0, 0);
344
345	return 0;
346}
347
348static const struct pinctrl_ops bcm6328_pctl_ops = {
349	.dt_free_map = pinctrl_utils_free_map,
350	.dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
351	.get_group_name = bcm6328_pinctrl_get_group_name,
352	.get_group_pins = bcm6328_pinctrl_get_group_pins,
353	.get_groups_count = bcm6328_pinctrl_get_group_count,
354};
355
356static const struct pinmux_ops bcm6328_pmx_ops = {
357	.get_function_groups = bcm6328_pinctrl_get_groups,
358	.get_function_name = bcm6328_pinctrl_get_func_name,
359	.get_functions_count = bcm6328_pinctrl_get_func_count,
360	.gpio_request_enable = bcm6328_gpio_request_enable,
361	.set_mux = bcm6328_pinctrl_set_mux,
362	.strict = true,
363};
364
365static const struct bcm63xx_pinctrl_soc bcm6328_soc = {
366	.ngpios = BCM6328_NUM_GPIOS,
367	.npins = ARRAY_SIZE(bcm6328_pins),
368	.pctl_ops = &bcm6328_pctl_ops,
369	.pins = bcm6328_pins,
370	.pmx_ops = &bcm6328_pmx_ops,
371};
372
373static int bcm6328_pinctrl_probe(struct platform_device *pdev)
374{
375	return bcm63xx_pinctrl_probe(pdev, &bcm6328_soc, NULL);
376}
377
378static const struct of_device_id bcm6328_pinctrl_match[] = {
379	{ .compatible = "brcm,bcm6328-pinctrl", },
380	{ /* sentinel */ }
381};
382
383static struct platform_driver bcm6328_pinctrl_driver = {
384	.probe = bcm6328_pinctrl_probe,
385	.driver = {
386		.name = "bcm6328-pinctrl",
387		.of_match_table = bcm6328_pinctrl_match,
388	},
389};
390
391builtin_platform_driver(bcm6328_pinctrl_driver);
392