drivers/pinctrl/rockchip/pinctrl-rockchip-core.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2019 Rockchip Electronics Co., Ltd
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <dm/pinctrl.h>
   9 #include <regmap.h>
  10 #include <syscon.h>
  11 #include <fdtdec.h>
  12
  13 #include "pinctrl-rockchip.h"
  14
  15 #define MAX_ROCKCHIP_PINS_ENTRIES       30
  16 #define MAX_ROCKCHIP_GPIO_PER_BANK      32
  17 #define RK_FUNC_GPIO                    0
  18
  19 static int rockchip_verify_config(struct udevice *dev, u32 bank, u32 pin)
  20 {
  21         struct rockchip_pinctrl_priv *priv = dev_get_priv(dev);
  22         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
  23
  24         if (bank >= ctrl->nr_banks) {
  25                 debug("pin conf bank %d >= nbanks %d\n", bank, ctrl->nr_banks);
  26                 return -EINVAL;
  27         }
  28
  29         if (pin >= MAX_ROCKCHIP_GPIO_PER_BANK) {
  30                 debug("pin conf pin %d >= %d\n", pin,
  31                       MAX_ROCKCHIP_GPIO_PER_BANK);
  32                 return -EINVAL;
  33         }
  34
  35         return 0;
  36 }
  37
  38 void rockchip_get_recalced_mux(struct rockchip_pin_bank *bank, int pin,
  39                                int *reg, u8 *bit, int *mask)
  40 {
  41         struct rockchip_pinctrl_priv *priv = bank->priv;
  42         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
  43         struct rockchip_mux_recalced_data *data;
  44         int i;
  45
  46         for (i = 0; i < ctrl->niomux_recalced; i++) {
  47                 data = &ctrl->iomux_recalced[i];
  48                 if (data->num == bank->bank_num &&
  49                     data->pin == pin)
  50                         break;
  51         }
  52
  53         if (i >= ctrl->niomux_recalced)
  54                 return;
  55
  56         *reg = data->reg;
  57         *mask = data->mask;
  58         *bit = data->bit;
  59 }
  60
  61 bool rockchip_get_mux_route(struct rockchip_pin_bank *bank, int pin,
  62                             int mux, u32 *reg, u32 *value)
  63 {
  64         struct rockchip_pinctrl_priv *priv = bank->priv;
  65         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
  66         struct rockchip_mux_route_data *data;
  67         int i;
  68
  69         for (i = 0; i < ctrl->niomux_routes; i++) {
  70                 data = &ctrl->iomux_routes[i];
  71                 if (data->bank_num == bank->bank_num &&
  72                     data->pin == pin && data->func == mux)
  73                         break;
  74         }
  75
  76         if (i >= ctrl->niomux_routes)
  77                 return false;
  78
  79         *reg = data->route_offset;
  80         *value = data->route_val;
  81
  82         return true;
  83 }
  84
  85 int rockchip_get_mux_data(int mux_type, int pin, u8 *bit, int *mask)
  86 {
  87         int offset = 0;
  88
  89         if (mux_type & IOMUX_WIDTH_4BIT) {
  90                 if ((pin % 8) >= 4)
  91                         offset = 0x4;
  92                 *bit = (pin % 4) * 4;
  93                 *mask = 0xf;
  94         } else if (mux_type & IOMUX_WIDTH_3BIT) {
  95                 /*
  96                  * pin0 ~ pin4 are at first register, and
  97                  * pin5 ~ pin7 are at second register.
  98                  */
  99                 if ((pin % 8) >= 5)
 100                         offset = 0x4;
 101                 *bit = (pin % 8 % 5) * 3;
 102                 *mask = 0x7;
 103         } else {
 104                 *bit = (pin % 8) * 2;
 105                 *mask = 0x3;
 106         }
 107
 108         return offset;
 109 }
 110
 111 static int rockchip_get_mux(struct rockchip_pin_bank *bank, int pin)
 112 {
 113         struct rockchip_pinctrl_priv *priv = bank->priv;
 114         int iomux_num = (pin / 8);
 115         struct regmap *regmap;
 116         unsigned int val;
 117         int reg, ret, mask, mux_type;
 118         u8 bit;
 119
 120         if (iomux_num > 3)
 121                 return -EINVAL;
 122
 123         if (bank->iomux[iomux_num].type & IOMUX_UNROUTED) {
 124                 debug("pin %d is unrouted\n", pin);
 125                 return -EINVAL;
 126         }
 127
 128         if (bank->iomux[iomux_num].type & IOMUX_GPIO_ONLY)
 129                 return RK_FUNC_GPIO;
 130
 131         regmap = (bank->iomux[iomux_num].type & IOMUX_SOURCE_PMU)
 132                                 ? priv->regmap_pmu : priv->regmap_base;
 133
 134         /* get basic quadrupel of mux registers and the correct reg inside */
 135         mux_type = bank->iomux[iomux_num].type;
 136         reg = bank->iomux[iomux_num].offset;
 137         reg += rockchip_get_mux_data(mux_type, pin, &bit, &mask);
 138
 139         if (bank->recalced_mask & BIT(pin))
 140                 rockchip_get_recalced_mux(bank, pin, &reg, &bit, &mask);
 141
 142         ret = regmap_read(regmap, reg, &val);
 143         if (ret)
 144                 return ret;
 145
 146         return ((val >> bit) & mask);
 147 }
 148
 149 static int rockchip_pinctrl_get_gpio_mux(struct udevice *dev, int banknum,
 150                                          int index)
 151 {       struct rockchip_pinctrl_priv *priv = dev_get_priv(dev);
 152         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
 153
 154         return rockchip_get_mux(&ctrl->pin_banks[banknum], index);
 155 }
 156
 157 static int rockchip_verify_mux(struct rockchip_pin_bank *bank,
 158                                int pin, int mux)
 159 {
 160         int iomux_num = (pin / 8);
 161
 162         if (iomux_num > 3)
 163                 return -EINVAL;
 164
 165         if (bank->iomux[iomux_num].type & IOMUX_UNROUTED) {
 166                 debug("pin %d is unrouted\n", pin);
 167                 return -EINVAL;
 168         }
 169
 170         if (bank->iomux[iomux_num].type & IOMUX_GPIO_ONLY) {
 171                 if (mux != IOMUX_GPIO_ONLY) {
 172                         debug("pin %d only supports a gpio mux\n", pin);
 173                         return -ENOTSUPP;
 174                 }
 175         }
 176
 177         return 0;
 178 }
 179
 180 /*
 181  * Set a new mux function for a pin.
 182  *
 183  * The register is divided into the upper and lower 16 bit. When changing
 184  * a value, the previous register value is not read and changed. Instead
 185  * it seems the changed bits are marked in the upper 16 bit, while the
 186  * changed value gets set in the same offset in the lower 16 bit.
 187  * All pin settings seem to be 2 bit wide in both the upper and lower
 188  * parts.
 189  * @bank: pin bank to change
 190  * @pin: pin to change
 191  * @mux: new mux function to set
 192  */
 193 static int rockchip_set_mux(struct rockchip_pin_bank *bank, int pin, int mux)
 194 {
 195         struct rockchip_pinctrl_priv *priv = bank->priv;
 196         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
 197         int iomux_num = (pin / 8);
 198         int ret;
 199
 200         ret = rockchip_verify_mux(bank, pin, mux);
 201         if (ret < 0)
 202                 return ret;
 203
 204         if (bank->iomux[iomux_num].type & IOMUX_GPIO_ONLY)
 205                 return 0;
 206
 207         debug("setting mux of GPIO%d-%d to %d\n", bank->bank_num, pin, mux);
 208
 209         if (!ctrl->set_mux)
 210                 return -ENOTSUPP;
 211
 212         ret = ctrl->set_mux(bank, pin, mux);
 213
 214         return ret;
 215 }
 216
 217 static int rockchip_perpin_drv_list[DRV_TYPE_MAX][8] = {
 218         { 2, 4, 8, 12, -1, -1, -1, -1 },
 219         { 3, 6, 9, 12, -1, -1, -1, -1 },
 220         { 5, 10, 15, 20, -1, -1, -1, -1 },
 221         { 4, 6, 8, 10, 12, 14, 16, 18 },
 222         { 4, 7, 10, 13, 16, 19, 22, 26 }
 223 };
 224
 225 int rockchip_translate_drive_value(int type, int strength)
 226 {
 227         int i, ret;
 228
 229         ret = -EINVAL;
 230         for (i = 0; i < ARRAY_SIZE(rockchip_perpin_drv_list[type]); i++) {
 231                 if (rockchip_perpin_drv_list[type][i] == strength) {
 232                         ret = i;
 233                         break;
 234                 } else if (rockchip_perpin_drv_list[type][i] < 0) {
 235                         ret = rockchip_perpin_drv_list[type][i];
 236                         break;
 237                 }
 238         }
 239
 240         return ret;
 241 }
 242
 243 static int rockchip_set_drive_perpin(struct rockchip_pin_bank *bank,
 244                                      int pin_num, int strength)
 245 {
 246         struct rockchip_pinctrl_priv *priv = bank->priv;
 247         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
 248
 249         debug("setting drive of GPIO%d-%d to %d\n", bank->bank_num,
 250               pin_num, strength);
 251
 252         if (!ctrl->set_drive)
 253                 return -ENOTSUPP;
 254
 255         return ctrl->set_drive(bank, pin_num, strength);
 256 }
 257
 258 static int rockchip_pull_list[PULL_TYPE_MAX][4] = {
 259         {
 260                 PIN_CONFIG_BIAS_DISABLE,
 261                 PIN_CONFIG_BIAS_PULL_UP,
 262                 PIN_CONFIG_BIAS_PULL_DOWN,
 263                 PIN_CONFIG_BIAS_BUS_HOLD
 264         },
 265         {
 266                 PIN_CONFIG_BIAS_DISABLE,
 267                 PIN_CONFIG_BIAS_PULL_DOWN,
 268                 PIN_CONFIG_BIAS_DISABLE,
 269                 PIN_CONFIG_BIAS_PULL_UP
 270         },
 271 };
 272
 273 static int rockchip_set_pull(struct rockchip_pin_bank *bank,
 274                              int pin_num, int pull)
 275 {
 276         struct rockchip_pinctrl_priv *priv = bank->priv;
 277         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
 278         struct regmap *regmap;
 279         int reg, ret, i, pull_type;
 280         u8 bit;
 281         u32 data;
 282
 283         debug("setting pull of GPIO%d-%d to %d\n", bank->bank_num,
 284               pin_num, pull);
 285
 286         ctrl->pull_calc_reg(bank, pin_num, &regmap, &reg, &bit);
 287
 288         switch (ctrl->type) {
 289         case RK3036:
 290         case RK3128:
 291                 data = BIT(bit + 16);
 292                 if (pull == PIN_CONFIG_BIAS_DISABLE)
 293                         data |= BIT(bit);
 294                 ret = regmap_write(regmap, reg, data);
 295                 break;
 296         case RV1108:
 297         case RK3188:
 298         case RK3288:
 299         case RK3368:
 300         case RK3399:
 301                 pull_type = bank->pull_type[pin_num / 8];
 302                 ret = -EINVAL;
 303                 for (i = 0; i < ARRAY_SIZE(rockchip_pull_list[pull_type]);
 304                         i++) {
 305                         if (rockchip_pull_list[pull_type][i] == pull) {
 306                                 ret = i;
 307                                 break;
 308                         }
 309                 }
 310
 311                 if (ret < 0) {
 312                         debug("unsupported pull setting %d\n", pull);
 313                         return ret;
 314                 }
 315
 316                 /* enable the write to the equivalent lower bits */
 317                 data = ((1 << ROCKCHIP_PULL_BITS_PER_PIN) - 1) << (bit + 16);
 318                 data |= (ret << bit);
 319
 320                 ret = regmap_write(regmap, reg, data);
 321                 break;
 322         default:
 323                 debug("unsupported pinctrl type\n");
 324                 return -EINVAL;
 325         }
 326
 327         return ret;
 328 }
 329
 330 static int rockchip_set_schmitt(struct rockchip_pin_bank *bank,
 331                                 int pin_num, int enable)
 332 {
 333         struct rockchip_pinctrl_priv *priv = bank->priv;
 334         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
 335         struct regmap *regmap;
 336         int reg, ret;
 337         u8 bit;
 338         u32 data;
 339
 340         debug("setting input schmitt of GPIO%d-%d to %d\n", bank->bank_num,
 341               pin_num, enable);
 342
 343         ret = ctrl->schmitt_calc_reg(bank, pin_num, &regmap, &reg, &bit);
 344         if (ret)
 345                 return ret;
 346
 347         /* enable the write to the equivalent lower bits */
 348         data = BIT(bit + 16) | (enable << bit);
 349
 350         return regmap_write(regmap, reg, data);
 351 }
 352
 353 /*
 354  * Pinconf_ops handling
 355  */
 356 static bool rockchip_pinconf_pull_valid(struct rockchip_pin_ctrl *ctrl,
 357                                         unsigned int pull)
 358 {
 359         switch (ctrl->type) {
 360         case RK3036:
 361         case RK3128:
 362                 return (pull == PIN_CONFIG_BIAS_PULL_PIN_DEFAULT ||
 363                         pull == PIN_CONFIG_BIAS_DISABLE);
 364         case RV1108:
 365         case RK3188:
 366         case RK3288:
 367         case RK3368:
 368         case RK3399:
 369                 return (pull != PIN_CONFIG_BIAS_PULL_PIN_DEFAULT);
 370         }
 371
 372         return false;
 373 }
 374
 375 /* set the pin config settings for a specified pin */
 376 static int rockchip_pinconf_set(struct rockchip_pin_bank *bank,
 377                                 u32 pin, u32 param, u32 arg)
 378 {
 379         struct rockchip_pinctrl_priv *priv = bank->priv;
 380         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
 381         int rc;
 382
 383         switch (param) {
 384         case PIN_CONFIG_BIAS_DISABLE:
 385                 rc =  rockchip_set_pull(bank, pin, param);
 386                 if (rc)
 387                         return rc;
 388                 break;
 389
 390         case PIN_CONFIG_BIAS_PULL_UP:
 391         case PIN_CONFIG_BIAS_PULL_DOWN:
 392         case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
 393         case PIN_CONFIG_BIAS_BUS_HOLD:
 394                 if (!rockchip_pinconf_pull_valid(ctrl, param))
 395                         return -ENOTSUPP;
 396
 397                 if (!arg)
 398                         return -EINVAL;
 399
 400                 rc = rockchip_set_pull(bank, pin, param);
 401                 if (rc)
 402                         return rc;
 403                 break;
 404
 405         case PIN_CONFIG_DRIVE_STRENGTH:
 406                 rc = rockchip_set_drive_perpin(bank, pin, arg);
 407                 if (rc < 0)
 408                         return rc;
 409                 break;
 410
 411         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
 412                 if (!ctrl->schmitt_calc_reg)
 413                         return -ENOTSUPP;
 414
 415                 rc = rockchip_set_schmitt(bank, pin, arg);
 416                 if (rc < 0)
 417                         return rc;
 418                 break;
 419
 420         default:
 421                 break;
 422         }
 423
 424         return 0;
 425 }
 426
 427 static const struct pinconf_param rockchip_conf_params[] = {
 428         { "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 },
 429         { "bias-bus-hold", PIN_CONFIG_BIAS_BUS_HOLD, 0 },
 430         { "bias-pull-up", PIN_CONFIG_BIAS_PULL_UP, 1 },
 431         { "bias-pull-down", PIN_CONFIG_BIAS_PULL_DOWN, 1 },
 432         { "bias-pull-pin-default", PIN_CONFIG_BIAS_PULL_PIN_DEFAULT, 1 },
 433         { "drive-strength", PIN_CONFIG_DRIVE_STRENGTH, 0 },
 434         { "input-schmitt-disable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 0 },
 435         { "input-schmitt-enable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 1 },
 436 };
 437
 438 static int rockchip_pinconf_prop_name_to_param(const char *property,
 439                                                u32 *default_value)
 440 {
 441         const struct pinconf_param *p, *end;
 442
 443         p = rockchip_conf_params;
 444         end = p + sizeof(rockchip_conf_params) / sizeof(struct pinconf_param);
 445
 446         /* See if this pctldev supports this parameter */
 447         for (; p < end; p++) {
 448                 if (!strcmp(property, p->property)) {
 449                         *default_value = p->default_value;
 450                         return p->param;
 451                 }
 452         }
 453
 454         *default_value = 0;
 455         return -EPERM;
 456 }
 457
 458 static int rockchip_pinctrl_set_state(struct udevice *dev,
 459                                       struct udevice *config)
 460 {
 461         struct rockchip_pinctrl_priv *priv = dev_get_priv(dev);
 462         struct rockchip_pin_ctrl *ctrl = priv->ctrl;
 463         u32 cells[MAX_ROCKCHIP_PINS_ENTRIES * 4];
 464         u32 bank, pin, mux, conf, arg, default_val;
 465         int ret, count, i;
 466         const char *prop_name;
 467         const void *value;
 468         int prop_len, param;
 469         const u32 *data;
 470         ofnode node;
 471 #ifdef CONFIG_OF_LIVE
 472         const struct device_node *np;
 473         struct property *pp;
 474 #else
 475         int property_offset, pcfg_node;
 476         const void *blob = gd->fdt_blob;
 477 #endif
 478         data = dev_read_prop(config, "rockchip,pins", &count);
 479         if (count < 0) {
 480                 debug("%s: bad array size %d\n", __func__, count);
 481                 return -EINVAL;
 482         }
 483
 484         count /= sizeof(u32);
 485         if (count > MAX_ROCKCHIP_PINS_ENTRIES * 4) {
 486                 debug("%s: unsupported pins array count %d\n",
 487                       __func__, count);
 488                 return -EINVAL;
 489         }
 490
 491         for (i = 0; i < count; i++)
 492                 cells[i] = fdt32_to_cpu(data[i]);
 493
 494         for (i = 0; i < (count >> 2); i++) {
 495                 bank = cells[4 * i + 0];
 496                 pin = cells[4 * i + 1];
 497                 mux = cells[4 * i + 2];
 498                 conf = cells[4 * i + 3];
 499
 500                 ret = rockchip_verify_config(dev, bank, pin);
 501                 if (ret)
 502                         return ret;
 503
 504                 ret = rockchip_set_mux(&ctrl->pin_banks[bank], pin, mux);
 505                 if (ret)
 506                         return ret;
 507
 508                 node = ofnode_get_by_phandle(conf);
 509                 if (!ofnode_valid(node))
 510                         return -ENODEV;
 511 #ifdef CONFIG_OF_LIVE
 512                 np = ofnode_to_np(node);
 513                 for (pp = np->properties; pp; pp = pp->next) {
 514                         prop_name = pp->name;
 515                         prop_len = pp->length;
 516                         value = pp->value;
 517 #else
 518                 pcfg_node = ofnode_to_offset(node);
 519                 fdt_for_each_property_offset(property_offset, blob, pcfg_node) {
 520                         value = fdt_getprop_by_offset(blob, property_offset,
 521                                                       &prop_name, &prop_len);
 522                         if (!value)
 523                                 return -ENOENT;
 524 #endif
 525                         param = rockchip_pinconf_prop_name_to_param(prop_name,
 526                                                                     &default_val);
 527                         if (param < 0)
 528                                 break;
 529
 530                         if (prop_len >= sizeof(fdt32_t))
 531                                 arg = fdt32_to_cpu(*(fdt32_t *)value);
 532                         else
 533                                 arg = default_val;
 534
 535                         ret = rockchip_pinconf_set(&ctrl->pin_banks[bank], pin,
 536                                                    param, arg);
 537                         if (ret) {
 538                                 debug("%s: rockchip_pinconf_set fail: %d\n",
 539                                       __func__, ret);
 540                                 return ret;
 541                         }
 542                 }
 543         }
 544
 545         return 0;
 546 }
 547
 548 const struct pinctrl_ops rockchip_pinctrl_ops = {
 549         .set_state                      = rockchip_pinctrl_set_state,
 550         .get_gpio_mux                   = rockchip_pinctrl_get_gpio_mux,
 551 };
 552
 553 /* retrieve the soc specific data */
 554 static struct rockchip_pin_ctrl *rockchip_pinctrl_get_soc_data(struct udevice *dev)
 555 {
 556         struct rockchip_pinctrl_priv *priv = dev_get_priv(dev);
 557         struct rockchip_pin_ctrl *ctrl =
 558                         (struct rockchip_pin_ctrl *)dev_get_driver_data(dev);
 559         struct rockchip_pin_bank *bank;
 560         int grf_offs, pmu_offs, drv_grf_offs, drv_pmu_offs, i, j;
 561
 562         grf_offs = ctrl->grf_mux_offset;
 563         pmu_offs = ctrl->pmu_mux_offset;
 564         drv_pmu_offs = ctrl->pmu_drv_offset;
 565         drv_grf_offs = ctrl->grf_drv_offset;
 566         bank = ctrl->pin_banks;
 567
 568         for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
 569                 int bank_pins = 0;
 570
 571                 bank->priv = priv;
 572                 bank->pin_base = ctrl->nr_pins;
 573                 ctrl->nr_pins += bank->nr_pins;
 574
 575                 /* calculate iomux and drv offsets */
 576                 for (j = 0; j < 4; j++) {
 577                         struct rockchip_iomux *iom = &bank->iomux[j];
 578                         struct rockchip_drv *drv = &bank->drv[j];
 579                         int inc;
 580
 581                         if (bank_pins >= bank->nr_pins)
 582                                 break;
 583
 584                         /* preset iomux offset value, set new start value */
 585                         if (iom->offset >= 0) {
 586                                 if (iom->type & IOMUX_SOURCE_PMU)
 587                                         pmu_offs = iom->offset;
 588                                 else
 589                                         grf_offs = iom->offset;
 590                         } else { /* set current iomux offset */
 591                                 iom->offset = (iom->type & IOMUX_SOURCE_PMU) ?
 592                                                         pmu_offs : grf_offs;
 593                         }
 594
 595                         /* preset drv offset value, set new start value */
 596                         if (drv->offset >= 0) {
 597                                 if (iom->type & IOMUX_SOURCE_PMU)
 598                                         drv_pmu_offs = drv->offset;
 599                                 else
 600                                         drv_grf_offs = drv->offset;
 601                         } else { /* set current drv offset */
 602                                 drv->offset = (iom->type & IOMUX_SOURCE_PMU) ?
 603                                                 drv_pmu_offs : drv_grf_offs;
 604                         }
 605
 606                         debug("bank %d, iomux %d has iom_offset 0x%x drv_offset 0x%x\n",
 607                               i, j, iom->offset, drv->offset);
 608
 609                         /*
 610                          * Increase offset according to iomux width.
 611                          * 4bit iomux'es are spread over two registers.
 612                          */
 613                         inc = (iom->type & (IOMUX_WIDTH_4BIT |
 614                                             IOMUX_WIDTH_3BIT)) ? 8 : 4;
 615                         if (iom->type & IOMUX_SOURCE_PMU)
 616                                 pmu_offs += inc;
 617                         else
 618                                 grf_offs += inc;
 619
 620                         /*
 621                          * Increase offset according to drv width.
 622                          * 3bit drive-strenth'es are spread over two registers.
 623                          */
 624                         if ((drv->drv_type == DRV_TYPE_IO_1V8_3V0_AUTO) ||
 625                             (drv->drv_type == DRV_TYPE_IO_3V3_ONLY))
 626                                 inc = 8;
 627                         else
 628                                 inc = 4;
 629
 630                         if (iom->type & IOMUX_SOURCE_PMU)
 631                                 drv_pmu_offs += inc;
 632                         else
 633                                 drv_grf_offs += inc;
 634
 635                         bank_pins += 8;
 636                 }
 637
 638                 /* calculate the per-bank recalced_mask */
 639                 for (j = 0; j < ctrl->niomux_recalced; j++) {
 640                         int pin = 0;
 641
 642                         if (ctrl->iomux_recalced[j].num == bank->bank_num) {
 643                                 pin = ctrl->iomux_recalced[j].pin;
 644                                 bank->recalced_mask |= BIT(pin);
 645                         }
 646                 }
 647
 648                 /* calculate the per-bank route_mask */
 649                 for (j = 0; j < ctrl->niomux_routes; j++) {
 650                         int pin = 0;
 651
 652                         if (ctrl->iomux_routes[j].bank_num == bank->bank_num) {
 653                                 pin = ctrl->iomux_routes[j].pin;
 654                                 bank->route_mask |= BIT(pin);
 655                         }
 656                 }
 657         }
 658
 659         return ctrl;
 660 }
 661
 662 int rockchip_pinctrl_probe(struct udevice *dev)
 663 {
 664         struct rockchip_pinctrl_priv *priv = dev_get_priv(dev);
 665         struct rockchip_pin_ctrl *ctrl;
 666         struct udevice *syscon;
 667         struct regmap *regmap;
 668         int ret = 0;
 669
 670         /* get rockchip grf syscon phandle */
 671         ret = uclass_get_device_by_phandle(UCLASS_SYSCON, dev, "rockchip,grf",
 672                                            &syscon);
 673         if (ret) {
 674                 debug("unable to find rockchip,grf syscon device (%d)\n", ret);
 675                 return ret;
 676         }
 677
 678         /* get grf-reg base address */
 679         regmap = syscon_get_regmap(syscon);
 680         if (!regmap) {
 681                 debug("unable to find rockchip grf regmap\n");
 682                 return -ENODEV;
 683         }
 684         priv->regmap_base = regmap;
 685
 686         /* option: get pmu-reg base address */
 687         ret = uclass_get_device_by_phandle(UCLASS_SYSCON, dev, "rockchip,pmu",
 688                                            &syscon);
 689         if (!ret) {
 690                 /* get pmugrf-reg base address */
 691                 regmap = syscon_get_regmap(syscon);
 692                 if (!regmap) {
 693                         debug("unable to find rockchip pmu regmap\n");
 694                         return -ENODEV;
 695                 }
 696                 priv->regmap_pmu = regmap;
 697         }
 698
 699         ctrl = rockchip_pinctrl_get_soc_data(dev);
 700         if (!ctrl) {
 701                 debug("driver data not available\n");
 702                 return -EINVAL;
 703         }
 704
 705         priv->ctrl = ctrl;
 706         return 0;
 707 }