1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Core driver for the S32 CC (Common Chassis) pin controller 4 * 5 * Copyright 2017-2022 NXP 6 * Copyright (C) 2022 SUSE LLC 7 * Copyright 2015-2016 Freescale Semiconductor, Inc. 8 */ 9 10 #include <linux/bitops.h> 11 #include <linux/err.h> 12 #include <linux/gpio/driver.h> 13 #include <linux/init.h> 14 #include <linux/io.h> 15 #include <linux/module.h> 16 #include <linux/of.h> 17 #include <linux/platform_device.h> 18 #include <linux/pinctrl/machine.h> 19 #include <linux/pinctrl/pinconf.h> 20 #include <linux/pinctrl/pinctrl.h> 21 #include <linux/pinctrl/pinmux.h> 22 #include <linux/regmap.h> 23 #include <linux/seq_file.h> 24 #include <linux/slab.h> 25 26 #include "../core.h" 27 #include "../pinconf.h" 28 #include "../pinctrl-utils.h" 29 #include "pinctrl-s32.h" 30 31 #define S32_PIN_ID_SHIFT 4 32 #define S32_PIN_ID_MASK GENMASK(31, S32_PIN_ID_SHIFT) 33 34 #define S32_MSCR_SSS_MASK GENMASK(2, 0) 35 #define S32_MSCR_PUS BIT(12) 36 #define S32_MSCR_PUE BIT(13) 37 #define S32_MSCR_SRE(X) (((X) & GENMASK(3, 0)) << 14) 38 #define S32_MSCR_IBE BIT(19) 39 #define S32_MSCR_ODE BIT(20) 40 #define S32_MSCR_OBE BIT(21) 41 42 static struct regmap_config s32_regmap_config = { 43 .reg_bits = 32, 44 .val_bits = 32, 45 .reg_stride = 4, 46 }; 47 48 static u32 get_pin_no(u32 pinmux) 49 { 50 return (pinmux & S32_PIN_ID_MASK) >> S32_PIN_ID_SHIFT; 51 } 52 53 static u32 get_pin_func(u32 pinmux) 54 { 55 return pinmux & GENMASK(3, 0); 56 } 57 58 struct s32_pinctrl_mem_region { 59 struct regmap *map; 60 const struct s32_pin_range *pin_range; 61 char name[8]; 62 }; 63 64 /* 65 * Holds pin configuration for GPIO's. 66 * @pin_id: Pin ID for this GPIO 67 * @config: Pin settings 68 * @list: Linked list entry for each gpio pin 69 */ 70 struct gpio_pin_config { 71 unsigned int pin_id; 72 unsigned int config; 73 struct list_head list; 74 }; 75 76 /* 77 * Pad config save/restore for power suspend/resume. 78 */ 79 struct s32_pinctrl_context { 80 unsigned int *pads; 81 }; 82 83 /* 84 * @dev: a pointer back to containing device 85 * @pctl: a pointer to the pinctrl device structure 86 * @regions: reserved memory regions with start/end pin 87 * @info: structure containing information about the pin 88 * @gpio_configs: Saved configurations for GPIO pins 89 * @gpiop_configs_lock: lock for the `gpio_configs` list 90 * @s32_pinctrl_context: Configuration saved over system sleep 91 */ 92 struct s32_pinctrl { 93 struct device *dev; 94 struct pinctrl_dev *pctl; 95 struct s32_pinctrl_mem_region *regions; 96 struct s32_pinctrl_soc_info *info; 97 struct list_head gpio_configs; 98 spinlock_t gpio_configs_lock; 99 #ifdef CONFIG_PM_SLEEP 100 struct s32_pinctrl_context saved_context; 101 #endif 102 }; 103 104 static struct s32_pinctrl_mem_region * 105 s32_get_region(struct pinctrl_dev *pctldev, unsigned int pin) 106 { 107 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 108 const struct s32_pin_range *pin_range; 109 unsigned int mem_regions = ipctl->info->soc_data->mem_regions; 110 unsigned int i; 111 112 for (i = 0; i < mem_regions; i++) { 113 pin_range = ipctl->regions[i].pin_range; 114 if (pin >= pin_range->start && pin <= pin_range->end) 115 return &ipctl->regions[i]; 116 } 117 118 return NULL; 119 } 120 121 static inline int s32_check_pin(struct pinctrl_dev *pctldev, 122 unsigned int pin) 123 { 124 return s32_get_region(pctldev, pin) ? 0 : -EINVAL; 125 } 126 127 static inline int s32_regmap_read(struct pinctrl_dev *pctldev, 128 unsigned int pin, unsigned int *val) 129 { 130 struct s32_pinctrl_mem_region *region; 131 unsigned int offset; 132 133 region = s32_get_region(pctldev, pin); 134 if (!region) 135 return -EINVAL; 136 137 offset = (pin - region->pin_range->start) * 138 regmap_get_reg_stride(region->map); 139 140 return regmap_read(region->map, offset, val); 141 } 142 143 static inline int s32_regmap_write(struct pinctrl_dev *pctldev, 144 unsigned int pin, 145 unsigned int val) 146 { 147 struct s32_pinctrl_mem_region *region; 148 unsigned int offset; 149 150 region = s32_get_region(pctldev, pin); 151 if (!region) 152 return -EINVAL; 153 154 offset = (pin - region->pin_range->start) * 155 regmap_get_reg_stride(region->map); 156 157 return regmap_write(region->map, offset, val); 158 159 } 160 161 static inline int s32_regmap_update(struct pinctrl_dev *pctldev, unsigned int pin, 162 unsigned int mask, unsigned int val) 163 { 164 struct s32_pinctrl_mem_region *region; 165 unsigned int offset; 166 167 region = s32_get_region(pctldev, pin); 168 if (!region) 169 return -EINVAL; 170 171 offset = (pin - region->pin_range->start) * 172 regmap_get_reg_stride(region->map); 173 174 return regmap_update_bits(region->map, offset, mask, val); 175 } 176 177 static int s32_get_groups_count(struct pinctrl_dev *pctldev) 178 { 179 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 180 const struct s32_pinctrl_soc_info *info = ipctl->info; 181 182 return info->ngroups; 183 } 184 185 static const char *s32_get_group_name(struct pinctrl_dev *pctldev, 186 unsigned int selector) 187 { 188 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 189 const struct s32_pinctrl_soc_info *info = ipctl->info; 190 191 return info->groups[selector].data.name; 192 } 193 194 static int s32_get_group_pins(struct pinctrl_dev *pctldev, 195 unsigned int selector, const unsigned int **pins, 196 unsigned int *npins) 197 { 198 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 199 const struct s32_pinctrl_soc_info *info = ipctl->info; 200 201 *pins = info->groups[selector].data.pins; 202 *npins = info->groups[selector].data.npins; 203 204 return 0; 205 } 206 207 static void s32_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s, 208 unsigned int offset) 209 { 210 seq_printf(s, "%s", dev_name(pctldev->dev)); 211 } 212 213 static int s32_dt_group_node_to_map(struct pinctrl_dev *pctldev, 214 struct device_node *np, 215 struct pinctrl_map **map, 216 unsigned int *reserved_maps, 217 unsigned int *num_maps, 218 const char *func_name) 219 { 220 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 221 struct device *dev = ipctl->dev; 222 unsigned long *cfgs = NULL; 223 unsigned int n_cfgs, reserve = 1; 224 int n_pins, ret; 225 226 n_pins = of_property_count_elems_of_size(np, "pinmux", sizeof(u32)); 227 if (n_pins < 0) { 228 dev_warn(dev, "Can't find 'pinmux' property in node %pOFn\n", np); 229 } else if (!n_pins) { 230 return -EINVAL; 231 } 232 233 ret = pinconf_generic_parse_dt_config(np, pctldev, &cfgs, &n_cfgs); 234 if (ret) { 235 dev_err(dev, "%pOF: could not parse node property\n", np); 236 return ret; 237 } 238 239 if (n_cfgs) 240 reserve++; 241 242 ret = pinctrl_utils_reserve_map(pctldev, map, reserved_maps, num_maps, 243 reserve); 244 if (ret < 0) 245 goto free_cfgs; 246 247 ret = pinctrl_utils_add_map_mux(pctldev, map, reserved_maps, num_maps, 248 np->name, func_name); 249 if (ret < 0) 250 goto free_cfgs; 251 252 if (n_cfgs) { 253 ret = pinctrl_utils_add_map_configs(pctldev, map, reserved_maps, 254 num_maps, np->name, cfgs, n_cfgs, 255 PIN_MAP_TYPE_CONFIGS_GROUP); 256 if (ret < 0) 257 goto free_cfgs; 258 } 259 260 free_cfgs: 261 kfree(cfgs); 262 return ret; 263 } 264 265 static int s32_dt_node_to_map(struct pinctrl_dev *pctldev, 266 struct device_node *np_config, 267 struct pinctrl_map **map, 268 unsigned int *num_maps) 269 { 270 unsigned int reserved_maps; 271 struct device_node *np; 272 int ret = 0; 273 274 reserved_maps = 0; 275 *map = NULL; 276 *num_maps = 0; 277 278 for_each_available_child_of_node(np_config, np) { 279 ret = s32_dt_group_node_to_map(pctldev, np, map, 280 &reserved_maps, num_maps, 281 np_config->name); 282 if (ret < 0) { 283 of_node_put(np); 284 break; 285 } 286 } 287 288 if (ret) 289 pinctrl_utils_free_map(pctldev, *map, *num_maps); 290 291 return ret; 292 293 } 294 295 static const struct pinctrl_ops s32_pctrl_ops = { 296 .get_groups_count = s32_get_groups_count, 297 .get_group_name = s32_get_group_name, 298 .get_group_pins = s32_get_group_pins, 299 .pin_dbg_show = s32_pin_dbg_show, 300 .dt_node_to_map = s32_dt_node_to_map, 301 .dt_free_map = pinctrl_utils_free_map, 302 }; 303 304 static int s32_pmx_set(struct pinctrl_dev *pctldev, unsigned int selector, 305 unsigned int group) 306 { 307 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 308 const struct s32_pinctrl_soc_info *info = ipctl->info; 309 int i, ret; 310 struct s32_pin_group *grp; 311 312 /* 313 * Configure the mux mode for each pin in the group for a specific 314 * function. 315 */ 316 grp = &info->groups[group]; 317 318 dev_dbg(ipctl->dev, "set mux for function %s group %s\n", 319 info->functions[selector].name, grp->data.name); 320 321 /* Check beforehand so we don't have a partial config. */ 322 for (i = 0; i < grp->data.npins; i++) { 323 if (s32_check_pin(pctldev, grp->data.pins[i]) != 0) { 324 dev_err(info->dev, "invalid pin: %u in group: %u\n", 325 grp->data.pins[i], group); 326 return -EINVAL; 327 } 328 } 329 330 for (i = 0, ret = 0; i < grp->data.npins && !ret; i++) { 331 ret = s32_regmap_update(pctldev, grp->data.pins[i], 332 S32_MSCR_SSS_MASK, grp->pin_sss[i]); 333 if (ret) { 334 dev_err(info->dev, "Failed to set pin %u\n", 335 grp->data.pins[i]); 336 return ret; 337 } 338 } 339 340 return 0; 341 } 342 343 static int s32_pmx_get_funcs_count(struct pinctrl_dev *pctldev) 344 { 345 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 346 const struct s32_pinctrl_soc_info *info = ipctl->info; 347 348 return info->nfunctions; 349 } 350 351 static const char *s32_pmx_get_func_name(struct pinctrl_dev *pctldev, 352 unsigned int selector) 353 { 354 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 355 const struct s32_pinctrl_soc_info *info = ipctl->info; 356 357 return info->functions[selector].name; 358 } 359 360 static int s32_pmx_get_groups(struct pinctrl_dev *pctldev, 361 unsigned int selector, 362 const char * const **groups, 363 unsigned int * const num_groups) 364 { 365 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 366 const struct s32_pinctrl_soc_info *info = ipctl->info; 367 368 *groups = info->functions[selector].groups; 369 *num_groups = info->functions[selector].ngroups; 370 371 return 0; 372 } 373 374 static int s32_pmx_gpio_request_enable(struct pinctrl_dev *pctldev, 375 struct pinctrl_gpio_range *range, 376 unsigned int offset) 377 { 378 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 379 struct gpio_pin_config *gpio_pin; 380 unsigned int config; 381 unsigned long flags; 382 int ret; 383 384 ret = s32_regmap_read(pctldev, offset, &config); 385 if (ret) 386 return ret; 387 388 /* Save current configuration */ 389 gpio_pin = kmalloc(sizeof(*gpio_pin), GFP_KERNEL); 390 if (!gpio_pin) 391 return -ENOMEM; 392 393 gpio_pin->pin_id = offset; 394 gpio_pin->config = config; 395 396 spin_lock_irqsave(&ipctl->gpio_configs_lock, flags); 397 list_add(&gpio_pin->list, &ipctl->gpio_configs); 398 spin_unlock_irqrestore(&ipctl->gpio_configs_lock, flags); 399 400 /* GPIO pin means SSS = 0 */ 401 config &= ~S32_MSCR_SSS_MASK; 402 403 return s32_regmap_write(pctldev, offset, config); 404 } 405 406 static void s32_pmx_gpio_disable_free(struct pinctrl_dev *pctldev, 407 struct pinctrl_gpio_range *range, 408 unsigned int offset) 409 { 410 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 411 struct gpio_pin_config *gpio_pin, *tmp; 412 unsigned long flags; 413 int ret; 414 415 spin_lock_irqsave(&ipctl->gpio_configs_lock, flags); 416 417 list_for_each_entry_safe(gpio_pin, tmp, &ipctl->gpio_configs, list) { 418 if (gpio_pin->pin_id == offset) { 419 ret = s32_regmap_write(pctldev, gpio_pin->pin_id, 420 gpio_pin->config); 421 if (ret != 0) 422 goto unlock; 423 424 list_del(&gpio_pin->list); 425 kfree(gpio_pin); 426 break; 427 } 428 } 429 430 unlock: 431 spin_unlock_irqrestore(&ipctl->gpio_configs_lock, flags); 432 } 433 434 static int s32_pmx_gpio_set_direction(struct pinctrl_dev *pctldev, 435 struct pinctrl_gpio_range *range, 436 unsigned int offset, 437 bool input) 438 { 439 unsigned int config; 440 unsigned int mask = S32_MSCR_IBE | S32_MSCR_OBE; 441 442 if (input) { 443 /* Disable output buffer and enable input buffer */ 444 config = S32_MSCR_IBE; 445 } else { 446 /* Disable input buffer and enable output buffer */ 447 config = S32_MSCR_OBE; 448 } 449 450 return s32_regmap_update(pctldev, offset, mask, config); 451 } 452 453 static const struct pinmux_ops s32_pmx_ops = { 454 .get_functions_count = s32_pmx_get_funcs_count, 455 .get_function_name = s32_pmx_get_func_name, 456 .get_function_groups = s32_pmx_get_groups, 457 .set_mux = s32_pmx_set, 458 .gpio_request_enable = s32_pmx_gpio_request_enable, 459 .gpio_disable_free = s32_pmx_gpio_disable_free, 460 .gpio_set_direction = s32_pmx_gpio_set_direction, 461 }; 462 463 /* Set the reserved elements as -1 */ 464 static const int support_slew[] = {208, -1, -1, -1, 166, 150, 133, 83}; 465 466 static int s32_get_slew_regval(int arg) 467 { 468 unsigned int i; 469 470 /* Translate a real slew rate (MHz) to a register value */ 471 for (i = 0; i < ARRAY_SIZE(support_slew); i++) { 472 if (arg == support_slew[i]) 473 return i; 474 } 475 476 return -EINVAL; 477 } 478 479 static inline void s32_pin_set_pull(enum pin_config_param param, 480 unsigned int *mask, unsigned int *config) 481 { 482 switch (param) { 483 case PIN_CONFIG_BIAS_DISABLE: 484 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: 485 *config &= ~(S32_MSCR_PUS | S32_MSCR_PUE); 486 break; 487 case PIN_CONFIG_BIAS_PULL_UP: 488 *config |= S32_MSCR_PUS | S32_MSCR_PUE; 489 break; 490 case PIN_CONFIG_BIAS_PULL_DOWN: 491 *config &= ~S32_MSCR_PUS; 492 *config |= S32_MSCR_PUE; 493 break; 494 default: 495 return; 496 } 497 498 *mask |= S32_MSCR_PUS | S32_MSCR_PUE; 499 } 500 501 static int s32_parse_pincfg(unsigned long pincfg, unsigned int *mask, 502 unsigned int *config) 503 { 504 enum pin_config_param param; 505 u32 arg; 506 int ret; 507 508 param = pinconf_to_config_param(pincfg); 509 arg = pinconf_to_config_argument(pincfg); 510 511 switch (param) { 512 /* All pins are persistent over suspend */ 513 case PIN_CONFIG_PERSIST_STATE: 514 return 0; 515 case PIN_CONFIG_DRIVE_OPEN_DRAIN: 516 *config |= S32_MSCR_ODE; 517 *mask |= S32_MSCR_ODE; 518 break; 519 case PIN_CONFIG_OUTPUT_ENABLE: 520 if (arg) 521 *config |= S32_MSCR_OBE; 522 else 523 *config &= ~S32_MSCR_OBE; 524 *mask |= S32_MSCR_OBE; 525 break; 526 case PIN_CONFIG_INPUT_ENABLE: 527 if (arg) 528 *config |= S32_MSCR_IBE; 529 else 530 *config &= ~S32_MSCR_IBE; 531 *mask |= S32_MSCR_IBE; 532 break; 533 case PIN_CONFIG_SLEW_RATE: 534 ret = s32_get_slew_regval(arg); 535 if (ret < 0) 536 return ret; 537 *config |= S32_MSCR_SRE((u32)ret); 538 *mask |= S32_MSCR_SRE(~0); 539 break; 540 case PIN_CONFIG_BIAS_DISABLE: 541 case PIN_CONFIG_BIAS_PULL_UP: 542 case PIN_CONFIG_BIAS_PULL_DOWN: 543 s32_pin_set_pull(param, mask, config); 544 break; 545 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: 546 *config &= ~(S32_MSCR_ODE | S32_MSCR_OBE | S32_MSCR_IBE); 547 *mask |= S32_MSCR_ODE | S32_MSCR_OBE | S32_MSCR_IBE; 548 s32_pin_set_pull(param, mask, config); 549 break; 550 default: 551 return -EOPNOTSUPP; 552 } 553 554 return 0; 555 } 556 557 static int s32_pinconf_mscr_update(struct pinctrl_dev *pctldev, 558 unsigned int pin_id, 559 unsigned long *configs, 560 unsigned int num_configs) 561 { 562 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 563 unsigned int config = 0, mask = 0; 564 int i, ret; 565 566 ret = s32_check_pin(pctldev, pin_id); 567 if (ret) 568 return ret; 569 570 dev_dbg(ipctl->dev, "pinconf set pin %s with %u configs\n", 571 pin_get_name(pctldev, pin_id), num_configs); 572 573 for (i = 0; i < num_configs; i++) { 574 ret = s32_parse_pincfg(configs[i], &mask, &config); 575 if (ret) 576 return ret; 577 } 578 579 if (!config && !mask) 580 return 0; 581 582 dev_dbg(ipctl->dev, "update: pin %u cfg 0x%x\n", pin_id, config); 583 584 return s32_regmap_update(pctldev, pin_id, mask, config); 585 } 586 587 static int s32_pinconf_get(struct pinctrl_dev *pctldev, 588 unsigned int pin_id, 589 unsigned long *config) 590 { 591 return s32_regmap_read(pctldev, pin_id, (unsigned int *)config); 592 } 593 594 static int s32_pinconf_set(struct pinctrl_dev *pctldev, 595 unsigned int pin_id, unsigned long *configs, 596 unsigned int num_configs) 597 { 598 return s32_pinconf_mscr_update(pctldev, pin_id, configs, 599 num_configs); 600 } 601 602 static int s32_pconf_group_set(struct pinctrl_dev *pctldev, unsigned int selector, 603 unsigned long *configs, unsigned int num_configs) 604 { 605 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 606 const struct s32_pinctrl_soc_info *info = ipctl->info; 607 struct s32_pin_group *grp; 608 int i, ret; 609 610 grp = &info->groups[selector]; 611 for (i = 0; i < grp->data.npins; i++) { 612 ret = s32_pinconf_mscr_update(pctldev, grp->data.pins[i], 613 configs, num_configs); 614 if (ret) 615 return ret; 616 } 617 618 return 0; 619 } 620 621 static void s32_pinconf_dbg_show(struct pinctrl_dev *pctldev, 622 struct seq_file *s, unsigned int pin_id) 623 { 624 unsigned int config; 625 int ret; 626 627 ret = s32_regmap_read(pctldev, pin_id, &config); 628 if (ret) 629 return; 630 631 seq_printf(s, "0x%x", config); 632 } 633 634 static void s32_pinconf_group_dbg_show(struct pinctrl_dev *pctldev, 635 struct seq_file *s, unsigned int selector) 636 { 637 struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); 638 const struct s32_pinctrl_soc_info *info = ipctl->info; 639 struct s32_pin_group *grp; 640 unsigned int config; 641 const char *name; 642 int i, ret; 643 644 seq_puts(s, "\n"); 645 grp = &info->groups[selector]; 646 for (i = 0; i < grp->data.npins; i++) { 647 name = pin_get_name(pctldev, grp->data.pins[i]); 648 ret = s32_regmap_read(pctldev, grp->data.pins[i], &config); 649 if (ret) 650 return; 651 seq_printf(s, "%s: 0x%x\n", name, config); 652 } 653 } 654 655 static const struct pinconf_ops s32_pinconf_ops = { 656 .pin_config_get = s32_pinconf_get, 657 .pin_config_set = s32_pinconf_set, 658 .pin_config_group_set = s32_pconf_group_set, 659 .pin_config_dbg_show = s32_pinconf_dbg_show, 660 .pin_config_group_dbg_show = s32_pinconf_group_dbg_show, 661 }; 662 663 #ifdef CONFIG_PM_SLEEP 664 static bool s32_pinctrl_should_save(struct s32_pinctrl *ipctl, 665 unsigned int pin) 666 { 667 const struct pin_desc *pd = pin_desc_get(ipctl->pctl, pin); 668 669 if (!pd) 670 return false; 671 672 /* 673 * Only restore the pin if it is actually in use by the kernel (or 674 * by userspace). 675 */ 676 if (pd->mux_owner || pd->gpio_owner) 677 return true; 678 679 return false; 680 } 681 682 int s32_pinctrl_suspend(struct device *dev) 683 { 684 struct platform_device *pdev = to_platform_device(dev); 685 struct s32_pinctrl *ipctl = platform_get_drvdata(pdev); 686 const struct pinctrl_pin_desc *pin; 687 const struct s32_pinctrl_soc_info *info = ipctl->info; 688 struct s32_pinctrl_context *saved_context = &ipctl->saved_context; 689 int i; 690 int ret; 691 unsigned int config; 692 693 for (i = 0; i < info->soc_data->npins; i++) { 694 pin = &info->soc_data->pins[i]; 695 696 if (!s32_pinctrl_should_save(ipctl, pin->number)) 697 continue; 698 699 ret = s32_regmap_read(ipctl->pctl, pin->number, &config); 700 if (ret) 701 return -EINVAL; 702 703 saved_context->pads[i] = config; 704 } 705 706 return 0; 707 } 708 709 int s32_pinctrl_resume(struct device *dev) 710 { 711 struct platform_device *pdev = to_platform_device(dev); 712 struct s32_pinctrl *ipctl = platform_get_drvdata(pdev); 713 const struct s32_pinctrl_soc_info *info = ipctl->info; 714 const struct pinctrl_pin_desc *pin; 715 struct s32_pinctrl_context *saved_context = &ipctl->saved_context; 716 int ret, i; 717 718 for (i = 0; i < info->soc_data->npins; i++) { 719 pin = &info->soc_data->pins[i]; 720 721 if (!s32_pinctrl_should_save(ipctl, pin->number)) 722 continue; 723 724 ret = s32_regmap_write(ipctl->pctl, pin->number, 725 saved_context->pads[i]); 726 if (ret) 727 return ret; 728 } 729 730 return 0; 731 } 732 #endif 733 734 static int s32_pinctrl_parse_groups(struct device_node *np, 735 struct s32_pin_group *grp, 736 struct s32_pinctrl_soc_info *info) 737 { 738 const __be32 *p; 739 struct device *dev; 740 struct property *prop; 741 unsigned int *pins, *sss; 742 int i, npins; 743 u32 pinmux; 744 745 dev = info->dev; 746 747 dev_dbg(dev, "group: %pOFn\n", np); 748 749 /* Initialise group */ 750 grp->data.name = np->name; 751 752 npins = of_property_count_elems_of_size(np, "pinmux", sizeof(u32)); 753 if (npins < 0) { 754 dev_err(dev, "Failed to read 'pinmux' property in node %s.\n", 755 grp->data.name); 756 return -EINVAL; 757 } 758 if (!npins) { 759 dev_err(dev, "The group %s has no pins.\n", grp->data.name); 760 return -EINVAL; 761 } 762 763 grp->data.npins = npins; 764 765 pins = devm_kcalloc(info->dev, npins, sizeof(*pins), GFP_KERNEL); 766 sss = devm_kcalloc(info->dev, npins, sizeof(*sss), GFP_KERNEL); 767 if (!pins || !sss) 768 return -ENOMEM; 769 770 i = 0; 771 of_property_for_each_u32(np, "pinmux", prop, p, pinmux) { 772 pins[i] = get_pin_no(pinmux); 773 sss[i] = get_pin_func(pinmux); 774 775 dev_dbg(info->dev, "pin: 0x%x, sss: 0x%x", pins[i], sss[i]); 776 i++; 777 } 778 779 grp->data.pins = pins; 780 grp->pin_sss = sss; 781 782 return 0; 783 } 784 785 static int s32_pinctrl_parse_functions(struct device_node *np, 786 struct s32_pinctrl_soc_info *info, 787 u32 index) 788 { 789 struct device_node *child; 790 struct pinfunction *func; 791 struct s32_pin_group *grp; 792 const char **groups; 793 u32 i = 0; 794 int ret = 0; 795 796 dev_dbg(info->dev, "parse function(%u): %pOFn\n", index, np); 797 798 func = &info->functions[index]; 799 800 /* Initialise function */ 801 func->name = np->name; 802 func->ngroups = of_get_child_count(np); 803 if (func->ngroups == 0) { 804 dev_err(info->dev, "no groups defined in %pOF\n", np); 805 return -EINVAL; 806 } 807 808 groups = devm_kcalloc(info->dev, func->ngroups, 809 sizeof(*func->groups), GFP_KERNEL); 810 if (!groups) 811 return -ENOMEM; 812 813 for_each_child_of_node(np, child) { 814 groups[i] = child->name; 815 grp = &info->groups[info->grp_index++]; 816 ret = s32_pinctrl_parse_groups(child, grp, info); 817 if (ret) { 818 of_node_put(child); 819 return ret; 820 } 821 i++; 822 } 823 824 func->groups = groups; 825 826 return 0; 827 } 828 829 static int s32_pinctrl_probe_dt(struct platform_device *pdev, 830 struct s32_pinctrl *ipctl) 831 { 832 struct s32_pinctrl_soc_info *info = ipctl->info; 833 struct device_node *np = pdev->dev.of_node; 834 struct device_node *child; 835 struct resource *res; 836 struct regmap *map; 837 void __iomem *base; 838 unsigned int mem_regions = info->soc_data->mem_regions; 839 int ret; 840 u32 nfuncs = 0; 841 u32 i = 0; 842 843 if (!np) 844 return -ENODEV; 845 846 if (mem_regions == 0) { 847 dev_err(&pdev->dev, "mem_regions is 0\n"); 848 return -EINVAL; 849 } 850 851 ipctl->regions = devm_kcalloc(&pdev->dev, mem_regions, 852 sizeof(*ipctl->regions), GFP_KERNEL); 853 if (!ipctl->regions) 854 return -ENOMEM; 855 856 for (i = 0; i < mem_regions; i++) { 857 base = devm_platform_get_and_ioremap_resource(pdev, i, &res); 858 if (IS_ERR(base)) 859 return PTR_ERR(base); 860 861 snprintf(ipctl->regions[i].name, 862 sizeof(ipctl->regions[i].name), "map%u", i); 863 864 s32_regmap_config.name = ipctl->regions[i].name; 865 s32_regmap_config.max_register = resource_size(res) - 866 s32_regmap_config.reg_stride; 867 868 map = devm_regmap_init_mmio(&pdev->dev, base, 869 &s32_regmap_config); 870 if (IS_ERR(map)) { 871 dev_err(&pdev->dev, "Failed to init regmap[%u]\n", i); 872 return PTR_ERR(map); 873 } 874 875 ipctl->regions[i].map = map; 876 ipctl->regions[i].pin_range = &info->soc_data->mem_pin_ranges[i]; 877 } 878 879 nfuncs = of_get_child_count(np); 880 if (nfuncs <= 0) { 881 dev_err(&pdev->dev, "no functions defined\n"); 882 return -EINVAL; 883 } 884 885 info->nfunctions = nfuncs; 886 info->functions = devm_kcalloc(&pdev->dev, nfuncs, 887 sizeof(*info->functions), GFP_KERNEL); 888 if (!info->functions) 889 return -ENOMEM; 890 891 info->ngroups = 0; 892 for_each_child_of_node(np, child) 893 info->ngroups += of_get_child_count(child); 894 895 info->groups = devm_kcalloc(&pdev->dev, info->ngroups, 896 sizeof(*info->groups), GFP_KERNEL); 897 if (!info->groups) 898 return -ENOMEM; 899 900 i = 0; 901 for_each_child_of_node(np, child) { 902 ret = s32_pinctrl_parse_functions(child, info, i++); 903 if (ret) { 904 of_node_put(child); 905 return ret; 906 } 907 } 908 909 return 0; 910 } 911 912 int s32_pinctrl_probe(struct platform_device *pdev, 913 const struct s32_pinctrl_soc_data *soc_data) 914 { 915 struct s32_pinctrl *ipctl; 916 int ret; 917 struct pinctrl_desc *s32_pinctrl_desc; 918 struct s32_pinctrl_soc_info *info; 919 #ifdef CONFIG_PM_SLEEP 920 struct s32_pinctrl_context *saved_context; 921 #endif 922 923 if (!soc_data || !soc_data->pins || !soc_data->npins) { 924 dev_err(&pdev->dev, "wrong pinctrl info\n"); 925 return -EINVAL; 926 } 927 928 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); 929 if (!info) 930 return -ENOMEM; 931 932 info->soc_data = soc_data; 933 info->dev = &pdev->dev; 934 935 /* Create state holders etc for this driver */ 936 ipctl = devm_kzalloc(&pdev->dev, sizeof(*ipctl), GFP_KERNEL); 937 if (!ipctl) 938 return -ENOMEM; 939 940 ipctl->info = info; 941 ipctl->dev = info->dev; 942 platform_set_drvdata(pdev, ipctl); 943 944 INIT_LIST_HEAD(&ipctl->gpio_configs); 945 spin_lock_init(&ipctl->gpio_configs_lock); 946 947 s32_pinctrl_desc = 948 devm_kmalloc(&pdev->dev, sizeof(*s32_pinctrl_desc), GFP_KERNEL); 949 if (!s32_pinctrl_desc) 950 return -ENOMEM; 951 952 s32_pinctrl_desc->name = dev_name(&pdev->dev); 953 s32_pinctrl_desc->pins = info->soc_data->pins; 954 s32_pinctrl_desc->npins = info->soc_data->npins; 955 s32_pinctrl_desc->pctlops = &s32_pctrl_ops; 956 s32_pinctrl_desc->pmxops = &s32_pmx_ops; 957 s32_pinctrl_desc->confops = &s32_pinconf_ops; 958 s32_pinctrl_desc->owner = THIS_MODULE; 959 960 ret = s32_pinctrl_probe_dt(pdev, ipctl); 961 if (ret) { 962 dev_err(&pdev->dev, "fail to probe dt properties\n"); 963 return ret; 964 } 965 966 ipctl->pctl = devm_pinctrl_register(&pdev->dev, s32_pinctrl_desc, 967 ipctl); 968 if (IS_ERR(ipctl->pctl)) 969 return dev_err_probe(&pdev->dev, PTR_ERR(ipctl->pctl), 970 "could not register s32 pinctrl driver\n"); 971 972 #ifdef CONFIG_PM_SLEEP 973 saved_context = &ipctl->saved_context; 974 saved_context->pads = 975 devm_kcalloc(&pdev->dev, info->soc_data->npins, 976 sizeof(*saved_context->pads), 977 GFP_KERNEL); 978 if (!saved_context->pads) 979 return -ENOMEM; 980 #endif 981 982 dev_info(&pdev->dev, "initialized s32 pinctrl driver\n"); 983 984 return 0; 985 } 986