mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-06-09 23:36:03 +09:00
41575d8e4c
This construct is quite long-winded. In earlier days it made some sense since auto-allocation was a strange concept. But with driver model now used pretty universally, we can shorten this to 'auto'. This reduces verbosity and makes it easier to read. Coincidentally it also ensures that every declaration is on one line, thus making dtoc's job easier. Signed-off-by: Simon Glass <sjg@chromium.org>
741 lines
19 KiB
C
741 lines
19 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (C) 2020 Sean Anderson <seanga2@gmail.com>
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <clk.h>
|
|
#include <dm.h>
|
|
#include <dm/pinctrl.h>
|
|
#include <dt-bindings/pinctrl/k210-pinctrl.h>
|
|
#include <mapmem.h>
|
|
#include <regmap.h>
|
|
#include <syscon.h>
|
|
#include <asm/io.h>
|
|
#include <linux/err.h>
|
|
#include <linux/bitfield.h>
|
|
#include <linux/bitops.h>
|
|
|
|
/*
|
|
* The K210 only implements 8 drive levels, even though there is register space
|
|
* for 16
|
|
*/
|
|
#define K210_PC_DRIVE_MASK GENMASK(11, 8)
|
|
#define K210_PC_DRIVE_SHIFT 8
|
|
#define K210_PC_DRIVE_0 (0 << K210_PC_DRIVE_SHIFT)
|
|
#define K210_PC_DRIVE_1 (1 << K210_PC_DRIVE_SHIFT)
|
|
#define K210_PC_DRIVE_2 (2 << K210_PC_DRIVE_SHIFT)
|
|
#define K210_PC_DRIVE_3 (3 << K210_PC_DRIVE_SHIFT)
|
|
#define K210_PC_DRIVE_4 (4 << K210_PC_DRIVE_SHIFT)
|
|
#define K210_PC_DRIVE_5 (5 << K210_PC_DRIVE_SHIFT)
|
|
#define K210_PC_DRIVE_6 (6 << K210_PC_DRIVE_SHIFT)
|
|
#define K210_PC_DRIVE_7 (7 << K210_PC_DRIVE_SHIFT)
|
|
#define K210_PC_DRIVE_MAX 7
|
|
|
|
#define K210_PC_MODE_MASK GENMASK(23, 12)
|
|
/*
|
|
* output enabled == PC_OE & (PC_OE_INV ^ FUNCTION_OE) where FUNCTION_OE is a
|
|
* physical signal from the function
|
|
*/
|
|
#define K210_PC_OE BIT(12) /* Output Enable */
|
|
#define K210_PC_OE_INV BIT(13) /* INVert function-controlled Output Enable */
|
|
#define K210_PC_DO_OE BIT(14) /* set Data Out to the Output Enable signal */
|
|
#define K210_PC_DO_INV BIT(15) /* INVert final Data Output */
|
|
#define K210_PC_PU BIT(16) /* Pull Up */
|
|
#define K210_PC_PD BIT(17) /* Pull Down */
|
|
/* Strong pull up not implemented on K210 */
|
|
#define K210_PC_SL BIT(19) /* reduce SLew rate to prevent overshoot */
|
|
/* Same semantics as OE above */
|
|
#define K210_PC_IE BIT(20) /* Input Enable */
|
|
#define K210_PC_IE_INV BIT(21) /* INVert function-controlled Input Enable */
|
|
#define K210_PC_DI_INV BIT(22) /* INVert Data Input */
|
|
#define K210_PC_ST BIT(23) /* Schmitt Trigger */
|
|
#define K210_PC_DI BIT(31) /* raw Data Input */
|
|
#define K210_PC_BIAS_MASK (K210_PC_PU & K210_PC_PD)
|
|
|
|
#define K210_PC_MODE_IN (K210_PC_IE | K210_PC_ST)
|
|
#define K210_PC_MODE_OUT (K210_PC_DRIVE_7 | K210_PC_OE)
|
|
#define K210_PC_MODE_I2C (K210_PC_MODE_IN | K210_PC_SL | K210_PC_OE | \
|
|
K210_PC_PU)
|
|
#define K210_PC_MODE_SCCB (K210_PC_MODE_I2C | K210_PC_OE_INV | K210_PC_IE_INV)
|
|
#define K210_PC_MODE_SPI (K210_PC_MODE_IN | K210_PC_IE_INV | \
|
|
K210_PC_MODE_OUT | K210_PC_OE_INV)
|
|
#define K210_PC_MODE_GPIO (K210_PC_MODE_IN | K210_PC_MODE_OUT)
|
|
|
|
#define K210_PG_FUNC GENMASK(7, 0)
|
|
#define K210_PG_DO BIT(8)
|
|
#define K210_PG_PIN GENMASK(22, 16)
|
|
|
|
#define PIN_CONFIG_OUTPUT_INVERT (PIN_CONFIG_END + 1)
|
|
#define PIN_CONFIG_INPUT_INVERT (PIN_CONFIG_END + 2)
|
|
|
|
struct k210_fpioa {
|
|
u32 pins[48];
|
|
u32 tie_en[8];
|
|
u32 tie_val[8];
|
|
};
|
|
|
|
struct k210_pc_priv {
|
|
struct clk clk;
|
|
struct k210_fpioa __iomem *fpioa; /* FPIOA register */
|
|
struct regmap *sysctl; /* Sysctl regmap */
|
|
u32 power_offset; /* Power bank register offset */
|
|
};
|
|
|
|
#ifdef CONFIG_CMD_PINMUX
|
|
static const char k210_pc_pin_names[][6] = {
|
|
#define PIN(i) \
|
|
[i] = "IO_" #i
|
|
PIN(0),
|
|
PIN(1),
|
|
PIN(2),
|
|
PIN(3),
|
|
PIN(4),
|
|
PIN(5),
|
|
PIN(6),
|
|
PIN(7),
|
|
PIN(8),
|
|
PIN(9),
|
|
PIN(10),
|
|
PIN(11),
|
|
PIN(12),
|
|
PIN(13),
|
|
PIN(14),
|
|
PIN(15),
|
|
PIN(16),
|
|
PIN(17),
|
|
PIN(18),
|
|
PIN(19),
|
|
PIN(20),
|
|
PIN(21),
|
|
PIN(22),
|
|
PIN(23),
|
|
PIN(24),
|
|
PIN(25),
|
|
PIN(26),
|
|
PIN(27),
|
|
PIN(28),
|
|
PIN(29),
|
|
PIN(30),
|
|
PIN(31),
|
|
PIN(32),
|
|
PIN(33),
|
|
PIN(34),
|
|
PIN(35),
|
|
PIN(36),
|
|
PIN(37),
|
|
PIN(38),
|
|
PIN(39),
|
|
PIN(40),
|
|
PIN(41),
|
|
PIN(42),
|
|
PIN(43),
|
|
PIN(44),
|
|
PIN(45),
|
|
PIN(46),
|
|
PIN(47),
|
|
#undef PIN
|
|
};
|
|
|
|
static int k210_pc_get_pins_count(struct udevice *dev)
|
|
{
|
|
return ARRAY_SIZE(k210_pc_pin_names);
|
|
};
|
|
|
|
static const char *k210_pc_get_pin_name(struct udevice *dev, unsigned selector)
|
|
{
|
|
return k210_pc_pin_names[selector];
|
|
}
|
|
#endif /* CONFIG_CMD_PINMUX */
|
|
|
|
/* These are just power domains */
|
|
static const char k210_pc_group_names[][3] = {
|
|
[0] = "A0",
|
|
[1] = "A1",
|
|
[2] = "A2",
|
|
[3] = "B3",
|
|
[4] = "B4",
|
|
[5] = "B5",
|
|
[6] = "C6",
|
|
[7] = "C7",
|
|
};
|
|
|
|
static int k210_pc_get_groups_count(struct udevice *dev)
|
|
{
|
|
return ARRAY_SIZE(k210_pc_group_names);
|
|
}
|
|
|
|
static const char *k210_pc_get_group_name(struct udevice *dev,
|
|
unsigned selector)
|
|
{
|
|
return k210_pc_group_names[selector];
|
|
}
|
|
|
|
enum k210_pc_mode_id {
|
|
K210_PC_DEFAULT_DISABLED,
|
|
K210_PC_DEFAULT_IN,
|
|
K210_PC_DEFAULT_IN_TIE,
|
|
K210_PC_DEFAULT_OUT,
|
|
K210_PC_DEFAULT_I2C,
|
|
K210_PC_DEFAULT_SCCB,
|
|
K210_PC_DEFAULT_SPI,
|
|
K210_PC_DEFAULT_GPIO,
|
|
K210_PC_DEFAULT_INT13,
|
|
};
|
|
|
|
static const u32 k210_pc_mode_id_to_mode[] = {
|
|
#define DEFAULT(mode) \
|
|
[K210_PC_DEFAULT_##mode] = K210_PC_MODE_##mode
|
|
[K210_PC_DEFAULT_DISABLED] = 0,
|
|
DEFAULT(IN),
|
|
[K210_PC_DEFAULT_IN_TIE] = K210_PC_MODE_IN,
|
|
DEFAULT(OUT),
|
|
DEFAULT(I2C),
|
|
DEFAULT(SCCB),
|
|
DEFAULT(SPI),
|
|
DEFAULT(GPIO),
|
|
[K210_PC_DEFAULT_INT13] = K210_PC_MODE_IN | K210_PC_PU,
|
|
#undef DEFAULT
|
|
};
|
|
|
|
/* This saves around 2K vs having a pointer+mode */
|
|
struct k210_pcf_info {
|
|
#ifdef CONFIG_CMD_PINMUX
|
|
char name[15];
|
|
#endif
|
|
u8 mode_id;
|
|
};
|
|
|
|
static const struct k210_pcf_info k210_pcf_infos[] = {
|
|
#ifdef CONFIG_CMD_PINMUX
|
|
#define FUNC(id, mode) \
|
|
[K210_PCF_##id] = { \
|
|
.name = #id, \
|
|
.mode_id = K210_PC_DEFAULT_##mode \
|
|
}
|
|
#else
|
|
#define FUNC(id, mode) \
|
|
[K210_PCF_##id] = { \
|
|
.mode_id = K210_PC_DEFAULT_##mode \
|
|
}
|
|
#endif
|
|
FUNC(JTAG_TCLK, IN),
|
|
FUNC(JTAG_TDI, IN),
|
|
FUNC(JTAG_TMS, IN),
|
|
FUNC(JTAG_TDO, OUT),
|
|
FUNC(SPI0_D0, SPI),
|
|
FUNC(SPI0_D1, SPI),
|
|
FUNC(SPI0_D2, SPI),
|
|
FUNC(SPI0_D3, SPI),
|
|
FUNC(SPI0_D4, SPI),
|
|
FUNC(SPI0_D5, SPI),
|
|
FUNC(SPI0_D6, SPI),
|
|
FUNC(SPI0_D7, SPI),
|
|
FUNC(SPI0_SS0, OUT),
|
|
FUNC(SPI0_SS1, OUT),
|
|
FUNC(SPI0_SS2, OUT),
|
|
FUNC(SPI0_SS3, OUT),
|
|
FUNC(SPI0_ARB, IN_TIE),
|
|
FUNC(SPI0_SCLK, OUT),
|
|
FUNC(UARTHS_RX, IN),
|
|
FUNC(UARTHS_TX, OUT),
|
|
FUNC(RESV6, IN),
|
|
FUNC(RESV7, IN),
|
|
FUNC(CLK_SPI1, OUT),
|
|
FUNC(CLK_I2C1, OUT),
|
|
FUNC(GPIOHS0, GPIO),
|
|
FUNC(GPIOHS1, GPIO),
|
|
FUNC(GPIOHS2, GPIO),
|
|
FUNC(GPIOHS3, GPIO),
|
|
FUNC(GPIOHS4, GPIO),
|
|
FUNC(GPIOHS5, GPIO),
|
|
FUNC(GPIOHS6, GPIO),
|
|
FUNC(GPIOHS7, GPIO),
|
|
FUNC(GPIOHS8, GPIO),
|
|
FUNC(GPIOHS9, GPIO),
|
|
FUNC(GPIOHS10, GPIO),
|
|
FUNC(GPIOHS11, GPIO),
|
|
FUNC(GPIOHS12, GPIO),
|
|
FUNC(GPIOHS13, GPIO),
|
|
FUNC(GPIOHS14, GPIO),
|
|
FUNC(GPIOHS15, GPIO),
|
|
FUNC(GPIOHS16, GPIO),
|
|
FUNC(GPIOHS17, GPIO),
|
|
FUNC(GPIOHS18, GPIO),
|
|
FUNC(GPIOHS19, GPIO),
|
|
FUNC(GPIOHS20, GPIO),
|
|
FUNC(GPIOHS21, GPIO),
|
|
FUNC(GPIOHS22, GPIO),
|
|
FUNC(GPIOHS23, GPIO),
|
|
FUNC(GPIOHS24, GPIO),
|
|
FUNC(GPIOHS25, GPIO),
|
|
FUNC(GPIOHS26, GPIO),
|
|
FUNC(GPIOHS27, GPIO),
|
|
FUNC(GPIOHS28, GPIO),
|
|
FUNC(GPIOHS29, GPIO),
|
|
FUNC(GPIOHS30, GPIO),
|
|
FUNC(GPIOHS31, GPIO),
|
|
FUNC(GPIO0, GPIO),
|
|
FUNC(GPIO1, GPIO),
|
|
FUNC(GPIO2, GPIO),
|
|
FUNC(GPIO3, GPIO),
|
|
FUNC(GPIO4, GPIO),
|
|
FUNC(GPIO5, GPIO),
|
|
FUNC(GPIO6, GPIO),
|
|
FUNC(GPIO7, GPIO),
|
|
FUNC(UART1_RX, IN),
|
|
FUNC(UART1_TX, OUT),
|
|
FUNC(UART2_RX, IN),
|
|
FUNC(UART2_TX, OUT),
|
|
FUNC(UART3_RX, IN),
|
|
FUNC(UART3_TX, OUT),
|
|
FUNC(SPI1_D0, SPI),
|
|
FUNC(SPI1_D1, SPI),
|
|
FUNC(SPI1_D2, SPI),
|
|
FUNC(SPI1_D3, SPI),
|
|
FUNC(SPI1_D4, SPI),
|
|
FUNC(SPI1_D5, SPI),
|
|
FUNC(SPI1_D6, SPI),
|
|
FUNC(SPI1_D7, SPI),
|
|
FUNC(SPI1_SS0, OUT),
|
|
FUNC(SPI1_SS1, OUT),
|
|
FUNC(SPI1_SS2, OUT),
|
|
FUNC(SPI1_SS3, OUT),
|
|
FUNC(SPI1_ARB, IN_TIE),
|
|
FUNC(SPI1_SCLK, OUT),
|
|
FUNC(SPI2_D0, SPI),
|
|
FUNC(SPI2_SS, IN),
|
|
FUNC(SPI2_SCLK, IN),
|
|
FUNC(I2S0_MCLK, OUT),
|
|
FUNC(I2S0_SCLK, OUT),
|
|
FUNC(I2S0_WS, OUT),
|
|
FUNC(I2S0_IN_D0, IN),
|
|
FUNC(I2S0_IN_D1, IN),
|
|
FUNC(I2S0_IN_D2, IN),
|
|
FUNC(I2S0_IN_D3, IN),
|
|
FUNC(I2S0_OUT_D0, OUT),
|
|
FUNC(I2S0_OUT_D1, OUT),
|
|
FUNC(I2S0_OUT_D2, OUT),
|
|
FUNC(I2S0_OUT_D3, OUT),
|
|
FUNC(I2S1_MCLK, OUT),
|
|
FUNC(I2S1_SCLK, OUT),
|
|
FUNC(I2S1_WS, OUT),
|
|
FUNC(I2S1_IN_D0, IN),
|
|
FUNC(I2S1_IN_D1, IN),
|
|
FUNC(I2S1_IN_D2, IN),
|
|
FUNC(I2S1_IN_D3, IN),
|
|
FUNC(I2S1_OUT_D0, OUT),
|
|
FUNC(I2S1_OUT_D1, OUT),
|
|
FUNC(I2S1_OUT_D2, OUT),
|
|
FUNC(I2S1_OUT_D3, OUT),
|
|
FUNC(I2S2_MCLK, OUT),
|
|
FUNC(I2S2_SCLK, OUT),
|
|
FUNC(I2S2_WS, OUT),
|
|
FUNC(I2S2_IN_D0, IN),
|
|
FUNC(I2S2_IN_D1, IN),
|
|
FUNC(I2S2_IN_D2, IN),
|
|
FUNC(I2S2_IN_D3, IN),
|
|
FUNC(I2S2_OUT_D0, OUT),
|
|
FUNC(I2S2_OUT_D1, OUT),
|
|
FUNC(I2S2_OUT_D2, OUT),
|
|
FUNC(I2S2_OUT_D3, OUT),
|
|
FUNC(RESV0, DISABLED),
|
|
FUNC(RESV1, DISABLED),
|
|
FUNC(RESV2, DISABLED),
|
|
FUNC(RESV3, DISABLED),
|
|
FUNC(RESV4, DISABLED),
|
|
FUNC(RESV5, DISABLED),
|
|
FUNC(I2C0_SCLK, I2C),
|
|
FUNC(I2C0_SDA, I2C),
|
|
FUNC(I2C1_SCLK, I2C),
|
|
FUNC(I2C1_SDA, I2C),
|
|
FUNC(I2C2_SCLK, I2C),
|
|
FUNC(I2C2_SDA, I2C),
|
|
FUNC(DVP_XCLK, OUT),
|
|
FUNC(DVP_RST, OUT),
|
|
FUNC(DVP_PWDN, OUT),
|
|
FUNC(DVP_VSYNC, IN),
|
|
FUNC(DVP_HSYNC, IN),
|
|
FUNC(DVP_PCLK, IN),
|
|
FUNC(DVP_D0, IN),
|
|
FUNC(DVP_D1, IN),
|
|
FUNC(DVP_D2, IN),
|
|
FUNC(DVP_D3, IN),
|
|
FUNC(DVP_D4, IN),
|
|
FUNC(DVP_D5, IN),
|
|
FUNC(DVP_D6, IN),
|
|
FUNC(DVP_D7, IN),
|
|
FUNC(SCCB_SCLK, SCCB),
|
|
FUNC(SCCB_SDA, SCCB),
|
|
FUNC(UART1_CTS, IN),
|
|
FUNC(UART1_DSR, IN),
|
|
FUNC(UART1_DCD, IN),
|
|
FUNC(UART1_RI, IN),
|
|
FUNC(UART1_SIR_IN, IN),
|
|
FUNC(UART1_DTR, OUT),
|
|
FUNC(UART1_RTS, OUT),
|
|
FUNC(UART1_OUT2, OUT),
|
|
FUNC(UART1_OUT1, OUT),
|
|
FUNC(UART1_SIR_OUT, OUT),
|
|
FUNC(UART1_BAUD, OUT),
|
|
FUNC(UART1_RE, OUT),
|
|
FUNC(UART1_DE, OUT),
|
|
FUNC(UART1_RS485_EN, OUT),
|
|
FUNC(UART2_CTS, IN),
|
|
FUNC(UART2_DSR, IN),
|
|
FUNC(UART2_DCD, IN),
|
|
FUNC(UART2_RI, IN),
|
|
FUNC(UART2_SIR_IN, IN),
|
|
FUNC(UART2_DTR, OUT),
|
|
FUNC(UART2_RTS, OUT),
|
|
FUNC(UART2_OUT2, OUT),
|
|
FUNC(UART2_OUT1, OUT),
|
|
FUNC(UART2_SIR_OUT, OUT),
|
|
FUNC(UART2_BAUD, OUT),
|
|
FUNC(UART2_RE, OUT),
|
|
FUNC(UART2_DE, OUT),
|
|
FUNC(UART2_RS485_EN, OUT),
|
|
FUNC(UART3_CTS, IN),
|
|
FUNC(UART3_DSR, IN),
|
|
FUNC(UART3_DCD, IN),
|
|
FUNC(UART3_RI, IN),
|
|
FUNC(UART3_SIR_IN, IN),
|
|
FUNC(UART3_DTR, OUT),
|
|
FUNC(UART3_RTS, OUT),
|
|
FUNC(UART3_OUT2, OUT),
|
|
FUNC(UART3_OUT1, OUT),
|
|
FUNC(UART3_SIR_OUT, OUT),
|
|
FUNC(UART3_BAUD, OUT),
|
|
FUNC(UART3_RE, OUT),
|
|
FUNC(UART3_DE, OUT),
|
|
FUNC(UART3_RS485_EN, OUT),
|
|
FUNC(TIMER0_TOGGLE1, OUT),
|
|
FUNC(TIMER0_TOGGLE2, OUT),
|
|
FUNC(TIMER0_TOGGLE3, OUT),
|
|
FUNC(TIMER0_TOGGLE4, OUT),
|
|
FUNC(TIMER1_TOGGLE1, OUT),
|
|
FUNC(TIMER1_TOGGLE2, OUT),
|
|
FUNC(TIMER1_TOGGLE3, OUT),
|
|
FUNC(TIMER1_TOGGLE4, OUT),
|
|
FUNC(TIMER2_TOGGLE1, OUT),
|
|
FUNC(TIMER2_TOGGLE2, OUT),
|
|
FUNC(TIMER2_TOGGLE3, OUT),
|
|
FUNC(TIMER2_TOGGLE4, OUT),
|
|
FUNC(CLK_SPI2, OUT),
|
|
FUNC(CLK_I2C2, OUT),
|
|
FUNC(INTERNAL0, OUT),
|
|
FUNC(INTERNAL1, OUT),
|
|
FUNC(INTERNAL2, OUT),
|
|
FUNC(INTERNAL3, OUT),
|
|
FUNC(INTERNAL4, OUT),
|
|
FUNC(INTERNAL5, OUT),
|
|
FUNC(INTERNAL6, OUT),
|
|
FUNC(INTERNAL7, OUT),
|
|
FUNC(INTERNAL8, OUT),
|
|
FUNC(INTERNAL9, IN),
|
|
FUNC(INTERNAL10, IN),
|
|
FUNC(INTERNAL11, IN),
|
|
FUNC(INTERNAL12, IN),
|
|
FUNC(INTERNAL13, INT13),
|
|
FUNC(INTERNAL14, I2C),
|
|
FUNC(INTERNAL15, IN),
|
|
FUNC(INTERNAL16, IN),
|
|
FUNC(INTERNAL17, IN),
|
|
FUNC(CONSTANT, DISABLED),
|
|
FUNC(INTERNAL18, IN),
|
|
FUNC(DEBUG0, OUT),
|
|
FUNC(DEBUG1, OUT),
|
|
FUNC(DEBUG2, OUT),
|
|
FUNC(DEBUG3, OUT),
|
|
FUNC(DEBUG4, OUT),
|
|
FUNC(DEBUG5, OUT),
|
|
FUNC(DEBUG6, OUT),
|
|
FUNC(DEBUG7, OUT),
|
|
FUNC(DEBUG8, OUT),
|
|
FUNC(DEBUG9, OUT),
|
|
FUNC(DEBUG10, OUT),
|
|
FUNC(DEBUG11, OUT),
|
|
FUNC(DEBUG12, OUT),
|
|
FUNC(DEBUG13, OUT),
|
|
FUNC(DEBUG14, OUT),
|
|
FUNC(DEBUG15, OUT),
|
|
FUNC(DEBUG16, OUT),
|
|
FUNC(DEBUG17, OUT),
|
|
FUNC(DEBUG18, OUT),
|
|
FUNC(DEBUG19, OUT),
|
|
FUNC(DEBUG20, OUT),
|
|
FUNC(DEBUG21, OUT),
|
|
FUNC(DEBUG22, OUT),
|
|
FUNC(DEBUG23, OUT),
|
|
FUNC(DEBUG24, OUT),
|
|
FUNC(DEBUG25, OUT),
|
|
FUNC(DEBUG26, OUT),
|
|
FUNC(DEBUG27, OUT),
|
|
FUNC(DEBUG28, OUT),
|
|
FUNC(DEBUG29, OUT),
|
|
FUNC(DEBUG30, OUT),
|
|
FUNC(DEBUG31, OUT),
|
|
#undef FUNC
|
|
};
|
|
|
|
static int k210_pc_pinmux_set(struct udevice *dev, u32 pinmux_group)
|
|
{
|
|
unsigned pin = FIELD_GET(K210_PG_PIN, pinmux_group);
|
|
bool do_oe = FIELD_GET(K210_PG_DO, pinmux_group);
|
|
unsigned func = FIELD_GET(K210_PG_FUNC, pinmux_group);
|
|
struct k210_pc_priv *priv = dev_get_priv(dev);
|
|
const struct k210_pcf_info *info = &k210_pcf_infos[func];
|
|
u32 mode = k210_pc_mode_id_to_mode[info->mode_id];
|
|
u32 val = func | mode | (do_oe ? K210_PC_DO_OE : 0);
|
|
|
|
debug("%s(%.8x): IO_%.2u = %3u | %.8x\n", __func__, pinmux_group, pin,
|
|
func, mode);
|
|
|
|
writel(val, &priv->fpioa->pins[pin]);
|
|
return pin;
|
|
}
|
|
|
|
/* Max drive strength in uA */
|
|
static const int k210_pc_drive_strength[] = {
|
|
[0] = 11200,
|
|
[1] = 16800,
|
|
[2] = 22300,
|
|
[3] = 27800,
|
|
[4] = 33300,
|
|
[5] = 38700,
|
|
[6] = 44100,
|
|
[7] = 49500,
|
|
};
|
|
|
|
static int k210_pc_get_drive(unsigned max_strength_ua)
|
|
{
|
|
int i;
|
|
|
|
for (i = K210_PC_DRIVE_MAX; i; i--)
|
|
if (k210_pc_drive_strength[i] < max_strength_ua)
|
|
return i;
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int k210_pc_pinconf_set(struct udevice *dev, unsigned pin_selector,
|
|
unsigned param, unsigned argument)
|
|
{
|
|
struct k210_pc_priv *priv = dev_get_priv(dev);
|
|
u32 val = readl(&priv->fpioa->pins[pin_selector]);
|
|
|
|
switch (param) {
|
|
case PIN_CONFIG_BIAS_DISABLE:
|
|
val &= ~K210_PC_BIAS_MASK;
|
|
break;
|
|
case PIN_CONFIG_BIAS_PULL_DOWN:
|
|
if (argument)
|
|
val |= K210_PC_PD;
|
|
else
|
|
return -EINVAL;
|
|
break;
|
|
case PIN_CONFIG_BIAS_PULL_UP:
|
|
if (argument)
|
|
val |= K210_PC_PD;
|
|
else
|
|
return -EINVAL;
|
|
break;
|
|
case PIN_CONFIG_DRIVE_STRENGTH:
|
|
argument *= 1000;
|
|
case PIN_CONFIG_DRIVE_STRENGTH_UA: {
|
|
int drive = k210_pc_get_drive(argument);
|
|
|
|
if (IS_ERR_VALUE(drive))
|
|
return drive;
|
|
val &= ~K210_PC_DRIVE_MASK;
|
|
val |= FIELD_PREP(K210_PC_DRIVE_MASK, drive);
|
|
break;
|
|
}
|
|
case PIN_CONFIG_INPUT_ENABLE:
|
|
if (argument)
|
|
val |= K210_PC_IE;
|
|
else
|
|
val &= ~K210_PC_IE;
|
|
break;
|
|
case PIN_CONFIG_INPUT_SCHMITT:
|
|
argument = 1;
|
|
case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
|
|
if (argument)
|
|
val |= K210_PC_ST;
|
|
else
|
|
val &= ~K210_PC_ST;
|
|
break;
|
|
case PIN_CONFIG_OUTPUT:
|
|
k210_pc_pinmux_set(dev,
|
|
K210_FPIOA(pin_selector, K210_PCF_CONSTANT));
|
|
val = readl(&priv->fpioa->pins[pin_selector]);
|
|
val |= K210_PC_MODE_OUT;
|
|
|
|
if (!argument)
|
|
val |= K210_PC_DO_INV;
|
|
break;
|
|
case PIN_CONFIG_OUTPUT_ENABLE:
|
|
if (argument)
|
|
val |= K210_PC_OE;
|
|
else
|
|
val &= ~K210_PC_OE;
|
|
break;
|
|
case PIN_CONFIG_SLEW_RATE:
|
|
if (argument)
|
|
val |= K210_PC_SL;
|
|
else
|
|
val &= ~K210_PC_SL;
|
|
break;
|
|
case PIN_CONFIG_OUTPUT_INVERT:
|
|
if (argument)
|
|
val |= K210_PC_DO_INV;
|
|
else
|
|
val &= ~K210_PC_DO_INV;
|
|
break;
|
|
case PIN_CONFIG_INPUT_INVERT:
|
|
if (argument)
|
|
val |= K210_PC_DI_INV;
|
|
else
|
|
val &= ~K210_PC_DI_INV;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
writel(val, &priv->fpioa->pins[pin_selector]);
|
|
return 0;
|
|
}
|
|
|
|
static int k210_pc_pinconf_group_set(struct udevice *dev,
|
|
unsigned group_selector, unsigned param,
|
|
unsigned argument)
|
|
{
|
|
struct k210_pc_priv *priv = dev_get_priv(dev);
|
|
|
|
if (param == PIN_CONFIG_POWER_SOURCE) {
|
|
u32 bit = BIT(group_selector);
|
|
|
|
regmap_update_bits(priv->sysctl, priv->power_offset, bit,
|
|
argument ? bit : 0);
|
|
} else {
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_CMD_PINMUX
|
|
static int k210_pc_get_pin_muxing(struct udevice *dev, unsigned int selector,
|
|
char *buf, int size)
|
|
{
|
|
struct k210_pc_priv *priv = dev_get_priv(dev);
|
|
u32 val = readl(&priv->fpioa->pins[selector]);
|
|
const struct k210_pcf_info *info = &k210_pcf_infos[val & K210_PCF_MASK];
|
|
|
|
strncpy(buf, info->name, min((size_t)size, sizeof(info->name)));
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static const struct pinconf_param k210_pc_pinconf_params[] = {
|
|
{ "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 },
|
|
{ "bias-pull-down", PIN_CONFIG_BIAS_PULL_DOWN, 1 },
|
|
{ "bias-pull-up", PIN_CONFIG_BIAS_PULL_UP, 1 },
|
|
{ "drive-strength", PIN_CONFIG_DRIVE_STRENGTH, U32_MAX },
|
|
{ "drive-strength-ua", PIN_CONFIG_DRIVE_STRENGTH_UA, U32_MAX },
|
|
{ "input-enable", PIN_CONFIG_INPUT_ENABLE, 1 },
|
|
{ "input-disable", PIN_CONFIG_INPUT_ENABLE, 0 },
|
|
{ "input-schmitt-enable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 1 },
|
|
{ "input-schmitt-disable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 0 },
|
|
{ "power-source", PIN_CONFIG_POWER_SOURCE, K210_PC_POWER_1V8 },
|
|
{ "output-low", PIN_CONFIG_OUTPUT, 0 },
|
|
{ "output-high", PIN_CONFIG_OUTPUT, 1 },
|
|
{ "output-enable", PIN_CONFIG_OUTPUT_ENABLE, 1 },
|
|
{ "output-disable", PIN_CONFIG_OUTPUT_ENABLE, 0 },
|
|
{ "slew-rate", PIN_CONFIG_SLEW_RATE, 1 },
|
|
{ "output-polarity-invert", PIN_CONFIG_OUTPUT_INVERT, 1},
|
|
{ "input-polarity-invert", PIN_CONFIG_INPUT_INVERT, 1},
|
|
};
|
|
|
|
static const struct pinctrl_ops k210_pc_pinctrl_ops = {
|
|
#ifdef CONFIG_CMD_PINMUX
|
|
.get_pins_count = k210_pc_get_pins_count,
|
|
.get_pin_name = k210_pc_get_pin_name,
|
|
#endif
|
|
.get_groups_count = k210_pc_get_groups_count,
|
|
.get_group_name = k210_pc_get_group_name,
|
|
.pinmux_property_set = k210_pc_pinmux_set,
|
|
.pinconf_num_params = ARRAY_SIZE(k210_pc_pinconf_params),
|
|
.pinconf_params = k210_pc_pinconf_params,
|
|
.pinconf_set = k210_pc_pinconf_set,
|
|
.pinconf_group_set = k210_pc_pinconf_group_set,
|
|
.set_state = pinctrl_generic_set_state,
|
|
#ifdef CONFIG_CMD_PINMUX
|
|
.get_pin_muxing = k210_pc_get_pin_muxing,
|
|
#endif
|
|
};
|
|
|
|
static int k210_pc_probe(struct udevice *dev)
|
|
{
|
|
int ret, i, j;
|
|
struct k210_pc_priv *priv = dev_get_priv(dev);
|
|
|
|
priv->fpioa = dev_read_addr_ptr(dev);
|
|
if (!priv->fpioa)
|
|
return -EINVAL;
|
|
|
|
ret = clk_get_by_index(dev, 0, &priv->clk);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = clk_enable(&priv->clk);
|
|
if (ret && ret != -ENOSYS && ret != -ENOTSUPP)
|
|
goto err;
|
|
|
|
priv->sysctl = syscon_regmap_lookup_by_phandle(dev, "kendryte,sysctl");
|
|
if (IS_ERR(priv->sysctl)) {
|
|
ret = -ENODEV;
|
|
goto err;
|
|
}
|
|
|
|
ret = dev_read_u32(dev, "kendryte,power-offset", &priv->power_offset);
|
|
if (ret)
|
|
goto err;
|
|
|
|
debug("%s: fpioa = %p sysctl = %p power offset = %x\n", __func__,
|
|
priv->fpioa, (void *)priv->sysctl->ranges[0].start,
|
|
priv->power_offset);
|
|
|
|
/* Init input ties */
|
|
for (i = 0; i < ARRAY_SIZE(priv->fpioa->tie_en); i++) {
|
|
u32 val = 0;
|
|
|
|
for (j = 0; j < 32; j++)
|
|
if (k210_pcf_infos[i * 32 + j].mode_id ==
|
|
K210_PC_DEFAULT_IN_TIE)
|
|
val |= BIT(j);
|
|
writel(val, &priv->fpioa->tie_en[i]);
|
|
writel(val, &priv->fpioa->tie_val[i]);
|
|
}
|
|
|
|
return 0;
|
|
|
|
err:
|
|
clk_free(&priv->clk);
|
|
return ret;
|
|
}
|
|
|
|
static const struct udevice_id k210_pc_ids[] = {
|
|
{ .compatible = "kendryte,k210-fpioa" },
|
|
{ }
|
|
};
|
|
|
|
U_BOOT_DRIVER(pinctrl_k210) = {
|
|
.name = "pinctrl_k210",
|
|
.id = UCLASS_PINCTRL,
|
|
.of_match = k210_pc_ids,
|
|
.probe = k210_pc_probe,
|
|
.priv_auto = sizeof(struct k210_pc_priv),
|
|
.ops = &k210_pc_pinctrl_ops,
|
|
};
|