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_4_7K                    (BIT(12) | BIT(7))
  72 #define PULL_UP_20K                     BIT(7)
  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_ENABLE:
 468                         arg = reg & SLEEP_OUTPUT_MASK;
 469                         break;
 470                 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
 471                         if ((reg & SLEEP_OUTPUT) || (reg & SLEEP_INPUT))
 472                                 return -EINVAL;
 473
 474                         arg = 1;
 475                         break;
 476                 case PIN_CONFIG_DRIVE_STRENGTH:
 477                         arg = (reg >> DRIVE_STRENGTH_SHIFT) &
 478                                 DRIVE_STRENGTH_MASK;
 479                         break;
 480                 case PIN_CONFIG_BIAS_PULL_DOWN:
 481                         /* combine sleep pull down and pull down config */
 482                         arg = ((reg >> SLEEP_PULL_DOWN_SHIFT) &
 483                                SLEEP_PULL_DOWN_MASK) << 16;
 484                         arg |= (reg >> PULL_DOWN_SHIFT) & PULL_DOWN_MASK;
 485                         break;
 486                 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
 487                         arg = (reg >> INPUT_SCHMITT_SHIFT) & INPUT_SCHMITT_MASK;
 488                         break;
 489                 case PIN_CONFIG_BIAS_PULL_UP:
 490                         /* combine sleep pull up and pull up config */
 491                         arg = ((reg >> SLEEP_PULL_UP_SHIFT) &
 492                                SLEEP_PULL_UP_MASK) << 16;
 493                         arg |= (reg >> PULL_UP_SHIFT) & PULL_UP_MASK;
 494                         break;
 495                 case PIN_CONFIG_BIAS_DISABLE:
 496                         if ((reg & (SLEEP_PULL_DOWN | SLEEP_PULL_UP)) ||
 497                             (reg & (PULL_DOWN | PULL_UP_4_7K | PULL_UP_20K)))
 498                                 return -EINVAL;
 499
 500                         arg = 1;
 501                         break;
 502                 case PIN_CONFIG_SLEEP_HARDWARE_STATE:
 503                         arg = 0;
 504                         break;
 505                 default:
 506                         return -ENOTSUPP;
 507                 }
 508         } else {
 509                 return -ENOTSUPP;
 510         }
 511
 512         *config = pinconf_to_config_packed(param, arg);
 513         return 0;
 514 }
 515
 516 static unsigned int sprd_pinconf_drive(unsigned int mA)
 517 {
 518         unsigned int val = 0;
 519
 520         switch (mA) {
 521         case 2:
 522                 break;
 523         case 4:
 524                 val |= BIT(19);
 525                 break;
 526         case 6:
 527                 val |= BIT(20);
 528                 break;
 529         case 8:
 530                 val |= BIT(19) | BIT(20);
 531                 break;
 532         case 10:
 533                 val |= BIT(21);
 534                 break;
 535         case 12:
 536                 val |= BIT(21) | BIT(19);
 537                 break;
 538         case 14:
 539                 val |= BIT(21) | BIT(20);
 540                 break;
 541         case 16:
 542                 val |= BIT(19) | BIT(20) | BIT(21);
 543                 break;
 544         case 20:
 545                 val |= BIT(22);
 546                 break;
 547         case 21:
 548                 val |= BIT(22) | BIT(19);
 549                 break;
 550         case 24:
 551                 val |= BIT(22) | BIT(20);
 552                 break;
 553         case 25:
 554                 val |= BIT(22) | BIT(20) | BIT(19);
 555                 break;
 556         case 27:
 557                 val |= BIT(22) | BIT(21);
 558                 break;
 559         case 29:
 560                 val |= BIT(22) | BIT(21) | BIT(19);
 561                 break;
 562         case 31:
 563                 val |= BIT(22) | BIT(21) | BIT(20);
 564                 break;
 565         case 33:
 566                 val |= BIT(22) | BIT(21) | BIT(20) | BIT(19);
 567                 break;
 568         default:
 569                 break;
 570         }
 571
 572         return val;
 573 }
 574
 575 static bool sprd_pinctrl_check_sleep_config(unsigned long *configs,
 576                                             unsigned int num_configs)
 577 {
 578         unsigned int param;
 579         int i;
 580
 581         for (i = 0; i < num_configs; i++) {
 582                 param = pinconf_to_config_param(configs[i]);
 583                 if (param == PIN_CONFIG_SLEEP_HARDWARE_STATE)
 584                         return true;
 585         }
 586
 587         return false;
 588 }
 589
 590 static int sprd_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin_id,
 591                             unsigned long *configs, unsigned int num_configs)
 592 {
 593         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 594         struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
 595         bool is_sleep_config;
 596         unsigned long reg;
 597         int i;
 598
 599         if (!pin)
 600                 return -EINVAL;
 601
 602         is_sleep_config = sprd_pinctrl_check_sleep_config(configs, num_configs);
 603
 604         for (i = 0; i < num_configs; i++) {
 605                 unsigned int param, arg, shift, mask, val;
 606
 607                 param = pinconf_to_config_param(configs[i]);
 608                 arg = pinconf_to_config_argument(configs[i]);
 609
 610                 val = 0;
 611                 shift = 0;
 612                 mask = 0;
 613                 if (pin->type == GLOBAL_CTRL_PIN &&
 614                     param == SPRD_PIN_CONFIG_CONTROL) {
 615                         val = arg;
 616                 } else if (pin->type == COMMON_PIN || pin->type == MISC_PIN) {
 617                         switch (param) {
 618                         case SPRD_PIN_CONFIG_SLEEP_MODE:
 619                                 if (arg & AP_SLEEP)
 620                                         val |= AP_SLEEP_MODE;
 621                                 if (arg & PUBCP_SLEEP)
 622                                         val |= PUBCP_SLEEP_MODE;
 623                                 if (arg & TGLDSP_SLEEP)
 624                                         val |= TGLDSP_SLEEP_MODE;
 625                                 if (arg & AGDSP_SLEEP)
 626                                         val |= AGDSP_SLEEP_MODE;
 627                                 if (arg & CM4_SLEEP)
 628                                         val |= CM4_SLEEP_MODE;
 629
 630                                 mask = SLEEP_MODE_MASK;
 631                                 shift = SLEEP_MODE_SHIFT;
 632                                 break;
 633                         case PIN_CONFIG_INPUT_ENABLE:
 634                                 if (is_sleep_config == true) {
 635                                         if (arg > 0)
 636                                                 val |= SLEEP_INPUT;
 637                                         else
 638                                                 val &= ~SLEEP_INPUT;
 639
 640                                         mask = SLEEP_INPUT_MASK;
 641                                         shift = SLEEP_INPUT_SHIFT;
 642                                 }
 643                                 break;
 644                         case PIN_CONFIG_OUTPUT_ENABLE:
 645                                 if (is_sleep_config == true) {
 646                                         if (arg > 0)
 647                                                 val |= SLEEP_OUTPUT;
 648                                         else
 649                                                 val &= ~SLEEP_OUTPUT;
 650
 651                                         mask = SLEEP_OUTPUT_MASK;
 652                                         shift = SLEEP_OUTPUT_SHIFT;
 653                                 }
 654                                 break;
 655                         case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
 656                                 if (is_sleep_config == true) {
 657                                         val = shift = 0;
 658                                         mask = SLEEP_OUTPUT | SLEEP_INPUT;
 659                                 }
 660                                 break;
 661                         case PIN_CONFIG_DRIVE_STRENGTH:
 662                                 if (arg < 2 || arg > 60)
 663                                         return -EINVAL;
 664
 665                                 val = sprd_pinconf_drive(arg);
 666                                 mask = DRIVE_STRENGTH_MASK;
 667                                 shift = DRIVE_STRENGTH_SHIFT;
 668                                 break;
 669                         case PIN_CONFIG_BIAS_PULL_DOWN:
 670                                 if (is_sleep_config == true) {
 671                                         val |= SLEEP_PULL_DOWN;
 672                                         mask = SLEEP_PULL_DOWN_MASK;
 673                                         shift = SLEEP_PULL_DOWN_SHIFT;
 674                                 } else {
 675                                         val |= PULL_DOWN;
 676                                         mask = PULL_DOWN_MASK;
 677                                         shift = PULL_DOWN_SHIFT;
 678                                 }
 679                                 break;
 680                         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
 681                                 if (arg > 0)
 682                                         val |= INPUT_SCHMITT;
 683                                 else
 684                                         val &= ~INPUT_SCHMITT;
 685
 686                                 mask = INPUT_SCHMITT_MASK;
 687                                 shift = INPUT_SCHMITT_SHIFT;
 688                                 break;
 689                         case PIN_CONFIG_BIAS_PULL_UP:
 690                                 if (is_sleep_config == true) {
 691                                         val |= SLEEP_PULL_UP;
 692                                         mask = SLEEP_PULL_UP_MASK;
 693                                         shift = SLEEP_PULL_UP_SHIFT;
 694                                 } else {
 695                                         if (arg == 20000)
 696                                                 val |= PULL_UP_20K;
 697                                         else if (arg == 4700)
 698                                                 val |= PULL_UP_4_7K;
 699
 700                                         mask = PULL_UP_MASK;
 701                                         shift = PULL_UP_SHIFT;
 702                                 }
 703                                 break;
 704                         case PIN_CONFIG_BIAS_DISABLE:
 705                                 if (is_sleep_config == true) {
 706                                         val = shift = 0;
 707                                         mask = SLEEP_PULL_DOWN | SLEEP_PULL_UP;
 708                                 } else {
 709                                         val = shift = 0;
 710                                         mask = PULL_DOWN | PULL_UP_20K |
 711                                                 PULL_UP_4_7K;
 712                                 }
 713                                 break;
 714                         case PIN_CONFIG_SLEEP_HARDWARE_STATE:
 715                                 continue;
 716                         default:
 717                                 return -ENOTSUPP;
 718                         }
 719                 } else {
 720                         return -ENOTSUPP;
 721                 }
 722
 723                 if (pin->type == GLOBAL_CTRL_PIN) {
 724                         reg = readl((void __iomem *)pin->reg);
 725                         reg &= ~(PINCTRL_BIT_MASK(pin->bit_width)
 726                                 << pin->bit_offset);
 727                         reg |= (val & PINCTRL_BIT_MASK(pin->bit_width))
 728                                 << pin->bit_offset;
 729                         writel(reg, (void __iomem *)pin->reg);
 730                 } else {
 731                         reg = readl((void __iomem *)pin->reg);
 732                         reg &= ~(mask << shift);
 733                         reg |= val;
 734                         writel(reg, (void __iomem *)pin->reg);
 735                 }
 736         }
 737
 738         return 0;
 739 }
 740
 741 static int sprd_pinconf_group_get(struct pinctrl_dev *pctldev,
 742                                   unsigned int selector, unsigned long *config)
 743 {
 744         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 745         struct sprd_pinctrl_soc_info *info = pctl->info;
 746         struct sprd_pin_group *grp;
 747         unsigned int pin_id;
 748
 749         if (selector >= info->ngroups)
 750                 return -EINVAL;
 751
 752         grp = &info->groups[selector];
 753         pin_id = grp->pins[0];
 754
 755         return sprd_pinconf_get(pctldev, pin_id, config);
 756 }
 757
 758 static int sprd_pinconf_group_set(struct pinctrl_dev *pctldev,
 759                                   unsigned int selector,
 760                                   unsigned long *configs,
 761                                   unsigned int num_configs)
 762 {
 763         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 764         struct sprd_pinctrl_soc_info *info = pctl->info;
 765         struct sprd_pin_group *grp;
 766         int ret, i;
 767
 768         if (selector >= info->ngroups)
 769                 return -EINVAL;
 770
 771         grp = &info->groups[selector];
 772
 773         for (i = 0; i < grp->npins; i++) {
 774                 unsigned int pin_id = grp->pins[i];
 775
 776                 ret = sprd_pinconf_set(pctldev, pin_id, configs, num_configs);
 777                 if (ret)
 778                         return ret;
 779         }
 780
 781         return 0;
 782 }
 783
 784 static int sprd_pinconf_get_config(struct pinctrl_dev *pctldev,
 785                                    unsigned int pin_id,
 786                                    unsigned long *config)
 787 {
 788         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 789         struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
 790
 791         if (!pin)
 792                 return -EINVAL;
 793
 794         if (pin->type == GLOBAL_CTRL_PIN) {
 795                 *config = (readl((void __iomem *)pin->reg) >>
 796                            pin->bit_offset) & PINCTRL_BIT_MASK(pin->bit_width);
 797         } else {
 798                 *config = readl((void __iomem *)pin->reg);
 799         }
 800
 801         return 0;
 802 }
 803
 804 static void sprd_pinconf_dbg_show(struct pinctrl_dev *pctldev,
 805                                   struct seq_file *s, unsigned int pin_id)
 806 {
 807         unsigned long config;
 808         int ret;
 809
 810         ret = sprd_pinconf_get_config(pctldev, pin_id, &config);
 811         if (ret)
 812                 return;
 813
 814         seq_printf(s, "0x%lx", config);
 815 }
 816
 817 static void sprd_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
 818                                         struct seq_file *s,
 819                                         unsigned int selector)
 820 {
 821         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 822         struct sprd_pinctrl_soc_info *info = pctl->info;
 823         struct sprd_pin_group *grp;
 824         unsigned long config;
 825         const char *name;
 826         int i, ret;
 827
 828         if (selector >= info->ngroups)
 829                 return;
 830
 831         grp = &info->groups[selector];
 832
 833         seq_putc(s, '\n');
 834         for (i = 0; i < grp->npins; i++, config++) {
 835                 unsigned int pin_id = grp->pins[i];
 836
 837                 name = pin_get_name(pctldev, pin_id);
 838                 ret = sprd_pinconf_get_config(pctldev, pin_id, &config);
 839                 if (ret)
 840                         return;
 841
 842                 seq_printf(s, "%s: 0x%lx ", name, config);
 843         }
 844 }
 845
 846 static const struct pinconf_ops sprd_pinconf_ops = {
 847         .is_generic = true,
 848         .pin_config_get = sprd_pinconf_get,
 849         .pin_config_set = sprd_pinconf_set,
 850         .pin_config_group_get = sprd_pinconf_group_get,
 851         .pin_config_group_set = sprd_pinconf_group_set,
 852         .pin_config_dbg_show = sprd_pinconf_dbg_show,
 853         .pin_config_group_dbg_show = sprd_pinconf_group_dbg_show,
 854 };
 855
 856 static const struct pinconf_generic_params sprd_dt_params[] = {
 857         {"sprd,control", SPRD_PIN_CONFIG_CONTROL, 0},
 858         {"sprd,sleep-mode", SPRD_PIN_CONFIG_SLEEP_MODE, 0},
 859 };
 860
 861 #ifdef CONFIG_DEBUG_FS
 862 static const struct pin_config_item sprd_conf_items[] = {
 863         PCONFDUMP(SPRD_PIN_CONFIG_CONTROL, "global control", NULL, true),
 864         PCONFDUMP(SPRD_PIN_CONFIG_SLEEP_MODE, "sleep mode", NULL, true),
 865 };
 866 #endif
 867
 868 static struct pinctrl_desc sprd_pinctrl_desc = {
 869         .pctlops = &sprd_pctrl_ops,
 870         .pmxops = &sprd_pmx_ops,
 871         .confops = &sprd_pinconf_ops,
 872         .num_custom_params = ARRAY_SIZE(sprd_dt_params),
 873         .custom_params = sprd_dt_params,
 874 #ifdef CONFIG_DEBUG_FS
 875         .custom_conf_items = sprd_conf_items,
 876 #endif
 877         .owner = THIS_MODULE,
 878 };
 879
 880 static int sprd_pinctrl_parse_groups(struct device_node *np,
 881                                      struct sprd_pinctrl *sprd_pctl,
 882                                      struct sprd_pin_group *grp)
 883 {
 884         struct property *prop;
 885         const char *pin_name;
 886         int ret, i = 0;
 887
 888         ret = of_property_count_strings(np, "pins");
 889         if (ret < 0)
 890                 return ret;
 891
 892         grp->name = np->name;
 893         grp->npins = ret;
 894         grp->pins = devm_kcalloc(sprd_pctl->dev,
 895                                  grp->npins, sizeof(unsigned int),
 896                                  GFP_KERNEL);
 897         if (!grp->pins)
 898                 return -ENOMEM;
 899
 900         of_property_for_each_string(np, "pins", prop, pin_name) {
 901                 ret = sprd_pinctrl_get_id_by_name(sprd_pctl, pin_name);
 902                 if (ret >= 0)
 903                         grp->pins[i++] = ret;
 904         }
 905
 906         for (i = 0; i < grp->npins; i++) {
 907                 dev_dbg(sprd_pctl->dev,
 908                         "Group[%s] contains [%d] pins: id = %d\n",
 909                         grp->name, grp->npins, grp->pins[i]);
 910         }
 911
 912         return 0;
 913 }
 914
 915 static unsigned int sprd_pinctrl_get_groups(struct device_node *np)
 916 {
 917         struct device_node *child;
 918         unsigned int group_cnt, cnt;
 919
 920         group_cnt = of_get_child_count(np);
 921
 922         for_each_child_of_node(np, child) {
 923                 cnt = of_get_child_count(child);
 924                 if (cnt > 0)
 925                         group_cnt += cnt;
 926         }
 927
 928         return group_cnt;
 929 }
 930
 931 static int sprd_pinctrl_parse_dt(struct sprd_pinctrl *sprd_pctl)
 932 {
 933         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
 934         struct device_node *np = sprd_pctl->dev->of_node;
 935         struct device_node *child, *sub_child;
 936         struct sprd_pin_group *grp;
 937         const char **temp;
 938         int ret;
 939
 940         if (!np)
 941                 return -ENODEV;
 942
 943         info->ngroups = sprd_pinctrl_get_groups(np);
 944         if (!info->ngroups)
 945                 return 0;
 946
 947         info->groups = devm_kcalloc(sprd_pctl->dev,
 948                                     info->ngroups,
 949                                     sizeof(struct sprd_pin_group),
 950                                     GFP_KERNEL);
 951         if (!info->groups)
 952                 return -ENOMEM;
 953
 954         info->grp_names = devm_kcalloc(sprd_pctl->dev,
 955                                        info->ngroups, sizeof(char *),
 956                                        GFP_KERNEL);
 957         if (!info->grp_names)
 958                 return -ENOMEM;
 959
 960         temp = info->grp_names;
 961         grp = info->groups;
 962
 963         for_each_child_of_node(np, child) {
 964                 ret = sprd_pinctrl_parse_groups(child, sprd_pctl, grp);
 965                 if (ret) {
 966                         of_node_put(child);
 967                         return ret;
 968                 }
 969
 970                 *temp++ = grp->name;
 971                 grp++;
 972
 973                 if (of_get_child_count(child) > 0) {
 974                         for_each_child_of_node(child, sub_child) {
 975                                 ret = sprd_pinctrl_parse_groups(sub_child,
 976                                                                 sprd_pctl, grp);
 977                                 if (ret) {
 978                                         of_node_put(sub_child);
 979                                         of_node_put(child);
 980                                         return ret;
 981                                 }
 982
 983                                 *temp++ = grp->name;
 984                                 grp++;
 985                         }
 986                 }
 987         }
 988
 989         return 0;
 990 }
 991
 992 static int sprd_pinctrl_add_pins(struct sprd_pinctrl *sprd_pctl,
 993                                  struct sprd_pins_info *sprd_soc_pin_info,
 994                                  int pins_cnt)
 995 {
 996         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
 997         unsigned int ctrl_pin = 0, com_pin = 0;
 998         struct sprd_pin *pin;
 999         int i;
1000
1001         info->npins = pins_cnt;
1002         info->pins = devm_kcalloc(sprd_pctl->dev,
1003                                   info->npins, sizeof(struct sprd_pin),
1004                                   GFP_KERNEL);
1005         if (!info->pins)
1006                 return -ENOMEM;
1007
1008         for (i = 0, pin = info->pins; i < info->npins; i++, pin++) {
1009                 unsigned int reg;
1010
1011                 pin->name = sprd_soc_pin_info[i].name;
1012                 pin->type = sprd_soc_pin_info[i].type;
1013                 pin->number = sprd_soc_pin_info[i].num;
1014                 reg = sprd_soc_pin_info[i].reg;
1015                 if (pin->type == GLOBAL_CTRL_PIN) {
1016                         pin->reg = (unsigned long)sprd_pctl->base +
1017                                 PINCTRL_REG_LEN * reg;
1018                         pin->bit_offset = sprd_soc_pin_info[i].bit_offset;
1019                         pin->bit_width = sprd_soc_pin_info[i].bit_width;
1020                         ctrl_pin++;
1021                 } else if (pin->type == COMMON_PIN) {
1022                         pin->reg = (unsigned long)sprd_pctl->base +
1023                                 PINCTRL_REG_OFFSET + PINCTRL_REG_LEN *
1024                                 (i - ctrl_pin);
1025                         com_pin++;
1026                 } else if (pin->type == MISC_PIN) {
1027                         pin->reg = (unsigned long)sprd_pctl->base +
1028                                 PINCTRL_REG_MISC_OFFSET + PINCTRL_REG_LEN *
1029                                 (i - ctrl_pin - com_pin);
1030                 }
1031         }
1032
1033         for (i = 0, pin = info->pins; i < info->npins; pin++, i++) {
1034                 dev_dbg(sprd_pctl->dev, "pin name[%s-%d], type = %d, "
1035                         "bit offset = %ld, bit width = %ld, reg = 0x%lx\n",
1036                         pin->name, pin->number, pin->type,
1037                         pin->bit_offset, pin->bit_width, pin->reg);
1038         }
1039
1040         return 0;
1041 }
1042
1043 int sprd_pinctrl_core_probe(struct platform_device *pdev,
1044                             struct sprd_pins_info *sprd_soc_pin_info,
1045                             int pins_cnt)
1046 {
1047         struct sprd_pinctrl *sprd_pctl;
1048         struct sprd_pinctrl_soc_info *pinctrl_info;
1049         struct pinctrl_pin_desc *pin_desc;
1050         int ret, i;
1051
1052         sprd_pctl = devm_kzalloc(&pdev->dev, sizeof(struct sprd_pinctrl),
1053                                  GFP_KERNEL);
1054         if (!sprd_pctl)
1055                 return -ENOMEM;
1056
1057         sprd_pctl->base = devm_platform_ioremap_resource(pdev, 0);
1058         if (IS_ERR(sprd_pctl->base))
1059                 return PTR_ERR(sprd_pctl->base);
1060
1061         pinctrl_info = devm_kzalloc(&pdev->dev,
1062                                     sizeof(struct sprd_pinctrl_soc_info),
1063                                     GFP_KERNEL);
1064         if (!pinctrl_info)
1065                 return -ENOMEM;
1066
1067         sprd_pctl->info = pinctrl_info;
1068         sprd_pctl->dev = &pdev->dev;
1069         platform_set_drvdata(pdev, sprd_pctl);
1070
1071         ret = sprd_pinctrl_add_pins(sprd_pctl, sprd_soc_pin_info, pins_cnt);
1072         if (ret) {
1073                 dev_err(&pdev->dev, "fail to add pins information\n");
1074                 return ret;
1075         }
1076
1077         ret = sprd_pinctrl_parse_dt(sprd_pctl);
1078         if (ret) {
1079                 dev_err(&pdev->dev, "fail to parse dt properties\n");
1080                 return ret;
1081         }
1082
1083         pin_desc = devm_kcalloc(&pdev->dev,
1084                                 pinctrl_info->npins,
1085                                 sizeof(struct pinctrl_pin_desc),
1086                                 GFP_KERNEL);
1087         if (!pin_desc)
1088                 return -ENOMEM;
1089
1090         for (i = 0; i < pinctrl_info->npins; i++) {
1091                 pin_desc[i].number = pinctrl_info->pins[i].number;
1092                 pin_desc[i].name = pinctrl_info->pins[i].name;
1093                 pin_desc[i].drv_data = pinctrl_info;
1094         }
1095
1096         sprd_pinctrl_desc.pins = pin_desc;
1097         sprd_pinctrl_desc.name = dev_name(&pdev->dev);
1098         sprd_pinctrl_desc.npins = pinctrl_info->npins;
1099
1100         sprd_pctl->pctl = pinctrl_register(&sprd_pinctrl_desc,
1101                                            &pdev->dev, (void *)sprd_pctl);
1102         if (IS_ERR(sprd_pctl->pctl)) {
1103                 dev_err(&pdev->dev, "could not register pinctrl driver\n");
1104                 return PTR_ERR(sprd_pctl->pctl);
1105         }
1106
1107         return 0;
1108 }
1109 EXPORT_SYMBOL_GPL(sprd_pinctrl_core_probe);
1110
1111 int sprd_pinctrl_remove(struct platform_device *pdev)
1112 {
1113         struct sprd_pinctrl *sprd_pctl = platform_get_drvdata(pdev);
1114
1115         pinctrl_unregister(sprd_pctl->pctl);
1116         return 0;
1117 }
1118 EXPORT_SYMBOL_GPL(sprd_pinctrl_remove);
1119
1120 void sprd_pinctrl_shutdown(struct platform_device *pdev)
1121 {
1122         struct pinctrl *pinctl;
1123         struct pinctrl_state *state;
1124
1125         pinctl = devm_pinctrl_get(&pdev->dev);
1126         if (IS_ERR(pinctl))
1127                 return;
1128         state = pinctrl_lookup_state(pinctl, "shutdown");
1129         if (IS_ERR(state))
1130                 return;
1131         pinctrl_select_state(pinctl, state);
1132 }
1133 EXPORT_SYMBOL_GPL(sprd_pinctrl_shutdown);
1134
1135 MODULE_DESCRIPTION("SPREADTRUM Pin Controller Driver");
1136 MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");
1137 MODULE_LICENSE("GPL v2");