drivers/pinctrl/qcom/pinctrl-msm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2013, Sony Mobile Communications AB.
   4  * Copyright (c) 2013, The Linux Foundation. All rights reserved.
   5  */
   6
   7 #include <linux/delay.h>
   8 #include <linux/err.h>
   9 #include <linux/io.h>
  10 #include <linux/module.h>
  11 #include <linux/of.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/pinctrl/machine.h>
  14 #include <linux/pinctrl/pinctrl.h>
  15 #include <linux/pinctrl/pinmux.h>
  16 #include <linux/pinctrl/pinconf.h>
  17 #include <linux/pinctrl/pinconf-generic.h>
  18 #include <linux/slab.h>
  19 #include <linux/gpio/driver.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/reboot.h>
  23 #include <linux/pm.h>
  24 #include <linux/log2.h>
  25 #include <linux/qcom_scm.h>
  26 #include <linux/io.h>
  27
  28 #include <linux/soc/qcom/irq.h>
  29
  30 #include "../core.h"
  31 #include "../pinconf.h"
  32 #include "pinctrl-msm.h"
  33 #include "../pinctrl-utils.h"
  34
  35 #define MAX_NR_GPIO 300
  36 #define MAX_NR_TILES 4
  37 #define PS_HOLD_OFFSET 0x820
  38
  39 /**
  40  * struct msm_pinctrl - state for a pinctrl-msm device
  41  * @dev:            device handle.
  42  * @pctrl:          pinctrl handle.
  43  * @chip:           gpiochip handle.
  44  * @restart_nb:     restart notifier block.
  45  * @irq:            parent irq for the TLMM irq_chip.
  46  * @lock:           Spinlock to protect register resources as well
  47  *                  as msm_pinctrl data structures.
  48  * @enabled_irqs:   Bitmap of currently enabled irqs.
  49  * @dual_edge_irqs: Bitmap of irqs that need sw emulated dual edge
  50  *                  detection.
  51  * @skip_wake_irqs: Skip IRQs that are handled by wakeup interrupt controller
  52  * @soc;            Reference to soc_data of platform specific data.
  53  * @regs:           Base addresses for the TLMM tiles.
  54  */
  55 struct msm_pinctrl {
  56         struct device *dev;
  57         struct pinctrl_dev *pctrl;
  58         struct gpio_chip chip;
  59         struct pinctrl_desc desc;
  60         struct notifier_block restart_nb;
  61
  62         struct irq_chip irq_chip;
  63         int irq;
  64
  65         bool intr_target_use_scm;
  66
  67         raw_spinlock_t lock;
  68
  69         DECLARE_BITMAP(dual_edge_irqs, MAX_NR_GPIO);
  70         DECLARE_BITMAP(enabled_irqs, MAX_NR_GPIO);
  71         DECLARE_BITMAP(skip_wake_irqs, MAX_NR_GPIO);
  72
  73         const struct msm_pinctrl_soc_data *soc;
  74         void __iomem *regs[MAX_NR_TILES];
  75         u32 phys_base[MAX_NR_TILES];
  76 };
  77
  78 #define MSM_ACCESSOR(name) \
  79 static u32 msm_readl_##name(struct msm_pinctrl *pctrl, \
  80                             const struct msm_pingroup *g) \
  81 { \
  82         return readl(pctrl->regs[g->tile] + g->name##_reg); \
  83 } \
  84 static void msm_writel_##name(u32 val, struct msm_pinctrl *pctrl, \
  85                               const struct msm_pingroup *g) \
  86 { \
  87         writel(val, pctrl->regs[g->tile] + g->name##_reg); \
  88 }
  89
  90 MSM_ACCESSOR(ctl)
  91 MSM_ACCESSOR(io)
  92 MSM_ACCESSOR(intr_cfg)
  93 MSM_ACCESSOR(intr_status)
  94 MSM_ACCESSOR(intr_target)
  95
  96 static int msm_get_groups_count(struct pinctrl_dev *pctldev)
  97 {
  98         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
  99
 100         return pctrl->soc->ngroups;
 101 }
 102
 103 static const char *msm_get_group_name(struct pinctrl_dev *pctldev,
 104                                       unsigned group)
 105 {
 106         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 107
 108         return pctrl->soc->groups[group].name;
 109 }
 110
 111 static int msm_get_group_pins(struct pinctrl_dev *pctldev,
 112                               unsigned group,
 113                               const unsigned **pins,
 114                               unsigned *num_pins)
 115 {
 116         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 117
 118         *pins = pctrl->soc->groups[group].pins;
 119         *num_pins = pctrl->soc->groups[group].npins;
 120         return 0;
 121 }
 122
 123 static const struct pinctrl_ops msm_pinctrl_ops = {
 124         .get_groups_count       = msm_get_groups_count,
 125         .get_group_name         = msm_get_group_name,
 126         .get_group_pins         = msm_get_group_pins,
 127         .dt_node_to_map         = pinconf_generic_dt_node_to_map_group,
 128         .dt_free_map            = pinctrl_utils_free_map,
 129 };
 130
 131 static int msm_pinmux_request(struct pinctrl_dev *pctldev, unsigned offset)
 132 {
 133         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 134         struct gpio_chip *chip = &pctrl->chip;
 135
 136         return gpiochip_line_is_valid(chip, offset) ? 0 : -EINVAL;
 137 }
 138
 139 static int msm_get_functions_count(struct pinctrl_dev *pctldev)
 140 {
 141         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 142
 143         return pctrl->soc->nfunctions;
 144 }
 145
 146 static const char *msm_get_function_name(struct pinctrl_dev *pctldev,
 147                                          unsigned function)
 148 {
 149         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 150
 151         return pctrl->soc->functions[function].name;
 152 }
 153
 154 static int msm_get_function_groups(struct pinctrl_dev *pctldev,
 155                                    unsigned function,
 156                                    const char * const **groups,
 157                                    unsigned * const num_groups)
 158 {
 159         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 160
 161         *groups = pctrl->soc->functions[function].groups;
 162         *num_groups = pctrl->soc->functions[function].ngroups;
 163         return 0;
 164 }
 165
 166 static int msm_pinmux_set_mux(struct pinctrl_dev *pctldev,
 167                               unsigned function,
 168                               unsigned group)
 169 {
 170         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 171         const struct msm_pingroup *g;
 172         unsigned long flags;
 173         u32 val, mask;
 174         int i;
 175
 176         g = &pctrl->soc->groups[group];
 177         mask = GENMASK(g->mux_bit + order_base_2(g->nfuncs) - 1, g->mux_bit);
 178
 179         for (i = 0; i < g->nfuncs; i++) {
 180                 if (g->funcs[i] == function)
 181                         break;
 182         }
 183
 184         if (WARN_ON(i == g->nfuncs))
 185                 return -EINVAL;
 186
 187         raw_spin_lock_irqsave(&pctrl->lock, flags);
 188
 189         val = msm_readl_ctl(pctrl, g);
 190         val &= ~mask;
 191         val |= i << g->mux_bit;
 192         msm_writel_ctl(val, pctrl, g);
 193
 194         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 195
 196         return 0;
 197 }
 198
 199 static int msm_pinmux_request_gpio(struct pinctrl_dev *pctldev,
 200                                    struct pinctrl_gpio_range *range,
 201                                    unsigned offset)
 202 {
 203         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 204         const struct msm_pingroup *g = &pctrl->soc->groups[offset];
 205
 206         /* No funcs? Probably ACPI so can't do anything here */
 207         if (!g->nfuncs)
 208                 return 0;
 209
 210         /* For now assume function 0 is GPIO because it always is */
 211         return msm_pinmux_set_mux(pctldev, g->funcs[0], offset);
 212 }
 213
 214 static const struct pinmux_ops msm_pinmux_ops = {
 215         .request                = msm_pinmux_request,
 216         .get_functions_count    = msm_get_functions_count,
 217         .get_function_name      = msm_get_function_name,
 218         .get_function_groups    = msm_get_function_groups,
 219         .gpio_request_enable    = msm_pinmux_request_gpio,
 220         .set_mux                = msm_pinmux_set_mux,
 221 };
 222
 223 static int msm_config_reg(struct msm_pinctrl *pctrl,
 224                           const struct msm_pingroup *g,
 225                           unsigned param,
 226                           unsigned *mask,
 227                           unsigned *bit)
 228 {
 229         switch (param) {
 230         case PIN_CONFIG_BIAS_DISABLE:
 231         case PIN_CONFIG_BIAS_PULL_DOWN:
 232         case PIN_CONFIG_BIAS_BUS_HOLD:
 233         case PIN_CONFIG_BIAS_PULL_UP:
 234                 *bit = g->pull_bit;
 235                 *mask = 3;
 236                 break;
 237         case PIN_CONFIG_DRIVE_STRENGTH:
 238                 *bit = g->drv_bit;
 239                 *mask = 7;
 240                 break;
 241         case PIN_CONFIG_OUTPUT:
 242         case PIN_CONFIG_INPUT_ENABLE:
 243                 *bit = g->oe_bit;
 244                 *mask = 1;
 245                 break;
 246         default:
 247                 return -ENOTSUPP;
 248         }
 249
 250         return 0;
 251 }
 252
 253 #define MSM_NO_PULL             0
 254 #define MSM_PULL_DOWN           1
 255 #define MSM_KEEPER              2
 256 #define MSM_PULL_UP_NO_KEEPER   2
 257 #define MSM_PULL_UP             3
 258
 259 static unsigned msm_regval_to_drive(u32 val)
 260 {
 261         return (val + 1) * 2;
 262 }
 263
 264 static int msm_config_group_get(struct pinctrl_dev *pctldev,
 265                                 unsigned int group,
 266                                 unsigned long *config)
 267 {
 268         const struct msm_pingroup *g;
 269         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 270         unsigned param = pinconf_to_config_param(*config);
 271         unsigned mask;
 272         unsigned arg;
 273         unsigned bit;
 274         int ret;
 275         u32 val;
 276
 277         g = &pctrl->soc->groups[group];
 278
 279         ret = msm_config_reg(pctrl, g, param, &mask, &bit);
 280         if (ret < 0)
 281                 return ret;
 282
 283         val = msm_readl_ctl(pctrl, g);
 284         arg = (val >> bit) & mask;
 285
 286         /* Convert register value to pinconf value */
 287         switch (param) {
 288         case PIN_CONFIG_BIAS_DISABLE:
 289                 if (arg != MSM_NO_PULL)
 290                         return -EINVAL;
 291                 arg = 1;
 292                 break;
 293         case PIN_CONFIG_BIAS_PULL_DOWN:
 294                 if (arg != MSM_PULL_DOWN)
 295                         return -EINVAL;
 296                 arg = 1;
 297                 break;
 298         case PIN_CONFIG_BIAS_BUS_HOLD:
 299                 if (pctrl->soc->pull_no_keeper)
 300                         return -ENOTSUPP;
 301
 302                 if (arg != MSM_KEEPER)
 303                         return -EINVAL;
 304                 arg = 1;
 305                 break;
 306         case PIN_CONFIG_BIAS_PULL_UP:
 307                 if (pctrl->soc->pull_no_keeper)
 308                         arg = arg == MSM_PULL_UP_NO_KEEPER;
 309                 else
 310                         arg = arg == MSM_PULL_UP;
 311                 if (!arg)
 312                         return -EINVAL;
 313                 break;
 314         case PIN_CONFIG_DRIVE_STRENGTH:
 315                 arg = msm_regval_to_drive(arg);
 316                 break;
 317         case PIN_CONFIG_OUTPUT:
 318                 /* Pin is not output */
 319                 if (!arg)
 320                         return -EINVAL;
 321
 322                 val = msm_readl_io(pctrl, g);
 323                 arg = !!(val & BIT(g->in_bit));
 324                 break;
 325         case PIN_CONFIG_INPUT_ENABLE:
 326                 /* Pin is output */
 327                 if (arg)
 328                         return -EINVAL;
 329                 arg = 1;
 330                 break;
 331         default:
 332                 return -ENOTSUPP;
 333         }
 334
 335         *config = pinconf_to_config_packed(param, arg);
 336
 337         return 0;
 338 }
 339
 340 static int msm_config_group_set(struct pinctrl_dev *pctldev,
 341                                 unsigned group,
 342                                 unsigned long *configs,
 343                                 unsigned num_configs)
 344 {
 345         const struct msm_pingroup *g;
 346         struct msm_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
 347         unsigned long flags;
 348         unsigned param;
 349         unsigned mask;
 350         unsigned arg;
 351         unsigned bit;
 352         int ret;
 353         u32 val;
 354         int i;
 355
 356         g = &pctrl->soc->groups[group];
 357
 358         for (i = 0; i < num_configs; i++) {
 359                 param = pinconf_to_config_param(configs[i]);
 360                 arg = pinconf_to_config_argument(configs[i]);
 361
 362                 ret = msm_config_reg(pctrl, g, param, &mask, &bit);
 363                 if (ret < 0)
 364                         return ret;
 365
 366                 /* Convert pinconf values to register values */
 367                 switch (param) {
 368                 case PIN_CONFIG_BIAS_DISABLE:
 369                         arg = MSM_NO_PULL;
 370                         break;
 371                 case PIN_CONFIG_BIAS_PULL_DOWN:
 372                         arg = MSM_PULL_DOWN;
 373                         break;
 374                 case PIN_CONFIG_BIAS_BUS_HOLD:
 375                         if (pctrl->soc->pull_no_keeper)
 376                                 return -ENOTSUPP;
 377
 378                         arg = MSM_KEEPER;
 379                         break;
 380                 case PIN_CONFIG_BIAS_PULL_UP:
 381                         if (pctrl->soc->pull_no_keeper)
 382                                 arg = MSM_PULL_UP_NO_KEEPER;
 383                         else
 384                                 arg = MSM_PULL_UP;
 385                         break;
 386                 case PIN_CONFIG_DRIVE_STRENGTH:
 387                         /* Check for invalid values */
 388                         if (arg > 16 || arg < 2 || (arg % 2) != 0)
 389                                 arg = -1;
 390                         else
 391                                 arg = (arg / 2) - 1;
 392                         break;
 393                 case PIN_CONFIG_OUTPUT:
 394                         /* set output value */
 395                         raw_spin_lock_irqsave(&pctrl->lock, flags);
 396                         val = msm_readl_io(pctrl, g);
 397                         if (arg)
 398                                 val |= BIT(g->out_bit);
 399                         else
 400                                 val &= ~BIT(g->out_bit);
 401                         msm_writel_io(val, pctrl, g);
 402                         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 403
 404                         /* enable output */
 405                         arg = 1;
 406                         break;
 407                 case PIN_CONFIG_INPUT_ENABLE:
 408                         /* disable output */
 409                         arg = 0;
 410                         break;
 411                 default:
 412                         dev_err(pctrl->dev, "Unsupported config parameter: %x\n",
 413                                 param);
 414                         return -EINVAL;
 415                 }
 416
 417                 /* Range-check user-supplied value */
 418                 if (arg & ~mask) {
 419                         dev_err(pctrl->dev, "config %x: %x is invalid\n", param, arg);
 420                         return -EINVAL;
 421                 }
 422
 423                 raw_spin_lock_irqsave(&pctrl->lock, flags);
 424                 val = msm_readl_ctl(pctrl, g);
 425                 val &= ~(mask << bit);
 426                 val |= arg << bit;
 427                 msm_writel_ctl(val, pctrl, g);
 428                 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 429         }
 430
 431         return 0;
 432 }
 433
 434 static const struct pinconf_ops msm_pinconf_ops = {
 435         .is_generic             = true,
 436         .pin_config_group_get   = msm_config_group_get,
 437         .pin_config_group_set   = msm_config_group_set,
 438 };
 439
 440 static int msm_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 441 {
 442         const struct msm_pingroup *g;
 443         struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
 444         unsigned long flags;
 445         u32 val;
 446
 447         g = &pctrl->soc->groups[offset];
 448
 449         raw_spin_lock_irqsave(&pctrl->lock, flags);
 450
 451         val = msm_readl_ctl(pctrl, g);
 452         val &= ~BIT(g->oe_bit);
 453         msm_writel_ctl(val, pctrl, g);
 454
 455         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 456
 457         return 0;
 458 }
 459
 460 static int msm_gpio_direction_output(struct gpio_chip *chip, unsigned offset, int value)
 461 {
 462         const struct msm_pingroup *g;
 463         struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
 464         unsigned long flags;
 465         u32 val;
 466
 467         g = &pctrl->soc->groups[offset];
 468
 469         raw_spin_lock_irqsave(&pctrl->lock, flags);
 470
 471         val = msm_readl_io(pctrl, g);
 472         if (value)
 473                 val |= BIT(g->out_bit);
 474         else
 475                 val &= ~BIT(g->out_bit);
 476         msm_writel_io(val, pctrl, g);
 477
 478         val = msm_readl_ctl(pctrl, g);
 479         val |= BIT(g->oe_bit);
 480         msm_writel_ctl(val, pctrl, g);
 481
 482         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 483
 484         return 0;
 485 }
 486
 487 static int msm_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
 488 {
 489         struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
 490         const struct msm_pingroup *g;
 491         u32 val;
 492
 493         g = &pctrl->soc->groups[offset];
 494
 495         val = msm_readl_ctl(pctrl, g);
 496
 497         return val & BIT(g->oe_bit) ? GPIO_LINE_DIRECTION_OUT :
 498                                       GPIO_LINE_DIRECTION_IN;
 499 }
 500
 501 static int msm_gpio_get(struct gpio_chip *chip, unsigned offset)
 502 {
 503         const struct msm_pingroup *g;
 504         struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
 505         u32 val;
 506
 507         g = &pctrl->soc->groups[offset];
 508
 509         val = msm_readl_io(pctrl, g);
 510         return !!(val & BIT(g->in_bit));
 511 }
 512
 513 static void msm_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 514 {
 515         const struct msm_pingroup *g;
 516         struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
 517         unsigned long flags;
 518         u32 val;
 519
 520         g = &pctrl->soc->groups[offset];
 521
 522         raw_spin_lock_irqsave(&pctrl->lock, flags);
 523
 524         val = msm_readl_io(pctrl, g);
 525         if (value)
 526                 val |= BIT(g->out_bit);
 527         else
 528                 val &= ~BIT(g->out_bit);
 529         msm_writel_io(val, pctrl, g);
 530
 531         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 532 }
 533
 534 #ifdef CONFIG_DEBUG_FS
 535 #include <linux/seq_file.h>
 536
 537 static void msm_gpio_dbg_show_one(struct seq_file *s,
 538                                   struct pinctrl_dev *pctldev,
 539                                   struct gpio_chip *chip,
 540                                   unsigned offset,
 541                                   unsigned gpio)
 542 {
 543         const struct msm_pingroup *g;
 544         struct msm_pinctrl *pctrl = gpiochip_get_data(chip);
 545         unsigned func;
 546         int is_out;
 547         int drive;
 548         int pull;
 549         int val;
 550         u32 ctl_reg, io_reg;
 551
 552         static const char * const pulls_keeper[] = {
 553                 "no pull",
 554                 "pull down",
 555                 "keeper",
 556                 "pull up"
 557         };
 558
 559         static const char * const pulls_no_keeper[] = {
 560                 "no pull",
 561                 "pull down",
 562                 "pull up",
 563         };
 564
 565         if (!gpiochip_line_is_valid(chip, offset))
 566                 return;
 567
 568         g = &pctrl->soc->groups[offset];
 569         ctl_reg = msm_readl_ctl(pctrl, g);
 570         io_reg = msm_readl_io(pctrl, g);
 571
 572         is_out = !!(ctl_reg & BIT(g->oe_bit));
 573         func = (ctl_reg >> g->mux_bit) & 7;
 574         drive = (ctl_reg >> g->drv_bit) & 7;
 575         pull = (ctl_reg >> g->pull_bit) & 3;
 576
 577         if (is_out)
 578                 val = !!(io_reg & BIT(g->out_bit));
 579         else
 580                 val = !!(io_reg & BIT(g->in_bit));
 581
 582         seq_printf(s, " %-8s: %-3s", g->name, is_out ? "out" : "in");
 583         seq_printf(s, " %-4s func%d", val ? "high" : "low", func);
 584         seq_printf(s, " %dmA", msm_regval_to_drive(drive));
 585         if (pctrl->soc->pull_no_keeper)
 586                 seq_printf(s, " %s", pulls_no_keeper[pull]);
 587         else
 588                 seq_printf(s, " %s", pulls_keeper[pull]);
 589         seq_puts(s, "\n");
 590 }
 591
 592 static void msm_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 593 {
 594         unsigned gpio = chip->base;
 595         unsigned i;
 596
 597         for (i = 0; i < chip->ngpio; i++, gpio++)
 598                 msm_gpio_dbg_show_one(s, NULL, chip, i, gpio);
 599 }
 600
 601 #else
 602 #define msm_gpio_dbg_show NULL
 603 #endif
 604
 605 static int msm_gpio_init_valid_mask(struct gpio_chip *gc,
 606                                     unsigned long *valid_mask,
 607                                     unsigned int ngpios)
 608 {
 609         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
 610         int ret;
 611         unsigned int len, i;
 612         const int *reserved = pctrl->soc->reserved_gpios;
 613         u16 *tmp;
 614
 615         /* Driver provided reserved list overrides DT and ACPI */
 616         if (reserved) {
 617                 bitmap_fill(valid_mask, ngpios);
 618                 for (i = 0; reserved[i] >= 0; i++) {
 619                         if (i >= ngpios || reserved[i] >= ngpios) {
 620                                 dev_err(pctrl->dev, "invalid list of reserved GPIOs\n");
 621                                 return -EINVAL;
 622                         }
 623                         clear_bit(reserved[i], valid_mask);
 624                 }
 625
 626                 return 0;
 627         }
 628
 629         /* The number of GPIOs in the ACPI tables */
 630         len = ret = device_property_count_u16(pctrl->dev, "gpios");
 631         if (ret < 0)
 632                 return 0;
 633
 634         if (ret > ngpios)
 635                 return -EINVAL;
 636
 637         tmp = kmalloc_array(len, sizeof(*tmp), GFP_KERNEL);
 638         if (!tmp)
 639                 return -ENOMEM;
 640
 641         ret = device_property_read_u16_array(pctrl->dev, "gpios", tmp, len);
 642         if (ret < 0) {
 643                 dev_err(pctrl->dev, "could not read list of GPIOs\n");
 644                 goto out;
 645         }
 646
 647         bitmap_zero(valid_mask, ngpios);
 648         for (i = 0; i < len; i++)
 649                 set_bit(tmp[i], valid_mask);
 650
 651 out:
 652         kfree(tmp);
 653         return ret;
 654 }
 655
 656 static const struct gpio_chip msm_gpio_template = {
 657         .direction_input  = msm_gpio_direction_input,
 658         .direction_output = msm_gpio_direction_output,
 659         .get_direction    = msm_gpio_get_direction,
 660         .get              = msm_gpio_get,
 661         .set              = msm_gpio_set,
 662         .request          = gpiochip_generic_request,
 663         .free             = gpiochip_generic_free,
 664         .dbg_show         = msm_gpio_dbg_show,
 665 };
 666
 667 /* For dual-edge interrupts in software, since some hardware has no
 668  * such support:
 669  *
 670  * At appropriate moments, this function may be called to flip the polarity
 671  * settings of both-edge irq lines to try and catch the next edge.
 672  *
 673  * The attempt is considered successful if:
 674  * - the status bit goes high, indicating that an edge was caught, or
 675  * - the input value of the gpio doesn't change during the attempt.
 676  * If the value changes twice during the process, that would cause the first
 677  * test to fail but would force the second, as two opposite
 678  * transitions would cause a detection no matter the polarity setting.
 679  *
 680  * The do-loop tries to sledge-hammer closed the timing hole between
 681  * the initial value-read and the polarity-write - if the line value changes
 682  * during that window, an interrupt is lost, the new polarity setting is
 683  * incorrect, and the first success test will fail, causing a retry.
 684  *
 685  * Algorithm comes from Google's msmgpio driver.
 686  */
 687 static void msm_gpio_update_dual_edge_pos(struct msm_pinctrl *pctrl,
 688                                           const struct msm_pingroup *g,
 689                                           struct irq_data *d)
 690 {
 691         int loop_limit = 100;
 692         unsigned val, val2, intstat;
 693         unsigned pol;
 694
 695         do {
 696                 val = msm_readl_io(pctrl, g) & BIT(g->in_bit);
 697
 698                 pol = msm_readl_intr_cfg(pctrl, g);
 699                 pol ^= BIT(g->intr_polarity_bit);
 700                 msm_writel_intr_cfg(pol, pctrl, g);
 701
 702                 val2 = msm_readl_io(pctrl, g) & BIT(g->in_bit);
 703                 intstat = msm_readl_intr_status(pctrl, g);
 704                 if (intstat || (val == val2))
 705                         return;
 706         } while (loop_limit-- > 0);
 707         dev_err(pctrl->dev, "dual-edge irq failed to stabilize, %#08x != %#08x\n",
 708                 val, val2);
 709 }
 710
 711 static void msm_gpio_irq_mask(struct irq_data *d)
 712 {
 713         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 714         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
 715         const struct msm_pingroup *g;
 716         unsigned long flags;
 717         u32 val;
 718
 719         if (d->parent_data)
 720                 irq_chip_mask_parent(d);
 721
 722         if (test_bit(d->hwirq, pctrl->skip_wake_irqs))
 723                 return;
 724
 725         g = &pctrl->soc->groups[d->hwirq];
 726
 727         raw_spin_lock_irqsave(&pctrl->lock, flags);
 728
 729         val = msm_readl_intr_cfg(pctrl, g);
 730         /*
 731          * There are two bits that control interrupt forwarding to the CPU. The
 732          * RAW_STATUS_EN bit causes the level or edge sensed on the line to be
 733          * latched into the interrupt status register when the hardware detects
 734          * an irq that it's configured for (either edge for edge type or level
 735          * for level type irq). The 'non-raw' status enable bit causes the
 736          * hardware to assert the summary interrupt to the CPU if the latched
 737          * status bit is set. There's a bug though, the edge detection logic
 738          * seems to have a problem where toggling the RAW_STATUS_EN bit may
 739          * cause the status bit to latch spuriously when there isn't any edge
 740          * so we can't touch that bit for edge type irqs and we have to keep
 741          * the bit set anyway so that edges are latched while the line is masked.
 742          *
 743          * To make matters more complicated, leaving the RAW_STATUS_EN bit
 744          * enabled all the time causes level interrupts to re-latch into the
 745          * status register because the level is still present on the line after
 746          * we ack it. We clear the raw status enable bit during mask here and
 747          * set the bit on unmask so the interrupt can't latch into the hardware
 748          * while it's masked.
 749          */
 750         if (irqd_get_trigger_type(d) & IRQ_TYPE_LEVEL_MASK)
 751                 val &= ~BIT(g->intr_raw_status_bit);
 752
 753         val &= ~BIT(g->intr_enable_bit);
 754         msm_writel_intr_cfg(val, pctrl, g);
 755
 756         clear_bit(d->hwirq, pctrl->enabled_irqs);
 757
 758         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 759 }
 760
 761 static void msm_gpio_irq_clear_unmask(struct irq_data *d, bool status_clear)
 762 {
 763         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 764         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
 765         const struct msm_pingroup *g;
 766         unsigned long flags;
 767         u32 val;
 768
 769         if (d->parent_data)
 770                 irq_chip_unmask_parent(d);
 771
 772         if (test_bit(d->hwirq, pctrl->skip_wake_irqs))
 773                 return;
 774
 775         g = &pctrl->soc->groups[d->hwirq];
 776
 777         raw_spin_lock_irqsave(&pctrl->lock, flags);
 778
 779         if (status_clear) {
 780                 /*
 781                  * clear the interrupt status bit before unmask to avoid
 782                  * any erroneous interrupts that would have got latched
 783                  * when the interrupt is not in use.
 784                  */
 785                 val = msm_readl_intr_status(pctrl, g);
 786                 val &= ~BIT(g->intr_status_bit);
 787                 msm_writel_intr_status(val, pctrl, g);
 788         }
 789
 790         val = msm_readl_intr_cfg(pctrl, g);
 791         val |= BIT(g->intr_raw_status_bit);
 792         val |= BIT(g->intr_enable_bit);
 793         msm_writel_intr_cfg(val, pctrl, g);
 794
 795         set_bit(d->hwirq, pctrl->enabled_irqs);
 796
 797         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 798 }
 799
 800 static void msm_gpio_irq_enable(struct irq_data *d)
 801 {
 802         /*
 803          * Clear the interrupt that may be pending before we enable
 804          * the line.
 805          * This is especially a problem with the GPIOs routed to the
 806          * PDC. These GPIOs are direct-connect interrupts to the GIC.
 807          * Disabling the interrupt line at the PDC does not prevent
 808          * the interrupt from being latched at the GIC. The state at
 809          * GIC needs to be cleared before enabling.
 810          */
 811         if (d->parent_data) {
 812                 irq_chip_set_parent_state(d, IRQCHIP_STATE_PENDING, 0);
 813                 irq_chip_enable_parent(d);
 814         }
 815
 816         msm_gpio_irq_clear_unmask(d, true);
 817 }
 818
 819 static void msm_gpio_irq_disable(struct irq_data *d)
 820 {
 821         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 822         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
 823
 824         if (d->parent_data)
 825                 irq_chip_disable_parent(d);
 826
 827         if (!test_bit(d->hwirq, pctrl->skip_wake_irqs))
 828                 msm_gpio_irq_mask(d);
 829 }
 830
 831 static void msm_gpio_irq_unmask(struct irq_data *d)
 832 {
 833         msm_gpio_irq_clear_unmask(d, false);
 834 }
 835
 836 static void msm_gpio_irq_ack(struct irq_data *d)
 837 {
 838         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 839         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
 840         const struct msm_pingroup *g;
 841         unsigned long flags;
 842         u32 val;
 843
 844         if (test_bit(d->hwirq, pctrl->skip_wake_irqs))
 845                 return;
 846
 847         g = &pctrl->soc->groups[d->hwirq];
 848
 849         raw_spin_lock_irqsave(&pctrl->lock, flags);
 850
 851         val = msm_readl_intr_status(pctrl, g);
 852         if (g->intr_ack_high)
 853                 val |= BIT(g->intr_status_bit);
 854         else
 855                 val &= ~BIT(g->intr_status_bit);
 856         msm_writel_intr_status(val, pctrl, g);
 857
 858         if (test_bit(d->hwirq, pctrl->dual_edge_irqs))
 859                 msm_gpio_update_dual_edge_pos(pctrl, g, d);
 860
 861         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 862 }
 863
 864 static int msm_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 865 {
 866         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 867         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
 868         const struct msm_pingroup *g;
 869         unsigned long flags;
 870         u32 val;
 871
 872         if (d->parent_data)
 873                 irq_chip_set_type_parent(d, type);
 874
 875         if (test_bit(d->hwirq, pctrl->skip_wake_irqs))
 876                 return 0;
 877
 878         g = &pctrl->soc->groups[d->hwirq];
 879
 880         raw_spin_lock_irqsave(&pctrl->lock, flags);
 881
 882         /*
 883          * For hw without possibility of detecting both edges
 884          */
 885         if (g->intr_detection_width == 1 && type == IRQ_TYPE_EDGE_BOTH)
 886                 set_bit(d->hwirq, pctrl->dual_edge_irqs);
 887         else
 888                 clear_bit(d->hwirq, pctrl->dual_edge_irqs);
 889
 890         /* Route interrupts to application cpu.
 891          * With intr_target_use_scm interrupts are routed to
 892          * application cpu using scm calls.
 893          */
 894         if (pctrl->intr_target_use_scm) {
 895                 u32 addr = pctrl->phys_base[0] + g->intr_target_reg;
 896                 int ret;
 897
 898                 qcom_scm_io_readl(addr, &val);
 899
 900                 val &= ~(7 << g->intr_target_bit);
 901                 val |= g->intr_target_kpss_val << g->intr_target_bit;
 902
 903                 ret = qcom_scm_io_writel(addr, val);
 904                 if (ret)
 905                         dev_err(pctrl->dev,
 906                                 "Failed routing %lu interrupt to Apps proc",
 907                                 d->hwirq);
 908         } else {
 909                 val = msm_readl_intr_target(pctrl, g);
 910                 val &= ~(7 << g->intr_target_bit);
 911                 val |= g->intr_target_kpss_val << g->intr_target_bit;
 912                 msm_writel_intr_target(val, pctrl, g);
 913         }
 914
 915         /* Update configuration for gpio.
 916          * RAW_STATUS_EN is left on for all gpio irqs. Due to the
 917          * internal circuitry of TLMM, toggling the RAW_STATUS
 918          * could cause the INTR_STATUS to be set for EDGE interrupts.
 919          */
 920         val = msm_readl_intr_cfg(pctrl, g);
 921         val |= BIT(g->intr_raw_status_bit);
 922         if (g->intr_detection_width == 2) {
 923                 val &= ~(3 << g->intr_detection_bit);
 924                 val &= ~(1 << g->intr_polarity_bit);
 925                 switch (type) {
 926                 case IRQ_TYPE_EDGE_RISING:
 927                         val |= 1 << g->intr_detection_bit;
 928                         val |= BIT(g->intr_polarity_bit);
 929                         break;
 930                 case IRQ_TYPE_EDGE_FALLING:
 931                         val |= 2 << g->intr_detection_bit;
 932                         val |= BIT(g->intr_polarity_bit);
 933                         break;
 934                 case IRQ_TYPE_EDGE_BOTH:
 935                         val |= 3 << g->intr_detection_bit;
 936                         val |= BIT(g->intr_polarity_bit);
 937                         break;
 938                 case IRQ_TYPE_LEVEL_LOW:
 939                         break;
 940                 case IRQ_TYPE_LEVEL_HIGH:
 941                         val |= BIT(g->intr_polarity_bit);
 942                         break;
 943                 }
 944         } else if (g->intr_detection_width == 1) {
 945                 val &= ~(1 << g->intr_detection_bit);
 946                 val &= ~(1 << g->intr_polarity_bit);
 947                 switch (type) {
 948                 case IRQ_TYPE_EDGE_RISING:
 949                         val |= BIT(g->intr_detection_bit);
 950                         val |= BIT(g->intr_polarity_bit);
 951                         break;
 952                 case IRQ_TYPE_EDGE_FALLING:
 953                         val |= BIT(g->intr_detection_bit);
 954                         break;
 955                 case IRQ_TYPE_EDGE_BOTH:
 956                         val |= BIT(g->intr_detection_bit);
 957                         val |= BIT(g->intr_polarity_bit);
 958                         break;
 959                 case IRQ_TYPE_LEVEL_LOW:
 960                         break;
 961                 case IRQ_TYPE_LEVEL_HIGH:
 962                         val |= BIT(g->intr_polarity_bit);
 963                         break;
 964                 }
 965         } else {
 966                 BUG();
 967         }
 968         msm_writel_intr_cfg(val, pctrl, g);
 969
 970         if (test_bit(d->hwirq, pctrl->dual_edge_irqs))
 971                 msm_gpio_update_dual_edge_pos(pctrl, g, d);
 972
 973         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 974
 975         if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
 976                 irq_set_handler_locked(d, handle_level_irq);
 977         else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
 978                 irq_set_handler_locked(d, handle_edge_irq);
 979
 980         return 0;
 981 }
 982
 983 static int msm_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
 984 {
 985         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 986         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
 987
 988         /*
 989          * While they may not wake up when the TLMM is powered off,
 990          * some GPIOs would like to wakeup the system from suspend
 991          * when TLMM is powered on. To allow that, enable the GPIO
 992          * summary line to be wakeup capable at GIC.
 993          */
 994         if (d->parent_data)
 995                 irq_chip_set_wake_parent(d, on);
 996
 997         irq_set_irq_wake(pctrl->irq, on);
 998
 999         return 0;
1000 }
1001
1002 static int msm_gpio_irq_reqres(struct irq_data *d)
1003 {
1004         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1005         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
1006         int ret;
1007
1008         if (!try_module_get(gc->owner))
1009                 return -ENODEV;
1010
1011         ret = msm_pinmux_request_gpio(pctrl->pctrl, NULL, d->hwirq);
1012         if (ret)
1013                 goto out;
1014         msm_gpio_direction_input(gc, d->hwirq);
1015
1016         if (gpiochip_lock_as_irq(gc, d->hwirq)) {
1017                 dev_err(gc->parent,
1018                         "unable to lock HW IRQ %lu for IRQ\n",
1019                         d->hwirq);
1020                 ret = -EINVAL;
1021                 goto out;
1022         }
1023         return 0;
1024 out:
1025         module_put(gc->owner);
1026         return ret;
1027 }
1028
1029 static void msm_gpio_irq_relres(struct irq_data *d)
1030 {
1031         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1032
1033         gpiochip_unlock_as_irq(gc, d->hwirq);
1034         module_put(gc->owner);
1035 }
1036
1037 static int msm_gpio_irq_set_affinity(struct irq_data *d,
1038                                 const struct cpumask *dest, bool force)
1039 {
1040         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1041         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
1042
1043         if (d->parent_data && test_bit(d->hwirq, pctrl->skip_wake_irqs))
1044                 return irq_chip_set_affinity_parent(d, dest, force);
1045
1046         return 0;
1047 }
1048
1049 static int msm_gpio_irq_set_vcpu_affinity(struct irq_data *d, void *vcpu_info)
1050 {
1051         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1052         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
1053
1054         if (d->parent_data && test_bit(d->hwirq, pctrl->skip_wake_irqs))
1055                 return irq_chip_set_vcpu_affinity_parent(d, vcpu_info);
1056
1057         return 0;
1058 }
1059
1060 static void msm_gpio_irq_handler(struct irq_desc *desc)
1061 {
1062         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
1063         const struct msm_pingroup *g;
1064         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
1065         struct irq_chip *chip = irq_desc_get_chip(desc);
1066         int irq_pin;
1067         int handled = 0;
1068         u32 val;
1069         int i;
1070
1071         chained_irq_enter(chip, desc);
1072
1073         /*
1074          * Each pin has it's own IRQ status register, so use
1075          * enabled_irq bitmap to limit the number of reads.
1076          */
1077         for_each_set_bit(i, pctrl->enabled_irqs, pctrl->chip.ngpio) {
1078                 g = &pctrl->soc->groups[i];
1079                 val = msm_readl_intr_status(pctrl, g);
1080                 if (val & BIT(g->intr_status_bit)) {
1081                         irq_pin = irq_find_mapping(gc->irq.domain, i);
1082                         generic_handle_irq(irq_pin);
1083                         handled++;
1084                 }
1085         }
1086
1087         /* No interrupts were flagged */
1088         if (handled == 0)
1089                 handle_bad_irq(desc);
1090
1091         chained_irq_exit(chip, desc);
1092 }
1093
1094 static int msm_gpio_wakeirq(struct gpio_chip *gc,
1095                             unsigned int child,
1096                             unsigned int child_type,
1097                             unsigned int *parent,
1098                             unsigned int *parent_type)
1099 {
1100         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
1101         const struct msm_gpio_wakeirq_map *map;
1102         int i;
1103
1104         *parent = GPIO_NO_WAKE_IRQ;
1105         *parent_type = IRQ_TYPE_EDGE_RISING;
1106
1107         for (i = 0; i < pctrl->soc->nwakeirq_map; i++) {
1108                 map = &pctrl->soc->wakeirq_map[i];
1109                 if (map->gpio == child) {
1110                         *parent = map->wakeirq;
1111                         break;
1112                 }
1113         }
1114
1115         return 0;
1116 }
1117
1118 static bool msm_gpio_needs_valid_mask(struct msm_pinctrl *pctrl)
1119 {
1120         if (pctrl->soc->reserved_gpios)
1121                 return true;
1122
1123         return device_property_count_u16(pctrl->dev, "gpios") > 0;
1124 }
1125
1126 static int msm_gpio_init(struct msm_pinctrl *pctrl)
1127 {
1128         struct gpio_chip *chip;
1129         struct gpio_irq_chip *girq;
1130         int i, ret;
1131         unsigned gpio, ngpio = pctrl->soc->ngpios;
1132         struct device_node *np;
1133         bool skip;
1134
1135         if (WARN_ON(ngpio > MAX_NR_GPIO))
1136                 return -EINVAL;
1137
1138         chip = &pctrl->chip;
1139         chip->base = -1;
1140         chip->ngpio = ngpio;
1141         chip->label = dev_name(pctrl->dev);
1142         chip->parent = pctrl->dev;
1143         chip->owner = THIS_MODULE;
1144         chip->of_node = pctrl->dev->of_node;
1145         if (msm_gpio_needs_valid_mask(pctrl))
1146                 chip->init_valid_mask = msm_gpio_init_valid_mask;
1147
1148         pctrl->irq_chip.name = "msmgpio";
1149         pctrl->irq_chip.irq_enable = msm_gpio_irq_enable;
1150         pctrl->irq_chip.irq_disable = msm_gpio_irq_disable;
1151         pctrl->irq_chip.irq_mask = msm_gpio_irq_mask;
1152         pctrl->irq_chip.irq_unmask = msm_gpio_irq_unmask;
1153         pctrl->irq_chip.irq_ack = msm_gpio_irq_ack;
1154         pctrl->irq_chip.irq_set_type = msm_gpio_irq_set_type;
1155         pctrl->irq_chip.irq_set_wake = msm_gpio_irq_set_wake;
1156         pctrl->irq_chip.irq_request_resources = msm_gpio_irq_reqres;
1157         pctrl->irq_chip.irq_release_resources = msm_gpio_irq_relres;
1158         pctrl->irq_chip.irq_set_affinity = msm_gpio_irq_set_affinity;
1159         pctrl->irq_chip.irq_set_vcpu_affinity = msm_gpio_irq_set_vcpu_affinity;
1160
1161         np = of_parse_phandle(pctrl->dev->of_node, "wakeup-parent", 0);
1162         if (np) {
1163                 chip->irq.parent_domain = irq_find_matching_host(np,
1164                                                  DOMAIN_BUS_WAKEUP);
1165                 of_node_put(np);
1166                 if (!chip->irq.parent_domain)
1167                         return -EPROBE_DEFER;
1168                 chip->irq.child_to_parent_hwirq = msm_gpio_wakeirq;
1169                 pctrl->irq_chip.irq_eoi = irq_chip_eoi_parent;
1170                 /*
1171                  * Let's skip handling the GPIOs, if the parent irqchip
1172                  * is handling the direct connect IRQ of the GPIO.
1173                  */
1174                 skip = irq_domain_qcom_handle_wakeup(chip->irq.parent_domain);
1175                 for (i = 0; skip && i < pctrl->soc->nwakeirq_map; i++) {
1176                         gpio = pctrl->soc->wakeirq_map[i].gpio;
1177                         set_bit(gpio, pctrl->skip_wake_irqs);
1178                 }
1179         }
1180
1181         girq = &chip->irq;
1182         girq->chip = &pctrl->irq_chip;
1183         girq->parent_handler = msm_gpio_irq_handler;
1184         girq->fwnode = pctrl->dev->fwnode;
1185         girq->num_parents = 1;
1186         girq->parents = devm_kcalloc(pctrl->dev, 1, sizeof(*girq->parents),
1187                                      GFP_KERNEL);
1188         if (!girq->parents)
1189                 return -ENOMEM;
1190         girq->default_type = IRQ_TYPE_NONE;
1191         girq->handler = handle_bad_irq;
1192         girq->parents[0] = pctrl->irq;
1193
1194         ret = gpiochip_add_data(&pctrl->chip, pctrl);
1195         if (ret) {
1196                 dev_err(pctrl->dev, "Failed register gpiochip\n");
1197                 return ret;
1198         }
1199
1200         /*
1201          * For DeviceTree-supported systems, the gpio core checks the
1202          * pinctrl's device node for the "gpio-ranges" property.
1203          * If it is present, it takes care of adding the pin ranges
1204          * for the driver. In this case the driver can skip ahead.
1205          *
1206          * In order to remain compatible with older, existing DeviceTree
1207          * files which don't set the "gpio-ranges" property or systems that
1208          * utilize ACPI the driver has to call gpiochip_add_pin_range().
1209          */
1210         if (!of_property_read_bool(pctrl->dev->of_node, "gpio-ranges")) {
1211                 ret = gpiochip_add_pin_range(&pctrl->chip,
1212                         dev_name(pctrl->dev), 0, 0, chip->ngpio);
1213                 if (ret) {
1214                         dev_err(pctrl->dev, "Failed to add pin range\n");
1215                         gpiochip_remove(&pctrl->chip);
1216                         return ret;
1217                 }
1218         }
1219
1220         return 0;
1221 }
1222
1223 static int msm_ps_hold_restart(struct notifier_block *nb, unsigned long action,
1224                                void *data)
1225 {
1226         struct msm_pinctrl *pctrl = container_of(nb, struct msm_pinctrl, restart_nb);
1227
1228         writel(0, pctrl->regs[0] + PS_HOLD_OFFSET);
1229         mdelay(1000);
1230         return NOTIFY_DONE;
1231 }
1232
1233 static struct msm_pinctrl *poweroff_pctrl;
1234
1235 static void msm_ps_hold_poweroff(void)
1236 {
1237         msm_ps_hold_restart(&poweroff_pctrl->restart_nb, 0, NULL);
1238 }
1239
1240 static void msm_pinctrl_setup_pm_reset(struct msm_pinctrl *pctrl)
1241 {
1242         int i;
1243         const struct msm_function *func = pctrl->soc->functions;
1244
1245         for (i = 0; i < pctrl->soc->nfunctions; i++)
1246                 if (!strcmp(func[i].name, "ps_hold")) {
1247                         pctrl->restart_nb.notifier_call = msm_ps_hold_restart;
1248                         pctrl->restart_nb.priority = 128;
1249                         if (register_restart_handler(&pctrl->restart_nb))
1250                                 dev_err(pctrl->dev,
1251                                         "failed to setup restart handler.\n");
1252                         poweroff_pctrl = pctrl;
1253                         pm_power_off = msm_ps_hold_poweroff;
1254                         break;
1255                 }
1256 }
1257
1258 static __maybe_unused int msm_pinctrl_suspend(struct device *dev)
1259 {
1260         struct msm_pinctrl *pctrl = dev_get_drvdata(dev);
1261
1262         return pinctrl_force_sleep(pctrl->pctrl);
1263 }
1264
1265 static __maybe_unused int msm_pinctrl_resume(struct device *dev)
1266 {
1267         struct msm_pinctrl *pctrl = dev_get_drvdata(dev);
1268
1269         return pinctrl_force_default(pctrl->pctrl);
1270 }
1271
1272 SIMPLE_DEV_PM_OPS(msm_pinctrl_dev_pm_ops, msm_pinctrl_suspend,
1273                   msm_pinctrl_resume);
1274
1275 EXPORT_SYMBOL(msm_pinctrl_dev_pm_ops);
1276
1277 int msm_pinctrl_probe(struct platform_device *pdev,
1278                       const struct msm_pinctrl_soc_data *soc_data)
1279 {
1280         struct msm_pinctrl *pctrl;
1281         struct resource *res;
1282         int ret;
1283         int i;
1284
1285         pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL);
1286         if (!pctrl)
1287                 return -ENOMEM;
1288
1289         pctrl->dev = &pdev->dev;
1290         pctrl->soc = soc_data;
1291         pctrl->chip = msm_gpio_template;
1292         pctrl->intr_target_use_scm = of_device_is_compatible(
1293                                         pctrl->dev->of_node,
1294                                         "qcom,ipq8064-pinctrl");
1295
1296         raw_spin_lock_init(&pctrl->lock);
1297
1298         if (soc_data->tiles) {
1299                 for (i = 0; i < soc_data->ntiles; i++) {
1300                         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
1301                                                            soc_data->tiles[i]);
1302                         pctrl->regs[i] = devm_ioremap_resource(&pdev->dev, res);
1303                         if (IS_ERR(pctrl->regs[i]))
1304                                 return PTR_ERR(pctrl->regs[i]);
1305                 }
1306         } else {
1307                 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1308                 pctrl->regs[0] = devm_ioremap_resource(&pdev->dev, res);
1309                 if (IS_ERR(pctrl->regs[0]))
1310                         return PTR_ERR(pctrl->regs[0]);
1311
1312                 pctrl->phys_base[0] = res->start;
1313         }
1314
1315         msm_pinctrl_setup_pm_reset(pctrl);
1316
1317         pctrl->irq = platform_get_irq(pdev, 0);
1318         if (pctrl->irq < 0)
1319                 return pctrl->irq;
1320
1321         pctrl->desc.owner = THIS_MODULE;
1322         pctrl->desc.pctlops = &msm_pinctrl_ops;
1323         pctrl->desc.pmxops = &msm_pinmux_ops;
1324         pctrl->desc.confops = &msm_pinconf_ops;
1325         pctrl->desc.name = dev_name(&pdev->dev);
1326         pctrl->desc.pins = pctrl->soc->pins;
1327         pctrl->desc.npins = pctrl->soc->npins;
1328
1329         pctrl->pctrl = devm_pinctrl_register(&pdev->dev, &pctrl->desc, pctrl);
1330         if (IS_ERR(pctrl->pctrl)) {
1331                 dev_err(&pdev->dev, "Couldn't register pinctrl driver\n");
1332                 return PTR_ERR(pctrl->pctrl);
1333         }
1334
1335         ret = msm_gpio_init(pctrl);
1336         if (ret)
1337                 return ret;
1338
1339         platform_set_drvdata(pdev, pctrl);
1340
1341         dev_dbg(&pdev->dev, "Probed Qualcomm pinctrl driver\n");
1342
1343         return 0;
1344 }
1345 EXPORT_SYMBOL(msm_pinctrl_probe);
1346
1347 int msm_pinctrl_remove(struct platform_device *pdev)
1348 {
1349         struct msm_pinctrl *pctrl = platform_get_drvdata(pdev);
1350
1351         gpiochip_remove(&pctrl->chip);
1352
1353         unregister_restart_handler(&pctrl->restart_nb);
1354
1355         return 0;
1356 }
1357 EXPORT_SYMBOL(msm_pinctrl_remove);
1358