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