1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * SuperH Pin Function Controller pinmux support. 4 * 5 * Copyright (C) 2012 Paul Mundt 6 */ 7 8 #define DRV_NAME "sh-pfc" 9 10 #include <linux/device.h> 11 #include <linux/err.h> 12 #include <linux/init.h> 13 #include <linux/io.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/pinctrl/consumer.h> 17 #include <linux/pinctrl/machine.h> 18 #include <linux/pinctrl/pinconf.h> 19 #include <linux/pinctrl/pinconf-generic.h> 20 #include <linux/pinctrl/pinctrl.h> 21 #include <linux/pinctrl/pinmux.h> 22 #include <linux/slab.h> 23 #include <linux/spinlock.h> 24 25 #include "core.h" 26 #include "../core.h" 27 #include "../pinconf.h" 28 29 struct sh_pfc_pin_config { 30 u16 gpio_enabled:1; 31 u16 mux_mark:15; 32 }; 33 34 struct sh_pfc_pinctrl { 35 struct pinctrl_dev *pctl; 36 struct pinctrl_desc pctl_desc; 37 38 struct sh_pfc *pfc; 39 40 struct pinctrl_pin_desc *pins; 41 struct sh_pfc_pin_config *configs; 42 43 const char *func_prop_name; 44 const char *groups_prop_name; 45 const char *pins_prop_name; 46 }; 47 48 static int sh_pfc_get_groups_count(struct pinctrl_dev *pctldev) 49 { 50 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 51 52 return pmx->pfc->info->nr_groups; 53 } 54 55 static const char *sh_pfc_get_group_name(struct pinctrl_dev *pctldev, 56 unsigned selector) 57 { 58 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 59 60 return pmx->pfc->info->groups[selector].name; 61 } 62 63 static int sh_pfc_get_group_pins(struct pinctrl_dev *pctldev, unsigned selector, 64 const unsigned **pins, unsigned *num_pins) 65 { 66 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 67 68 *pins = pmx->pfc->info->groups[selector].pins; 69 *num_pins = pmx->pfc->info->groups[selector].nr_pins; 70 71 return 0; 72 } 73 74 static void sh_pfc_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s, 75 unsigned offset) 76 { 77 seq_puts(s, DRV_NAME); 78 } 79 80 #ifdef CONFIG_OF 81 static int sh_pfc_map_add_config(struct pinctrl_map *map, 82 const char *group_or_pin, 83 enum pinctrl_map_type type, 84 unsigned long *configs, 85 unsigned int num_configs) 86 { 87 unsigned long *cfgs; 88 89 cfgs = kmemdup(configs, num_configs * sizeof(*cfgs), 90 GFP_KERNEL); 91 if (cfgs == NULL) 92 return -ENOMEM; 93 94 map->type = type; 95 map->data.configs.group_or_pin = group_or_pin; 96 map->data.configs.configs = cfgs; 97 map->data.configs.num_configs = num_configs; 98 99 return 0; 100 } 101 102 static int sh_pfc_dt_subnode_to_map(struct pinctrl_dev *pctldev, 103 struct device_node *np, 104 struct pinctrl_map **map, 105 unsigned int *num_maps, unsigned int *index) 106 { 107 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 108 struct device *dev = pmx->pfc->dev; 109 struct pinctrl_map *maps = *map; 110 unsigned int nmaps = *num_maps; 111 unsigned int idx = *index; 112 unsigned int num_configs; 113 const char *function = NULL; 114 unsigned long *configs; 115 struct property *prop; 116 unsigned int num_groups; 117 unsigned int num_pins; 118 const char *group; 119 const char *pin; 120 int ret; 121 122 /* Support both the old Renesas-specific properties and the new standard 123 * properties. Mixing old and new properties isn't allowed, neither 124 * inside a subnode nor across subnodes. 125 */ 126 if (!pmx->func_prop_name) { 127 if (of_find_property(np, "groups", NULL) || 128 of_find_property(np, "pins", NULL)) { 129 pmx->func_prop_name = "function"; 130 pmx->groups_prop_name = "groups"; 131 pmx->pins_prop_name = "pins"; 132 } else { 133 pmx->func_prop_name = "renesas,function"; 134 pmx->groups_prop_name = "renesas,groups"; 135 pmx->pins_prop_name = "renesas,pins"; 136 } 137 } 138 139 /* Parse the function and configuration properties. At least a function 140 * or one configuration must be specified. 141 */ 142 ret = of_property_read_string(np, pmx->func_prop_name, &function); 143 if (ret < 0 && ret != -EINVAL) { 144 dev_err(dev, "Invalid function in DT\n"); 145 return ret; 146 } 147 148 ret = pinconf_generic_parse_dt_config(np, NULL, &configs, &num_configs); 149 if (ret < 0) 150 return ret; 151 152 if (!function && num_configs == 0) { 153 dev_err(dev, 154 "DT node must contain at least a function or config\n"); 155 ret = -ENODEV; 156 goto done; 157 } 158 159 /* Count the number of pins and groups and reallocate mappings. */ 160 ret = of_property_count_strings(np, pmx->pins_prop_name); 161 if (ret == -EINVAL) { 162 num_pins = 0; 163 } else if (ret < 0) { 164 dev_err(dev, "Invalid pins list in DT\n"); 165 goto done; 166 } else { 167 num_pins = ret; 168 } 169 170 ret = of_property_count_strings(np, pmx->groups_prop_name); 171 if (ret == -EINVAL) { 172 num_groups = 0; 173 } else if (ret < 0) { 174 dev_err(dev, "Invalid pin groups list in DT\n"); 175 goto done; 176 } else { 177 num_groups = ret; 178 } 179 180 if (!num_pins && !num_groups) { 181 dev_err(dev, "No pin or group provided in DT node\n"); 182 ret = -ENODEV; 183 goto done; 184 } 185 186 if (function) 187 nmaps += num_groups; 188 if (configs) 189 nmaps += num_pins + num_groups; 190 191 maps = krealloc(maps, sizeof(*maps) * nmaps, GFP_KERNEL); 192 if (maps == NULL) { 193 ret = -ENOMEM; 194 goto done; 195 } 196 197 *map = maps; 198 *num_maps = nmaps; 199 200 /* Iterate over pins and groups and create the mappings. */ 201 of_property_for_each_string(np, pmx->groups_prop_name, prop, group) { 202 if (function) { 203 maps[idx].type = PIN_MAP_TYPE_MUX_GROUP; 204 maps[idx].data.mux.group = group; 205 maps[idx].data.mux.function = function; 206 idx++; 207 } 208 209 if (configs) { 210 ret = sh_pfc_map_add_config(&maps[idx], group, 211 PIN_MAP_TYPE_CONFIGS_GROUP, 212 configs, num_configs); 213 if (ret < 0) 214 goto done; 215 216 idx++; 217 } 218 } 219 220 if (!configs) { 221 ret = 0; 222 goto done; 223 } 224 225 of_property_for_each_string(np, pmx->pins_prop_name, prop, pin) { 226 ret = sh_pfc_map_add_config(&maps[idx], pin, 227 PIN_MAP_TYPE_CONFIGS_PIN, 228 configs, num_configs); 229 if (ret < 0) 230 goto done; 231 232 idx++; 233 } 234 235 done: 236 *index = idx; 237 kfree(configs); 238 return ret; 239 } 240 241 static void sh_pfc_dt_free_map(struct pinctrl_dev *pctldev, 242 struct pinctrl_map *map, unsigned num_maps) 243 { 244 unsigned int i; 245 246 if (map == NULL) 247 return; 248 249 for (i = 0; i < num_maps; ++i) { 250 if (map[i].type == PIN_MAP_TYPE_CONFIGS_GROUP || 251 map[i].type == PIN_MAP_TYPE_CONFIGS_PIN) 252 kfree(map[i].data.configs.configs); 253 } 254 255 kfree(map); 256 } 257 258 static int sh_pfc_dt_node_to_map(struct pinctrl_dev *pctldev, 259 struct device_node *np, 260 struct pinctrl_map **map, unsigned *num_maps) 261 { 262 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 263 struct device *dev = pmx->pfc->dev; 264 struct device_node *child; 265 unsigned int index; 266 int ret; 267 268 *map = NULL; 269 *num_maps = 0; 270 index = 0; 271 272 for_each_child_of_node(np, child) { 273 ret = sh_pfc_dt_subnode_to_map(pctldev, child, map, num_maps, 274 &index); 275 if (ret < 0) { 276 of_node_put(child); 277 goto done; 278 } 279 } 280 281 /* If no mapping has been found in child nodes try the config node. */ 282 if (*num_maps == 0) { 283 ret = sh_pfc_dt_subnode_to_map(pctldev, np, map, num_maps, 284 &index); 285 if (ret < 0) 286 goto done; 287 } 288 289 if (*num_maps) 290 return 0; 291 292 dev_err(dev, "no mapping found in node %pOF\n", np); 293 ret = -EINVAL; 294 295 done: 296 if (ret < 0) 297 sh_pfc_dt_free_map(pctldev, *map, *num_maps); 298 299 return ret; 300 } 301 #endif /* CONFIG_OF */ 302 303 static const struct pinctrl_ops sh_pfc_pinctrl_ops = { 304 .get_groups_count = sh_pfc_get_groups_count, 305 .get_group_name = sh_pfc_get_group_name, 306 .get_group_pins = sh_pfc_get_group_pins, 307 .pin_dbg_show = sh_pfc_pin_dbg_show, 308 #ifdef CONFIG_OF 309 .dt_node_to_map = sh_pfc_dt_node_to_map, 310 .dt_free_map = sh_pfc_dt_free_map, 311 #endif 312 }; 313 314 static int sh_pfc_get_functions_count(struct pinctrl_dev *pctldev) 315 { 316 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 317 318 return pmx->pfc->info->nr_functions; 319 } 320 321 static const char *sh_pfc_get_function_name(struct pinctrl_dev *pctldev, 322 unsigned selector) 323 { 324 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 325 326 return pmx->pfc->info->functions[selector].name; 327 } 328 329 static int sh_pfc_get_function_groups(struct pinctrl_dev *pctldev, 330 unsigned selector, 331 const char * const **groups, 332 unsigned * const num_groups) 333 { 334 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 335 336 *groups = pmx->pfc->info->functions[selector].groups; 337 *num_groups = pmx->pfc->info->functions[selector].nr_groups; 338 339 return 0; 340 } 341 342 static int sh_pfc_func_set_mux(struct pinctrl_dev *pctldev, unsigned selector, 343 unsigned group) 344 { 345 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 346 struct sh_pfc *pfc = pmx->pfc; 347 const struct sh_pfc_pin_group *grp = &pfc->info->groups[group]; 348 unsigned long flags; 349 unsigned int i; 350 int ret = 0; 351 352 dev_dbg(pctldev->dev, "Configuring pin group %s\n", grp->name); 353 354 spin_lock_irqsave(&pfc->lock, flags); 355 356 for (i = 0; i < grp->nr_pins; ++i) { 357 int idx = sh_pfc_get_pin_index(pfc, grp->pins[i]); 358 struct sh_pfc_pin_config *cfg = &pmx->configs[idx]; 359 360 /* 361 * This driver cannot manage both gpio and mux when the gpio 362 * pin is already enabled. So, this function fails. 363 */ 364 if (cfg->gpio_enabled) { 365 ret = -EBUSY; 366 goto done; 367 } 368 369 ret = sh_pfc_config_mux(pfc, grp->mux[i], PINMUX_TYPE_FUNCTION); 370 if (ret < 0) 371 goto done; 372 } 373 374 /* All group pins are configured, mark the pins as muxed */ 375 for (i = 0; i < grp->nr_pins; ++i) { 376 int idx = sh_pfc_get_pin_index(pfc, grp->pins[i]); 377 struct sh_pfc_pin_config *cfg = &pmx->configs[idx]; 378 379 cfg->mux_mark = grp->mux[i]; 380 } 381 382 done: 383 spin_unlock_irqrestore(&pfc->lock, flags); 384 return ret; 385 } 386 387 static int sh_pfc_gpio_request_enable(struct pinctrl_dev *pctldev, 388 struct pinctrl_gpio_range *range, 389 unsigned offset) 390 { 391 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 392 struct sh_pfc *pfc = pmx->pfc; 393 int idx = sh_pfc_get_pin_index(pfc, offset); 394 struct sh_pfc_pin_config *cfg = &pmx->configs[idx]; 395 unsigned long flags; 396 int ret; 397 398 spin_lock_irqsave(&pfc->lock, flags); 399 400 if (!pfc->gpio) { 401 /* If GPIOs are handled externally the pin mux type needs to be 402 * set to GPIO here. 403 */ 404 const struct sh_pfc_pin *pin = &pfc->info->pins[idx]; 405 406 ret = sh_pfc_config_mux(pfc, pin->enum_id, PINMUX_TYPE_GPIO); 407 if (ret < 0) 408 goto done; 409 } 410 411 cfg->gpio_enabled = true; 412 413 ret = 0; 414 415 done: 416 spin_unlock_irqrestore(&pfc->lock, flags); 417 418 return ret; 419 } 420 421 static void sh_pfc_gpio_disable_free(struct pinctrl_dev *pctldev, 422 struct pinctrl_gpio_range *range, 423 unsigned offset) 424 { 425 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 426 struct sh_pfc *pfc = pmx->pfc; 427 int idx = sh_pfc_get_pin_index(pfc, offset); 428 struct sh_pfc_pin_config *cfg = &pmx->configs[idx]; 429 unsigned long flags; 430 431 spin_lock_irqsave(&pfc->lock, flags); 432 cfg->gpio_enabled = false; 433 /* If mux is already set, this configures it here */ 434 if (cfg->mux_mark) 435 sh_pfc_config_mux(pfc, cfg->mux_mark, PINMUX_TYPE_FUNCTION); 436 spin_unlock_irqrestore(&pfc->lock, flags); 437 } 438 439 #ifdef CONFIG_PINCTRL_SH_PFC_GPIO 440 static int sh_pfc_gpio_set_direction(struct pinctrl_dev *pctldev, 441 struct pinctrl_gpio_range *range, 442 unsigned offset, bool input) 443 { 444 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 445 struct sh_pfc *pfc = pmx->pfc; 446 int new_type = input ? PINMUX_TYPE_INPUT : PINMUX_TYPE_OUTPUT; 447 int idx = sh_pfc_get_pin_index(pfc, offset); 448 const struct sh_pfc_pin *pin = &pfc->info->pins[idx]; 449 unsigned long flags; 450 unsigned int dir; 451 int ret; 452 453 /* Check if the requested direction is supported by the pin. Not all 454 * SoCs provide pin config data, so perform the check conditionally. 455 */ 456 if (pin->configs) { 457 dir = input ? SH_PFC_PIN_CFG_INPUT : SH_PFC_PIN_CFG_OUTPUT; 458 if (!(pin->configs & dir)) 459 return -EINVAL; 460 } 461 462 spin_lock_irqsave(&pfc->lock, flags); 463 ret = sh_pfc_config_mux(pfc, pin->enum_id, new_type); 464 spin_unlock_irqrestore(&pfc->lock, flags); 465 return ret; 466 } 467 #else 468 #define sh_pfc_gpio_set_direction NULL 469 #endif 470 471 static const struct pinmux_ops sh_pfc_pinmux_ops = { 472 .get_functions_count = sh_pfc_get_functions_count, 473 .get_function_name = sh_pfc_get_function_name, 474 .get_function_groups = sh_pfc_get_function_groups, 475 .set_mux = sh_pfc_func_set_mux, 476 .gpio_request_enable = sh_pfc_gpio_request_enable, 477 .gpio_disable_free = sh_pfc_gpio_disable_free, 478 .gpio_set_direction = sh_pfc_gpio_set_direction, 479 }; 480 481 static u32 sh_pfc_pinconf_find_drive_strength_reg(struct sh_pfc *pfc, 482 unsigned int pin, unsigned int *offset, unsigned int *size) 483 { 484 const struct pinmux_drive_reg_field *field; 485 const struct pinmux_drive_reg *reg; 486 unsigned int i; 487 488 for (reg = pfc->info->drive_regs; reg->reg; ++reg) { 489 for (i = 0; i < ARRAY_SIZE(reg->fields); ++i) { 490 field = ®->fields[i]; 491 492 if (field->size && field->pin == pin) { 493 *offset = field->offset; 494 *size = field->size; 495 496 return reg->reg; 497 } 498 } 499 } 500 501 return 0; 502 } 503 504 static int sh_pfc_pinconf_get_drive_strength(struct sh_pfc *pfc, 505 unsigned int pin) 506 { 507 unsigned long flags; 508 unsigned int offset; 509 unsigned int size; 510 u32 reg; 511 u32 val; 512 513 reg = sh_pfc_pinconf_find_drive_strength_reg(pfc, pin, &offset, &size); 514 if (!reg) 515 return -EINVAL; 516 517 spin_lock_irqsave(&pfc->lock, flags); 518 val = sh_pfc_read(pfc, reg); 519 spin_unlock_irqrestore(&pfc->lock, flags); 520 521 val = (val >> offset) & GENMASK(size - 1, 0); 522 523 /* Convert the value to mA based on a full drive strength value of 24mA. 524 * We can make the full value configurable later if needed. 525 */ 526 return (val + 1) * (size == 2 ? 6 : 3); 527 } 528 529 static int sh_pfc_pinconf_set_drive_strength(struct sh_pfc *pfc, 530 unsigned int pin, u16 strength) 531 { 532 unsigned long flags; 533 unsigned int offset; 534 unsigned int size; 535 unsigned int step; 536 u32 reg; 537 u32 val; 538 539 reg = sh_pfc_pinconf_find_drive_strength_reg(pfc, pin, &offset, &size); 540 if (!reg) 541 return -EINVAL; 542 543 step = size == 2 ? 6 : 3; 544 545 if (strength < step || strength > 24) 546 return -EINVAL; 547 548 /* Convert the value from mA based on a full drive strength value of 549 * 24mA. We can make the full value configurable later if needed. 550 */ 551 strength = strength / step - 1; 552 553 spin_lock_irqsave(&pfc->lock, flags); 554 555 val = sh_pfc_read(pfc, reg); 556 val &= ~GENMASK(offset + size - 1, offset); 557 val |= strength << offset; 558 559 sh_pfc_write(pfc, reg, val); 560 561 spin_unlock_irqrestore(&pfc->lock, flags); 562 563 return 0; 564 } 565 566 /* Check whether the requested parameter is supported for a pin. */ 567 static bool sh_pfc_pinconf_validate(struct sh_pfc *pfc, unsigned int _pin, 568 enum pin_config_param param) 569 { 570 int idx = sh_pfc_get_pin_index(pfc, _pin); 571 const struct sh_pfc_pin *pin = &pfc->info->pins[idx]; 572 573 switch (param) { 574 case PIN_CONFIG_BIAS_DISABLE: 575 return pin->configs & SH_PFC_PIN_CFG_PULL_UP_DOWN; 576 577 case PIN_CONFIG_BIAS_PULL_UP: 578 return pin->configs & SH_PFC_PIN_CFG_PULL_UP; 579 580 case PIN_CONFIG_BIAS_PULL_DOWN: 581 return pin->configs & SH_PFC_PIN_CFG_PULL_DOWN; 582 583 case PIN_CONFIG_DRIVE_STRENGTH: 584 return pin->configs & SH_PFC_PIN_CFG_DRIVE_STRENGTH; 585 586 case PIN_CONFIG_POWER_SOURCE: 587 return pin->configs & SH_PFC_PIN_CFG_IO_VOLTAGE; 588 589 default: 590 return false; 591 } 592 } 593 594 static int sh_pfc_pinconf_get(struct pinctrl_dev *pctldev, unsigned _pin, 595 unsigned long *config) 596 { 597 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 598 struct sh_pfc *pfc = pmx->pfc; 599 enum pin_config_param param = pinconf_to_config_param(*config); 600 unsigned long flags; 601 unsigned int arg; 602 603 if (!sh_pfc_pinconf_validate(pfc, _pin, param)) 604 return -ENOTSUPP; 605 606 switch (param) { 607 case PIN_CONFIG_BIAS_DISABLE: 608 case PIN_CONFIG_BIAS_PULL_UP: 609 case PIN_CONFIG_BIAS_PULL_DOWN: { 610 unsigned int bias; 611 612 if (!pfc->info->ops || !pfc->info->ops->get_bias) 613 return -ENOTSUPP; 614 615 spin_lock_irqsave(&pfc->lock, flags); 616 bias = pfc->info->ops->get_bias(pfc, _pin); 617 spin_unlock_irqrestore(&pfc->lock, flags); 618 619 if (bias != param) 620 return -EINVAL; 621 622 arg = 0; 623 break; 624 } 625 626 case PIN_CONFIG_DRIVE_STRENGTH: { 627 int ret; 628 629 ret = sh_pfc_pinconf_get_drive_strength(pfc, _pin); 630 if (ret < 0) 631 return ret; 632 633 arg = ret; 634 break; 635 } 636 637 case PIN_CONFIG_POWER_SOURCE: { 638 int idx = sh_pfc_get_pin_index(pfc, _pin); 639 const struct sh_pfc_pin *pin = &pfc->info->pins[idx]; 640 unsigned int lower_voltage; 641 u32 pocctrl, val; 642 int bit; 643 644 if (!pfc->info->ops || !pfc->info->ops->pin_to_pocctrl) 645 return -ENOTSUPP; 646 647 bit = pfc->info->ops->pin_to_pocctrl(pfc, _pin, &pocctrl); 648 if (WARN(bit < 0, "invalid pin %#x", _pin)) 649 return bit; 650 651 spin_lock_irqsave(&pfc->lock, flags); 652 val = sh_pfc_read(pfc, pocctrl); 653 spin_unlock_irqrestore(&pfc->lock, flags); 654 655 lower_voltage = (pin->configs & SH_PFC_PIN_VOLTAGE_25_33) ? 656 2500 : 1800; 657 658 arg = (val & BIT(bit)) ? 3300 : lower_voltage; 659 break; 660 } 661 662 default: 663 return -ENOTSUPP; 664 } 665 666 *config = pinconf_to_config_packed(param, arg); 667 return 0; 668 } 669 670 static int sh_pfc_pinconf_set(struct pinctrl_dev *pctldev, unsigned _pin, 671 unsigned long *configs, unsigned num_configs) 672 { 673 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 674 struct sh_pfc *pfc = pmx->pfc; 675 enum pin_config_param param; 676 unsigned long flags; 677 unsigned int i; 678 679 for (i = 0; i < num_configs; i++) { 680 param = pinconf_to_config_param(configs[i]); 681 682 if (!sh_pfc_pinconf_validate(pfc, _pin, param)) 683 return -ENOTSUPP; 684 685 switch (param) { 686 case PIN_CONFIG_BIAS_PULL_UP: 687 case PIN_CONFIG_BIAS_PULL_DOWN: 688 case PIN_CONFIG_BIAS_DISABLE: 689 if (!pfc->info->ops || !pfc->info->ops->set_bias) 690 return -ENOTSUPP; 691 692 spin_lock_irqsave(&pfc->lock, flags); 693 pfc->info->ops->set_bias(pfc, _pin, param); 694 spin_unlock_irqrestore(&pfc->lock, flags); 695 696 break; 697 698 case PIN_CONFIG_DRIVE_STRENGTH: { 699 unsigned int arg = 700 pinconf_to_config_argument(configs[i]); 701 int ret; 702 703 ret = sh_pfc_pinconf_set_drive_strength(pfc, _pin, arg); 704 if (ret < 0) 705 return ret; 706 707 break; 708 } 709 710 case PIN_CONFIG_POWER_SOURCE: { 711 unsigned int mV = pinconf_to_config_argument(configs[i]); 712 int idx = sh_pfc_get_pin_index(pfc, _pin); 713 const struct sh_pfc_pin *pin = &pfc->info->pins[idx]; 714 unsigned int lower_voltage; 715 u32 pocctrl, val; 716 int bit; 717 718 if (!pfc->info->ops || !pfc->info->ops->pin_to_pocctrl) 719 return -ENOTSUPP; 720 721 bit = pfc->info->ops->pin_to_pocctrl(pfc, _pin, &pocctrl); 722 if (WARN(bit < 0, "invalid pin %#x", _pin)) 723 return bit; 724 725 lower_voltage = (pin->configs & SH_PFC_PIN_VOLTAGE_25_33) ? 726 2500 : 1800; 727 728 if (mV != lower_voltage && mV != 3300) 729 return -EINVAL; 730 731 spin_lock_irqsave(&pfc->lock, flags); 732 val = sh_pfc_read(pfc, pocctrl); 733 if (mV == 3300) 734 val |= BIT(bit); 735 else 736 val &= ~BIT(bit); 737 sh_pfc_write(pfc, pocctrl, val); 738 spin_unlock_irqrestore(&pfc->lock, flags); 739 740 break; 741 } 742 743 default: 744 return -ENOTSUPP; 745 } 746 } /* for each config */ 747 748 return 0; 749 } 750 751 static int sh_pfc_pinconf_group_set(struct pinctrl_dev *pctldev, unsigned group, 752 unsigned long *configs, 753 unsigned num_configs) 754 { 755 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 756 const unsigned int *pins; 757 unsigned int num_pins; 758 unsigned int i, ret; 759 760 pins = pmx->pfc->info->groups[group].pins; 761 num_pins = pmx->pfc->info->groups[group].nr_pins; 762 763 for (i = 0; i < num_pins; ++i) { 764 ret = sh_pfc_pinconf_set(pctldev, pins[i], configs, num_configs); 765 if (ret) 766 return ret; 767 } 768 769 return 0; 770 } 771 772 static const struct pinconf_ops sh_pfc_pinconf_ops = { 773 .is_generic = true, 774 .pin_config_get = sh_pfc_pinconf_get, 775 .pin_config_set = sh_pfc_pinconf_set, 776 .pin_config_group_set = sh_pfc_pinconf_group_set, 777 .pin_config_config_dbg_show = pinconf_generic_dump_config, 778 }; 779 780 /* PFC ranges -> pinctrl pin descs */ 781 static int sh_pfc_map_pins(struct sh_pfc *pfc, struct sh_pfc_pinctrl *pmx) 782 { 783 unsigned int i; 784 785 /* Allocate and initialize the pins and configs arrays. */ 786 pmx->pins = devm_kcalloc(pfc->dev, 787 pfc->info->nr_pins, sizeof(*pmx->pins), 788 GFP_KERNEL); 789 if (unlikely(!pmx->pins)) 790 return -ENOMEM; 791 792 pmx->configs = devm_kcalloc(pfc->dev, 793 pfc->info->nr_pins, sizeof(*pmx->configs), 794 GFP_KERNEL); 795 if (unlikely(!pmx->configs)) 796 return -ENOMEM; 797 798 for (i = 0; i < pfc->info->nr_pins; ++i) { 799 const struct sh_pfc_pin *info = &pfc->info->pins[i]; 800 struct pinctrl_pin_desc *pin = &pmx->pins[i]; 801 802 /* If the pin number is equal to -1 all pins are considered */ 803 pin->number = info->pin != (u16)-1 ? info->pin : i; 804 pin->name = info->name; 805 } 806 807 return 0; 808 } 809 810 int sh_pfc_register_pinctrl(struct sh_pfc *pfc) 811 { 812 struct sh_pfc_pinctrl *pmx; 813 int ret; 814 815 pmx = devm_kzalloc(pfc->dev, sizeof(*pmx), GFP_KERNEL); 816 if (unlikely(!pmx)) 817 return -ENOMEM; 818 819 pmx->pfc = pfc; 820 821 ret = sh_pfc_map_pins(pfc, pmx); 822 if (ret < 0) 823 return ret; 824 825 pmx->pctl_desc.name = DRV_NAME; 826 pmx->pctl_desc.owner = THIS_MODULE; 827 pmx->pctl_desc.pctlops = &sh_pfc_pinctrl_ops; 828 pmx->pctl_desc.pmxops = &sh_pfc_pinmux_ops; 829 pmx->pctl_desc.confops = &sh_pfc_pinconf_ops; 830 pmx->pctl_desc.pins = pmx->pins; 831 pmx->pctl_desc.npins = pfc->info->nr_pins; 832 833 ret = devm_pinctrl_register_and_init(pfc->dev, &pmx->pctl_desc, pmx, 834 &pmx->pctl); 835 if (ret) { 836 dev_err(pfc->dev, "could not register: %i\n", ret); 837 838 return ret; 839 } 840 841 return pinctrl_enable(pmx->pctl); 842 } 843 844 const struct pinmux_bias_reg * 845 rcar_pin_to_bias_reg(const struct sh_pfc *pfc, unsigned int pin, 846 unsigned int *bit) 847 { 848 unsigned int i, j; 849 850 for (i = 0; pfc->info->bias_regs[i].puen || pfc->info->bias_regs[i].pud; i++) { 851 for (j = 0; j < ARRAY_SIZE(pfc->info->bias_regs[i].pins); j++) { 852 if (pfc->info->bias_regs[i].pins[j] == pin) { 853 *bit = j; 854 return &pfc->info->bias_regs[i]; 855 } 856 } 857 } 858 859 WARN_ONCE(1, "Pin %u is not in bias info list\n", pin); 860 861 return NULL; 862 } 863 864 unsigned int rcar_pinmux_get_bias(struct sh_pfc *pfc, unsigned int pin) 865 { 866 const struct pinmux_bias_reg *reg; 867 unsigned int bit; 868 869 reg = rcar_pin_to_bias_reg(pfc, pin, &bit); 870 if (!reg) 871 return PIN_CONFIG_BIAS_DISABLE; 872 873 if (reg->puen) { 874 if (!(sh_pfc_read(pfc, reg->puen) & BIT(bit))) 875 return PIN_CONFIG_BIAS_DISABLE; 876 else if (!reg->pud || (sh_pfc_read(pfc, reg->pud) & BIT(bit))) 877 return PIN_CONFIG_BIAS_PULL_UP; 878 else 879 return PIN_CONFIG_BIAS_PULL_DOWN; 880 } else { 881 if (sh_pfc_read(pfc, reg->pud) & BIT(bit)) 882 return PIN_CONFIG_BIAS_PULL_DOWN; 883 else 884 return PIN_CONFIG_BIAS_DISABLE; 885 } 886 } 887 888 void rcar_pinmux_set_bias(struct sh_pfc *pfc, unsigned int pin, 889 unsigned int bias) 890 { 891 const struct pinmux_bias_reg *reg; 892 u32 enable, updown; 893 unsigned int bit; 894 895 reg = rcar_pin_to_bias_reg(pfc, pin, &bit); 896 if (!reg) 897 return; 898 899 if (reg->puen) { 900 enable = sh_pfc_read(pfc, reg->puen) & ~BIT(bit); 901 if (bias != PIN_CONFIG_BIAS_DISABLE) { 902 enable |= BIT(bit); 903 904 if (reg->pud) { 905 updown = sh_pfc_read(pfc, reg->pud) & ~BIT(bit); 906 if (bias == PIN_CONFIG_BIAS_PULL_UP) 907 updown |= BIT(bit); 908 909 sh_pfc_write(pfc, reg->pud, updown); 910 } 911 } 912 sh_pfc_write(pfc, reg->puen, enable); 913 } else { 914 enable = sh_pfc_read(pfc, reg->pud) & ~BIT(bit); 915 if (bias == PIN_CONFIG_BIAS_PULL_DOWN) 916 enable |= BIT(bit); 917 918 sh_pfc_write(pfc, reg->pud, enable); 919 } 920 } 921 922 #define PORTnCR_PULMD_OFF (0 << 6) 923 #define PORTnCR_PULMD_DOWN (2 << 6) 924 #define PORTnCR_PULMD_UP (3 << 6) 925 #define PORTnCR_PULMD_MASK (3 << 6) 926 927 unsigned int rmobile_pinmux_get_bias(struct sh_pfc *pfc, unsigned int pin) 928 { 929 void __iomem *reg = pfc->info->ops->pin_to_portcr(pfc, pin); 930 u32 value = ioread8(reg) & PORTnCR_PULMD_MASK; 931 932 switch (value) { 933 case PORTnCR_PULMD_UP: 934 return PIN_CONFIG_BIAS_PULL_UP; 935 case PORTnCR_PULMD_DOWN: 936 return PIN_CONFIG_BIAS_PULL_DOWN; 937 case PORTnCR_PULMD_OFF: 938 default: 939 return PIN_CONFIG_BIAS_DISABLE; 940 } 941 } 942 943 void rmobile_pinmux_set_bias(struct sh_pfc *pfc, unsigned int pin, 944 unsigned int bias) 945 { 946 void __iomem *reg = pfc->info->ops->pin_to_portcr(pfc, pin); 947 u32 value = ioread8(reg) & ~PORTnCR_PULMD_MASK; 948 949 switch (bias) { 950 case PIN_CONFIG_BIAS_PULL_UP: 951 value |= PORTnCR_PULMD_UP; 952 break; 953 case PIN_CONFIG_BIAS_PULL_DOWN: 954 value |= PORTnCR_PULMD_DOWN; 955 break; 956 } 957 958 iowrite8(value, reg); 959 } 960