drivers/pinctrl/aspeed/pinctrl-aspeed.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2016 IBM Corp.
   4  */
   5
   6 #include <linux/mfd/syscon.h>
   7 #include <linux/platform_device.h>
   8 #include <linux/seq_file.h>
   9 #include <linux/slab.h>
  10 #include <linux/string.h>
  11 #include "../core.h"
  12 #include "pinctrl-aspeed.h"
  13
  14 int aspeed_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
  15 {
  16         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  17
  18         return pdata->pinmux.ngroups;
  19 }
  20
  21 const char *aspeed_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
  22                 unsigned int group)
  23 {
  24         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  25
  26         return pdata->pinmux.groups[group].name;
  27 }
  28
  29 int aspeed_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
  30                                   unsigned int group, const unsigned int **pins,
  31                                   unsigned int *npins)
  32 {
  33         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  34
  35         *pins = &pdata->pinmux.groups[group].pins[0];
  36         *npins = pdata->pinmux.groups[group].npins;
  37
  38         return 0;
  39 }
  40
  41 void aspeed_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
  42                                  struct seq_file *s, unsigned int offset)
  43 {
  44         seq_printf(s, " %s", dev_name(pctldev->dev));
  45 }
  46
  47 int aspeed_pinmux_get_fn_count(struct pinctrl_dev *pctldev)
  48 {
  49         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  50
  51         return pdata->pinmux.nfunctions;
  52 }
  53
  54 const char *aspeed_pinmux_get_fn_name(struct pinctrl_dev *pctldev,
  55                                       unsigned int function)
  56 {
  57         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  58
  59         return pdata->pinmux.functions[function].name;
  60 }
  61
  62 int aspeed_pinmux_get_fn_groups(struct pinctrl_dev *pctldev,
  63                                 unsigned int function,
  64                                 const char * const **groups,
  65                                 unsigned int * const num_groups)
  66 {
  67         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  68
  69         *groups = pdata->pinmux.functions[function].groups;
  70         *num_groups = pdata->pinmux.functions[function].ngroups;
  71
  72         return 0;
  73 }
  74
  75 static int aspeed_sig_expr_enable(struct aspeed_pinmux_data *ctx,
  76                                   const struct aspeed_sig_expr *expr)
  77 {
  78         int ret;
  79
  80         pr_debug("Enabling signal %s for %s\n", expr->signal,
  81                  expr->function);
  82
  83         ret = aspeed_sig_expr_eval(ctx, expr, true);
  84         if (ret < 0)
  85                 return ret;
  86
  87         if (!ret)
  88                 return aspeed_sig_expr_set(ctx, expr, true);
  89
  90         return 0;
  91 }
  92
  93 static int aspeed_sig_expr_disable(struct aspeed_pinmux_data *ctx,
  94                                    const struct aspeed_sig_expr *expr)
  95 {
  96         int ret;
  97
  98         pr_debug("Disabling signal %s for %s\n", expr->signal,
  99                  expr->function);
 100
 101         ret = aspeed_sig_expr_eval(ctx, expr, true);
 102         if (ret < 0)
 103                 return ret;
 104
 105         if (ret)
 106                 return aspeed_sig_expr_set(ctx, expr, false);
 107
 108         return 0;
 109 }
 110
 111 /**
 112  * aspeed_disable_sig() - Disable a signal on a pin by disabling all provided
 113  * signal expressions.
 114  *
 115  * @ctx: The pinmux context
 116  * @exprs: The list of signal expressions (from a priority level on a pin)
 117  *
 118  * Return: 0 if all expressions are disabled, otherwise a negative error code
 119  */
 120 static int aspeed_disable_sig(struct aspeed_pinmux_data *ctx,
 121                               const struct aspeed_sig_expr **exprs)
 122 {
 123         int ret = 0;
 124
 125         if (!exprs)
 126                 return -EINVAL;
 127
 128         while (*exprs && !ret) {
 129                 ret = aspeed_sig_expr_disable(ctx, *exprs);
 130                 exprs++;
 131         }
 132
 133         return ret;
 134 }
 135
 136 /**
 137  * aspeed_find_expr_by_name - Search for the signal expression needed to
 138  * enable the pin's signal for the requested function.
 139  *
 140  * @exprs: List of signal expressions (haystack)
 141  * @name: The name of the requested function (needle)
 142  *
 143  * Return: A pointer to the signal expression whose function tag matches the
 144  * provided name, otherwise NULL.
 145  *
 146  */
 147 static const struct aspeed_sig_expr *aspeed_find_expr_by_name(
 148                 const struct aspeed_sig_expr **exprs, const char *name)
 149 {
 150         while (*exprs) {
 151                 if (strcmp((*exprs)->function, name) == 0)
 152                         return *exprs;
 153                 exprs++;
 154         }
 155
 156         return NULL;
 157 }
 158
 159 static char *get_defined_attribute(const struct aspeed_pin_desc *pdesc,
 160                                    const char *(*get)(
 161                                            const struct aspeed_sig_expr *))
 162 {
 163         char *found = NULL;
 164         size_t len = 0;
 165         const struct aspeed_sig_expr ***prios, **funcs, *expr;
 166
 167         prios = pdesc->prios;
 168
 169         while ((funcs = *prios)) {
 170                 while ((expr = *funcs)) {
 171                         const char *str = get(expr);
 172                         size_t delta = strlen(str) + 2;
 173                         char *expanded;
 174
 175                         expanded = krealloc(found, len + delta + 1, GFP_KERNEL);
 176                         if (!expanded) {
 177                                 kfree(found);
 178                                 return expanded;
 179                         }
 180
 181                         found = expanded;
 182                         found[len] = '\0';
 183                         len += delta;
 184
 185                         strcat(found, str);
 186                         strcat(found, ", ");
 187
 188                         funcs++;
 189                 }
 190                 prios++;
 191         }
 192
 193         if (len < 2) {
 194                 kfree(found);
 195                 return NULL;
 196         }
 197
 198         found[len - 2] = '\0';
 199
 200         return found;
 201 }
 202
 203 static const char *aspeed_sig_expr_function(const struct aspeed_sig_expr *expr)
 204 {
 205         return expr->function;
 206 }
 207
 208 static char *get_defined_functions(const struct aspeed_pin_desc *pdesc)
 209 {
 210         return get_defined_attribute(pdesc, aspeed_sig_expr_function);
 211 }
 212
 213 static const char *aspeed_sig_expr_signal(const struct aspeed_sig_expr *expr)
 214 {
 215         return expr->signal;
 216 }
 217
 218 static char *get_defined_signals(const struct aspeed_pin_desc *pdesc)
 219 {
 220         return get_defined_attribute(pdesc, aspeed_sig_expr_signal);
 221 }
 222
 223 int aspeed_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned int function,
 224                           unsigned int group)
 225 {
 226         int i;
 227         int ret;
 228         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 229         const struct aspeed_pin_group *pgroup = &pdata->pinmux.groups[group];
 230         const struct aspeed_pin_function *pfunc =
 231                 &pdata->pinmux.functions[function];
 232
 233         for (i = 0; i < pgroup->npins; i++) {
 234                 int pin = pgroup->pins[i];
 235                 const struct aspeed_pin_desc *pdesc = pdata->pins[pin].drv_data;
 236                 const struct aspeed_sig_expr *expr = NULL;
 237                 const struct aspeed_sig_expr **funcs;
 238                 const struct aspeed_sig_expr ***prios;
 239
 240                 if (!pdesc)
 241                         return -EINVAL;
 242
 243                 pr_debug("Muxing pin %s for %s\n", pdesc->name, pfunc->name);
 244
 245                 prios = pdesc->prios;
 246
 247                 if (!prios)
 248                         continue;
 249
 250                 /* Disable functions at a higher priority than that requested */
 251                 while ((funcs = *prios)) {
 252                         expr = aspeed_find_expr_by_name(funcs, pfunc->name);
 253
 254                         if (expr)
 255                                 break;
 256
 257                         ret = aspeed_disable_sig(&pdata->pinmux, funcs);
 258                         if (ret)
 259                                 return ret;
 260
 261                         prios++;
 262                 }
 263
 264                 if (!expr) {
 265                         char *functions = get_defined_functions(pdesc);
 266                         char *signals = get_defined_signals(pdesc);
 267
 268                         pr_warn("No function %s found on pin %s (%d). Found signal(s) %s for function(s) %s\n",
 269                                 pfunc->name, pdesc->name, pin, signals,
 270                                 functions);
 271                         kfree(signals);
 272                         kfree(functions);
 273
 274                         return -ENXIO;
 275                 }
 276
 277                 ret = aspeed_sig_expr_enable(&pdata->pinmux, expr);
 278                 if (ret)
 279                         return ret;
 280
 281                 pr_debug("Muxed pin %s as %s for %s\n", pdesc->name, expr->signal,
 282                          expr->function);
 283         }
 284
 285         return 0;
 286 }
 287
 288 static bool aspeed_expr_is_gpio(const struct aspeed_sig_expr *expr)
 289 {
 290         /*
 291          * We need to differentiate between GPIO and non-GPIO signals to
 292          * implement the gpio_request_enable() interface. For better or worse
 293          * the ASPEED pinctrl driver uses the expression names to determine
 294          * whether an expression will mux a pin for GPIO.
 295          *
 296          * Generally we have the following - A GPIO such as B1 has:
 297          *
 298          *    - expr->signal set to "GPIOB1"
 299          *    - expr->function set to "GPIOB1"
 300          *
 301          * Using this fact we can determine whether the provided expression is
 302          * a GPIO expression by testing the signal name for the string prefix
 303          * "GPIO".
 304          *
 305          * However, some GPIOs are input-only, and the ASPEED datasheets name
 306          * them differently. An input-only GPIO such as T0 has:
 307          *
 308          *    - expr->signal set to "GPIT0"
 309          *    - expr->function set to "GPIT0"
 310          *
 311          * It's tempting to generalise the prefix test from "GPIO" to "GPI" to
 312          * account for both GPIOs and GPIs, but in doing so we run aground on
 313          * another feature:
 314          *
 315          * Some pins in the ASPEED BMC SoCs have a "pass-through" GPIO
 316          * function where the input state of one pin is replicated as the
 317          * output state of another (as if they were shorted together - a mux
 318          * configuration that is typically enabled by hardware strapping).
 319          * This feature allows the BMC to pass e.g. power button state through
 320          * to the host while the BMC is yet to boot, but take control of the
 321          * button state once the BMC has booted by muxing each pin as a
 322          * separate, pin-specific GPIO.
 323          *
 324          * Conceptually this pass-through mode is a form of GPIO and is named
 325          * as such in the datasheets, e.g. "GPID0". This naming similarity
 326          * trips us up with the simple GPI-prefixed-signal-name scheme
 327          * discussed above, as the pass-through configuration is not what we
 328          * want when muxing a pin as GPIO for the GPIO subsystem.
 329          *
 330          * On e.g. the AST2400, a pass-through function "GPID0" is grouped on
 331          * balls A18 and D16, where we have:
 332          *
 333          *    For ball A18:
 334          *    - expr->signal set to "GPID0IN"
 335          *    - expr->function set to "GPID0"
 336          *
 337          *    For ball D16:
 338          *    - expr->signal set to "GPID0OUT"
 339          *    - expr->function set to "GPID0"
 340          *
 341          * By contrast, the pin-specific GPIO expressions for the same pins are
 342          * as follows:
 343          *
 344          *    For ball A18:
 345          *    - expr->signal looks like "GPIOD0"
 346          *    - expr->function looks like "GPIOD0"
 347          *
 348          *    For ball D16:
 349          *    - expr->signal looks like "GPIOD1"
 350          *    - expr->function looks like "GPIOD1"
 351          *
 352          * Testing both the signal _and_ function names gives us the means
 353          * differentiate the pass-through GPIO pinmux configuration from the
 354          * pin-specific configuration that the GPIO subsystem is after: An
 355          * expression is a pin-specific (non-pass-through) GPIO configuration
 356          * if the signal prefix is "GPI" and the signal name matches the
 357          * function name.
 358          */
 359         return !strncmp(expr->signal, "GPI", 3) &&
 360                         !strcmp(expr->signal, expr->function);
 361 }
 362
 363 static bool aspeed_gpio_in_exprs(const struct aspeed_sig_expr **exprs)
 364 {
 365         if (!exprs)
 366                 return false;
 367
 368         while (*exprs) {
 369                 if (aspeed_expr_is_gpio(*exprs))
 370                         return true;
 371                 exprs++;
 372         }
 373
 374         return false;
 375 }
 376
 377 int aspeed_gpio_request_enable(struct pinctrl_dev *pctldev,
 378                                struct pinctrl_gpio_range *range,
 379                                unsigned int offset)
 380 {
 381         int ret;
 382         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 383         const struct aspeed_pin_desc *pdesc = pdata->pins[offset].drv_data;
 384         const struct aspeed_sig_expr ***prios, **funcs, *expr;
 385
 386         if (!pdesc)
 387                 return -EINVAL;
 388
 389         prios = pdesc->prios;
 390
 391         if (!prios)
 392                 return -ENXIO;
 393
 394         pr_debug("Muxing pin %s for GPIO\n", pdesc->name);
 395
 396         /* Disable any functions of higher priority than GPIO */
 397         while ((funcs = *prios)) {
 398                 if (aspeed_gpio_in_exprs(funcs))
 399                         break;
 400
 401                 ret = aspeed_disable_sig(&pdata->pinmux, funcs);
 402                 if (ret)
 403                         return ret;
 404
 405                 prios++;
 406         }
 407
 408         if (!funcs) {
 409                 char *signals = get_defined_signals(pdesc);
 410
 411                 pr_warn("No GPIO signal type found on pin %s (%d). Found: %s\n",
 412                         pdesc->name, offset, signals);
 413                 kfree(signals);
 414
 415                 return -ENXIO;
 416         }
 417
 418         expr = *funcs;
 419
 420         /*
 421          * Disabling all higher-priority expressions is enough to enable the
 422          * lowest-priority signal type. As such it has no associated
 423          * expression.
 424          */
 425         if (!expr) {
 426                 pr_debug("Muxed pin %s as GPIO\n", pdesc->name);
 427                 return 0;
 428         }
 429
 430         /*
 431          * If GPIO is not the lowest priority signal type, assume there is only
 432          * one expression defined to enable the GPIO function
 433          */
 434         ret = aspeed_sig_expr_enable(&pdata->pinmux, expr);
 435         if (ret)
 436                 return ret;
 437
 438         pr_debug("Muxed pin %s as %s\n", pdesc->name, expr->signal);
 439
 440         return 0;
 441 }
 442
 443 int aspeed_pinctrl_probe(struct platform_device *pdev,
 444                          struct pinctrl_desc *pdesc,
 445                          struct aspeed_pinctrl_data *pdata)
 446 {
 447         struct device *parent;
 448         struct pinctrl_dev *pctl;
 449
 450         parent = pdev->dev.parent;
 451         if (!parent) {
 452                 dev_err(&pdev->dev, "No parent for syscon pincontroller\n");
 453                 return -ENODEV;
 454         }
 455
 456         pdata->scu = syscon_node_to_regmap(parent->of_node);
 457         if (IS_ERR(pdata->scu)) {
 458                 dev_err(&pdev->dev, "No regmap for syscon pincontroller parent\n");
 459                 return PTR_ERR(pdata->scu);
 460         }
 461
 462         pdata->pinmux.maps[ASPEED_IP_SCU] = pdata->scu;
 463
 464         pctl = pinctrl_register(pdesc, &pdev->dev, pdata);
 465
 466         if (IS_ERR(pctl)) {
 467                 dev_err(&pdev->dev, "Failed to register pinctrl\n");
 468                 return PTR_ERR(pctl);
 469         }
 470
 471         platform_set_drvdata(pdev, pdata);
 472
 473         return 0;
 474 }
 475
 476 static inline bool pin_in_config_range(unsigned int offset,
 477                 const struct aspeed_pin_config *config)
 478 {
 479         return offset >= config->pins[0] && offset <= config->pins[1];
 480 }
 481
 482 static inline const struct aspeed_pin_config *find_pinconf_config(
 483                 const struct aspeed_pinctrl_data *pdata,
 484                 unsigned int offset,
 485                 enum pin_config_param param)
 486 {
 487         unsigned int i;
 488
 489         for (i = 0; i < pdata->nconfigs; i++) {
 490                 if (param == pdata->configs[i].param &&
 491                                 pin_in_config_range(offset, &pdata->configs[i]))
 492                         return &pdata->configs[i];
 493         }
 494
 495         return NULL;
 496 }
 497
 498 enum aspeed_pin_config_map_type { MAP_TYPE_ARG, MAP_TYPE_VAL };
 499
 500 static const struct aspeed_pin_config_map *find_pinconf_map(
 501                 const struct aspeed_pinctrl_data *pdata,
 502                 enum pin_config_param param,
 503                 enum aspeed_pin_config_map_type type,
 504                 s64 value)
 505 {
 506         int i;
 507
 508         for (i = 0; i < pdata->nconfmaps; i++) {
 509                 const struct aspeed_pin_config_map *elem;
 510                 bool match;
 511
 512                 elem = &pdata->confmaps[i];
 513
 514                 switch (type) {
 515                 case MAP_TYPE_ARG:
 516                         match = (elem->arg == -1 || elem->arg == value);
 517                         break;
 518                 case MAP_TYPE_VAL:
 519                         match = (elem->val == value);
 520                         break;
 521                 }
 522
 523                 if (param == elem->param && match)
 524                         return elem;
 525         }
 526
 527         return NULL;
 528 }
 529
 530 int aspeed_pin_config_get(struct pinctrl_dev *pctldev, unsigned int offset,
 531                 unsigned long *config)
 532 {
 533         const enum pin_config_param param = pinconf_to_config_param(*config);
 534         const struct aspeed_pin_config_map *pmap;
 535         const struct aspeed_pinctrl_data *pdata;
 536         const struct aspeed_pin_config *pconf;
 537         unsigned int val;
 538         int rc = 0;
 539         u32 arg;
 540
 541         pdata = pinctrl_dev_get_drvdata(pctldev);
 542         pconf = find_pinconf_config(pdata, offset, param);
 543         if (!pconf)
 544                 return -ENOTSUPP;
 545
 546         rc = regmap_read(pdata->scu, pconf->reg, &val);
 547         if (rc < 0)
 548                 return rc;
 549
 550         pmap = find_pinconf_map(pdata, param, MAP_TYPE_VAL,
 551                         (val & pconf->mask) >> __ffs(pconf->mask));
 552
 553         if (!pmap)
 554                 return -EINVAL;
 555
 556         if (param == PIN_CONFIG_DRIVE_STRENGTH)
 557                 arg = (u32) pmap->arg;
 558         else if (param == PIN_CONFIG_BIAS_PULL_DOWN)
 559                 arg = !!pmap->arg;
 560         else
 561                 arg = 1;
 562
 563         if (!arg)
 564                 return -EINVAL;
 565
 566         *config = pinconf_to_config_packed(param, arg);
 567
 568         return 0;
 569 }
 570
 571 int aspeed_pin_config_set(struct pinctrl_dev *pctldev, unsigned int offset,
 572                 unsigned long *configs, unsigned int num_configs)
 573 {
 574         const struct aspeed_pinctrl_data *pdata;
 575         unsigned int i;
 576         int rc = 0;
 577
 578         pdata = pinctrl_dev_get_drvdata(pctldev);
 579
 580         for (i = 0; i < num_configs; i++) {
 581                 const struct aspeed_pin_config_map *pmap;
 582                 const struct aspeed_pin_config *pconf;
 583                 enum pin_config_param param;
 584                 unsigned int val;
 585                 u32 arg;
 586
 587                 param = pinconf_to_config_param(configs[i]);
 588                 arg = pinconf_to_config_argument(configs[i]);
 589
 590                 pconf = find_pinconf_config(pdata, offset, param);
 591                 if (!pconf)
 592                         return -ENOTSUPP;
 593
 594                 pmap = find_pinconf_map(pdata, param, MAP_TYPE_ARG, arg);
 595
 596                 if (WARN_ON(!pmap))
 597                         return -EINVAL;
 598
 599                 val = pmap->val << __ffs(pconf->mask);
 600
 601                 rc = regmap_update_bits(pdata->scu, pconf->reg,
 602                                         pconf->mask, val);
 603
 604                 if (rc < 0)
 605                         return rc;
 606
 607                 pr_debug("%s: Set SCU%02X[0x%08X]=0x%X for param %d(=%d) on pin %d\n",
 608                                 __func__, pconf->reg, pconf->mask,
 609                                 val, param, arg, offset);
 610         }
 611
 612         return 0;
 613 }
 614
 615 int aspeed_pin_config_group_get(struct pinctrl_dev *pctldev,
 616                 unsigned int selector,
 617                 unsigned long *config)
 618 {
 619         const unsigned int *pins;
 620         unsigned int npins;
 621         int rc;
 622
 623         rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
 624         if (rc < 0)
 625                 return rc;
 626
 627         if (!npins)
 628                 return -ENODEV;
 629
 630         rc = aspeed_pin_config_get(pctldev, pins[0], config);
 631
 632         return rc;
 633 }
 634
 635 int aspeed_pin_config_group_set(struct pinctrl_dev *pctldev,
 636                 unsigned int selector,
 637                 unsigned long *configs,
 638                 unsigned int num_configs)
 639 {
 640         const unsigned int *pins;
 641         unsigned int npins;
 642         int rc;
 643         int i;
 644
 645         pr_debug("%s: Fetching pins for group selector %d\n",
 646                         __func__, selector);
 647         rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
 648         if (rc < 0)
 649                 return rc;
 650
 651         for (i = 0; i < npins; i++) {
 652                 rc = aspeed_pin_config_set(pctldev, pins[i], configs,
 653                                 num_configs);
 654                 if (rc < 0)
 655                         return rc;
 656         }
 657
 658         return 0;
 659 }