1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2020 Sean Anderson <seanga2@gmail.com>
4 * Copyright (c) 2020 Western Digital Corporation or its affiliates.
5 */
6#include <linux/bitfield.h>
7#include <linux/clk.h>
8#include <linux/io.h>
9#include <linux/mfd/syscon.h>
10#include <linux/of.h>
11#include <linux/platform_device.h>
12#include <linux/regmap.h>
13#include <linux/seq_file.h>
14#include <linux/slab.h>
15
16#include <linux/pinctrl/pinconf-generic.h>
17#include <linux/pinctrl/pinconf.h>
18#include <linux/pinctrl/pinctrl.h>
19#include <linux/pinctrl/pinmux.h>
20
21#include <dt-bindings/pinctrl/k210-fpioa.h>
22
23#include "core.h"
24#include "pinconf.h"
25#include "pinctrl-utils.h"
26
27/*
28 * The K210 only implements 8 drive levels, even though
29 * there is register space for 16
30 */
31#define K210_PC_DRIVE_MASK	GENMASK(11, 8)
32#define K210_PC_DRIVE_SHIFT	8
33#define K210_PC_DRIVE_0		(0 << K210_PC_DRIVE_SHIFT)
34#define K210_PC_DRIVE_1		(1 << K210_PC_DRIVE_SHIFT)
35#define K210_PC_DRIVE_2		(2 << K210_PC_DRIVE_SHIFT)
36#define K210_PC_DRIVE_3		(3 << K210_PC_DRIVE_SHIFT)
37#define K210_PC_DRIVE_4		(4 << K210_PC_DRIVE_SHIFT)
38#define K210_PC_DRIVE_5		(5 << K210_PC_DRIVE_SHIFT)
39#define K210_PC_DRIVE_6		(6 << K210_PC_DRIVE_SHIFT)
40#define K210_PC_DRIVE_7		(7 << K210_PC_DRIVE_SHIFT)
41#define K210_PC_DRIVE_MAX	7
42#define K210_PC_MODE_MASK	GENMASK(23, 12)
43
44/*
45 * output enabled == PC_OE & (PC_OE_INV ^ FUNCTION_OE)
46 * where FUNCTION_OE is a physical signal from the function.
47 */
48#define K210_PC_OE		BIT(12) /* Output Enable */
49#define K210_PC_OE_INV		BIT(13) /* INVert Output Enable */
50#define K210_PC_DO_OE		BIT(14) /* set Data Out to Output Enable sig */
51#define K210_PC_DO_INV		BIT(15) /* INVert final Data Output */
52#define K210_PC_PU		BIT(16) /* Pull Up */
53#define K210_PC_PD		BIT(17) /* Pull Down */
54/* Strong pull up not implemented on K210 */
55#define K210_PC_SL		BIT(19) /* reduce SLew rate */
56/* Same semantics as OE above */
57#define K210_PC_IE		BIT(20) /* Input Enable */
58#define K210_PC_IE_INV		BIT(21) /* INVert Input Enable */
59#define K210_PC_DI_INV		BIT(22) /* INVert Data Input */
60#define K210_PC_ST		BIT(23) /* Schmitt Trigger */
61#define K210_PC_DI		BIT(31) /* raw Data Input */
62
63#define K210_PC_BIAS_MASK	(K210_PC_PU & K210_PC_PD)
64
65#define K210_PC_MODE_IN		(K210_PC_IE | K210_PC_ST)
66#define K210_PC_MODE_OUT	(K210_PC_DRIVE_7 | K210_PC_OE)
67#define K210_PC_MODE_I2C	(K210_PC_MODE_IN | K210_PC_SL | \
68				 K210_PC_OE | K210_PC_PU)
69#define K210_PC_MODE_SCCB	(K210_PC_MODE_I2C | \
70				 K210_PC_OE_INV | K210_PC_IE_INV)
71#define K210_PC_MODE_SPI	(K210_PC_MODE_IN | K210_PC_IE_INV | \
72				 K210_PC_MODE_OUT | K210_PC_OE_INV)
73#define K210_PC_MODE_GPIO	(K210_PC_MODE_IN | K210_PC_MODE_OUT)
74
75#define K210_PG_FUNC		GENMASK(7, 0)
76#define K210_PG_DO		BIT(8)
77#define K210_PG_PIN		GENMASK(22, 16)
78
79/*
80 * struct k210_fpioa: Kendryte K210 FPIOA memory mapped registers
81 * @pins: 48 32-bits IO pin registers
82 * @tie_en: 256 (one per function) input tie enable bits
83 * @tie_val: 256 (one per function) input tie value bits
84 */
85struct k210_fpioa {
86	u32 pins[48];
87	u32 tie_en[8];
88	u32 tie_val[8];
89};
90
91struct k210_fpioa_data {
92
93	struct device *dev;
94	struct pinctrl_dev *pctl;
95
96	struct k210_fpioa __iomem *fpioa;
97	struct regmap *sysctl_map;
98	u32 power_offset;
99	struct clk *clk;
100	struct clk *pclk;
101};
102
103#define K210_PIN_NAME(i)	("IO_" #i)
104#define K210_PIN(i)		[(i)] = PINCTRL_PIN((i), K210_PIN_NAME(i))
105
106static const struct pinctrl_pin_desc k210_pins[] = {
107	K210_PIN(0),  K210_PIN(1),  K210_PIN(2),
108	K210_PIN(3),  K210_PIN(4),  K210_PIN(5),
109	K210_PIN(6),  K210_PIN(7),  K210_PIN(8),
110	K210_PIN(9),  K210_PIN(10), K210_PIN(11),
111	K210_PIN(12), K210_PIN(13), K210_PIN(14),
112	K210_PIN(15), K210_PIN(16), K210_PIN(17),
113	K210_PIN(18), K210_PIN(19), K210_PIN(20),
114	K210_PIN(21), K210_PIN(22), K210_PIN(23),
115	K210_PIN(24), K210_PIN(25), K210_PIN(26),
116	K210_PIN(27), K210_PIN(28), K210_PIN(29),
117	K210_PIN(30), K210_PIN(31), K210_PIN(32),
118	K210_PIN(33), K210_PIN(34), K210_PIN(35),
119	K210_PIN(36), K210_PIN(37), K210_PIN(38),
120	K210_PIN(39), K210_PIN(40), K210_PIN(41),
121	K210_PIN(42), K210_PIN(43), K210_PIN(44),
122	K210_PIN(45), K210_PIN(46), K210_PIN(47)
123};
124
125#define K210_NPINS ARRAY_SIZE(k210_pins)
126
127/*
128 * Pin groups: each of the 48 programmable pins is a group.
129 * To this are added 8 power domain groups, which for the purposes of
130 * the pin subsystem, contain no pins. The power domain groups only exist
131 * to set the power level. The id should never be used (since there are
132 * no pins 48-55).
133 */
134static const char *const k210_group_names[] = {
135	/* The first 48 groups are for pins, one each */
136	K210_PIN_NAME(0),  K210_PIN_NAME(1),  K210_PIN_NAME(2),
137	K210_PIN_NAME(3),  K210_PIN_NAME(4),  K210_PIN_NAME(5),
138	K210_PIN_NAME(6),  K210_PIN_NAME(7),  K210_PIN_NAME(8),
139	K210_PIN_NAME(9),  K210_PIN_NAME(10), K210_PIN_NAME(11),
140	K210_PIN_NAME(12), K210_PIN_NAME(13), K210_PIN_NAME(14),
141	K210_PIN_NAME(15), K210_PIN_NAME(16), K210_PIN_NAME(17),
142	K210_PIN_NAME(18), K210_PIN_NAME(19), K210_PIN_NAME(20),
143	K210_PIN_NAME(21), K210_PIN_NAME(22), K210_PIN_NAME(23),
144	K210_PIN_NAME(24), K210_PIN_NAME(25), K210_PIN_NAME(26),
145	K210_PIN_NAME(27), K210_PIN_NAME(28), K210_PIN_NAME(29),
146	K210_PIN_NAME(30), K210_PIN_NAME(31), K210_PIN_NAME(32),
147	K210_PIN_NAME(33), K210_PIN_NAME(34), K210_PIN_NAME(35),
148	K210_PIN_NAME(36), K210_PIN_NAME(37), K210_PIN_NAME(38),
149	K210_PIN_NAME(39), K210_PIN_NAME(40), K210_PIN_NAME(41),
150	K210_PIN_NAME(42), K210_PIN_NAME(43), K210_PIN_NAME(44),
151	K210_PIN_NAME(45), K210_PIN_NAME(46), K210_PIN_NAME(47),
152	[48] = "A0", [49] = "A1", [50] = "A2",
153	[51] = "B3", [52] = "B4", [53] = "B5",
154	[54] = "C6", [55] = "C7"
155};
156
157#define K210_NGROUPS	ARRAY_SIZE(k210_group_names)
158
159enum k210_pinctrl_mode_id {
160	K210_PC_DEFAULT_DISABLED,
161	K210_PC_DEFAULT_IN,
162	K210_PC_DEFAULT_IN_TIE,
163	K210_PC_DEFAULT_OUT,
164	K210_PC_DEFAULT_I2C,
165	K210_PC_DEFAULT_SCCB,
166	K210_PC_DEFAULT_SPI,
167	K210_PC_DEFAULT_GPIO,
168	K210_PC_DEFAULT_INT13,
169};
170
171#define K210_PC_DEFAULT(mode) \
172	[K210_PC_DEFAULT_##mode] = K210_PC_MODE_##mode
173
174static const u32 k210_pinconf_mode_id_to_mode[] = {
175	[K210_PC_DEFAULT_DISABLED] = 0,
176	K210_PC_DEFAULT(IN),
177	[K210_PC_DEFAULT_IN_TIE] = K210_PC_MODE_IN,
178	K210_PC_DEFAULT(OUT),
179	K210_PC_DEFAULT(I2C),
180	K210_PC_DEFAULT(SCCB),
181	K210_PC_DEFAULT(SPI),
182	K210_PC_DEFAULT(GPIO),
183	[K210_PC_DEFAULT_INT13] = K210_PC_MODE_IN | K210_PC_PU,
184};
185
186#undef DEFAULT
187
188/*
189 * Pin functions configuration information.
190 */
191struct k210_pcf_info {
192	char name[15];
193	u8 mode_id;
194};
195
196#define K210_FUNC(id, mode)				\
197	[K210_PCF_##id] = {				\
198		.name = #id,				\
199		.mode_id = K210_PC_DEFAULT_##mode	\
200	}
201
202static const struct k210_pcf_info k210_pcf_infos[] = {
203	K210_FUNC(JTAG_TCLK,		IN),
204	K210_FUNC(JTAG_TDI,		IN),
205	K210_FUNC(JTAG_TMS,		IN),
206	K210_FUNC(JTAG_TDO,		OUT),
207	K210_FUNC(SPI0_D0,		SPI),
208	K210_FUNC(SPI0_D1,		SPI),
209	K210_FUNC(SPI0_D2,		SPI),
210	K210_FUNC(SPI0_D3,		SPI),
211	K210_FUNC(SPI0_D4,		SPI),
212	K210_FUNC(SPI0_D5,		SPI),
213	K210_FUNC(SPI0_D6,		SPI),
214	K210_FUNC(SPI0_D7,		SPI),
215	K210_FUNC(SPI0_SS0,		OUT),
216	K210_FUNC(SPI0_SS1,		OUT),
217	K210_FUNC(SPI0_SS2,		OUT),
218	K210_FUNC(SPI0_SS3,		OUT),
219	K210_FUNC(SPI0_ARB,		IN_TIE),
220	K210_FUNC(SPI0_SCLK,		OUT),
221	K210_FUNC(UARTHS_RX,		IN),
222	K210_FUNC(UARTHS_TX,		OUT),
223	K210_FUNC(RESV6,		IN),
224	K210_FUNC(RESV7,		IN),
225	K210_FUNC(CLK_SPI1,		OUT),
226	K210_FUNC(CLK_I2C1,		OUT),
227	K210_FUNC(GPIOHS0,		GPIO),
228	K210_FUNC(GPIOHS1,		GPIO),
229	K210_FUNC(GPIOHS2,		GPIO),
230	K210_FUNC(GPIOHS3,		GPIO),
231	K210_FUNC(GPIOHS4,		GPIO),
232	K210_FUNC(GPIOHS5,		GPIO),
233	K210_FUNC(GPIOHS6,		GPIO),
234	K210_FUNC(GPIOHS7,		GPIO),
235	K210_FUNC(GPIOHS8,		GPIO),
236	K210_FUNC(GPIOHS9,		GPIO),
237	K210_FUNC(GPIOHS10,		GPIO),
238	K210_FUNC(GPIOHS11,		GPIO),
239	K210_FUNC(GPIOHS12,		GPIO),
240	K210_FUNC(GPIOHS13,		GPIO),
241	K210_FUNC(GPIOHS14,		GPIO),
242	K210_FUNC(GPIOHS15,		GPIO),
243	K210_FUNC(GPIOHS16,		GPIO),
244	K210_FUNC(GPIOHS17,		GPIO),
245	K210_FUNC(GPIOHS18,		GPIO),
246	K210_FUNC(GPIOHS19,		GPIO),
247	K210_FUNC(GPIOHS20,		GPIO),
248	K210_FUNC(GPIOHS21,		GPIO),
249	K210_FUNC(GPIOHS22,		GPIO),
250	K210_FUNC(GPIOHS23,		GPIO),
251	K210_FUNC(GPIOHS24,		GPIO),
252	K210_FUNC(GPIOHS25,		GPIO),
253	K210_FUNC(GPIOHS26,		GPIO),
254	K210_FUNC(GPIOHS27,		GPIO),
255	K210_FUNC(GPIOHS28,		GPIO),
256	K210_FUNC(GPIOHS29,		GPIO),
257	K210_FUNC(GPIOHS30,		GPIO),
258	K210_FUNC(GPIOHS31,		GPIO),
259	K210_FUNC(GPIO0,		GPIO),
260	K210_FUNC(GPIO1,		GPIO),
261	K210_FUNC(GPIO2,		GPIO),
262	K210_FUNC(GPIO3,		GPIO),
263	K210_FUNC(GPIO4,		GPIO),
264	K210_FUNC(GPIO5,		GPIO),
265	K210_FUNC(GPIO6,		GPIO),
266	K210_FUNC(GPIO7,		GPIO),
267	K210_FUNC(UART1_RX,		IN),
268	K210_FUNC(UART1_TX,		OUT),
269	K210_FUNC(UART2_RX,		IN),
270	K210_FUNC(UART2_TX,		OUT),
271	K210_FUNC(UART3_RX,		IN),
272	K210_FUNC(UART3_TX,		OUT),
273	K210_FUNC(SPI1_D0,		SPI),
274	K210_FUNC(SPI1_D1,		SPI),
275	K210_FUNC(SPI1_D2,		SPI),
276	K210_FUNC(SPI1_D3,		SPI),
277	K210_FUNC(SPI1_D4,		SPI),
278	K210_FUNC(SPI1_D5,		SPI),
279	K210_FUNC(SPI1_D6,		SPI),
280	K210_FUNC(SPI1_D7,		SPI),
281	K210_FUNC(SPI1_SS0,		OUT),
282	K210_FUNC(SPI1_SS1,		OUT),
283	K210_FUNC(SPI1_SS2,		OUT),
284	K210_FUNC(SPI1_SS3,		OUT),
285	K210_FUNC(SPI1_ARB,		IN_TIE),
286	K210_FUNC(SPI1_SCLK,		OUT),
287	K210_FUNC(SPI2_D0,		SPI),
288	K210_FUNC(SPI2_SS,		IN),
289	K210_FUNC(SPI2_SCLK,		IN),
290	K210_FUNC(I2S0_MCLK,		OUT),
291	K210_FUNC(I2S0_SCLK,		OUT),
292	K210_FUNC(I2S0_WS,		OUT),
293	K210_FUNC(I2S0_IN_D0,		IN),
294	K210_FUNC(I2S0_IN_D1,		IN),
295	K210_FUNC(I2S0_IN_D2,		IN),
296	K210_FUNC(I2S0_IN_D3,		IN),
297	K210_FUNC(I2S0_OUT_D0,		OUT),
298	K210_FUNC(I2S0_OUT_D1,		OUT),
299	K210_FUNC(I2S0_OUT_D2,		OUT),
300	K210_FUNC(I2S0_OUT_D3,		OUT),
301	K210_FUNC(I2S1_MCLK,		OUT),
302	K210_FUNC(I2S1_SCLK,		OUT),
303	K210_FUNC(I2S1_WS,		OUT),
304	K210_FUNC(I2S1_IN_D0,		IN),
305	K210_FUNC(I2S1_IN_D1,		IN),
306	K210_FUNC(I2S1_IN_D2,		IN),
307	K210_FUNC(I2S1_IN_D3,		IN),
308	K210_FUNC(I2S1_OUT_D0,		OUT),
309	K210_FUNC(I2S1_OUT_D1,		OUT),
310	K210_FUNC(I2S1_OUT_D2,		OUT),
311	K210_FUNC(I2S1_OUT_D3,		OUT),
312	K210_FUNC(I2S2_MCLK,		OUT),
313	K210_FUNC(I2S2_SCLK,		OUT),
314	K210_FUNC(I2S2_WS,		OUT),
315	K210_FUNC(I2S2_IN_D0,		IN),
316	K210_FUNC(I2S2_IN_D1,		IN),
317	K210_FUNC(I2S2_IN_D2,		IN),
318	K210_FUNC(I2S2_IN_D3,		IN),
319	K210_FUNC(I2S2_OUT_D0,		OUT),
320	K210_FUNC(I2S2_OUT_D1,		OUT),
321	K210_FUNC(I2S2_OUT_D2,		OUT),
322	K210_FUNC(I2S2_OUT_D3,		OUT),
323	K210_FUNC(RESV0,		DISABLED),
324	K210_FUNC(RESV1,		DISABLED),
325	K210_FUNC(RESV2,		DISABLED),
326	K210_FUNC(RESV3,		DISABLED),
327	K210_FUNC(RESV4,		DISABLED),
328	K210_FUNC(RESV5,		DISABLED),
329	K210_FUNC(I2C0_SCLK,		I2C),
330	K210_FUNC(I2C0_SDA,		I2C),
331	K210_FUNC(I2C1_SCLK,		I2C),
332	K210_FUNC(I2C1_SDA,		I2C),
333	K210_FUNC(I2C2_SCLK,		I2C),
334	K210_FUNC(I2C2_SDA,		I2C),
335	K210_FUNC(DVP_XCLK,		OUT),
336	K210_FUNC(DVP_RST,		OUT),
337	K210_FUNC(DVP_PWDN,		OUT),
338	K210_FUNC(DVP_VSYNC,		IN),
339	K210_FUNC(DVP_HSYNC,		IN),
340	K210_FUNC(DVP_PCLK,		IN),
341	K210_FUNC(DVP_D0,		IN),
342	K210_FUNC(DVP_D1,		IN),
343	K210_FUNC(DVP_D2,		IN),
344	K210_FUNC(DVP_D3,		IN),
345	K210_FUNC(DVP_D4,		IN),
346	K210_FUNC(DVP_D5,		IN),
347	K210_FUNC(DVP_D6,		IN),
348	K210_FUNC(DVP_D7,		IN),
349	K210_FUNC(SCCB_SCLK,		SCCB),
350	K210_FUNC(SCCB_SDA,		SCCB),
351	K210_FUNC(UART1_CTS,		IN),
352	K210_FUNC(UART1_DSR,		IN),
353	K210_FUNC(UART1_DCD,		IN),
354	K210_FUNC(UART1_RI,		IN),
355	K210_FUNC(UART1_SIR_IN,		IN),
356	K210_FUNC(UART1_DTR,		OUT),
357	K210_FUNC(UART1_RTS,		OUT),
358	K210_FUNC(UART1_OUT2,		OUT),
359	K210_FUNC(UART1_OUT1,		OUT),
360	K210_FUNC(UART1_SIR_OUT,	OUT),
361	K210_FUNC(UART1_BAUD,		OUT),
362	K210_FUNC(UART1_RE,		OUT),
363	K210_FUNC(UART1_DE,		OUT),
364	K210_FUNC(UART1_RS485_EN,	OUT),
365	K210_FUNC(UART2_CTS,		IN),
366	K210_FUNC(UART2_DSR,		IN),
367	K210_FUNC(UART2_DCD,		IN),
368	K210_FUNC(UART2_RI,		IN),
369	K210_FUNC(UART2_SIR_IN,		IN),
370	K210_FUNC(UART2_DTR,		OUT),
371	K210_FUNC(UART2_RTS,		OUT),
372	K210_FUNC(UART2_OUT2,		OUT),
373	K210_FUNC(UART2_OUT1,		OUT),
374	K210_FUNC(UART2_SIR_OUT,	OUT),
375	K210_FUNC(UART2_BAUD,		OUT),
376	K210_FUNC(UART2_RE,		OUT),
377	K210_FUNC(UART2_DE,		OUT),
378	K210_FUNC(UART2_RS485_EN,	OUT),
379	K210_FUNC(UART3_CTS,		IN),
380	K210_FUNC(UART3_DSR,		IN),
381	K210_FUNC(UART3_DCD,		IN),
382	K210_FUNC(UART3_RI,		IN),
383	K210_FUNC(UART3_SIR_IN,		IN),
384	K210_FUNC(UART3_DTR,		OUT),
385	K210_FUNC(UART3_RTS,		OUT),
386	K210_FUNC(UART3_OUT2,		OUT),
387	K210_FUNC(UART3_OUT1,		OUT),
388	K210_FUNC(UART3_SIR_OUT,	OUT),
389	K210_FUNC(UART3_BAUD,		OUT),
390	K210_FUNC(UART3_RE,		OUT),
391	K210_FUNC(UART3_DE,		OUT),
392	K210_FUNC(UART3_RS485_EN,	OUT),
393	K210_FUNC(TIMER0_TOGGLE1,	OUT),
394	K210_FUNC(TIMER0_TOGGLE2,	OUT),
395	K210_FUNC(TIMER0_TOGGLE3,	OUT),
396	K210_FUNC(TIMER0_TOGGLE4,	OUT),
397	K210_FUNC(TIMER1_TOGGLE1,	OUT),
398	K210_FUNC(TIMER1_TOGGLE2,	OUT),
399	K210_FUNC(TIMER1_TOGGLE3,	OUT),
400	K210_FUNC(TIMER1_TOGGLE4,	OUT),
401	K210_FUNC(TIMER2_TOGGLE1,	OUT),
402	K210_FUNC(TIMER2_TOGGLE2,	OUT),
403	K210_FUNC(TIMER2_TOGGLE3,	OUT),
404	K210_FUNC(TIMER2_TOGGLE4,	OUT),
405	K210_FUNC(CLK_SPI2,		OUT),
406	K210_FUNC(CLK_I2C2,		OUT),
407	K210_FUNC(INTERNAL0,		OUT),
408	K210_FUNC(INTERNAL1,		OUT),
409	K210_FUNC(INTERNAL2,		OUT),
410	K210_FUNC(INTERNAL3,		OUT),
411	K210_FUNC(INTERNAL4,		OUT),
412	K210_FUNC(INTERNAL5,		OUT),
413	K210_FUNC(INTERNAL6,		OUT),
414	K210_FUNC(INTERNAL7,		OUT),
415	K210_FUNC(INTERNAL8,		OUT),
416	K210_FUNC(INTERNAL9,		IN),
417	K210_FUNC(INTERNAL10,		IN),
418	K210_FUNC(INTERNAL11,		IN),
419	K210_FUNC(INTERNAL12,		IN),
420	K210_FUNC(INTERNAL13,		INT13),
421	K210_FUNC(INTERNAL14,		I2C),
422	K210_FUNC(INTERNAL15,		IN),
423	K210_FUNC(INTERNAL16,		IN),
424	K210_FUNC(INTERNAL17,		IN),
425	K210_FUNC(CONSTANT,		DISABLED),
426	K210_FUNC(INTERNAL18,		IN),
427	K210_FUNC(DEBUG0,		OUT),
428	K210_FUNC(DEBUG1,		OUT),
429	K210_FUNC(DEBUG2,		OUT),
430	K210_FUNC(DEBUG3,		OUT),
431	K210_FUNC(DEBUG4,		OUT),
432	K210_FUNC(DEBUG5,		OUT),
433	K210_FUNC(DEBUG6,		OUT),
434	K210_FUNC(DEBUG7,		OUT),
435	K210_FUNC(DEBUG8,		OUT),
436	K210_FUNC(DEBUG9,		OUT),
437	K210_FUNC(DEBUG10,		OUT),
438	K210_FUNC(DEBUG11,		OUT),
439	K210_FUNC(DEBUG12,		OUT),
440	K210_FUNC(DEBUG13,		OUT),
441	K210_FUNC(DEBUG14,		OUT),
442	K210_FUNC(DEBUG15,		OUT),
443	K210_FUNC(DEBUG16,		OUT),
444	K210_FUNC(DEBUG17,		OUT),
445	K210_FUNC(DEBUG18,		OUT),
446	K210_FUNC(DEBUG19,		OUT),
447	K210_FUNC(DEBUG20,		OUT),
448	K210_FUNC(DEBUG21,		OUT),
449	K210_FUNC(DEBUG22,		OUT),
450	K210_FUNC(DEBUG23,		OUT),
451	K210_FUNC(DEBUG24,		OUT),
452	K210_FUNC(DEBUG25,		OUT),
453	K210_FUNC(DEBUG26,		OUT),
454	K210_FUNC(DEBUG27,		OUT),
455	K210_FUNC(DEBUG28,		OUT),
456	K210_FUNC(DEBUG29,		OUT),
457	K210_FUNC(DEBUG30,		OUT),
458	K210_FUNC(DEBUG31,		OUT),
459};
460
461#define PIN_CONFIG_OUTPUT_INVERT	(PIN_CONFIG_END + 1)
462#define PIN_CONFIG_INPUT_INVERT		(PIN_CONFIG_END + 2)
463
464static const struct pinconf_generic_params k210_pinconf_custom_params[] = {
465	{ "output-polarity-invert", PIN_CONFIG_OUTPUT_INVERT, 1 },
466	{ "input-polarity-invert",  PIN_CONFIG_INPUT_INVERT, 1 },
467};
468
469/*
470 * Max drive strength in uA.
471 */
472static const int k210_pinconf_drive_strength[] = {
473	[0] = 11200,
474	[1] = 16800,
475	[2] = 22300,
476	[3] = 27800,
477	[4] = 33300,
478	[5] = 38700,
479	[6] = 44100,
480	[7] = 49500,
481};
482
483static int k210_pinconf_get_drive(unsigned int max_strength_ua)
484{
485	int i;
486
487	for (i = K210_PC_DRIVE_MAX; i >= 0; i--) {
488		if (k210_pinconf_drive_strength[i] <= max_strength_ua)
489			return i;
490	}
491
492	return -EINVAL;
493}
494
495static void k210_pinmux_set_pin_function(struct pinctrl_dev *pctldev,
496					 u32 pin, u32 func)
497{
498	struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
499	const struct k210_pcf_info *info = &k210_pcf_infos[func];
500	u32 mode = k210_pinconf_mode_id_to_mode[info->mode_id];
501	u32 val = func | mode;
502
503	dev_dbg(pdata->dev, "set pin %u function %s (%u) -> 0x%08x\n",
504		pin, info->name, func, val);
505
506	writel(val, &pdata->fpioa->pins[pin]);
507}
508
509static int k210_pinconf_set_param(struct pinctrl_dev *pctldev,
510				  unsigned int pin,
511				  unsigned int param, unsigned int arg)
512{
513	struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
514	u32 val = readl(&pdata->fpioa->pins[pin]);
515	int drive;
516
517	dev_dbg(pdata->dev, "set pin %u param %u, arg 0x%x\n",
518		pin, param, arg);
519
520	switch (param) {
521	case PIN_CONFIG_BIAS_DISABLE:
522		val &= ~K210_PC_BIAS_MASK;
523		break;
524	case PIN_CONFIG_BIAS_PULL_DOWN:
525		if (!arg)
526			return -EINVAL;
527		val |= K210_PC_PD;
528		break;
529	case PIN_CONFIG_BIAS_PULL_UP:
530		if (!arg)
531			return -EINVAL;
532		val |= K210_PC_PU;
533		break;
534	case PIN_CONFIG_DRIVE_STRENGTH:
535		arg *= 1000;
536		fallthrough;
537	case PIN_CONFIG_DRIVE_STRENGTH_UA:
538		drive = k210_pinconf_get_drive(arg);
539		if (drive < 0)
540			return drive;
541		val &= ~K210_PC_DRIVE_MASK;
542		val |= FIELD_PREP(K210_PC_DRIVE_MASK, drive);
543		break;
544	case PIN_CONFIG_INPUT_ENABLE:
545		if (arg)
546			val |= K210_PC_IE;
547		else
548			val &= ~K210_PC_IE;
549		break;
550	case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
551		if (arg)
552			val |= K210_PC_ST;
553		else
554			val &= ~K210_PC_ST;
555		break;
556	case PIN_CONFIG_OUTPUT:
557		k210_pinmux_set_pin_function(pctldev, pin, K210_PCF_CONSTANT);
558		val = readl(&pdata->fpioa->pins[pin]);
559		val |= K210_PC_MODE_OUT;
560		if (!arg)
561			val |= K210_PC_DO_INV;
562		break;
563	case PIN_CONFIG_OUTPUT_ENABLE:
564		if (arg)
565			val |= K210_PC_OE;
566		else
567			val &= ~K210_PC_OE;
568		break;
569	case PIN_CONFIG_SLEW_RATE:
570		if (arg)
571			val |= K210_PC_SL;
572		else
573			val &= ~K210_PC_SL;
574		break;
575	case PIN_CONFIG_OUTPUT_INVERT:
576		if (arg)
577			val |= K210_PC_DO_INV;
578		else
579			val &= ~K210_PC_DO_INV;
580		break;
581	case PIN_CONFIG_INPUT_INVERT:
582		if (arg)
583			val |= K210_PC_DI_INV;
584		else
585			val &= ~K210_PC_DI_INV;
586		break;
587	default:
588		return -EINVAL;
589	}
590
591	writel(val, &pdata->fpioa->pins[pin]);
592
593	return 0;
594}
595
596static int k210_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
597			    unsigned long *configs, unsigned int num_configs)
598{
599	unsigned int param, arg;
600	int i, ret;
601
602	if (WARN_ON(pin >= K210_NPINS))
603		return -EINVAL;
604
605	for (i = 0; i < num_configs; i++) {
606		param = pinconf_to_config_param(configs[i]);
607		arg = pinconf_to_config_argument(configs[i]);
608		ret = k210_pinconf_set_param(pctldev, pin, param, arg);
609		if (ret)
610			return ret;
611	}
612
613	return 0;
614}
615
616static void k210_pinconf_dbg_show(struct pinctrl_dev *pctldev,
617				  struct seq_file *s, unsigned int pin)
618{
619	struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
620
621	seq_printf(s, "%#x", readl(&pdata->fpioa->pins[pin]));
622}
623
624static int k210_pinconf_group_set(struct pinctrl_dev *pctldev,
625				  unsigned int selector, unsigned long *configs,
626				  unsigned int num_configs)
627{
628	struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
629	unsigned int param, arg;
630	u32 bit;
631	int i;
632
633	/* Pins should be configured with pinmux, not groups*/
634	if (selector < K210_NPINS)
635		return -EINVAL;
636
637	/* Otherwise it's a power domain */
638	for (i = 0; i < num_configs; i++) {
639		param = pinconf_to_config_param(configs[i]);
640		if (param != PIN_CONFIG_POWER_SOURCE)
641			return -EINVAL;
642
643		arg = pinconf_to_config_argument(configs[i]);
644		bit = BIT(selector - K210_NPINS);
645		regmap_update_bits(pdata->sysctl_map,
646				   pdata->power_offset,
647				   bit, arg ? bit : 0);
648	}
649
650	return 0;
651}
652
653static void k210_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
654					struct seq_file *s,
655					unsigned int selector)
656{
657	struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
658	int ret;
659	u32 val;
660
661	if (selector < K210_NPINS)
662		return k210_pinconf_dbg_show(pctldev, s, selector);
663
664	ret = regmap_read(pdata->sysctl_map, pdata->power_offset, &val);
665	if (ret) {
666		dev_err(pdata->dev, "Failed to read power reg\n");
667		return;
668	}
669
670	seq_printf(s, "%s: %s V", k210_group_names[selector],
671		   val & BIT(selector - K210_NPINS) ? "1.8" : "3.3");
672}
673
674static const struct pinconf_ops k210_pinconf_ops = {
675	.is_generic = true,
676	.pin_config_set = k210_pinconf_set,
677	.pin_config_group_set = k210_pinconf_group_set,
678	.pin_config_dbg_show = k210_pinconf_dbg_show,
679	.pin_config_group_dbg_show = k210_pinconf_group_dbg_show,
680};
681
682static int k210_pinmux_get_function_count(struct pinctrl_dev *pctldev)
683{
684	return ARRAY_SIZE(k210_pcf_infos);
685}
686
687static const char *k210_pinmux_get_function_name(struct pinctrl_dev *pctldev,
688						 unsigned int selector)
689{
690	return k210_pcf_infos[selector].name;
691}
692
693static int k210_pinmux_get_function_groups(struct pinctrl_dev *pctldev,
694					   unsigned int selector,
695					   const char * const **groups,
696					   unsigned int * const num_groups)
697{
698	/* Any function can be mapped to any pin */
699	*groups = k210_group_names;
700	*num_groups = K210_NPINS;
701
702	return 0;
703}
704
705static int k210_pinmux_set_mux(struct pinctrl_dev *pctldev,
706			       unsigned int function,
707			       unsigned int group)
708{
709	/* Can't mux power domains */
710	if (group >= K210_NPINS)
711		return -EINVAL;
712
713	k210_pinmux_set_pin_function(pctldev, group, function);
714
715	return 0;
716}
717
718static const struct pinmux_ops k210_pinmux_ops = {
719	.get_functions_count = k210_pinmux_get_function_count,
720	.get_function_name = k210_pinmux_get_function_name,
721	.get_function_groups = k210_pinmux_get_function_groups,
722	.set_mux = k210_pinmux_set_mux,
723	.strict = true,
724};
725
726static int k210_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
727{
728	return K210_NGROUPS;
729}
730
731static const char *k210_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
732					       unsigned int group)
733{
734	return k210_group_names[group];
735}
736
737static int k210_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
738				       unsigned int group,
739				       const unsigned int **pins,
740				       unsigned int *npins)
741{
742	if (group >= K210_NPINS) {
743		*pins = NULL;
744		*npins = 0;
745		return 0;
746	}
747
748	*pins = &k210_pins[group].number;
749	*npins = 1;
750
751	return 0;
752}
753
754static void k210_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
755				      struct seq_file *s, unsigned int offset)
756{
757	seq_printf(s, "%s", dev_name(pctldev->dev));
758}
759
760static int k210_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
761					  struct device_node *np,
762					  struct pinctrl_map **map,
763					  unsigned int *reserved_maps,
764					  unsigned int *num_maps)
765{
766	struct property *prop;
767	const __be32 *p;
768	int ret, pinmux_groups;
769	u32 pinmux_group;
770	unsigned long *configs = NULL;
771	unsigned int num_configs = 0;
772	unsigned int reserve = 0;
773
774	ret = of_property_count_strings(np, "groups");
775	if (!ret)
776		return pinconf_generic_dt_subnode_to_map(pctldev, np, map,
777						reserved_maps, num_maps,
778						PIN_MAP_TYPE_CONFIGS_GROUP);
779
780	pinmux_groups = of_property_count_u32_elems(np, "pinmux");
781	if (pinmux_groups <= 0) {
782		/* Ignore this node */
783		return 0;
784	}
785
786	ret = pinconf_generic_parse_dt_config(np, pctldev, &configs,
787					      &num_configs);
788	if (ret < 0) {
789		dev_err(pctldev->dev, "%pOF: could not parse node property\n",
790			np);
791		return ret;
792	}
793
794	reserve = pinmux_groups * (1 + num_configs);
795	ret = pinctrl_utils_reserve_map(pctldev, map, reserved_maps, num_maps,
796					reserve);
797	if (ret < 0)
798		goto exit;
799
800	of_property_for_each_u32(np, "pinmux", prop, p, pinmux_group) {
801		const char *group_name, *func_name;
802		u32 pin = FIELD_GET(K210_PG_PIN, pinmux_group);
803		u32 func = FIELD_GET(K210_PG_FUNC, pinmux_group);
804
805		if (pin >= K210_NPINS) {
806			ret = -EINVAL;
807			goto exit;
808		}
809
810		group_name = k210_group_names[pin];
811		func_name = k210_pcf_infos[func].name;
812
813		dev_dbg(pctldev->dev, "Pinmux %s: pin %u func %s\n",
814			np->name, pin, func_name);
815
816		ret = pinctrl_utils_add_map_mux(pctldev, map, reserved_maps,
817						num_maps, group_name,
818						func_name);
819		if (ret < 0) {
820			dev_err(pctldev->dev, "%pOF add mux map failed %d\n",
821				np, ret);
822			goto exit;
823		}
824
825		if (num_configs) {
826			ret = pinctrl_utils_add_map_configs(pctldev, map,
827					reserved_maps, num_maps, group_name,
828					configs, num_configs,
829					PIN_MAP_TYPE_CONFIGS_PIN);
830			if (ret < 0) {
831				dev_err(pctldev->dev,
832					"%pOF add configs map failed %d\n",
833					np, ret);
834				goto exit;
835			}
836		}
837	}
838
839	ret = 0;
840
841exit:
842	kfree(configs);
843	return ret;
844}
845
846static int k210_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,
847				       struct device_node *np_config,
848				       struct pinctrl_map **map,
849				       unsigned int *num_maps)
850{
851	unsigned int reserved_maps;
852	struct device_node *np;
853	int ret;
854
855	reserved_maps = 0;
856	*map = NULL;
857	*num_maps = 0;
858
859	ret = k210_pinctrl_dt_subnode_to_map(pctldev, np_config, map,
860					     &reserved_maps, num_maps);
861	if (ret < 0)
862		goto err;
863
864	for_each_available_child_of_node(np_config, np) {
865		ret = k210_pinctrl_dt_subnode_to_map(pctldev, np, map,
866						     &reserved_maps, num_maps);
867		if (ret < 0) {
868			of_node_put(np);
869			goto err;
870		}
871	}
872	return 0;
873
874err:
875	pinctrl_utils_free_map(pctldev, *map, *num_maps);
876	return ret;
877}
878
879
880static const struct pinctrl_ops k210_pinctrl_ops = {
881	.get_groups_count = k210_pinctrl_get_groups_count,
882	.get_group_name = k210_pinctrl_get_group_name,
883	.get_group_pins = k210_pinctrl_get_group_pins,
884	.pin_dbg_show = k210_pinctrl_pin_dbg_show,
885	.dt_node_to_map = k210_pinctrl_dt_node_to_map,
886	.dt_free_map = pinconf_generic_dt_free_map,
887};
888
889static struct pinctrl_desc k210_pinctrl_desc = {
890	.name = "k210-pinctrl",
891	.pins = k210_pins,
892	.npins = K210_NPINS,
893	.pctlops = &k210_pinctrl_ops,
894	.pmxops = &k210_pinmux_ops,
895	.confops = &k210_pinconf_ops,
896	.custom_params = k210_pinconf_custom_params,
897	.num_custom_params = ARRAY_SIZE(k210_pinconf_custom_params),
898};
899
900static void k210_fpioa_init_ties(struct k210_fpioa_data *pdata)
901{
902	struct k210_fpioa __iomem *fpioa = pdata->fpioa;
903	u32 val;
904	int i, j;
905
906	dev_dbg(pdata->dev, "Init pin ties\n");
907
908	/* Init pin functions input ties */
909	for (i = 0; i < ARRAY_SIZE(fpioa->tie_en); i++) {
910		val = 0;
911		for (j = 0; j < 32; j++) {
912			if (k210_pcf_infos[i * 32 + j].mode_id ==
913			    K210_PC_DEFAULT_IN_TIE) {
914				dev_dbg(pdata->dev,
915					"tie_en function %d (%s)\n",
916					i * 32 + j,
917					k210_pcf_infos[i * 32 + j].name);
918				val |= BIT(j);
919			}
920		}
921
922		/* Set value before enable */
923		writel(val, &fpioa->tie_val[i]);
924		writel(val, &fpioa->tie_en[i]);
925	}
926}
927
928static int k210_fpioa_probe(struct platform_device *pdev)
929{
930	struct device *dev = &pdev->dev;
931	struct device_node *np = dev->of_node;
932	struct k210_fpioa_data *pdata;
933	int ret;
934
935	dev_info(dev, "K210 FPIOA pin controller\n");
936
937	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
938	if (!pdata)
939		return -ENOMEM;
940
941	pdata->dev = dev;
942	platform_set_drvdata(pdev, pdata);
943
944	pdata->fpioa = devm_platform_ioremap_resource(pdev, 0);
945	if (IS_ERR(pdata->fpioa))
946		return PTR_ERR(pdata->fpioa);
947
948	pdata->clk = devm_clk_get(dev, "ref");
949	if (IS_ERR(pdata->clk))
950		return PTR_ERR(pdata->clk);
951
952	ret = clk_prepare_enable(pdata->clk);
953	if (ret)
954		return ret;
955
956	pdata->pclk = devm_clk_get_optional(dev, "pclk");
957	if (!IS_ERR(pdata->pclk)) {
958		ret = clk_prepare_enable(pdata->pclk);
959		if (ret)
960			goto disable_clk;
961	}
962
963	pdata->sysctl_map =
964		syscon_regmap_lookup_by_phandle_args(np,
965						"canaan,k210-sysctl-power",
966						1, &pdata->power_offset);
967	if (IS_ERR(pdata->sysctl_map)) {
968		ret = PTR_ERR(pdata->sysctl_map);
969		goto disable_pclk;
970	}
971
972	k210_fpioa_init_ties(pdata);
973
974	pdata->pctl = pinctrl_register(&k210_pinctrl_desc, dev, (void *)pdata);
975	if (IS_ERR(pdata->pctl)) {
976		ret = PTR_ERR(pdata->pctl);
977		goto disable_pclk;
978	}
979
980	return 0;
981
982disable_pclk:
983	clk_disable_unprepare(pdata->pclk);
984disable_clk:
985	clk_disable_unprepare(pdata->clk);
986
987	return ret;
988}
989
990static const struct of_device_id k210_fpioa_dt_ids[] = {
991	{ .compatible = "canaan,k210-fpioa" },
992	{ /* sentinel */ },
993};
994
995static struct platform_driver k210_fpioa_driver = {
996	.probe	= k210_fpioa_probe,
997	.driver = {
998		.name		= "k210-fpioa",
999		.of_match_table	= k210_fpioa_dt_ids,
1000	},
1001};
1002builtin_platform_driver(k210_fpioa_driver);
1003