1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2018 Emmanuel Vadot <manu@FreeBSD.org> 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/bus.h> 35 36 #include <sys/gpio.h> 37 #include <sys/kernel.h> 38 #include <sys/lock.h> 39 #include <sys/module.h> 40 #include <sys/mutex.h> 41 #include <sys/rman.h> 42 43 #include <machine/bus.h> 44 #include <machine/resource.h> 45 #include <machine/intr.h> 46 47 #include <dev/fdt/simplebus.h> 48 49 #include <dev/ofw/ofw_bus.h> 50 #include <dev/ofw/ofw_bus_subr.h> 51 52 #include <dev/fdt/fdt_pinctrl.h> 53 54 #include <dev/extres/syscon/syscon.h> 55 56 #include "gpio_if.h" 57 #include "syscon_if.h" 58 #include "fdt_pinctrl_if.h" 59 60 struct rk_pinctrl_pin_drive { 61 uint32_t bank; 62 uint32_t subbank; 63 uint32_t offset; 64 uint32_t value; 65 uint32_t ma; 66 }; 67 68 struct rk_pinctrl_bank { 69 uint32_t bank; 70 uint32_t subbank; 71 uint32_t offset; 72 uint32_t nbits; 73 }; 74 75 struct rk_pinctrl_pin_fixup { 76 uint32_t bank; 77 uint32_t subbank; 78 uint32_t pin; 79 uint32_t reg; 80 uint32_t bit; 81 uint32_t mask; 82 }; 83 84 struct rk_pinctrl_gpio { 85 uint32_t bank; 86 char *gpio_name; 87 device_t gpio_dev; 88 }; 89 90 91 struct rk_pinctrl_softc; 92 93 struct rk_pinctrl_conf { 94 struct rk_pinctrl_bank *iomux_conf; 95 uint32_t iomux_nbanks; 96 struct rk_pinctrl_pin_fixup *pin_fixup; 97 uint32_t npin_fixup; 98 struct rk_pinctrl_pin_drive *pin_drive; 99 uint32_t npin_drive; 100 struct rk_pinctrl_gpio *gpio_bank; 101 uint32_t ngpio_bank; 102 uint32_t (*get_pd_offset)(struct rk_pinctrl_softc *, uint32_t); 103 struct syscon *(*get_syscon)(struct rk_pinctrl_softc *, uint32_t); 104 int (*parse_bias)(phandle_t, int); 105 int (*resolv_bias_value)(int, int); 106 int (*get_bias_value)(int, int); 107 }; 108 109 struct rk_pinctrl_softc { 110 struct simplebus_softc simplebus_sc; 111 device_t dev; 112 struct syscon *grf; 113 struct syscon *pmu; 114 struct rk_pinctrl_conf *conf; 115 struct mtx mtx; 116 }; 117 118 #define RK_PINCTRL_LOCK(_sc) mtx_lock_spin(&(_sc)->mtx) 119 #define RK_PINCTRL_UNLOCK(_sc) mtx_unlock_spin(&(_sc)->mtx) 120 #define RK_PINCTRL_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->mtx, MA_OWNED) 121 122 #define RK_IOMUX(_bank, _subbank, _offset, _nbits) \ 123 { \ 124 .bank = _bank, \ 125 .subbank = _subbank, \ 126 .offset = _offset, \ 127 .nbits = _nbits, \ 128 } 129 130 #define RK_PINFIX(_bank, _pin, _reg, _bit, _mask) \ 131 { \ 132 .bank = _bank, \ 133 .pin = _pin, \ 134 .reg = _reg, \ 135 .bit = _bit, \ 136 .mask = _mask, \ 137 } 138 139 #define RK_PINDRIVE(_bank, _subbank, _offset, _value, _ma) \ 140 { \ 141 .bank = _bank, \ 142 .subbank = _subbank, \ 143 .offset = _offset, \ 144 .value = _value, \ 145 .ma = _ma, \ 146 } 147 #define RK_GPIO(_bank, _name) \ 148 { \ 149 .bank = _bank, \ 150 .gpio_name = _name, \ 151 } 152 153 static struct rk_pinctrl_gpio rk3288_gpio_bank[] = { 154 RK_GPIO(0, "gpio0"), 155 RK_GPIO(1, "gpio1"), 156 RK_GPIO(2, "gpio2"), 157 RK_GPIO(3, "gpio3"), 158 RK_GPIO(4, "gpio4"), 159 RK_GPIO(5, "gpio5"), 160 RK_GPIO(6, "gpio6"), 161 RK_GPIO(7, "gpio7"), 162 RK_GPIO(8, "gpio8"), 163 }; 164 165 static struct rk_pinctrl_bank rk3288_iomux_bank[] = { 166 /* bank sub offs nbits */ 167 /* PMU */ 168 RK_IOMUX(0, 0, 0x0084, 2), 169 RK_IOMUX(0, 1, 0x0088, 2), 170 RK_IOMUX(0, 2, 0x008C, 2), 171 /* GFR */ 172 RK_IOMUX(1, 3, 0x000C, 2), 173 RK_IOMUX(2, 0, 0x0010, 2), 174 RK_IOMUX(2, 1, 0x0014, 2), 175 RK_IOMUX(2, 2, 0x0018, 2), 176 RK_IOMUX(2, 3, 0x001C, 2), 177 RK_IOMUX(3, 0, 0x0020, 2), 178 RK_IOMUX(3, 1, 0x0024, 2), 179 RK_IOMUX(3, 2, 0x0028, 2), 180 RK_IOMUX(3, 3, 0x002C, 4), 181 RK_IOMUX(4, 0, 0x0034, 4), 182 RK_IOMUX(4, 1, 0x003C, 4), 183 RK_IOMUX(4, 2, 0x0044, 2), 184 RK_IOMUX(4, 3, 0x0048, 2), 185 /* 5,0 - Empty */ 186 RK_IOMUX(5, 1, 0x0050, 2), 187 RK_IOMUX(5, 2, 0x0054, 2), 188 /* 5,3 - Empty */ 189 RK_IOMUX(6, 0, 0x005C, 2), 190 RK_IOMUX(6, 1, 0x0060, 2), 191 RK_IOMUX(6, 2, 0x0064, 2), 192 /* 6,3 - Empty */ 193 RK_IOMUX(7, 0, 0x006C, 2), 194 RK_IOMUX(7, 1, 0x0070, 2), 195 RK_IOMUX(7, 2, 0x0074, 4), 196 /* 7,3 - Empty */ 197 RK_IOMUX(8, 0, 0x0080, 2), 198 RK_IOMUX(8, 1, 0x0084, 2), 199 /* 8,2 - Empty */ 200 /* 8,3 - Empty */ 201 202 }; 203 204 static struct rk_pinctrl_pin_fixup rk3288_pin_fixup[] = { 205 }; 206 207 static struct rk_pinctrl_pin_drive rk3288_pin_drive[] = { 208 /* bank sub offs val ma */ 209 /* GPIO0A (PMU)*/ 210 RK_PINDRIVE(0, 0, 0x070, 0, 2), 211 RK_PINDRIVE(0, 0, 0x070, 1, 4), 212 RK_PINDRIVE(0, 0, 0x070, 2, 8), 213 RK_PINDRIVE(0, 0, 0x070, 3, 12), 214 215 /* GPIO0B (PMU)*/ 216 RK_PINDRIVE(0, 1, 0x074, 0, 2), 217 RK_PINDRIVE(0, 1, 0x074, 1, 4), 218 RK_PINDRIVE(0, 1, 0x074, 2, 8), 219 RK_PINDRIVE(0, 1, 0x074, 3, 12), 220 221 /* GPIO0C (PMU)*/ 222 RK_PINDRIVE(0, 2, 0x078, 0, 2), 223 RK_PINDRIVE(0, 2, 0x078, 1, 4), 224 RK_PINDRIVE(0, 2, 0x078, 2, 8), 225 RK_PINDRIVE(0, 2, 0x078, 3, 12), 226 227 /* GPIO1D */ 228 RK_PINDRIVE(1, 3, 0x1CC, 0, 2), 229 RK_PINDRIVE(1, 3, 0x1CC, 1, 4), 230 RK_PINDRIVE(1, 3, 0x1CC, 2, 8), 231 RK_PINDRIVE(1, 3, 0x1CC, 3, 12), 232 233 /* GPIO2A */ 234 RK_PINDRIVE(2, 0, 0x1D0, 0, 2), 235 RK_PINDRIVE(2, 0, 0x1D0, 1, 4), 236 RK_PINDRIVE(2, 0, 0x1D0, 2, 8), 237 RK_PINDRIVE(2, 0, 0x1D0, 3, 12), 238 239 /* GPIO2B */ 240 RK_PINDRIVE(2, 1, 0x1D4, 0, 2), 241 RK_PINDRIVE(2, 1, 0x1D4, 1, 4), 242 RK_PINDRIVE(2, 1, 0x1D4, 2, 8), 243 RK_PINDRIVE(2, 1, 0x1D4, 3, 12), 244 245 /* GPIO2C */ 246 RK_PINDRIVE(2, 2, 0x1D8, 0, 2), 247 RK_PINDRIVE(2, 2, 0x1D8, 1, 4), 248 RK_PINDRIVE(2, 2, 0x1D8, 2, 8), 249 RK_PINDRIVE(2, 2, 0x1D8, 3, 12), 250 251 /* GPIO2D */ 252 RK_PINDRIVE(2, 3, 0x1DC, 0, 2), 253 RK_PINDRIVE(2, 3, 0x1DC, 1, 4), 254 RK_PINDRIVE(2, 3, 0x1DC, 2, 8), 255 RK_PINDRIVE(2, 3, 0x1DC, 3, 12), 256 257 /* GPIO3A */ 258 RK_PINDRIVE(3, 0, 0x1E0, 0, 2), 259 RK_PINDRIVE(3, 0, 0x1E0, 1, 4), 260 RK_PINDRIVE(3, 0, 0x1E0, 2, 8), 261 RK_PINDRIVE(3, 0, 0x1E0, 3, 12), 262 263 /* GPIO3B */ 264 RK_PINDRIVE(3, 1, 0x1E4, 0, 2), 265 RK_PINDRIVE(3, 1, 0x1E4, 1, 4), 266 RK_PINDRIVE(3, 1, 0x1E4, 2, 8), 267 RK_PINDRIVE(3, 1, 0x1E4, 3, 12), 268 269 /* GPIO3C */ 270 RK_PINDRIVE(3, 2, 0x1E8, 0, 2), 271 RK_PINDRIVE(3, 2, 0x1E8, 1, 4), 272 RK_PINDRIVE(3, 2, 0x1E8, 2, 8), 273 RK_PINDRIVE(3, 2, 0x1E8, 3, 12), 274 275 /* GPIO3D */ 276 RK_PINDRIVE(3, 3, 0x1EC, 0, 2), 277 RK_PINDRIVE(3, 3, 0x1EC, 1, 4), 278 RK_PINDRIVE(3, 3, 0x1EC, 2, 8), 279 RK_PINDRIVE(3, 3, 0x1EC, 3, 12), 280 281 /* GPIO4A */ 282 RK_PINDRIVE(4, 0, 0x1F0, 0, 2), 283 RK_PINDRIVE(4, 0, 0x1F0, 1, 4), 284 RK_PINDRIVE(4, 0, 0x1F0, 2, 8), 285 RK_PINDRIVE(4, 0, 0x1F0, 3, 12), 286 287 /* GPIO4B */ 288 RK_PINDRIVE(4, 1, 0x1F4, 0, 2), 289 RK_PINDRIVE(4, 1, 0x1F4, 1, 4), 290 RK_PINDRIVE(4, 1, 0x1F4, 2, 8), 291 RK_PINDRIVE(4, 1, 0x1F4, 3, 12), 292 293 /* GPIO4C */ 294 RK_PINDRIVE(4, 2, 0x1F8, 0, 2), 295 RK_PINDRIVE(4, 2, 0x1F8, 1, 4), 296 RK_PINDRIVE(4, 2, 0x1F8, 2, 8), 297 RK_PINDRIVE(4, 2, 0x1F8, 3, 12), 298 299 /* GPIO4D */ 300 RK_PINDRIVE(4, 3, 0x1FC, 0, 2), 301 RK_PINDRIVE(4, 3, 0x1FC, 1, 4), 302 RK_PINDRIVE(4, 3, 0x1FC, 2, 8), 303 RK_PINDRIVE(4, 3, 0x1FC, 3, 12), 304 305 /* GPIO5B */ 306 RK_PINDRIVE(5, 1, 0x204, 0, 2), 307 RK_PINDRIVE(5, 1, 0x204, 1, 4), 308 RK_PINDRIVE(5, 1, 0x204, 2, 8), 309 RK_PINDRIVE(5, 1, 0x204, 3, 12), 310 311 /* GPIO5C */ 312 RK_PINDRIVE(5, 2, 0x208, 0, 2), 313 RK_PINDRIVE(5, 2, 0x208, 1, 4), 314 RK_PINDRIVE(5, 2, 0x208, 2, 8), 315 RK_PINDRIVE(5, 2, 0x208, 3, 12), 316 317 /* GPIO6A */ 318 RK_PINDRIVE(6, 0, 0x210, 0, 2), 319 RK_PINDRIVE(6, 0, 0x210, 1, 4), 320 RK_PINDRIVE(6, 0, 0x210, 2, 8), 321 RK_PINDRIVE(6, 0, 0x210, 3, 12), 322 323 /* GPIO6B */ 324 RK_PINDRIVE(6, 1, 0x214, 0, 2), 325 RK_PINDRIVE(6, 1, 0x214, 1, 4), 326 RK_PINDRIVE(6, 1, 0x214, 2, 8), 327 RK_PINDRIVE(6, 1, 0x214, 3, 12), 328 329 /* GPIO6C */ 330 RK_PINDRIVE(6, 2, 0x218, 0, 2), 331 RK_PINDRIVE(6, 2, 0x218, 1, 4), 332 RK_PINDRIVE(6, 2, 0x218, 2, 8), 333 RK_PINDRIVE(6, 2, 0x218, 3, 12), 334 335 /* GPIO7A */ 336 RK_PINDRIVE(7, 0, 0x220, 0, 2), 337 RK_PINDRIVE(7, 0, 0x220, 1, 4), 338 RK_PINDRIVE(7, 0, 0x220, 2, 8), 339 RK_PINDRIVE(7, 0, 0x220, 3, 12), 340 341 /* GPIO7B */ 342 RK_PINDRIVE(7, 1, 0x224, 0, 2), 343 RK_PINDRIVE(7, 1, 0x224, 1, 4), 344 RK_PINDRIVE(7, 1, 0x224, 2, 8), 345 RK_PINDRIVE(7, 1, 0x224, 3, 12), 346 347 /* GPIO7C */ 348 RK_PINDRIVE(7, 2, 0x228, 0, 2), 349 RK_PINDRIVE(7, 2, 0x228, 1, 4), 350 RK_PINDRIVE(7, 2, 0x228, 2, 8), 351 RK_PINDRIVE(7, 2, 0x228, 3, 12), 352 353 /* GPIO8A */ 354 RK_PINDRIVE(8, 0, 0x230, 0, 2), 355 RK_PINDRIVE(8, 0, 0x230, 1, 4), 356 RK_PINDRIVE(8, 0, 0x230, 2, 8), 357 RK_PINDRIVE(8, 0, 0x230, 3, 12), 358 359 /* GPIO8B */ 360 RK_PINDRIVE(8, 1, 0x234, 0, 2), 361 RK_PINDRIVE(8, 1, 0x234, 1, 4), 362 RK_PINDRIVE(8, 1, 0x234, 2, 8), 363 RK_PINDRIVE(8, 1, 0x234, 3, 12), 364 }; 365 366 static uint32_t 367 rk3288_get_pd_offset(struct rk_pinctrl_softc *sc, uint32_t bank) 368 { 369 if (bank == 0) 370 return (0x064); /* PMU */ 371 return (0x130); 372 } 373 374 static struct syscon * 375 rk3288_get_syscon(struct rk_pinctrl_softc *sc, uint32_t bank) 376 { 377 if (bank == 0) 378 return (sc->pmu); 379 return (sc->grf); 380 } 381 382 static int 383 rk3288_parse_bias(phandle_t node, int bank) 384 { 385 if (OF_hasprop(node, "bias-disable")) 386 return (0); 387 if (OF_hasprop(node, "bias-pull-up")) 388 return (1); 389 if (OF_hasprop(node, "bias-pull-down")) 390 return (2); 391 392 return (-1); 393 } 394 395 static int 396 rk3288_resolv_bias_value(int bank, int bias) 397 { 398 int rv = 0; 399 400 if (bias == 1) 401 rv = GPIO_PIN_PULLUP; 402 else if (bias == 2) 403 rv = GPIO_PIN_PULLDOWN; 404 405 return (rv); 406 } 407 408 static int 409 rk3288_get_bias_value(int bank, int bias) 410 { 411 int rv = 0; 412 413 if (bias & GPIO_PIN_PULLUP) 414 rv = 1; 415 else if (bias & GPIO_PIN_PULLDOWN) 416 rv = 2; 417 418 return (rv); 419 } 420 421 struct rk_pinctrl_conf rk3288_conf = { 422 .iomux_conf = rk3288_iomux_bank, 423 .iomux_nbanks = nitems(rk3288_iomux_bank), 424 .pin_fixup = rk3288_pin_fixup, 425 .npin_fixup = nitems(rk3288_pin_fixup), 426 .pin_drive = rk3288_pin_drive, 427 .npin_drive = nitems(rk3288_pin_drive), 428 .gpio_bank = rk3288_gpio_bank, 429 .ngpio_bank = nitems(rk3288_gpio_bank), 430 .get_pd_offset = rk3288_get_pd_offset, 431 .get_syscon = rk3288_get_syscon, 432 .parse_bias = rk3288_parse_bias, 433 .resolv_bias_value = rk3288_resolv_bias_value, 434 .get_bias_value = rk3288_get_bias_value, 435 }; 436 437 static struct rk_pinctrl_gpio rk3328_gpio_bank[] = { 438 RK_GPIO(0, "gpio0"), 439 RK_GPIO(1, "gpio1"), 440 RK_GPIO(2, "gpio2"), 441 RK_GPIO(3, "gpio3"), 442 }; 443 444 static struct rk_pinctrl_bank rk3328_iomux_bank[] = { 445 /* bank sub offs nbits */ 446 RK_IOMUX(0, 0, 0x0000, 2), 447 RK_IOMUX(0, 1, 0x0004, 2), 448 RK_IOMUX(0, 2, 0x0008, 2), 449 RK_IOMUX(0, 3, 0x000C, 2), 450 RK_IOMUX(1, 0, 0x0010, 2), 451 RK_IOMUX(1, 1, 0x0014, 2), 452 RK_IOMUX(1, 2, 0x0018, 2), 453 RK_IOMUX(1, 3, 0x001C, 2), 454 RK_IOMUX(2, 0, 0x0020, 2), 455 RK_IOMUX(2, 1, 0x0024, 3), 456 RK_IOMUX(2, 2, 0x002c, 3), 457 RK_IOMUX(2, 3, 0x0034, 2), 458 RK_IOMUX(3, 0, 0x0038, 3), 459 RK_IOMUX(3, 1, 0x0040, 3), 460 RK_IOMUX(3, 2, 0x0048, 2), 461 RK_IOMUX(3, 3, 0x004c, 2), 462 }; 463 464 static struct rk_pinctrl_pin_fixup rk3328_pin_fixup[] = { 465 /* bank pin reg bit mask */ 466 RK_PINFIX(2, 12, 0x24, 8, 0x300), 467 RK_PINFIX(2, 15, 0x28, 0, 0x7), 468 RK_PINFIX(2, 23, 0x30, 14, 0x6000), 469 }; 470 471 472 static struct rk_pinctrl_pin_drive rk3328_pin_drive[] = { 473 /* bank sub offs val ma */ 474 RK_PINDRIVE(0, 0, 0x200, 0, 2), 475 RK_PINDRIVE(0, 0, 0x200, 1, 4), 476 RK_PINDRIVE(0, 0, 0x200, 2, 8), 477 RK_PINDRIVE(0, 0, 0x200, 3, 12), 478 479 RK_PINDRIVE(0, 1, 0x204, 0, 2), 480 RK_PINDRIVE(0, 1, 0x204, 1, 4), 481 RK_PINDRIVE(0, 1, 0x204, 2, 8), 482 RK_PINDRIVE(0, 1, 0x204, 3, 12), 483 484 RK_PINDRIVE(0, 2, 0x208, 0, 2), 485 RK_PINDRIVE(0, 2, 0x208, 1, 4), 486 RK_PINDRIVE(0, 2, 0x208, 2, 8), 487 RK_PINDRIVE(0, 2, 0x208, 3, 12), 488 489 RK_PINDRIVE(0, 3, 0x20C, 0, 2), 490 RK_PINDRIVE(0, 3, 0x20C, 1, 4), 491 RK_PINDRIVE(0, 3, 0x20C, 2, 8), 492 RK_PINDRIVE(0, 3, 0x20C, 3, 12), 493 494 RK_PINDRIVE(1, 0, 0x210, 0, 2), 495 RK_PINDRIVE(1, 0, 0x210, 1, 4), 496 RK_PINDRIVE(1, 0, 0x210, 2, 8), 497 RK_PINDRIVE(1, 0, 0x210, 3, 12), 498 499 RK_PINDRIVE(1, 1, 0x214, 0, 2), 500 RK_PINDRIVE(1, 1, 0x214, 1, 4), 501 RK_PINDRIVE(1, 1, 0x214, 2, 8), 502 RK_PINDRIVE(1, 1, 0x214, 3, 12), 503 504 RK_PINDRIVE(1, 2, 0x218, 0, 2), 505 RK_PINDRIVE(1, 2, 0x218, 1, 4), 506 RK_PINDRIVE(1, 2, 0x218, 2, 8), 507 RK_PINDRIVE(1, 2, 0x218, 3, 12), 508 509 RK_PINDRIVE(1, 3, 0x21C, 0, 2), 510 RK_PINDRIVE(1, 3, 0x21C, 1, 4), 511 RK_PINDRIVE(1, 3, 0x21C, 2, 8), 512 RK_PINDRIVE(1, 3, 0x21C, 3, 12), 513 514 RK_PINDRIVE(2, 0, 0x220, 0, 2), 515 RK_PINDRIVE(2, 0, 0x220, 1, 4), 516 RK_PINDRIVE(2, 0, 0x220, 2, 8), 517 RK_PINDRIVE(2, 0, 0x220, 3, 12), 518 519 RK_PINDRIVE(2, 1, 0x224, 0, 2), 520 RK_PINDRIVE(2, 1, 0x224, 1, 4), 521 RK_PINDRIVE(2, 1, 0x224, 2, 8), 522 RK_PINDRIVE(2, 1, 0x224, 3, 12), 523 524 RK_PINDRIVE(2, 2, 0x228, 0, 2), 525 RK_PINDRIVE(2, 2, 0x228, 1, 4), 526 RK_PINDRIVE(2, 2, 0x228, 2, 8), 527 RK_PINDRIVE(2, 2, 0x228, 3, 12), 528 529 RK_PINDRIVE(2, 3, 0x22C, 0, 2), 530 RK_PINDRIVE(2, 3, 0x22C, 1, 4), 531 RK_PINDRIVE(2, 3, 0x22C, 2, 8), 532 RK_PINDRIVE(2, 3, 0x22C, 3, 12), 533 534 RK_PINDRIVE(3, 0, 0x230, 0, 2), 535 RK_PINDRIVE(3, 0, 0x230, 1, 4), 536 RK_PINDRIVE(3, 0, 0x230, 2, 8), 537 RK_PINDRIVE(3, 0, 0x230, 3, 12), 538 539 RK_PINDRIVE(3, 1, 0x234, 0, 2), 540 RK_PINDRIVE(3, 1, 0x234, 1, 4), 541 RK_PINDRIVE(3, 1, 0x234, 2, 8), 542 RK_PINDRIVE(3, 1, 0x234, 3, 12), 543 544 RK_PINDRIVE(3, 2, 0x238, 0, 2), 545 RK_PINDRIVE(3, 2, 0x238, 1, 4), 546 RK_PINDRIVE(3, 2, 0x238, 2, 8), 547 RK_PINDRIVE(3, 2, 0x238, 3, 12), 548 549 RK_PINDRIVE(3, 3, 0x23C, 0, 2), 550 RK_PINDRIVE(3, 3, 0x23C, 1, 4), 551 RK_PINDRIVE(3, 3, 0x23C, 2, 8), 552 RK_PINDRIVE(3, 3, 0x23C, 3, 12), 553 }; 554 555 static uint32_t 556 rk3328_get_pd_offset(struct rk_pinctrl_softc *sc, uint32_t bank) 557 { 558 return (0x100); 559 } 560 561 static struct syscon * 562 rk3328_get_syscon(struct rk_pinctrl_softc *sc, uint32_t bank) 563 { 564 return (sc->grf); 565 } 566 567 struct rk_pinctrl_conf rk3328_conf = { 568 .iomux_conf = rk3328_iomux_bank, 569 .iomux_nbanks = nitems(rk3328_iomux_bank), 570 .pin_fixup = rk3328_pin_fixup, 571 .npin_fixup = nitems(rk3328_pin_fixup), 572 .pin_drive = rk3328_pin_drive, 573 .npin_drive = nitems(rk3328_pin_drive), 574 .gpio_bank = rk3328_gpio_bank, 575 .ngpio_bank = nitems(rk3328_gpio_bank), 576 .get_pd_offset = rk3328_get_pd_offset, 577 .get_syscon = rk3328_get_syscon, 578 .parse_bias = rk3288_parse_bias, 579 .resolv_bias_value = rk3288_resolv_bias_value, 580 .get_bias_value = rk3288_get_bias_value, 581 }; 582 583 static struct rk_pinctrl_gpio rk3399_gpio_bank[] = { 584 RK_GPIO(0, "gpio0"), 585 RK_GPIO(1, "gpio1"), 586 RK_GPIO(2, "gpio2"), 587 RK_GPIO(3, "gpio3"), 588 RK_GPIO(4, "gpio4"), 589 }; 590 591 static struct rk_pinctrl_bank rk3399_iomux_bank[] = { 592 /* bank sub offs nbits */ 593 RK_IOMUX(0, 0, 0x0000, 2), 594 RK_IOMUX(0, 1, 0x0004, 2), 595 RK_IOMUX(0, 2, 0x0008, 2), 596 RK_IOMUX(0, 3, 0x000C, 2), 597 RK_IOMUX(1, 0, 0x0010, 2), 598 RK_IOMUX(1, 1, 0x0014, 2), 599 RK_IOMUX(1, 2, 0x0018, 2), 600 RK_IOMUX(1, 3, 0x001C, 2), 601 RK_IOMUX(2, 0, 0xE000, 2), 602 RK_IOMUX(2, 1, 0xE004, 2), 603 RK_IOMUX(2, 2, 0xE008, 2), 604 RK_IOMUX(2, 3, 0xE00C, 2), 605 RK_IOMUX(3, 0, 0xE010, 2), 606 RK_IOMUX(3, 1, 0xE014, 2), 607 RK_IOMUX(3, 2, 0xE018, 2), 608 RK_IOMUX(3, 3, 0xE01C, 2), 609 RK_IOMUX(4, 0, 0xE020, 2), 610 RK_IOMUX(4, 1, 0xE024, 2), 611 RK_IOMUX(4, 2, 0xE028, 2), 612 RK_IOMUX(4, 3, 0xE02C, 2), 613 }; 614 615 static struct rk_pinctrl_pin_fixup rk3399_pin_fixup[] = {}; 616 617 static struct rk_pinctrl_pin_drive rk3399_pin_drive[] = { 618 /* bank sub offs val ma */ 619 /* GPIO0A */ 620 RK_PINDRIVE(0, 0, 0x80, 0, 5), 621 RK_PINDRIVE(0, 0, 0x80, 1, 10), 622 RK_PINDRIVE(0, 0, 0x80, 2, 15), 623 RK_PINDRIVE(0, 0, 0x80, 3, 20), 624 625 /* GPIOB */ 626 RK_PINDRIVE(0, 1, 0x88, 0, 5), 627 RK_PINDRIVE(0, 1, 0x88, 1, 10), 628 RK_PINDRIVE(0, 1, 0x88, 2, 15), 629 RK_PINDRIVE(0, 1, 0x88, 3, 20), 630 631 /* GPIO1A */ 632 RK_PINDRIVE(1, 0, 0xA0, 0, 3), 633 RK_PINDRIVE(1, 0, 0xA0, 1, 6), 634 RK_PINDRIVE(1, 0, 0xA0, 2, 9), 635 RK_PINDRIVE(1, 0, 0xA0, 3, 12), 636 637 /* GPIO1B */ 638 RK_PINDRIVE(1, 1, 0xA8, 0, 3), 639 RK_PINDRIVE(1, 1, 0xA8, 1, 6), 640 RK_PINDRIVE(1, 1, 0xA8, 2, 9), 641 RK_PINDRIVE(1, 1, 0xA8, 3, 12), 642 643 /* GPIO1C */ 644 RK_PINDRIVE(1, 2, 0xB0, 0, 3), 645 RK_PINDRIVE(1, 2, 0xB0, 1, 6), 646 RK_PINDRIVE(1, 2, 0xB0, 2, 9), 647 RK_PINDRIVE(1, 2, 0xB0, 3, 12), 648 649 /* GPIO1D */ 650 RK_PINDRIVE(1, 3, 0xB8, 0, 3), 651 RK_PINDRIVE(1, 3, 0xB8, 1, 6), 652 RK_PINDRIVE(1, 3, 0xB8, 2, 9), 653 RK_PINDRIVE(1, 3, 0xB8, 3, 12), 654 }; 655 656 static uint32_t 657 rk3399_get_pd_offset(struct rk_pinctrl_softc *sc, uint32_t bank) 658 { 659 if (bank < 2) 660 return (0x40); 661 662 return (0xE040); 663 } 664 665 static struct syscon * 666 rk3399_get_syscon(struct rk_pinctrl_softc *sc, uint32_t bank) 667 { 668 if (bank < 2) 669 return (sc->pmu); 670 671 return (sc->grf); 672 } 673 674 static int 675 rk3399_parse_bias(phandle_t node, int bank) 676 { 677 int pullup, pulldown; 678 679 if (OF_hasprop(node, "bias-disable")) 680 return (0); 681 682 switch (bank) { 683 case 0: 684 case 2: 685 pullup = 3; 686 pulldown = 1; 687 break; 688 case 1: 689 case 3: 690 case 4: 691 pullup = 1; 692 pulldown = 2; 693 break; 694 } 695 696 if (OF_hasprop(node, "bias-pull-up")) 697 return (pullup); 698 if (OF_hasprop(node, "bias-pull-down")) 699 return (pulldown); 700 701 return (-1); 702 } 703 704 static int 705 rk3399_resolv_bias_value(int bank, int bias) 706 { 707 int rv = 0; 708 709 switch (bank) { 710 case 0: 711 case 2: 712 if (bias == 3) 713 rv = GPIO_PIN_PULLUP; 714 else if (bias == 1) 715 rv = GPIO_PIN_PULLDOWN; 716 break; 717 case 1: 718 case 3: 719 case 4: 720 if (bias == 1) 721 rv = GPIO_PIN_PULLUP; 722 else if (bias == 2) 723 rv = GPIO_PIN_PULLDOWN; 724 break; 725 } 726 727 return (rv); 728 } 729 730 static int 731 rk3399_get_bias_value(int bank, int bias) 732 { 733 int rv = 0; 734 735 switch (bank) { 736 case 0: 737 case 2: 738 if (bias & GPIO_PIN_PULLUP) 739 rv = 3; 740 else if (bias & GPIO_PIN_PULLDOWN) 741 rv = 1; 742 break; 743 case 1: 744 case 3: 745 case 4: 746 if (bias & GPIO_PIN_PULLUP) 747 rv = 1; 748 else if (bias & GPIO_PIN_PULLDOWN) 749 rv = 2; 750 break; 751 } 752 753 return (rv); 754 } 755 756 struct rk_pinctrl_conf rk3399_conf = { 757 .iomux_conf = rk3399_iomux_bank, 758 .iomux_nbanks = nitems(rk3399_iomux_bank), 759 .pin_fixup = rk3399_pin_fixup, 760 .npin_fixup = nitems(rk3399_pin_fixup), 761 .pin_drive = rk3399_pin_drive, 762 .npin_drive = nitems(rk3399_pin_drive), 763 .gpio_bank = rk3399_gpio_bank, 764 .ngpio_bank = nitems(rk3399_gpio_bank), 765 .get_pd_offset = rk3399_get_pd_offset, 766 .get_syscon = rk3399_get_syscon, 767 .parse_bias = rk3399_parse_bias, 768 .resolv_bias_value = rk3399_resolv_bias_value, 769 .get_bias_value = rk3399_get_bias_value, 770 }; 771 772 static struct ofw_compat_data compat_data[] = { 773 {"rockchip,rk3288-pinctrl", (uintptr_t)&rk3288_conf}, 774 {"rockchip,rk3328-pinctrl", (uintptr_t)&rk3328_conf}, 775 {"rockchip,rk3399-pinctrl", (uintptr_t)&rk3399_conf}, 776 {NULL, 0} 777 }; 778 779 static int 780 rk_pinctrl_parse_drive(struct rk_pinctrl_softc *sc, phandle_t node, 781 uint32_t bank, uint32_t subbank, uint32_t *drive, uint32_t *offset) 782 { 783 uint32_t value; 784 int i; 785 786 if (OF_getencprop(node, "drive-strength", &value, 787 sizeof(value)) != 0) 788 return (-1); 789 790 /* Map to the correct drive value */ 791 for (i = 0; i < sc->conf->npin_drive; i++) { 792 if (sc->conf->pin_drive[i].bank != bank && 793 sc->conf->pin_drive[i].subbank != subbank) 794 continue; 795 if (sc->conf->pin_drive[i].ma == value) { 796 *drive = sc->conf->pin_drive[i].value; 797 return (0); 798 } 799 } 800 801 return (-1); 802 } 803 804 static void 805 rk_pinctrl_get_fixup(struct rk_pinctrl_softc *sc, uint32_t bank, uint32_t pin, 806 uint32_t *reg, uint32_t *mask, uint32_t *bit) 807 { 808 int i; 809 810 for (i = 0; i < sc->conf->npin_fixup; i++) 811 if (sc->conf->pin_fixup[i].bank == bank && 812 sc->conf->pin_fixup[i].pin == pin) { 813 *reg = sc->conf->pin_fixup[i].reg; 814 *mask = sc->conf->pin_fixup[i].mask; 815 *bit = sc->conf->pin_fixup[i].bit; 816 817 return; 818 } 819 } 820 821 static int 822 rk_pinctrl_handle_io(struct rk_pinctrl_softc *sc, phandle_t node, uint32_t bank, 823 uint32_t pin) 824 { 825 bool have_cfg, have_direction, have_value; 826 uint32_t direction_value, pin_value; 827 struct rk_pinctrl_gpio *gpio; 828 int i, rv; 829 830 have_cfg = false; 831 have_direction = false; 832 have_value = false; 833 834 /* Get (subset of) GPIO pin properties. */ 835 if (OF_hasprop(node, "output-disable")) { 836 have_cfg = true; 837 have_direction = true; 838 direction_value = GPIO_PIN_INPUT; 839 } 840 841 if (OF_hasprop(node, "output-enable")) { 842 have_cfg = true; 843 have_direction = true; 844 direction_value = GPIO_PIN_OUTPUT; 845 } 846 847 if (OF_hasprop(node, "output-low")) { 848 have_cfg = true; 849 have_direction = true; 850 direction_value = GPIO_PIN_OUTPUT; 851 have_value = true; 852 pin_value = 0; 853 } 854 855 if (OF_hasprop(node, "output-high")) { 856 have_cfg = true; 857 have_direction = true; 858 direction_value = GPIO_PIN_OUTPUT; 859 have_value = true; 860 pin_value = 1; 861 } 862 863 if (!have_cfg) 864 return (0); 865 866 /* Find gpio */ 867 gpio = NULL; 868 for(i = 0; i < sc->conf->ngpio_bank; i++) { 869 if (bank == sc->conf->gpio_bank[i].bank) { 870 gpio = sc->conf->gpio_bank + i; 871 break; 872 } 873 } 874 if (gpio == NULL) { 875 device_printf(sc->dev, "Cannot find GPIO bank %d\n", bank); 876 return (ENXIO); 877 } 878 if (gpio->gpio_dev == NULL) { 879 device_printf(sc->dev, 880 "No GPIO subdevice found for bank %d\n", bank); 881 return (ENXIO); 882 } 883 884 rv = 0; 885 if (have_value) { 886 rv = GPIO_PIN_SET(gpio->gpio_dev, pin, pin_value); 887 if (rv != 0) { 888 device_printf(sc->dev, "Cannot set GPIO value: %d\n", 889 rv); 890 return (rv); 891 } 892 } 893 894 if (have_direction) { 895 rv = GPIO_PIN_SETFLAGS(gpio->gpio_dev, pin, direction_value); 896 if (rv != 0) { 897 device_printf(sc->dev, 898 "Cannot set GPIO direction: %d\n", rv); 899 return (rv); 900 } 901 } 902 903 return (0); 904 } 905 906 static void 907 rk_pinctrl_configure_pin(struct rk_pinctrl_softc *sc, uint32_t *pindata) 908 { 909 phandle_t pin_conf; 910 struct syscon *syscon; 911 uint32_t bank, subbank, pin, function, bias; 912 uint32_t bit, mask, reg, drive; 913 int i, rv; 914 915 bank = pindata[0]; 916 pin = pindata[1]; 917 function = pindata[2]; 918 pin_conf = OF_node_from_xref(pindata[3]); 919 subbank = pin / 8; 920 921 for (i = 0; i < sc->conf->iomux_nbanks; i++) 922 if (sc->conf->iomux_conf[i].bank == bank && 923 sc->conf->iomux_conf[i].subbank == subbank) 924 break; 925 926 if (i == sc->conf->iomux_nbanks) { 927 device_printf(sc->dev, "Unknown pin %d in bank %d\n", pin, 928 bank); 929 return; 930 } 931 932 /* Find syscon */ 933 syscon = sc->conf->get_syscon(sc, bank); 934 935 /* Parse pin function */ 936 reg = sc->conf->iomux_conf[i].offset; 937 switch (sc->conf->iomux_conf[i].nbits) { 938 case 4: 939 if ((pin % 8) >= 4) 940 reg += 0x4; 941 bit = (pin % 4) * 4; 942 mask = (0xF << bit); 943 break; 944 case 3: 945 if ((pin % 8) >= 5) 946 reg += 4; 947 bit = (pin % 8 % 5) * 3; 948 mask = (0x7 << bit); 949 break; 950 case 2: 951 bit = (pin % 8) * 2; 952 mask = (0x3 << bit); 953 break; 954 default: 955 device_printf(sc->dev, 956 "Unknown pin stride width %d in bank %d\n", 957 sc->conf->iomux_conf[i].nbits, bank); 958 return; 959 } 960 rk_pinctrl_get_fixup(sc, bank, pin, ®, &mask, &bit); 961 962 /* 963 * NOTE: not all syscon registers uses hi-word write mask, thus 964 * register modify method should be used. 965 * XXXX We should not pass write mask to syscon register 966 * without hi-word write mask. 967 */ 968 SYSCON_MODIFY_4(syscon, reg, mask, function << bit | (mask << 16)); 969 970 /* Pull-Up/Down */ 971 bias = sc->conf->parse_bias(pin_conf, bank); 972 if (bias >= 0) { 973 reg = sc->conf->get_pd_offset(sc, bank); 974 975 reg += bank * 0x10 + ((pin / 8) * 0x4); 976 bit = (pin % 8) * 2; 977 mask = (0x3 << bit); 978 SYSCON_MODIFY_4(syscon, reg, mask, bias << bit | (mask << 16)); 979 } 980 981 /* Drive Strength */ 982 rv = rk_pinctrl_parse_drive(sc, pin_conf, bank, subbank, &drive, ®); 983 if (rv == 0) { 984 bit = (pin % 8) * 2; 985 mask = (0x3 << bit); 986 SYSCON_MODIFY_4(syscon, reg, mask, drive << bit | (mask << 16)); 987 } 988 989 /* Input/Outpot + default level */ 990 rv = rk_pinctrl_handle_io(sc, pin_conf, bank, pin); 991 } 992 993 static int 994 rk_pinctrl_configure_pins(device_t dev, phandle_t cfgxref) 995 { 996 struct rk_pinctrl_softc *sc; 997 phandle_t node; 998 uint32_t *pins; 999 int i, npins; 1000 1001 sc = device_get_softc(dev); 1002 node = OF_node_from_xref(cfgxref); 1003 1004 npins = OF_getencprop_alloc_multi(node, "rockchip,pins", sizeof(*pins), 1005 (void **)&pins); 1006 if (npins <= 0) 1007 return (ENOENT); 1008 1009 for (i = 0; i != npins; i += 4) 1010 rk_pinctrl_configure_pin(sc, pins + i); 1011 1012 return (0); 1013 } 1014 1015 static int 1016 rk_pinctrl_is_gpio_locked(struct rk_pinctrl_softc *sc, struct syscon *syscon, 1017 int bank, uint32_t pin, bool *is_gpio) 1018 { 1019 uint32_t subbank, bit, mask, reg; 1020 uint32_t pinfunc; 1021 int i; 1022 1023 RK_PINCTRL_LOCK_ASSERT(sc); 1024 1025 subbank = pin / 8; 1026 *is_gpio = false; 1027 1028 for (i = 0; i < sc->conf->iomux_nbanks; i++) 1029 if (sc->conf->iomux_conf[i].bank == bank && 1030 sc->conf->iomux_conf[i].subbank == subbank) 1031 break; 1032 1033 if (i == sc->conf->iomux_nbanks) { 1034 device_printf(sc->dev, "Unknown pin %d in bank %d\n", pin, 1035 bank); 1036 return (EINVAL); 1037 } 1038 1039 syscon = sc->conf->get_syscon(sc, bank); 1040 1041 /* Parse pin function */ 1042 reg = sc->conf->iomux_conf[i].offset; 1043 switch (sc->conf->iomux_conf[i].nbits) { 1044 case 4: 1045 if ((pin % 8) >= 4) 1046 reg += 0x4; 1047 bit = (pin % 4) * 4; 1048 mask = (0xF << bit); 1049 break; 1050 case 3: 1051 if ((pin % 8) >= 5) 1052 reg += 4; 1053 bit = (pin % 8 % 5) * 3; 1054 mask = (0x7 << bit); 1055 break; 1056 case 2: 1057 bit = (pin % 8) * 2; 1058 mask = (0x3 << bit); 1059 break; 1060 default: 1061 device_printf(sc->dev, 1062 "Unknown pin stride width %d in bank %d\n", 1063 sc->conf->iomux_conf[i].nbits, bank); 1064 return (EINVAL); 1065 } 1066 rk_pinctrl_get_fixup(sc, bank, pin, ®, &mask, &bit); 1067 1068 reg = SYSCON_READ_4(syscon, reg); 1069 pinfunc = (reg & mask) >> bit; 1070 1071 /* Test if the pin is in gpio mode */ 1072 if (pinfunc == 0) 1073 *is_gpio = true; 1074 1075 return (0); 1076 } 1077 1078 static int 1079 rk_pinctrl_get_bank(struct rk_pinctrl_softc *sc, device_t gpio, int *bank) 1080 { 1081 int i; 1082 1083 for (i = 0; i < sc->conf->ngpio_bank; i++) { 1084 if (sc->conf->gpio_bank[i].gpio_dev == gpio) 1085 break; 1086 } 1087 if (i == sc->conf->ngpio_bank) 1088 return (EINVAL); 1089 1090 *bank = i; 1091 return (0); 1092 } 1093 1094 static int 1095 rk_pinctrl_is_gpio(device_t pinctrl, device_t gpio, uint32_t pin, bool *is_gpio) 1096 { 1097 struct rk_pinctrl_softc *sc; 1098 struct syscon *syscon; 1099 int bank; 1100 int rv; 1101 1102 sc = device_get_softc(pinctrl); 1103 RK_PINCTRL_LOCK(sc); 1104 1105 rv = rk_pinctrl_get_bank(sc, gpio, &bank); 1106 if (rv != 0) 1107 goto done; 1108 syscon = sc->conf->get_syscon(sc, bank); 1109 rv = rk_pinctrl_is_gpio_locked(sc, syscon, bank, pin, is_gpio); 1110 1111 done: 1112 RK_PINCTRL_UNLOCK(sc); 1113 1114 return (rv); 1115 } 1116 1117 static int 1118 rk_pinctrl_get_flags(device_t pinctrl, device_t gpio, uint32_t pin, 1119 uint32_t *flags) 1120 { 1121 struct rk_pinctrl_softc *sc; 1122 struct syscon *syscon; 1123 uint32_t reg, mask, bit; 1124 uint32_t bias; 1125 int bank; 1126 int rv = 0; 1127 bool is_gpio; 1128 1129 sc = device_get_softc(pinctrl); 1130 RK_PINCTRL_LOCK(sc); 1131 1132 rv = rk_pinctrl_get_bank(sc, gpio, &bank); 1133 if (rv != 0) 1134 goto done; 1135 syscon = sc->conf->get_syscon(sc, bank); 1136 rv = rk_pinctrl_is_gpio_locked(sc, syscon, bank, pin, &is_gpio); 1137 if (rv != 0) 1138 goto done; 1139 if (!is_gpio) { 1140 rv = EINVAL; 1141 goto done; 1142 } 1143 /* Get the pullup/pulldown configuration */ 1144 reg = sc->conf->get_pd_offset(sc, bank); 1145 reg += bank * 0x10 + ((pin / 8) * 0x4); 1146 bit = (pin % 8) * 2; 1147 mask = (0x3 << bit) << 16; 1148 reg = SYSCON_READ_4(syscon, reg); 1149 reg = (reg >> bit) & 0x3; 1150 bias = sc->conf->resolv_bias_value(bank, reg); 1151 *flags = bias; 1152 1153 done: 1154 RK_PINCTRL_UNLOCK(sc); 1155 return (rv); 1156 } 1157 1158 static int 1159 rk_pinctrl_set_flags(device_t pinctrl, device_t gpio, uint32_t pin, 1160 uint32_t flags) 1161 { 1162 struct rk_pinctrl_softc *sc; 1163 struct syscon *syscon; 1164 uint32_t bit, mask, reg; 1165 uint32_t bias; 1166 int bank; 1167 int rv = 0; 1168 bool is_gpio; 1169 1170 sc = device_get_softc(pinctrl); 1171 RK_PINCTRL_LOCK(sc); 1172 1173 rv = rk_pinctrl_get_bank(sc, gpio, &bank); 1174 if (rv != 0) 1175 goto done; 1176 syscon = sc->conf->get_syscon(sc, bank); 1177 rv = rk_pinctrl_is_gpio_locked(sc, syscon, bank, pin, &is_gpio); 1178 if (rv != 0) 1179 goto done; 1180 if (!is_gpio) { 1181 rv = EINVAL; 1182 goto done; 1183 } 1184 /* Get the pullup/pulldown configuration */ 1185 reg = sc->conf->get_pd_offset(sc, bank); 1186 reg += bank * 0x10 + ((pin / 8) * 0x4); 1187 bit = (pin % 8) * 2; 1188 mask = (0x3 << bit); 1189 bias = sc->conf->get_bias_value(bank, flags); 1190 SYSCON_MODIFY_4(syscon, reg, mask, bias << bit | (mask << 16)); 1191 1192 done: 1193 RK_PINCTRL_UNLOCK(sc); 1194 return (rv); 1195 } 1196 1197 static int 1198 rk_pinctrl_register_gpio(struct rk_pinctrl_softc *sc, char *gpio_name, 1199 device_t gpio_dev) 1200 { 1201 int i; 1202 1203 for(i = 0; i < sc->conf->ngpio_bank; i++) { 1204 if (strcmp(gpio_name, sc->conf->gpio_bank[i].gpio_name) != 0) 1205 continue; 1206 sc->conf->gpio_bank[i].gpio_dev = gpio_dev; 1207 return(0); 1208 } 1209 return (ENXIO); 1210 } 1211 1212 static int 1213 rk_pinctrl_probe(device_t dev) 1214 { 1215 1216 if (!ofw_bus_status_okay(dev)) 1217 return (ENXIO); 1218 1219 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0) 1220 return (ENXIO); 1221 1222 device_set_desc(dev, "RockChip Pinctrl controller"); 1223 return (BUS_PROBE_DEFAULT); 1224 } 1225 1226 static int 1227 rk_pinctrl_attach(device_t dev) 1228 { 1229 struct rk_pinctrl_softc *sc; 1230 phandle_t node; 1231 device_t cdev; 1232 char *gpio_name, *eptr; 1233 int rv; 1234 1235 sc = device_get_softc(dev); 1236 sc->dev = dev; 1237 1238 node = ofw_bus_get_node(dev); 1239 1240 if (OF_hasprop(node, "rockchip,grf") && 1241 syscon_get_by_ofw_property(dev, node, 1242 "rockchip,grf", &sc->grf) != 0) { 1243 device_printf(dev, "cannot get grf driver handle\n"); 1244 return (ENXIO); 1245 } 1246 1247 /* RK3399,RK3288 has banks in PMU. RK3328 does not have a PMU. */ 1248 if (ofw_bus_node_is_compatible(node, "rockchip,rk3399-pinctrl") || 1249 ofw_bus_node_is_compatible(node, "rockchip,rk3288-pinctrl")) { 1250 if (OF_hasprop(node, "rockchip,pmu") && 1251 syscon_get_by_ofw_property(dev, node, 1252 "rockchip,pmu", &sc->pmu) != 0) { 1253 device_printf(dev, "cannot get pmu driver handle\n"); 1254 return (ENXIO); 1255 } 1256 } 1257 1258 mtx_init(&sc->mtx, "rk pinctrl", "pinctrl", MTX_SPIN); 1259 1260 sc->conf = (struct rk_pinctrl_conf *)ofw_bus_search_compatible(dev, 1261 compat_data)->ocd_data; 1262 1263 fdt_pinctrl_register(dev, "rockchip,pins"); 1264 1265 simplebus_init(dev, node); 1266 1267 bus_generic_probe(dev); 1268 1269 /* Attach child devices */ 1270 for (node = OF_child(node); node > 0; node = OF_peer(node)) { 1271 if (!ofw_bus_node_is_compatible(node, "rockchip,gpio-bank")) 1272 continue; 1273 1274 rv = OF_getprop_alloc(node, "name", (void **)&gpio_name); 1275 if (rv <= 0) { 1276 device_printf(sc->dev, "Cannot GPIO subdevice name.\n"); 1277 continue; 1278 } 1279 1280 cdev = simplebus_add_device(dev, node, 0, NULL, -1, NULL); 1281 if (cdev == NULL) { 1282 device_printf(dev, " Cannot add GPIO subdevice: %s\n", 1283 gpio_name); 1284 OF_prop_free(gpio_name); 1285 continue; 1286 } 1287 1288 rv = device_probe_and_attach(cdev); 1289 if (rv != 0) { 1290 device_printf(sc->dev, 1291 "Cannot attach GPIO subdevice: %s\n", gpio_name); 1292 OF_prop_free(gpio_name); 1293 continue; 1294 } 1295 1296 /* Grep device name from name property */ 1297 eptr = gpio_name; 1298 strsep(&eptr, "@"); 1299 if (gpio_name == eptr) { 1300 device_printf(sc->dev, 1301 "Unrecognized format of GPIO subdevice name: %s\n", 1302 gpio_name); 1303 OF_prop_free(gpio_name); 1304 continue; 1305 } 1306 rv = rk_pinctrl_register_gpio(sc, gpio_name, cdev); 1307 if (rv != 0) { 1308 device_printf(sc->dev, 1309 "Cannot register GPIO subdevice %s: %d\n", 1310 gpio_name, rv); 1311 OF_prop_free(gpio_name); 1312 continue; 1313 } 1314 OF_prop_free(gpio_name); 1315 } 1316 1317 fdt_pinctrl_configure_tree(dev); 1318 1319 return (bus_generic_attach(dev)); 1320 } 1321 1322 static int 1323 rk_pinctrl_detach(device_t dev) 1324 { 1325 1326 return (EBUSY); 1327 } 1328 1329 static device_method_t rk_pinctrl_methods[] = { 1330 /* Device interface */ 1331 DEVMETHOD(device_probe, rk_pinctrl_probe), 1332 DEVMETHOD(device_attach, rk_pinctrl_attach), 1333 DEVMETHOD(device_detach, rk_pinctrl_detach), 1334 1335 /* fdt_pinctrl interface */ 1336 DEVMETHOD(fdt_pinctrl_configure, rk_pinctrl_configure_pins), 1337 DEVMETHOD(fdt_pinctrl_is_gpio, rk_pinctrl_is_gpio), 1338 DEVMETHOD(fdt_pinctrl_get_flags, rk_pinctrl_get_flags), 1339 DEVMETHOD(fdt_pinctrl_set_flags, rk_pinctrl_set_flags), 1340 1341 DEVMETHOD_END 1342 }; 1343 1344 static devclass_t rk_pinctrl_devclass; 1345 1346 DEFINE_CLASS_1(rk_pinctrl, rk_pinctrl_driver, rk_pinctrl_methods, 1347 sizeof(struct rk_pinctrl_softc), simplebus_driver); 1348 1349 EARLY_DRIVER_MODULE(rk_pinctrl, simplebus, rk_pinctrl_driver, 1350 rk_pinctrl_devclass, 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_MIDDLE); 1351 MODULE_VERSION(rk_pinctrl, 1); 1352