drivers/pinctrl/renesas/pinctrl.c

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