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