root/drivers/pinctrl/aspeed/pinctrl-aspeed.c

DEFINITIONS

1. aspeed_pinctrl_get_groups_count
2. aspeed_pinctrl_get_group_name
3. aspeed_pinctrl_get_group_pins
4. aspeed_pinctrl_pin_dbg_show
5. aspeed_pinmux_get_fn_count
6. aspeed_pinmux_get_fn_name
7. aspeed_pinmux_get_fn_groups
8. aspeed_sig_expr_enable
9. aspeed_sig_expr_disable
10. aspeed_disable_sig
11. aspeed_find_expr_by_name
12. get_defined_attribute
13. aspeed_sig_expr_function
14. get_defined_functions
15. aspeed_sig_expr_signal
16. get_defined_signals
17. aspeed_pinmux_set_mux
18. aspeed_expr_is_gpio
19. aspeed_gpio_in_exprs
20. aspeed_gpio_request_enable
21. aspeed_pinctrl_probe
22. pin_in_config_range
23. find_pinconf_config
24. find_pinconf_map
25. aspeed_pin_config_get
26. aspeed_pin_config_set
27. aspeed_pin_config_group_get
28. aspeed_pin_config_group_set

   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/slab.h>
   9 #include <linux/string.h>
  10 #include "../core.h"
  11 #include "pinctrl-aspeed.h"
  12 
  13 int aspeed_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
  14 {
  15         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  16 
  17         return pdata->pinmux.ngroups;
  18 }
  19 
  20 const char *aspeed_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
  21                 unsigned int group)
  22 {
  23         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  24 
  25         return pdata->pinmux.groups[group].name;
  26 }
  27 
  28 int aspeed_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
  29                                   unsigned int group, const unsigned int **pins,
  30                                   unsigned int *npins)
  31 {
  32         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  33 
  34         *pins = &pdata->pinmux.groups[group].pins[0];
  35         *npins = pdata->pinmux.groups[group].npins;
  36 
  37         return 0;
  38 }
  39 
  40 void aspeed_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
  41                                  struct seq_file *s, unsigned int offset)
  42 {
  43         seq_printf(s, " %s", dev_name(pctldev->dev));
  44 }
  45 
  46 int aspeed_pinmux_get_fn_count(struct pinctrl_dev *pctldev)
  47 {
  48         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  49 
  50         return pdata->pinmux.nfunctions;
  51 }
  52 
  53 const char *aspeed_pinmux_get_fn_name(struct pinctrl_dev *pctldev,
  54                                       unsigned int function)
  55 {
  56         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  57 
  58         return pdata->pinmux.functions[function].name;
  59 }
  60 
  61 int aspeed_pinmux_get_fn_groups(struct pinctrl_dev *pctldev,
  62                                 unsigned int function,
  63                                 const char * const **groups,
  64                                 unsigned int * const num_groups)
  65 {
  66         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
  67 
  68         *groups = pdata->pinmux.functions[function].groups;
  69         *num_groups = pdata->pinmux.functions[function].ngroups;
  70 
  71         return 0;
  72 }
  73 
  74 static int aspeed_sig_expr_enable(struct aspeed_pinmux_data *ctx,
  75                                   const struct aspeed_sig_expr *expr)
  76 {
  77         int ret;
  78 
  79         ret = aspeed_sig_expr_eval(ctx, expr, true);
  80         if (ret < 0)
  81                 return ret;
  82 
  83         if (!ret)
  84                 return aspeed_sig_expr_set(ctx, expr, true);
  85 
  86         return 0;
  87 }
  88 
  89 static int aspeed_sig_expr_disable(struct aspeed_pinmux_data *ctx,
  90                                    const struct aspeed_sig_expr *expr)
  91 {
  92         int ret;
  93 
  94         ret = aspeed_sig_expr_eval(ctx, expr, true);
  95         if (ret < 0)
  96                 return ret;
  97 
  98         if (ret)
  99                 return aspeed_sig_expr_set(ctx, expr, false);
 100 
 101         return 0;
 102 }
 103 
 104 /**
 105  * Disable a signal on a pin by disabling all provided signal expressions.
 106  *
 107  * @ctx: The pinmux context
 108  * @exprs: The list of signal expressions (from a priority level on a pin)
 109  *
 110  * Return: 0 if all expressions are disabled, otherwise a negative error code
 111  */
 112 static int aspeed_disable_sig(struct aspeed_pinmux_data *ctx,
 113                               const struct aspeed_sig_expr **exprs)
 114 {
 115         int ret = 0;
 116 
 117         if (!exprs)
 118                 return true;
 119 
 120         while (*exprs && !ret) {
 121                 ret = aspeed_sig_expr_disable(ctx, *exprs);
 122                 exprs++;
 123         }
 124 
 125         return ret;
 126 }
 127 
 128 /**
 129  * Search for the signal expression needed to enable the pin's signal for the
 130  * requested function.
 131  *
 132  * @exprs: List of signal expressions (haystack)
 133  * @name: The name of the requested function (needle)
 134  *
 135  * Return: A pointer to the signal expression whose function tag matches the
 136  * provided name, otherwise NULL.
 137  *
 138  */
 139 static const struct aspeed_sig_expr *aspeed_find_expr_by_name(
 140                 const struct aspeed_sig_expr **exprs, const char *name)
 141 {
 142         while (*exprs) {
 143                 if (strcmp((*exprs)->function, name) == 0)
 144                         return *exprs;
 145                 exprs++;
 146         }
 147 
 148         return NULL;
 149 }
 150 
 151 static char *get_defined_attribute(const struct aspeed_pin_desc *pdesc,
 152                                    const char *(*get)(
 153                                            const struct aspeed_sig_expr *))
 154 {
 155         char *found = NULL;
 156         size_t len = 0;
 157         const struct aspeed_sig_expr ***prios, **funcs, *expr;
 158 
 159         prios = pdesc->prios;
 160 
 161         while ((funcs = *prios)) {
 162                 while ((expr = *funcs)) {
 163                         const char *str = get(expr);
 164                         size_t delta = strlen(str) + 2;
 165                         char *expanded;
 166 
 167                         expanded = krealloc(found, len + delta + 1, GFP_KERNEL);
 168                         if (!expanded) {
 169                                 kfree(found);
 170                                 return expanded;
 171                         }
 172 
 173                         found = expanded;
 174                         found[len] = '\0';
 175                         len += delta;
 176 
 177                         strcat(found, str);
 178                         strcat(found, ", ");
 179 
 180                         funcs++;
 181                 }
 182                 prios++;
 183         }
 184 
 185         if (len < 2) {
 186                 kfree(found);
 187                 return NULL;
 188         }
 189 
 190         found[len - 2] = '\0';
 191 
 192         return found;
 193 }
 194 
 195 static const char *aspeed_sig_expr_function(const struct aspeed_sig_expr *expr)
 196 {
 197         return expr->function;
 198 }
 199 
 200 static char *get_defined_functions(const struct aspeed_pin_desc *pdesc)
 201 {
 202         return get_defined_attribute(pdesc, aspeed_sig_expr_function);
 203 }
 204 
 205 static const char *aspeed_sig_expr_signal(const struct aspeed_sig_expr *expr)
 206 {
 207         return expr->signal;
 208 }
 209 
 210 static char *get_defined_signals(const struct aspeed_pin_desc *pdesc)
 211 {
 212         return get_defined_attribute(pdesc, aspeed_sig_expr_signal);
 213 }
 214 
 215 int aspeed_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned int function,
 216                           unsigned int group)
 217 {
 218         int i;
 219         int ret;
 220         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 221         const struct aspeed_pin_group *pgroup = &pdata->pinmux.groups[group];
 222         const struct aspeed_pin_function *pfunc =
 223                 &pdata->pinmux.functions[function];
 224 
 225         for (i = 0; i < pgroup->npins; i++) {
 226                 int pin = pgroup->pins[i];
 227                 const struct aspeed_pin_desc *pdesc = pdata->pins[pin].drv_data;
 228                 const struct aspeed_sig_expr *expr = NULL;
 229                 const struct aspeed_sig_expr **funcs;
 230                 const struct aspeed_sig_expr ***prios;
 231 
 232                 pr_debug("Muxing pin %d for %s\n", pin, pfunc->name);
 233 
 234                 if (!pdesc)
 235                         return -EINVAL;
 236 
 237                 prios = pdesc->prios;
 238 
 239                 if (!prios)
 240                         continue;
 241 
 242                 /* Disable functions at a higher priority than that requested */
 243                 while ((funcs = *prios)) {
 244                         expr = aspeed_find_expr_by_name(funcs, pfunc->name);
 245 
 246                         if (expr)
 247                                 break;
 248 
 249                         ret = aspeed_disable_sig(&pdata->pinmux, funcs);
 250                         if (ret)
 251                                 return ret;
 252 
 253                         prios++;
 254                 }
 255 
 256                 if (!expr) {
 257                         char *functions = get_defined_functions(pdesc);
 258                         char *signals = get_defined_signals(pdesc);
 259 
 260                         pr_warn("No function %s found on pin %s (%d). Found signal(s) %s for function(s) %s\n",
 261                                 pfunc->name, pdesc->name, pin, signals,
 262                                 functions);
 263                         kfree(signals);
 264                         kfree(functions);
 265 
 266                         return -ENXIO;
 267                 }
 268 
 269                 ret = aspeed_sig_expr_enable(&pdata->pinmux, expr);
 270                 if (ret)
 271                         return ret;
 272         }
 273 
 274         return 0;
 275 }
 276 
 277 static bool aspeed_expr_is_gpio(const struct aspeed_sig_expr *expr)
 278 {
 279         /*
 280          * The signal type is GPIO if the signal name has "GPIO" as a prefix.
 281          * strncmp (rather than strcmp) is used to implement the prefix
 282          * requirement.
 283          *
 284          * expr->signal might look like "GPIOT3" in the GPIO case.
 285          */
 286         return strncmp(expr->signal, "GPIO", 4) == 0;
 287 }
 288 
 289 static bool aspeed_gpio_in_exprs(const struct aspeed_sig_expr **exprs)
 290 {
 291         if (!exprs)
 292                 return false;
 293 
 294         while (*exprs) {
 295                 if (aspeed_expr_is_gpio(*exprs))
 296                         return true;
 297                 exprs++;
 298         }
 299 
 300         return false;
 301 }
 302 
 303 int aspeed_gpio_request_enable(struct pinctrl_dev *pctldev,
 304                                struct pinctrl_gpio_range *range,
 305                                unsigned int offset)
 306 {
 307         int ret;
 308         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 309         const struct aspeed_pin_desc *pdesc = pdata->pins[offset].drv_data;
 310         const struct aspeed_sig_expr ***prios, **funcs, *expr;
 311 
 312         if (!pdesc)
 313                 return -EINVAL;
 314 
 315         prios = pdesc->prios;
 316 
 317         if (!prios)
 318                 return -ENXIO;
 319 
 320         /* Disable any functions of higher priority than GPIO */
 321         while ((funcs = *prios)) {
 322                 if (aspeed_gpio_in_exprs(funcs))
 323                         break;
 324 
 325                 ret = aspeed_disable_sig(&pdata->pinmux, funcs);
 326                 if (ret)
 327                         return ret;
 328 
 329                 prios++;
 330         }
 331 
 332         if (!funcs) {
 333                 char *signals = get_defined_signals(pdesc);
 334 
 335                 pr_warn("No GPIO signal type found on pin %s (%d). Found: %s\n",
 336                         pdesc->name, offset, signals);
 337                 kfree(signals);
 338 
 339                 return -ENXIO;
 340         }
 341 
 342         expr = *funcs;
 343 
 344         /*
 345          * Disabling all higher-priority expressions is enough to enable the
 346          * lowest-priority signal type. As such it has no associated
 347          * expression.
 348          */
 349         if (!expr)
 350                 return 0;
 351 
 352         /*
 353          * If GPIO is not the lowest priority signal type, assume there is only
 354          * one expression defined to enable the GPIO function
 355          */
 356         return aspeed_sig_expr_enable(&pdata->pinmux, expr);
 357 }
 358 
 359 int aspeed_pinctrl_probe(struct platform_device *pdev,
 360                          struct pinctrl_desc *pdesc,
 361                          struct aspeed_pinctrl_data *pdata)
 362 {
 363         struct device *parent;
 364         struct pinctrl_dev *pctl;
 365 
 366         parent = pdev->dev.parent;
 367         if (!parent) {
 368                 dev_err(&pdev->dev, "No parent for syscon pincontroller\n");
 369                 return -ENODEV;
 370         }
 371 
 372         pdata->scu = syscon_node_to_regmap(parent->of_node);
 373         if (IS_ERR(pdata->scu)) {
 374                 dev_err(&pdev->dev, "No regmap for syscon pincontroller parent\n");
 375                 return PTR_ERR(pdata->scu);
 376         }
 377 
 378         pdata->pinmux.maps[ASPEED_IP_SCU] = pdata->scu;
 379 
 380         pctl = pinctrl_register(pdesc, &pdev->dev, pdata);
 381 
 382         if (IS_ERR(pctl)) {
 383                 dev_err(&pdev->dev, "Failed to register pinctrl\n");
 384                 return PTR_ERR(pctl);
 385         }
 386 
 387         platform_set_drvdata(pdev, pdata);
 388 
 389         return 0;
 390 }
 391 
 392 static inline bool pin_in_config_range(unsigned int offset,
 393                 const struct aspeed_pin_config *config)
 394 {
 395         return offset >= config->pins[0] && offset <= config->pins[1];
 396 }
 397 
 398 static inline const struct aspeed_pin_config *find_pinconf_config(
 399                 const struct aspeed_pinctrl_data *pdata,
 400                 unsigned int offset,
 401                 enum pin_config_param param)
 402 {
 403         unsigned int i;
 404 
 405         for (i = 0; i < pdata->nconfigs; i++) {
 406                 if (param == pdata->configs[i].param &&
 407                                 pin_in_config_range(offset, &pdata->configs[i]))
 408                         return &pdata->configs[i];
 409         }
 410 
 411         return NULL;
 412 }
 413 
 414 /*
 415  * Aspeed pin configuration description.
 416  *
 417  * @param: pinconf configuration parameter
 418  * @arg: The supported argument for @param, or -1 if any value is supported
 419  * @val: The register value to write to configure @arg for @param
 420  *
 421  * The map is to be used in conjunction with the configuration array supplied
 422  * by the driver implementation.
 423  */
 424 struct aspeed_pin_config_map {
 425         enum pin_config_param param;
 426         s32 arg;
 427         u32 val;
 428 };
 429 
 430 enum aspeed_pin_config_map_type { MAP_TYPE_ARG, MAP_TYPE_VAL };
 431 
 432 /* Aspeed consistently both:
 433  *
 434  * 1. Defines "disable bits" for internal pull-downs
 435  * 2. Uses 8mA or 16mA drive strengths
 436  */
 437 static const struct aspeed_pin_config_map pin_config_map[] = {
 438         { PIN_CONFIG_BIAS_PULL_DOWN,  0, 1 },
 439         { PIN_CONFIG_BIAS_PULL_DOWN, -1, 0 },
 440         { PIN_CONFIG_BIAS_DISABLE,   -1, 1 },
 441         { PIN_CONFIG_DRIVE_STRENGTH,  8, 0 },
 442         { PIN_CONFIG_DRIVE_STRENGTH, 16, 1 },
 443 };
 444 
 445 static const struct aspeed_pin_config_map *find_pinconf_map(
 446                 enum pin_config_param param,
 447                 enum aspeed_pin_config_map_type type,
 448                 s64 value)
 449 {
 450         int i;
 451 
 452         for (i = 0; i < ARRAY_SIZE(pin_config_map); i++) {
 453                 const struct aspeed_pin_config_map *elem;
 454                 bool match;
 455 
 456                 elem = &pin_config_map[i];
 457 
 458                 switch (type) {
 459                 case MAP_TYPE_ARG:
 460                         match = (elem->arg == -1 || elem->arg == value);
 461                         break;
 462                 case MAP_TYPE_VAL:
 463                         match = (elem->val == value);
 464                         break;
 465                 }
 466 
 467                 if (param == elem->param && match)
 468                         return elem;
 469         }
 470 
 471         return NULL;
 472 }
 473 
 474 int aspeed_pin_config_get(struct pinctrl_dev *pctldev, unsigned int offset,
 475                 unsigned long *config)
 476 {
 477         const enum pin_config_param param = pinconf_to_config_param(*config);
 478         const struct aspeed_pin_config_map *pmap;
 479         const struct aspeed_pinctrl_data *pdata;
 480         const struct aspeed_pin_config *pconf;
 481         unsigned int val;
 482         int rc = 0;
 483         u32 arg;
 484 
 485         pdata = pinctrl_dev_get_drvdata(pctldev);
 486         pconf = find_pinconf_config(pdata, offset, param);
 487         if (!pconf)
 488                 return -ENOTSUPP;
 489 
 490         rc = regmap_read(pdata->scu, pconf->reg, &val);
 491         if (rc < 0)
 492                 return rc;
 493 
 494         pmap = find_pinconf_map(param, MAP_TYPE_VAL,
 495                         (val & BIT(pconf->bit)) >> pconf->bit);
 496 
 497         if (!pmap)
 498                 return -EINVAL;
 499 
 500         if (param == PIN_CONFIG_DRIVE_STRENGTH)
 501                 arg = (u32) pmap->arg;
 502         else if (param == PIN_CONFIG_BIAS_PULL_DOWN)
 503                 arg = !!pmap->arg;
 504         else
 505                 arg = 1;
 506 
 507         if (!arg)
 508                 return -EINVAL;
 509 
 510         *config = pinconf_to_config_packed(param, arg);
 511 
 512         return 0;
 513 }
 514 
 515 int aspeed_pin_config_set(struct pinctrl_dev *pctldev, unsigned int offset,
 516                 unsigned long *configs, unsigned int num_configs)
 517 {
 518         const struct aspeed_pinctrl_data *pdata;
 519         unsigned int i;
 520         int rc = 0;
 521 
 522         pdata = pinctrl_dev_get_drvdata(pctldev);
 523 
 524         for (i = 0; i < num_configs; i++) {
 525                 const struct aspeed_pin_config_map *pmap;
 526                 const struct aspeed_pin_config *pconf;
 527                 enum pin_config_param param;
 528                 unsigned int val;
 529                 u32 arg;
 530 
 531                 param = pinconf_to_config_param(configs[i]);
 532                 arg = pinconf_to_config_argument(configs[i]);
 533 
 534                 pconf = find_pinconf_config(pdata, offset, param);
 535                 if (!pconf)
 536                         return -ENOTSUPP;
 537 
 538                 pmap = find_pinconf_map(param, MAP_TYPE_ARG, arg);
 539 
 540                 if (WARN_ON(!pmap))
 541                         return -EINVAL;
 542 
 543                 val = pmap->val << pconf->bit;
 544 
 545                 rc = regmap_update_bits(pdata->scu, pconf->reg,
 546                                         BIT(pconf->bit), val);
 547 
 548                 if (rc < 0)
 549                         return rc;
 550 
 551                 pr_debug("%s: Set SCU%02X[%d]=%d for param %d(=%d) on pin %d\n",
 552                                 __func__, pconf->reg, pconf->bit, pmap->val,
 553                                 param, arg, offset);
 554         }
 555 
 556         return 0;
 557 }
 558 
 559 int aspeed_pin_config_group_get(struct pinctrl_dev *pctldev,
 560                 unsigned int selector,
 561                 unsigned long *config)
 562 {
 563         const unsigned int *pins;
 564         unsigned int npins;
 565         int rc;
 566 
 567         rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
 568         if (rc < 0)
 569                 return rc;
 570 
 571         if (!npins)
 572                 return -ENODEV;
 573 
 574         rc = aspeed_pin_config_get(pctldev, pins[0], config);
 575 
 576         return rc;
 577 }
 578 
 579 int aspeed_pin_config_group_set(struct pinctrl_dev *pctldev,
 580                 unsigned int selector,
 581                 unsigned long *configs,
 582                 unsigned int num_configs)
 583 {
 584         const unsigned int *pins;
 585         unsigned int npins;
 586         int rc;
 587         int i;
 588 
 589         pr_debug("%s: Fetching pins for group selector %d\n",
 590                         __func__, selector);
 591         rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
 592         if (rc < 0)
 593                 return rc;
 594 
 595         for (i = 0; i < npins; i++) {
 596                 rc = aspeed_pin_config_set(pctldev, pins[i], configs,
 597                                 num_configs);
 598                 if (rc < 0)
 599                         return rc;
 600         }
 601 
 602         return 0;
 603 }