1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Pistachio SoC pinctrl driver 4 * 5 * Copyright (C) 2014 Imagination Technologies Ltd. 6 * Copyright (C) 2014 Google, Inc. 7 */ 8 9 #include <linux/gpio/driver.h> 10 #include <linux/interrupt.h> 11 #include <linux/io.h> 12 #include <linux/irq.h> 13 #include <linux/mod_devicetable.h> 14 #include <linux/pinctrl/pinconf.h> 15 #include <linux/pinctrl/pinconf-generic.h> 16 #include <linux/pinctrl/pinctrl.h> 17 #include <linux/pinctrl/pinmux.h> 18 #include <linux/platform_device.h> 19 #include <linux/property.h> 20 #include <linux/seq_file.h> 21 #include <linux/slab.h> 22 #include <linux/spinlock.h> 23 24 #include "pinctrl-utils.h" 25 26 #define PADS_SCHMITT_EN0 0x000 27 #define PADS_SCHMITT_EN_REG(pin) (PADS_SCHMITT_EN0 + 0x4 * ((pin) / 32)) 28 #define PADS_SCHMITT_EN_BIT(pin) BIT((pin) % 32) 29 30 #define PADS_PU_PD0 0x040 31 #define PADS_PU_PD_REG(pin) (PADS_PU_PD0 + 0x4 * ((pin) / 16)) 32 #define PADS_PU_PD_SHIFT(pin) (2 * ((pin) % 16)) 33 #define PADS_PU_PD_MASK 0x3 34 #define PADS_PU_PD_HIGHZ 0x0 35 #define PADS_PU_PD_UP 0x1 36 #define PADS_PU_PD_DOWN 0x2 37 #define PADS_PU_PD_BUS 0x3 38 39 #define PADS_FUNCTION_SELECT0 0x0c0 40 #define PADS_FUNCTION_SELECT1 0x0c4 41 #define PADS_FUNCTION_SELECT2 0x0c8 42 #define PADS_SCENARIO_SELECT 0x0f8 43 44 #define PADS_SLEW_RATE0 0x100 45 #define PADS_SLEW_RATE_REG(pin) (PADS_SLEW_RATE0 + 0x4 * ((pin) / 32)) 46 #define PADS_SLEW_RATE_BIT(pin) BIT((pin) % 32) 47 48 #define PADS_DRIVE_STRENGTH0 0x120 49 #define PADS_DRIVE_STRENGTH_REG(pin) \ 50 (PADS_DRIVE_STRENGTH0 + 0x4 * ((pin) / 16)) 51 #define PADS_DRIVE_STRENGTH_SHIFT(pin) (2 * ((pin) % 16)) 52 #define PADS_DRIVE_STRENGTH_MASK 0x3 53 #define PADS_DRIVE_STRENGTH_2MA 0x0 54 #define PADS_DRIVE_STRENGTH_4MA 0x1 55 #define PADS_DRIVE_STRENGTH_8MA 0x2 56 #define PADS_DRIVE_STRENGTH_12MA 0x3 57 58 #define GPIO_BANK_BASE(bank) (0x200 + 0x24 * (bank)) 59 60 #define GPIO_BIT_EN 0x00 61 #define GPIO_OUTPUT_EN 0x04 62 #define GPIO_OUTPUT 0x08 63 #define GPIO_INPUT 0x0c 64 #define GPIO_INPUT_POLARITY 0x10 65 #define GPIO_INTERRUPT_TYPE 0x14 66 #define GPIO_INTERRUPT_TYPE_LEVEL 0x0 67 #define GPIO_INTERRUPT_TYPE_EDGE 0x1 68 #define GPIO_INTERRUPT_EDGE 0x18 69 #define GPIO_INTERRUPT_EDGE_SINGLE 0x0 70 #define GPIO_INTERRUPT_EDGE_DUAL 0x1 71 #define GPIO_INTERRUPT_EN 0x1c 72 #define GPIO_INTERRUPT_STATUS 0x20 73 74 struct pistachio_function { 75 const char *name; 76 const char * const *groups; 77 unsigned int ngroups; 78 const int *scenarios; 79 unsigned int nscenarios; 80 unsigned int scenario_reg; 81 unsigned int scenario_shift; 82 unsigned int scenario_mask; 83 }; 84 85 struct pistachio_pin_group { 86 const char *name; 87 unsigned int pin; 88 int mux_option[3]; 89 int mux_reg; 90 int mux_shift; 91 int mux_mask; 92 }; 93 94 struct pistachio_gpio_bank { 95 struct pistachio_pinctrl *pctl; 96 void __iomem *base; 97 int instance; 98 unsigned int pin_base; 99 unsigned int npins; 100 struct gpio_chip gpio_chip; 101 }; 102 103 struct pistachio_pinctrl { 104 struct device *dev; 105 void __iomem *base; 106 struct pinctrl_dev *pctldev; 107 const struct pinctrl_pin_desc *pins; 108 unsigned int npins; 109 const struct pistachio_function *functions; 110 unsigned int nfunctions; 111 const struct pistachio_pin_group *groups; 112 unsigned int ngroups; 113 struct pistachio_gpio_bank *gpio_banks; 114 unsigned int nbanks; 115 }; 116 117 #define PISTACHIO_PIN_MFIO(p) (p) 118 #define PISTACHIO_PIN_TCK 90 119 #define PISTACHIO_PIN_TRSTN 91 120 #define PISTACHIO_PIN_TDI 92 121 #define PISTACHIO_PIN_TMS 93 122 #define PISTACHIO_PIN_TDO 94 123 #define PISTACHIO_PIN_JTAG_COMPLY 95 124 #define PISTACHIO_PIN_SAFE_MODE 96 125 #define PISTACHIO_PIN_POR_DISABLE 97 126 #define PISTACHIO_PIN_RESETN 98 127 128 #define MFIO_PIN_DESC(p) PINCTRL_PIN(PISTACHIO_PIN_MFIO(p), "mfio" #p) 129 130 static const struct pinctrl_pin_desc pistachio_pins[] = { 131 MFIO_PIN_DESC(0), 132 MFIO_PIN_DESC(1), 133 MFIO_PIN_DESC(2), 134 MFIO_PIN_DESC(3), 135 MFIO_PIN_DESC(4), 136 MFIO_PIN_DESC(5), 137 MFIO_PIN_DESC(6), 138 MFIO_PIN_DESC(7), 139 MFIO_PIN_DESC(8), 140 MFIO_PIN_DESC(9), 141 MFIO_PIN_DESC(10), 142 MFIO_PIN_DESC(11), 143 MFIO_PIN_DESC(12), 144 MFIO_PIN_DESC(13), 145 MFIO_PIN_DESC(14), 146 MFIO_PIN_DESC(15), 147 MFIO_PIN_DESC(16), 148 MFIO_PIN_DESC(17), 149 MFIO_PIN_DESC(18), 150 MFIO_PIN_DESC(19), 151 MFIO_PIN_DESC(20), 152 MFIO_PIN_DESC(21), 153 MFIO_PIN_DESC(22), 154 MFIO_PIN_DESC(23), 155 MFIO_PIN_DESC(24), 156 MFIO_PIN_DESC(25), 157 MFIO_PIN_DESC(26), 158 MFIO_PIN_DESC(27), 159 MFIO_PIN_DESC(28), 160 MFIO_PIN_DESC(29), 161 MFIO_PIN_DESC(30), 162 MFIO_PIN_DESC(31), 163 MFIO_PIN_DESC(32), 164 MFIO_PIN_DESC(33), 165 MFIO_PIN_DESC(34), 166 MFIO_PIN_DESC(35), 167 MFIO_PIN_DESC(36), 168 MFIO_PIN_DESC(37), 169 MFIO_PIN_DESC(38), 170 MFIO_PIN_DESC(39), 171 MFIO_PIN_DESC(40), 172 MFIO_PIN_DESC(41), 173 MFIO_PIN_DESC(42), 174 MFIO_PIN_DESC(43), 175 MFIO_PIN_DESC(44), 176 MFIO_PIN_DESC(45), 177 MFIO_PIN_DESC(46), 178 MFIO_PIN_DESC(47), 179 MFIO_PIN_DESC(48), 180 MFIO_PIN_DESC(49), 181 MFIO_PIN_DESC(50), 182 MFIO_PIN_DESC(51), 183 MFIO_PIN_DESC(52), 184 MFIO_PIN_DESC(53), 185 MFIO_PIN_DESC(54), 186 MFIO_PIN_DESC(55), 187 MFIO_PIN_DESC(56), 188 MFIO_PIN_DESC(57), 189 MFIO_PIN_DESC(58), 190 MFIO_PIN_DESC(59), 191 MFIO_PIN_DESC(60), 192 MFIO_PIN_DESC(61), 193 MFIO_PIN_DESC(62), 194 MFIO_PIN_DESC(63), 195 MFIO_PIN_DESC(64), 196 MFIO_PIN_DESC(65), 197 MFIO_PIN_DESC(66), 198 MFIO_PIN_DESC(67), 199 MFIO_PIN_DESC(68), 200 MFIO_PIN_DESC(69), 201 MFIO_PIN_DESC(70), 202 MFIO_PIN_DESC(71), 203 MFIO_PIN_DESC(72), 204 MFIO_PIN_DESC(73), 205 MFIO_PIN_DESC(74), 206 MFIO_PIN_DESC(75), 207 MFIO_PIN_DESC(76), 208 MFIO_PIN_DESC(77), 209 MFIO_PIN_DESC(78), 210 MFIO_PIN_DESC(79), 211 MFIO_PIN_DESC(80), 212 MFIO_PIN_DESC(81), 213 MFIO_PIN_DESC(82), 214 MFIO_PIN_DESC(83), 215 MFIO_PIN_DESC(84), 216 MFIO_PIN_DESC(85), 217 MFIO_PIN_DESC(86), 218 MFIO_PIN_DESC(87), 219 MFIO_PIN_DESC(88), 220 MFIO_PIN_DESC(89), 221 PINCTRL_PIN(PISTACHIO_PIN_TCK, "tck"), 222 PINCTRL_PIN(PISTACHIO_PIN_TRSTN, "trstn"), 223 PINCTRL_PIN(PISTACHIO_PIN_TDI, "tdi"), 224 PINCTRL_PIN(PISTACHIO_PIN_TMS, "tms"), 225 PINCTRL_PIN(PISTACHIO_PIN_TDO, "tdo"), 226 PINCTRL_PIN(PISTACHIO_PIN_JTAG_COMPLY, "jtag_comply"), 227 PINCTRL_PIN(PISTACHIO_PIN_SAFE_MODE, "safe_mode"), 228 PINCTRL_PIN(PISTACHIO_PIN_POR_DISABLE, "por_disable"), 229 PINCTRL_PIN(PISTACHIO_PIN_RESETN, "resetn"), 230 }; 231 232 static const char * const pistachio_spim0_groups[] = { 233 "mfio1", "mfio2", "mfio8", "mfio9", "mfio10", "mfio28", "mfio29", 234 "mfio30", "mfio55", "mfio56", "mfio57", 235 }; 236 237 static const char * const pistachio_spim1_groups[] = { 238 "mfio0", "mfio1", "mfio2", "mfio3", "mfio4", "mfio5", "mfio6", 239 "mfio7", "mfio31", "mfio55", "mfio56", "mfio57", "mfio58", 240 }; 241 242 static const char * const pistachio_spis_groups[] = { 243 "mfio11", "mfio12", "mfio13", "mfio14", 244 }; 245 246 static const char *const pistachio_sdhost_groups[] = { 247 "mfio15", "mfio16", "mfio17", "mfio18", "mfio19", "mfio20", 248 "mfio21", "mfio22", "mfio23", "mfio24", "mfio25", "mfio26", 249 "mfio27", 250 }; 251 252 static const char * const pistachio_i2c0_groups[] = { 253 "mfio28", "mfio29", 254 }; 255 256 static const char * const pistachio_i2c1_groups[] = { 257 "mfio30", "mfio31", 258 }; 259 260 static const char * const pistachio_i2c2_groups[] = { 261 "mfio32", "mfio33", 262 }; 263 264 static const char * const pistachio_i2c3_groups[] = { 265 "mfio34", "mfio35", 266 }; 267 268 static const char * const pistachio_audio_clk_in_groups[] = { 269 "mfio36", 270 }; 271 272 static const char * const pistachio_i2s_out_groups[] = { 273 "mfio36", "mfio37", "mfio38", "mfio39", "mfio40", "mfio41", 274 "mfio42", "mfio43", "mfio44", 275 }; 276 277 static const char * const pistachio_debug_raw_cca_ind_groups[] = { 278 "mfio37", 279 }; 280 281 static const char * const pistachio_debug_ed_sec20_cca_ind_groups[] = { 282 "mfio38", 283 }; 284 285 static const char * const pistachio_debug_ed_sec40_cca_ind_groups[] = { 286 "mfio39", 287 }; 288 289 static const char * const pistachio_debug_agc_done_0_groups[] = { 290 "mfio40", 291 }; 292 293 static const char * const pistachio_debug_agc_done_1_groups[] = { 294 "mfio41", 295 }; 296 297 static const char * const pistachio_debug_ed_cca_ind_groups[] = { 298 "mfio42", 299 }; 300 301 static const char * const pistachio_debug_s2l_done_groups[] = { 302 "mfio43", 303 }; 304 305 static const char * const pistachio_i2s_dac_clk_groups[] = { 306 "mfio45", 307 }; 308 309 static const char * const pistachio_audio_sync_groups[] = { 310 "mfio45", 311 }; 312 313 static const char * const pistachio_audio_trigger_groups[] = { 314 "mfio46", 315 }; 316 317 static const char * const pistachio_i2s_in_groups[] = { 318 "mfio47", "mfio48", "mfio49", "mfio50", "mfio51", "mfio52", 319 "mfio53", "mfio54", 320 }; 321 322 static const char * const pistachio_uart0_groups[] = { 323 "mfio55", "mfio56", "mfio57", "mfio58", 324 }; 325 326 static const char * const pistachio_uart1_groups[] = { 327 "mfio59", "mfio60", "mfio1", "mfio2", 328 }; 329 330 static const char * const pistachio_spdif_out_groups[] = { 331 "mfio61", 332 }; 333 334 static const char * const pistachio_spdif_in_groups[] = { 335 "mfio62", "mfio54", 336 }; 337 static const int pistachio_spdif_in_scenarios[] = { 338 PISTACHIO_PIN_MFIO(62), 339 PISTACHIO_PIN_MFIO(54), 340 }; 341 342 static const char * const pistachio_eth_groups[] = { 343 "mfio63", "mfio64", "mfio65", "mfio66", "mfio67", "mfio68", 344 "mfio69", "mfio70", "mfio71", 345 }; 346 347 static const char * const pistachio_ir_groups[] = { 348 "mfio72", 349 }; 350 351 static const char * const pistachio_pwmpdm_groups[] = { 352 "mfio73", "mfio74", "mfio75", "mfio76", 353 }; 354 355 static const char * const pistachio_mips_trace_clk_groups[] = { 356 "mfio15", "mfio63", "mfio73", 357 }; 358 359 static const char * const pistachio_mips_trace_dint_groups[] = { 360 "mfio16", "mfio64", "mfio74", 361 }; 362 static const int pistachio_mips_trace_dint_scenarios[] = { 363 PISTACHIO_PIN_MFIO(16), 364 PISTACHIO_PIN_MFIO(64), 365 PISTACHIO_PIN_MFIO(74), 366 }; 367 368 static const char * const pistachio_mips_trace_trigout_groups[] = { 369 "mfio17", "mfio65", "mfio75", 370 }; 371 372 static const char * const pistachio_mips_trace_trigin_groups[] = { 373 "mfio18", "mfio66", "mfio76", 374 }; 375 static const int pistachio_mips_trace_trigin_scenarios[] = { 376 PISTACHIO_PIN_MFIO(18), 377 PISTACHIO_PIN_MFIO(66), 378 PISTACHIO_PIN_MFIO(76), 379 }; 380 381 static const char * const pistachio_mips_trace_dm_groups[] = { 382 "mfio19", "mfio67", "mfio77", 383 }; 384 385 static const char * const pistachio_mips_probe_n_groups[] = { 386 "mfio20", "mfio68", "mfio78", 387 }; 388 static const int pistachio_mips_probe_n_scenarios[] = { 389 PISTACHIO_PIN_MFIO(20), 390 PISTACHIO_PIN_MFIO(68), 391 PISTACHIO_PIN_MFIO(78), 392 }; 393 394 static const char * const pistachio_mips_trace_data_groups[] = { 395 "mfio15", "mfio16", "mfio17", "mfio18", "mfio19", "mfio20", 396 "mfio21", "mfio22", "mfio63", "mfio64", "mfio65", "mfio66", 397 "mfio67", "mfio68", "mfio69", "mfio70", "mfio79", "mfio80", 398 "mfio81", "mfio82", "mfio83", "mfio84", "mfio85", "mfio86", 399 }; 400 401 static const char * const pistachio_sram_debug_groups[] = { 402 "mfio73", "mfio74", 403 }; 404 405 static const char * const pistachio_rom_debug_groups[] = { 406 "mfio75", "mfio76", 407 }; 408 409 static const char * const pistachio_rpu_debug_groups[] = { 410 "mfio77", "mfio78", 411 }; 412 413 static const char * const pistachio_mips_debug_groups[] = { 414 "mfio79", "mfio80", 415 }; 416 417 static const char * const pistachio_eth_debug_groups[] = { 418 "mfio81", "mfio82", 419 }; 420 421 static const char * const pistachio_usb_debug_groups[] = { 422 "mfio83", "mfio84", 423 }; 424 425 static const char * const pistachio_sdhost_debug_groups[] = { 426 "mfio85", "mfio86", 427 }; 428 429 static const char * const pistachio_socif_debug_groups[] = { 430 "mfio87", "mfio88", 431 }; 432 433 static const char * const pistachio_mdc_debug_groups[] = { 434 "mfio77", "mfio78", 435 }; 436 437 static const char * const pistachio_ddr_debug_groups[] = { 438 "mfio79", "mfio80", 439 }; 440 441 static const char * const pistachio_dreq0_groups[] = { 442 "mfio81", 443 }; 444 445 static const char * const pistachio_dreq1_groups[] = { 446 "mfio82", 447 }; 448 449 static const char * const pistachio_dreq2_groups[] = { 450 "mfio87", 451 }; 452 453 static const char * const pistachio_dreq3_groups[] = { 454 "mfio88", 455 }; 456 457 static const char * const pistachio_dreq4_groups[] = { 458 "mfio89", 459 }; 460 461 static const char * const pistachio_dreq5_groups[] = { 462 "mfio89", 463 }; 464 465 static const char * const pistachio_mips_pll_lock_groups[] = { 466 "mfio83", 467 }; 468 469 static const char * const pistachio_audio_pll_lock_groups[] = { 470 "mfio84", 471 }; 472 473 static const char * const pistachio_rpu_v_pll_lock_groups[] = { 474 "mfio85", 475 }; 476 477 static const char * const pistachio_rpu_l_pll_lock_groups[] = { 478 "mfio86", 479 }; 480 481 static const char * const pistachio_sys_pll_lock_groups[] = { 482 "mfio87", 483 }; 484 485 static const char * const pistachio_wifi_pll_lock_groups[] = { 486 "mfio88", 487 }; 488 489 static const char * const pistachio_bt_pll_lock_groups[] = { 490 "mfio89", 491 }; 492 493 #define FUNCTION(_name) \ 494 { \ 495 .name = #_name, \ 496 .groups = pistachio_##_name##_groups, \ 497 .ngroups = ARRAY_SIZE(pistachio_##_name##_groups), \ 498 } 499 500 #define FUNCTION_SCENARIO(_name, _reg, _shift, _mask) \ 501 { \ 502 .name = #_name, \ 503 .groups = pistachio_##_name##_groups, \ 504 .ngroups = ARRAY_SIZE(pistachio_##_name##_groups), \ 505 .scenarios = pistachio_##_name##_scenarios, \ 506 .nscenarios = ARRAY_SIZE(pistachio_##_name##_scenarios),\ 507 .scenario_reg = _reg, \ 508 .scenario_shift = _shift, \ 509 .scenario_mask = _mask, \ 510 } 511 512 enum pistachio_mux_option { 513 PISTACHIO_FUNCTION_NONE = -1, 514 PISTACHIO_FUNCTION_SPIM0, 515 PISTACHIO_FUNCTION_SPIM1, 516 PISTACHIO_FUNCTION_SPIS, 517 PISTACHIO_FUNCTION_SDHOST, 518 PISTACHIO_FUNCTION_I2C0, 519 PISTACHIO_FUNCTION_I2C1, 520 PISTACHIO_FUNCTION_I2C2, 521 PISTACHIO_FUNCTION_I2C3, 522 PISTACHIO_FUNCTION_AUDIO_CLK_IN, 523 PISTACHIO_FUNCTION_I2S_OUT, 524 PISTACHIO_FUNCTION_I2S_DAC_CLK, 525 PISTACHIO_FUNCTION_AUDIO_SYNC, 526 PISTACHIO_FUNCTION_AUDIO_TRIGGER, 527 PISTACHIO_FUNCTION_I2S_IN, 528 PISTACHIO_FUNCTION_UART0, 529 PISTACHIO_FUNCTION_UART1, 530 PISTACHIO_FUNCTION_SPDIF_OUT, 531 PISTACHIO_FUNCTION_SPDIF_IN, 532 PISTACHIO_FUNCTION_ETH, 533 PISTACHIO_FUNCTION_IR, 534 PISTACHIO_FUNCTION_PWMPDM, 535 PISTACHIO_FUNCTION_MIPS_TRACE_CLK, 536 PISTACHIO_FUNCTION_MIPS_TRACE_DINT, 537 PISTACHIO_FUNCTION_MIPS_TRACE_TRIGOUT, 538 PISTACHIO_FUNCTION_MIPS_TRACE_TRIGIN, 539 PISTACHIO_FUNCTION_MIPS_TRACE_DM, 540 PISTACHIO_FUNCTION_MIPS_TRACE_PROBE_N, 541 PISTACHIO_FUNCTION_MIPS_TRACE_DATA, 542 PISTACHIO_FUNCTION_SRAM_DEBUG, 543 PISTACHIO_FUNCTION_ROM_DEBUG, 544 PISTACHIO_FUNCTION_RPU_DEBUG, 545 PISTACHIO_FUNCTION_MIPS_DEBUG, 546 PISTACHIO_FUNCTION_ETH_DEBUG, 547 PISTACHIO_FUNCTION_USB_DEBUG, 548 PISTACHIO_FUNCTION_SDHOST_DEBUG, 549 PISTACHIO_FUNCTION_SOCIF_DEBUG, 550 PISTACHIO_FUNCTION_MDC_DEBUG, 551 PISTACHIO_FUNCTION_DDR_DEBUG, 552 PISTACHIO_FUNCTION_DREQ0, 553 PISTACHIO_FUNCTION_DREQ1, 554 PISTACHIO_FUNCTION_DREQ2, 555 PISTACHIO_FUNCTION_DREQ3, 556 PISTACHIO_FUNCTION_DREQ4, 557 PISTACHIO_FUNCTION_DREQ5, 558 PISTACHIO_FUNCTION_MIPS_PLL_LOCK, 559 PISTACHIO_FUNCTION_AUDIO_PLL_LOCK, 560 PISTACHIO_FUNCTION_RPU_V_PLL_LOCK, 561 PISTACHIO_FUNCTION_RPU_L_PLL_LOCK, 562 PISTACHIO_FUNCTION_SYS_PLL_LOCK, 563 PISTACHIO_FUNCTION_WIFI_PLL_LOCK, 564 PISTACHIO_FUNCTION_BT_PLL_LOCK, 565 PISTACHIO_FUNCTION_DEBUG_RAW_CCA_IND, 566 PISTACHIO_FUNCTION_DEBUG_ED_SEC20_CCA_IND, 567 PISTACHIO_FUNCTION_DEBUG_ED_SEC40_CCA_IND, 568 PISTACHIO_FUNCTION_DEBUG_AGC_DONE_0, 569 PISTACHIO_FUNCTION_DEBUG_AGC_DONE_1, 570 PISTACHIO_FUNCTION_DEBUG_ED_CCA_IND, 571 PISTACHIO_FUNCTION_DEBUG_S2L_DONE, 572 }; 573 574 static const struct pistachio_function pistachio_functions[] = { 575 FUNCTION(spim0), 576 FUNCTION(spim1), 577 FUNCTION(spis), 578 FUNCTION(sdhost), 579 FUNCTION(i2c0), 580 FUNCTION(i2c1), 581 FUNCTION(i2c2), 582 FUNCTION(i2c3), 583 FUNCTION(audio_clk_in), 584 FUNCTION(i2s_out), 585 FUNCTION(i2s_dac_clk), 586 FUNCTION(audio_sync), 587 FUNCTION(audio_trigger), 588 FUNCTION(i2s_in), 589 FUNCTION(uart0), 590 FUNCTION(uart1), 591 FUNCTION(spdif_out), 592 FUNCTION_SCENARIO(spdif_in, PADS_SCENARIO_SELECT, 0, 0x1), 593 FUNCTION(eth), 594 FUNCTION(ir), 595 FUNCTION(pwmpdm), 596 FUNCTION(mips_trace_clk), 597 FUNCTION_SCENARIO(mips_trace_dint, PADS_SCENARIO_SELECT, 1, 0x3), 598 FUNCTION(mips_trace_trigout), 599 FUNCTION_SCENARIO(mips_trace_trigin, PADS_SCENARIO_SELECT, 3, 0x3), 600 FUNCTION(mips_trace_dm), 601 FUNCTION_SCENARIO(mips_probe_n, PADS_SCENARIO_SELECT, 5, 0x3), 602 FUNCTION(mips_trace_data), 603 FUNCTION(sram_debug), 604 FUNCTION(rom_debug), 605 FUNCTION(rpu_debug), 606 FUNCTION(mips_debug), 607 FUNCTION(eth_debug), 608 FUNCTION(usb_debug), 609 FUNCTION(sdhost_debug), 610 FUNCTION(socif_debug), 611 FUNCTION(mdc_debug), 612 FUNCTION(ddr_debug), 613 FUNCTION(dreq0), 614 FUNCTION(dreq1), 615 FUNCTION(dreq2), 616 FUNCTION(dreq3), 617 FUNCTION(dreq4), 618 FUNCTION(dreq5), 619 FUNCTION(mips_pll_lock), 620 FUNCTION(audio_pll_lock), 621 FUNCTION(rpu_v_pll_lock), 622 FUNCTION(rpu_l_pll_lock), 623 FUNCTION(sys_pll_lock), 624 FUNCTION(wifi_pll_lock), 625 FUNCTION(bt_pll_lock), 626 FUNCTION(debug_raw_cca_ind), 627 FUNCTION(debug_ed_sec20_cca_ind), 628 FUNCTION(debug_ed_sec40_cca_ind), 629 FUNCTION(debug_agc_done_0), 630 FUNCTION(debug_agc_done_1), 631 FUNCTION(debug_ed_cca_ind), 632 FUNCTION(debug_s2l_done), 633 }; 634 635 #define PIN_GROUP(_pin, _name) \ 636 { \ 637 .name = #_name, \ 638 .pin = PISTACHIO_PIN_##_pin, \ 639 .mux_option = { \ 640 PISTACHIO_FUNCTION_NONE, \ 641 PISTACHIO_FUNCTION_NONE, \ 642 PISTACHIO_FUNCTION_NONE, \ 643 }, \ 644 .mux_reg = -1, \ 645 .mux_shift = -1, \ 646 .mux_mask = -1, \ 647 } 648 649 #define MFIO_PIN_GROUP(_pin, _func) \ 650 { \ 651 .name = "mfio" #_pin, \ 652 .pin = PISTACHIO_PIN_MFIO(_pin), \ 653 .mux_option = { \ 654 PISTACHIO_FUNCTION_##_func, \ 655 PISTACHIO_FUNCTION_NONE, \ 656 PISTACHIO_FUNCTION_NONE, \ 657 }, \ 658 .mux_reg = -1, \ 659 .mux_shift = -1, \ 660 .mux_mask = -1, \ 661 } 662 663 #define MFIO_MUX_PIN_GROUP(_pin, _f0, _f1, _f2, _reg, _shift, _mask) \ 664 { \ 665 .name = "mfio" #_pin, \ 666 .pin = PISTACHIO_PIN_MFIO(_pin), \ 667 .mux_option = { \ 668 PISTACHIO_FUNCTION_##_f0, \ 669 PISTACHIO_FUNCTION_##_f1, \ 670 PISTACHIO_FUNCTION_##_f2, \ 671 }, \ 672 .mux_reg = _reg, \ 673 .mux_shift = _shift, \ 674 .mux_mask = _mask, \ 675 } 676 677 static const struct pistachio_pin_group pistachio_groups[] = { 678 MFIO_PIN_GROUP(0, SPIM1), 679 MFIO_MUX_PIN_GROUP(1, SPIM1, SPIM0, UART1, 680 PADS_FUNCTION_SELECT0, 0, 0x3), 681 MFIO_MUX_PIN_GROUP(2, SPIM1, SPIM0, UART1, 682 PADS_FUNCTION_SELECT0, 2, 0x3), 683 MFIO_PIN_GROUP(3, SPIM1), 684 MFIO_PIN_GROUP(4, SPIM1), 685 MFIO_PIN_GROUP(5, SPIM1), 686 MFIO_PIN_GROUP(6, SPIM1), 687 MFIO_PIN_GROUP(7, SPIM1), 688 MFIO_PIN_GROUP(8, SPIM0), 689 MFIO_PIN_GROUP(9, SPIM0), 690 MFIO_PIN_GROUP(10, SPIM0), 691 MFIO_PIN_GROUP(11, SPIS), 692 MFIO_PIN_GROUP(12, SPIS), 693 MFIO_PIN_GROUP(13, SPIS), 694 MFIO_PIN_GROUP(14, SPIS), 695 MFIO_MUX_PIN_GROUP(15, SDHOST, MIPS_TRACE_CLK, MIPS_TRACE_DATA, 696 PADS_FUNCTION_SELECT0, 4, 0x3), 697 MFIO_MUX_PIN_GROUP(16, SDHOST, MIPS_TRACE_DINT, MIPS_TRACE_DATA, 698 PADS_FUNCTION_SELECT0, 6, 0x3), 699 MFIO_MUX_PIN_GROUP(17, SDHOST, MIPS_TRACE_TRIGOUT, MIPS_TRACE_DATA, 700 PADS_FUNCTION_SELECT0, 8, 0x3), 701 MFIO_MUX_PIN_GROUP(18, SDHOST, MIPS_TRACE_TRIGIN, MIPS_TRACE_DATA, 702 PADS_FUNCTION_SELECT0, 10, 0x3), 703 MFIO_MUX_PIN_GROUP(19, SDHOST, MIPS_TRACE_DM, MIPS_TRACE_DATA, 704 PADS_FUNCTION_SELECT0, 12, 0x3), 705 MFIO_MUX_PIN_GROUP(20, SDHOST, MIPS_TRACE_PROBE_N, MIPS_TRACE_DATA, 706 PADS_FUNCTION_SELECT0, 14, 0x3), 707 MFIO_MUX_PIN_GROUP(21, SDHOST, NONE, MIPS_TRACE_DATA, 708 PADS_FUNCTION_SELECT0, 16, 0x3), 709 MFIO_MUX_PIN_GROUP(22, SDHOST, NONE, MIPS_TRACE_DATA, 710 PADS_FUNCTION_SELECT0, 18, 0x3), 711 MFIO_PIN_GROUP(23, SDHOST), 712 MFIO_PIN_GROUP(24, SDHOST), 713 MFIO_PIN_GROUP(25, SDHOST), 714 MFIO_PIN_GROUP(26, SDHOST), 715 MFIO_PIN_GROUP(27, SDHOST), 716 MFIO_MUX_PIN_GROUP(28, I2C0, SPIM0, NONE, 717 PADS_FUNCTION_SELECT0, 20, 0x1), 718 MFIO_MUX_PIN_GROUP(29, I2C0, SPIM0, NONE, 719 PADS_FUNCTION_SELECT0, 21, 0x1), 720 MFIO_MUX_PIN_GROUP(30, I2C1, SPIM0, NONE, 721 PADS_FUNCTION_SELECT0, 22, 0x1), 722 MFIO_MUX_PIN_GROUP(31, I2C1, SPIM1, NONE, 723 PADS_FUNCTION_SELECT0, 23, 0x1), 724 MFIO_PIN_GROUP(32, I2C2), 725 MFIO_PIN_GROUP(33, I2C2), 726 MFIO_PIN_GROUP(34, I2C3), 727 MFIO_PIN_GROUP(35, I2C3), 728 MFIO_MUX_PIN_GROUP(36, I2S_OUT, AUDIO_CLK_IN, NONE, 729 PADS_FUNCTION_SELECT0, 24, 0x1), 730 MFIO_MUX_PIN_GROUP(37, I2S_OUT, DEBUG_RAW_CCA_IND, NONE, 731 PADS_FUNCTION_SELECT0, 25, 0x1), 732 MFIO_MUX_PIN_GROUP(38, I2S_OUT, DEBUG_ED_SEC20_CCA_IND, NONE, 733 PADS_FUNCTION_SELECT0, 26, 0x1), 734 MFIO_MUX_PIN_GROUP(39, I2S_OUT, DEBUG_ED_SEC40_CCA_IND, NONE, 735 PADS_FUNCTION_SELECT0, 27, 0x1), 736 MFIO_MUX_PIN_GROUP(40, I2S_OUT, DEBUG_AGC_DONE_0, NONE, 737 PADS_FUNCTION_SELECT0, 28, 0x1), 738 MFIO_MUX_PIN_GROUP(41, I2S_OUT, DEBUG_AGC_DONE_1, NONE, 739 PADS_FUNCTION_SELECT0, 29, 0x1), 740 MFIO_MUX_PIN_GROUP(42, I2S_OUT, DEBUG_ED_CCA_IND, NONE, 741 PADS_FUNCTION_SELECT0, 30, 0x1), 742 MFIO_MUX_PIN_GROUP(43, I2S_OUT, DEBUG_S2L_DONE, NONE, 743 PADS_FUNCTION_SELECT0, 31, 0x1), 744 MFIO_PIN_GROUP(44, I2S_OUT), 745 MFIO_MUX_PIN_GROUP(45, I2S_DAC_CLK, AUDIO_SYNC, NONE, 746 PADS_FUNCTION_SELECT1, 0, 0x1), 747 MFIO_PIN_GROUP(46, AUDIO_TRIGGER), 748 MFIO_PIN_GROUP(47, I2S_IN), 749 MFIO_PIN_GROUP(48, I2S_IN), 750 MFIO_PIN_GROUP(49, I2S_IN), 751 MFIO_PIN_GROUP(50, I2S_IN), 752 MFIO_PIN_GROUP(51, I2S_IN), 753 MFIO_PIN_GROUP(52, I2S_IN), 754 MFIO_PIN_GROUP(53, I2S_IN), 755 MFIO_MUX_PIN_GROUP(54, I2S_IN, NONE, SPDIF_IN, 756 PADS_FUNCTION_SELECT1, 1, 0x3), 757 MFIO_MUX_PIN_GROUP(55, UART0, SPIM0, SPIM1, 758 PADS_FUNCTION_SELECT1, 3, 0x3), 759 MFIO_MUX_PIN_GROUP(56, UART0, SPIM0, SPIM1, 760 PADS_FUNCTION_SELECT1, 5, 0x3), 761 MFIO_MUX_PIN_GROUP(57, UART0, SPIM0, SPIM1, 762 PADS_FUNCTION_SELECT1, 7, 0x3), 763 MFIO_MUX_PIN_GROUP(58, UART0, SPIM1, NONE, 764 PADS_FUNCTION_SELECT1, 9, 0x1), 765 MFIO_PIN_GROUP(59, UART1), 766 MFIO_PIN_GROUP(60, UART1), 767 MFIO_PIN_GROUP(61, SPDIF_OUT), 768 MFIO_PIN_GROUP(62, SPDIF_IN), 769 MFIO_MUX_PIN_GROUP(63, ETH, MIPS_TRACE_CLK, MIPS_TRACE_DATA, 770 PADS_FUNCTION_SELECT1, 10, 0x3), 771 MFIO_MUX_PIN_GROUP(64, ETH, MIPS_TRACE_DINT, MIPS_TRACE_DATA, 772 PADS_FUNCTION_SELECT1, 12, 0x3), 773 MFIO_MUX_PIN_GROUP(65, ETH, MIPS_TRACE_TRIGOUT, MIPS_TRACE_DATA, 774 PADS_FUNCTION_SELECT1, 14, 0x3), 775 MFIO_MUX_PIN_GROUP(66, ETH, MIPS_TRACE_TRIGIN, MIPS_TRACE_DATA, 776 PADS_FUNCTION_SELECT1, 16, 0x3), 777 MFIO_MUX_PIN_GROUP(67, ETH, MIPS_TRACE_DM, MIPS_TRACE_DATA, 778 PADS_FUNCTION_SELECT1, 18, 0x3), 779 MFIO_MUX_PIN_GROUP(68, ETH, MIPS_TRACE_PROBE_N, MIPS_TRACE_DATA, 780 PADS_FUNCTION_SELECT1, 20, 0x3), 781 MFIO_MUX_PIN_GROUP(69, ETH, NONE, MIPS_TRACE_DATA, 782 PADS_FUNCTION_SELECT1, 22, 0x3), 783 MFIO_MUX_PIN_GROUP(70, ETH, NONE, MIPS_TRACE_DATA, 784 PADS_FUNCTION_SELECT1, 24, 0x3), 785 MFIO_PIN_GROUP(71, ETH), 786 MFIO_PIN_GROUP(72, IR), 787 MFIO_MUX_PIN_GROUP(73, PWMPDM, MIPS_TRACE_CLK, SRAM_DEBUG, 788 PADS_FUNCTION_SELECT1, 26, 0x3), 789 MFIO_MUX_PIN_GROUP(74, PWMPDM, MIPS_TRACE_DINT, SRAM_DEBUG, 790 PADS_FUNCTION_SELECT1, 28, 0x3), 791 MFIO_MUX_PIN_GROUP(75, PWMPDM, MIPS_TRACE_TRIGOUT, ROM_DEBUG, 792 PADS_FUNCTION_SELECT1, 30, 0x3), 793 MFIO_MUX_PIN_GROUP(76, PWMPDM, MIPS_TRACE_TRIGIN, ROM_DEBUG, 794 PADS_FUNCTION_SELECT2, 0, 0x3), 795 MFIO_MUX_PIN_GROUP(77, MDC_DEBUG, MIPS_TRACE_DM, RPU_DEBUG, 796 PADS_FUNCTION_SELECT2, 2, 0x3), 797 MFIO_MUX_PIN_GROUP(78, MDC_DEBUG, MIPS_TRACE_PROBE_N, RPU_DEBUG, 798 PADS_FUNCTION_SELECT2, 4, 0x3), 799 MFIO_MUX_PIN_GROUP(79, DDR_DEBUG, MIPS_TRACE_DATA, MIPS_DEBUG, 800 PADS_FUNCTION_SELECT2, 6, 0x3), 801 MFIO_MUX_PIN_GROUP(80, DDR_DEBUG, MIPS_TRACE_DATA, MIPS_DEBUG, 802 PADS_FUNCTION_SELECT2, 8, 0x3), 803 MFIO_MUX_PIN_GROUP(81, DREQ0, MIPS_TRACE_DATA, ETH_DEBUG, 804 PADS_FUNCTION_SELECT2, 10, 0x3), 805 MFIO_MUX_PIN_GROUP(82, DREQ1, MIPS_TRACE_DATA, ETH_DEBUG, 806 PADS_FUNCTION_SELECT2, 12, 0x3), 807 MFIO_MUX_PIN_GROUP(83, MIPS_PLL_LOCK, MIPS_TRACE_DATA, USB_DEBUG, 808 PADS_FUNCTION_SELECT2, 14, 0x3), 809 MFIO_MUX_PIN_GROUP(84, AUDIO_PLL_LOCK, MIPS_TRACE_DATA, USB_DEBUG, 810 PADS_FUNCTION_SELECT2, 16, 0x3), 811 MFIO_MUX_PIN_GROUP(85, RPU_V_PLL_LOCK, MIPS_TRACE_DATA, SDHOST_DEBUG, 812 PADS_FUNCTION_SELECT2, 18, 0x3), 813 MFIO_MUX_PIN_GROUP(86, RPU_L_PLL_LOCK, MIPS_TRACE_DATA, SDHOST_DEBUG, 814 PADS_FUNCTION_SELECT2, 20, 0x3), 815 MFIO_MUX_PIN_GROUP(87, SYS_PLL_LOCK, DREQ2, SOCIF_DEBUG, 816 PADS_FUNCTION_SELECT2, 22, 0x3), 817 MFIO_MUX_PIN_GROUP(88, WIFI_PLL_LOCK, DREQ3, SOCIF_DEBUG, 818 PADS_FUNCTION_SELECT2, 24, 0x3), 819 MFIO_MUX_PIN_GROUP(89, BT_PLL_LOCK, DREQ4, DREQ5, 820 PADS_FUNCTION_SELECT2, 26, 0x3), 821 PIN_GROUP(TCK, "tck"), 822 PIN_GROUP(TRSTN, "trstn"), 823 PIN_GROUP(TDI, "tdi"), 824 PIN_GROUP(TMS, "tms"), 825 PIN_GROUP(TDO, "tdo"), 826 PIN_GROUP(JTAG_COMPLY, "jtag_comply"), 827 PIN_GROUP(SAFE_MODE, "safe_mode"), 828 PIN_GROUP(POR_DISABLE, "por_disable"), 829 PIN_GROUP(RESETN, "resetn"), 830 }; 831 832 static inline u32 pctl_readl(struct pistachio_pinctrl *pctl, u32 reg) 833 { 834 return readl(pctl->base + reg); 835 } 836 837 static inline void pctl_writel(struct pistachio_pinctrl *pctl, u32 val, u32 reg) 838 { 839 writel(val, pctl->base + reg); 840 } 841 842 static inline struct pistachio_gpio_bank *irqd_to_bank(struct irq_data *d) 843 { 844 return gpiochip_get_data(irq_data_get_irq_chip_data(d)); 845 } 846 847 static inline u32 gpio_readl(struct pistachio_gpio_bank *bank, u32 reg) 848 { 849 return readl(bank->base + reg); 850 } 851 852 static inline void gpio_writel(struct pistachio_gpio_bank *bank, u32 val, 853 u32 reg) 854 { 855 writel(val, bank->base + reg); 856 } 857 858 static inline void gpio_mask_writel(struct pistachio_gpio_bank *bank, 859 u32 reg, unsigned int bit, u32 val) 860 { 861 /* 862 * For most of the GPIO registers, bit 16 + X must be set in order to 863 * write bit X. 864 */ 865 gpio_writel(bank, (0x10000 | val) << bit, reg); 866 } 867 868 static inline void gpio_enable(struct pistachio_gpio_bank *bank, 869 unsigned offset) 870 { 871 gpio_mask_writel(bank, GPIO_BIT_EN, offset, 1); 872 } 873 874 static inline void gpio_disable(struct pistachio_gpio_bank *bank, 875 unsigned offset) 876 { 877 gpio_mask_writel(bank, GPIO_BIT_EN, offset, 0); 878 } 879 880 static int pistachio_pinctrl_get_groups_count(struct pinctrl_dev *pctldev) 881 { 882 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 883 884 return pctl->ngroups; 885 } 886 887 static const char *pistachio_pinctrl_get_group_name(struct pinctrl_dev *pctldev, 888 unsigned group) 889 { 890 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 891 892 return pctl->groups[group].name; 893 } 894 895 static int pistachio_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, 896 unsigned group, 897 const unsigned **pins, 898 unsigned *num_pins) 899 { 900 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 901 902 *pins = &pctl->groups[group].pin; 903 *num_pins = 1; 904 905 return 0; 906 } 907 908 static const struct pinctrl_ops pistachio_pinctrl_ops = { 909 .get_groups_count = pistachio_pinctrl_get_groups_count, 910 .get_group_name = pistachio_pinctrl_get_group_name, 911 .get_group_pins = pistachio_pinctrl_get_group_pins, 912 .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, 913 .dt_free_map = pinctrl_utils_free_map, 914 }; 915 916 static int pistachio_pinmux_get_functions_count(struct pinctrl_dev *pctldev) 917 { 918 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 919 920 return pctl->nfunctions; 921 } 922 923 static const char * 924 pistachio_pinmux_get_function_name(struct pinctrl_dev *pctldev, unsigned func) 925 { 926 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 927 928 return pctl->functions[func].name; 929 } 930 931 static int pistachio_pinmux_get_function_groups(struct pinctrl_dev *pctldev, 932 unsigned func, 933 const char * const **groups, 934 unsigned * const num_groups) 935 { 936 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 937 938 *groups = pctl->functions[func].groups; 939 *num_groups = pctl->functions[func].ngroups; 940 941 return 0; 942 } 943 944 static int pistachio_pinmux_enable(struct pinctrl_dev *pctldev, 945 unsigned func, unsigned group) 946 { 947 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 948 const struct pistachio_pin_group *pg = &pctl->groups[group]; 949 const struct pistachio_function *pf = &pctl->functions[func]; 950 struct pinctrl_gpio_range *range; 951 unsigned int i; 952 u32 val; 953 954 if (pg->mux_reg > 0) { 955 for (i = 0; i < ARRAY_SIZE(pg->mux_option); i++) { 956 if (pg->mux_option[i] == func) 957 break; 958 } 959 if (i == ARRAY_SIZE(pg->mux_option)) { 960 dev_err(pctl->dev, "Cannot mux pin %u to function %u\n", 961 group, func); 962 return -EINVAL; 963 } 964 965 val = pctl_readl(pctl, pg->mux_reg); 966 val &= ~(pg->mux_mask << pg->mux_shift); 967 val |= i << pg->mux_shift; 968 pctl_writel(pctl, val, pg->mux_reg); 969 970 if (pf->scenarios) { 971 for (i = 0; i < pf->nscenarios; i++) { 972 if (pf->scenarios[i] == group) 973 break; 974 } 975 if (WARN_ON(i == pf->nscenarios)) 976 return -EINVAL; 977 978 val = pctl_readl(pctl, pf->scenario_reg); 979 val &= ~(pf->scenario_mask << pf->scenario_shift); 980 val |= i << pf->scenario_shift; 981 pctl_writel(pctl, val, pf->scenario_reg); 982 } 983 } 984 985 range = pinctrl_find_gpio_range_from_pin(pctl->pctldev, pg->pin); 986 if (range) 987 gpio_disable(gpiochip_get_data(range->gc), pg->pin - range->pin_base); 988 989 return 0; 990 } 991 992 static const struct pinmux_ops pistachio_pinmux_ops = { 993 .get_functions_count = pistachio_pinmux_get_functions_count, 994 .get_function_name = pistachio_pinmux_get_function_name, 995 .get_function_groups = pistachio_pinmux_get_function_groups, 996 .set_mux = pistachio_pinmux_enable, 997 }; 998 999 static int pistachio_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin, 1000 unsigned long *config) 1001 { 1002 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 1003 enum pin_config_param param = pinconf_to_config_param(*config); 1004 u32 val, arg; 1005 1006 switch (param) { 1007 case PIN_CONFIG_INPUT_SCHMITT_ENABLE: 1008 val = pctl_readl(pctl, PADS_SCHMITT_EN_REG(pin)); 1009 arg = !!(val & PADS_SCHMITT_EN_BIT(pin)); 1010 break; 1011 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: 1012 val = pctl_readl(pctl, PADS_PU_PD_REG(pin)) >> 1013 PADS_PU_PD_SHIFT(pin); 1014 arg = (val & PADS_PU_PD_MASK) == PADS_PU_PD_HIGHZ; 1015 break; 1016 case PIN_CONFIG_BIAS_PULL_UP: 1017 val = pctl_readl(pctl, PADS_PU_PD_REG(pin)) >> 1018 PADS_PU_PD_SHIFT(pin); 1019 arg = (val & PADS_PU_PD_MASK) == PADS_PU_PD_UP; 1020 break; 1021 case PIN_CONFIG_BIAS_PULL_DOWN: 1022 val = pctl_readl(pctl, PADS_PU_PD_REG(pin)) >> 1023 PADS_PU_PD_SHIFT(pin); 1024 arg = (val & PADS_PU_PD_MASK) == PADS_PU_PD_DOWN; 1025 break; 1026 case PIN_CONFIG_BIAS_BUS_HOLD: 1027 val = pctl_readl(pctl, PADS_PU_PD_REG(pin)) >> 1028 PADS_PU_PD_SHIFT(pin); 1029 arg = (val & PADS_PU_PD_MASK) == PADS_PU_PD_BUS; 1030 break; 1031 case PIN_CONFIG_SLEW_RATE: 1032 val = pctl_readl(pctl, PADS_SLEW_RATE_REG(pin)); 1033 arg = !!(val & PADS_SLEW_RATE_BIT(pin)); 1034 break; 1035 case PIN_CONFIG_DRIVE_STRENGTH: 1036 val = pctl_readl(pctl, PADS_DRIVE_STRENGTH_REG(pin)) >> 1037 PADS_DRIVE_STRENGTH_SHIFT(pin); 1038 switch (val & PADS_DRIVE_STRENGTH_MASK) { 1039 case PADS_DRIVE_STRENGTH_2MA: 1040 arg = 2; 1041 break; 1042 case PADS_DRIVE_STRENGTH_4MA: 1043 arg = 4; 1044 break; 1045 case PADS_DRIVE_STRENGTH_8MA: 1046 arg = 8; 1047 break; 1048 case PADS_DRIVE_STRENGTH_12MA: 1049 default: 1050 arg = 12; 1051 break; 1052 } 1053 break; 1054 default: 1055 dev_dbg(pctl->dev, "Property %u not supported\n", param); 1056 return -ENOTSUPP; 1057 } 1058 1059 *config = pinconf_to_config_packed(param, arg); 1060 1061 return 0; 1062 } 1063 1064 static int pistachio_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin, 1065 unsigned long *configs, unsigned num_configs) 1066 { 1067 struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 1068 enum pin_config_param param; 1069 u32 drv, val, arg; 1070 unsigned int i; 1071 1072 for (i = 0; i < num_configs; i++) { 1073 param = pinconf_to_config_param(configs[i]); 1074 arg = pinconf_to_config_argument(configs[i]); 1075 1076 switch (param) { 1077 case PIN_CONFIG_INPUT_SCHMITT_ENABLE: 1078 val = pctl_readl(pctl, PADS_SCHMITT_EN_REG(pin)); 1079 if (arg) 1080 val |= PADS_SCHMITT_EN_BIT(pin); 1081 else 1082 val &= ~PADS_SCHMITT_EN_BIT(pin); 1083 pctl_writel(pctl, val, PADS_SCHMITT_EN_REG(pin)); 1084 break; 1085 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: 1086 val = pctl_readl(pctl, PADS_PU_PD_REG(pin)); 1087 val &= ~(PADS_PU_PD_MASK << PADS_PU_PD_SHIFT(pin)); 1088 val |= PADS_PU_PD_HIGHZ << PADS_PU_PD_SHIFT(pin); 1089 pctl_writel(pctl, val, PADS_PU_PD_REG(pin)); 1090 break; 1091 case PIN_CONFIG_BIAS_PULL_UP: 1092 val = pctl_readl(pctl, PADS_PU_PD_REG(pin)); 1093 val &= ~(PADS_PU_PD_MASK << PADS_PU_PD_SHIFT(pin)); 1094 val |= PADS_PU_PD_UP << PADS_PU_PD_SHIFT(pin); 1095 pctl_writel(pctl, val, PADS_PU_PD_REG(pin)); 1096 break; 1097 case PIN_CONFIG_BIAS_PULL_DOWN: 1098 val = pctl_readl(pctl, PADS_PU_PD_REG(pin)); 1099 val &= ~(PADS_PU_PD_MASK << PADS_PU_PD_SHIFT(pin)); 1100 val |= PADS_PU_PD_DOWN << PADS_PU_PD_SHIFT(pin); 1101 pctl_writel(pctl, val, PADS_PU_PD_REG(pin)); 1102 break; 1103 case PIN_CONFIG_BIAS_BUS_HOLD: 1104 val = pctl_readl(pctl, PADS_PU_PD_REG(pin)); 1105 val &= ~(PADS_PU_PD_MASK << PADS_PU_PD_SHIFT(pin)); 1106 val |= PADS_PU_PD_BUS << PADS_PU_PD_SHIFT(pin); 1107 pctl_writel(pctl, val, PADS_PU_PD_REG(pin)); 1108 break; 1109 case PIN_CONFIG_SLEW_RATE: 1110 val = pctl_readl(pctl, PADS_SLEW_RATE_REG(pin)); 1111 if (arg) 1112 val |= PADS_SLEW_RATE_BIT(pin); 1113 else 1114 val &= ~PADS_SLEW_RATE_BIT(pin); 1115 pctl_writel(pctl, val, PADS_SLEW_RATE_REG(pin)); 1116 break; 1117 case PIN_CONFIG_DRIVE_STRENGTH: 1118 val = pctl_readl(pctl, PADS_DRIVE_STRENGTH_REG(pin)); 1119 val &= ~(PADS_DRIVE_STRENGTH_MASK << 1120 PADS_DRIVE_STRENGTH_SHIFT(pin)); 1121 switch (arg) { 1122 case 2: 1123 drv = PADS_DRIVE_STRENGTH_2MA; 1124 break; 1125 case 4: 1126 drv = PADS_DRIVE_STRENGTH_4MA; 1127 break; 1128 case 8: 1129 drv = PADS_DRIVE_STRENGTH_8MA; 1130 break; 1131 case 12: 1132 drv = PADS_DRIVE_STRENGTH_12MA; 1133 break; 1134 default: 1135 dev_err(pctl->dev, 1136 "Drive strength %umA not supported\n", 1137 arg); 1138 return -EINVAL; 1139 } 1140 val |= drv << PADS_DRIVE_STRENGTH_SHIFT(pin); 1141 pctl_writel(pctl, val, PADS_DRIVE_STRENGTH_REG(pin)); 1142 break; 1143 default: 1144 dev_err(pctl->dev, "Property %u not supported\n", 1145 param); 1146 return -ENOTSUPP; 1147 } 1148 } 1149 1150 return 0; 1151 } 1152 1153 static const struct pinconf_ops pistachio_pinconf_ops = { 1154 .pin_config_get = pistachio_pinconf_get, 1155 .pin_config_set = pistachio_pinconf_set, 1156 .is_generic = true, 1157 }; 1158 1159 static struct pinctrl_desc pistachio_pinctrl_desc = { 1160 .name = "pistachio-pinctrl", 1161 .pctlops = &pistachio_pinctrl_ops, 1162 .pmxops = &pistachio_pinmux_ops, 1163 .confops = &pistachio_pinconf_ops, 1164 }; 1165 1166 static int pistachio_gpio_get_direction(struct gpio_chip *chip, unsigned offset) 1167 { 1168 struct pistachio_gpio_bank *bank = gpiochip_get_data(chip); 1169 1170 if (gpio_readl(bank, GPIO_OUTPUT_EN) & BIT(offset)) 1171 return GPIO_LINE_DIRECTION_OUT; 1172 1173 return GPIO_LINE_DIRECTION_IN; 1174 } 1175 1176 static int pistachio_gpio_get(struct gpio_chip *chip, unsigned offset) 1177 { 1178 struct pistachio_gpio_bank *bank = gpiochip_get_data(chip); 1179 u32 reg; 1180 1181 if (gpio_readl(bank, GPIO_OUTPUT_EN) & BIT(offset)) 1182 reg = GPIO_OUTPUT; 1183 else 1184 reg = GPIO_INPUT; 1185 1186 return !!(gpio_readl(bank, reg) & BIT(offset)); 1187 } 1188 1189 static void pistachio_gpio_set(struct gpio_chip *chip, unsigned offset, 1190 int value) 1191 { 1192 struct pistachio_gpio_bank *bank = gpiochip_get_data(chip); 1193 1194 gpio_mask_writel(bank, GPIO_OUTPUT, offset, !!value); 1195 } 1196 1197 static int pistachio_gpio_direction_input(struct gpio_chip *chip, 1198 unsigned offset) 1199 { 1200 struct pistachio_gpio_bank *bank = gpiochip_get_data(chip); 1201 1202 gpio_mask_writel(bank, GPIO_OUTPUT_EN, offset, 0); 1203 gpio_enable(bank, offset); 1204 1205 return 0; 1206 } 1207 1208 static int pistachio_gpio_direction_output(struct gpio_chip *chip, 1209 unsigned offset, int value) 1210 { 1211 struct pistachio_gpio_bank *bank = gpiochip_get_data(chip); 1212 1213 pistachio_gpio_set(chip, offset, value); 1214 gpio_mask_writel(bank, GPIO_OUTPUT_EN, offset, 1); 1215 gpio_enable(bank, offset); 1216 1217 return 0; 1218 } 1219 1220 static void pistachio_gpio_irq_ack(struct irq_data *data) 1221 { 1222 struct pistachio_gpio_bank *bank = irqd_to_bank(data); 1223 1224 gpio_mask_writel(bank, GPIO_INTERRUPT_STATUS, data->hwirq, 0); 1225 } 1226 1227 static void pistachio_gpio_irq_mask(struct irq_data *data) 1228 { 1229 struct pistachio_gpio_bank *bank = irqd_to_bank(data); 1230 1231 gpio_mask_writel(bank, GPIO_INTERRUPT_EN, data->hwirq, 0); 1232 gpiochip_disable_irq(&bank->gpio_chip, irqd_to_hwirq(data)); 1233 } 1234 1235 static void pistachio_gpio_irq_unmask(struct irq_data *data) 1236 { 1237 struct pistachio_gpio_bank *bank = irqd_to_bank(data); 1238 1239 gpiochip_enable_irq(&bank->gpio_chip, irqd_to_hwirq(data)); 1240 gpio_mask_writel(bank, GPIO_INTERRUPT_EN, data->hwirq, 1); 1241 } 1242 1243 static unsigned int pistachio_gpio_irq_startup(struct irq_data *data) 1244 { 1245 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 1246 1247 pistachio_gpio_direction_input(chip, data->hwirq); 1248 pistachio_gpio_irq_unmask(data); 1249 1250 return 0; 1251 } 1252 1253 static int pistachio_gpio_irq_set_type(struct irq_data *data, unsigned int type) 1254 { 1255 struct pistachio_gpio_bank *bank = irqd_to_bank(data); 1256 1257 switch (type & IRQ_TYPE_SENSE_MASK) { 1258 case IRQ_TYPE_EDGE_RISING: 1259 gpio_mask_writel(bank, GPIO_INPUT_POLARITY, data->hwirq, 1); 1260 gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq, 1261 GPIO_INTERRUPT_TYPE_EDGE); 1262 gpio_mask_writel(bank, GPIO_INTERRUPT_EDGE, data->hwirq, 1263 GPIO_INTERRUPT_EDGE_SINGLE); 1264 break; 1265 case IRQ_TYPE_EDGE_FALLING: 1266 gpio_mask_writel(bank, GPIO_INPUT_POLARITY, data->hwirq, 0); 1267 gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq, 1268 GPIO_INTERRUPT_TYPE_EDGE); 1269 gpio_mask_writel(bank, GPIO_INTERRUPT_EDGE, data->hwirq, 1270 GPIO_INTERRUPT_EDGE_SINGLE); 1271 break; 1272 case IRQ_TYPE_EDGE_BOTH: 1273 gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq, 1274 GPIO_INTERRUPT_TYPE_EDGE); 1275 gpio_mask_writel(bank, GPIO_INTERRUPT_EDGE, data->hwirq, 1276 GPIO_INTERRUPT_EDGE_DUAL); 1277 break; 1278 case IRQ_TYPE_LEVEL_HIGH: 1279 gpio_mask_writel(bank, GPIO_INPUT_POLARITY, data->hwirq, 1); 1280 gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq, 1281 GPIO_INTERRUPT_TYPE_LEVEL); 1282 break; 1283 case IRQ_TYPE_LEVEL_LOW: 1284 gpio_mask_writel(bank, GPIO_INPUT_POLARITY, data->hwirq, 0); 1285 gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq, 1286 GPIO_INTERRUPT_TYPE_LEVEL); 1287 break; 1288 default: 1289 return -EINVAL; 1290 } 1291 1292 if (type & IRQ_TYPE_LEVEL_MASK) 1293 irq_set_handler_locked(data, handle_level_irq); 1294 else 1295 irq_set_handler_locked(data, handle_edge_irq); 1296 1297 return 0; 1298 } 1299 1300 static void pistachio_gpio_irq_handler(struct irq_desc *desc) 1301 { 1302 struct gpio_chip *gc = irq_desc_get_handler_data(desc); 1303 struct pistachio_gpio_bank *bank = gpiochip_get_data(gc); 1304 struct irq_chip *chip = irq_desc_get_chip(desc); 1305 unsigned long pending; 1306 unsigned int pin; 1307 1308 chained_irq_enter(chip, desc); 1309 pending = gpio_readl(bank, GPIO_INTERRUPT_STATUS) & 1310 gpio_readl(bank, GPIO_INTERRUPT_EN); 1311 for_each_set_bit(pin, &pending, 16) 1312 generic_handle_domain_irq(gc->irq.domain, pin); 1313 chained_irq_exit(chip, desc); 1314 } 1315 1316 #define GPIO_BANK(_bank, _pin_base, _npins) \ 1317 { \ 1318 .instance = (_bank), \ 1319 .pin_base = _pin_base, \ 1320 .npins = _npins, \ 1321 .gpio_chip = { \ 1322 .label = "GPIO" #_bank, \ 1323 .request = gpiochip_generic_request, \ 1324 .free = gpiochip_generic_free, \ 1325 .get_direction = pistachio_gpio_get_direction, \ 1326 .direction_input = pistachio_gpio_direction_input, \ 1327 .direction_output = pistachio_gpio_direction_output, \ 1328 .get = pistachio_gpio_get, \ 1329 .set = pistachio_gpio_set, \ 1330 .base = _pin_base, \ 1331 .ngpio = _npins, \ 1332 }, \ 1333 } 1334 1335 static struct pistachio_gpio_bank pistachio_gpio_banks[] = { 1336 GPIO_BANK(0, PISTACHIO_PIN_MFIO(0), 16), 1337 GPIO_BANK(1, PISTACHIO_PIN_MFIO(16), 16), 1338 GPIO_BANK(2, PISTACHIO_PIN_MFIO(32), 16), 1339 GPIO_BANK(3, PISTACHIO_PIN_MFIO(48), 16), 1340 GPIO_BANK(4, PISTACHIO_PIN_MFIO(64), 16), 1341 GPIO_BANK(5, PISTACHIO_PIN_MFIO(80), 10), 1342 }; 1343 1344 static void pistachio_gpio_irq_print_chip(struct irq_data *data, 1345 struct seq_file *p) 1346 { 1347 struct pistachio_gpio_bank *bank = irqd_to_bank(data); 1348 1349 seq_printf(p, "GPIO%d", bank->instance); 1350 } 1351 1352 static const struct irq_chip pistachio_gpio_irq_chip = { 1353 .irq_startup = pistachio_gpio_irq_startup, 1354 .irq_ack = pistachio_gpio_irq_ack, 1355 .irq_mask = pistachio_gpio_irq_mask, 1356 .irq_unmask = pistachio_gpio_irq_unmask, 1357 .irq_set_type = pistachio_gpio_irq_set_type, 1358 .irq_print_chip = pistachio_gpio_irq_print_chip, 1359 .flags = IRQCHIP_IMMUTABLE, 1360 GPIOCHIP_IRQ_RESOURCE_HELPERS, 1361 }; 1362 1363 static int pistachio_gpio_register(struct pistachio_pinctrl *pctl) 1364 { 1365 struct pistachio_gpio_bank *bank; 1366 unsigned int i; 1367 int irq, ret = 0; 1368 1369 for (i = 0; i < pctl->nbanks; i++) { 1370 char child_name[sizeof("gpioXX")]; 1371 struct fwnode_handle *child; 1372 struct gpio_irq_chip *girq; 1373 1374 snprintf(child_name, sizeof(child_name), "gpio%d", i); 1375 child = device_get_named_child_node(pctl->dev, child_name); 1376 if (!child) { 1377 dev_err(pctl->dev, "No node for bank %u\n", i); 1378 ret = -ENODEV; 1379 goto err; 1380 } 1381 1382 if (!fwnode_property_present(child, "gpio-controller")) { 1383 fwnode_handle_put(child); 1384 dev_err(pctl->dev, 1385 "No gpio-controller property for bank %u\n", i); 1386 ret = -ENODEV; 1387 goto err; 1388 } 1389 1390 ret = fwnode_irq_get(child, 0); 1391 if (ret < 0) { 1392 fwnode_handle_put(child); 1393 dev_err(pctl->dev, "Failed to retrieve IRQ for bank %u\n", i); 1394 goto err; 1395 } 1396 if (!ret) { 1397 fwnode_handle_put(child); 1398 dev_err(pctl->dev, "No IRQ for bank %u\n", i); 1399 ret = -EINVAL; 1400 goto err; 1401 } 1402 irq = ret; 1403 1404 bank = &pctl->gpio_banks[i]; 1405 bank->pctl = pctl; 1406 bank->base = pctl->base + GPIO_BANK_BASE(i); 1407 1408 bank->gpio_chip.parent = pctl->dev; 1409 bank->gpio_chip.fwnode = child; 1410 1411 girq = &bank->gpio_chip.irq; 1412 gpio_irq_chip_set_chip(girq, &pistachio_gpio_irq_chip); 1413 girq->parent_handler = pistachio_gpio_irq_handler; 1414 girq->num_parents = 1; 1415 girq->parents = devm_kcalloc(pctl->dev, 1, 1416 sizeof(*girq->parents), 1417 GFP_KERNEL); 1418 if (!girq->parents) { 1419 ret = -ENOMEM; 1420 goto err; 1421 } 1422 girq->parents[0] = irq; 1423 girq->default_type = IRQ_TYPE_NONE; 1424 girq->handler = handle_level_irq; 1425 1426 ret = gpiochip_add_data(&bank->gpio_chip, bank); 1427 if (ret < 0) { 1428 dev_err(pctl->dev, "Failed to add GPIO chip %u: %d\n", 1429 i, ret); 1430 goto err; 1431 } 1432 1433 ret = gpiochip_add_pin_range(&bank->gpio_chip, 1434 dev_name(pctl->dev), 0, 1435 bank->pin_base, bank->npins); 1436 if (ret < 0) { 1437 dev_err(pctl->dev, "Failed to add GPIO range %u: %d\n", 1438 i, ret); 1439 gpiochip_remove(&bank->gpio_chip); 1440 goto err; 1441 } 1442 } 1443 1444 return 0; 1445 err: 1446 for (; i > 0; i--) { 1447 bank = &pctl->gpio_banks[i - 1]; 1448 gpiochip_remove(&bank->gpio_chip); 1449 } 1450 return ret; 1451 } 1452 1453 static const struct of_device_id pistachio_pinctrl_of_match[] = { 1454 { .compatible = "img,pistachio-system-pinctrl", }, 1455 { }, 1456 }; 1457 1458 static int pistachio_pinctrl_probe(struct platform_device *pdev) 1459 { 1460 struct pistachio_pinctrl *pctl; 1461 1462 pctl = devm_kzalloc(&pdev->dev, sizeof(*pctl), GFP_KERNEL); 1463 if (!pctl) 1464 return -ENOMEM; 1465 pctl->dev = &pdev->dev; 1466 dev_set_drvdata(&pdev->dev, pctl); 1467 1468 pctl->base = devm_platform_ioremap_resource(pdev, 0); 1469 if (IS_ERR(pctl->base)) 1470 return PTR_ERR(pctl->base); 1471 1472 pctl->pins = pistachio_pins; 1473 pctl->npins = ARRAY_SIZE(pistachio_pins); 1474 pctl->functions = pistachio_functions; 1475 pctl->nfunctions = ARRAY_SIZE(pistachio_functions); 1476 pctl->groups = pistachio_groups; 1477 pctl->ngroups = ARRAY_SIZE(pistachio_groups); 1478 pctl->gpio_banks = pistachio_gpio_banks; 1479 pctl->nbanks = ARRAY_SIZE(pistachio_gpio_banks); 1480 1481 pistachio_pinctrl_desc.pins = pctl->pins; 1482 pistachio_pinctrl_desc.npins = pctl->npins; 1483 1484 pctl->pctldev = devm_pinctrl_register(&pdev->dev, &pistachio_pinctrl_desc, 1485 pctl); 1486 if (IS_ERR(pctl->pctldev)) { 1487 dev_err(&pdev->dev, "Failed to register pinctrl device\n"); 1488 return PTR_ERR(pctl->pctldev); 1489 } 1490 1491 return pistachio_gpio_register(pctl); 1492 } 1493 1494 static struct platform_driver pistachio_pinctrl_driver = { 1495 .driver = { 1496 .name = "pistachio-pinctrl", 1497 .of_match_table = pistachio_pinctrl_of_match, 1498 .suppress_bind_attrs = true, 1499 }, 1500 .probe = pistachio_pinctrl_probe, 1501 }; 1502 1503 static int __init pistachio_pinctrl_register(void) 1504 { 1505 return platform_driver_register(&pistachio_pinctrl_driver); 1506 } 1507 arch_initcall(pistachio_pinctrl_register); 1508