660 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*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 14int 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 21const 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 29int 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 41void 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 47int 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 54const 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 62int 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 75static 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 93static 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 provided113 * signal expressions.114 *115 * @ctx: The pinmux context116 * @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 code119 */120static 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 to138 * 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 the144 * provided name, otherwise NULL.145 *146 */147static 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 159static 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 203static const char *aspeed_sig_expr_function(const struct aspeed_sig_expr *expr)204{205 return expr->function;206}207 208static char *get_defined_functions(const struct aspeed_pin_desc *pdesc)209{210 return get_defined_attribute(pdesc, aspeed_sig_expr_function);211}212 213static const char *aspeed_sig_expr_signal(const struct aspeed_sig_expr *expr)214{215 return expr->signal;216}217 218static char *get_defined_signals(const struct aspeed_pin_desc *pdesc)219{220 return get_defined_attribute(pdesc, aspeed_sig_expr_signal);221}222 223int 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 288static bool aspeed_expr_is_gpio(const struct aspeed_sig_expr *expr)289{290 /*291 * We need to differentiate between GPIO and non-GPIO signals to292 * implement the gpio_request_enable() interface. For better or worse293 * the ASPEED pinctrl driver uses the expression names to determine294 * 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 is302 * a GPIO expression by testing the signal name for the string prefix303 * "GPIO".304 *305 * However, some GPIOs are input-only, and the ASPEED datasheets name306 * 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" to312 * account for both GPIOs and GPIs, but in doing so we run aground on313 * another feature:314 *315 * Some pins in the ASPEED BMC SoCs have a "pass-through" GPIO316 * function where the input state of one pin is replicated as the317 * output state of another (as if they were shorted together - a mux318 * configuration that is typically enabled by hardware strapping).319 * This feature allows the BMC to pass e.g. power button state through320 * to the host while the BMC is yet to boot, but take control of the321 * button state once the BMC has booted by muxing each pin as a322 * separate, pin-specific GPIO.323 *324 * Conceptually this pass-through mode is a form of GPIO and is named325 * as such in the datasheets, e.g. "GPID0". This naming similarity326 * trips us up with the simple GPI-prefixed-signal-name scheme327 * discussed above, as the pass-through configuration is not what we328 * 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 on331 * 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 are342 * 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 means353 * differentiate the pass-through GPIO pinmux configuration from the354 * pin-specific configuration that the GPIO subsystem is after: An355 * expression is a pin-specific (non-pass-through) GPIO configuration356 * if the signal prefix is "GPI" and the signal name matches the357 * function name.358 */359 return !strncmp(expr->signal, "GPI", 3) &&360 !strcmp(expr->signal, expr->function);361}362 363static 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 377int 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 the422 * lowest-priority signal type. As such it has no associated423 * 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 only432 * one expression defined to enable the GPIO function433 */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 443int 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 476static 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 482static 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 498enum aspeed_pin_config_map_type { MAP_TYPE_ARG, MAP_TYPE_VAL };499 500static 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 530int 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 else561 arg = 1;562 563 if (!arg)564 return -EINVAL;565 566 *config = pinconf_to_config_packed(param, arg);567 568 return 0;569}570 571int 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 615int 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 635int 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}660