drivers/pinctrl/pinctrl-rk3368.c

   1 /*
   2  * Pinctrl driver for Rockchip SoCs
   3  *
   4  * Copyright (c) 2013 MundoReader S.L.
   5  * Author: Heiko Stuebner <heiko@sntech.de>
   6  *
   7  * With some ideas taken from pinctrl-samsung:
   8  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   9  *              http://www.samsung.com
  10  * Copyright (c) 2012 Linaro Ltd
  11  *              http://www.linaro.org
  12  *
  13  * and pinctrl-at91:
  14  * Copyright (C) 2011-2012 Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License version 2 as published
  18  * by the Free Software Foundation.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/io.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/bitops.h>
  31 #include <linux/gpio.h>
  32 #include <linux/of_address.h>
  33 #include <linux/of_irq.h>
  34 #include <linux/pinctrl/machine.h>
  35 #include <linux/pinctrl/pinconf.h>
  36 #include <linux/pinctrl/pinctrl.h>
  37 #include <linux/pinctrl/pinmux.h>
  38 #include <linux/pinctrl/pinconf-generic.h>
  39 #include <linux/irqchip/chained_irq.h>
  40 #include <linux/clk.h>
  41 #include <linux/regmap.h>
  42 #include <linux/mfd/syscon.h>
  43 #include <linux/syscore_ops.h>
  44 #include <dt-bindings/pinctrl/rockchip.h>
  45
  46 #include "core.h"
  47 #include "pinconf.h"
  48
  49
  50 #if 0
  51 #define pinctrl_dbg(dev, format, arg...)            \
  52         dev_printk(KERN_INFO , dev , format , ## arg)
  53 #else
  54 #define pinctrl_dbg(dev, format, arg...)
  55 #endif
  56
  57
  58 /* GPIO control registers */
  59 #define GPIO_SWPORT_DR          0x00
  60 #define GPIO_SWPORT_DDR         0x04
  61 #define GPIO_INTEN              0x30
  62 #define GPIO_INTMASK            0x34
  63 #define GPIO_INTTYPE_LEVEL      0x38
  64 #define GPIO_INT_POLARITY       0x3c
  65 #define GPIO_INT_STATUS         0x40
  66 #define GPIO_INT_RAWSTATUS      0x44
  67 #define GPIO_DEBOUNCE           0x48
  68 #define GPIO_PORTS_EOI          0x4c
  69 #define GPIO_EXT_PORT           0x50
  70 #define GPIO_LS_SYNC            0x60
  71
  72 enum rockchip_pinctrl_type {
  73         RK2928,
  74         RK3066B,
  75         RK3188,
  76         RK3288,
  77         RK3368,
  78 };
  79
  80 /**
  81  * Encode variants of iomux registers into a type variable
  82  */
  83 #define IOMUX_GPIO_ONLY         BIT(0)
  84 #define IOMUX_WIDTH_4BIT        BIT(1)
  85 #define IOMUX_SOURCE_PMU        BIT(2)
  86 #define IOMUX_UNROUTED          BIT(3)
  87
  88 /**
  89  * @type: iomux variant using IOMUX_* constants
  90  * @offset: if initialized to -1 it will be autocalculated, by specifying
  91  *          an initial offset value the relevant source offset can be reset
  92  *          to a new value for autocalculating the following iomux registers.
  93  */
  94 struct rockchip_iomux {
  95         int                             type;
  96         int                             offset;
  97 };
  98
  99 /**
 100  * @reg_base: register base of the gpio bank
 101  * @reg_pull: optional separate register for additional pull settings
 102  * @clk: clock of the gpio bank
 103  * @irq: interrupt of the gpio bank
 104  * @pin_base: first pin number
 105  * @nr_pins: number of pins in this bank
 106  * @name: name of the bank
 107  * @bank_num: number of the bank, to account for holes
 108  * @iomux: array describing the 4 iomux sources of the bank
 109  * @valid: are all necessary informations present
 110  * @of_node: dt node of this bank
 111  * @drvdata: common pinctrl basedata
 112  * @domain: irqdomain of the gpio bank
 113  * @gpio_chip: gpiolib chip
 114  * @grange: gpio range
 115  * @slock: spinlock for the gpio bank
 116  */
 117 struct rockchip_pin_bank {
 118         void __iomem                    *reg_base;
 119         struct regmap                   *regmap_pull;
 120         struct clk                      *clk;
 121         int                             irq;
 122         u32                             pin_base;
 123         u8                              nr_pins;
 124         char                            *name;
 125         u8                              bank_num;
 126         struct rockchip_iomux           iomux[4];
 127         bool                            valid;
 128         struct device_node              *of_node;
 129         struct rockchip_pinctrl         *drvdata;
 130         struct irq_domain               *domain;
 131         struct gpio_chip                gpio_chip;
 132         struct pinctrl_gpio_range       grange;
 133         spinlock_t                      slock;
 134         u32                             toggle_edge_mode;
 135         u32                             suspend_wakeup;
 136         u32                             saved_wakeup;
 137 };
 138
 139 #define PIN_BANK(id, pins, label)                       \
 140         {                                               \
 141                 .bank_num       = id,                   \
 142                 .nr_pins        = pins,                 \
 143                 .name           = label,                \
 144                 .iomux          = {                     \
 145                         { .offset = -1 },               \
 146                         { .offset = -1 },               \
 147                         { .offset = -1 },               \
 148                         { .offset = -1 },               \
 149                 },                                      \
 150         }
 151
 152 #define PIN_BANK_IOMUX_FLAGS(id, pins, label, iom0, iom1, iom2, iom3)   \
 153         {                                                               \
 154                 .bank_num       = id,                                   \
 155                 .nr_pins        = pins,                                 \
 156                 .name           = label,                                \
 157                 .iomux          = {                                     \
 158                         { .type = iom0, .offset = -1 },                 \
 159                         { .type = iom1, .offset = -1 },                 \
 160                         { .type = iom2, .offset = -1 },                 \
 161                         { .type = iom3, .offset = -1 },                 \
 162                 },                                                      \
 163         }
 164
 165 /**
 166  */
 167 struct rockchip_pin_ctrl {
 168         struct rockchip_pin_bank        *pin_banks;
 169         u32                             nr_banks;
 170         u32                             nr_pins;
 171         char                            *label;
 172         enum rockchip_pinctrl_type      type;
 173         int                             grf_mux_offset;
 174         int                             pmu_mux_offset;
 175         void    (*pull_calc_reg)(struct rockchip_pin_bank *bank,
 176                                     int pin_num, struct regmap **regmap,
 177                                     int *reg, u8 *bit);
 178 };
 179
 180 struct rockchip_pin_config {
 181         unsigned int            func;
 182         unsigned long           *configs;
 183         unsigned int            nconfigs;
 184 };
 185
 186 /**
 187  * struct rockchip_pin_group: represent group of pins of a pinmux function.
 188  * @name: name of the pin group, used to lookup the group.
 189  * @pins: the pins included in this group.
 190  * @npins: number of pins included in this group.
 191  * @func: the mux function number to be programmed when selected.
 192  * @configs: the config values to be set for each pin
 193  * @nconfigs: number of configs for each pin
 194  */
 195 struct rockchip_pin_group {
 196         const char                      *name;
 197         unsigned int                    npins;
 198         unsigned int                    *pins;
 199         struct rockchip_pin_config      *data;
 200 };
 201
 202 /**
 203  * struct rockchip_pmx_func: represent a pin function.
 204  * @name: name of the pin function, used to lookup the function.
 205  * @groups: one or more names of pin groups that provide this function.
 206  * @num_groups: number of groups included in @groups.
 207  */
 208 struct rockchip_pmx_func {
 209         const char              *name;
 210         const char              **groups;
 211         u8                      ngroups;
 212 };
 213
 214 struct rockchip_pinctrl {
 215         struct regmap                   *regmap_base;
 216         int                             reg_size;
 217         struct regmap                   *regmap_pull;
 218         struct regmap                   *regmap_pmu;
 219         struct device                   *dev;
 220         struct rockchip_pin_ctrl        *ctrl;
 221         struct pinctrl_desc             pctl;
 222         struct pinctrl_dev              *pctl_dev;
 223         struct rockchip_pin_group       *groups;
 224         unsigned int                    ngroups;
 225         struct rockchip_pmx_func        *functions;
 226         unsigned int                    nfunctions;
 227 };
 228
 229 static struct regmap_config rockchip_regmap_config = {
 230         .reg_bits = 32,
 231         .val_bits = 32,
 232         .reg_stride = 4,
 233 };
 234 static struct rockchip_pinctrl *g_info;
 235
 236 static inline struct rockchip_pin_bank *gc_to_pin_bank(struct gpio_chip *gc)
 237 {
 238         return container_of(gc, struct rockchip_pin_bank, gpio_chip);
 239 }
 240
 241 static const inline struct rockchip_pin_group *pinctrl_name_to_group(
 242                                         const struct rockchip_pinctrl *info,
 243                                         const char *name)
 244 {
 245         int i;
 246
 247         for (i = 0; i < info->ngroups; i++) {
 248                 if (!strcmp(info->groups[i].name, name))
 249                         return &info->groups[i];
 250         }
 251
 252         return NULL;
 253 }
 254
 255 /*
 256  * given a pin number that is local to a pin controller, find out the pin bank
 257  * and the register base of the pin bank.
 258  */
 259 static struct rockchip_pin_bank *pin_to_bank(struct rockchip_pinctrl *info,
 260                                                                 unsigned pin)
 261 {
 262         struct rockchip_pin_bank *b = info->ctrl->pin_banks;
 263
 264         while (pin >= (b->pin_base + b->nr_pins))
 265                 b++;
 266
 267         return b;
 268 }
 269
 270 static struct rockchip_pin_bank *bank_num_to_bank(
 271                                         struct rockchip_pinctrl *info,
 272                                         unsigned num)
 273 {
 274         struct rockchip_pin_bank *b = info->ctrl->pin_banks;
 275         int i;
 276
 277         for (i = 0; i < info->ctrl->nr_banks; i++, b++) {
 278                 if (b->bank_num == num)
 279                         return b;
 280         }
 281
 282         return ERR_PTR(-EINVAL);
 283 }
 284
 285 /*
 286  * Pinctrl_ops handling
 287  */
 288
 289 static int rockchip_get_groups_count(struct pinctrl_dev *pctldev)
 290 {
 291         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 292
 293         return info->ngroups;
 294 }
 295
 296 static const char *rockchip_get_group_name(struct pinctrl_dev *pctldev,
 297                                                         unsigned selector)
 298 {
 299         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 300
 301         return info->groups[selector].name;
 302 }
 303
 304 static int rockchip_get_group_pins(struct pinctrl_dev *pctldev,
 305                                       unsigned selector, const unsigned **pins,
 306                                       unsigned *npins)
 307 {
 308         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 309
 310         if (selector >= info->ngroups)
 311                 return -EINVAL;
 312
 313         *pins = info->groups[selector].pins;
 314         *npins = info->groups[selector].npins;
 315
 316         return 0;
 317 }
 318
 319 static int rockchip_dt_node_to_map(struct pinctrl_dev *pctldev,
 320                                  struct device_node *np,
 321                                  struct pinctrl_map **map, unsigned *num_maps)
 322 {
 323         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 324         const struct rockchip_pin_group *grp;
 325         struct pinctrl_map *new_map;
 326         struct device_node *parent;
 327         int map_num = 1;
 328         int i;
 329
 330         /*
 331          * first find the group of this node and check if we need to create
 332          * config maps for pins
 333          */
 334         grp = pinctrl_name_to_group(info, np->name);
 335         if (!grp) {
 336                 dev_err(info->dev, "unable to find group for node %s\n",
 337                         np->name);
 338                 return -EINVAL;
 339         }
 340
 341         map_num += grp->npins;
 342         new_map = devm_kzalloc(pctldev->dev, sizeof(*new_map) * map_num,
 343                                                                 GFP_KERNEL);
 344         if (!new_map)
 345                 return -ENOMEM;
 346
 347         *map = new_map;
 348         *num_maps = map_num;
 349
 350         /* create mux map */
 351         parent = of_get_parent(np);
 352         if (!parent) {
 353                 devm_kfree(pctldev->dev, new_map);
 354                 return -EINVAL;
 355         }
 356         new_map[0].type = PIN_MAP_TYPE_MUX_GROUP;
 357         new_map[0].data.mux.function = parent->name;
 358         new_map[0].data.mux.group = np->name;
 359         of_node_put(parent);
 360
 361         /* create config map */
 362         new_map++;
 363         for (i = 0; i < grp->npins; i++) {
 364                 new_map[i].type = PIN_MAP_TYPE_CONFIGS_PIN;
 365                 new_map[i].data.configs.group_or_pin =
 366                                 pin_get_name(pctldev, grp->pins[i]);
 367                 new_map[i].data.configs.configs = grp->data[i].configs;
 368                 new_map[i].data.configs.num_configs = grp->data[i].nconfigs;
 369         }
 370
 371         pinctrl_dbg(pctldev->dev, "maps: function %s group %s num %d\n",
 372                 (*map)->data.mux.function, (*map)->data.mux.group, map_num);
 373
 374         return 0;
 375 }
 376
 377 static void rockchip_dt_free_map(struct pinctrl_dev *pctldev,
 378                                     struct pinctrl_map *map, unsigned num_maps)
 379 {
 380 }
 381
 382 static const struct pinctrl_ops rockchip_pctrl_ops = {
 383         .get_groups_count       = rockchip_get_groups_count,
 384         .get_group_name         = rockchip_get_group_name,
 385         .get_group_pins         = rockchip_get_group_pins,
 386         .dt_node_to_map         = rockchip_dt_node_to_map,
 387         .dt_free_map            = rockchip_dt_free_map,
 388 };
 389
 390 /*
 391  * Hardware access
 392  */
 393
 394 static int rockchip_get_mux(struct rockchip_pin_bank *bank, int pin)
 395 {
 396         struct rockchip_pinctrl *info = bank->drvdata;
 397         int iomux_num = (pin / 8);
 398         struct regmap *regmap;
 399         unsigned int val;
 400         int reg, ret, mask;
 401         u8 bit;
 402
 403         if (iomux_num > 3)
 404                 return -EINVAL;
 405
 406         if (bank->iomux[iomux_num].type & IOMUX_UNROUTED) {
 407                 dev_err(info->dev, "pin %d is unrouted\n", pin);
 408                 return -EINVAL;
 409         }
 410
 411         if (bank->iomux[iomux_num].type & IOMUX_GPIO_ONLY)
 412                 return RK_FUNC_GPIO;
 413
 414         regmap = (bank->iomux[iomux_num].type & IOMUX_SOURCE_PMU)
 415                                 ? info->regmap_pmu : info->regmap_base;
 416
 417         /* get basic quadrupel of mux registers and the correct reg inside */
 418         mask = (bank->iomux[iomux_num].type & IOMUX_WIDTH_4BIT) ? 0xf : 0x3;
 419         reg = bank->iomux[iomux_num].offset;
 420         if (bank->iomux[iomux_num].type & IOMUX_WIDTH_4BIT) {
 421                 if ((pin % 8) >= 4)
 422                         reg += 0x4;
 423                 bit = (pin % 4) * 4;
 424         } else {
 425                 bit = (pin % 8) * 2;
 426         }
 427
 428         ret = regmap_read(regmap, reg, &val);
 429         if (ret)
 430                 return ret;
 431
 432         return ((val >> bit) & mask);
 433 }
 434
 435 /*
 436  * Set a new mux function for a pin.
 437  *
 438  * The register is divided into the upper and lower 16 bit. When changing
 439  * a value, the previous register value is not read and changed. Instead
 440  * it seems the changed bits are marked in the upper 16 bit, while the
 441  * changed value gets set in the same offset in the lower 16 bit.
 442  * All pin settings seem to be 2 bit wide in both the upper and lower
 443  * parts.
 444  * @bank: pin bank to change
 445  * @pin: pin to change
 446  * @mux: new mux function to set
 447  */
 448 static int rockchip_set_mux(struct rockchip_pin_bank *bank, int pin, int mux)
 449 {
 450         struct rockchip_pinctrl *info = bank->drvdata;
 451         int iomux_num = (pin / 8);
 452         struct regmap *regmap;
 453         int reg, ret, mask;
 454         unsigned long flags;
 455         u8 bit;
 456         u32 data, rmask;
 457
 458         if (iomux_num > 3)
 459                 return -EINVAL;
 460
 461         if (bank->iomux[iomux_num].type & IOMUX_UNROUTED) {
 462                 dev_err(info->dev, "pin %d is unrouted\n", pin);
 463                 return -EINVAL;
 464         }
 465
 466         if (bank->iomux[iomux_num].type & IOMUX_GPIO_ONLY) {
 467                 if (mux != RK_FUNC_GPIO) {
 468                         dev_err(info->dev,
 469                                 "pin %d only supports a gpio mux\n", pin);
 470                         return -ENOTSUPP;
 471                 } else {
 472                         return 0;
 473                 }
 474         }
 475
 476         pinctrl_dbg(info->dev, "setting mux of GPIO%d-%d to %d\n",
 477                                                 bank->bank_num, pin, mux);
 478
 479         regmap = (bank->iomux[iomux_num].type & IOMUX_SOURCE_PMU)
 480                                 ? info->regmap_pmu : info->regmap_base;
 481
 482         /* get basic quadrupel of mux registers and the correct reg inside */
 483         mask = (bank->iomux[iomux_num].type & IOMUX_WIDTH_4BIT) ? 0xf : 0x3;
 484         reg = bank->iomux[iomux_num].offset;
 485         if (bank->iomux[iomux_num].type & IOMUX_WIDTH_4BIT) {
 486                 if ((pin % 8) >= 4)
 487                         reg += 0x4;
 488                 bit = (pin % 4) * 4;
 489         } else {
 490                 bit = (pin % 8) * 2;
 491         }
 492
 493         spin_lock_irqsave(&bank->slock, flags);
 494
 495         data = (mask << (bit + 16));
 496         rmask = data | (data >> 16);
 497         data |= (mux & mask) << bit;
 498         ret = regmap_update_bits(regmap, reg, rmask, data);
 499
 500         spin_unlock_irqrestore(&bank->slock, flags);
 501
 502         return ret;
 503 }
 504
 505 #define RK2928_PULL_OFFSET              0x118
 506 #define RK2928_PULL_PINS_PER_REG        16
 507 #define RK2928_PULL_BANK_STRIDE         8
 508
 509 static void rk2928_calc_pull_reg_and_bit(struct rockchip_pin_bank *bank,
 510                                     int pin_num, struct regmap **regmap,
 511                                     int *reg, u8 *bit)
 512 {
 513         struct rockchip_pinctrl *info = bank->drvdata;
 514
 515         *regmap = info->regmap_base;
 516         *reg = RK2928_PULL_OFFSET;
 517         *reg += bank->bank_num * RK2928_PULL_BANK_STRIDE;
 518         *reg += (pin_num / RK2928_PULL_PINS_PER_REG) * 4;
 519
 520         *bit = pin_num % RK2928_PULL_PINS_PER_REG;
 521 };
 522
 523 #define RK3188_PULL_OFFSET              0x164
 524 #define RK3188_PULL_BITS_PER_PIN        2
 525 #define RK3188_PULL_PINS_PER_REG        8
 526 #define RK3188_PULL_BANK_STRIDE         16
 527 #define RK3188_PULL_PMU_OFFSET          0x64
 528
 529 static void rk3188_calc_pull_reg_and_bit(struct rockchip_pin_bank *bank,
 530                                     int pin_num, struct regmap **regmap,
 531                                     int *reg, u8 *bit)
 532 {
 533         struct rockchip_pinctrl *info = bank->drvdata;
 534
 535         /* The first 12 pins of the first bank are located elsewhere */
 536         if (bank->bank_num == 0 && pin_num < 12) {
 537                 *regmap = info->regmap_pmu ? info->regmap_pmu
 538                                            : bank->regmap_pull;
 539                 *reg = info->regmap_pmu ? RK3188_PULL_PMU_OFFSET : 0;
 540                 *reg += ((pin_num / RK3188_PULL_PINS_PER_REG) * 4);
 541                 *bit = pin_num % RK3188_PULL_PINS_PER_REG;
 542                 *bit *= RK3188_PULL_BITS_PER_PIN;
 543         } else {
 544                 *regmap = info->regmap_pull ? info->regmap_pull
 545                                             : info->regmap_base;
 546                 *reg = info->regmap_pull ? 0 : RK3188_PULL_OFFSET;
 547
 548                 /* correct the offset, as it is the 2nd pull register */
 549                 *reg -= 4;
 550                 *reg += bank->bank_num * RK3188_PULL_BANK_STRIDE;
 551                 *reg += ((pin_num / RK3188_PULL_PINS_PER_REG) * 4);
 552
 553                 /*
 554                  * The bits in these registers have an inverse ordering
 555                  * with the lowest pin being in bits 15:14 and the highest
 556                  * pin in bits 1:0
 557                  */
 558                 *bit = 7 - (pin_num % RK3188_PULL_PINS_PER_REG);
 559                 *bit *= RK3188_PULL_BITS_PER_PIN;
 560         }
 561 }
 562
 563 #define RK3288_PULL_OFFSET              0x140
 564 #define RK3368_PULL_PMU_OFFSET 0x10
 565 #define RK3368_PULL_OFFSET              0x100
 566
 567 static void rk3288_calc_pull_reg_and_bit(struct rockchip_pin_bank *bank,
 568                                     int pin_num, struct regmap **regmap,
 569                                     int *reg, u8 *bit)
 570 {
 571         struct rockchip_pinctrl *info = bank->drvdata;
 572         struct rockchip_pin_ctrl *ctrl = info->ctrl;
 573
 574         /* The first 24 pins of the first bank are located in PMU */
 575         if (bank->bank_num == 0) {
 576                 *regmap = info->regmap_pmu;
 577                 if(ctrl->type == RK3288)
 578                         *reg = RK3188_PULL_PMU_OFFSET;
 579                 else if (ctrl->type == RK3368)
 580                         *reg = RK3368_PULL_PMU_OFFSET;
 581
 582                 *reg += ((pin_num / RK3188_PULL_PINS_PER_REG) * 4);
 583                 *bit = pin_num % RK3188_PULL_PINS_PER_REG;
 584                 *bit *= RK3188_PULL_BITS_PER_PIN;
 585         } else {
 586                 *regmap = info->regmap_base;
 587                 if(ctrl->type == RK3288)
 588                         *reg = RK3288_PULL_OFFSET;
 589                 else if (ctrl->type == RK3368)
 590                         *reg = RK3368_PULL_OFFSET;
 591
 592                 /* correct the offset, as we're starting with the 2nd bank */
 593                 *reg -= 0x10;
 594                 *reg += bank->bank_num * RK3188_PULL_BANK_STRIDE;
 595                 *reg += ((pin_num / RK3188_PULL_PINS_PER_REG) * 4);
 596
 597                 *bit = (pin_num % RK3188_PULL_PINS_PER_REG);
 598                 *bit *= RK3188_PULL_BITS_PER_PIN;
 599         }
 600 }
 601
 602 #define RK3288_DRV_PMU_OFFSET           0x70
 603 #define RK3288_DRV_GRF_OFFSET           0x1c0
 604 #define RK3288_DRV_BITS_PER_PIN         2
 605 #define RK3288_DRV_PINS_PER_REG         8
 606 #define RK3288_DRV_BANK_STRIDE          16
 607 static int rk3288_drv_list[] = { 2, 4, 8, 12 };
 608
 609 #define RK3368_DRV_PMU_OFFSET           0x20
 610 #define RK3368_DRV_GRF_OFFSET           0x200
 611
 612
 613 static void rk3288_calc_drv_reg_and_bit(struct rockchip_pin_bank *bank,
 614                                     int pin_num, struct regmap **regmap,
 615                                     int *reg, u8 *bit)
 616 {
 617         struct rockchip_pinctrl *info = bank->drvdata;
 618         struct rockchip_pin_ctrl *ctrl = info->ctrl;
 619
 620         /* The first 24 pins of the first bank are located in PMU */
 621         if (bank->bank_num == 0) {
 622                 *regmap = info->regmap_pmu;
 623                 if(ctrl->type == RK3288)
 624                         *reg = RK3288_DRV_PMU_OFFSET;
 625                 else if (ctrl->type == RK3368)
 626                         *reg = RK3368_DRV_PMU_OFFSET;
 627
 628                 *reg += ((pin_num / RK3288_DRV_PINS_PER_REG) * 4);
 629                 *bit = pin_num % RK3288_DRV_PINS_PER_REG;
 630                 *bit *= RK3288_DRV_BITS_PER_PIN;
 631         } else {
 632                 *regmap = info->regmap_base;
 633                 if(ctrl->type == RK3288)
 634                         *reg = RK3288_DRV_GRF_OFFSET;
 635                 else if (ctrl->type == RK3368)
 636                         *reg = RK3368_DRV_GRF_OFFSET;
 637
 638
 639                 /* correct the offset, as we're starting with the 2nd bank */
 640                 *reg -= 0x10;
 641                 *reg += bank->bank_num * RK3288_DRV_BANK_STRIDE;
 642                 *reg += ((pin_num / RK3288_DRV_PINS_PER_REG) * 4);
 643
 644                 *bit = (pin_num % RK3288_DRV_PINS_PER_REG);
 645                 *bit *= RK3288_DRV_BITS_PER_PIN;
 646         }
 647 }
 648
 649 static int rk3288_get_drive(struct rockchip_pin_bank *bank, int pin_num)
 650 {
 651         struct regmap *regmap;
 652         int reg, ret;
 653         u32 data;
 654         u8 bit;
 655
 656         rk3288_calc_drv_reg_and_bit(bank, pin_num, &regmap, &reg, &bit);
 657
 658         ret = regmap_read(regmap, reg, &data);
 659         if (ret)
 660                 return ret;
 661
 662         data >>= bit;
 663         data &= (1 << RK3288_DRV_BITS_PER_PIN) - 1;
 664
 665         return rk3288_drv_list[data];
 666 }
 667
 668 static int rk3288_set_drive(struct rockchip_pin_bank *bank, int pin_num,
 669                             int strength)
 670 {
 671         struct rockchip_pinctrl *info = bank->drvdata;
 672         struct regmap *regmap;
 673         unsigned long flags;
 674         int reg, ret, i;
 675         u32 data, rmask;
 676         u8 bit;
 677
 678         rk3288_calc_drv_reg_and_bit(bank, pin_num, &regmap, &reg, &bit);
 679
 680         ret = -EINVAL;
 681         for (i = 0; i < ARRAY_SIZE(rk3288_drv_list); i++) {
 682                 if (rk3288_drv_list[i] == strength) {
 683                         ret = i;
 684                         break;
 685                 }
 686         }
 687
 688         if (ret < 0) {
 689                 dev_err(info->dev, "unsupported driver strength %d\n",
 690                         strength);
 691                 return ret;
 692         }
 693
 694         spin_lock_irqsave(&bank->slock, flags);
 695
 696         /* enable the write to the equivalent lower bits */
 697         data = ((1 << RK3288_DRV_BITS_PER_PIN) - 1) << (bit + 16);
 698         rmask = data | (data >> 16);
 699         data |= (ret << bit);
 700
 701         ret = regmap_update_bits(regmap, reg, rmask, data);
 702         spin_unlock_irqrestore(&bank->slock, flags);
 703
 704         return ret;
 705 }
 706
 707 static int rockchip_get_pull(struct rockchip_pin_bank *bank, int pin_num)
 708 {
 709         struct rockchip_pinctrl *info = bank->drvdata;
 710         struct rockchip_pin_ctrl *ctrl = info->ctrl;
 711         struct regmap *regmap;
 712         int reg, ret;
 713         u8 bit;
 714         u32 data;
 715
 716         /* rk3066b does support any pulls */
 717         if (ctrl->type == RK3066B)
 718                 return PIN_CONFIG_BIAS_DISABLE;
 719
 720         ctrl->pull_calc_reg(bank, pin_num, &regmap, &reg, &bit);
 721
 722         ret = regmap_read(regmap, reg, &data);
 723         if (ret)
 724                 return ret;
 725
 726         switch (ctrl->type) {
 727         case RK2928:
 728                 return !(data & BIT(bit))
 729                                 ? PIN_CONFIG_BIAS_PULL_PIN_DEFAULT
 730                                 : PIN_CONFIG_BIAS_DISABLE;
 731         case RK3188:
 732         case RK3288:
 733         case RK3368:
 734                 data >>= bit;
 735                 data &= (1 << RK3188_PULL_BITS_PER_PIN) - 1;
 736
 737                 switch (data) {
 738                 case 0:
 739                         return PIN_CONFIG_BIAS_DISABLE;
 740                 case 1:
 741                         return PIN_CONFIG_BIAS_PULL_UP;
 742                 case 2:
 743                         return PIN_CONFIG_BIAS_PULL_DOWN;
 744                 case 3:
 745                         return PIN_CONFIG_BIAS_BUS_HOLD;
 746                 }
 747
 748                 dev_err(info->dev, "unknown pull setting\n");
 749                 return -EIO;
 750         default:
 751                 dev_err(info->dev, "unsupported pinctrl type\n");
 752                 return -EINVAL;
 753         };
 754 }
 755
 756 static int rockchip_set_pull(struct rockchip_pin_bank *bank,
 757                                         int pin_num, int pull)
 758 {
 759         struct rockchip_pinctrl *info = bank->drvdata;
 760         struct rockchip_pin_ctrl *ctrl = info->ctrl;
 761         struct regmap *regmap;
 762         int reg, ret;
 763         unsigned long flags;
 764         u8 bit;
 765         u32 data, rmask;
 766
 767         pinctrl_dbg(info->dev, "setting pull of GPIO%d-%d to %d\n",
 768                  bank->bank_num, pin_num, pull);
 769
 770         /* rk3066b does support any pulls */
 771         if (ctrl->type == RK3066B)
 772                 return pull ? -EINVAL : 0;
 773
 774         ctrl->pull_calc_reg(bank, pin_num, &regmap, &reg, &bit);
 775
 776         switch (ctrl->type) {
 777         case RK2928:
 778                 spin_lock_irqsave(&bank->slock, flags);
 779
 780                 data = BIT(bit + 16);
 781                 if (pull == PIN_CONFIG_BIAS_DISABLE)
 782                         data |= BIT(bit);
 783                 ret = regmap_write(regmap, reg, data);
 784
 785                 spin_unlock_irqrestore(&bank->slock, flags);
 786                 break;
 787         case RK3188:
 788         case RK3288:
 789         case RK3368:
 790                 spin_lock_irqsave(&bank->slock, flags);
 791
 792                 /* enable the write to the equivalent lower bits */
 793                 data = ((1 << RK3188_PULL_BITS_PER_PIN) - 1) << (bit + 16);
 794                 rmask = data | (data >> 16);
 795
 796                 switch (pull) {
 797                 case PIN_CONFIG_BIAS_DISABLE:
 798                         break;
 799                 case PIN_CONFIG_BIAS_PULL_UP:
 800                         data |= (1 << bit);
 801                         break;
 802                 case PIN_CONFIG_BIAS_PULL_DOWN:
 803                         data |= (2 << bit);
 804                         break;
 805                 case PIN_CONFIG_BIAS_BUS_HOLD:
 806                         data |= (3 << bit);
 807                         break;
 808                 default:
 809                         spin_unlock_irqrestore(&bank->slock, flags);
 810                         dev_err(info->dev, "unsupported pull setting %d\n",
 811                                 pull);
 812                         return -EINVAL;
 813                 }
 814
 815                 ret = regmap_update_bits(regmap, reg, rmask, data);
 816
 817                 spin_unlock_irqrestore(&bank->slock, flags);
 818                 break;
 819         default:
 820                 dev_err(info->dev, "unsupported pinctrl type\n");
 821                 return -EINVAL;
 822         }
 823
 824         return ret;
 825 }
 826
 827 /*
 828  * Pinmux_ops handling
 829  */
 830
 831 static int rockchip_pmx_get_funcs_count(struct pinctrl_dev *pctldev)
 832 {
 833         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 834
 835         return info->nfunctions;
 836 }
 837
 838 static const char *rockchip_pmx_get_func_name(struct pinctrl_dev *pctldev,
 839                                           unsigned selector)
 840 {
 841         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 842
 843         return info->functions[selector].name;
 844 }
 845
 846 static int rockchip_pmx_get_groups(struct pinctrl_dev *pctldev,
 847                                 unsigned selector, const char * const **groups,
 848                                 unsigned * const num_groups)
 849 {
 850         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 851
 852         *groups = info->functions[selector].groups;
 853         *num_groups = info->functions[selector].ngroups;
 854
 855         return 0;
 856 }
 857
 858 static int rockchip_pmx_enable(struct pinctrl_dev *pctldev, unsigned selector,
 859                                                             unsigned group)
 860 {
 861         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 862         const unsigned int *pins = info->groups[group].pins;
 863         const struct rockchip_pin_config *data = info->groups[group].data;
 864         struct rockchip_pin_bank *bank;
 865         int cnt, ret = 0;
 866
 867         pinctrl_dbg(info->dev, "enable function %s group %s\n",
 868                 info->functions[selector].name, info->groups[group].name);
 869
 870         /*
 871          * for each pin in the pin group selected, program the correspoding pin
 872          * pin function number in the config register.
 873          */
 874         for (cnt = 0; cnt < info->groups[group].npins; cnt++) {
 875                 bank = pin_to_bank(info, pins[cnt]);
 876                 ret = rockchip_set_mux(bank, pins[cnt] - bank->pin_base,
 877                                        data[cnt].func);
 878                 if (ret)
 879                         break;
 880         }
 881
 882         if (ret) {
 883                 /* revert the already done pin settings */
 884                 for (cnt--; cnt >= 0; cnt--)
 885                         rockchip_set_mux(bank, pins[cnt] - bank->pin_base, 0);
 886
 887                 return ret;
 888         }
 889
 890         return 0;
 891 }
 892
 893 static void rockchip_pmx_disable(struct pinctrl_dev *pctldev,
 894                                         unsigned selector, unsigned group)
 895 {
 896         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 897         const unsigned int *pins = info->groups[group].pins;
 898         struct rockchip_pin_bank *bank;
 899         int cnt;
 900
 901         pinctrl_dbg(info->dev, "disable function %s group %s\n",
 902                 info->functions[selector].name, info->groups[group].name);
 903
 904         for (cnt = 0; cnt < info->groups[group].npins; cnt++) {
 905                 bank = pin_to_bank(info, pins[cnt]);
 906                 rockchip_set_mux(bank, pins[cnt] - bank->pin_base, 0);
 907         }
 908 }
 909
 910 /*
 911  * The calls to gpio_direction_output() and gpio_direction_input()
 912  * leads to this function call (via the pinctrl_gpio_direction_{input|output}()
 913  * function called from the gpiolib interface).
 914  */
 915 static int rockchip_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
 916                                               struct pinctrl_gpio_range *range,
 917                                               unsigned offset, bool input)
 918 {
 919         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 920         struct rockchip_pin_bank *bank;
 921         struct gpio_chip *chip;
 922         int pin, ret;
 923         u32 data;
 924
 925         chip = range->gc;
 926         bank = gc_to_pin_bank(chip);
 927         pin = offset - chip->base;
 928
 929         dev_dbg(info->dev, "gpio_direction for pin %u as %s-%d to %s\n",
 930                  offset, range->name, pin, input ? "input" : "output");
 931
 932         ret = rockchip_set_mux(bank, pin, RK_FUNC_GPIO);
 933         if (ret < 0)
 934                 return ret;
 935
 936         data = readl_relaxed(bank->reg_base + GPIO_SWPORT_DDR);
 937         /* set bit to 1 for output, 0 for input */
 938         if (!input)
 939                 data |= BIT(pin);
 940         else
 941                 data &= ~BIT(pin);
 942         writel_relaxed(data, bank->reg_base + GPIO_SWPORT_DDR);
 943
 944         return 0;
 945 }
 946
 947 static const struct pinmux_ops rockchip_pmx_ops = {
 948         .get_functions_count    = rockchip_pmx_get_funcs_count,
 949         .get_function_name      = rockchip_pmx_get_func_name,
 950         .get_function_groups    = rockchip_pmx_get_groups,
 951         .enable                 = rockchip_pmx_enable,
 952         .disable                = rockchip_pmx_disable,
 953         .gpio_set_direction     = rockchip_pmx_gpio_set_direction,
 954 };
 955
 956 /*
 957  * Pinconf_ops handling
 958  */
 959
 960 static bool rockchip_pinconf_pull_valid(struct rockchip_pin_ctrl *ctrl,
 961                                         enum pin_config_param pull)
 962 {
 963         switch (ctrl->type) {
 964         case RK2928:
 965                 return (pull == PIN_CONFIG_BIAS_PULL_PIN_DEFAULT ||
 966                                         pull == PIN_CONFIG_BIAS_DISABLE);
 967         case RK3066B:
 968                 return pull ? false : true;
 969         case RK3188:
 970         case RK3288:
 971         case RK3368:
 972                 return (pull != PIN_CONFIG_BIAS_PULL_PIN_DEFAULT);
 973         }
 974
 975         return false;
 976 }
 977
 978 static int rockchip_gpio_direction_output(struct gpio_chip *gc,
 979                                           unsigned offset, int value);
 980 static int rockchip_gpio_get(struct gpio_chip *gc, unsigned offset);
 981
 982 /* set the pin config settings for a specified pin */
 983 static int rockchip_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
 984                                 unsigned long configs)
 985 {
 986         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
 987         struct rockchip_pin_bank *bank = pin_to_bank(info, pin);
 988         enum pin_config_param param;
 989         u16 arg;
 990         //int i;
 991         int rc;
 992
 993         //for (i = 0; i < num_configs; i++) {
 994                 param = pinconf_to_config_param(configs);
 995                 arg = pinconf_to_config_argument(configs);
 996
 997                 switch (param) {
 998                 case PIN_CONFIG_BIAS_DISABLE:
 999                         rc =  rockchip_set_pull(bank, pin - bank->pin_base,
1000                                 param);
1001                         if (rc)
1002                                 return rc;
1003                         break;
1004                 case PIN_CONFIG_BIAS_PULL_UP:
1005                 case PIN_CONFIG_BIAS_PULL_DOWN:
1006                 case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
1007                 case PIN_CONFIG_BIAS_BUS_HOLD:
1008                         if (!rockchip_pinconf_pull_valid(info->ctrl, param))
1009                                 return -ENOTSUPP;
1010
1011                         if (!arg)
1012                                 return -EINVAL;
1013
1014                         rc = rockchip_set_pull(bank, pin - bank->pin_base,
1015                                 param);
1016                         if (rc)
1017                                 return rc;
1018                         break;
1019                 case PIN_CONFIG_OUTPUT:
1020                         rc = rockchip_gpio_direction_output(&bank->gpio_chip,
1021                                                             pin - bank->pin_base,
1022                                                             arg);
1023                         if (rc)
1024                                 return rc;
1025                         break;
1026                 case PIN_CONFIG_DRIVE_STRENGTH:
1027                         /* rk3288 RK3368 is the first with per-pin drive-strength */
1028                         if ((info->ctrl->type != RK3288) && ((info->ctrl->type != RK3368)))
1029                                 return -ENOTSUPP;
1030
1031                         rc = rk3288_set_drive(bank, pin - bank->pin_base, arg);
1032                         if (rc < 0)
1033                                 return rc;
1034                         break;
1035                 default:
1036                         return -ENOTSUPP;
1037                         break;
1038                 }
1039         //} /* for each config */
1040
1041         return 0;
1042 }
1043
1044 /* get the pin config settings for a specified pin */
1045 static int rockchip_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin,
1046                                                         unsigned long *config)
1047 {
1048         struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
1049         struct rockchip_pin_bank *bank = pin_to_bank(info, pin);
1050         enum pin_config_param param = pinconf_to_config_param(*config);
1051         u16 arg;
1052         int rc;
1053
1054         switch (param) {
1055         case PIN_CONFIG_BIAS_DISABLE:
1056                 if (rockchip_get_pull(bank, pin - bank->pin_base) != param)
1057                         return -EINVAL;
1058
1059                 arg = 0;
1060                 break;
1061         case PIN_CONFIG_BIAS_PULL_UP:
1062         case PIN_CONFIG_BIAS_PULL_DOWN:
1063         case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
1064         case PIN_CONFIG_BIAS_BUS_HOLD:
1065                 if (!rockchip_pinconf_pull_valid(info->ctrl, param))
1066                         return -ENOTSUPP;
1067
1068                 if (rockchip_get_pull(bank, pin - bank->pin_base) != param)
1069                         return -EINVAL;
1070
1071                 arg = 1;
1072                 break;
1073         case PIN_CONFIG_OUTPUT:
1074                 rc = rockchip_get_mux(bank, pin - bank->pin_base);
1075                 if (rc != RK_FUNC_GPIO)
1076                         return -EINVAL;
1077
1078                 rc = rockchip_gpio_get(&bank->gpio_chip, pin - bank->pin_base);
1079                 if (rc < 0)
1080                         return rc;
1081
1082                 arg = rc ? 1 : 0;
1083                 break;
1084         case PIN_CONFIG_DRIVE_STRENGTH:
1085                 /* rk3288 RK3368 is the first with per-pin drive-strength */
1086                 if ((info->ctrl->type != RK3288) && ((info->ctrl->type != RK3368)))
1087                         return -ENOTSUPP;
1088
1089                 rc = rk3288_get_drive(bank, pin - bank->pin_base);
1090                 if (rc < 0)
1091                         return rc;
1092
1093                 arg = rc;
1094                 break;
1095         default:
1096                 return -ENOTSUPP;
1097                 break;
1098         }
1099
1100         *config = pinconf_to_config_packed(param, arg);
1101
1102         return 0;
1103 }
1104
1105 static const struct pinconf_ops rockchip_pinconf_ops = {
1106         .pin_config_get                 = rockchip_pinconf_get,
1107         .pin_config_set                 = rockchip_pinconf_set,
1108         .is_generic                     = true,
1109 };
1110
1111 static const struct of_device_id rockchip_bank_match[] = {
1112         { .compatible = "rockchip,gpio-bank" },
1113         { .compatible = "rockchip,rk3188-gpio-bank0" },
1114         {},
1115 };
1116
1117 static void rockchip_pinctrl_child_count(struct rockchip_pinctrl *info,
1118                                                 struct device_node *np)
1119 {
1120         struct device_node *child;
1121
1122         for_each_child_of_node(np, child) {
1123                 if (of_match_node(rockchip_bank_match, child))
1124                         continue;
1125
1126                 info->nfunctions++;
1127                 info->ngroups += of_get_child_count(child);
1128         }
1129 }
1130
1131 static int rockchip_pinctrl_parse_groups(struct device_node *np,
1132                                               struct rockchip_pin_group *grp,
1133                                               struct rockchip_pinctrl *info,
1134                                               u32 index)
1135 {
1136         struct rockchip_pin_bank *bank;
1137         int size;
1138         const __be32 *list;
1139         int num;
1140         int i, j;
1141         int ret;
1142
1143         dev_dbg(info->dev, "group(%d): %s\n", index, np->name);
1144
1145         /* Initialise group */
1146         grp->name = np->name;
1147
1148         /*
1149          * the binding format is rockchip,pins = <bank pin mux CONFIG>,
1150          * do sanity check and calculate pins number
1151          */
1152         list = of_get_property(np, "rockchip,pins", &size);
1153         /* we do not check return since it's safe node passed down */
1154         size /= sizeof(*list);
1155         if (!size || size % 4) {
1156                 dev_err(info->dev, "wrong pins number or pins and configs should be by 4\n");
1157                 return -EINVAL;
1158         }
1159
1160         grp->npins = size / 4;
1161
1162         grp->pins = devm_kzalloc(info->dev, grp->npins * sizeof(unsigned int),
1163                                                 GFP_KERNEL);
1164         grp->data = devm_kzalloc(info->dev, grp->npins *
1165                                           sizeof(struct rockchip_pin_config),
1166                                         GFP_KERNEL);
1167         if (!grp->pins || !grp->data)
1168                 return -ENOMEM;
1169
1170         for (i = 0, j = 0; i < size; i += 4, j++) {
1171                 const __be32 *phandle;
1172                 struct device_node *np_config;
1173
1174                 num = be32_to_cpu(*list++);
1175                 bank = bank_num_to_bank(info, num);
1176                 if (IS_ERR(bank))
1177                         return PTR_ERR(bank);
1178
1179                 grp->pins[j] = bank->pin_base + be32_to_cpu(*list++);
1180                 grp->data[j].func = be32_to_cpu(*list++);
1181
1182                 phandle = list++;
1183                 if (!phandle)
1184                         return -EINVAL;
1185
1186                 np_config = of_find_node_by_phandle(be32_to_cpup(phandle));
1187                 ret = pinconf_generic_parse_dt_config(np_config,
1188                                 &grp->data[j].configs, &grp->data[j].nconfigs);
1189                 if (ret)
1190                         return ret;
1191         }
1192
1193         return 0;
1194 }
1195
1196 static int rockchip_pinctrl_parse_functions(struct device_node *np,
1197                                                 struct rockchip_pinctrl *info,
1198                                                 u32 index)
1199 {
1200         struct device_node *child;
1201         struct rockchip_pmx_func *func;
1202         struct rockchip_pin_group *grp;
1203         int ret;
1204         static u32 grp_index;
1205         u32 i = 0;
1206
1207         dev_dbg(info->dev, "parse function(%d): %s\n", index, np->name);
1208
1209         func = &info->functions[index];
1210
1211         /* Initialise function */
1212         func->name = np->name;
1213         func->ngroups = of_get_child_count(np);
1214         if (func->ngroups <= 0)
1215                 return 0;
1216
1217         func->groups = devm_kzalloc(info->dev,
1218                         func->ngroups * sizeof(char *), GFP_KERNEL);
1219         if (!func->groups)
1220                 return -ENOMEM;
1221
1222         for_each_child_of_node(np, child) {
1223                 func->groups[i] = child->name;
1224                 grp = &info->groups[grp_index++];
1225                 ret = rockchip_pinctrl_parse_groups(child, grp, info, i++);
1226                 if (ret)
1227                         return ret;
1228         }
1229
1230         return 0;
1231 }
1232
1233 static int rockchip_pinctrl_parse_dt(struct platform_device *pdev,
1234                                               struct rockchip_pinctrl *info)
1235 {
1236         struct device *dev = &pdev->dev;
1237         struct device_node *np = dev->of_node;
1238         struct device_node *child;
1239         int ret;
1240         int i;
1241
1242         rockchip_pinctrl_child_count(info, np);
1243
1244         dev_dbg(&pdev->dev, "nfunctions = %d\n", info->nfunctions);
1245         dev_dbg(&pdev->dev, "ngroups = %d\n", info->ngroups);
1246
1247         info->functions = devm_kzalloc(dev, info->nfunctions *
1248                                               sizeof(struct rockchip_pmx_func),
1249                                               GFP_KERNEL);
1250         if (!info->functions) {
1251                 dev_err(dev, "failed to allocate memory for function list\n");
1252                 return -EINVAL;
1253         }
1254
1255         info->groups = devm_kzalloc(dev, info->ngroups *
1256                                             sizeof(struct rockchip_pin_group),
1257                                             GFP_KERNEL);
1258         if (!info->groups) {
1259                 dev_err(dev, "failed allocate memory for ping group list\n");
1260                 return -EINVAL;
1261         }
1262
1263         i = 0;
1264
1265         for_each_child_of_node(np, child) {
1266                 if (of_match_node(rockchip_bank_match, child))
1267                         continue;
1268
1269                 ret = rockchip_pinctrl_parse_functions(child, info, i++);
1270                 if (ret) {
1271                         dev_err(&pdev->dev, "failed to parse function\n");
1272                         return ret;
1273                 }
1274         }
1275
1276         return 0;
1277 }
1278
1279 static int rockchip_pinctrl_register(struct platform_device *pdev,
1280                                         struct rockchip_pinctrl *info)
1281 {
1282         struct pinctrl_desc *ctrldesc = &info->pctl;
1283         struct pinctrl_pin_desc *pindesc, *pdesc;
1284         struct rockchip_pin_bank *pin_bank;
1285         int pin, bank, ret;
1286         int k;
1287
1288         ctrldesc->name = "rockchip-pinctrl";
1289         ctrldesc->owner = THIS_MODULE;
1290         ctrldesc->pctlops = &rockchip_pctrl_ops;
1291         ctrldesc->pmxops = &rockchip_pmx_ops;
1292         ctrldesc->confops = &rockchip_pinconf_ops;
1293
1294         pindesc = devm_kzalloc(&pdev->dev, sizeof(*pindesc) *
1295                         info->ctrl->nr_pins, GFP_KERNEL);
1296         if (!pindesc) {
1297                 dev_err(&pdev->dev, "mem alloc for pin descriptors failed\n");
1298                 return -ENOMEM;
1299         }
1300         ctrldesc->pins = pindesc;
1301         ctrldesc->npins = info->ctrl->nr_pins;
1302
1303         pdesc = pindesc;
1304         for (bank = 0 , k = 0; bank < info->ctrl->nr_banks; bank++) {
1305                 pin_bank = &info->ctrl->pin_banks[bank];
1306                 for (pin = 0; pin < pin_bank->nr_pins; pin++, k++) {
1307                         pdesc->number = k;
1308                         pdesc->name = kasprintf(GFP_KERNEL, "%s-%d",
1309                                                 pin_bank->name, pin);
1310                         pdesc++;
1311                 }
1312         }
1313
1314         info->pctl_dev = pinctrl_register(ctrldesc, &pdev->dev, info);
1315         if (!info->pctl_dev) {
1316                 dev_err(&pdev->dev, "could not register pinctrl driver\n");
1317                 return -EINVAL;
1318         }
1319
1320         for (bank = 0; bank < info->ctrl->nr_banks; ++bank) {
1321                 pin_bank = &info->ctrl->pin_banks[bank];
1322                 pin_bank->grange.name = pin_bank->name;
1323                 pin_bank->grange.id = bank;
1324                 pin_bank->grange.pin_base = pin_bank->pin_base;
1325                 pin_bank->grange.base = pin_bank->gpio_chip.base;
1326                 pin_bank->grange.npins = pin_bank->gpio_chip.ngpio;
1327                 pin_bank->grange.gc = &pin_bank->gpio_chip;
1328                 pinctrl_add_gpio_range(info->pctl_dev, &pin_bank->grange);
1329         }
1330
1331         ret = rockchip_pinctrl_parse_dt(pdev, info);
1332         if (ret) {
1333                 pinctrl_unregister(info->pctl_dev);
1334                 return ret;
1335         }
1336
1337         return 0;
1338 }
1339
1340 /*
1341  * GPIO handling
1342  */
1343
1344 static int rockchip_gpio_request(struct gpio_chip *chip, unsigned offset)
1345 {
1346         return pinctrl_request_gpio(chip->base + offset);
1347 }
1348
1349 static void rockchip_gpio_free(struct gpio_chip *chip, unsigned offset)
1350 {
1351         pinctrl_free_gpio(chip->base + offset);
1352 }
1353
1354 static void rockchip_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
1355 {
1356         struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
1357         void __iomem *reg = bank->reg_base + GPIO_SWPORT_DR;
1358         unsigned long flags;
1359         u32 data;
1360
1361         spin_lock_irqsave(&bank->slock, flags);
1362
1363         data = readl(reg);
1364         data &= ~BIT(offset);
1365         if (value)
1366                 data |= BIT(offset);
1367         writel(data, reg);
1368
1369         spin_unlock_irqrestore(&bank->slock, flags);
1370 }
1371
1372 /*
1373  * Returns the level of the pin for input direction and setting of the DR
1374  * register for output gpios.
1375  */
1376 static int rockchip_gpio_get(struct gpio_chip *gc, unsigned offset)
1377 {
1378         struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
1379         u32 data;
1380
1381         data = readl(bank->reg_base + GPIO_EXT_PORT);
1382         data >>= offset;
1383         data &= 1;
1384         return data;
1385 }
1386
1387 /*
1388  * gpiolib gpio_direction_input callback function. The setting of the pin
1389  * mux function as 'gpio input' will be handled by the pinctrl susbsystem
1390  * interface.
1391  */
1392 static int rockchip_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
1393 {
1394         return pinctrl_gpio_direction_input(gc->base + offset);
1395 }
1396
1397 /*
1398  * gpiolib gpio_direction_output callback function. The setting of the pin
1399  * mux function as 'gpio output' will be handled by the pinctrl susbsystem
1400  * interface.
1401  */
1402 static int rockchip_gpio_direction_output(struct gpio_chip *gc,
1403                                           unsigned offset, int value)
1404 {
1405         rockchip_gpio_set(gc, offset, value);
1406         return pinctrl_gpio_direction_output(gc->base + offset);
1407 }
1408
1409 /*
1410  * gpiolib gpio_to_irq callback function. Creates a mapping between a GPIO pin
1411  * and a virtual IRQ, if not already present.
1412  */
1413 static int rockchip_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
1414 {
1415         struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
1416         unsigned int virq;
1417
1418         if (!bank->domain)
1419                 return -ENXIO;
1420
1421         virq = irq_create_mapping(bank->domain, offset);
1422
1423         return (virq) ? : -ENXIO;
1424 }
1425
1426 static const struct gpio_chip rockchip_gpiolib_chip = {
1427         .request = rockchip_gpio_request,
1428         .free = rockchip_gpio_free,
1429         .set = rockchip_gpio_set,
1430         .get = rockchip_gpio_get,
1431         .direction_input = rockchip_gpio_direction_input,
1432         .direction_output = rockchip_gpio_direction_output,
1433         .to_irq = rockchip_gpio_to_irq,
1434         .owner = THIS_MODULE,
1435 };
1436
1437 /*
1438  * Interrupt handling
1439  */
1440
1441 static void rockchip_irq_demux(unsigned int irq, struct irq_desc *desc)
1442 {
1443         struct irq_chip *chip = irq_get_chip(irq);
1444         struct rockchip_pin_bank *bank = irq_get_handler_data(irq);
1445         u32 polarity = 0, data = 0;
1446         u32 pend;
1447         bool edge_changed = false;
1448
1449         pinctrl_dbg(bank->drvdata->dev, "got irq for bank %s\n", bank->name);
1450
1451         chained_irq_enter(chip, desc);
1452
1453         pend = readl_relaxed(bank->reg_base + GPIO_INT_STATUS);
1454
1455         if (bank->toggle_edge_mode) {
1456                 polarity = readl_relaxed(bank->reg_base +
1457                                          GPIO_INT_POLARITY);
1458                 data = readl_relaxed(bank->reg_base + GPIO_EXT_PORT);
1459         }
1460
1461         while (pend) {
1462                 unsigned int virq;
1463
1464                 irq = __ffs(pend);
1465                 pend &= ~BIT(irq);
1466                 virq = irq_linear_revmap(bank->domain, irq);
1467
1468                 if (!virq) {
1469                         dev_err(bank->drvdata->dev, "unmapped irq %d\n", irq);
1470                         continue;
1471                 }
1472
1473                 pinctrl_dbg(bank->drvdata->dev, "handling irq %d\n", irq);
1474
1475                 /*
1476                  * Triggering IRQ on both rising and falling edge
1477                  * needs manual intervention.
1478                  */
1479                 if (bank->toggle_edge_mode & BIT(irq)) {
1480                         if (data & BIT(irq))
1481                                 polarity &= ~BIT(irq);
1482                         else
1483                                 polarity |= BIT(irq);
1484
1485                         edge_changed = true;
1486                 }
1487
1488                 generic_handle_irq(virq);
1489         }
1490
1491         if (bank->toggle_edge_mode && edge_changed) {
1492                 /* Interrupt params should only be set with ints disabled */
1493                 data = readl_relaxed(bank->reg_base + GPIO_INTEN);
1494                 writel_relaxed(0, bank->reg_base + GPIO_INTEN);
1495                 writel(polarity, bank->reg_base + GPIO_INT_POLARITY);
1496                 writel(data, bank->reg_base + GPIO_INTEN);
1497         }
1498
1499         chained_irq_exit(chip, desc);
1500 }
1501
1502 static int rockchip_gpio_irq_set_type(struct irq_data *d, unsigned int type)
1503 {
1504         struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
1505         //struct rockchip_pinctrl *info = bank->drvdata;
1506         u32 mask = BIT(d->hwirq);
1507         u32 polarity;
1508         u32 level;
1509         u32 data;
1510         int ret;
1511         unsigned long flags;
1512
1513         /* make sure the pin is configured as gpio input */
1514         ret = rockchip_set_mux(bank, d->hwirq, RK_FUNC_GPIO);
1515         if (ret < 0)
1516                 return ret;
1517
1518         data = readl_relaxed(bank->reg_base + GPIO_SWPORT_DDR);
1519         data &= ~mask;
1520         writel_relaxed(data, bank->reg_base + GPIO_SWPORT_DDR);
1521
1522         if (type & IRQ_TYPE_EDGE_BOTH)
1523                 __irq_set_handler_locked(d->irq, handle_edge_irq);
1524         else
1525                 __irq_set_handler_locked(d->irq, handle_level_irq);
1526
1527         spin_lock_irqsave(&bank->slock, flags);
1528
1529         level = readl_relaxed(bank->reg_base + GPIO_INTTYPE_LEVEL);
1530         polarity = readl_relaxed(bank->reg_base + GPIO_INT_POLARITY);
1531
1532         switch (type) {
1533         case IRQ_TYPE_EDGE_BOTH:
1534                 bank->toggle_edge_mode |= mask;
1535                 level |= mask;
1536
1537                 /*
1538                  * Determine gpio state. If 1 next interrupt should be falling
1539                  * otherwise rising.
1540                  */
1541                 data = readl(bank->reg_base + GPIO_EXT_PORT);
1542                 if (data & mask)
1543                         polarity &= ~mask;
1544                 else
1545                         polarity |= mask;
1546                 break;
1547         case IRQ_TYPE_EDGE_RISING:
1548                 bank->toggle_edge_mode &= ~mask;
1549                 level |= mask;
1550                 polarity |= mask;
1551                 break;
1552         case IRQ_TYPE_EDGE_FALLING:
1553                 bank->toggle_edge_mode &= ~mask;
1554                 level |= mask;
1555                 polarity &= ~mask;
1556                 break;
1557         case IRQ_TYPE_LEVEL_HIGH:
1558                 bank->toggle_edge_mode &= ~mask;
1559                 level &= ~mask;
1560                 polarity |= mask;
1561                 break;
1562         case IRQ_TYPE_LEVEL_LOW:
1563                 bank->toggle_edge_mode &= ~mask;
1564                 level &= ~mask;
1565                 polarity &= ~mask;
1566                 break;
1567         default:
1568                 //irq_gc_unlock(gc);
1569                 return -EINVAL;
1570         }
1571
1572         writel_relaxed(level, bank->reg_base + GPIO_INTTYPE_LEVEL);
1573         writel_relaxed(polarity, bank->reg_base + GPIO_INT_POLARITY);
1574
1575         spin_unlock_irqrestore(&bank->slock, flags);
1576
1577         //DBG_PINCTRL("%s:type=%d,irq=%d,hwirq=%d,ok\n",__func__,type, d->irq, (int)d->hwirq);
1578         return 0;
1579 }
1580
1581 static inline void rockchip_gpio_bit_op(void __iomem *reg_base
1582         , unsigned int offset, u32 bit, unsigned char flag)
1583 {
1584         u32 val = __raw_readl(reg_base + offset);
1585         if (flag)
1586                 val |= BIT(bit);
1587         else
1588                 val &= ~BIT(bit);
1589
1590
1591         __raw_writel(val, reg_base + offset);
1592 }
1593
1594 static inline unsigned gpio_to_bit(struct rockchip_pin_bank *bank, unsigned gpio)
1595 {
1596         while (gpio >= (bank->pin_base + bank->nr_pins))
1597                 bank++;
1598
1599         return gpio - bank->pin_base;
1600 }
1601
1602 static inline unsigned offset_to_bit(unsigned offset)
1603 {
1604         return 1u << offset;
1605 }
1606
1607 static void GPIOEnableIntr(void __iomem *reg_base, unsigned int bit)
1608 {
1609         rockchip_gpio_bit_op(reg_base, GPIO_INTEN, bit, 1);
1610 }
1611
1612 static void GPIODisableIntr(void __iomem *reg_base, unsigned int bit)
1613 {
1614         rockchip_gpio_bit_op(reg_base, GPIO_INTEN, bit, 0);
1615 }
1616
1617 static void GPIOAckIntr(void __iomem *reg_base, unsigned int bit)
1618 {
1619         rockchip_gpio_bit_op(reg_base, GPIO_PORTS_EOI, bit, 1);
1620 }
1621
1622 static int rockchip_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
1623 {
1624         struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
1625         //struct rockchip_pinctrl *info = bank->drvdata;
1626         u32 bit = d->hwirq;
1627         unsigned long flags;
1628         //int pin = d->hwirq;
1629
1630         spin_lock_irqsave(&bank->slock, flags);
1631
1632         if (on)
1633         {
1634                 bank->suspend_wakeup |= BIT(bit);
1635         }
1636         else
1637         {
1638                 bank->suspend_wakeup &= ~BIT(bit);
1639         }
1640         spin_unlock_irqrestore(&bank->slock, flags);
1641
1642         //DBG_PINCTRL("%s:irq=%d,hwirq=%d,bank->reg_base=0x%x,bit=%d\n"
1643                 //, __func__,d->irq, (int)d->hwirq, (int)bank->reg_base,bit);
1644         return 0;
1645 }
1646
1647 static void rockchip_gpio_irq_unmask(struct irq_data *d)
1648 {
1649         struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
1650         //struct rockchip_pinctrl *info = bank->drvdata;
1651         u32 bit = d->hwirq;
1652         unsigned long flags;
1653         //int pin = d->hwirq;
1654
1655         spin_lock_irqsave(&bank->slock, flags);
1656         GPIOEnableIntr(bank->reg_base, bit);
1657         spin_unlock_irqrestore(&bank->slock, flags);
1658
1659         //DBG_PINCTRL("%s:irq=%d,hwirq=%d,bank->reg_base=0x%x,bit=%d\n"
1660                 //, __func__,d->irq, (int)d->hwirq, (int)bank->reg_base,bit);
1661 }
1662
1663 static void rockchip_gpio_irq_mask(struct irq_data *d)
1664 {
1665         struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
1666         //struct rockchip_pinctrl *info = bank->drvdata;
1667         //u32 bit = gpio_to_bit(bank, d->irq);
1668         u32 bit = d->hwirq;
1669         unsigned long flags;
1670         //int pin = d->hwirq;
1671
1672         spin_lock_irqsave(&bank->slock, flags);
1673         GPIODisableIntr(bank->reg_base, bit);
1674         spin_unlock_irqrestore(&bank->slock, flags);
1675
1676         //DBG_PINCTRL("%s:irq=%d,hwirq=%d,bank->reg_base=0x%x,bit=%d\n"
1677                 //, __func__,d->irq, (int)d->hwirq, (int)bank->reg_base,bit);
1678 }
1679
1680 static void rockchip_gpio_irq_ack(struct irq_data *d)
1681 {
1682         struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
1683         //struct rockchip_pinctrl *info = bank->drvdata;
1684         //u32 bit = gpio_to_bit(bank, d->irq);
1685         u32 bit = d->hwirq;
1686         //int pin = d->hwirq;
1687
1688         GPIOAckIntr(bank->reg_base, bit);
1689
1690         //DBG_PINCTRL("%s:irq=%d,hwirq=%d,bank->reg_base=0x%x,bit=%d\n"
1691                 //, __func__,d->irq, (int)d->hwirq, (int)bank->reg_base,bit);
1692 }
1693
1694 static struct irq_chip rockchip_gpio_irq_chip = {
1695         .name           = "ROCKCHIP_GPIO_CHIP",
1696         .irq_ack                = rockchip_gpio_irq_ack,
1697         .irq_disable    = rockchip_gpio_irq_mask,
1698         .irq_mask       = rockchip_gpio_irq_mask,
1699         .irq_unmask     = rockchip_gpio_irq_unmask,
1700         .irq_set_type   = rockchip_gpio_irq_set_type,
1701         .irq_set_wake   = rockchip_gpio_irq_set_wake,
1702 };
1703
1704 static int rockchip_gpio_irq_map(struct irq_domain *d, unsigned int irq,
1705                                 irq_hw_number_t hwirq)
1706 {
1707         struct rockchip_pin_bank *bank = d->host_data;
1708         //struct rockchip_pinctrl *info = bank->drvdata;
1709         struct irq_data *irq_data = irq_get_irq_data(irq);
1710         //int pin = hwirq;
1711
1712         if (!bank)
1713         {
1714                 printk("%s:bank=0x%p,irq=%d\n",__func__,bank, irq);
1715                 return -EINVAL;
1716         }
1717
1718         irq_set_chip_and_handler(irq, &rockchip_gpio_irq_chip, handle_level_irq);
1719         irq_set_chip_data(irq, bank);
1720         set_irq_flags(irq, IRQF_VALID);
1721
1722         irq_data->hwirq = hwirq;
1723         irq_data->irq = irq;
1724
1725         pinctrl_dbg(bank->drvdata->dev, "%s:irq = %d, hwirq =%ld\n",__func__,irq, hwirq);
1726         return 0;
1727 }
1728
1729 static const struct irq_domain_ops rockchip_gpio_irq_ops = {
1730         .map = rockchip_gpio_irq_map,
1731         .xlate = irq_domain_xlate_twocell,
1732 };
1733
1734 static int rockchip_interrupts_register(struct platform_device *pdev,
1735                                                 struct rockchip_pinctrl *info)
1736 {
1737         struct rockchip_pin_ctrl *ctrl = info->ctrl;
1738         struct rockchip_pin_bank *bank = ctrl->pin_banks;
1739         //unsigned int clr = IRQ_NOREQUEST | IRQ_NOPROBE | IRQ_NOAUTOEN;
1740         int i;
1741
1742         for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
1743                 if (!bank->valid) {
1744                         dev_warn(&pdev->dev, "bank %s is not valid\n",
1745                                  bank->name);
1746                         continue;
1747                 }
1748
1749                 __raw_writel(0, bank->reg_base + GPIO_INTEN);
1750
1751                 bank->drvdata = info;
1752                 bank->domain = irq_domain_add_linear(bank->of_node, 32,
1753                                 &rockchip_gpio_irq_ops, bank);
1754                 if (!bank->domain) {
1755                         dev_warn(&pdev->dev, "could not initialize irq domain for bank %s\n",
1756                                  bank->name);
1757                         continue;
1758                 }
1759
1760                 //if(atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1))
1761                         //printk("%s:bank_num=%d\n",__func__,bank->bank_num);
1762
1763                 irq_set_handler_data(bank->irq, bank);
1764                 irq_set_chained_handler(bank->irq, rockchip_irq_demux);
1765         }
1766
1767         return 0;
1768 }
1769
1770 static int rockchip_gpiolib_register(struct platform_device *pdev,
1771                                                 struct rockchip_pinctrl *info)
1772 {
1773         struct rockchip_pin_ctrl *ctrl = info->ctrl;
1774         struct rockchip_pin_bank *bank = ctrl->pin_banks;
1775         struct gpio_chip *gc;
1776         int ret;
1777         int i;
1778
1779         for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
1780                 if (!bank->valid) {
1781                         dev_warn(&pdev->dev, "bank %s is not valid\n",
1782                                  bank->name);
1783                         continue;
1784                 }
1785
1786                 bank->gpio_chip = rockchip_gpiolib_chip;
1787
1788                 gc = &bank->gpio_chip;
1789                 gc->base = bank->pin_base;
1790                 gc->ngpio = bank->nr_pins;
1791                 gc->dev = &pdev->dev;
1792                 gc->of_node = bank->of_node;
1793                 gc->label = bank->name;
1794
1795                 ret = gpiochip_add(gc);
1796                 if (ret) {
1797                         dev_err(&pdev->dev, "failed to register gpio_chip %s, error code: %d\n",
1798                                                         gc->label, ret);
1799                         goto fail;
1800                 }
1801         }
1802
1803         rockchip_interrupts_register(pdev, info);
1804
1805         return 0;
1806
1807 fail:
1808         for (--i, --bank; i >= 0; --i, --bank) {
1809                 if (!bank->valid)
1810                         continue;
1811
1812                 if (gpiochip_remove(&bank->gpio_chip))
1813                         dev_err(&pdev->dev, "gpio chip %s remove failed\n",
1814                                                         bank->gpio_chip.label);
1815         }
1816         return ret;
1817 }
1818
1819 static int rockchip_gpiolib_unregister(struct platform_device *pdev,
1820                                                 struct rockchip_pinctrl *info)
1821 {
1822         struct rockchip_pin_ctrl *ctrl = info->ctrl;
1823         struct rockchip_pin_bank *bank = ctrl->pin_banks;
1824         int ret = 0;
1825         int i;
1826
1827         for (i = 0; !ret && i < ctrl->nr_banks; ++i, ++bank) {
1828                 if (!bank->valid)
1829                         continue;
1830
1831                 ret = gpiochip_remove(&bank->gpio_chip);
1832         }
1833
1834         if (ret)
1835                 dev_err(&pdev->dev, "gpio chip remove failed\n");
1836
1837         return ret;
1838 }
1839
1840 static int rockchip_get_bank_data(struct rockchip_pin_bank *bank,
1841                                   struct rockchip_pinctrl *info)
1842 {
1843         struct resource res;
1844         void __iomem *base;
1845
1846         if (of_address_to_resource(bank->of_node, 0, &res)) {
1847                 dev_err(info->dev, "cannot find IO resource for bank\n");
1848                 return -ENOENT;
1849         }
1850
1851         bank->reg_base = devm_ioremap_resource(info->dev, &res);
1852         if (IS_ERR(bank->reg_base))
1853                 return PTR_ERR(bank->reg_base);
1854
1855         /*
1856          * special case, where parts of the pull setting-registers are
1857          * part of the PMU register space
1858          */
1859         if (of_device_is_compatible(bank->of_node,
1860                                     "rockchip,rk3188-gpio-bank0")) {
1861                 struct device_node *node;
1862
1863                 node = of_parse_phandle(bank->of_node->parent,
1864                                         "rockchip,pmu", 0);
1865                 if (!node) {
1866                         if (of_address_to_resource(bank->of_node, 1, &res)) {
1867                                 dev_err(info->dev, "cannot find IO resource for bank\n");
1868                                 return -ENOENT;
1869                         }
1870
1871                         base = devm_ioremap_resource(info->dev, &res);
1872                         if (IS_ERR(base))
1873                                 return PTR_ERR(base);
1874                         rockchip_regmap_config.max_register =
1875                                                     resource_size(&res) - 4;
1876                         rockchip_regmap_config.name =
1877                                             "rockchip,rk3188-gpio-bank0-pull";
1878                         bank->regmap_pull = devm_regmap_init_mmio(info->dev,
1879                                                     base,
1880                                                     &rockchip_regmap_config);
1881                 }
1882         }
1883
1884         bank->irq = irq_of_parse_and_map(bank->of_node, 0);
1885
1886         bank->clk = of_clk_get(bank->of_node, 0);
1887         if (IS_ERR(bank->clk))
1888                 return PTR_ERR(bank->clk);
1889
1890         return clk_prepare_enable(bank->clk);
1891 }
1892
1893 static const struct of_device_id rockchip_pinctrl_dt_match[];
1894
1895 /* retrieve the soc specific data */
1896 static struct rockchip_pin_ctrl *rockchip_pinctrl_get_soc_data(
1897                                                 struct rockchip_pinctrl *d,
1898                                                 struct platform_device *pdev)
1899 {
1900         const struct of_device_id *match;
1901         struct device_node *node = pdev->dev.of_node;
1902         struct device_node *np;
1903         struct rockchip_pin_ctrl *ctrl;
1904         struct rockchip_pin_bank *bank;
1905         int grf_offs, pmu_offs, i, j;
1906
1907         match = of_match_node(rockchip_pinctrl_dt_match, node);
1908         ctrl = (struct rockchip_pin_ctrl *)match->data;
1909
1910         for_each_child_of_node(node, np) {
1911                 if (!of_find_property(np, "gpio-controller", NULL))
1912                         continue;
1913
1914                 bank = ctrl->pin_banks;
1915                 for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
1916                         if (!strcmp(bank->name, np->name)) {
1917                                 bank->of_node = np;
1918
1919                                 if (!rockchip_get_bank_data(bank, d))
1920                                         bank->valid = true;
1921
1922                                 break;
1923                         }
1924                 }
1925         }
1926
1927         grf_offs = ctrl->grf_mux_offset;
1928         pmu_offs = ctrl->pmu_mux_offset;
1929         bank = ctrl->pin_banks;
1930         for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
1931                 int bank_pins = 0;
1932
1933                 spin_lock_init(&bank->slock);
1934                 bank->drvdata = d;
1935                 bank->pin_base = ctrl->nr_pins;
1936                 ctrl->nr_pins += bank->nr_pins;
1937
1938                 /* calculate iomux offsets */
1939                 for (j = 0; j < 4; j++) {
1940                         struct rockchip_iomux *iom = &bank->iomux[j];
1941                         int inc;
1942
1943                         if (bank_pins >= bank->nr_pins)
1944                                 break;
1945
1946                         /* preset offset value, set new start value */
1947                         if (iom->offset >= 0) {
1948                                 if (iom->type & IOMUX_SOURCE_PMU)
1949                                         pmu_offs = iom->offset;
1950                                 else
1951                                         grf_offs = iom->offset;
1952                         } else { /* set current offset */
1953                                 iom->offset = (iom->type & IOMUX_SOURCE_PMU) ?
1954                                                         pmu_offs : grf_offs;
1955                         }
1956
1957                         pinctrl_dbg(d->dev, "bank %d, iomux %d has offset 0x%x\n",
1958                                  i, j, iom->offset);
1959
1960                         /*
1961                          * Increase offset according to iomux width.
1962                          * 4bit iomux'es are spread over two registers.
1963                          */
1964                         inc = (iom->type & IOMUX_WIDTH_4BIT) ? 8 : 4;
1965                         if (iom->type & IOMUX_SOURCE_PMU)
1966                                 pmu_offs += inc;
1967                         else
1968                                 grf_offs += inc;
1969
1970                         bank_pins += 8;
1971                 }
1972         }
1973
1974         return ctrl;
1975 }
1976
1977 static int rockchip_pinctrl_probe(struct platform_device *pdev)
1978 {
1979         struct rockchip_pinctrl *info;
1980         struct device *dev = &pdev->dev;
1981         struct rockchip_pin_ctrl *ctrl;
1982         struct device_node *np = pdev->dev.of_node, *node;
1983         struct resource *res;
1984         void __iomem *base;
1985         int ret;
1986
1987         if (!dev->of_node) {
1988                 dev_err(dev, "device tree node not found\n");
1989                 return -ENODEV;
1990         }
1991
1992         info = devm_kzalloc(dev, sizeof(struct rockchip_pinctrl), GFP_KERNEL);
1993         if (!info)
1994                 return -ENOMEM;
1995
1996         info->dev = dev;
1997
1998         ctrl = rockchip_pinctrl_get_soc_data(info, pdev);
1999         if (!ctrl) {
2000                 dev_err(dev, "driver data not available\n");
2001                 return -EINVAL;
2002         }
2003         info->ctrl = ctrl;
2004         g_info = info;
2005
2006         node = of_parse_phandle(np, "rockchip,grf", 0);
2007         if (node) {
2008                 info->regmap_base = syscon_node_to_regmap(node);
2009                 if (IS_ERR(info->regmap_base))
2010                         return PTR_ERR(info->regmap_base);
2011         } else {
2012                 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2013                 base = devm_ioremap_resource(&pdev->dev, res);
2014                 if (IS_ERR(base))
2015                         return PTR_ERR(base);
2016
2017                 rockchip_regmap_config.max_register = resource_size(res) - 4;
2018                 rockchip_regmap_config.name = "rockchip,pinctrl";
2019                 info->regmap_base = devm_regmap_init_mmio(&pdev->dev, base,
2020                                                     &rockchip_regmap_config);
2021
2022                 /* to check for the old dt-bindings */
2023                 info->reg_size = resource_size(res);
2024
2025                 /* Honor the old binding, with pull registers as 2nd resource */
2026                 if (ctrl->type == RK3188 && info->reg_size < 0x200) {
2027                         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2028                         base = devm_ioremap_resource(&pdev->dev, res);
2029                         if (IS_ERR(base))
2030                                 return PTR_ERR(base);
2031
2032                         rockchip_regmap_config.max_register =
2033                                                         resource_size(res) - 4;
2034                         rockchip_regmap_config.name = "rockchip,pinctrl-pull";
2035                         info->regmap_pull = devm_regmap_init_mmio(&pdev->dev,
2036                                                     base,
2037                                                     &rockchip_regmap_config);
2038                 }
2039         }
2040
2041         /* try to find the optional reference to the pmu syscon */
2042         node = of_parse_phandle(np, "rockchip,pmu", 0);
2043         if (node) {
2044                 info->regmap_pmu = syscon_node_to_regmap(node);
2045                 if (IS_ERR(info->regmap_pmu))
2046                         return PTR_ERR(info->regmap_pmu);
2047         }
2048
2049         ret = rockchip_gpiolib_register(pdev, info);
2050         if (ret)
2051                 return ret;
2052
2053         ret = rockchip_pinctrl_register(pdev, info);
2054         if (ret) {
2055                 rockchip_gpiolib_unregister(pdev, info);
2056                 return ret;
2057         }
2058
2059         platform_set_drvdata(pdev, info);
2060         printk("%s:init ok\n",__func__);
2061
2062         return 0;
2063 }
2064
2065 #ifdef CONFIG_PM
2066 static int rockchip_pinctrl_suspend(void)
2067 {
2068         struct rockchip_pinctrl *info = g_info;
2069         struct rockchip_pin_ctrl *ctrl = info->ctrl;
2070         struct rockchip_pin_bank *bank = ctrl->pin_banks;
2071         int n;
2072         //int value = 0;
2073
2074         for(n=0; n<ctrl->nr_banks-1; n++)
2075         {
2076 #if 0
2077                 int i;
2078                 for(i=0; i<0x60; i=i+4)
2079                 {
2080                         value = readl_relaxed(bank->reg_base + i);
2081                         printk("%s:bank_num=%d,reg[0x%x+0x%x]=0x%x,bank_name=%s\n",__func__,bank->bank_num, bank->reg_base, i, value, bank->name);
2082                 }
2083 #endif
2084                 bank->saved_wakeup = __raw_readl(bank->reg_base + GPIO_INTEN);
2085                 __raw_writel(bank->suspend_wakeup, bank->reg_base + GPIO_INTEN);
2086
2087                 if (!bank->suspend_wakeup)
2088                 clk_disable_unprepare(bank->clk);
2089
2090                 //if(atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1))
2091                         //printk("%s:bank_num=%d, suspend_wakeup=0x%x\n"
2092                                 //,__func__, bank->bank_num, bank->suspend_wakeup);
2093                 bank++;
2094         }
2095
2096
2097         return 0;
2098 }
2099
2100 static void rockchip_pinctrl_resume(void)
2101 {
2102         struct rockchip_pinctrl *info = g_info;
2103         struct rockchip_pin_ctrl *ctrl = info->ctrl;
2104         struct rockchip_pin_bank *bank = ctrl->pin_banks;
2105         int n;
2106         u32 isr;
2107
2108         for(n=0; n<ctrl->nr_banks-1; n++)
2109         {
2110 #if 0
2111                 int i;
2112                 for(i=0; i<0x60; i=i+4)
2113                 {
2114                         u32 value = readl_relaxed(bank->reg_base + i);
2115                         printk("%s:bank_num=%d,reg[0x%x+0x%x]=0x%x,bank_name=%s\n",__func__,bank->bank_num, bank->reg_base, i, value, bank->name);
2116                 }
2117 #endif
2118                 if (!bank->suspend_wakeup)
2119                 clk_prepare_enable(bank->clk);
2120
2121                 /* keep enable for resume irq */
2122                  isr = __raw_readl(bank->reg_base + GPIO_INT_STATUS);
2123                         __raw_writel(bank->saved_wakeup | (bank->suspend_wakeup & isr)
2124                                         , bank->reg_base + GPIO_INTEN);
2125
2126                 //if(atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1))
2127                         //printk("%s:bank_num=%d, suspend_wakeup=0x%x\n",__func__
2128                                  //bank->bank_num, bank->saved_wakeup | (bank->suspend_wakeup & isr));
2129
2130                 bank++;
2131         }
2132
2133 }
2134 #endif
2135
2136 static struct rockchip_pin_bank rk2928_pin_banks[] = {
2137         PIN_BANK(0, 32, "gpio0"),
2138         PIN_BANK(1, 32, "gpio1"),
2139         PIN_BANK(2, 32, "gpio2"),
2140         PIN_BANK(3, 32, "gpio3"),
2141 };
2142
2143 static struct rockchip_pin_ctrl rk2928_pin_ctrl = {
2144                 .pin_banks              = rk2928_pin_banks,
2145                 .nr_banks               = ARRAY_SIZE(rk2928_pin_banks),
2146                 .label                  = "RK2928-GPIO",
2147                 .type                   = RK2928,
2148                 .grf_mux_offset         = 0xa8,
2149                 .pull_calc_reg          = rk2928_calc_pull_reg_and_bit,
2150 };
2151
2152 static struct rockchip_pin_bank rk3066a_pin_banks[] = {
2153         PIN_BANK(0, 32, "gpio0"),
2154         PIN_BANK(1, 32, "gpio1"),
2155         PIN_BANK(2, 32, "gpio2"),
2156         PIN_BANK(3, 32, "gpio3"),
2157         PIN_BANK(4, 32, "gpio4"),
2158         PIN_BANK(6, 16, "gpio6"),
2159 };
2160
2161 static struct rockchip_pin_ctrl rk3066a_pin_ctrl = {
2162                 .pin_banks              = rk3066a_pin_banks,
2163                 .nr_banks               = ARRAY_SIZE(rk3066a_pin_banks),
2164                 .label                  = "RK3066a-GPIO",
2165                 .type                   = RK2928,
2166                 .grf_mux_offset         = 0xa8,
2167                 .pull_calc_reg          = rk2928_calc_pull_reg_and_bit,
2168 };
2169
2170 static struct rockchip_pin_bank rk3066b_pin_banks[] = {
2171         PIN_BANK(0, 32, "gpio0"),
2172         PIN_BANK(1, 32, "gpio1"),
2173         PIN_BANK(2, 32, "gpio2"),
2174         PIN_BANK(3, 32, "gpio3"),
2175 };
2176
2177 static struct rockchip_pin_ctrl rk3066b_pin_ctrl = {
2178                 .pin_banks      = rk3066b_pin_banks,
2179                 .nr_banks       = ARRAY_SIZE(rk3066b_pin_banks),
2180                 .label          = "RK3066b-GPIO",
2181                 .type           = RK3066B,
2182                 .grf_mux_offset = 0x60,
2183 };
2184
2185 static struct rockchip_pin_bank rk3188_pin_banks[] = {
2186         PIN_BANK_IOMUX_FLAGS(0, 32, "gpio0", IOMUX_GPIO_ONLY, 0, 0, 0),
2187         PIN_BANK(1, 32, "gpio1"),
2188         PIN_BANK(2, 32, "gpio2"),
2189         PIN_BANK(3, 32, "gpio3"),
2190 };
2191
2192 static struct rockchip_pin_ctrl rk3188_pin_ctrl = {
2193                 .pin_banks              = rk3188_pin_banks,
2194                 .nr_banks               = ARRAY_SIZE(rk3188_pin_banks),
2195                 .label                  = "RK3188-GPIO",
2196                 .type                   = RK3188,
2197                 .grf_mux_offset         = 0x60,
2198                 .pull_calc_reg          = rk3188_calc_pull_reg_and_bit,
2199 };
2200
2201 static struct rockchip_pin_bank rk3288_pin_banks[] = {
2202         PIN_BANK_IOMUX_FLAGS(0, 24, "gpio0", IOMUX_SOURCE_PMU,
2203                                              IOMUX_SOURCE_PMU,
2204                                              IOMUX_SOURCE_PMU,
2205                                              IOMUX_UNROUTED
2206                             ),
2207         PIN_BANK_IOMUX_FLAGS(1, 32, "gpio1", IOMUX_UNROUTED,
2208                                              IOMUX_UNROUTED,
2209                                              IOMUX_UNROUTED,
2210                                              0
2211                             ),
2212         PIN_BANK_IOMUX_FLAGS(2, 32, "gpio2", 0, 0, 0, IOMUX_UNROUTED),
2213         PIN_BANK_IOMUX_FLAGS(3, 32, "gpio3", 0, 0, 0, IOMUX_WIDTH_4BIT),
2214         PIN_BANK_IOMUX_FLAGS(4, 32, "gpio4", IOMUX_WIDTH_4BIT,
2215                                              IOMUX_WIDTH_4BIT,
2216                                              0,
2217                                              0
2218                             ),
2219         PIN_BANK_IOMUX_FLAGS(5, 32, "gpio5", IOMUX_UNROUTED,
2220                                              0,
2221                                              0,
2222                                              IOMUX_UNROUTED
2223                             ),
2224         PIN_BANK_IOMUX_FLAGS(6, 32, "gpio6", 0, 0, 0, IOMUX_UNROUTED),
2225         PIN_BANK_IOMUX_FLAGS(7, 32, "gpio7", 0,
2226                                              0,
2227                                              IOMUX_WIDTH_4BIT,
2228                                              IOMUX_UNROUTED
2229                             ),
2230         PIN_BANK(8, 16, "gpio8"),
2231 };
2232
2233 static struct rockchip_pin_ctrl rk3288_pin_ctrl = {
2234                 .pin_banks              = rk3288_pin_banks,
2235                 .nr_banks               = ARRAY_SIZE(rk3288_pin_banks),
2236                 .label                  = "RK3288-GPIO",
2237                 .type                   = RK3288,
2238                 .grf_mux_offset         = 0x0,
2239                 .pmu_mux_offset         = 0x84,
2240                 .pull_calc_reg          = rk3288_calc_pull_reg_and_bit,
2241 };
2242
2243 static struct rockchip_pin_bank rk3368_pin_banks[] = {
2244         PIN_BANK_IOMUX_FLAGS(0, 32, "gpio0", IOMUX_SOURCE_PMU,
2245                                              IOMUX_SOURCE_PMU,
2246                                              IOMUX_SOURCE_PMU,
2247                                              IOMUX_SOURCE_PMU),
2248         PIN_BANK_IOMUX_FLAGS(1, 32, "gpio1", 0, 0, 0, 0),
2249         PIN_BANK_IOMUX_FLAGS(2, 32, "gpio2", 0, 0, 0, 0),
2250         PIN_BANK_IOMUX_FLAGS(3, 32, "gpio3", 0, 0, 0, 0),
2251 };
2252
2253 static struct rockchip_pin_ctrl rk3368_pin_ctrl = {
2254                 .pin_banks              = rk3368_pin_banks,
2255                 .nr_banks               = ARRAY_SIZE(rk3368_pin_banks),
2256                 .label                  = "RK3368-GPIO",
2257                 .type                   = RK3368,
2258                 .grf_mux_offset         = 0x0,
2259                 .pmu_mux_offset         = 0x0,
2260                 .pull_calc_reg          = rk3288_calc_pull_reg_and_bit,
2261 };
2262
2263 static const struct of_device_id rockchip_pinctrl_dt_match[] = {
2264         { .compatible = "rockchip,rk2928-pinctrl",
2265                 .data = (void *)&rk2928_pin_ctrl },
2266         { .compatible = "rockchip,rk3066a-pinctrl",
2267                 .data = (void *)&rk3066a_pin_ctrl },
2268         { .compatible = "rockchip,rk3066b-pinctrl",
2269                 .data = (void *)&rk3066b_pin_ctrl },
2270         { .compatible = "rockchip,rk3188-pinctrl",
2271                 .data = (void *)&rk3188_pin_ctrl },
2272         { .compatible = "rockchip,rk3288-pinctrl",
2273                 .data = (void *)&rk3288_pin_ctrl },
2274         { .compatible = "rockchip,rk3368-pinctrl",
2275                 .data = (void *)&rk3368_pin_ctrl },
2276         {},
2277 };
2278 MODULE_DEVICE_TABLE(of, rockchip_pinctrl_dt_match);
2279
2280 static struct platform_driver rockchip_pinctrl_driver = {
2281         .probe          = rockchip_pinctrl_probe,
2282         .driver = {
2283                 .name   = "rockchip-pinctrl",
2284                 .owner  = THIS_MODULE,
2285                 .of_match_table = rockchip_pinctrl_dt_match,
2286         },
2287 };
2288
2289 #ifdef CONFIG_PM
2290 static struct syscore_ops rockchip_gpio_syscore_ops = {
2291         .suspend        = rockchip_pinctrl_suspend,
2292         .resume         = rockchip_pinctrl_resume,
2293 };
2294 #endif
2295
2296 static int __init rockchip_pinctrl_drv_register(void)
2297 {
2298 #ifdef CONFIG_PM
2299                 register_syscore_ops(&rockchip_gpio_syscore_ops);
2300 #endif
2301         return platform_driver_register(&rockchip_pinctrl_driver);
2302 }
2303 postcore_initcall(rockchip_pinctrl_drv_register);
2304
2305 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
2306 MODULE_DESCRIPTION("Rockchip pinctrl driver");
2307 MODULE_LICENSE("GPL v2");