]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/pinctrl/pinctrl-k210.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
scsi: iscsi: Fix conn cleanup and stop race during iscsid restart
[mirror_ubuntu-jammy-kernel.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 >= 0; 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_PU;
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);
Ubuntu Jammy Linux kernel mirror