drivers/pinctrl/sprd/pinctrl-sprd.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Spreadtrum pin controller driver
   4  * Copyright (C) 2017 Spreadtrum  - http://www.spreadtrum.com
   5  */
   6
   7 #include <linux/debugfs.h>
   8 #include <linux/err.h>
   9 #include <linux/init.h>
  10 #include <linux/io.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/of_device.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/pinctrl/machine.h>
  17 #include <linux/pinctrl/pinconf.h>
  18 #include <linux/pinctrl/pinconf-generic.h>
  19 #include <linux/pinctrl/pinctrl.h>
  20 #include <linux/pinctrl/pinmux.h>
  21 #include <linux/slab.h>
  22
  23 #include "../core.h"
  24 #include "../pinmux.h"
  25 #include "../pinconf.h"
  26 #include "../pinctrl-utils.h"
  27 #include "pinctrl-sprd.h"
  28
  29 #define PINCTRL_BIT_MASK(width)         (~(~0UL << (width)))
  30 #define PINCTRL_REG_OFFSET              0x20
  31 #define PINCTRL_REG_MISC_OFFSET         0x4020
  32 #define PINCTRL_REG_LEN                 0x4
  33
  34 #define PIN_FUNC_MASK                   (BIT(4) | BIT(5))
  35 #define PIN_FUNC_SEL_1                  ~PIN_FUNC_MASK
  36 #define PIN_FUNC_SEL_2                  BIT(4)
  37 #define PIN_FUNC_SEL_3                  BIT(5)
  38 #define PIN_FUNC_SEL_4                  PIN_FUNC_MASK
  39
  40 #define AP_SLEEP_MODE                   BIT(13)
  41 #define PUBCP_SLEEP_MODE                BIT(14)
  42 #define TGLDSP_SLEEP_MODE               BIT(15)
  43 #define AGDSP_SLEEP_MODE                BIT(16)
  44 #define CM4_SLEEP_MODE                  BIT(17)
  45 #define SLEEP_MODE_MASK                 GENMASK(5, 0)
  46 #define SLEEP_MODE_SHIFT                13
  47
  48 #define SLEEP_INPUT                     BIT(1)
  49 #define SLEEP_INPUT_MASK                0x1
  50 #define SLEEP_INPUT_SHIFT               1
  51
  52 #define SLEEP_OUTPUT                    BIT(0)
  53 #define SLEEP_OUTPUT_MASK               0x1
  54 #define SLEEP_OUTPUT_SHIFT              0
  55
  56 #define DRIVE_STRENGTH_MASK             GENMASK(3, 0)
  57 #define DRIVE_STRENGTH_SHIFT            19
  58
  59 #define SLEEP_PULL_DOWN                 BIT(2)
  60 #define SLEEP_PULL_DOWN_MASK            0x1
  61 #define SLEEP_PULL_DOWN_SHIFT           2
  62
  63 #define PULL_DOWN                       BIT(6)
  64 #define PULL_DOWN_MASK                  0x1
  65 #define PULL_DOWN_SHIFT                 6
  66
  67 #define SLEEP_PULL_UP                   BIT(3)
  68 #define SLEEP_PULL_UP_MASK              0x1
  69 #define SLEEP_PULL_UP_SHIFT             3
  70
  71 #define PULL_UP_20K                     (BIT(12) | BIT(7))
  72 #define PULL_UP_4_7K                    BIT(12)
  73 #define PULL_UP_MASK                    0x21
  74 #define PULL_UP_SHIFT                   7
  75
  76 #define INPUT_SCHMITT                   BIT(11)
  77 #define INPUT_SCHMITT_MASK              0x1
  78 #define INPUT_SCHMITT_SHIFT             11
  79
  80 enum pin_sleep_mode {
  81         AP_SLEEP = BIT(0),
  82         PUBCP_SLEEP = BIT(1),
  83         TGLDSP_SLEEP = BIT(2),
  84         AGDSP_SLEEP = BIT(3),
  85         CM4_SLEEP = BIT(4),
  86 };
  87
  88 enum pin_func_sel {
  89         PIN_FUNC_1,
  90         PIN_FUNC_2,
  91         PIN_FUNC_3,
  92         PIN_FUNC_4,
  93         PIN_FUNC_MAX,
  94 };
  95
  96 /**
  97  * struct sprd_pin: represent one pin's description
  98  * @name: pin name
  99  * @number: pin number
 100  * @type: pin type, can be GLOBAL_CTRL_PIN/COMMON_PIN/MISC_PIN
 101  * @reg: pin register address
 102  * @bit_offset: bit offset in pin register
 103  * @bit_width: bit width in pin register
 104  */
 105 struct sprd_pin {
 106         const char *name;
 107         unsigned int number;
 108         enum pin_type type;
 109         unsigned long reg;
 110         unsigned long bit_offset;
 111         unsigned long bit_width;
 112 };
 113
 114 /**
 115  * struct sprd_pin_group: represent one group's description
 116  * @name: group name
 117  * @npins: pin numbers of this group
 118  * @pins: pointer to pins array
 119  */
 120 struct sprd_pin_group {
 121         const char *name;
 122         unsigned int npins;
 123         unsigned int *pins;
 124 };
 125
 126 /**
 127  * struct sprd_pinctrl_soc_info: represent the SoC's pins description
 128  * @groups: pointer to groups of pins
 129  * @ngroups: group numbers of the whole SoC
 130  * @pins: pointer to pins description
 131  * @npins: pin numbers of the whole SoC
 132  * @grp_names: pointer to group names array
 133  */
 134 struct sprd_pinctrl_soc_info {
 135         struct sprd_pin_group *groups;
 136         unsigned int ngroups;
 137         struct sprd_pin *pins;
 138         unsigned int npins;
 139         const char **grp_names;
 140 };
 141
 142 /**
 143  * struct sprd_pinctrl: represent the pin controller device
 144  * @dev: pointer to the device structure
 145  * @pctl: pointer to the pinctrl handle
 146  * @base: base address of the controller
 147  * @info: pointer to SoC's pins description information
 148  */
 149 struct sprd_pinctrl {
 150         struct device *dev;
 151         struct pinctrl_dev *pctl;
 152         void __iomem *base;
 153         struct sprd_pinctrl_soc_info *info;
 154 };
 155
 156 #define SPRD_PIN_CONFIG_CONTROL         (PIN_CONFIG_END + 1)
 157 #define SPRD_PIN_CONFIG_SLEEP_MODE      (PIN_CONFIG_END + 2)
 158
 159 static int sprd_pinctrl_get_id_by_name(struct sprd_pinctrl *sprd_pctl,
 160                                        const char *name)
 161 {
 162         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
 163         int i;
 164
 165         for (i = 0; i < info->npins; i++) {
 166                 if (!strcmp(info->pins[i].name, name))
 167                         return info->pins[i].number;
 168         }
 169
 170         return -ENODEV;
 171 }
 172
 173 static struct sprd_pin *
 174 sprd_pinctrl_get_pin_by_id(struct sprd_pinctrl *sprd_pctl, unsigned int id)
 175 {
 176         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
 177         struct sprd_pin *pin = NULL;
 178         int i;
 179
 180         for (i = 0; i < info->npins; i++) {
 181                 if (info->pins[i].number == id) {
 182                         pin = &info->pins[i];
 183                         break;
 184                 }
 185         }
 186
 187         return pin;
 188 }
 189
 190 static const struct sprd_pin_group *
 191 sprd_pinctrl_find_group_by_name(struct sprd_pinctrl *sprd_pctl,
 192                                 const char *name)
 193 {
 194         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
 195         const struct sprd_pin_group *grp = NULL;
 196         int i;
 197
 198         for (i = 0; i < info->ngroups; i++) {
 199                 if (!strcmp(info->groups[i].name, name)) {
 200                         grp = &info->groups[i];
 201                         break;
 202                 }
 203         }
 204
 205         return grp;
 206 }
 207
 208 static int sprd_pctrl_group_count(struct pinctrl_dev *pctldev)
 209 {
 210         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 211         struct sprd_pinctrl_soc_info *info = pctl->info;
 212
 213         return info->ngroups;
 214 }
 215
 216 static const char *sprd_pctrl_group_name(struct pinctrl_dev *pctldev,
 217                                          unsigned int selector)
 218 {
 219         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 220         struct sprd_pinctrl_soc_info *info = pctl->info;
 221
 222         return info->groups[selector].name;
 223 }
 224
 225 static int sprd_pctrl_group_pins(struct pinctrl_dev *pctldev,
 226                                  unsigned int selector,
 227                                  const unsigned int **pins,
 228                                  unsigned int *npins)
 229 {
 230         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 231         struct sprd_pinctrl_soc_info *info = pctl->info;
 232
 233         if (selector >= info->ngroups)
 234                 return -EINVAL;
 235
 236         *pins = info->groups[selector].pins;
 237         *npins = info->groups[selector].npins;
 238
 239         return 0;
 240 }
 241
 242 static int sprd_dt_node_to_map(struct pinctrl_dev *pctldev,
 243                                struct device_node *np,
 244                                struct pinctrl_map **map,
 245                                unsigned int *num_maps)
 246 {
 247         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 248         const struct sprd_pin_group *grp;
 249         unsigned long *configs = NULL;
 250         unsigned int num_configs = 0;
 251         unsigned int reserved_maps = 0;
 252         unsigned int reserve = 0;
 253         const char *function;
 254         enum pinctrl_map_type type;
 255         int ret;
 256
 257         grp = sprd_pinctrl_find_group_by_name(pctl, np->name);
 258         if (!grp) {
 259                 dev_err(pctl->dev, "unable to find group for node %s\n",
 260                         of_node_full_name(np));
 261                 return -EINVAL;
 262         }
 263
 264         ret = of_property_count_strings(np, "pins");
 265         if (ret < 0)
 266                 return ret;
 267
 268         if (ret == 1)
 269                 type = PIN_MAP_TYPE_CONFIGS_PIN;
 270         else
 271                 type = PIN_MAP_TYPE_CONFIGS_GROUP;
 272
 273         ret = of_property_read_string(np, "function", &function);
 274         if (ret < 0) {
 275                 if (ret != -EINVAL)
 276                         dev_err(pctl->dev,
 277                                 "%s: could not parse property function\n",
 278                                 of_node_full_name(np));
 279                 function = NULL;
 280         }
 281
 282         ret = pinconf_generic_parse_dt_config(np, pctldev, &configs,
 283                                               &num_configs);
 284         if (ret < 0) {
 285                 dev_err(pctl->dev, "%s: could not parse node property\n",
 286                         of_node_full_name(np));
 287                 return ret;
 288         }
 289
 290         *map = NULL;
 291         *num_maps = 0;
 292
 293         if (function != NULL)
 294                 reserve++;
 295         if (num_configs)
 296                 reserve++;
 297
 298         ret = pinctrl_utils_reserve_map(pctldev, map, &reserved_maps,
 299                                         num_maps, reserve);
 300         if (ret < 0)
 301                 goto out;
 302
 303         if (function) {
 304                 ret = pinctrl_utils_add_map_mux(pctldev, map,
 305                                                 &reserved_maps, num_maps,
 306                                                 grp->name, function);
 307                 if (ret < 0)
 308                         goto out;
 309         }
 310
 311         if (num_configs) {
 312                 const char *group_or_pin;
 313                 unsigned int pin_id;
 314
 315                 if (type == PIN_MAP_TYPE_CONFIGS_PIN) {
 316                         pin_id = grp->pins[0];
 317                         group_or_pin = pin_get_name(pctldev, pin_id);
 318                 } else {
 319                         group_or_pin = grp->name;
 320                 }
 321
 322                 ret = pinctrl_utils_add_map_configs(pctldev, map,
 323                                                     &reserved_maps, num_maps,
 324                                                     group_or_pin, configs,
 325                                                     num_configs, type);
 326         }
 327
 328 out:
 329         kfree(configs);
 330         return ret;
 331 }
 332
 333 static void sprd_pctrl_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
 334                                 unsigned int offset)
 335 {
 336         seq_printf(s, "%s", dev_name(pctldev->dev));
 337 }
 338
 339 static const struct pinctrl_ops sprd_pctrl_ops = {
 340         .get_groups_count = sprd_pctrl_group_count,
 341         .get_group_name = sprd_pctrl_group_name,
 342         .get_group_pins = sprd_pctrl_group_pins,
 343         .pin_dbg_show = sprd_pctrl_dbg_show,
 344         .dt_node_to_map = sprd_dt_node_to_map,
 345         .dt_free_map = pinctrl_utils_free_map,
 346 };
 347
 348 static int sprd_pmx_get_function_count(struct pinctrl_dev *pctldev)
 349 {
 350         return PIN_FUNC_MAX;
 351 }
 352
 353 static const char *sprd_pmx_get_function_name(struct pinctrl_dev *pctldev,
 354                                               unsigned int selector)
 355 {
 356         switch (selector) {
 357         case PIN_FUNC_1:
 358                 return "func1";
 359         case PIN_FUNC_2:
 360                 return "func2";
 361         case PIN_FUNC_3:
 362                 return "func3";
 363         case PIN_FUNC_4:
 364                 return "func4";
 365         default:
 366                 return "null";
 367         }
 368 }
 369
 370 static int sprd_pmx_get_function_groups(struct pinctrl_dev *pctldev,
 371                                         unsigned int selector,
 372                                         const char * const **groups,
 373                                         unsigned int * const num_groups)
 374 {
 375         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 376         struct sprd_pinctrl_soc_info *info = pctl->info;
 377
 378         *groups = info->grp_names;
 379         *num_groups = info->ngroups;
 380
 381         return 0;
 382 }
 383
 384 static int sprd_pmx_set_mux(struct pinctrl_dev *pctldev,
 385                             unsigned int func_selector,
 386                             unsigned int group_selector)
 387 {
 388         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 389         struct sprd_pinctrl_soc_info *info = pctl->info;
 390         struct sprd_pin_group *grp = &info->groups[group_selector];
 391         unsigned int i, grp_pins = grp->npins;
 392         unsigned long reg;
 393         unsigned int val = 0;
 394
 395         if (group_selector >= info->ngroups)
 396                 return -EINVAL;
 397
 398         switch (func_selector) {
 399         case PIN_FUNC_1:
 400                 val &= PIN_FUNC_SEL_1;
 401                 break;
 402         case PIN_FUNC_2:
 403                 val |= PIN_FUNC_SEL_2;
 404                 break;
 405         case PIN_FUNC_3:
 406                 val |= PIN_FUNC_SEL_3;
 407                 break;
 408         case PIN_FUNC_4:
 409                 val |= PIN_FUNC_SEL_4;
 410                 break;
 411         default:
 412                 break;
 413         }
 414
 415         for (i = 0; i < grp_pins; i++) {
 416                 unsigned int pin_id = grp->pins[i];
 417                 struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
 418
 419                 if (!pin || pin->type != COMMON_PIN)
 420                         continue;
 421
 422                 reg = readl((void __iomem *)pin->reg);
 423                 reg &= ~PIN_FUNC_MASK;
 424                 reg |= val;
 425                 writel(reg, (void __iomem *)pin->reg);
 426         }
 427
 428         return 0;
 429 }
 430
 431 static const struct pinmux_ops sprd_pmx_ops = {
 432         .get_functions_count = sprd_pmx_get_function_count,
 433         .get_function_name = sprd_pmx_get_function_name,
 434         .get_function_groups = sprd_pmx_get_function_groups,
 435         .set_mux = sprd_pmx_set_mux,
 436 };
 437
 438 static int sprd_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin_id,
 439                             unsigned long *config)
 440 {
 441         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 442         struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
 443         unsigned int param = pinconf_to_config_param(*config);
 444         unsigned int reg, arg;
 445
 446         if (!pin)
 447                 return -EINVAL;
 448
 449         if (pin->type == GLOBAL_CTRL_PIN) {
 450                 reg = (readl((void __iomem *)pin->reg) >>
 451                            pin->bit_offset) & PINCTRL_BIT_MASK(pin->bit_width);
 452         } else {
 453                 reg = readl((void __iomem *)pin->reg);
 454         }
 455
 456         if (pin->type == GLOBAL_CTRL_PIN &&
 457             param == SPRD_PIN_CONFIG_CONTROL) {
 458                 arg = reg;
 459         } else if (pin->type == COMMON_PIN || pin->type == MISC_PIN) {
 460                 switch (param) {
 461                 case SPRD_PIN_CONFIG_SLEEP_MODE:
 462                         arg = (reg >> SLEEP_MODE_SHIFT) & SLEEP_MODE_MASK;
 463                         break;
 464                 case PIN_CONFIG_INPUT_ENABLE:
 465                         arg = (reg >> SLEEP_INPUT_SHIFT) & SLEEP_INPUT_MASK;
 466                         break;
 467                 case PIN_CONFIG_OUTPUT:
 468                         arg = reg & SLEEP_OUTPUT_MASK;
 469                         break;
 470                 case PIN_CONFIG_DRIVE_STRENGTH:
 471                         arg = (reg >> DRIVE_STRENGTH_SHIFT) &
 472                                 DRIVE_STRENGTH_MASK;
 473                         break;
 474                 case PIN_CONFIG_BIAS_PULL_DOWN:
 475                         /* combine sleep pull down and pull down config */
 476                         arg = ((reg >> SLEEP_PULL_DOWN_SHIFT) &
 477                                SLEEP_PULL_DOWN_MASK) << 16;
 478                         arg |= (reg >> PULL_DOWN_SHIFT) & PULL_DOWN_MASK;
 479                         break;
 480                 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
 481                         arg = (reg >> INPUT_SCHMITT_SHIFT) & INPUT_SCHMITT_MASK;
 482                         break;
 483                 case PIN_CONFIG_BIAS_PULL_UP:
 484                         /* combine sleep pull up and pull up config */
 485                         arg = ((reg >> SLEEP_PULL_UP_SHIFT) &
 486                                SLEEP_PULL_UP_MASK) << 16;
 487                         arg |= (reg >> PULL_UP_SHIFT) & PULL_UP_MASK;
 488                         break;
 489                 case PIN_CONFIG_BIAS_DISABLE:
 490                         if ((reg & (SLEEP_PULL_DOWN | SLEEP_PULL_UP)) ||
 491                             (reg & (PULL_DOWN | PULL_UP_4_7K | PULL_UP_20K)))
 492                                 return -EINVAL;
 493
 494                         arg = 1;
 495                         break;
 496                 case PIN_CONFIG_SLEEP_HARDWARE_STATE:
 497                         arg = 0;
 498                         break;
 499                 default:
 500                         return -ENOTSUPP;
 501                 }
 502         } else {
 503                 return -ENOTSUPP;
 504         }
 505
 506         *config = pinconf_to_config_packed(param, arg);
 507         return 0;
 508 }
 509
 510 static unsigned int sprd_pinconf_drive(unsigned int mA)
 511 {
 512         unsigned int val = 0;
 513
 514         switch (mA) {
 515         case 2:
 516                 break;
 517         case 4:
 518                 val |= BIT(19);
 519                 break;
 520         case 6:
 521                 val |= BIT(20);
 522                 break;
 523         case 8:
 524                 val |= BIT(19) | BIT(20);
 525                 break;
 526         case 10:
 527                 val |= BIT(21);
 528                 break;
 529         case 12:
 530                 val |= BIT(21) | BIT(19);
 531                 break;
 532         case 14:
 533                 val |= BIT(21) | BIT(20);
 534                 break;
 535         case 16:
 536                 val |= BIT(19) | BIT(20) | BIT(21);
 537                 break;
 538         case 20:
 539                 val |= BIT(22);
 540                 break;
 541         case 21:
 542                 val |= BIT(22) | BIT(19);
 543                 break;
 544         case 24:
 545                 val |= BIT(22) | BIT(20);
 546                 break;
 547         case 25:
 548                 val |= BIT(22) | BIT(20) | BIT(19);
 549                 break;
 550         case 27:
 551                 val |= BIT(22) | BIT(21);
 552                 break;
 553         case 29:
 554                 val |= BIT(22) | BIT(21) | BIT(19);
 555                 break;
 556         case 31:
 557                 val |= BIT(22) | BIT(21) | BIT(20);
 558                 break;
 559         case 33:
 560                 val |= BIT(22) | BIT(21) | BIT(20) | BIT(19);
 561                 break;
 562         default:
 563                 break;
 564         }
 565
 566         return val;
 567 }
 568
 569 static bool sprd_pinctrl_check_sleep_config(unsigned long *configs,
 570                                             unsigned int num_configs)
 571 {
 572         unsigned int param;
 573         int i;
 574
 575         for (i = 0; i < num_configs; i++) {
 576                 param = pinconf_to_config_param(configs[i]);
 577                 if (param == PIN_CONFIG_SLEEP_HARDWARE_STATE)
 578                         return true;
 579         }
 580
 581         return false;
 582 }
 583
 584 static int sprd_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin_id,
 585                             unsigned long *configs, unsigned int num_configs)
 586 {
 587         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 588         struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
 589         bool is_sleep_config;
 590         unsigned long reg;
 591         int i;
 592
 593         if (!pin)
 594                 return -EINVAL;
 595
 596         is_sleep_config = sprd_pinctrl_check_sleep_config(configs, num_configs);
 597
 598         for (i = 0; i < num_configs; i++) {
 599                 unsigned int param, arg, shift, mask, val;
 600
 601                 param = pinconf_to_config_param(configs[i]);
 602                 arg = pinconf_to_config_argument(configs[i]);
 603
 604                 val = 0;
 605                 shift = 0;
 606                 mask = 0;
 607                 if (pin->type == GLOBAL_CTRL_PIN &&
 608                     param == SPRD_PIN_CONFIG_CONTROL) {
 609                         val = arg;
 610                 } else if (pin->type == COMMON_PIN || pin->type == MISC_PIN) {
 611                         switch (param) {
 612                         case SPRD_PIN_CONFIG_SLEEP_MODE:
 613                                 if (arg & AP_SLEEP)
 614                                         val |= AP_SLEEP_MODE;
 615                                 if (arg & PUBCP_SLEEP)
 616                                         val |= PUBCP_SLEEP_MODE;
 617                                 if (arg & TGLDSP_SLEEP)
 618                                         val |= TGLDSP_SLEEP_MODE;
 619                                 if (arg & AGDSP_SLEEP)
 620                                         val |= AGDSP_SLEEP_MODE;
 621                                 if (arg & CM4_SLEEP)
 622                                         val |= CM4_SLEEP_MODE;
 623
 624                                 mask = SLEEP_MODE_MASK;
 625                                 shift = SLEEP_MODE_SHIFT;
 626                                 break;
 627                         case PIN_CONFIG_INPUT_ENABLE:
 628                                 if (is_sleep_config == true) {
 629                                         if (arg > 0)
 630                                                 val |= SLEEP_INPUT;
 631                                         else
 632                                                 val &= ~SLEEP_INPUT;
 633
 634                                         mask = SLEEP_INPUT_MASK;
 635                                         shift = SLEEP_INPUT_SHIFT;
 636                                 }
 637                                 break;
 638                         case PIN_CONFIG_OUTPUT:
 639                                 if (is_sleep_config == true) {
 640                                         val |= SLEEP_OUTPUT;
 641                                         mask = SLEEP_OUTPUT_MASK;
 642                                         shift = SLEEP_OUTPUT_SHIFT;
 643                                 }
 644                                 break;
 645                         case PIN_CONFIG_DRIVE_STRENGTH:
 646                                 if (arg < 2 || arg > 60)
 647                                         return -EINVAL;
 648
 649                                 val = sprd_pinconf_drive(arg);
 650                                 mask = DRIVE_STRENGTH_MASK;
 651                                 shift = DRIVE_STRENGTH_SHIFT;
 652                                 break;
 653                         case PIN_CONFIG_BIAS_PULL_DOWN:
 654                                 if (is_sleep_config == true) {
 655                                         val |= SLEEP_PULL_DOWN;
 656                                         mask = SLEEP_PULL_DOWN_MASK;
 657                                         shift = SLEEP_PULL_DOWN_SHIFT;
 658                                 } else {
 659                                         val |= PULL_DOWN;
 660                                         mask = PULL_DOWN_MASK;
 661                                         shift = PULL_DOWN_SHIFT;
 662                                 }
 663                                 break;
 664                         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
 665                                 if (arg > 0)
 666                                         val |= INPUT_SCHMITT;
 667                                 else
 668                                         val &= ~INPUT_SCHMITT;
 669
 670                                 mask = INPUT_SCHMITT_MASK;
 671                                 shift = INPUT_SCHMITT_SHIFT;
 672                                 break;
 673                         case PIN_CONFIG_BIAS_PULL_UP:
 674                                 if (is_sleep_config == true) {
 675                                         val |= SLEEP_PULL_UP;
 676                                         mask = SLEEP_PULL_UP_MASK;
 677                                         shift = SLEEP_PULL_UP_SHIFT;
 678                                 } else {
 679                                         if (arg == 20000)
 680                                                 val |= PULL_UP_20K;
 681                                         else if (arg == 4700)
 682                                                 val |= PULL_UP_4_7K;
 683
 684                                         mask = PULL_UP_MASK;
 685                                         shift = PULL_UP_SHIFT;
 686                                 }
 687                                 break;
 688                         case PIN_CONFIG_BIAS_DISABLE:
 689                                 if (is_sleep_config == true) {
 690                                         val = shift = 0;
 691                                         mask = SLEEP_PULL_DOWN | SLEEP_PULL_UP;
 692                                 } else {
 693                                         val = shift = 0;
 694                                         mask = PULL_DOWN | PULL_UP_20K |
 695                                                 PULL_UP_4_7K;
 696                                 }
 697                                 break;
 698                         case PIN_CONFIG_SLEEP_HARDWARE_STATE:
 699                                 continue;
 700                         default:
 701                                 return -ENOTSUPP;
 702                         }
 703                 } else {
 704                         return -ENOTSUPP;
 705                 }
 706
 707                 if (pin->type == GLOBAL_CTRL_PIN) {
 708                         reg = readl((void __iomem *)pin->reg);
 709                         reg &= ~(PINCTRL_BIT_MASK(pin->bit_width)
 710                                 << pin->bit_offset);
 711                         reg |= (val & PINCTRL_BIT_MASK(pin->bit_width))
 712                                 << pin->bit_offset;
 713                         writel(reg, (void __iomem *)pin->reg);
 714                 } else {
 715                         reg = readl((void __iomem *)pin->reg);
 716                         reg &= ~(mask << shift);
 717                         reg |= val;
 718                         writel(reg, (void __iomem *)pin->reg);
 719                 }
 720         }
 721
 722         return 0;
 723 }
 724
 725 static int sprd_pinconf_group_get(struct pinctrl_dev *pctldev,
 726                                   unsigned int selector, unsigned long *config)
 727 {
 728         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 729         struct sprd_pinctrl_soc_info *info = pctl->info;
 730         struct sprd_pin_group *grp;
 731         unsigned int pin_id;
 732
 733         if (selector >= info->ngroups)
 734                 return -EINVAL;
 735
 736         grp = &info->groups[selector];
 737         pin_id = grp->pins[0];
 738
 739         return sprd_pinconf_get(pctldev, pin_id, config);
 740 }
 741
 742 static int sprd_pinconf_group_set(struct pinctrl_dev *pctldev,
 743                                   unsigned int selector,
 744                                   unsigned long *configs,
 745                                   unsigned int num_configs)
 746 {
 747         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 748         struct sprd_pinctrl_soc_info *info = pctl->info;
 749         struct sprd_pin_group *grp;
 750         int ret, i;
 751
 752         if (selector >= info->ngroups)
 753                 return -EINVAL;
 754
 755         grp = &info->groups[selector];
 756
 757         for (i = 0; i < grp->npins; i++) {
 758                 unsigned int pin_id = grp->pins[i];
 759
 760                 ret = sprd_pinconf_set(pctldev, pin_id, configs, num_configs);
 761                 if (ret)
 762                         return ret;
 763         }
 764
 765         return 0;
 766 }
 767
 768 static int sprd_pinconf_get_config(struct pinctrl_dev *pctldev,
 769                                    unsigned int pin_id,
 770                                    unsigned long *config)
 771 {
 772         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 773         struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
 774
 775         if (!pin)
 776                 return -EINVAL;
 777
 778         if (pin->type == GLOBAL_CTRL_PIN) {
 779                 *config = (readl((void __iomem *)pin->reg) >>
 780                            pin->bit_offset) & PINCTRL_BIT_MASK(pin->bit_width);
 781         } else {
 782                 *config = readl((void __iomem *)pin->reg);
 783         }
 784
 785         return 0;
 786 }
 787
 788 static void sprd_pinconf_dbg_show(struct pinctrl_dev *pctldev,
 789                                   struct seq_file *s, unsigned int pin_id)
 790 {
 791         unsigned long config;
 792         int ret;
 793
 794         ret = sprd_pinconf_get_config(pctldev, pin_id, &config);
 795         if (ret)
 796                 return;
 797
 798         seq_printf(s, "0x%lx", config);
 799 }
 800
 801 static void sprd_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
 802                                         struct seq_file *s,
 803                                         unsigned int selector)
 804 {
 805         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 806         struct sprd_pinctrl_soc_info *info = pctl->info;
 807         struct sprd_pin_group *grp;
 808         unsigned long config;
 809         const char *name;
 810         int i, ret;
 811
 812         if (selector >= info->ngroups)
 813                 return;
 814
 815         grp = &info->groups[selector];
 816
 817         seq_putc(s, '\n');
 818         for (i = 0; i < grp->npins; i++, config++) {
 819                 unsigned int pin_id = grp->pins[i];
 820
 821                 name = pin_get_name(pctldev, pin_id);
 822                 ret = sprd_pinconf_get_config(pctldev, pin_id, &config);
 823                 if (ret)
 824                         return;
 825
 826                 seq_printf(s, "%s: 0x%lx ", name, config);
 827         }
 828 }
 829
 830 static const struct pinconf_ops sprd_pinconf_ops = {
 831         .is_generic = true,
 832         .pin_config_get = sprd_pinconf_get,
 833         .pin_config_set = sprd_pinconf_set,
 834         .pin_config_group_get = sprd_pinconf_group_get,
 835         .pin_config_group_set = sprd_pinconf_group_set,
 836         .pin_config_dbg_show = sprd_pinconf_dbg_show,
 837         .pin_config_group_dbg_show = sprd_pinconf_group_dbg_show,
 838 };
 839
 840 static const struct pinconf_generic_params sprd_dt_params[] = {
 841         {"sprd,control", SPRD_PIN_CONFIG_CONTROL, 0},
 842         {"sprd,sleep-mode", SPRD_PIN_CONFIG_SLEEP_MODE, 0},
 843 };
 844
 845 #ifdef CONFIG_DEBUG_FS
 846 static const struct pin_config_item sprd_conf_items[] = {
 847         PCONFDUMP(SPRD_PIN_CONFIG_CONTROL, "global control", NULL, true),
 848         PCONFDUMP(SPRD_PIN_CONFIG_SLEEP_MODE, "sleep mode", NULL, true),
 849 };
 850 #endif
 851
 852 static struct pinctrl_desc sprd_pinctrl_desc = {
 853         .pctlops = &sprd_pctrl_ops,
 854         .pmxops = &sprd_pmx_ops,
 855         .confops = &sprd_pinconf_ops,
 856         .num_custom_params = ARRAY_SIZE(sprd_dt_params),
 857         .custom_params = sprd_dt_params,
 858 #ifdef CONFIG_DEBUG_FS
 859         .custom_conf_items = sprd_conf_items,
 860 #endif
 861         .owner = THIS_MODULE,
 862 };
 863
 864 static int sprd_pinctrl_parse_groups(struct device_node *np,
 865                                      struct sprd_pinctrl *sprd_pctl,
 866                                      struct sprd_pin_group *grp)
 867 {
 868         struct property *prop;
 869         const char *pin_name;
 870         int ret, i = 0;
 871
 872         ret = of_property_count_strings(np, "pins");
 873         if (ret < 0)
 874                 return ret;
 875
 876         grp->name = np->name;
 877         grp->npins = ret;
 878         grp->pins = devm_kcalloc(sprd_pctl->dev,
 879                                  grp->npins, sizeof(unsigned int),
 880                                  GFP_KERNEL);
 881         if (!grp->pins)
 882                 return -ENOMEM;
 883
 884         of_property_for_each_string(np, "pins", prop, pin_name) {
 885                 ret = sprd_pinctrl_get_id_by_name(sprd_pctl, pin_name);
 886                 if (ret >= 0)
 887                         grp->pins[i++] = ret;
 888         }
 889
 890         for (i = 0; i < grp->npins; i++) {
 891                 dev_dbg(sprd_pctl->dev,
 892                         "Group[%s] contains [%d] pins: id = %d\n",
 893                         grp->name, grp->npins, grp->pins[i]);
 894         }
 895
 896         return 0;
 897 }
 898
 899 static unsigned int sprd_pinctrl_get_groups(struct device_node *np)
 900 {
 901         struct device_node *child;
 902         unsigned int group_cnt, cnt;
 903
 904         group_cnt = of_get_child_count(np);
 905
 906         for_each_child_of_node(np, child) {
 907                 cnt = of_get_child_count(child);
 908                 if (cnt > 0)
 909                         group_cnt += cnt;
 910         }
 911
 912         return group_cnt;
 913 }
 914
 915 static int sprd_pinctrl_parse_dt(struct sprd_pinctrl *sprd_pctl)
 916 {
 917         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
 918         struct device_node *np = sprd_pctl->dev->of_node;
 919         struct device_node *child, *sub_child;
 920         struct sprd_pin_group *grp;
 921         const char **temp;
 922         int ret;
 923
 924         if (!np)
 925                 return -ENODEV;
 926
 927         info->ngroups = sprd_pinctrl_get_groups(np);
 928         if (!info->ngroups)
 929                 return 0;
 930
 931         info->groups = devm_kcalloc(sprd_pctl->dev,
 932                                     info->ngroups,
 933                                     sizeof(struct sprd_pin_group),
 934                                     GFP_KERNEL);
 935         if (!info->groups)
 936                 return -ENOMEM;
 937
 938         info->grp_names = devm_kcalloc(sprd_pctl->dev,
 939                                        info->ngroups, sizeof(char *),
 940                                        GFP_KERNEL);
 941         if (!info->grp_names)
 942                 return -ENOMEM;
 943
 944         temp = info->grp_names;
 945         grp = info->groups;
 946
 947         for_each_child_of_node(np, child) {
 948                 ret = sprd_pinctrl_parse_groups(child, sprd_pctl, grp);
 949                 if (ret) {
 950                         of_node_put(child);
 951                         return ret;
 952                 }
 953
 954                 *temp++ = grp->name;
 955                 grp++;
 956
 957                 if (of_get_child_count(child) > 0) {
 958                         for_each_child_of_node(child, sub_child) {
 959                                 ret = sprd_pinctrl_parse_groups(sub_child,
 960                                                                 sprd_pctl, grp);
 961                                 if (ret) {
 962                                         of_node_put(sub_child);
 963                                         of_node_put(child);
 964                                         return ret;
 965                                 }
 966
 967                                 *temp++ = grp->name;
 968                                 grp++;
 969                         }
 970                 }
 971         }
 972
 973         return 0;
 974 }
 975
 976 static int sprd_pinctrl_add_pins(struct sprd_pinctrl *sprd_pctl,
 977                                  struct sprd_pins_info *sprd_soc_pin_info,
 978                                  int pins_cnt)
 979 {
 980         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
 981         unsigned int ctrl_pin = 0, com_pin = 0;
 982         struct sprd_pin *pin;
 983         int i;
 984
 985         info->npins = pins_cnt;
 986         info->pins = devm_kcalloc(sprd_pctl->dev,
 987                                   info->npins, sizeof(struct sprd_pin),
 988                                   GFP_KERNEL);
 989         if (!info->pins)
 990                 return -ENOMEM;
 991
 992         for (i = 0, pin = info->pins; i < info->npins; i++, pin++) {
 993                 unsigned int reg;
 994
 995                 pin->name = sprd_soc_pin_info[i].name;
 996                 pin->type = sprd_soc_pin_info[i].type;
 997                 pin->number = sprd_soc_pin_info[i].num;
 998                 reg = sprd_soc_pin_info[i].reg;
 999                 if (pin->type == GLOBAL_CTRL_PIN) {
1000                         pin->reg = (unsigned long)sprd_pctl->base +
1001                                 PINCTRL_REG_LEN * reg;
1002                         pin->bit_offset = sprd_soc_pin_info[i].bit_offset;
1003                         pin->bit_width = sprd_soc_pin_info[i].bit_width;
1004                         ctrl_pin++;
1005                 } else if (pin->type == COMMON_PIN) {
1006                         pin->reg = (unsigned long)sprd_pctl->base +
1007                                 PINCTRL_REG_OFFSET + PINCTRL_REG_LEN *
1008                                 (i - ctrl_pin);
1009                         com_pin++;
1010                 } else if (pin->type == MISC_PIN) {
1011                         pin->reg = (unsigned long)sprd_pctl->base +
1012                                 PINCTRL_REG_MISC_OFFSET + PINCTRL_REG_LEN *
1013                                 (i - ctrl_pin - com_pin);
1014                 }
1015         }
1016
1017         for (i = 0, pin = info->pins; i < info->npins; pin++, i++) {
1018                 dev_dbg(sprd_pctl->dev, "pin name[%s-%d], type = %d, "
1019                         "bit offset = %ld, bit width = %ld, reg = 0x%lx\n",
1020                         pin->name, pin->number, pin->type,
1021                         pin->bit_offset, pin->bit_width, pin->reg);
1022         }
1023
1024         return 0;
1025 }
1026
1027 int sprd_pinctrl_core_probe(struct platform_device *pdev,
1028                             struct sprd_pins_info *sprd_soc_pin_info,
1029                             int pins_cnt)
1030 {
1031         struct sprd_pinctrl *sprd_pctl;
1032         struct sprd_pinctrl_soc_info *pinctrl_info;
1033         struct pinctrl_pin_desc *pin_desc;
1034         int ret, i;
1035
1036         sprd_pctl = devm_kzalloc(&pdev->dev, sizeof(struct sprd_pinctrl),
1037                                  GFP_KERNEL);
1038         if (!sprd_pctl)
1039                 return -ENOMEM;
1040
1041         sprd_pctl->base = devm_platform_ioremap_resource(pdev, 0);
1042         if (IS_ERR(sprd_pctl->base))
1043                 return PTR_ERR(sprd_pctl->base);
1044
1045         pinctrl_info = devm_kzalloc(&pdev->dev,
1046                                     sizeof(struct sprd_pinctrl_soc_info),
1047                                     GFP_KERNEL);
1048         if (!pinctrl_info)
1049                 return -ENOMEM;
1050
1051         sprd_pctl->info = pinctrl_info;
1052         sprd_pctl->dev = &pdev->dev;
1053         platform_set_drvdata(pdev, sprd_pctl);
1054
1055         ret = sprd_pinctrl_add_pins(sprd_pctl, sprd_soc_pin_info, pins_cnt);
1056         if (ret) {
1057                 dev_err(&pdev->dev, "fail to add pins information\n");
1058                 return ret;
1059         }
1060
1061         ret = sprd_pinctrl_parse_dt(sprd_pctl);
1062         if (ret) {
1063                 dev_err(&pdev->dev, "fail to parse dt properties\n");
1064                 return ret;
1065         }
1066
1067         pin_desc = devm_kcalloc(&pdev->dev,
1068                                 pinctrl_info->npins,
1069                                 sizeof(struct pinctrl_pin_desc),
1070                                 GFP_KERNEL);
1071         if (!pin_desc)
1072                 return -ENOMEM;
1073
1074         for (i = 0; i < pinctrl_info->npins; i++) {
1075                 pin_desc[i].number = pinctrl_info->pins[i].number;
1076                 pin_desc[i].name = pinctrl_info->pins[i].name;
1077                 pin_desc[i].drv_data = pinctrl_info;
1078         }
1079
1080         sprd_pinctrl_desc.pins = pin_desc;
1081         sprd_pinctrl_desc.name = dev_name(&pdev->dev);
1082         sprd_pinctrl_desc.npins = pinctrl_info->npins;
1083
1084         sprd_pctl->pctl = pinctrl_register(&sprd_pinctrl_desc,
1085                                            &pdev->dev, (void *)sprd_pctl);
1086         if (IS_ERR(sprd_pctl->pctl)) {
1087                 dev_err(&pdev->dev, "could not register pinctrl driver\n");
1088                 return PTR_ERR(sprd_pctl->pctl);
1089         }
1090
1091         return 0;
1092 }
1093
1094 int sprd_pinctrl_remove(struct platform_device *pdev)
1095 {
1096         struct sprd_pinctrl *sprd_pctl = platform_get_drvdata(pdev);
1097
1098         pinctrl_unregister(sprd_pctl->pctl);
1099         return 0;
1100 }
1101
1102 void sprd_pinctrl_shutdown(struct platform_device *pdev)
1103 {
1104         struct pinctrl *pinctl;
1105         struct pinctrl_state *state;
1106
1107         pinctl = devm_pinctrl_get(&pdev->dev);
1108         if (IS_ERR(pinctl))
1109                 return;
1110         state = pinctrl_lookup_state(pinctl, "shutdown");
1111         if (IS_ERR(state))
1112                 return;
1113         pinctrl_select_state(pinctl, state);
1114 }
1115
1116 MODULE_DESCRIPTION("SPREADTRUM Pin Controller Driver");
1117 MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");
1118 MODULE_LICENSE("GPL v2");