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