1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Pinctrl for Cirrus Logic Madera codecs 4 * 5 * Copyright (C) 2016-2018 Cirrus Logic 6 */ 7 8 #include <linux/err.h> 9 #include <linux/module.h> 10 #include <linux/platform_device.h> 11 #include <linux/property.h> 12 #include <linux/regmap.h> 13 #include <linux/slab.h> 14 15 #include <linux/pinctrl/machine.h> 16 #include <linux/pinctrl/pinctrl.h> 17 #include <linux/pinctrl/pinmux.h> 18 #include <linux/pinctrl/pinconf.h> 19 #include <linux/pinctrl/pinconf-generic.h> 20 21 #include <linux/mfd/madera/core.h> 22 #include <linux/mfd/madera/registers.h> 23 24 #include "../pinctrl-utils.h" 25 26 #include "pinctrl-madera.h" 27 28 /* 29 * Use pin GPIO names for consistency 30 * NOTE: IDs are zero-indexed for coding convenience 31 */ 32 static const struct pinctrl_pin_desc madera_pins[] = { 33 PINCTRL_PIN(0, "gpio1"), 34 PINCTRL_PIN(1, "gpio2"), 35 PINCTRL_PIN(2, "gpio3"), 36 PINCTRL_PIN(3, "gpio4"), 37 PINCTRL_PIN(4, "gpio5"), 38 PINCTRL_PIN(5, "gpio6"), 39 PINCTRL_PIN(6, "gpio7"), 40 PINCTRL_PIN(7, "gpio8"), 41 PINCTRL_PIN(8, "gpio9"), 42 PINCTRL_PIN(9, "gpio10"), 43 PINCTRL_PIN(10, "gpio11"), 44 PINCTRL_PIN(11, "gpio12"), 45 PINCTRL_PIN(12, "gpio13"), 46 PINCTRL_PIN(13, "gpio14"), 47 PINCTRL_PIN(14, "gpio15"), 48 PINCTRL_PIN(15, "gpio16"), 49 PINCTRL_PIN(16, "gpio17"), 50 PINCTRL_PIN(17, "gpio18"), 51 PINCTRL_PIN(18, "gpio19"), 52 PINCTRL_PIN(19, "gpio20"), 53 PINCTRL_PIN(20, "gpio21"), 54 PINCTRL_PIN(21, "gpio22"), 55 PINCTRL_PIN(22, "gpio23"), 56 PINCTRL_PIN(23, "gpio24"), 57 PINCTRL_PIN(24, "gpio25"), 58 PINCTRL_PIN(25, "gpio26"), 59 PINCTRL_PIN(26, "gpio27"), 60 PINCTRL_PIN(27, "gpio28"), 61 PINCTRL_PIN(28, "gpio29"), 62 PINCTRL_PIN(29, "gpio30"), 63 PINCTRL_PIN(30, "gpio31"), 64 PINCTRL_PIN(31, "gpio32"), 65 PINCTRL_PIN(32, "gpio33"), 66 PINCTRL_PIN(33, "gpio34"), 67 PINCTRL_PIN(34, "gpio35"), 68 PINCTRL_PIN(35, "gpio36"), 69 PINCTRL_PIN(36, "gpio37"), 70 PINCTRL_PIN(37, "gpio38"), 71 PINCTRL_PIN(38, "gpio39"), 72 PINCTRL_PIN(39, "gpio40"), 73 }; 74 75 /* 76 * All single-pin functions can be mapped to any GPIO, however pinmux applies 77 * functions to pin groups and only those groups declared as supporting that 78 * function. To make this work we must put each pin in its own dummy group so 79 * that the functions can be described as applying to all pins. 80 * Since these do not correspond to anything in the actual hardware - they are 81 * merely an adaptation to pinctrl's view of the world - we use the same name 82 * as the pin to avoid confusion when comparing with datasheet instructions 83 */ 84 static const char * const madera_pin_single_group_names[] = { 85 "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7", 86 "gpio8", "gpio9", "gpio10", "gpio11", "gpio12", "gpio13", "gpio14", 87 "gpio15", "gpio16", "gpio17", "gpio18", "gpio19", "gpio20", "gpio21", 88 "gpio22", "gpio23", "gpio24", "gpio25", "gpio26", "gpio27", "gpio28", 89 "gpio29", "gpio30", "gpio31", "gpio32", "gpio33", "gpio34", "gpio35", 90 "gpio36", "gpio37", "gpio38", "gpio39", "gpio40", 91 }; 92 93 /* set of pin numbers for single-pin groups, zero-indexed */ 94 static const unsigned int madera_pin_single_group_pins[] = { 95 0, 1, 2, 3, 4, 5, 6, 96 7, 8, 9, 10, 11, 12, 13, 97 14, 15, 16, 17, 18, 19, 20, 98 21, 22, 23, 24, 25, 26, 27, 99 28, 29, 30, 31, 32, 33, 34, 100 35, 36, 37, 38, 39, 101 }; 102 103 static const char * const madera_aif1_group_names[] = { "aif1" }; 104 static const char * const madera_aif2_group_names[] = { "aif2" }; 105 static const char * const madera_aif3_group_names[] = { "aif3" }; 106 static const char * const madera_aif4_group_names[] = { "aif4" }; 107 static const char * const madera_mif1_group_names[] = { "mif1" }; 108 static const char * const madera_mif2_group_names[] = { "mif2" }; 109 static const char * const madera_mif3_group_names[] = { "mif3" }; 110 static const char * const madera_dmic3_group_names[] = { "dmic3" }; 111 static const char * const madera_dmic4_group_names[] = { "dmic4" }; 112 static const char * const madera_dmic5_group_names[] = { "dmic5" }; 113 static const char * const madera_dmic6_group_names[] = { "dmic6" }; 114 static const char * const madera_spk1_group_names[] = { "pdmspk1" }; 115 static const char * const madera_spk2_group_names[] = { "pdmspk2" }; 116 117 /* 118 * alt-functions always apply to a single pin group, other functions always 119 * apply to all pins 120 */ 121 static const struct { 122 const char *name; 123 const char * const *group_names; 124 u32 func; 125 } madera_mux_funcs[] = { 126 { 127 .name = "aif1", 128 .group_names = madera_aif1_group_names, 129 .func = 0x000 130 }, 131 { 132 .name = "aif2", 133 .group_names = madera_aif2_group_names, 134 .func = 0x000 135 }, 136 { 137 .name = "aif3", 138 .group_names = madera_aif3_group_names, 139 .func = 0x000 140 }, 141 { 142 .name = "aif4", 143 .group_names = madera_aif4_group_names, 144 .func = 0x000 145 }, 146 { 147 .name = "mif1", 148 .group_names = madera_mif1_group_names, 149 .func = 0x000 150 }, 151 { 152 .name = "mif2", 153 .group_names = madera_mif2_group_names, 154 .func = 0x000 155 }, 156 { 157 .name = "mif3", 158 .group_names = madera_mif3_group_names, 159 .func = 0x000 160 }, 161 { 162 .name = "dmic3", 163 .group_names = madera_dmic3_group_names, 164 .func = 0x000 165 }, 166 { 167 .name = "dmic4", 168 .group_names = madera_dmic4_group_names, 169 .func = 0x000 170 }, 171 { 172 .name = "dmic5", 173 .group_names = madera_dmic5_group_names, 174 .func = 0x000 175 }, 176 { 177 .name = "dmic6", 178 .group_names = madera_dmic6_group_names, 179 .func = 0x000 180 }, 181 { 182 .name = "pdmspk1", 183 .group_names = madera_spk1_group_names, 184 .func = 0x000 185 }, 186 { 187 .name = "pdmspk2", 188 .group_names = madera_spk2_group_names, 189 .func = 0x000 190 }, 191 { 192 .name = "io", 193 .group_names = madera_pin_single_group_names, 194 .func = 0x001 195 }, 196 { 197 .name = "dsp-gpio", 198 .group_names = madera_pin_single_group_names, 199 .func = 0x002 200 }, 201 { 202 .name = "irq1", 203 .group_names = madera_pin_single_group_names, 204 .func = 0x003 205 }, 206 { 207 .name = "irq2", 208 .group_names = madera_pin_single_group_names, 209 .func = 0x004 210 }, 211 { 212 .name = "fll1-clk", 213 .group_names = madera_pin_single_group_names, 214 .func = 0x010 215 }, 216 { 217 .name = "fll2-clk", 218 .group_names = madera_pin_single_group_names, 219 .func = 0x011 220 }, 221 { 222 .name = "fll3-clk", 223 .group_names = madera_pin_single_group_names, 224 .func = 0x012 225 }, 226 { 227 .name = "fllao-clk", 228 .group_names = madera_pin_single_group_names, 229 .func = 0x013 230 }, 231 { 232 .name = "fll1-lock", 233 .group_names = madera_pin_single_group_names, 234 .func = 0x018 235 }, 236 { 237 .name = "fll2-lock", 238 .group_names = madera_pin_single_group_names, 239 .func = 0x019 240 }, 241 { 242 .name = "fll3-lock", 243 .group_names = madera_pin_single_group_names, 244 .func = 0x01a 245 }, 246 { 247 .name = "fllao-lock", 248 .group_names = madera_pin_single_group_names, 249 .func = 0x01b 250 }, 251 { 252 .name = "opclk", 253 .group_names = madera_pin_single_group_names, 254 .func = 0x040 255 }, 256 { 257 .name = "opclk-async", 258 .group_names = madera_pin_single_group_names, 259 .func = 0x041 260 }, 261 { 262 .name = "pwm1", 263 .group_names = madera_pin_single_group_names, 264 .func = 0x048 265 }, 266 { 267 .name = "pwm2", 268 .group_names = madera_pin_single_group_names, 269 .func = 0x049 270 }, 271 { 272 .name = "spdif", 273 .group_names = madera_pin_single_group_names, 274 .func = 0x04c 275 }, 276 { 277 .name = "asrc1-in1-lock", 278 .group_names = madera_pin_single_group_names, 279 .func = 0x088 280 }, 281 { 282 .name = "asrc1-in2-lock", 283 .group_names = madera_pin_single_group_names, 284 .func = 0x089 285 }, 286 { 287 .name = "asrc2-in1-lock", 288 .group_names = madera_pin_single_group_names, 289 .func = 0x08a 290 }, 291 { 292 .name = "asrc2-in2-lock", 293 .group_names = madera_pin_single_group_names, 294 .func = 0x08b 295 }, 296 { 297 .name = "spkl-short-circuit", 298 .group_names = madera_pin_single_group_names, 299 .func = 0x0b6 300 }, 301 { 302 .name = "spkr-short-circuit", 303 .group_names = madera_pin_single_group_names, 304 .func = 0x0b7 305 }, 306 { 307 .name = "spk-shutdown", 308 .group_names = madera_pin_single_group_names, 309 .func = 0x0e0 310 }, 311 { 312 .name = "spk-overheat-shutdown", 313 .group_names = madera_pin_single_group_names, 314 .func = 0x0e1 315 }, 316 { 317 .name = "spk-overheat-warn", 318 .group_names = madera_pin_single_group_names, 319 .func = 0x0e2 320 }, 321 { 322 .name = "timer1-sts", 323 .group_names = madera_pin_single_group_names, 324 .func = 0x140 325 }, 326 { 327 .name = "timer2-sts", 328 .group_names = madera_pin_single_group_names, 329 .func = 0x141 330 }, 331 { 332 .name = "timer3-sts", 333 .group_names = madera_pin_single_group_names, 334 .func = 0x142 335 }, 336 { 337 .name = "timer4-sts", 338 .group_names = madera_pin_single_group_names, 339 .func = 0x143 340 }, 341 { 342 .name = "timer5-sts", 343 .group_names = madera_pin_single_group_names, 344 .func = 0x144 345 }, 346 { 347 .name = "timer6-sts", 348 .group_names = madera_pin_single_group_names, 349 .func = 0x145 350 }, 351 { 352 .name = "timer7-sts", 353 .group_names = madera_pin_single_group_names, 354 .func = 0x146 355 }, 356 { 357 .name = "timer8-sts", 358 .group_names = madera_pin_single_group_names, 359 .func = 0x147 360 }, 361 { 362 .name = "log1-fifo-ne", 363 .group_names = madera_pin_single_group_names, 364 .func = 0x150 365 }, 366 { 367 .name = "log2-fifo-ne", 368 .group_names = madera_pin_single_group_names, 369 .func = 0x151 370 }, 371 { 372 .name = "log3-fifo-ne", 373 .group_names = madera_pin_single_group_names, 374 .func = 0x152 375 }, 376 { 377 .name = "log4-fifo-ne", 378 .group_names = madera_pin_single_group_names, 379 .func = 0x153 380 }, 381 { 382 .name = "log5-fifo-ne", 383 .group_names = madera_pin_single_group_names, 384 .func = 0x154 385 }, 386 { 387 .name = "log6-fifo-ne", 388 .group_names = madera_pin_single_group_names, 389 .func = 0x155 390 }, 391 { 392 .name = "log7-fifo-ne", 393 .group_names = madera_pin_single_group_names, 394 .func = 0x156 395 }, 396 { 397 .name = "log8-fifo-ne", 398 .group_names = madera_pin_single_group_names, 399 .func = 0x157 400 }, 401 { 402 .name = "aux-pdm-clk", 403 .group_names = madera_pin_single_group_names, 404 .func = 0x280 405 }, 406 { 407 .name = "aux-pdm-dat", 408 .group_names = madera_pin_single_group_names, 409 .func = 0x281 410 }, 411 }; 412 413 static u16 madera_pin_make_drv_str(struct madera_pin_private *priv, 414 unsigned int milliamps) 415 { 416 switch (milliamps) { 417 case 4: 418 return 0; 419 case 8: 420 return 2 << MADERA_GP1_DRV_STR_SHIFT; 421 default: 422 break; 423 } 424 425 dev_warn(priv->dev, "%u mA not a valid drive strength", milliamps); 426 427 return 0; 428 } 429 430 static unsigned int madera_pin_unmake_drv_str(struct madera_pin_private *priv, 431 u16 regval) 432 { 433 regval = (regval & MADERA_GP1_DRV_STR_MASK) >> MADERA_GP1_DRV_STR_SHIFT; 434 435 switch (regval) { 436 case 0: 437 return 4; 438 case 2: 439 return 8; 440 default: 441 return 0; 442 } 443 } 444 445 static int madera_get_groups_count(struct pinctrl_dev *pctldev) 446 { 447 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 448 449 /* Number of alt function groups plus number of single-pin groups */ 450 return priv->chip->n_pin_groups + priv->chip->n_pins; 451 } 452 453 static const char *madera_get_group_name(struct pinctrl_dev *pctldev, 454 unsigned int selector) 455 { 456 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 457 458 if (selector < priv->chip->n_pin_groups) 459 return priv->chip->pin_groups[selector].name; 460 461 selector -= priv->chip->n_pin_groups; 462 return madera_pin_single_group_names[selector]; 463 } 464 465 static int madera_get_group_pins(struct pinctrl_dev *pctldev, 466 unsigned int selector, 467 const unsigned int **pins, 468 unsigned int *num_pins) 469 { 470 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 471 472 if (selector < priv->chip->n_pin_groups) { 473 *pins = priv->chip->pin_groups[selector].pins; 474 *num_pins = priv->chip->pin_groups[selector].n_pins; 475 } else { 476 /* return the dummy group for a single pin */ 477 selector -= priv->chip->n_pin_groups; 478 *pins = &madera_pin_single_group_pins[selector]; 479 *num_pins = 1; 480 } 481 return 0; 482 } 483 484 static void madera_pin_dbg_show_fn(struct madera_pin_private *priv, 485 struct seq_file *s, 486 unsigned int pin, unsigned int fn) 487 { 488 const struct madera_pin_chip *chip = priv->chip; 489 int i, g_pin; 490 491 if (fn != 0) { 492 for (i = 0; i < ARRAY_SIZE(madera_mux_funcs); ++i) { 493 if (madera_mux_funcs[i].func == fn) { 494 seq_printf(s, " FN=%s", 495 madera_mux_funcs[i].name); 496 return; 497 } 498 } 499 return; /* ignore unknown function values */ 500 } 501 502 /* alt function */ 503 for (i = 0; i < chip->n_pin_groups; ++i) { 504 for (g_pin = 0; g_pin < chip->pin_groups[i].n_pins; ++g_pin) { 505 if (chip->pin_groups[i].pins[g_pin] == pin) { 506 seq_printf(s, " FN=%s", 507 chip->pin_groups[i].name); 508 return; 509 } 510 } 511 } 512 } 513 514 static void __maybe_unused madera_pin_dbg_show(struct pinctrl_dev *pctldev, 515 struct seq_file *s, 516 unsigned int pin) 517 { 518 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 519 unsigned int conf[2]; 520 unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * pin); 521 unsigned int fn; 522 int ret; 523 524 ret = regmap_read(priv->madera->regmap, reg, &conf[0]); 525 if (ret) 526 return; 527 528 ret = regmap_read(priv->madera->regmap, reg + 1, &conf[1]); 529 if (ret) 530 return; 531 532 seq_printf(s, "%04x:%04x", conf[0], conf[1]); 533 534 fn = (conf[0] & MADERA_GP1_FN_MASK) >> MADERA_GP1_FN_SHIFT; 535 madera_pin_dbg_show_fn(priv, s, pin, fn); 536 537 /* State of direction bit is only relevant if function==1 */ 538 if (fn == 1) { 539 if (conf[1] & MADERA_GP1_DIR_MASK) 540 seq_puts(s, " IN"); 541 else 542 seq_puts(s, " OUT"); 543 } 544 545 if (conf[1] & MADERA_GP1_PU_MASK) 546 seq_puts(s, " PU"); 547 548 if (conf[1] & MADERA_GP1_PD_MASK) 549 seq_puts(s, " PD"); 550 551 if (conf[0] & MADERA_GP1_DB_MASK) 552 seq_puts(s, " DB"); 553 554 if (conf[0] & MADERA_GP1_OP_CFG_MASK) 555 seq_puts(s, " OD"); 556 else 557 seq_puts(s, " CMOS"); 558 559 seq_printf(s, " DRV=%umA", madera_pin_unmake_drv_str(priv, conf[1])); 560 561 if (conf[0] & MADERA_GP1_IP_CFG_MASK) 562 seq_puts(s, " SCHMITT"); 563 } 564 565 static const struct pinctrl_ops madera_pin_group_ops = { 566 .get_groups_count = madera_get_groups_count, 567 .get_group_name = madera_get_group_name, 568 .get_group_pins = madera_get_group_pins, 569 #if IS_ENABLED(CONFIG_OF) 570 .dt_node_to_map = pinconf_generic_dt_node_to_map_all, 571 .dt_free_map = pinctrl_utils_free_map, 572 #endif 573 #if IS_ENABLED(CONFIG_DEBUG_FS) 574 .pin_dbg_show = madera_pin_dbg_show, 575 #endif 576 }; 577 578 static int madera_mux_get_funcs_count(struct pinctrl_dev *pctldev) 579 { 580 return ARRAY_SIZE(madera_mux_funcs); 581 } 582 583 static const char *madera_mux_get_func_name(struct pinctrl_dev *pctldev, 584 unsigned int selector) 585 { 586 return madera_mux_funcs[selector].name; 587 } 588 589 static int madera_mux_get_groups(struct pinctrl_dev *pctldev, 590 unsigned int selector, 591 const char * const **groups, 592 unsigned int * const num_groups) 593 { 594 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 595 596 *groups = madera_mux_funcs[selector].group_names; 597 598 if (madera_mux_funcs[selector].func == 0) { 599 /* alt func always maps to a single group */ 600 *num_groups = 1; 601 } else { 602 /* other funcs map to all available gpio pins */ 603 *num_groups = priv->chip->n_pins; 604 } 605 606 return 0; 607 } 608 609 static int madera_mux_set_mux(struct pinctrl_dev *pctldev, 610 unsigned int selector, 611 unsigned int group) 612 { 613 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 614 struct madera *madera = priv->madera; 615 const struct madera_pin_groups *pin_group = priv->chip->pin_groups; 616 unsigned int n_chip_groups = priv->chip->n_pin_groups; 617 const char *func_name = madera_mux_funcs[selector].name; 618 unsigned int reg; 619 int i, ret = 0; 620 621 dev_dbg(priv->dev, "%s selecting %u (%s) for group %u (%s)\n", 622 __func__, selector, func_name, group, 623 madera_get_group_name(pctldev, group)); 624 625 if (madera_mux_funcs[selector].func == 0) { 626 /* alt func pin assignments are codec-specific */ 627 for (i = 0; i < n_chip_groups; ++i) { 628 if (strcmp(func_name, pin_group->name) == 0) 629 break; 630 631 ++pin_group; 632 } 633 634 if (i == n_chip_groups) 635 return -EINVAL; 636 637 for (i = 0; i < pin_group->n_pins; ++i) { 638 reg = MADERA_GPIO1_CTRL_1 + (2 * pin_group->pins[i]); 639 640 dev_dbg(priv->dev, "%s setting 0x%x func bits to 0\n", 641 __func__, reg); 642 643 ret = regmap_update_bits(madera->regmap, reg, 644 MADERA_GP1_FN_MASK, 0); 645 if (ret) 646 break; 647 648 } 649 } else { 650 /* 651 * for other funcs the group will be the gpio number and will 652 * be offset by the number of chip-specific functions at the 653 * start of the group list 654 */ 655 group -= n_chip_groups; 656 reg = MADERA_GPIO1_CTRL_1 + (2 * group); 657 658 dev_dbg(priv->dev, "%s setting 0x%x func bits to 0x%x\n", 659 __func__, reg, madera_mux_funcs[selector].func); 660 661 ret = regmap_update_bits(madera->regmap, 662 reg, 663 MADERA_GP1_FN_MASK, 664 madera_mux_funcs[selector].func); 665 } 666 667 if (ret) 668 dev_err(priv->dev, "Failed to write to 0x%x (%d)\n", reg, ret); 669 670 return ret; 671 } 672 673 static int madera_gpio_set_direction(struct pinctrl_dev *pctldev, 674 struct pinctrl_gpio_range *range, 675 unsigned int offset, 676 bool input) 677 { 678 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 679 struct madera *madera = priv->madera; 680 unsigned int reg = MADERA_GPIO1_CTRL_2 + (2 * offset); 681 unsigned int val; 682 int ret; 683 684 if (input) 685 val = MADERA_GP1_DIR; 686 else 687 val = 0; 688 689 ret = regmap_update_bits(madera->regmap, reg, MADERA_GP1_DIR_MASK, val); 690 if (ret) 691 dev_err(priv->dev, "Failed to write to 0x%x (%d)\n", reg, ret); 692 693 return ret; 694 } 695 696 static int madera_gpio_request_enable(struct pinctrl_dev *pctldev, 697 struct pinctrl_gpio_range *range, 698 unsigned int offset) 699 { 700 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 701 struct madera *madera = priv->madera; 702 unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * offset); 703 int ret; 704 705 /* put the pin into GPIO mode */ 706 ret = regmap_update_bits(madera->regmap, reg, MADERA_GP1_FN_MASK, 1); 707 if (ret) 708 dev_err(priv->dev, "Failed to write to 0x%x (%d)\n", reg, ret); 709 710 return ret; 711 } 712 713 static void madera_gpio_disable_free(struct pinctrl_dev *pctldev, 714 struct pinctrl_gpio_range *range, 715 unsigned int offset) 716 { 717 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 718 struct madera *madera = priv->madera; 719 unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * offset); 720 int ret; 721 722 /* disable GPIO by setting to GPIO IN */ 723 madera_gpio_set_direction(pctldev, range, offset, true); 724 725 ret = regmap_update_bits(madera->regmap, reg, MADERA_GP1_FN_MASK, 1); 726 if (ret) 727 dev_err(priv->dev, "Failed to write to 0x%x (%d)\n", reg, ret); 728 } 729 730 static const struct pinmux_ops madera_pin_mux_ops = { 731 .get_functions_count = madera_mux_get_funcs_count, 732 .get_function_name = madera_mux_get_func_name, 733 .get_function_groups = madera_mux_get_groups, 734 .set_mux = madera_mux_set_mux, 735 .gpio_request_enable = madera_gpio_request_enable, 736 .gpio_disable_free = madera_gpio_disable_free, 737 .gpio_set_direction = madera_gpio_set_direction, 738 .strict = true, /* GPIO and other functions are exclusive */ 739 }; 740 741 static int madera_pin_conf_get(struct pinctrl_dev *pctldev, unsigned int pin, 742 unsigned long *config) 743 { 744 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 745 unsigned int param = pinconf_to_config_param(*config); 746 unsigned int result = 0; 747 unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * pin); 748 unsigned int conf[2]; 749 int ret; 750 751 ret = regmap_read(priv->madera->regmap, reg, &conf[0]); 752 if (!ret) 753 ret = regmap_read(priv->madera->regmap, reg + 1, &conf[1]); 754 755 if (ret) { 756 dev_err(priv->dev, "Failed to read GP%d conf (%d)\n", 757 pin + 1, ret); 758 return ret; 759 } 760 761 switch (param) { 762 case PIN_CONFIG_BIAS_BUS_HOLD: 763 conf[1] &= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK; 764 if (conf[1] == (MADERA_GP1_PU | MADERA_GP1_PD)) 765 result = 1; 766 break; 767 case PIN_CONFIG_BIAS_DISABLE: 768 conf[1] &= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK; 769 if (!conf[1]) 770 result = 1; 771 break; 772 case PIN_CONFIG_BIAS_PULL_DOWN: 773 conf[1] &= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK; 774 if (conf[1] == MADERA_GP1_PD_MASK) 775 result = 1; 776 break; 777 case PIN_CONFIG_BIAS_PULL_UP: 778 conf[1] &= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK; 779 if (conf[1] == MADERA_GP1_PU_MASK) 780 result = 1; 781 break; 782 case PIN_CONFIG_DRIVE_OPEN_DRAIN: 783 if (conf[0] & MADERA_GP1_OP_CFG_MASK) 784 result = 1; 785 break; 786 case PIN_CONFIG_DRIVE_PUSH_PULL: 787 if (!(conf[0] & MADERA_GP1_OP_CFG_MASK)) 788 result = 1; 789 break; 790 case PIN_CONFIG_DRIVE_STRENGTH: 791 result = madera_pin_unmake_drv_str(priv, conf[1]); 792 break; 793 case PIN_CONFIG_INPUT_DEBOUNCE: 794 if (conf[0] & MADERA_GP1_DB_MASK) 795 result = 1; 796 break; 797 case PIN_CONFIG_INPUT_ENABLE: 798 if (conf[0] & MADERA_GP1_DIR_MASK) 799 result = 1; 800 break; 801 case PIN_CONFIG_INPUT_SCHMITT: 802 case PIN_CONFIG_INPUT_SCHMITT_ENABLE: 803 if (conf[0] & MADERA_GP1_IP_CFG_MASK) 804 result = 1; 805 break; 806 case PIN_CONFIG_OUTPUT: 807 if ((conf[1] & MADERA_GP1_DIR_MASK) && 808 (conf[0] & MADERA_GP1_LVL_MASK)) 809 result = 1; 810 break; 811 default: 812 return -ENOTSUPP; 813 } 814 815 *config = pinconf_to_config_packed(param, result); 816 817 return 0; 818 } 819 820 static int madera_pin_conf_set(struct pinctrl_dev *pctldev, unsigned int pin, 821 unsigned long *configs, unsigned int num_configs) 822 { 823 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 824 u16 conf[2] = {0, 0}; 825 u16 mask[2] = {0, 0}; 826 unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * pin); 827 unsigned int val; 828 int ret; 829 830 while (num_configs) { 831 dev_dbg(priv->dev, "%s config 0x%lx\n", __func__, *configs); 832 833 switch (pinconf_to_config_param(*configs)) { 834 case PIN_CONFIG_BIAS_BUS_HOLD: 835 mask[1] |= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK; 836 conf[1] |= MADERA_GP1_PU | MADERA_GP1_PD; 837 break; 838 case PIN_CONFIG_BIAS_DISABLE: 839 mask[1] |= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK; 840 conf[1] &= ~(MADERA_GP1_PU | MADERA_GP1_PD); 841 break; 842 case PIN_CONFIG_BIAS_PULL_DOWN: 843 mask[1] |= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK; 844 conf[1] |= MADERA_GP1_PD; 845 conf[1] &= ~MADERA_GP1_PU; 846 break; 847 case PIN_CONFIG_BIAS_PULL_UP: 848 mask[1] |= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK; 849 conf[1] |= MADERA_GP1_PU; 850 conf[1] &= ~MADERA_GP1_PD; 851 break; 852 case PIN_CONFIG_DRIVE_OPEN_DRAIN: 853 mask[0] |= MADERA_GP1_OP_CFG_MASK; 854 conf[0] |= MADERA_GP1_OP_CFG; 855 break; 856 case PIN_CONFIG_DRIVE_PUSH_PULL: 857 mask[0] |= MADERA_GP1_OP_CFG_MASK; 858 conf[0] &= ~MADERA_GP1_OP_CFG; 859 break; 860 case PIN_CONFIG_DRIVE_STRENGTH: 861 val = pinconf_to_config_argument(*configs); 862 mask[1] |= MADERA_GP1_DRV_STR_MASK; 863 conf[1] &= ~MADERA_GP1_DRV_STR_MASK; 864 conf[1] |= madera_pin_make_drv_str(priv, val); 865 break; 866 case PIN_CONFIG_INPUT_DEBOUNCE: 867 mask[0] |= MADERA_GP1_DB_MASK; 868 869 /* 870 * we can't configure debounce time per-pin so value 871 * is just a flag 872 */ 873 val = pinconf_to_config_argument(*configs); 874 if (val) 875 conf[0] |= MADERA_GP1_DB; 876 else 877 conf[0] &= ~MADERA_GP1_DB; 878 break; 879 case PIN_CONFIG_INPUT_ENABLE: 880 val = pinconf_to_config_argument(*configs); 881 mask[1] |= MADERA_GP1_DIR_MASK; 882 if (val) 883 conf[1] |= MADERA_GP1_DIR; 884 else 885 conf[1] &= ~MADERA_GP1_DIR; 886 break; 887 case PIN_CONFIG_INPUT_SCHMITT: 888 val = pinconf_to_config_argument(*configs); 889 mask[0] |= MADERA_GP1_IP_CFG; 890 if (val) 891 conf[0] |= MADERA_GP1_IP_CFG; 892 else 893 conf[0] &= ~MADERA_GP1_IP_CFG; 894 895 mask[1] |= MADERA_GP1_DIR_MASK; 896 conf[1] |= MADERA_GP1_DIR; 897 break; 898 case PIN_CONFIG_INPUT_SCHMITT_ENABLE: 899 mask[0] |= MADERA_GP1_IP_CFG; 900 conf[0] |= MADERA_GP1_IP_CFG; 901 mask[1] |= MADERA_GP1_DIR_MASK; 902 conf[1] |= MADERA_GP1_DIR; 903 break; 904 case PIN_CONFIG_OUTPUT: 905 val = pinconf_to_config_argument(*configs); 906 mask[0] |= MADERA_GP1_LVL_MASK; 907 if (val) 908 conf[0] |= MADERA_GP1_LVL; 909 else 910 conf[0] &= ~MADERA_GP1_LVL; 911 912 mask[1] |= MADERA_GP1_DIR_MASK; 913 conf[1] &= ~MADERA_GP1_DIR; 914 break; 915 default: 916 return -ENOTSUPP; 917 } 918 919 ++configs; 920 --num_configs; 921 } 922 923 dev_dbg(priv->dev, 924 "%s gpio%d 0x%x:0x%x 0x%x:0x%x\n", 925 __func__, pin + 1, reg, conf[0], reg + 1, conf[1]); 926 927 ret = regmap_update_bits(priv->madera->regmap, reg, mask[0], conf[0]); 928 if (ret) 929 goto err; 930 931 ++reg; 932 ret = regmap_update_bits(priv->madera->regmap, reg, mask[1], conf[1]); 933 if (ret) 934 goto err; 935 936 return 0; 937 938 err: 939 dev_err(priv->dev, 940 "Failed to write GPIO%d conf (%d) reg 0x%x\n", 941 pin + 1, ret, reg); 942 943 return ret; 944 } 945 946 static int madera_pin_conf_group_set(struct pinctrl_dev *pctldev, 947 unsigned int selector, 948 unsigned long *configs, 949 unsigned int num_configs) 950 { 951 struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev); 952 const struct madera_pin_groups *pin_group; 953 unsigned int n_groups = priv->chip->n_pin_groups; 954 int i, ret; 955 956 dev_dbg(priv->dev, "%s setting group %s\n", __func__, 957 madera_get_group_name(pctldev, selector)); 958 959 if (selector >= n_groups) { 960 /* group is a single pin, convert to pin number and set */ 961 return madera_pin_conf_set(pctldev, 962 selector - n_groups, 963 configs, 964 num_configs); 965 } else { 966 pin_group = &priv->chip->pin_groups[selector]; 967 968 for (i = 0; i < pin_group->n_pins; ++i) { 969 ret = madera_pin_conf_set(pctldev, 970 pin_group->pins[i], 971 configs, 972 num_configs); 973 if (ret) 974 return ret; 975 } 976 } 977 978 return 0; 979 } 980 981 static const struct pinconf_ops madera_pin_conf_ops = { 982 .is_generic = true, 983 .pin_config_get = madera_pin_conf_get, 984 .pin_config_set = madera_pin_conf_set, 985 .pin_config_group_set = madera_pin_conf_group_set, 986 }; 987 988 static struct pinctrl_desc madera_pin_desc = { 989 .name = "madera-pinctrl", 990 .pins = madera_pins, 991 .pctlops = &madera_pin_group_ops, 992 .pmxops = &madera_pin_mux_ops, 993 .confops = &madera_pin_conf_ops, 994 .owner = THIS_MODULE, 995 }; 996 997 static int madera_pin_probe(struct platform_device *pdev) 998 { 999 struct madera *madera = dev_get_drvdata(pdev->dev.parent); 1000 const struct madera_pdata *pdata = &madera->pdata; 1001 struct madera_pin_private *priv; 1002 int ret; 1003 1004 BUILD_BUG_ON(ARRAY_SIZE(madera_pin_single_group_names) != 1005 ARRAY_SIZE(madera_pin_single_group_pins)); 1006 1007 dev_dbg(&pdev->dev, "%s\n", __func__); 1008 1009 device_set_node(&pdev->dev, dev_fwnode(pdev->dev.parent)); 1010 1011 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 1012 if (!priv) 1013 return -ENOMEM; 1014 1015 priv->dev = &pdev->dev; 1016 priv->madera = madera; 1017 1018 switch (madera->type) { 1019 case CS47L15: 1020 if (IS_ENABLED(CONFIG_PINCTRL_CS47L15)) 1021 priv->chip = &cs47l15_pin_chip; 1022 break; 1023 case CS47L35: 1024 if (IS_ENABLED(CONFIG_PINCTRL_CS47L35)) 1025 priv->chip = &cs47l35_pin_chip; 1026 break; 1027 case CS47L85: 1028 case WM1840: 1029 if (IS_ENABLED(CONFIG_PINCTRL_CS47L85)) 1030 priv->chip = &cs47l85_pin_chip; 1031 break; 1032 case CS47L90: 1033 case CS47L91: 1034 if (IS_ENABLED(CONFIG_PINCTRL_CS47L90)) 1035 priv->chip = &cs47l90_pin_chip; 1036 break; 1037 case CS42L92: 1038 case CS47L92: 1039 case CS47L93: 1040 if (IS_ENABLED(CONFIG_PINCTRL_CS47L92)) 1041 priv->chip = &cs47l92_pin_chip; 1042 break; 1043 default: 1044 break; 1045 } 1046 1047 if (!priv->chip) 1048 return -ENODEV; 1049 1050 madera_pin_desc.npins = priv->chip->n_pins; 1051 1052 ret = devm_pinctrl_register_and_init(&pdev->dev, 1053 &madera_pin_desc, 1054 priv, 1055 &priv->pctl); 1056 if (ret) { 1057 dev_err(priv->dev, "Failed pinctrl register (%d)\n", ret); 1058 return ret; 1059 } 1060 1061 /* if the configuration is provided through pdata, apply it */ 1062 if (pdata->gpio_configs) { 1063 ret = pinctrl_register_mappings(pdata->gpio_configs, 1064 pdata->n_gpio_configs); 1065 if (ret) { 1066 dev_err(priv->dev, 1067 "Failed to register pdata mappings (%d)\n", 1068 ret); 1069 return ret; 1070 } 1071 } 1072 1073 ret = pinctrl_enable(priv->pctl); 1074 if (ret) { 1075 dev_err(priv->dev, "Failed to enable pinctrl (%d)\n", ret); 1076 return ret; 1077 } 1078 1079 platform_set_drvdata(pdev, priv); 1080 1081 dev_dbg(priv->dev, "pinctrl probed ok\n"); 1082 1083 return 0; 1084 } 1085 1086 static int madera_pin_remove(struct platform_device *pdev) 1087 { 1088 struct madera_pin_private *priv = platform_get_drvdata(pdev); 1089 1090 if (priv->madera->pdata.gpio_configs) 1091 pinctrl_unregister_mappings(priv->madera->pdata.gpio_configs); 1092 1093 return 0; 1094 } 1095 1096 static struct platform_driver madera_pin_driver = { 1097 .probe = madera_pin_probe, 1098 .remove = madera_pin_remove, 1099 .driver = { 1100 .name = "madera-pinctrl", 1101 }, 1102 }; 1103 1104 module_platform_driver(madera_pin_driver); 1105 1106 MODULE_DESCRIPTION("Madera pinctrl driver"); 1107 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>"); 1108 MODULE_LICENSE("GPL v2"); 1109