1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2020 Sean Anderson <seanga2@gmail.com>
9 #include <dm/pinctrl.h>
10 #include <dt-bindings/pinctrl/k210-pinctrl.h>
15 #include <linux/err.h>
16 #include <linux/bitfield.h>
17 #include <linux/bitops.h>
20 * The K210 only implements 8 drive levels, even though there is register space
23 #define K210_PC_DRIVE_MASK GENMASK(11, 8)
24 #define K210_PC_DRIVE_SHIFT 8
25 #define K210_PC_DRIVE_0 (0 << K210_PC_DRIVE_SHIFT)
26 #define K210_PC_DRIVE_1 (1 << K210_PC_DRIVE_SHIFT)
27 #define K210_PC_DRIVE_2 (2 << K210_PC_DRIVE_SHIFT)
28 #define K210_PC_DRIVE_3 (3 << K210_PC_DRIVE_SHIFT)
29 #define K210_PC_DRIVE_4 (4 << K210_PC_DRIVE_SHIFT)
30 #define K210_PC_DRIVE_5 (5 << K210_PC_DRIVE_SHIFT)
31 #define K210_PC_DRIVE_6 (6 << K210_PC_DRIVE_SHIFT)
32 #define K210_PC_DRIVE_7 (7 << K210_PC_DRIVE_SHIFT)
33 #define K210_PC_DRIVE_MAX 7
35 #define K210_PC_MODE_MASK GENMASK(23, 12)
37 * output enabled == PC_OE & (PC_OE_INV ^ FUNCTION_OE) where FUNCTION_OE is a
38 * physical signal from the function
40 #define K210_PC_OE BIT(12) /* Output Enable */
41 #define K210_PC_OE_INV BIT(13) /* INVert function-controlled Output Enable */
42 #define K210_PC_DO_OE BIT(14) /* set Data Out to the Output Enable signal */
43 #define K210_PC_DO_INV BIT(15) /* INVert final Data Output */
44 #define K210_PC_PU BIT(16) /* Pull Up */
45 #define K210_PC_PD BIT(17) /* Pull Down */
46 /* Strong pull up not implemented on K210 */
47 #define K210_PC_SL BIT(19) /* reduce SLew rate to prevent overshoot */
48 /* Same semantics as OE above */
49 #define K210_PC_IE BIT(20) /* Input Enable */
50 #define K210_PC_IE_INV BIT(21) /* INVert function-controlled Input Enable */
51 #define K210_PC_DI_INV BIT(22) /* INVert Data Input */
52 #define K210_PC_ST BIT(23) /* Schmitt Trigger */
53 #define K210_PC_DI BIT(31) /* raw Data Input */
54 #define K210_PC_BIAS_MASK (K210_PC_PU & K210_PC_PD)
56 #define K210_PC_MODE_IN (K210_PC_IE | K210_PC_ST)
57 #define K210_PC_MODE_OUT (K210_PC_DRIVE_7 | K210_PC_OE)
58 #define K210_PC_MODE_I2C (K210_PC_MODE_IN | K210_PC_SL | K210_PC_OE | \
60 #define K210_PC_MODE_SCCB (K210_PC_MODE_I2C | K210_PC_OE_INV | K210_PC_IE_INV)
61 #define K210_PC_MODE_SPI (K210_PC_MODE_IN | K210_PC_IE_INV | \
62 K210_PC_MODE_OUT | K210_PC_OE_INV)
63 #define K210_PC_MODE_GPIO (K210_PC_MODE_IN | K210_PC_MODE_OUT)
65 #define K210_PG_FUNC GENMASK(7, 0)
66 #define K210_PG_DO BIT(8)
67 #define K210_PG_PIN GENMASK(22, 16)
69 #define PIN_CONFIG_OUTPUT_INVERT (PIN_CONFIG_END + 1)
70 #define PIN_CONFIG_INPUT_INVERT (PIN_CONFIG_END + 2)
80 struct k210_fpioa __iomem *fpioa; /* FPIOA register */
81 struct regmap *sysctl; /* Sysctl regmap */
82 u32 power_offset; /* Power bank register offset */
85 #ifdef CONFIG_CMD_PINMUX
86 static const char k210_pc_pin_names[][6] = {
140 static int k210_pc_get_pins_count(struct udevice *dev)
142 return ARRAY_SIZE(k210_pc_pin_names);
145 static const char *k210_pc_get_pin_name(struct udevice *dev, unsigned selector)
147 return k210_pc_pin_names[selector];
149 #endif /* CONFIG_CMD_PINMUX */
151 /* These are just power domains */
152 static const char k210_pc_group_names[][3] = {
163 static int k210_pc_get_groups_count(struct udevice *dev)
165 return ARRAY_SIZE(k210_pc_group_names);
168 static const char *k210_pc_get_group_name(struct udevice *dev,
171 return k210_pc_group_names[selector];
174 enum k210_pc_mode_id {
175 K210_PC_DEFAULT_DISABLED,
177 K210_PC_DEFAULT_IN_TIE,
180 K210_PC_DEFAULT_SCCB,
182 K210_PC_DEFAULT_GPIO,
183 K210_PC_DEFAULT_INT13,
186 static const u32 k210_pc_mode_id_to_mode[] = {
187 #define DEFAULT(mode) \
188 [K210_PC_DEFAULT_##mode] = K210_PC_MODE_##mode
189 [K210_PC_DEFAULT_DISABLED] = 0,
191 [K210_PC_DEFAULT_IN_TIE] = K210_PC_MODE_IN,
197 [K210_PC_DEFAULT_INT13] = K210_PC_MODE_IN | K210_PC_PU,
201 /* This saves around 2K vs having a pointer+mode */
202 struct k210_pcf_info {
203 #ifdef CONFIG_CMD_PINMUX
209 static const struct k210_pcf_info k210_pcf_infos[] = {
210 #ifdef CONFIG_CMD_PINMUX
211 #define FUNC(id, mode) \
212 [K210_PCF_##id] = { \
214 .mode_id = K210_PC_DEFAULT_##mode \
217 #define FUNC(id, mode) \
218 [K210_PCF_##id] = { \
219 .mode_id = K210_PC_DEFAULT_##mode \
238 FUNC(SPI0_ARB, IN_TIE),
239 FUNC(SPI0_SCLK, OUT),
241 FUNC(UARTHS_TX, OUT),
256 FUNC(GPIOHS10, GPIO),
257 FUNC(GPIOHS11, GPIO),
258 FUNC(GPIOHS12, GPIO),
259 FUNC(GPIOHS13, GPIO),
260 FUNC(GPIOHS14, GPIO),
261 FUNC(GPIOHS15, GPIO),
262 FUNC(GPIOHS16, GPIO),
263 FUNC(GPIOHS17, GPIO),
264 FUNC(GPIOHS18, GPIO),
265 FUNC(GPIOHS19, GPIO),
266 FUNC(GPIOHS20, GPIO),
267 FUNC(GPIOHS21, GPIO),
268 FUNC(GPIOHS22, GPIO),
269 FUNC(GPIOHS23, GPIO),
270 FUNC(GPIOHS24, GPIO),
271 FUNC(GPIOHS25, GPIO),
272 FUNC(GPIOHS26, GPIO),
273 FUNC(GPIOHS27, GPIO),
274 FUNC(GPIOHS28, GPIO),
275 FUNC(GPIOHS29, GPIO),
276 FUNC(GPIOHS30, GPIO),
277 FUNC(GPIOHS31, GPIO),
304 FUNC(SPI1_ARB, IN_TIE),
305 FUNC(SPI1_SCLK, OUT),
309 FUNC(I2S0_MCLK, OUT),
310 FUNC(I2S0_SCLK, OUT),
312 FUNC(I2S0_IN_D0, IN),
313 FUNC(I2S0_IN_D1, IN),
314 FUNC(I2S0_IN_D2, IN),
315 FUNC(I2S0_IN_D3, IN),
316 FUNC(I2S0_OUT_D0, OUT),
317 FUNC(I2S0_OUT_D1, OUT),
318 FUNC(I2S0_OUT_D2, OUT),
319 FUNC(I2S0_OUT_D3, OUT),
320 FUNC(I2S1_MCLK, OUT),
321 FUNC(I2S1_SCLK, OUT),
323 FUNC(I2S1_IN_D0, IN),
324 FUNC(I2S1_IN_D1, IN),
325 FUNC(I2S1_IN_D2, IN),
326 FUNC(I2S1_IN_D3, IN),
327 FUNC(I2S1_OUT_D0, OUT),
328 FUNC(I2S1_OUT_D1, OUT),
329 FUNC(I2S1_OUT_D2, OUT),
330 FUNC(I2S1_OUT_D3, OUT),
331 FUNC(I2S2_MCLK, OUT),
332 FUNC(I2S2_SCLK, OUT),
334 FUNC(I2S2_IN_D0, IN),
335 FUNC(I2S2_IN_D1, IN),
336 FUNC(I2S2_IN_D2, IN),
337 FUNC(I2S2_IN_D3, IN),
338 FUNC(I2S2_OUT_D0, OUT),
339 FUNC(I2S2_OUT_D1, OUT),
340 FUNC(I2S2_OUT_D2, OUT),
341 FUNC(I2S2_OUT_D3, OUT),
342 FUNC(RESV0, DISABLED),
343 FUNC(RESV1, DISABLED),
344 FUNC(RESV2, DISABLED),
345 FUNC(RESV3, DISABLED),
346 FUNC(RESV4, DISABLED),
347 FUNC(RESV5, DISABLED),
348 FUNC(I2C0_SCLK, I2C),
350 FUNC(I2C1_SCLK, I2C),
352 FUNC(I2C2_SCLK, I2C),
368 FUNC(SCCB_SCLK, SCCB),
369 FUNC(SCCB_SDA, SCCB),
374 FUNC(UART1_SIR_IN, IN),
375 FUNC(UART1_DTR, OUT),
376 FUNC(UART1_RTS, OUT),
377 FUNC(UART1_OUT2, OUT),
378 FUNC(UART1_OUT1, OUT),
379 FUNC(UART1_SIR_OUT, OUT),
380 FUNC(UART1_BAUD, OUT),
383 FUNC(UART1_RS485_EN, OUT),
388 FUNC(UART2_SIR_IN, IN),
389 FUNC(UART2_DTR, OUT),
390 FUNC(UART2_RTS, OUT),
391 FUNC(UART2_OUT2, OUT),
392 FUNC(UART2_OUT1, OUT),
393 FUNC(UART2_SIR_OUT, OUT),
394 FUNC(UART2_BAUD, OUT),
397 FUNC(UART2_RS485_EN, OUT),
402 FUNC(UART3_SIR_IN, IN),
403 FUNC(UART3_DTR, OUT),
404 FUNC(UART3_RTS, OUT),
405 FUNC(UART3_OUT2, OUT),
406 FUNC(UART3_OUT1, OUT),
407 FUNC(UART3_SIR_OUT, OUT),
408 FUNC(UART3_BAUD, OUT),
411 FUNC(UART3_RS485_EN, OUT),
412 FUNC(TIMER0_TOGGLE1, OUT),
413 FUNC(TIMER0_TOGGLE2, OUT),
414 FUNC(TIMER0_TOGGLE3, OUT),
415 FUNC(TIMER0_TOGGLE4, OUT),
416 FUNC(TIMER1_TOGGLE1, OUT),
417 FUNC(TIMER1_TOGGLE2, OUT),
418 FUNC(TIMER1_TOGGLE3, OUT),
419 FUNC(TIMER1_TOGGLE4, OUT),
420 FUNC(TIMER2_TOGGLE1, OUT),
421 FUNC(TIMER2_TOGGLE2, OUT),
422 FUNC(TIMER2_TOGGLE3, OUT),
423 FUNC(TIMER2_TOGGLE4, OUT),
426 FUNC(INTERNAL0, OUT),
427 FUNC(INTERNAL1, OUT),
428 FUNC(INTERNAL2, OUT),
429 FUNC(INTERNAL3, OUT),
430 FUNC(INTERNAL4, OUT),
431 FUNC(INTERNAL5, OUT),
432 FUNC(INTERNAL6, OUT),
433 FUNC(INTERNAL7, OUT),
434 FUNC(INTERNAL8, OUT),
436 FUNC(INTERNAL10, IN),
437 FUNC(INTERNAL11, IN),
438 FUNC(INTERNAL12, IN),
439 FUNC(INTERNAL13, INT13),
440 FUNC(INTERNAL14, I2C),
441 FUNC(INTERNAL15, IN),
442 FUNC(INTERNAL16, IN),
443 FUNC(INTERNAL17, IN),
444 FUNC(CONSTANT, DISABLED),
445 FUNC(INTERNAL18, IN),
481 static int k210_pc_pinmux_set(struct udevice *dev, u32 pinmux_group)
483 unsigned pin = FIELD_GET(K210_PG_PIN, pinmux_group);
484 bool do_oe = FIELD_GET(K210_PG_DO, pinmux_group);
485 unsigned func = FIELD_GET(K210_PG_FUNC, pinmux_group);
486 struct k210_pc_priv *priv = dev_get_priv(dev);
487 const struct k210_pcf_info *info = &k210_pcf_infos[func];
488 u32 mode = k210_pc_mode_id_to_mode[info->mode_id];
489 u32 val = func | mode | (do_oe ? K210_PC_DO_OE : 0);
491 debug("%s(%.8x): IO_%.2u = %3u | %.8x\n", __func__, pinmux_group, pin,
494 writel(val, &priv->fpioa->pins[pin]);
498 /* Max drive strength in uA */
499 static const int k210_pc_drive_strength[] = {
510 static int k210_pc_get_drive(unsigned max_strength_ua)
514 for (i = K210_PC_DRIVE_MAX; i; i--)
515 if (k210_pc_drive_strength[i] < max_strength_ua)
521 static int k210_pc_pinconf_set(struct udevice *dev, unsigned pin_selector,
522 unsigned param, unsigned argument)
524 struct k210_pc_priv *priv = dev_get_priv(dev);
525 u32 val = readl(&priv->fpioa->pins[pin_selector]);
528 case PIN_CONFIG_BIAS_DISABLE:
529 val &= ~K210_PC_BIAS_MASK;
531 case PIN_CONFIG_BIAS_PULL_DOWN:
537 case PIN_CONFIG_BIAS_PULL_UP:
543 case PIN_CONFIG_DRIVE_STRENGTH:
545 case PIN_CONFIG_DRIVE_STRENGTH_UA: {
546 int drive = k210_pc_get_drive(argument);
548 if (IS_ERR_VALUE(drive))
550 val &= ~K210_PC_DRIVE_MASK;
551 val |= FIELD_PREP(K210_PC_DRIVE_MASK, drive);
554 case PIN_CONFIG_INPUT_ENABLE:
560 case PIN_CONFIG_INPUT_SCHMITT:
562 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
568 case PIN_CONFIG_OUTPUT:
569 k210_pc_pinmux_set(dev,
570 K210_FPIOA(pin_selector, K210_PCF_CONSTANT));
571 val = readl(&priv->fpioa->pins[pin_selector]);
572 val |= K210_PC_MODE_OUT;
575 val |= K210_PC_DO_INV;
577 case PIN_CONFIG_OUTPUT_ENABLE:
583 case PIN_CONFIG_SLEW_RATE:
589 case PIN_CONFIG_OUTPUT_INVERT:
591 val |= K210_PC_DO_INV;
593 val &= ~K210_PC_DO_INV;
595 case PIN_CONFIG_INPUT_INVERT:
597 val |= K210_PC_DI_INV;
599 val &= ~K210_PC_DI_INV;
605 writel(val, &priv->fpioa->pins[pin_selector]);
609 static int k210_pc_pinconf_group_set(struct udevice *dev,
610 unsigned group_selector, unsigned param,
613 struct k210_pc_priv *priv = dev_get_priv(dev);
615 if (param == PIN_CONFIG_POWER_SOURCE) {
616 u32 bit = BIT(group_selector);
618 regmap_update_bits(priv->sysctl, priv->power_offset, bit,
627 #ifdef CONFIG_CMD_PINMUX
628 static int k210_pc_get_pin_muxing(struct udevice *dev, unsigned int selector,
631 struct k210_pc_priv *priv = dev_get_priv(dev);
632 u32 val = readl(&priv->fpioa->pins[selector]);
633 const struct k210_pcf_info *info = &k210_pcf_infos[val & K210_PCF_MASK];
635 strncpy(buf, info->name, min((size_t)size, sizeof(info->name)));
640 static const struct pinconf_param k210_pc_pinconf_params[] = {
641 { "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 },
642 { "bias-pull-down", PIN_CONFIG_BIAS_PULL_DOWN, 1 },
643 { "bias-pull-up", PIN_CONFIG_BIAS_PULL_UP, 1 },
644 { "drive-strength", PIN_CONFIG_DRIVE_STRENGTH, U32_MAX },
645 { "drive-strength-ua", PIN_CONFIG_DRIVE_STRENGTH_UA, U32_MAX },
646 { "input-enable", PIN_CONFIG_INPUT_ENABLE, 1 },
647 { "input-disable", PIN_CONFIG_INPUT_ENABLE, 0 },
648 { "input-schmitt-enable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 1 },
649 { "input-schmitt-disable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 0 },
650 { "power-source", PIN_CONFIG_POWER_SOURCE, K210_PC_POWER_1V8 },
651 { "output-low", PIN_CONFIG_OUTPUT, 0 },
652 { "output-high", PIN_CONFIG_OUTPUT, 1 },
653 { "output-enable", PIN_CONFIG_OUTPUT_ENABLE, 1 },
654 { "output-disable", PIN_CONFIG_OUTPUT_ENABLE, 0 },
655 { "slew-rate", PIN_CONFIG_SLEW_RATE, 1 },
656 { "output-polarity-invert", PIN_CONFIG_OUTPUT_INVERT, 1},
657 { "input-polarity-invert", PIN_CONFIG_INPUT_INVERT, 1},
660 static const struct pinctrl_ops k210_pc_pinctrl_ops = {
661 #ifdef CONFIG_CMD_PINMUX
662 .get_pins_count = k210_pc_get_pins_count,
663 .get_pin_name = k210_pc_get_pin_name,
665 .get_groups_count = k210_pc_get_groups_count,
666 .get_group_name = k210_pc_get_group_name,
667 .pinmux_property_set = k210_pc_pinmux_set,
668 .pinconf_num_params = ARRAY_SIZE(k210_pc_pinconf_params),
669 .pinconf_params = k210_pc_pinconf_params,
670 .pinconf_set = k210_pc_pinconf_set,
671 .pinconf_group_set = k210_pc_pinconf_group_set,
672 .set_state = pinctrl_generic_set_state,
673 #ifdef CONFIG_CMD_PINMUX
674 .get_pin_muxing = k210_pc_get_pin_muxing,
678 static int k210_pc_probe(struct udevice *dev)
681 struct k210_pc_priv *priv = dev_get_priv(dev);
683 priv->fpioa = dev_read_addr_ptr(dev);
687 ret = clk_get_by_index(dev, 0, &priv->clk);
691 ret = clk_enable(&priv->clk);
692 if (ret && ret != -ENOSYS && ret != -ENOTSUPP)
695 priv->sysctl = syscon_regmap_lookup_by_phandle(dev, "kendryte,sysctl");
696 if (IS_ERR(priv->sysctl)) {
701 ret = dev_read_u32(dev, "kendryte,power-offset", &priv->power_offset);
705 debug("%s: fpioa = %p sysctl = %p power offset = %x\n", __func__,
706 priv->fpioa, (void *)priv->sysctl->ranges[0].start,
709 /* Init input ties */
710 for (i = 0; i < ARRAY_SIZE(priv->fpioa->tie_en); i++) {
713 for (j = 0; j < 32; j++)
714 if (k210_pcf_infos[i * 32 + j].mode_id ==
715 K210_PC_DEFAULT_IN_TIE)
717 writel(val, &priv->fpioa->tie_en[i]);
718 writel(val, &priv->fpioa->tie_val[i]);
724 clk_free(&priv->clk);
728 static const struct udevice_id k210_pc_ids[] = {
729 { .compatible = "kendryte,k210-fpioa" },
733 U_BOOT_DRIVER(pinctrl_k210) = {
734 .name = "pinctrl_k210",
735 .id = UCLASS_PINCTRL,
736 .of_match = k210_pc_ids,
737 .probe = k210_pc_probe,
738 .priv_auto = sizeof(struct k210_pc_priv),
739 .ops = &k210_pc_pinctrl_ops,