Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2020 Sean Anderson <seanga2@gmail.com>
0004  * Copyright (c) 2020 Western Digital Corporation or its affiliates.
0005  */
0006 #include <linux/io.h>
0007 #include <linux/of_device.h>
0008 #include <linux/clk.h>
0009 #include <linux/mfd/syscon.h>
0010 #include <linux/platform_device.h>
0011 #include <linux/bitfield.h>
0012 #include <linux/regmap.h>
0013 #include <linux/slab.h>
0014 #include <linux/pinctrl/pinctrl.h>
0015 #include <linux/pinctrl/pinmux.h>
0016 #include <linux/pinctrl/pinconf.h>
0017 #include <linux/pinctrl/pinconf-generic.h>
0018 
0019 #include <dt-bindings/pinctrl/k210-fpioa.h>
0020 
0021 #include "core.h"
0022 #include "pinconf.h"
0023 #include "pinctrl-utils.h"
0024 
0025 /*
0026  * The K210 only implements 8 drive levels, even though
0027  * there is register space for 16
0028  */
0029 #define K210_PC_DRIVE_MASK  GENMASK(11, 8)
0030 #define K210_PC_DRIVE_SHIFT 8
0031 #define K210_PC_DRIVE_0     (0 << K210_PC_DRIVE_SHIFT)
0032 #define K210_PC_DRIVE_1     (1 << K210_PC_DRIVE_SHIFT)
0033 #define K210_PC_DRIVE_2     (2 << K210_PC_DRIVE_SHIFT)
0034 #define K210_PC_DRIVE_3     (3 << K210_PC_DRIVE_SHIFT)
0035 #define K210_PC_DRIVE_4     (4 << K210_PC_DRIVE_SHIFT)
0036 #define K210_PC_DRIVE_5     (5 << K210_PC_DRIVE_SHIFT)
0037 #define K210_PC_DRIVE_6     (6 << K210_PC_DRIVE_SHIFT)
0038 #define K210_PC_DRIVE_7     (7 << K210_PC_DRIVE_SHIFT)
0039 #define K210_PC_DRIVE_MAX   7
0040 #define K210_PC_MODE_MASK   GENMASK(23, 12)
0041 
0042 /*
0043  * output enabled == PC_OE & (PC_OE_INV ^ FUNCTION_OE)
0044  * where FUNCTION_OE is a physical signal from the function.
0045  */
0046 #define K210_PC_OE      BIT(12) /* Output Enable */
0047 #define K210_PC_OE_INV      BIT(13) /* INVert Output Enable */
0048 #define K210_PC_DO_OE       BIT(14) /* set Data Out to Output Enable sig */
0049 #define K210_PC_DO_INV      BIT(15) /* INVert final Data Output */
0050 #define K210_PC_PU      BIT(16) /* Pull Up */
0051 #define K210_PC_PD      BIT(17) /* Pull Down */
0052 /* Strong pull up not implemented on K210 */
0053 #define K210_PC_SL      BIT(19) /* reduce SLew rate */
0054 /* Same semantics as OE above */
0055 #define K210_PC_IE      BIT(20) /* Input Enable */
0056 #define K210_PC_IE_INV      BIT(21) /* INVert Input Enable */
0057 #define K210_PC_DI_INV      BIT(22) /* INVert Data Input */
0058 #define K210_PC_ST      BIT(23) /* Schmitt Trigger */
0059 #define K210_PC_DI      BIT(31) /* raw Data Input */
0060 
0061 #define K210_PC_BIAS_MASK   (K210_PC_PU & K210_PC_PD)
0062 
0063 #define K210_PC_MODE_IN     (K210_PC_IE | K210_PC_ST)
0064 #define K210_PC_MODE_OUT    (K210_PC_DRIVE_7 | K210_PC_OE)
0065 #define K210_PC_MODE_I2C    (K210_PC_MODE_IN | K210_PC_SL | \
0066                  K210_PC_OE | K210_PC_PU)
0067 #define K210_PC_MODE_SCCB   (K210_PC_MODE_I2C | \
0068                  K210_PC_OE_INV | K210_PC_IE_INV)
0069 #define K210_PC_MODE_SPI    (K210_PC_MODE_IN | K210_PC_IE_INV | \
0070                  K210_PC_MODE_OUT | K210_PC_OE_INV)
0071 #define K210_PC_MODE_GPIO   (K210_PC_MODE_IN | K210_PC_MODE_OUT)
0072 
0073 #define K210_PG_FUNC        GENMASK(7, 0)
0074 #define K210_PG_DO      BIT(8)
0075 #define K210_PG_PIN     GENMASK(22, 16)
0076 
0077 /*
0078  * struct k210_fpioa: Kendryte K210 FPIOA memory mapped registers
0079  * @pins: 48 32-bits IO pin registers
0080  * @tie_en: 256 (one per function) input tie enable bits
0081  * @tie_val: 256 (one per function) input tie value bits
0082  */
0083 struct k210_fpioa {
0084     u32 pins[48];
0085     u32 tie_en[8];
0086     u32 tie_val[8];
0087 };
0088 
0089 struct k210_fpioa_data {
0090 
0091     struct device *dev;
0092     struct pinctrl_dev *pctl;
0093 
0094     struct k210_fpioa __iomem *fpioa;
0095     struct regmap *sysctl_map;
0096     u32 power_offset;
0097     struct clk *clk;
0098     struct clk *pclk;
0099 };
0100 
0101 #define K210_PIN_NAME(i)    ("IO_" #i)
0102 #define K210_PIN(i)     [(i)] = PINCTRL_PIN((i), K210_PIN_NAME(i))
0103 
0104 static const struct pinctrl_pin_desc k210_pins[] = {
0105     K210_PIN(0),  K210_PIN(1),  K210_PIN(2),
0106     K210_PIN(3),  K210_PIN(4),  K210_PIN(5),
0107     K210_PIN(6),  K210_PIN(7),  K210_PIN(8),
0108     K210_PIN(9),  K210_PIN(10), K210_PIN(11),
0109     K210_PIN(12), K210_PIN(13), K210_PIN(14),
0110     K210_PIN(15), K210_PIN(16), K210_PIN(17),
0111     K210_PIN(18), K210_PIN(19), K210_PIN(20),
0112     K210_PIN(21), K210_PIN(22), K210_PIN(23),
0113     K210_PIN(24), K210_PIN(25), K210_PIN(26),
0114     K210_PIN(27), K210_PIN(28), K210_PIN(29),
0115     K210_PIN(30), K210_PIN(31), K210_PIN(32),
0116     K210_PIN(33), K210_PIN(34), K210_PIN(35),
0117     K210_PIN(36), K210_PIN(37), K210_PIN(38),
0118     K210_PIN(39), K210_PIN(40), K210_PIN(41),
0119     K210_PIN(42), K210_PIN(43), K210_PIN(44),
0120     K210_PIN(45), K210_PIN(46), K210_PIN(47)
0121 };
0122 
0123 #define K210_NPINS ARRAY_SIZE(k210_pins)
0124 
0125 /*
0126  * Pin groups: each of the 48 programmable pins is a group.
0127  * To this are added 8 power domain groups, which for the purposes of
0128  * the pin subsystem, contain no pins. The power domain groups only exist
0129  * to set the power level. The id should never be used (since there are
0130  * no pins 48-55).
0131  */
0132 static const char *const k210_group_names[] = {
0133     /* The first 48 groups are for pins, one each */
0134     K210_PIN_NAME(0),  K210_PIN_NAME(1),  K210_PIN_NAME(2),
0135     K210_PIN_NAME(3),  K210_PIN_NAME(4),  K210_PIN_NAME(5),
0136     K210_PIN_NAME(6),  K210_PIN_NAME(7),  K210_PIN_NAME(8),
0137     K210_PIN_NAME(9),  K210_PIN_NAME(10), K210_PIN_NAME(11),
0138     K210_PIN_NAME(12), K210_PIN_NAME(13), K210_PIN_NAME(14),
0139     K210_PIN_NAME(15), K210_PIN_NAME(16), K210_PIN_NAME(17),
0140     K210_PIN_NAME(18), K210_PIN_NAME(19), K210_PIN_NAME(20),
0141     K210_PIN_NAME(21), K210_PIN_NAME(22), K210_PIN_NAME(23),
0142     K210_PIN_NAME(24), K210_PIN_NAME(25), K210_PIN_NAME(26),
0143     K210_PIN_NAME(27), K210_PIN_NAME(28), K210_PIN_NAME(29),
0144     K210_PIN_NAME(30), K210_PIN_NAME(31), K210_PIN_NAME(32),
0145     K210_PIN_NAME(33), K210_PIN_NAME(34), K210_PIN_NAME(35),
0146     K210_PIN_NAME(36), K210_PIN_NAME(37), K210_PIN_NAME(38),
0147     K210_PIN_NAME(39), K210_PIN_NAME(40), K210_PIN_NAME(41),
0148     K210_PIN_NAME(42), K210_PIN_NAME(43), K210_PIN_NAME(44),
0149     K210_PIN_NAME(45), K210_PIN_NAME(46), K210_PIN_NAME(47),
0150     [48] = "A0", [49] = "A1", [50] = "A2",
0151     [51] = "B3", [52] = "B4", [53] = "B5",
0152     [54] = "C6", [55] = "C7"
0153 };
0154 
0155 #define K210_NGROUPS    ARRAY_SIZE(k210_group_names)
0156 
0157 enum k210_pinctrl_mode_id {
0158     K210_PC_DEFAULT_DISABLED,
0159     K210_PC_DEFAULT_IN,
0160     K210_PC_DEFAULT_IN_TIE,
0161     K210_PC_DEFAULT_OUT,
0162     K210_PC_DEFAULT_I2C,
0163     K210_PC_DEFAULT_SCCB,
0164     K210_PC_DEFAULT_SPI,
0165     K210_PC_DEFAULT_GPIO,
0166     K210_PC_DEFAULT_INT13,
0167 };
0168 
0169 #define K210_PC_DEFAULT(mode) \
0170     [K210_PC_DEFAULT_##mode] = K210_PC_MODE_##mode
0171 
0172 static const u32 k210_pinconf_mode_id_to_mode[] = {
0173     [K210_PC_DEFAULT_DISABLED] = 0,
0174     K210_PC_DEFAULT(IN),
0175     [K210_PC_DEFAULT_IN_TIE] = K210_PC_MODE_IN,
0176     K210_PC_DEFAULT(OUT),
0177     K210_PC_DEFAULT(I2C),
0178     K210_PC_DEFAULT(SCCB),
0179     K210_PC_DEFAULT(SPI),
0180     K210_PC_DEFAULT(GPIO),
0181     [K210_PC_DEFAULT_INT13] = K210_PC_MODE_IN | K210_PC_PU,
0182 };
0183 
0184 #undef DEFAULT
0185 
0186 /*
0187  * Pin functions configuration information.
0188  */
0189 struct k210_pcf_info {
0190     char name[15];
0191     u8 mode_id;
0192 };
0193 
0194 #define K210_FUNC(id, mode)             \
0195     [K210_PCF_##id] = {             \
0196         .name = #id,                \
0197         .mode_id = K210_PC_DEFAULT_##mode   \
0198     }
0199 
0200 static const struct k210_pcf_info k210_pcf_infos[] = {
0201     K210_FUNC(JTAG_TCLK,        IN),
0202     K210_FUNC(JTAG_TDI,     IN),
0203     K210_FUNC(JTAG_TMS,     IN),
0204     K210_FUNC(JTAG_TDO,     OUT),
0205     K210_FUNC(SPI0_D0,      SPI),
0206     K210_FUNC(SPI0_D1,      SPI),
0207     K210_FUNC(SPI0_D2,      SPI),
0208     K210_FUNC(SPI0_D3,      SPI),
0209     K210_FUNC(SPI0_D4,      SPI),
0210     K210_FUNC(SPI0_D5,      SPI),
0211     K210_FUNC(SPI0_D6,      SPI),
0212     K210_FUNC(SPI0_D7,      SPI),
0213     K210_FUNC(SPI0_SS0,     OUT),
0214     K210_FUNC(SPI0_SS1,     OUT),
0215     K210_FUNC(SPI0_SS2,     OUT),
0216     K210_FUNC(SPI0_SS3,     OUT),
0217     K210_FUNC(SPI0_ARB,     IN_TIE),
0218     K210_FUNC(SPI0_SCLK,        OUT),
0219     K210_FUNC(UARTHS_RX,        IN),
0220     K210_FUNC(UARTHS_TX,        OUT),
0221     K210_FUNC(RESV6,        IN),
0222     K210_FUNC(RESV7,        IN),
0223     K210_FUNC(CLK_SPI1,     OUT),
0224     K210_FUNC(CLK_I2C1,     OUT),
0225     K210_FUNC(GPIOHS0,      GPIO),
0226     K210_FUNC(GPIOHS1,      GPIO),
0227     K210_FUNC(GPIOHS2,      GPIO),
0228     K210_FUNC(GPIOHS3,      GPIO),
0229     K210_FUNC(GPIOHS4,      GPIO),
0230     K210_FUNC(GPIOHS5,      GPIO),
0231     K210_FUNC(GPIOHS6,      GPIO),
0232     K210_FUNC(GPIOHS7,      GPIO),
0233     K210_FUNC(GPIOHS8,      GPIO),
0234     K210_FUNC(GPIOHS9,      GPIO),
0235     K210_FUNC(GPIOHS10,     GPIO),
0236     K210_FUNC(GPIOHS11,     GPIO),
0237     K210_FUNC(GPIOHS12,     GPIO),
0238     K210_FUNC(GPIOHS13,     GPIO),
0239     K210_FUNC(GPIOHS14,     GPIO),
0240     K210_FUNC(GPIOHS15,     GPIO),
0241     K210_FUNC(GPIOHS16,     GPIO),
0242     K210_FUNC(GPIOHS17,     GPIO),
0243     K210_FUNC(GPIOHS18,     GPIO),
0244     K210_FUNC(GPIOHS19,     GPIO),
0245     K210_FUNC(GPIOHS20,     GPIO),
0246     K210_FUNC(GPIOHS21,     GPIO),
0247     K210_FUNC(GPIOHS22,     GPIO),
0248     K210_FUNC(GPIOHS23,     GPIO),
0249     K210_FUNC(GPIOHS24,     GPIO),
0250     K210_FUNC(GPIOHS25,     GPIO),
0251     K210_FUNC(GPIOHS26,     GPIO),
0252     K210_FUNC(GPIOHS27,     GPIO),
0253     K210_FUNC(GPIOHS28,     GPIO),
0254     K210_FUNC(GPIOHS29,     GPIO),
0255     K210_FUNC(GPIOHS30,     GPIO),
0256     K210_FUNC(GPIOHS31,     GPIO),
0257     K210_FUNC(GPIO0,        GPIO),
0258     K210_FUNC(GPIO1,        GPIO),
0259     K210_FUNC(GPIO2,        GPIO),
0260     K210_FUNC(GPIO3,        GPIO),
0261     K210_FUNC(GPIO4,        GPIO),
0262     K210_FUNC(GPIO5,        GPIO),
0263     K210_FUNC(GPIO6,        GPIO),
0264     K210_FUNC(GPIO7,        GPIO),
0265     K210_FUNC(UART1_RX,     IN),
0266     K210_FUNC(UART1_TX,     OUT),
0267     K210_FUNC(UART2_RX,     IN),
0268     K210_FUNC(UART2_TX,     OUT),
0269     K210_FUNC(UART3_RX,     IN),
0270     K210_FUNC(UART3_TX,     OUT),
0271     K210_FUNC(SPI1_D0,      SPI),
0272     K210_FUNC(SPI1_D1,      SPI),
0273     K210_FUNC(SPI1_D2,      SPI),
0274     K210_FUNC(SPI1_D3,      SPI),
0275     K210_FUNC(SPI1_D4,      SPI),
0276     K210_FUNC(SPI1_D5,      SPI),
0277     K210_FUNC(SPI1_D6,      SPI),
0278     K210_FUNC(SPI1_D7,      SPI),
0279     K210_FUNC(SPI1_SS0,     OUT),
0280     K210_FUNC(SPI1_SS1,     OUT),
0281     K210_FUNC(SPI1_SS2,     OUT),
0282     K210_FUNC(SPI1_SS3,     OUT),
0283     K210_FUNC(SPI1_ARB,     IN_TIE),
0284     K210_FUNC(SPI1_SCLK,        OUT),
0285     K210_FUNC(SPI2_D0,      SPI),
0286     K210_FUNC(SPI2_SS,      IN),
0287     K210_FUNC(SPI2_SCLK,        IN),
0288     K210_FUNC(I2S0_MCLK,        OUT),
0289     K210_FUNC(I2S0_SCLK,        OUT),
0290     K210_FUNC(I2S0_WS,      OUT),
0291     K210_FUNC(I2S0_IN_D0,       IN),
0292     K210_FUNC(I2S0_IN_D1,       IN),
0293     K210_FUNC(I2S0_IN_D2,       IN),
0294     K210_FUNC(I2S0_IN_D3,       IN),
0295     K210_FUNC(I2S0_OUT_D0,      OUT),
0296     K210_FUNC(I2S0_OUT_D1,      OUT),
0297     K210_FUNC(I2S0_OUT_D2,      OUT),
0298     K210_FUNC(I2S0_OUT_D3,      OUT),
0299     K210_FUNC(I2S1_MCLK,        OUT),
0300     K210_FUNC(I2S1_SCLK,        OUT),
0301     K210_FUNC(I2S1_WS,      OUT),
0302     K210_FUNC(I2S1_IN_D0,       IN),
0303     K210_FUNC(I2S1_IN_D1,       IN),
0304     K210_FUNC(I2S1_IN_D2,       IN),
0305     K210_FUNC(I2S1_IN_D3,       IN),
0306     K210_FUNC(I2S1_OUT_D0,      OUT),
0307     K210_FUNC(I2S1_OUT_D1,      OUT),
0308     K210_FUNC(I2S1_OUT_D2,      OUT),
0309     K210_FUNC(I2S1_OUT_D3,      OUT),
0310     K210_FUNC(I2S2_MCLK,        OUT),
0311     K210_FUNC(I2S2_SCLK,        OUT),
0312     K210_FUNC(I2S2_WS,      OUT),
0313     K210_FUNC(I2S2_IN_D0,       IN),
0314     K210_FUNC(I2S2_IN_D1,       IN),
0315     K210_FUNC(I2S2_IN_D2,       IN),
0316     K210_FUNC(I2S2_IN_D3,       IN),
0317     K210_FUNC(I2S2_OUT_D0,      OUT),
0318     K210_FUNC(I2S2_OUT_D1,      OUT),
0319     K210_FUNC(I2S2_OUT_D2,      OUT),
0320     K210_FUNC(I2S2_OUT_D3,      OUT),
0321     K210_FUNC(RESV0,        DISABLED),
0322     K210_FUNC(RESV1,        DISABLED),
0323     K210_FUNC(RESV2,        DISABLED),
0324     K210_FUNC(RESV3,        DISABLED),
0325     K210_FUNC(RESV4,        DISABLED),
0326     K210_FUNC(RESV5,        DISABLED),
0327     K210_FUNC(I2C0_SCLK,        I2C),
0328     K210_FUNC(I2C0_SDA,     I2C),
0329     K210_FUNC(I2C1_SCLK,        I2C),
0330     K210_FUNC(I2C1_SDA,     I2C),
0331     K210_FUNC(I2C2_SCLK,        I2C),
0332     K210_FUNC(I2C2_SDA,     I2C),
0333     K210_FUNC(DVP_XCLK,     OUT),
0334     K210_FUNC(DVP_RST,      OUT),
0335     K210_FUNC(DVP_PWDN,     OUT),
0336     K210_FUNC(DVP_VSYNC,        IN),
0337     K210_FUNC(DVP_HSYNC,        IN),
0338     K210_FUNC(DVP_PCLK,     IN),
0339     K210_FUNC(DVP_D0,       IN),
0340     K210_FUNC(DVP_D1,       IN),
0341     K210_FUNC(DVP_D2,       IN),
0342     K210_FUNC(DVP_D3,       IN),
0343     K210_FUNC(DVP_D4,       IN),
0344     K210_FUNC(DVP_D5,       IN),
0345     K210_FUNC(DVP_D6,       IN),
0346     K210_FUNC(DVP_D7,       IN),
0347     K210_FUNC(SCCB_SCLK,        SCCB),
0348     K210_FUNC(SCCB_SDA,     SCCB),
0349     K210_FUNC(UART1_CTS,        IN),
0350     K210_FUNC(UART1_DSR,        IN),
0351     K210_FUNC(UART1_DCD,        IN),
0352     K210_FUNC(UART1_RI,     IN),
0353     K210_FUNC(UART1_SIR_IN,     IN),
0354     K210_FUNC(UART1_DTR,        OUT),
0355     K210_FUNC(UART1_RTS,        OUT),
0356     K210_FUNC(UART1_OUT2,       OUT),
0357     K210_FUNC(UART1_OUT1,       OUT),
0358     K210_FUNC(UART1_SIR_OUT,    OUT),
0359     K210_FUNC(UART1_BAUD,       OUT),
0360     K210_FUNC(UART1_RE,     OUT),
0361     K210_FUNC(UART1_DE,     OUT),
0362     K210_FUNC(UART1_RS485_EN,   OUT),
0363     K210_FUNC(UART2_CTS,        IN),
0364     K210_FUNC(UART2_DSR,        IN),
0365     K210_FUNC(UART2_DCD,        IN),
0366     K210_FUNC(UART2_RI,     IN),
0367     K210_FUNC(UART2_SIR_IN,     IN),
0368     K210_FUNC(UART2_DTR,        OUT),
0369     K210_FUNC(UART2_RTS,        OUT),
0370     K210_FUNC(UART2_OUT2,       OUT),
0371     K210_FUNC(UART2_OUT1,       OUT),
0372     K210_FUNC(UART2_SIR_OUT,    OUT),
0373     K210_FUNC(UART2_BAUD,       OUT),
0374     K210_FUNC(UART2_RE,     OUT),
0375     K210_FUNC(UART2_DE,     OUT),
0376     K210_FUNC(UART2_RS485_EN,   OUT),
0377     K210_FUNC(UART3_CTS,        IN),
0378     K210_FUNC(UART3_DSR,        IN),
0379     K210_FUNC(UART3_DCD,        IN),
0380     K210_FUNC(UART3_RI,     IN),
0381     K210_FUNC(UART3_SIR_IN,     IN),
0382     K210_FUNC(UART3_DTR,        OUT),
0383     K210_FUNC(UART3_RTS,        OUT),
0384     K210_FUNC(UART3_OUT2,       OUT),
0385     K210_FUNC(UART3_OUT1,       OUT),
0386     K210_FUNC(UART3_SIR_OUT,    OUT),
0387     K210_FUNC(UART3_BAUD,       OUT),
0388     K210_FUNC(UART3_RE,     OUT),
0389     K210_FUNC(UART3_DE,     OUT),
0390     K210_FUNC(UART3_RS485_EN,   OUT),
0391     K210_FUNC(TIMER0_TOGGLE1,   OUT),
0392     K210_FUNC(TIMER0_TOGGLE2,   OUT),
0393     K210_FUNC(TIMER0_TOGGLE3,   OUT),
0394     K210_FUNC(TIMER0_TOGGLE4,   OUT),
0395     K210_FUNC(TIMER1_TOGGLE1,   OUT),
0396     K210_FUNC(TIMER1_TOGGLE2,   OUT),
0397     K210_FUNC(TIMER1_TOGGLE3,   OUT),
0398     K210_FUNC(TIMER1_TOGGLE4,   OUT),
0399     K210_FUNC(TIMER2_TOGGLE1,   OUT),
0400     K210_FUNC(TIMER2_TOGGLE2,   OUT),
0401     K210_FUNC(TIMER2_TOGGLE3,   OUT),
0402     K210_FUNC(TIMER2_TOGGLE4,   OUT),
0403     K210_FUNC(CLK_SPI2,     OUT),
0404     K210_FUNC(CLK_I2C2,     OUT),
0405     K210_FUNC(INTERNAL0,        OUT),
0406     K210_FUNC(INTERNAL1,        OUT),
0407     K210_FUNC(INTERNAL2,        OUT),
0408     K210_FUNC(INTERNAL3,        OUT),
0409     K210_FUNC(INTERNAL4,        OUT),
0410     K210_FUNC(INTERNAL5,        OUT),
0411     K210_FUNC(INTERNAL6,        OUT),
0412     K210_FUNC(INTERNAL7,        OUT),
0413     K210_FUNC(INTERNAL8,        OUT),
0414     K210_FUNC(INTERNAL9,        IN),
0415     K210_FUNC(INTERNAL10,       IN),
0416     K210_FUNC(INTERNAL11,       IN),
0417     K210_FUNC(INTERNAL12,       IN),
0418     K210_FUNC(INTERNAL13,       INT13),
0419     K210_FUNC(INTERNAL14,       I2C),
0420     K210_FUNC(INTERNAL15,       IN),
0421     K210_FUNC(INTERNAL16,       IN),
0422     K210_FUNC(INTERNAL17,       IN),
0423     K210_FUNC(CONSTANT,     DISABLED),
0424     K210_FUNC(INTERNAL18,       IN),
0425     K210_FUNC(DEBUG0,       OUT),
0426     K210_FUNC(DEBUG1,       OUT),
0427     K210_FUNC(DEBUG2,       OUT),
0428     K210_FUNC(DEBUG3,       OUT),
0429     K210_FUNC(DEBUG4,       OUT),
0430     K210_FUNC(DEBUG5,       OUT),
0431     K210_FUNC(DEBUG6,       OUT),
0432     K210_FUNC(DEBUG7,       OUT),
0433     K210_FUNC(DEBUG8,       OUT),
0434     K210_FUNC(DEBUG9,       OUT),
0435     K210_FUNC(DEBUG10,      OUT),
0436     K210_FUNC(DEBUG11,      OUT),
0437     K210_FUNC(DEBUG12,      OUT),
0438     K210_FUNC(DEBUG13,      OUT),
0439     K210_FUNC(DEBUG14,      OUT),
0440     K210_FUNC(DEBUG15,      OUT),
0441     K210_FUNC(DEBUG16,      OUT),
0442     K210_FUNC(DEBUG17,      OUT),
0443     K210_FUNC(DEBUG18,      OUT),
0444     K210_FUNC(DEBUG19,      OUT),
0445     K210_FUNC(DEBUG20,      OUT),
0446     K210_FUNC(DEBUG21,      OUT),
0447     K210_FUNC(DEBUG22,      OUT),
0448     K210_FUNC(DEBUG23,      OUT),
0449     K210_FUNC(DEBUG24,      OUT),
0450     K210_FUNC(DEBUG25,      OUT),
0451     K210_FUNC(DEBUG26,      OUT),
0452     K210_FUNC(DEBUG27,      OUT),
0453     K210_FUNC(DEBUG28,      OUT),
0454     K210_FUNC(DEBUG29,      OUT),
0455     K210_FUNC(DEBUG30,      OUT),
0456     K210_FUNC(DEBUG31,      OUT),
0457 };
0458 
0459 #define PIN_CONFIG_OUTPUT_INVERT    (PIN_CONFIG_END + 1)
0460 #define PIN_CONFIG_INPUT_INVERT     (PIN_CONFIG_END + 2)
0461 
0462 static const struct pinconf_generic_params k210_pinconf_custom_params[] = {
0463     { "output-polarity-invert", PIN_CONFIG_OUTPUT_INVERT, 1 },
0464     { "input-polarity-invert",  PIN_CONFIG_INPUT_INVERT, 1 },
0465 };
0466 
0467 /*
0468  * Max drive strength in uA.
0469  */
0470 static const int k210_pinconf_drive_strength[] = {
0471     [0] = 11200,
0472     [1] = 16800,
0473     [2] = 22300,
0474     [3] = 27800,
0475     [4] = 33300,
0476     [5] = 38700,
0477     [6] = 44100,
0478     [7] = 49500,
0479 };
0480 
0481 static int k210_pinconf_get_drive(unsigned int max_strength_ua)
0482 {
0483     int i;
0484 
0485     for (i = K210_PC_DRIVE_MAX; i >= 0; i--) {
0486         if (k210_pinconf_drive_strength[i] <= max_strength_ua)
0487             return i;
0488     }
0489 
0490     return -EINVAL;
0491 }
0492 
0493 static void k210_pinmux_set_pin_function(struct pinctrl_dev *pctldev,
0494                      u32 pin, u32 func)
0495 {
0496     struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
0497     const struct k210_pcf_info *info = &k210_pcf_infos[func];
0498     u32 mode = k210_pinconf_mode_id_to_mode[info->mode_id];
0499     u32 val = func | mode;
0500 
0501     dev_dbg(pdata->dev, "set pin %u function %s (%u) -> 0x%08x\n",
0502         pin, info->name, func, val);
0503 
0504     writel(val, &pdata->fpioa->pins[pin]);
0505 }
0506 
0507 static int k210_pinconf_set_param(struct pinctrl_dev *pctldev,
0508                   unsigned int pin,
0509                   unsigned int param, unsigned int arg)
0510 {
0511     struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
0512     u32 val = readl(&pdata->fpioa->pins[pin]);
0513     int drive;
0514 
0515     dev_dbg(pdata->dev, "set pin %u param %u, arg 0x%x\n",
0516         pin, param, arg);
0517 
0518     switch (param) {
0519     case PIN_CONFIG_BIAS_DISABLE:
0520         val &= ~K210_PC_BIAS_MASK;
0521         break;
0522     case PIN_CONFIG_BIAS_PULL_DOWN:
0523         if (!arg)
0524             return -EINVAL;
0525         val |= K210_PC_PD;
0526         break;
0527     case PIN_CONFIG_BIAS_PULL_UP:
0528         if (!arg)
0529             return -EINVAL;
0530         val |= K210_PC_PU;
0531         break;
0532     case PIN_CONFIG_DRIVE_STRENGTH:
0533         arg *= 1000;
0534         fallthrough;
0535     case PIN_CONFIG_DRIVE_STRENGTH_UA:
0536         drive = k210_pinconf_get_drive(arg);
0537         if (drive < 0)
0538             return drive;
0539         val &= ~K210_PC_DRIVE_MASK;
0540         val |= FIELD_PREP(K210_PC_DRIVE_MASK, drive);
0541         break;
0542     case PIN_CONFIG_INPUT_ENABLE:
0543         if (arg)
0544             val |= K210_PC_IE;
0545         else
0546             val &= ~K210_PC_IE;
0547         break;
0548     case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
0549         if (arg)
0550             val |= K210_PC_ST;
0551         else
0552             val &= ~K210_PC_ST;
0553         break;
0554     case PIN_CONFIG_OUTPUT:
0555         k210_pinmux_set_pin_function(pctldev, pin, K210_PCF_CONSTANT);
0556         val = readl(&pdata->fpioa->pins[pin]);
0557         val |= K210_PC_MODE_OUT;
0558         if (!arg)
0559             val |= K210_PC_DO_INV;
0560         break;
0561     case PIN_CONFIG_OUTPUT_ENABLE:
0562         if (arg)
0563             val |= K210_PC_OE;
0564         else
0565             val &= ~K210_PC_OE;
0566         break;
0567     case PIN_CONFIG_SLEW_RATE:
0568         if (arg)
0569             val |= K210_PC_SL;
0570         else
0571             val &= ~K210_PC_SL;
0572         break;
0573     case PIN_CONFIG_OUTPUT_INVERT:
0574         if (arg)
0575             val |= K210_PC_DO_INV;
0576         else
0577             val &= ~K210_PC_DO_INV;
0578         break;
0579     case PIN_CONFIG_INPUT_INVERT:
0580         if (arg)
0581             val |= K210_PC_DI_INV;
0582         else
0583             val &= ~K210_PC_DI_INV;
0584         break;
0585     default:
0586         return -EINVAL;
0587     }
0588 
0589     writel(val, &pdata->fpioa->pins[pin]);
0590 
0591     return 0;
0592 }
0593 
0594 static int k210_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
0595                 unsigned long *configs, unsigned int num_configs)
0596 {
0597     unsigned int param, arg;
0598     int i, ret;
0599 
0600     if (WARN_ON(pin >= K210_NPINS))
0601         return -EINVAL;
0602 
0603     for (i = 0; i < num_configs; i++) {
0604         param = pinconf_to_config_param(configs[i]);
0605         arg = pinconf_to_config_argument(configs[i]);
0606         ret = k210_pinconf_set_param(pctldev, pin, param, arg);
0607         if (ret)
0608             return ret;
0609     }
0610 
0611     return 0;
0612 }
0613 
0614 static void k210_pinconf_dbg_show(struct pinctrl_dev *pctldev,
0615                   struct seq_file *s, unsigned int pin)
0616 {
0617     struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
0618 
0619     seq_printf(s, "%#x", readl(&pdata->fpioa->pins[pin]));
0620 }
0621 
0622 static int k210_pinconf_group_set(struct pinctrl_dev *pctldev,
0623                   unsigned int selector, unsigned long *configs,
0624                   unsigned int num_configs)
0625 {
0626     struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
0627     unsigned int param, arg;
0628     u32 bit;
0629     int i;
0630 
0631     /* Pins should be configured with pinmux, not groups*/
0632     if (selector < K210_NPINS)
0633         return -EINVAL;
0634 
0635     /* Otherwise it's a power domain */
0636     for (i = 0; i < num_configs; i++) {
0637         param = pinconf_to_config_param(configs[i]);
0638         if (param != PIN_CONFIG_POWER_SOURCE)
0639             return -EINVAL;
0640 
0641         arg = pinconf_to_config_argument(configs[i]);
0642         bit = BIT(selector - K210_NPINS);
0643         regmap_update_bits(pdata->sysctl_map,
0644                    pdata->power_offset,
0645                    bit, arg ? bit : 0);
0646     }
0647 
0648     return 0;
0649 }
0650 
0651 static void k210_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
0652                     struct seq_file *s,
0653                     unsigned int selector)
0654 {
0655     struct k210_fpioa_data *pdata = pinctrl_dev_get_drvdata(pctldev);
0656     int ret;
0657     u32 val;
0658 
0659     if (selector < K210_NPINS)
0660         return k210_pinconf_dbg_show(pctldev, s, selector);
0661 
0662     ret = regmap_read(pdata->sysctl_map, pdata->power_offset, &val);
0663     if (ret) {
0664         dev_err(pdata->dev, "Failed to read power reg\n");
0665         return;
0666     }
0667 
0668     seq_printf(s, "%s: %s V", k210_group_names[selector],
0669            val & BIT(selector - K210_NPINS) ? "1.8" : "3.3");
0670 }
0671 
0672 static const struct pinconf_ops k210_pinconf_ops = {
0673     .is_generic = true,
0674     .pin_config_set = k210_pinconf_set,
0675     .pin_config_group_set = k210_pinconf_group_set,
0676     .pin_config_dbg_show = k210_pinconf_dbg_show,
0677     .pin_config_group_dbg_show = k210_pinconf_group_dbg_show,
0678 };
0679 
0680 static int k210_pinmux_get_function_count(struct pinctrl_dev *pctldev)
0681 {
0682     return ARRAY_SIZE(k210_pcf_infos);
0683 }
0684 
0685 static const char *k210_pinmux_get_function_name(struct pinctrl_dev *pctldev,
0686                          unsigned int selector)
0687 {
0688     return k210_pcf_infos[selector].name;
0689 }
0690 
0691 static int k210_pinmux_get_function_groups(struct pinctrl_dev *pctldev,
0692                        unsigned int selector,
0693                        const char * const **groups,
0694                        unsigned int * const num_groups)
0695 {
0696     /* Any function can be mapped to any pin */
0697     *groups = k210_group_names;
0698     *num_groups = K210_NPINS;
0699 
0700     return 0;
0701 }
0702 
0703 static int k210_pinmux_set_mux(struct pinctrl_dev *pctldev,
0704                    unsigned int function,
0705                    unsigned int group)
0706 {
0707     /* Can't mux power domains */
0708     if (group >= K210_NPINS)
0709         return -EINVAL;
0710 
0711     k210_pinmux_set_pin_function(pctldev, group, function);
0712 
0713     return 0;
0714 }
0715 
0716 static const struct pinmux_ops k210_pinmux_ops = {
0717     .get_functions_count = k210_pinmux_get_function_count,
0718     .get_function_name = k210_pinmux_get_function_name,
0719     .get_function_groups = k210_pinmux_get_function_groups,
0720     .set_mux = k210_pinmux_set_mux,
0721     .strict = true,
0722 };
0723 
0724 static int k210_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
0725 {
0726     return K210_NGROUPS;
0727 }
0728 
0729 static const char *k210_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
0730                            unsigned int group)
0731 {
0732     return k210_group_names[group];
0733 }
0734 
0735 static int k210_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
0736                        unsigned int group,
0737                        const unsigned int **pins,
0738                        unsigned int *npins)
0739 {
0740     if (group >= K210_NPINS) {
0741         *pins = NULL;
0742         *npins = 0;
0743         return 0;
0744     }
0745 
0746     *pins = &k210_pins[group].number;
0747     *npins = 1;
0748 
0749     return 0;
0750 }
0751 
0752 static void k210_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
0753                       struct seq_file *s, unsigned int offset)
0754 {
0755     seq_printf(s, "%s", dev_name(pctldev->dev));
0756 }
0757 
0758 static int k210_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
0759                       struct device_node *np,
0760                       struct pinctrl_map **map,
0761                       unsigned int *reserved_maps,
0762                       unsigned int *num_maps)
0763 {
0764     struct property *prop;
0765     const __be32 *p;
0766     int ret, pinmux_groups;
0767     u32 pinmux_group;
0768     unsigned long *configs = NULL;
0769     unsigned int num_configs = 0;
0770     unsigned int reserve = 0;
0771 
0772     ret = of_property_count_strings(np, "groups");
0773     if (!ret)
0774         return pinconf_generic_dt_subnode_to_map(pctldev, np, map,
0775                         reserved_maps, num_maps,
0776                         PIN_MAP_TYPE_CONFIGS_GROUP);
0777 
0778     pinmux_groups = of_property_count_u32_elems(np, "pinmux");
0779     if (pinmux_groups <= 0) {
0780         /* Ignore this node */
0781         return 0;
0782     }
0783 
0784     ret = pinconf_generic_parse_dt_config(np, pctldev, &configs,
0785                           &num_configs);
0786     if (ret < 0) {
0787         dev_err(pctldev->dev, "%pOF: could not parse node property\n",
0788             np);
0789         return ret;
0790     }
0791 
0792     reserve = pinmux_groups * (1 + num_configs);
0793     ret = pinctrl_utils_reserve_map(pctldev, map, reserved_maps, num_maps,
0794                     reserve);
0795     if (ret < 0)
0796         goto exit;
0797 
0798     of_property_for_each_u32(np, "pinmux", prop, p, pinmux_group) {
0799         const char *group_name, *func_name;
0800         u32 pin = FIELD_GET(K210_PG_PIN, pinmux_group);
0801         u32 func = FIELD_GET(K210_PG_FUNC, pinmux_group);
0802 
0803         if (pin >= K210_NPINS) {
0804             ret = -EINVAL;
0805             goto exit;
0806         }
0807 
0808         group_name = k210_group_names[pin];
0809         func_name = k210_pcf_infos[func].name;
0810 
0811         dev_dbg(pctldev->dev, "Pinmux %s: pin %u func %s\n",
0812             np->name, pin, func_name);
0813 
0814         ret = pinctrl_utils_add_map_mux(pctldev, map, reserved_maps,
0815                         num_maps, group_name,
0816                         func_name);
0817         if (ret < 0) {
0818             dev_err(pctldev->dev, "%pOF add mux map failed %d\n",
0819                 np, ret);
0820             goto exit;
0821         }
0822 
0823         if (num_configs) {
0824             ret = pinctrl_utils_add_map_configs(pctldev, map,
0825                     reserved_maps, num_maps, group_name,
0826                     configs, num_configs,
0827                     PIN_MAP_TYPE_CONFIGS_PIN);
0828             if (ret < 0) {
0829                 dev_err(pctldev->dev,
0830                     "%pOF add configs map failed %d\n",
0831                     np, ret);
0832                 goto exit;
0833             }
0834         }
0835     }
0836 
0837     ret = 0;
0838 
0839 exit:
0840     kfree(configs);
0841     return ret;
0842 }
0843 
0844 static int k210_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,
0845                        struct device_node *np_config,
0846                        struct pinctrl_map **map,
0847                        unsigned int *num_maps)
0848 {
0849     unsigned int reserved_maps;
0850     struct device_node *np;
0851     int ret;
0852 
0853     reserved_maps = 0;
0854     *map = NULL;
0855     *num_maps = 0;
0856 
0857     ret = k210_pinctrl_dt_subnode_to_map(pctldev, np_config, map,
0858                          &reserved_maps, num_maps);
0859     if (ret < 0)
0860         goto err;
0861 
0862     for_each_available_child_of_node(np_config, np) {
0863         ret = k210_pinctrl_dt_subnode_to_map(pctldev, np, map,
0864                              &reserved_maps, num_maps);
0865         if (ret < 0)
0866             goto err;
0867     }
0868     return 0;
0869 
0870 err:
0871     pinctrl_utils_free_map(pctldev, *map, *num_maps);
0872     return ret;
0873 }
0874 
0875 
0876 static const struct pinctrl_ops k210_pinctrl_ops = {
0877     .get_groups_count = k210_pinctrl_get_groups_count,
0878     .get_group_name = k210_pinctrl_get_group_name,
0879     .get_group_pins = k210_pinctrl_get_group_pins,
0880     .pin_dbg_show = k210_pinctrl_pin_dbg_show,
0881     .dt_node_to_map = k210_pinctrl_dt_node_to_map,
0882     .dt_free_map = pinconf_generic_dt_free_map,
0883 };
0884 
0885 static struct pinctrl_desc k210_pinctrl_desc = {
0886     .name = "k210-pinctrl",
0887     .pins = k210_pins,
0888     .npins = K210_NPINS,
0889     .pctlops = &k210_pinctrl_ops,
0890     .pmxops = &k210_pinmux_ops,
0891     .confops = &k210_pinconf_ops,
0892     .custom_params = k210_pinconf_custom_params,
0893     .num_custom_params = ARRAY_SIZE(k210_pinconf_custom_params),
0894 };
0895 
0896 static void k210_fpioa_init_ties(struct k210_fpioa_data *pdata)
0897 {
0898     struct k210_fpioa __iomem *fpioa = pdata->fpioa;
0899     u32 val;
0900     int i, j;
0901 
0902     dev_dbg(pdata->dev, "Init pin ties\n");
0903 
0904     /* Init pin functions input ties */
0905     for (i = 0; i < ARRAY_SIZE(fpioa->tie_en); i++) {
0906         val = 0;
0907         for (j = 0; j < 32; j++) {
0908             if (k210_pcf_infos[i * 32 + j].mode_id ==
0909                 K210_PC_DEFAULT_IN_TIE) {
0910                 dev_dbg(pdata->dev,
0911                     "tie_en function %d (%s)\n",
0912                     i * 32 + j,
0913                     k210_pcf_infos[i * 32 + j].name);
0914                 val |= BIT(j);
0915             }
0916         }
0917 
0918         /* Set value before enable */
0919         writel(val, &fpioa->tie_val[i]);
0920         writel(val, &fpioa->tie_en[i]);
0921     }
0922 }
0923 
0924 static int k210_fpioa_probe(struct platform_device *pdev)
0925 {
0926     struct device *dev = &pdev->dev;
0927     struct device_node *np = dev->of_node;
0928     struct k210_fpioa_data *pdata;
0929     int ret;
0930 
0931     dev_info(dev, "K210 FPIOA pin controller\n");
0932 
0933     pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
0934     if (!pdata)
0935         return -ENOMEM;
0936 
0937     pdata->dev = dev;
0938     platform_set_drvdata(pdev, pdata);
0939 
0940     pdata->fpioa = devm_platform_ioremap_resource(pdev, 0);
0941     if (IS_ERR(pdata->fpioa))
0942         return PTR_ERR(pdata->fpioa);
0943 
0944     pdata->clk = devm_clk_get(dev, "ref");
0945     if (IS_ERR(pdata->clk))
0946         return PTR_ERR(pdata->clk);
0947 
0948     ret = clk_prepare_enable(pdata->clk);
0949     if (ret)
0950         return ret;
0951 
0952     pdata->pclk = devm_clk_get_optional(dev, "pclk");
0953     if (!IS_ERR(pdata->pclk)) {
0954         ret = clk_prepare_enable(pdata->pclk);
0955         if (ret)
0956             goto disable_clk;
0957     }
0958 
0959     pdata->sysctl_map =
0960         syscon_regmap_lookup_by_phandle_args(np,
0961                         "canaan,k210-sysctl-power",
0962                         1, &pdata->power_offset);
0963     if (IS_ERR(pdata->sysctl_map)) {
0964         ret = PTR_ERR(pdata->sysctl_map);
0965         goto disable_pclk;
0966     }
0967 
0968     k210_fpioa_init_ties(pdata);
0969 
0970     pdata->pctl = pinctrl_register(&k210_pinctrl_desc, dev, (void *)pdata);
0971     if (IS_ERR(pdata->pctl)) {
0972         ret = PTR_ERR(pdata->pctl);
0973         goto disable_pclk;
0974     }
0975 
0976     return 0;
0977 
0978 disable_pclk:
0979     clk_disable_unprepare(pdata->pclk);
0980 disable_clk:
0981     clk_disable_unprepare(pdata->clk);
0982 
0983     return ret;
0984 }
0985 
0986 static const struct of_device_id k210_fpioa_dt_ids[] = {
0987     { .compatible = "canaan,k210-fpioa" },
0988     { /* sentinel */ },
0989 };
0990 
0991 static struct platform_driver k210_fpioa_driver = {
0992     .probe  = k210_fpioa_probe,
0993     .driver = {
0994         .name       = "k210-fpioa",
0995         .of_match_table = k210_fpioa_dt_ids,
0996     },
0997 };
0998 builtin_platform_driver(k210_fpioa_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!