1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver for BCM6362 GPIO unit (pinctrl + GPIO) 4 * 5 * Copyright (C) 2021 Álvaro Fernández Rojas <noltari@gmail.com> 6 * Copyright (C) 2016 Jonas Gorski <jonas.gorski@gmail.com> 7 */ 8 9 #include <linux/bits.h> 10 #include <linux/gpio/driver.h> 11 #include <linux/kernel.h> 12 #include <linux/of.h> 13 #include <linux/pinctrl/pinmux.h> 14 #include <linux/platform_device.h> 15 #include <linux/regmap.h> 16 17 #include "../pinctrl-utils.h" 18 19 #include "pinctrl-bcm63xx.h" 20 21 #define BCM6362_BANK_GPIOS 32 22 #define BCM6362_NUM_GPIOS 48 23 #define BCM6362_NUM_LEDS 24 24 25 #define BCM6362_LED_REG 0x10 26 #define BCM6362_MODE_REG 0x18 27 #define BCM6362_CTRL_REG 0x1c 28 #define BCM6362_BASEMODE_REG 0x38 29 #define BASEMODE_NAND BIT(2) 30 31 enum bcm6362_pinctrl_reg { 32 BCM6362_LEDCTRL, 33 BCM6362_MODE, 34 BCM6362_CTRL, 35 BCM6362_BASEMODE, 36 }; 37 38 struct bcm6362_pingroup { 39 const char *name; 40 const unsigned * const pins; 41 const unsigned num_pins; 42 }; 43 44 struct bcm6362_function { 45 const char *name; 46 const char * const *groups; 47 const unsigned num_groups; 48 49 enum bcm6362_pinctrl_reg reg; 50 uint32_t basemode_mask; 51 }; 52 53 #define BCM6362_PIN(a, b, mask) \ 54 { \ 55 .number = a, \ 56 .name = b, \ 57 .drv_data = (void *)(mask), \ 58 } 59 60 static const struct pinctrl_pin_desc bcm6362_pins[] = { 61 PINCTRL_PIN(0, "gpio0"), 62 PINCTRL_PIN(1, "gpio1"), 63 PINCTRL_PIN(2, "gpio2"), 64 PINCTRL_PIN(3, "gpio3"), 65 PINCTRL_PIN(4, "gpio4"), 66 PINCTRL_PIN(5, "gpio5"), 67 PINCTRL_PIN(6, "gpio6"), 68 PINCTRL_PIN(7, "gpio7"), 69 BCM6362_PIN(8, "gpio8", BASEMODE_NAND), 70 PINCTRL_PIN(9, "gpio9"), 71 PINCTRL_PIN(10, "gpio10"), 72 PINCTRL_PIN(11, "gpio11"), 73 BCM6362_PIN(12, "gpio12", BASEMODE_NAND), 74 BCM6362_PIN(13, "gpio13", BASEMODE_NAND), 75 BCM6362_PIN(14, "gpio14", BASEMODE_NAND), 76 BCM6362_PIN(15, "gpio15", BASEMODE_NAND), 77 BCM6362_PIN(16, "gpio16", BASEMODE_NAND), 78 BCM6362_PIN(17, "gpio17", BASEMODE_NAND), 79 BCM6362_PIN(18, "gpio18", BASEMODE_NAND), 80 BCM6362_PIN(19, "gpio19", BASEMODE_NAND), 81 BCM6362_PIN(20, "gpio20", BASEMODE_NAND), 82 BCM6362_PIN(21, "gpio21", BASEMODE_NAND), 83 BCM6362_PIN(22, "gpio22", BASEMODE_NAND), 84 BCM6362_PIN(23, "gpio23", BASEMODE_NAND), 85 PINCTRL_PIN(24, "gpio24"), 86 PINCTRL_PIN(25, "gpio25"), 87 PINCTRL_PIN(26, "gpio26"), 88 BCM6362_PIN(27, "gpio27", BASEMODE_NAND), 89 PINCTRL_PIN(28, "gpio28"), 90 PINCTRL_PIN(29, "gpio29"), 91 PINCTRL_PIN(30, "gpio30"), 92 PINCTRL_PIN(31, "gpio31"), 93 PINCTRL_PIN(32, "gpio32"), 94 PINCTRL_PIN(33, "gpio33"), 95 PINCTRL_PIN(34, "gpio34"), 96 PINCTRL_PIN(35, "gpio35"), 97 PINCTRL_PIN(36, "gpio36"), 98 PINCTRL_PIN(37, "gpio37"), 99 PINCTRL_PIN(38, "gpio38"), 100 PINCTRL_PIN(39, "gpio39"), 101 PINCTRL_PIN(40, "gpio40"), 102 PINCTRL_PIN(41, "gpio41"), 103 PINCTRL_PIN(42, "gpio42"), 104 PINCTRL_PIN(43, "gpio43"), 105 PINCTRL_PIN(44, "gpio44"), 106 PINCTRL_PIN(45, "gpio45"), 107 PINCTRL_PIN(46, "gpio46"), 108 PINCTRL_PIN(47, "gpio47"), 109 }; 110 111 static unsigned gpio0_pins[] = { 0 }; 112 static unsigned gpio1_pins[] = { 1 }; 113 static unsigned gpio2_pins[] = { 2 }; 114 static unsigned gpio3_pins[] = { 3 }; 115 static unsigned gpio4_pins[] = { 4 }; 116 static unsigned gpio5_pins[] = { 5 }; 117 static unsigned gpio6_pins[] = { 6 }; 118 static unsigned gpio7_pins[] = { 7 }; 119 static unsigned gpio8_pins[] = { 8 }; 120 static unsigned gpio9_pins[] = { 9 }; 121 static unsigned gpio10_pins[] = { 10 }; 122 static unsigned gpio11_pins[] = { 11 }; 123 static unsigned gpio12_pins[] = { 12 }; 124 static unsigned gpio13_pins[] = { 13 }; 125 static unsigned gpio14_pins[] = { 14 }; 126 static unsigned gpio15_pins[] = { 15 }; 127 static unsigned gpio16_pins[] = { 16 }; 128 static unsigned gpio17_pins[] = { 17 }; 129 static unsigned gpio18_pins[] = { 18 }; 130 static unsigned gpio19_pins[] = { 19 }; 131 static unsigned gpio20_pins[] = { 20 }; 132 static unsigned gpio21_pins[] = { 21 }; 133 static unsigned gpio22_pins[] = { 22 }; 134 static unsigned gpio23_pins[] = { 23 }; 135 static unsigned gpio24_pins[] = { 24 }; 136 static unsigned gpio25_pins[] = { 25 }; 137 static unsigned gpio26_pins[] = { 26 }; 138 static unsigned gpio27_pins[] = { 27 }; 139 static unsigned gpio28_pins[] = { 28 }; 140 static unsigned gpio29_pins[] = { 29 }; 141 static unsigned gpio30_pins[] = { 30 }; 142 static unsigned gpio31_pins[] = { 31 }; 143 static unsigned gpio32_pins[] = { 32 }; 144 static unsigned gpio33_pins[] = { 33 }; 145 static unsigned gpio34_pins[] = { 34 }; 146 static unsigned gpio35_pins[] = { 35 }; 147 static unsigned gpio36_pins[] = { 36 }; 148 static unsigned gpio37_pins[] = { 37 }; 149 static unsigned gpio38_pins[] = { 38 }; 150 static unsigned gpio39_pins[] = { 39 }; 151 static unsigned gpio40_pins[] = { 40 }; 152 static unsigned gpio41_pins[] = { 41 }; 153 static unsigned gpio42_pins[] = { 42 }; 154 static unsigned gpio43_pins[] = { 43 }; 155 static unsigned gpio44_pins[] = { 44 }; 156 static unsigned gpio45_pins[] = { 45 }; 157 static unsigned gpio46_pins[] = { 46 }; 158 static unsigned gpio47_pins[] = { 47 }; 159 160 static unsigned nand_grp_pins[] = { 161 8, 12, 13, 14, 15, 16, 17, 162 18, 19, 20, 21, 22, 23, 27, 163 }; 164 165 #define BCM6362_GROUP(n) \ 166 { \ 167 .name = #n, \ 168 .pins = n##_pins, \ 169 .num_pins = ARRAY_SIZE(n##_pins), \ 170 } 171 172 static struct bcm6362_pingroup bcm6362_groups[] = { 173 BCM6362_GROUP(gpio0), 174 BCM6362_GROUP(gpio1), 175 BCM6362_GROUP(gpio2), 176 BCM6362_GROUP(gpio3), 177 BCM6362_GROUP(gpio4), 178 BCM6362_GROUP(gpio5), 179 BCM6362_GROUP(gpio6), 180 BCM6362_GROUP(gpio7), 181 BCM6362_GROUP(gpio8), 182 BCM6362_GROUP(gpio9), 183 BCM6362_GROUP(gpio10), 184 BCM6362_GROUP(gpio11), 185 BCM6362_GROUP(gpio12), 186 BCM6362_GROUP(gpio13), 187 BCM6362_GROUP(gpio14), 188 BCM6362_GROUP(gpio15), 189 BCM6362_GROUP(gpio16), 190 BCM6362_GROUP(gpio17), 191 BCM6362_GROUP(gpio18), 192 BCM6362_GROUP(gpio19), 193 BCM6362_GROUP(gpio20), 194 BCM6362_GROUP(gpio21), 195 BCM6362_GROUP(gpio22), 196 BCM6362_GROUP(gpio23), 197 BCM6362_GROUP(gpio24), 198 BCM6362_GROUP(gpio25), 199 BCM6362_GROUP(gpio26), 200 BCM6362_GROUP(gpio27), 201 BCM6362_GROUP(gpio28), 202 BCM6362_GROUP(gpio29), 203 BCM6362_GROUP(gpio30), 204 BCM6362_GROUP(gpio31), 205 BCM6362_GROUP(gpio32), 206 BCM6362_GROUP(gpio33), 207 BCM6362_GROUP(gpio34), 208 BCM6362_GROUP(gpio35), 209 BCM6362_GROUP(gpio36), 210 BCM6362_GROUP(gpio37), 211 BCM6362_GROUP(gpio38), 212 BCM6362_GROUP(gpio39), 213 BCM6362_GROUP(gpio40), 214 BCM6362_GROUP(gpio41), 215 BCM6362_GROUP(gpio42), 216 BCM6362_GROUP(gpio43), 217 BCM6362_GROUP(gpio44), 218 BCM6362_GROUP(gpio45), 219 BCM6362_GROUP(gpio46), 220 BCM6362_GROUP(gpio47), 221 BCM6362_GROUP(nand_grp), 222 }; 223 224 static const char * const led_groups[] = { 225 "gpio0", 226 "gpio1", 227 "gpio2", 228 "gpio3", 229 "gpio4", 230 "gpio5", 231 "gpio6", 232 "gpio7", 233 "gpio8", 234 "gpio9", 235 "gpio10", 236 "gpio11", 237 "gpio12", 238 "gpio13", 239 "gpio14", 240 "gpio15", 241 "gpio16", 242 "gpio17", 243 "gpio18", 244 "gpio19", 245 "gpio20", 246 "gpio21", 247 "gpio22", 248 "gpio23", 249 }; 250 251 static const char * const usb_device_led_groups[] = { 252 "gpio0", 253 }; 254 255 static const char * const sys_irq_groups[] = { 256 "gpio1", 257 }; 258 259 static const char * const serial_led_clk_groups[] = { 260 "gpio2", 261 }; 262 263 static const char * const serial_led_data_groups[] = { 264 "gpio3", 265 }; 266 267 static const char * const robosw_led_data_groups[] = { 268 "gpio4", 269 }; 270 271 static const char * const robosw_led_clk_groups[] = { 272 "gpio5", 273 }; 274 275 static const char * const robosw_led0_groups[] = { 276 "gpio6", 277 }; 278 279 static const char * const robosw_led1_groups[] = { 280 "gpio7", 281 }; 282 283 static const char * const inet_led_groups[] = { 284 "gpio8", 285 }; 286 287 static const char * const spi_cs2_groups[] = { 288 "gpio9", 289 }; 290 291 static const char * const spi_cs3_groups[] = { 292 "gpio10", 293 }; 294 295 static const char * const ntr_pulse_groups[] = { 296 "gpio11", 297 }; 298 299 static const char * const uart1_scts_groups[] = { 300 "gpio12", 301 }; 302 303 static const char * const uart1_srts_groups[] = { 304 "gpio13", 305 }; 306 307 static const char * const uart1_sdin_groups[] = { 308 "gpio14", 309 }; 310 311 static const char * const uart1_sdout_groups[] = { 312 "gpio15", 313 }; 314 315 static const char * const adsl_spi_miso_groups[] = { 316 "gpio16", 317 }; 318 319 static const char * const adsl_spi_mosi_groups[] = { 320 "gpio17", 321 }; 322 323 static const char * const adsl_spi_clk_groups[] = { 324 "gpio18", 325 }; 326 327 static const char * const adsl_spi_cs_groups[] = { 328 "gpio19", 329 }; 330 331 static const char * const ephy0_led_groups[] = { 332 "gpio20", 333 }; 334 335 static const char * const ephy1_led_groups[] = { 336 "gpio21", 337 }; 338 339 static const char * const ephy2_led_groups[] = { 340 "gpio22", 341 }; 342 343 static const char * const ephy3_led_groups[] = { 344 "gpio23", 345 }; 346 347 static const char * const ext_irq0_groups[] = { 348 "gpio24", 349 }; 350 351 static const char * const ext_irq1_groups[] = { 352 "gpio25", 353 }; 354 355 static const char * const ext_irq2_groups[] = { 356 "gpio26", 357 }; 358 359 static const char * const ext_irq3_groups[] = { 360 "gpio27", 361 }; 362 363 static const char * const wifi_groups[] = { 364 "gpio32", 365 "gpio33", 366 "gpio34", 367 "gpio35", 368 "gpio36", 369 "gpio37", 370 "gpio38", 371 "gpio39", 372 "gpio40", 373 "gpio41", 374 "gpio42", 375 "gpio43", 376 "gpio44", 377 "gpio45", 378 "gpio46", 379 "gpio47", 380 }; 381 382 static const char * const nand_groups[] = { 383 "nand_grp", 384 }; 385 386 #define BCM6362_LED_FUN(n) \ 387 { \ 388 .name = #n, \ 389 .groups = n##_groups, \ 390 .num_groups = ARRAY_SIZE(n##_groups), \ 391 .reg = BCM6362_LEDCTRL, \ 392 } 393 394 #define BCM6362_MODE_FUN(n) \ 395 { \ 396 .name = #n, \ 397 .groups = n##_groups, \ 398 .num_groups = ARRAY_SIZE(n##_groups), \ 399 .reg = BCM6362_MODE, \ 400 } 401 402 #define BCM6362_CTRL_FUN(n) \ 403 { \ 404 .name = #n, \ 405 .groups = n##_groups, \ 406 .num_groups = ARRAY_SIZE(n##_groups), \ 407 .reg = BCM6362_CTRL, \ 408 } 409 410 #define BCM6362_BASEMODE_FUN(n, mask) \ 411 { \ 412 .name = #n, \ 413 .groups = n##_groups, \ 414 .num_groups = ARRAY_SIZE(n##_groups), \ 415 .reg = BCM6362_BASEMODE, \ 416 .basemode_mask = (mask), \ 417 } 418 419 static const struct bcm6362_function bcm6362_funcs[] = { 420 BCM6362_LED_FUN(led), 421 BCM6362_MODE_FUN(usb_device_led), 422 BCM6362_MODE_FUN(sys_irq), 423 BCM6362_MODE_FUN(serial_led_clk), 424 BCM6362_MODE_FUN(serial_led_data), 425 BCM6362_MODE_FUN(robosw_led_data), 426 BCM6362_MODE_FUN(robosw_led_clk), 427 BCM6362_MODE_FUN(robosw_led0), 428 BCM6362_MODE_FUN(robosw_led1), 429 BCM6362_MODE_FUN(inet_led), 430 BCM6362_MODE_FUN(spi_cs2), 431 BCM6362_MODE_FUN(spi_cs3), 432 BCM6362_MODE_FUN(ntr_pulse), 433 BCM6362_MODE_FUN(uart1_scts), 434 BCM6362_MODE_FUN(uart1_srts), 435 BCM6362_MODE_FUN(uart1_sdin), 436 BCM6362_MODE_FUN(uart1_sdout), 437 BCM6362_MODE_FUN(adsl_spi_miso), 438 BCM6362_MODE_FUN(adsl_spi_mosi), 439 BCM6362_MODE_FUN(adsl_spi_clk), 440 BCM6362_MODE_FUN(adsl_spi_cs), 441 BCM6362_MODE_FUN(ephy0_led), 442 BCM6362_MODE_FUN(ephy1_led), 443 BCM6362_MODE_FUN(ephy2_led), 444 BCM6362_MODE_FUN(ephy3_led), 445 BCM6362_MODE_FUN(ext_irq0), 446 BCM6362_MODE_FUN(ext_irq1), 447 BCM6362_MODE_FUN(ext_irq2), 448 BCM6362_MODE_FUN(ext_irq3), 449 BCM6362_CTRL_FUN(wifi), 450 BCM6362_BASEMODE_FUN(nand, BASEMODE_NAND), 451 }; 452 453 static int bcm6362_pinctrl_get_group_count(struct pinctrl_dev *pctldev) 454 { 455 return ARRAY_SIZE(bcm6362_groups); 456 } 457 458 static const char *bcm6362_pinctrl_get_group_name(struct pinctrl_dev *pctldev, 459 unsigned group) 460 { 461 return bcm6362_groups[group].name; 462 } 463 464 static int bcm6362_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, 465 unsigned group, const unsigned **pins, 466 unsigned *num_pins) 467 { 468 *pins = bcm6362_groups[group].pins; 469 *num_pins = bcm6362_groups[group].num_pins; 470 471 return 0; 472 } 473 474 static int bcm6362_pinctrl_get_func_count(struct pinctrl_dev *pctldev) 475 { 476 return ARRAY_SIZE(bcm6362_funcs); 477 } 478 479 static const char *bcm6362_pinctrl_get_func_name(struct pinctrl_dev *pctldev, 480 unsigned selector) 481 { 482 return bcm6362_funcs[selector].name; 483 } 484 485 static int bcm6362_pinctrl_get_groups(struct pinctrl_dev *pctldev, 486 unsigned selector, 487 const char * const **groups, 488 unsigned * const num_groups) 489 { 490 *groups = bcm6362_funcs[selector].groups; 491 *num_groups = bcm6362_funcs[selector].num_groups; 492 493 return 0; 494 } 495 496 static void bcm6362_set_gpio(struct bcm63xx_pinctrl *pc, unsigned pin) 497 { 498 const struct pinctrl_pin_desc *desc = &bcm6362_pins[pin]; 499 unsigned int basemode = (uintptr_t)desc->drv_data; 500 unsigned int mask = bcm63xx_bank_pin(pin); 501 502 if (basemode) 503 regmap_update_bits(pc->regs, BCM6362_BASEMODE_REG, basemode, 0); 504 505 if (pin < BCM63XX_BANK_GPIOS) { 506 /* base mode 0 => gpio 1 => mux function */ 507 regmap_update_bits(pc->regs, BCM6362_MODE_REG, mask, 0); 508 509 /* pins 0-23 might be muxed to led */ 510 if (pin < BCM6362_NUM_LEDS) 511 regmap_update_bits(pc->regs, BCM6362_LED_REG, mask, 0); 512 } else { 513 /* ctrl reg 0 => wifi function 1 => gpio */ 514 regmap_update_bits(pc->regs, BCM6362_CTRL_REG, mask, mask); 515 } 516 } 517 518 static int bcm6362_pinctrl_set_mux(struct pinctrl_dev *pctldev, 519 unsigned selector, unsigned group) 520 { 521 struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 522 const struct bcm6362_pingroup *pg = &bcm6362_groups[group]; 523 const struct bcm6362_function *f = &bcm6362_funcs[selector]; 524 unsigned i; 525 unsigned int reg; 526 unsigned int val, mask; 527 528 for (i = 0; i < pg->num_pins; i++) 529 bcm6362_set_gpio(pc, pg->pins[i]); 530 531 switch (f->reg) { 532 case BCM6362_LEDCTRL: 533 reg = BCM6362_LED_REG; 534 mask = BIT(pg->pins[0]); 535 val = BIT(pg->pins[0]); 536 break; 537 case BCM6362_MODE: 538 reg = BCM6362_MODE_REG; 539 mask = BIT(pg->pins[0]); 540 val = BIT(pg->pins[0]); 541 break; 542 case BCM6362_CTRL: 543 reg = BCM6362_CTRL_REG; 544 mask = BIT(pg->pins[0]); 545 val = 0; 546 break; 547 case BCM6362_BASEMODE: 548 reg = BCM6362_BASEMODE_REG; 549 mask = f->basemode_mask; 550 val = f->basemode_mask; 551 break; 552 default: 553 WARN_ON(1); 554 return -EINVAL; 555 } 556 557 regmap_update_bits(pc->regs, reg, mask, val); 558 559 return 0; 560 } 561 562 static int bcm6362_gpio_request_enable(struct pinctrl_dev *pctldev, 563 struct pinctrl_gpio_range *range, 564 unsigned offset) 565 { 566 struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 567 568 /* disable all functions using this pin */ 569 bcm6362_set_gpio(pc, offset); 570 571 return 0; 572 } 573 574 static const struct pinctrl_ops bcm6362_pctl_ops = { 575 .dt_free_map = pinctrl_utils_free_map, 576 .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, 577 .get_group_name = bcm6362_pinctrl_get_group_name, 578 .get_group_pins = bcm6362_pinctrl_get_group_pins, 579 .get_groups_count = bcm6362_pinctrl_get_group_count, 580 }; 581 582 static const struct pinmux_ops bcm6362_pmx_ops = { 583 .get_function_groups = bcm6362_pinctrl_get_groups, 584 .get_function_name = bcm6362_pinctrl_get_func_name, 585 .get_functions_count = bcm6362_pinctrl_get_func_count, 586 .gpio_request_enable = bcm6362_gpio_request_enable, 587 .set_mux = bcm6362_pinctrl_set_mux, 588 .strict = true, 589 }; 590 591 static const struct bcm63xx_pinctrl_soc bcm6362_soc = { 592 .ngpios = BCM6362_NUM_GPIOS, 593 .npins = ARRAY_SIZE(bcm6362_pins), 594 .pctl_ops = &bcm6362_pctl_ops, 595 .pins = bcm6362_pins, 596 .pmx_ops = &bcm6362_pmx_ops, 597 }; 598 599 static int bcm6362_pinctrl_probe(struct platform_device *pdev) 600 { 601 return bcm63xx_pinctrl_probe(pdev, &bcm6362_soc, NULL); 602 } 603 604 static const struct of_device_id bcm6362_pinctrl_match[] = { 605 { .compatible = "brcm,bcm6362-pinctrl", }, 606 { /* sentinel */ } 607 }; 608 609 static struct platform_driver bcm6362_pinctrl_driver = { 610 .probe = bcm6362_pinctrl_probe, 611 .driver = { 612 .name = "bcm6362-pinctrl", 613 .of_match_table = bcm6362_pinctrl_match, 614 }, 615 }; 616 617 builtin_platform_driver(bcm6362_pinctrl_driver); 618