drivers/pinctrl/cirrus/pinctrl-madera-core.c

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