drivers/soc/tegra/pmc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * drivers/soc/tegra/pmc.c
   4  *
   5  * Copyright (c) 2010 Google, Inc
   6  * Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
   7  *
   8  * Author:
   9  *      Colin Cross <ccross@google.com>
  10  */
  11
  12 #define pr_fmt(fmt) "tegra-pmc: " fmt
  13
  14 #include <linux/arm-smccc.h>
  15 #include <linux/clk.h>
  16 #include <linux/clk-provider.h>
  17 #include <linux/clkdev.h>
  18 #include <linux/clk/clk-conf.h>
  19 #include <linux/clk/tegra.h>
  20 #include <linux/debugfs.h>
  21 #include <linux/delay.h>
  22 #include <linux/device.h>
  23 #include <linux/err.h>
  24 #include <linux/export.h>
  25 #include <linux/init.h>
  26 #include <linux/io.h>
  27 #include <linux/iopoll.h>
  28 #include <linux/irqdomain.h>
  29 #include <linux/irq.h>
  30 #include <linux/kernel.h>
  31 #include <linux/of_address.h>
  32 #include <linux/of_clk.h>
  33 #include <linux/of.h>
  34 #include <linux/of_irq.h>
  35 #include <linux/of_platform.h>
  36 #include <linux/pinctrl/pinconf-generic.h>
  37 #include <linux/pinctrl/pinconf.h>
  38 #include <linux/pinctrl/pinctrl.h>
  39 #include <linux/platform_device.h>
  40 #include <linux/pm_domain.h>
  41 #include <linux/reboot.h>
  42 #include <linux/reset.h>
  43 #include <linux/seq_file.h>
  44 #include <linux/slab.h>
  45 #include <linux/spinlock.h>
  46
  47 #include <soc/tegra/common.h>
  48 #include <soc/tegra/fuse.h>
  49 #include <soc/tegra/pmc.h>
  50
  51 #include <dt-bindings/interrupt-controller/arm-gic.h>
  52 #include <dt-bindings/pinctrl/pinctrl-tegra-io-pad.h>
  53 #include <dt-bindings/gpio/tegra186-gpio.h>
  54 #include <dt-bindings/gpio/tegra194-gpio.h>
  55 #include <dt-bindings/soc/tegra-pmc.h>
  56
  57 #define PMC_CNTRL                       0x0
  58 #define  PMC_CNTRL_INTR_POLARITY        BIT(17) /* inverts INTR polarity */
  59 #define  PMC_CNTRL_CPU_PWRREQ_OE        BIT(16) /* CPU pwr req enable */
  60 #define  PMC_CNTRL_CPU_PWRREQ_POLARITY  BIT(15) /* CPU pwr req polarity */
  61 #define  PMC_CNTRL_SIDE_EFFECT_LP0      BIT(14) /* LP0 when CPU pwr gated */
  62 #define  PMC_CNTRL_SYSCLK_OE            BIT(11) /* system clock enable */
  63 #define  PMC_CNTRL_SYSCLK_POLARITY      BIT(10) /* sys clk polarity */
  64 #define  PMC_CNTRL_PWRREQ_POLARITY      BIT(8)
  65 #define  PMC_CNTRL_BLINK_EN             7
  66 #define  PMC_CNTRL_MAIN_RST             BIT(4)
  67
  68 #define PMC_WAKE_MASK                   0x0c
  69 #define PMC_WAKE_LEVEL                  0x10
  70 #define PMC_WAKE_STATUS                 0x14
  71 #define PMC_SW_WAKE_STATUS              0x18
  72 #define PMC_DPD_PADS_ORIDE              0x1c
  73 #define  PMC_DPD_PADS_ORIDE_BLINK       20
  74
  75 #define DPD_SAMPLE                      0x020
  76 #define  DPD_SAMPLE_ENABLE              BIT(0)
  77 #define  DPD_SAMPLE_DISABLE             (0 << 0)
  78
  79 #define PWRGATE_TOGGLE                  0x30
  80 #define  PWRGATE_TOGGLE_START           BIT(8)
  81
  82 #define REMOVE_CLAMPING                 0x34
  83
  84 #define PWRGATE_STATUS                  0x38
  85
  86 #define PMC_BLINK_TIMER                 0x40
  87 #define PMC_IMPL_E_33V_PWR              0x40
  88
  89 #define PMC_PWR_DET                     0x48
  90
  91 #define PMC_SCRATCH0_MODE_RECOVERY      BIT(31)
  92 #define PMC_SCRATCH0_MODE_BOOTLOADER    BIT(30)
  93 #define PMC_SCRATCH0_MODE_RCM           BIT(1)
  94 #define PMC_SCRATCH0_MODE_MASK          (PMC_SCRATCH0_MODE_RECOVERY | \
  95                                          PMC_SCRATCH0_MODE_BOOTLOADER | \
  96                                          PMC_SCRATCH0_MODE_RCM)
  97
  98 #define PMC_CPUPWRGOOD_TIMER            0xc8
  99 #define PMC_CPUPWROFF_TIMER             0xcc
 100 #define PMC_COREPWRGOOD_TIMER           0x3c
 101 #define PMC_COREPWROFF_TIMER            0xe0
 102
 103 #define PMC_PWR_DET_VALUE               0xe4
 104
 105 #define PMC_SCRATCH41                   0x140
 106
 107 #define PMC_WAKE2_MASK                  0x160
 108 #define PMC_WAKE2_LEVEL                 0x164
 109 #define PMC_WAKE2_STATUS                0x168
 110 #define PMC_SW_WAKE2_STATUS             0x16c
 111
 112 #define PMC_CLK_OUT_CNTRL               0x1a8
 113 #define  PMC_CLK_OUT_MUX_MASK           GENMASK(1, 0)
 114 #define PMC_SENSOR_CTRL                 0x1b0
 115 #define  PMC_SENSOR_CTRL_SCRATCH_WRITE  BIT(2)
 116 #define  PMC_SENSOR_CTRL_ENABLE_RST     BIT(1)
 117
 118 #define  PMC_RST_STATUS_POR             0
 119 #define  PMC_RST_STATUS_WATCHDOG        1
 120 #define  PMC_RST_STATUS_SENSOR          2
 121 #define  PMC_RST_STATUS_SW_MAIN         3
 122 #define  PMC_RST_STATUS_LP0             4
 123 #define  PMC_RST_STATUS_AOTAG           5
 124
 125 #define IO_DPD_REQ                      0x1b8
 126 #define  IO_DPD_REQ_CODE_IDLE           (0U << 30)
 127 #define  IO_DPD_REQ_CODE_OFF            (1U << 30)
 128 #define  IO_DPD_REQ_CODE_ON             (2U << 30)
 129 #define  IO_DPD_REQ_CODE_MASK           (3U << 30)
 130
 131 #define IO_DPD_STATUS                   0x1bc
 132 #define IO_DPD2_REQ                     0x1c0
 133 #define IO_DPD2_STATUS                  0x1c4
 134 #define SEL_DPD_TIM                     0x1c8
 135
 136 #define PMC_SCRATCH54                   0x258
 137 #define  PMC_SCRATCH54_DATA_SHIFT       8
 138 #define  PMC_SCRATCH54_ADDR_SHIFT       0
 139
 140 #define PMC_SCRATCH55                   0x25c
 141 #define  PMC_SCRATCH55_RESET_TEGRA      BIT(31)
 142 #define  PMC_SCRATCH55_CNTRL_ID_SHIFT   27
 143 #define  PMC_SCRATCH55_PINMUX_SHIFT     24
 144 #define  PMC_SCRATCH55_16BITOP          BIT(15)
 145 #define  PMC_SCRATCH55_CHECKSUM_SHIFT   16
 146 #define  PMC_SCRATCH55_I2CSLV1_SHIFT    0
 147
 148 #define GPU_RG_CNTRL                    0x2d4
 149
 150 /* Tegra186 and later */
 151 #define WAKE_AOWAKE_CNTRL(x) (0x000 + ((x) << 2))
 152 #define WAKE_AOWAKE_CNTRL_LEVEL (1 << 3)
 153 #define WAKE_AOWAKE_MASK_W(x) (0x180 + ((x) << 2))
 154 #define WAKE_AOWAKE_MASK_R(x) (0x300 + ((x) << 2))
 155 #define WAKE_AOWAKE_STATUS_W(x) (0x30c + ((x) << 2))
 156 #define WAKE_AOWAKE_STATUS_R(x) (0x48c + ((x) << 2))
 157 #define WAKE_AOWAKE_TIER0_ROUTING(x) (0x4b4 + ((x) << 2))
 158 #define WAKE_AOWAKE_TIER1_ROUTING(x) (0x4c0 + ((x) << 2))
 159 #define WAKE_AOWAKE_TIER2_ROUTING(x) (0x4cc + ((x) << 2))
 160
 161 #define WAKE_AOWAKE_CTRL 0x4f4
 162 #define  WAKE_AOWAKE_CTRL_INTR_POLARITY BIT(0)
 163
 164 /* for secure PMC */
 165 #define TEGRA_SMC_PMC           0xc2fffe00
 166 #define  TEGRA_SMC_PMC_READ     0xaa
 167 #define  TEGRA_SMC_PMC_WRITE    0xbb
 168
 169 struct pmc_clk {
 170         struct clk_hw   hw;
 171         unsigned long   offs;
 172         u32             mux_shift;
 173         u32             force_en_shift;
 174 };
 175
 176 #define to_pmc_clk(_hw) container_of(_hw, struct pmc_clk, hw)
 177
 178 struct pmc_clk_gate {
 179         struct clk_hw   hw;
 180         unsigned long   offs;
 181         u32             shift;
 182 };
 183
 184 #define to_pmc_clk_gate(_hw) container_of(_hw, struct pmc_clk_gate, hw)
 185
 186 struct pmc_clk_init_data {
 187         char *name;
 188         const char *const *parents;
 189         int num_parents;
 190         int clk_id;
 191         u8 mux_shift;
 192         u8 force_en_shift;
 193 };
 194
 195 static const char * const clk_out1_parents[] = { "osc", "osc_div2",
 196         "osc_div4", "extern1",
 197 };
 198
 199 static const char * const clk_out2_parents[] = { "osc", "osc_div2",
 200         "osc_div4", "extern2",
 201 };
 202
 203 static const char * const clk_out3_parents[] = { "osc", "osc_div2",
 204         "osc_div4", "extern3",
 205 };
 206
 207 static const struct pmc_clk_init_data tegra_pmc_clks_data[] = {
 208         {
 209                 .name = "pmc_clk_out_1",
 210                 .parents = clk_out1_parents,
 211                 .num_parents = ARRAY_SIZE(clk_out1_parents),
 212                 .clk_id = TEGRA_PMC_CLK_OUT_1,
 213                 .mux_shift = 6,
 214                 .force_en_shift = 2,
 215         },
 216         {
 217                 .name = "pmc_clk_out_2",
 218                 .parents = clk_out2_parents,
 219                 .num_parents = ARRAY_SIZE(clk_out2_parents),
 220                 .clk_id = TEGRA_PMC_CLK_OUT_2,
 221                 .mux_shift = 14,
 222                 .force_en_shift = 10,
 223         },
 224         {
 225                 .name = "pmc_clk_out_3",
 226                 .parents = clk_out3_parents,
 227                 .num_parents = ARRAY_SIZE(clk_out3_parents),
 228                 .clk_id = TEGRA_PMC_CLK_OUT_3,
 229                 .mux_shift = 22,
 230                 .force_en_shift = 18,
 231         },
 232 };
 233
 234 struct tegra_powergate {
 235         struct generic_pm_domain genpd;
 236         struct tegra_pmc *pmc;
 237         unsigned int id;
 238         struct clk **clks;
 239         unsigned int num_clks;
 240         struct reset_control *reset;
 241 };
 242
 243 struct tegra_io_pad_soc {
 244         enum tegra_io_pad id;
 245         unsigned int dpd;
 246         unsigned int voltage;
 247         const char *name;
 248 };
 249
 250 struct tegra_pmc_regs {
 251         unsigned int scratch0;
 252         unsigned int dpd_req;
 253         unsigned int dpd_status;
 254         unsigned int dpd2_req;
 255         unsigned int dpd2_status;
 256         unsigned int rst_status;
 257         unsigned int rst_source_shift;
 258         unsigned int rst_source_mask;
 259         unsigned int rst_level_shift;
 260         unsigned int rst_level_mask;
 261 };
 262
 263 struct tegra_wake_event {
 264         const char *name;
 265         unsigned int id;
 266         unsigned int irq;
 267         struct {
 268                 unsigned int instance;
 269                 unsigned int pin;
 270         } gpio;
 271 };
 272
 273 #define TEGRA_WAKE_IRQ(_name, _id, _irq)                \
 274         {                                               \
 275                 .name = _name,                          \
 276                 .id = _id,                              \
 277                 .irq = _irq,                            \
 278                 .gpio = {                               \
 279                         .instance = UINT_MAX,           \
 280                         .pin = UINT_MAX,                \
 281                 },                                      \
 282         }
 283
 284 #define TEGRA_WAKE_GPIO(_name, _id, _instance, _pin)    \
 285         {                                               \
 286                 .name = _name,                          \
 287                 .id = _id,                              \
 288                 .irq = 0,                               \
 289                 .gpio = {                               \
 290                         .instance = _instance,          \
 291                         .pin = _pin,                    \
 292                 },                                      \
 293         }
 294
 295 struct tegra_pmc_soc {
 296         unsigned int num_powergates;
 297         const char *const *powergates;
 298         unsigned int num_cpu_powergates;
 299         const u8 *cpu_powergates;
 300
 301         bool has_tsense_reset;
 302         bool has_gpu_clamps;
 303         bool needs_mbist_war;
 304         bool has_impl_33v_pwr;
 305         bool maybe_tz_only;
 306
 307         const struct tegra_io_pad_soc *io_pads;
 308         unsigned int num_io_pads;
 309
 310         const struct pinctrl_pin_desc *pin_descs;
 311         unsigned int num_pin_descs;
 312
 313         const struct tegra_pmc_regs *regs;
 314         void (*init)(struct tegra_pmc *pmc);
 315         void (*setup_irq_polarity)(struct tegra_pmc *pmc,
 316                                    struct device_node *np,
 317                                    bool invert);
 318         int (*irq_set_wake)(struct irq_data *data, unsigned int on);
 319         int (*irq_set_type)(struct irq_data *data, unsigned int type);
 320
 321         const char * const *reset_sources;
 322         unsigned int num_reset_sources;
 323         const char * const *reset_levels;
 324         unsigned int num_reset_levels;
 325
 326         /*
 327          * These describe events that can wake the system from sleep (i.e.
 328          * LP0 or SC7). Wakeup from other sleep states (such as LP1 or LP2)
 329          * are dealt with in the LIC.
 330          */
 331         const struct tegra_wake_event *wake_events;
 332         unsigned int num_wake_events;
 333
 334         const struct pmc_clk_init_data *pmc_clks_data;
 335         unsigned int num_pmc_clks;
 336         bool has_blink_output;
 337 };
 338
 339 /**
 340  * struct tegra_pmc - NVIDIA Tegra PMC
 341  * @dev: pointer to PMC device structure
 342  * @base: pointer to I/O remapped register region
 343  * @wake: pointer to I/O remapped region for WAKE registers
 344  * @aotag: pointer to I/O remapped region for AOTAG registers
 345  * @scratch: pointer to I/O remapped region for scratch registers
 346  * @clk: pointer to pclk clock
 347  * @soc: pointer to SoC data structure
 348  * @tz_only: flag specifying if the PMC can only be accessed via TrustZone
 349  * @debugfs: pointer to debugfs entry
 350  * @rate: currently configured rate of pclk
 351  * @suspend_mode: lowest suspend mode available
 352  * @cpu_good_time: CPU power good time (in microseconds)
 353  * @cpu_off_time: CPU power off time (in microsecends)
 354  * @core_osc_time: core power good OSC time (in microseconds)
 355  * @core_pmu_time: core power good PMU time (in microseconds)
 356  * @core_off_time: core power off time (in microseconds)
 357  * @corereq_high: core power request is active-high
 358  * @sysclkreq_high: system clock request is active-high
 359  * @combined_req: combined power request for CPU & core
 360  * @cpu_pwr_good_en: CPU power good signal is enabled
 361  * @lp0_vec_phys: physical base address of the LP0 warm boot code
 362  * @lp0_vec_size: size of the LP0 warm boot code
 363  * @powergates_available: Bitmap of available power gates
 364  * @powergates_lock: mutex for power gate register access
 365  * @pctl_dev: pin controller exposed by the PMC
 366  * @domain: IRQ domain provided by the PMC
 367  * @irq: chip implementation for the IRQ domain
 368  * @clk_nb: pclk clock changes handler
 369  */
 370 struct tegra_pmc {
 371         struct device *dev;
 372         void __iomem *base;
 373         void __iomem *wake;
 374         void __iomem *aotag;
 375         void __iomem *scratch;
 376         struct clk *clk;
 377         struct dentry *debugfs;
 378
 379         const struct tegra_pmc_soc *soc;
 380         bool tz_only;
 381
 382         unsigned long rate;
 383
 384         enum tegra_suspend_mode suspend_mode;
 385         u32 cpu_good_time;
 386         u32 cpu_off_time;
 387         u32 core_osc_time;
 388         u32 core_pmu_time;
 389         u32 core_off_time;
 390         bool corereq_high;
 391         bool sysclkreq_high;
 392         bool combined_req;
 393         bool cpu_pwr_good_en;
 394         u32 lp0_vec_phys;
 395         u32 lp0_vec_size;
 396         DECLARE_BITMAP(powergates_available, TEGRA_POWERGATE_MAX);
 397
 398         struct mutex powergates_lock;
 399
 400         struct pinctrl_dev *pctl_dev;
 401
 402         struct irq_domain *domain;
 403         struct irq_chip irq;
 404
 405         struct notifier_block clk_nb;
 406 };
 407
 408 static struct tegra_pmc *pmc = &(struct tegra_pmc) {
 409         .base = NULL,
 410         .suspend_mode = TEGRA_SUSPEND_NONE,
 411 };
 412
 413 static inline struct tegra_powergate *
 414 to_powergate(struct generic_pm_domain *domain)
 415 {
 416         return container_of(domain, struct tegra_powergate, genpd);
 417 }
 418
 419 static u32 tegra_pmc_readl(struct tegra_pmc *pmc, unsigned long offset)
 420 {
 421         struct arm_smccc_res res;
 422
 423         if (pmc->tz_only) {
 424                 arm_smccc_smc(TEGRA_SMC_PMC, TEGRA_SMC_PMC_READ, offset, 0, 0,
 425                               0, 0, 0, &res);
 426                 if (res.a0) {
 427                         if (pmc->dev)
 428                                 dev_warn(pmc->dev, "%s(): SMC failed: %lu\n",
 429                                          __func__, res.a0);
 430                         else
 431                                 pr_warn("%s(): SMC failed: %lu\n", __func__,
 432                                         res.a0);
 433                 }
 434
 435                 return res.a1;
 436         }
 437
 438         return readl(pmc->base + offset);
 439 }
 440
 441 static void tegra_pmc_writel(struct tegra_pmc *pmc, u32 value,
 442                              unsigned long offset)
 443 {
 444         struct arm_smccc_res res;
 445
 446         if (pmc->tz_only) {
 447                 arm_smccc_smc(TEGRA_SMC_PMC, TEGRA_SMC_PMC_WRITE, offset,
 448                               value, 0, 0, 0, 0, &res);
 449                 if (res.a0) {
 450                         if (pmc->dev)
 451                                 dev_warn(pmc->dev, "%s(): SMC failed: %lu\n",
 452                                          __func__, res.a0);
 453                         else
 454                                 pr_warn("%s(): SMC failed: %lu\n", __func__,
 455                                         res.a0);
 456                 }
 457         } else {
 458                 writel(value, pmc->base + offset);
 459         }
 460 }
 461
 462 static u32 tegra_pmc_scratch_readl(struct tegra_pmc *pmc, unsigned long offset)
 463 {
 464         if (pmc->tz_only)
 465                 return tegra_pmc_readl(pmc, offset);
 466
 467         return readl(pmc->scratch + offset);
 468 }
 469
 470 static void tegra_pmc_scratch_writel(struct tegra_pmc *pmc, u32 value,
 471                                      unsigned long offset)
 472 {
 473         if (pmc->tz_only)
 474                 tegra_pmc_writel(pmc, value, offset);
 475         else
 476                 writel(value, pmc->scratch + offset);
 477 }
 478
 479 /*
 480  * TODO Figure out a way to call this with the struct tegra_pmc * passed in.
 481  * This currently doesn't work because readx_poll_timeout() can only operate
 482  * on functions that take a single argument.
 483  */
 484 static inline bool tegra_powergate_state(int id)
 485 {
 486         if (id == TEGRA_POWERGATE_3D && pmc->soc->has_gpu_clamps)
 487                 return (tegra_pmc_readl(pmc, GPU_RG_CNTRL) & 0x1) == 0;
 488         else
 489                 return (tegra_pmc_readl(pmc, PWRGATE_STATUS) & BIT(id)) != 0;
 490 }
 491
 492 static inline bool tegra_powergate_is_valid(struct tegra_pmc *pmc, int id)
 493 {
 494         return (pmc->soc && pmc->soc->powergates[id]);
 495 }
 496
 497 static inline bool tegra_powergate_is_available(struct tegra_pmc *pmc, int id)
 498 {
 499         return test_bit(id, pmc->powergates_available);
 500 }
 501
 502 static int tegra_powergate_lookup(struct tegra_pmc *pmc, const char *name)
 503 {
 504         unsigned int i;
 505
 506         if (!pmc || !pmc->soc || !name)
 507                 return -EINVAL;
 508
 509         for (i = 0; i < pmc->soc->num_powergates; i++) {
 510                 if (!tegra_powergate_is_valid(pmc, i))
 511                         continue;
 512
 513                 if (!strcmp(name, pmc->soc->powergates[i]))
 514                         return i;
 515         }
 516
 517         return -ENODEV;
 518 }
 519
 520 /**
 521  * tegra_powergate_set() - set the state of a partition
 522  * @pmc: power management controller
 523  * @id: partition ID
 524  * @new_state: new state of the partition
 525  */
 526 static int tegra_powergate_set(struct tegra_pmc *pmc, unsigned int id,
 527                                bool new_state)
 528 {
 529         bool status;
 530         int err;
 531
 532         if (id == TEGRA_POWERGATE_3D && pmc->soc->has_gpu_clamps)
 533                 return -EINVAL;
 534
 535         mutex_lock(&pmc->powergates_lock);
 536
 537         if (tegra_powergate_state(id) == new_state) {
 538                 mutex_unlock(&pmc->powergates_lock);
 539                 return 0;
 540         }
 541
 542         tegra_pmc_writel(pmc, PWRGATE_TOGGLE_START | id, PWRGATE_TOGGLE);
 543
 544         err = readx_poll_timeout(tegra_powergate_state, id, status,
 545                                  status == new_state, 10, 100000);
 546
 547         mutex_unlock(&pmc->powergates_lock);
 548
 549         return err;
 550 }
 551
 552 static int __tegra_powergate_remove_clamping(struct tegra_pmc *pmc,
 553                                              unsigned int id)
 554 {
 555         u32 mask;
 556
 557         mutex_lock(&pmc->powergates_lock);
 558
 559         /*
 560          * On Tegra124 and later, the clamps for the GPU are controlled by a
 561          * separate register (with different semantics).
 562          */
 563         if (id == TEGRA_POWERGATE_3D) {
 564                 if (pmc->soc->has_gpu_clamps) {
 565                         tegra_pmc_writel(pmc, 0, GPU_RG_CNTRL);
 566                         goto out;
 567                 }
 568         }
 569
 570         /*
 571          * Tegra 2 has a bug where PCIE and VDE clamping masks are
 572          * swapped relatively to the partition ids
 573          */
 574         if (id == TEGRA_POWERGATE_VDEC)
 575                 mask = (1 << TEGRA_POWERGATE_PCIE);
 576         else if (id == TEGRA_POWERGATE_PCIE)
 577                 mask = (1 << TEGRA_POWERGATE_VDEC);
 578         else
 579                 mask = (1 << id);
 580
 581         tegra_pmc_writel(pmc, mask, REMOVE_CLAMPING);
 582
 583 out:
 584         mutex_unlock(&pmc->powergates_lock);
 585
 586         return 0;
 587 }
 588
 589 static void tegra_powergate_disable_clocks(struct tegra_powergate *pg)
 590 {
 591         unsigned int i;
 592
 593         for (i = 0; i < pg->num_clks; i++)
 594                 clk_disable_unprepare(pg->clks[i]);
 595 }
 596
 597 static int tegra_powergate_enable_clocks(struct tegra_powergate *pg)
 598 {
 599         unsigned int i;
 600         int err;
 601
 602         for (i = 0; i < pg->num_clks; i++) {
 603                 err = clk_prepare_enable(pg->clks[i]);
 604                 if (err)
 605                         goto out;
 606         }
 607
 608         return 0;
 609
 610 out:
 611         while (i--)
 612                 clk_disable_unprepare(pg->clks[i]);
 613
 614         return err;
 615 }
 616
 617 int __weak tegra210_clk_handle_mbist_war(unsigned int id)
 618 {
 619         return 0;
 620 }
 621
 622 static int tegra_powergate_power_up(struct tegra_powergate *pg,
 623                                     bool disable_clocks)
 624 {
 625         int err;
 626
 627         err = reset_control_assert(pg->reset);
 628         if (err)
 629                 return err;
 630
 631         usleep_range(10, 20);
 632
 633         err = tegra_powergate_set(pg->pmc, pg->id, true);
 634         if (err < 0)
 635                 return err;
 636
 637         usleep_range(10, 20);
 638
 639         err = tegra_powergate_enable_clocks(pg);
 640         if (err)
 641                 goto disable_clks;
 642
 643         usleep_range(10, 20);
 644
 645         err = __tegra_powergate_remove_clamping(pg->pmc, pg->id);
 646         if (err)
 647                 goto disable_clks;
 648
 649         usleep_range(10, 20);
 650
 651         err = reset_control_deassert(pg->reset);
 652         if (err)
 653                 goto powergate_off;
 654
 655         usleep_range(10, 20);
 656
 657         if (pg->pmc->soc->needs_mbist_war)
 658                 err = tegra210_clk_handle_mbist_war(pg->id);
 659         if (err)
 660                 goto disable_clks;
 661
 662         if (disable_clocks)
 663                 tegra_powergate_disable_clocks(pg);
 664
 665         return 0;
 666
 667 disable_clks:
 668         tegra_powergate_disable_clocks(pg);
 669         usleep_range(10, 20);
 670
 671 powergate_off:
 672         tegra_powergate_set(pg->pmc, pg->id, false);
 673
 674         return err;
 675 }
 676
 677 static int tegra_powergate_power_down(struct tegra_powergate *pg)
 678 {
 679         int err;
 680
 681         err = tegra_powergate_enable_clocks(pg);
 682         if (err)
 683                 return err;
 684
 685         usleep_range(10, 20);
 686
 687         err = reset_control_assert(pg->reset);
 688         if (err)
 689                 goto disable_clks;
 690
 691         usleep_range(10, 20);
 692
 693         tegra_powergate_disable_clocks(pg);
 694
 695         usleep_range(10, 20);
 696
 697         err = tegra_powergate_set(pg->pmc, pg->id, false);
 698         if (err)
 699                 goto assert_resets;
 700
 701         return 0;
 702
 703 assert_resets:
 704         tegra_powergate_enable_clocks(pg);
 705         usleep_range(10, 20);
 706         reset_control_deassert(pg->reset);
 707         usleep_range(10, 20);
 708
 709 disable_clks:
 710         tegra_powergate_disable_clocks(pg);
 711
 712         return err;
 713 }
 714
 715 static int tegra_genpd_power_on(struct generic_pm_domain *domain)
 716 {
 717         struct tegra_powergate *pg = to_powergate(domain);
 718         struct device *dev = pg->pmc->dev;
 719         int err;
 720
 721         err = tegra_powergate_power_up(pg, true);
 722         if (err) {
 723                 dev_err(dev, "failed to turn on PM domain %s: %d\n",
 724                         pg->genpd.name, err);
 725                 goto out;
 726         }
 727
 728         reset_control_release(pg->reset);
 729
 730 out:
 731         return err;
 732 }
 733
 734 static int tegra_genpd_power_off(struct generic_pm_domain *domain)
 735 {
 736         struct tegra_powergate *pg = to_powergate(domain);
 737         struct device *dev = pg->pmc->dev;
 738         int err;
 739
 740         err = reset_control_acquire(pg->reset);
 741         if (err < 0) {
 742                 pr_err("failed to acquire resets: %d\n", err);
 743                 return err;
 744         }
 745
 746         err = tegra_powergate_power_down(pg);
 747         if (err) {
 748                 dev_err(dev, "failed to turn off PM domain %s: %d\n",
 749                         pg->genpd.name, err);
 750                 reset_control_release(pg->reset);
 751         }
 752
 753         return err;
 754 }
 755
 756 /**
 757  * tegra_powergate_power_on() - power on partition
 758  * @id: partition ID
 759  */
 760 int tegra_powergate_power_on(unsigned int id)
 761 {
 762         if (!tegra_powergate_is_available(pmc, id))
 763                 return -EINVAL;
 764
 765         return tegra_powergate_set(pmc, id, true);
 766 }
 767 EXPORT_SYMBOL(tegra_powergate_power_on);
 768
 769 /**
 770  * tegra_powergate_power_off() - power off partition
 771  * @id: partition ID
 772  */
 773 int tegra_powergate_power_off(unsigned int id)
 774 {
 775         if (!tegra_powergate_is_available(pmc, id))
 776                 return -EINVAL;
 777
 778         return tegra_powergate_set(pmc, id, false);
 779 }
 780 EXPORT_SYMBOL(tegra_powergate_power_off);
 781
 782 /**
 783  * tegra_powergate_is_powered() - check if partition is powered
 784  * @pmc: power management controller
 785  * @id: partition ID
 786  */
 787 static int tegra_powergate_is_powered(struct tegra_pmc *pmc, unsigned int id)
 788 {
 789         if (!tegra_powergate_is_valid(pmc, id))
 790                 return -EINVAL;
 791
 792         return tegra_powergate_state(id);
 793 }
 794
 795 /**
 796  * tegra_powergate_remove_clamping() - remove power clamps for partition
 797  * @id: partition ID
 798  */
 799 int tegra_powergate_remove_clamping(unsigned int id)
 800 {
 801         if (!tegra_powergate_is_available(pmc, id))
 802                 return -EINVAL;
 803
 804         return __tegra_powergate_remove_clamping(pmc, id);
 805 }
 806 EXPORT_SYMBOL(tegra_powergate_remove_clamping);
 807
 808 /**
 809  * tegra_powergate_sequence_power_up() - power up partition
 810  * @id: partition ID
 811  * @clk: clock for partition
 812  * @rst: reset for partition
 813  *
 814  * Must be called with clk disabled, and returns with clk enabled.
 815  */
 816 int tegra_powergate_sequence_power_up(unsigned int id, struct clk *clk,
 817                                       struct reset_control *rst)
 818 {
 819         struct tegra_powergate *pg;
 820         int err;
 821
 822         if (!tegra_powergate_is_available(pmc, id))
 823                 return -EINVAL;
 824
 825         pg = kzalloc(sizeof(*pg), GFP_KERNEL);
 826         if (!pg)
 827                 return -ENOMEM;
 828
 829         pg->id = id;
 830         pg->clks = &clk;
 831         pg->num_clks = 1;
 832         pg->reset = rst;
 833         pg->pmc = pmc;
 834
 835         err = tegra_powergate_power_up(pg, false);
 836         if (err)
 837                 dev_err(pmc->dev, "failed to turn on partition %d: %d\n", id,
 838                         err);
 839
 840         kfree(pg);
 841
 842         return err;
 843 }
 844 EXPORT_SYMBOL(tegra_powergate_sequence_power_up);
 845
 846 /**
 847  * tegra_get_cpu_powergate_id() - convert from CPU ID to partition ID
 848  * @pmc: power management controller
 849  * @cpuid: CPU partition ID
 850  *
 851  * Returns the partition ID corresponding to the CPU partition ID or a
 852  * negative error code on failure.
 853  */
 854 static int tegra_get_cpu_powergate_id(struct tegra_pmc *pmc,
 855                                       unsigned int cpuid)
 856 {
 857         if (pmc->soc && cpuid < pmc->soc->num_cpu_powergates)
 858                 return pmc->soc->cpu_powergates[cpuid];
 859
 860         return -EINVAL;
 861 }
 862
 863 /**
 864  * tegra_pmc_cpu_is_powered() - check if CPU partition is powered
 865  * @cpuid: CPU partition ID
 866  */
 867 bool tegra_pmc_cpu_is_powered(unsigned int cpuid)
 868 {
 869         int id;
 870
 871         id = tegra_get_cpu_powergate_id(pmc, cpuid);
 872         if (id < 0)
 873                 return false;
 874
 875         return tegra_powergate_is_powered(pmc, id);
 876 }
 877
 878 /**
 879  * tegra_pmc_cpu_power_on() - power on CPU partition
 880  * @cpuid: CPU partition ID
 881  */
 882 int tegra_pmc_cpu_power_on(unsigned int cpuid)
 883 {
 884         int id;
 885
 886         id = tegra_get_cpu_powergate_id(pmc, cpuid);
 887         if (id < 0)
 888                 return id;
 889
 890         return tegra_powergate_set(pmc, id, true);
 891 }
 892
 893 /**
 894  * tegra_pmc_cpu_remove_clamping() - remove power clamps for CPU partition
 895  * @cpuid: CPU partition ID
 896  */
 897 int tegra_pmc_cpu_remove_clamping(unsigned int cpuid)
 898 {
 899         int id;
 900
 901         id = tegra_get_cpu_powergate_id(pmc, cpuid);
 902         if (id < 0)
 903                 return id;
 904
 905         return tegra_powergate_remove_clamping(id);
 906 }
 907
 908 static int tegra_pmc_restart_notify(struct notifier_block *this,
 909                                     unsigned long action, void *data)
 910 {
 911         const char *cmd = data;
 912         u32 value;
 913
 914         value = tegra_pmc_scratch_readl(pmc, pmc->soc->regs->scratch0);
 915         value &= ~PMC_SCRATCH0_MODE_MASK;
 916
 917         if (cmd) {
 918                 if (strcmp(cmd, "recovery") == 0)
 919                         value |= PMC_SCRATCH0_MODE_RECOVERY;
 920
 921                 if (strcmp(cmd, "bootloader") == 0)
 922                         value |= PMC_SCRATCH0_MODE_BOOTLOADER;
 923
 924                 if (strcmp(cmd, "forced-recovery") == 0)
 925                         value |= PMC_SCRATCH0_MODE_RCM;
 926         }
 927
 928         tegra_pmc_scratch_writel(pmc, value, pmc->soc->regs->scratch0);
 929
 930         /* reset everything but PMC_SCRATCH0 and PMC_RST_STATUS */
 931         value = tegra_pmc_readl(pmc, PMC_CNTRL);
 932         value |= PMC_CNTRL_MAIN_RST;
 933         tegra_pmc_writel(pmc, value, PMC_CNTRL);
 934
 935         return NOTIFY_DONE;
 936 }
 937
 938 static struct notifier_block tegra_pmc_restart_handler = {
 939         .notifier_call = tegra_pmc_restart_notify,
 940         .priority = 128,
 941 };
 942
 943 static int powergate_show(struct seq_file *s, void *data)
 944 {
 945         unsigned int i;
 946         int status;
 947
 948         seq_printf(s, " powergate powered\n");
 949         seq_printf(s, "------------------\n");
 950
 951         for (i = 0; i < pmc->soc->num_powergates; i++) {
 952                 status = tegra_powergate_is_powered(pmc, i);
 953                 if (status < 0)
 954                         continue;
 955
 956                 seq_printf(s, " %9s %7s\n", pmc->soc->powergates[i],
 957                            status ? "yes" : "no");
 958         }
 959
 960         return 0;
 961 }
 962
 963 DEFINE_SHOW_ATTRIBUTE(powergate);
 964
 965 static int tegra_powergate_debugfs_init(void)
 966 {
 967         pmc->debugfs = debugfs_create_file("powergate", S_IRUGO, NULL, NULL,
 968                                            &powergate_fops);
 969         if (!pmc->debugfs)
 970                 return -ENOMEM;
 971
 972         return 0;
 973 }
 974
 975 static int tegra_powergate_of_get_clks(struct tegra_powergate *pg,
 976                                        struct device_node *np)
 977 {
 978         struct clk *clk;
 979         unsigned int i, count;
 980         int err;
 981
 982         count = of_clk_get_parent_count(np);
 983         if (count == 0)
 984                 return -ENODEV;
 985
 986         pg->clks = kcalloc(count, sizeof(clk), GFP_KERNEL);
 987         if (!pg->clks)
 988                 return -ENOMEM;
 989
 990         for (i = 0; i < count; i++) {
 991                 pg->clks[i] = of_clk_get(np, i);
 992                 if (IS_ERR(pg->clks[i])) {
 993                         err = PTR_ERR(pg->clks[i]);
 994                         goto err;
 995                 }
 996         }
 997
 998         pg->num_clks = count;
 999
1000         return 0;
1001
1002 err:
1003         while (i--)
1004                 clk_put(pg->clks[i]);
1005
1006         kfree(pg->clks);
1007
1008         return err;
1009 }
1010
1011 static int tegra_powergate_of_get_resets(struct tegra_powergate *pg,
1012                                          struct device_node *np, bool off)
1013 {
1014         struct device *dev = pg->pmc->dev;
1015         int err;
1016
1017         pg->reset = of_reset_control_array_get_exclusive_released(np);
1018         if (IS_ERR(pg->reset)) {
1019                 err = PTR_ERR(pg->reset);
1020                 dev_err(dev, "failed to get device resets: %d\n", err);
1021                 return err;
1022         }
1023
1024         err = reset_control_acquire(pg->reset);
1025         if (err < 0) {
1026                 pr_err("failed to acquire resets: %d\n", err);
1027                 goto out;
1028         }
1029
1030         if (off) {
1031                 err = reset_control_assert(pg->reset);
1032         } else {
1033                 err = reset_control_deassert(pg->reset);
1034                 if (err < 0)
1035                         goto out;
1036
1037                 reset_control_release(pg->reset);
1038         }
1039
1040 out:
1041         if (err) {
1042                 reset_control_release(pg->reset);
1043                 reset_control_put(pg->reset);
1044         }
1045
1046         return err;
1047 }
1048
1049 static int tegra_powergate_add(struct tegra_pmc *pmc, struct device_node *np)
1050 {
1051         struct device *dev = pmc->dev;
1052         struct tegra_powergate *pg;
1053         int id, err = 0;
1054         bool off;
1055
1056         pg = kzalloc(sizeof(*pg), GFP_KERNEL);
1057         if (!pg)
1058                 return -ENOMEM;
1059
1060         id = tegra_powergate_lookup(pmc, np->name);
1061         if (id < 0) {
1062                 dev_err(dev, "powergate lookup failed for %pOFn: %d\n", np, id);
1063                 err = -ENODEV;
1064                 goto free_mem;
1065         }
1066
1067         /*
1068          * Clear the bit for this powergate so it cannot be managed
1069          * directly via the legacy APIs for controlling powergates.
1070          */
1071         clear_bit(id, pmc->powergates_available);
1072
1073         pg->id = id;
1074         pg->genpd.name = np->name;
1075         pg->genpd.power_off = tegra_genpd_power_off;
1076         pg->genpd.power_on = tegra_genpd_power_on;
1077         pg->pmc = pmc;
1078
1079         off = !tegra_powergate_is_powered(pmc, pg->id);
1080
1081         err = tegra_powergate_of_get_clks(pg, np);
1082         if (err < 0) {
1083                 dev_err(dev, "failed to get clocks for %pOFn: %d\n", np, err);
1084                 goto set_available;
1085         }
1086
1087         err = tegra_powergate_of_get_resets(pg, np, off);
1088         if (err < 0) {
1089                 dev_err(dev, "failed to get resets for %pOFn: %d\n", np, err);
1090                 goto remove_clks;
1091         }
1092
1093         if (!IS_ENABLED(CONFIG_PM_GENERIC_DOMAINS)) {
1094                 if (off)
1095                         WARN_ON(tegra_powergate_power_up(pg, true));
1096
1097                 goto remove_resets;
1098         }
1099
1100         err = pm_genpd_init(&pg->genpd, NULL, off);
1101         if (err < 0) {
1102                 dev_err(dev, "failed to initialise PM domain %pOFn: %d\n", np,
1103                        err);
1104                 goto remove_resets;
1105         }
1106
1107         err = of_genpd_add_provider_simple(np, &pg->genpd);
1108         if (err < 0) {
1109                 dev_err(dev, "failed to add PM domain provider for %pOFn: %d\n",
1110                         np, err);
1111                 goto remove_genpd;
1112         }
1113
1114         dev_dbg(dev, "added PM domain %s\n", pg->genpd.name);
1115
1116         return 0;
1117
1118 remove_genpd:
1119         pm_genpd_remove(&pg->genpd);
1120
1121 remove_resets:
1122         reset_control_put(pg->reset);
1123
1124 remove_clks:
1125         while (pg->num_clks--)
1126                 clk_put(pg->clks[pg->num_clks]);
1127
1128         kfree(pg->clks);
1129
1130 set_available:
1131         set_bit(id, pmc->powergates_available);
1132
1133 free_mem:
1134         kfree(pg);
1135
1136         return err;
1137 }
1138
1139 static int tegra_powergate_init(struct tegra_pmc *pmc,
1140                                 struct device_node *parent)
1141 {
1142         struct device_node *np, *child;
1143         int err = 0;
1144
1145         np = of_get_child_by_name(parent, "powergates");
1146         if (!np)
1147                 return 0;
1148
1149         for_each_child_of_node(np, child) {
1150                 err = tegra_powergate_add(pmc, child);
1151                 if (err < 0) {
1152                         of_node_put(child);
1153                         break;
1154                 }
1155         }
1156
1157         of_node_put(np);
1158
1159         return err;
1160 }
1161
1162 static void tegra_powergate_remove(struct generic_pm_domain *genpd)
1163 {
1164         struct tegra_powergate *pg = to_powergate(genpd);
1165
1166         reset_control_put(pg->reset);
1167
1168         while (pg->num_clks--)
1169                 clk_put(pg->clks[pg->num_clks]);
1170
1171         kfree(pg->clks);
1172
1173         set_bit(pg->id, pmc->powergates_available);
1174
1175         kfree(pg);
1176 }
1177
1178 static void tegra_powergate_remove_all(struct device_node *parent)
1179 {
1180         struct generic_pm_domain *genpd;
1181         struct device_node *np, *child;
1182
1183         np = of_get_child_by_name(parent, "powergates");
1184         if (!np)
1185                 return;
1186
1187         for_each_child_of_node(np, child) {
1188                 of_genpd_del_provider(child);
1189
1190                 genpd = of_genpd_remove_last(child);
1191                 if (IS_ERR(genpd))
1192                         continue;
1193
1194                 tegra_powergate_remove(genpd);
1195         }
1196
1197         of_node_put(np);
1198 }
1199
1200 static const struct tegra_io_pad_soc *
1201 tegra_io_pad_find(struct tegra_pmc *pmc, enum tegra_io_pad id)
1202 {
1203         unsigned int i;
1204
1205         for (i = 0; i < pmc->soc->num_io_pads; i++)
1206                 if (pmc->soc->io_pads[i].id == id)
1207                         return &pmc->soc->io_pads[i];
1208
1209         return NULL;
1210 }
1211
1212 static int tegra_io_pad_get_dpd_register_bit(struct tegra_pmc *pmc,
1213                                              enum tegra_io_pad id,
1214                                              unsigned long *request,
1215                                              unsigned long *status,
1216                                              u32 *mask)
1217 {
1218         const struct tegra_io_pad_soc *pad;
1219
1220         pad = tegra_io_pad_find(pmc, id);
1221         if (!pad) {
1222                 dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);
1223                 return -ENOENT;
1224         }
1225
1226         if (pad->dpd == UINT_MAX)
1227                 return -ENOTSUPP;
1228
1229         *mask = BIT(pad->dpd % 32);
1230
1231         if (pad->dpd < 32) {
1232                 *status = pmc->soc->regs->dpd_status;
1233                 *request = pmc->soc->regs->dpd_req;
1234         } else {
1235                 *status = pmc->soc->regs->dpd2_status;
1236                 *request = pmc->soc->regs->dpd2_req;
1237         }
1238
1239         return 0;
1240 }
1241
1242 static int tegra_io_pad_prepare(struct tegra_pmc *pmc, enum tegra_io_pad id,
1243                                 unsigned long *request, unsigned long *status,
1244                                 u32 *mask)
1245 {
1246         unsigned long rate, value;
1247         int err;
1248
1249         err = tegra_io_pad_get_dpd_register_bit(pmc, id, request, status, mask);
1250         if (err)
1251                 return err;
1252
1253         if (pmc->clk) {
1254                 rate = pmc->rate;
1255                 if (!rate) {
1256                         dev_err(pmc->dev, "failed to get clock rate\n");
1257                         return -ENODEV;
1258                 }
1259
1260                 tegra_pmc_writel(pmc, DPD_SAMPLE_ENABLE, DPD_SAMPLE);
1261
1262                 /* must be at least 200 ns, in APB (PCLK) clock cycles */
1263                 value = DIV_ROUND_UP(1000000000, rate);
1264                 value = DIV_ROUND_UP(200, value);
1265                 tegra_pmc_writel(pmc, value, SEL_DPD_TIM);
1266         }
1267
1268         return 0;
1269 }
1270
1271 static int tegra_io_pad_poll(struct tegra_pmc *pmc, unsigned long offset,
1272                              u32 mask, u32 val, unsigned long timeout)
1273 {
1274         u32 value;
1275
1276         timeout = jiffies + msecs_to_jiffies(timeout);
1277
1278         while (time_after(timeout, jiffies)) {
1279                 value = tegra_pmc_readl(pmc, offset);
1280                 if ((value & mask) == val)
1281                         return 0;
1282
1283                 usleep_range(250, 1000);
1284         }
1285
1286         return -ETIMEDOUT;
1287 }
1288
1289 static void tegra_io_pad_unprepare(struct tegra_pmc *pmc)
1290 {
1291         if (pmc->clk)
1292                 tegra_pmc_writel(pmc, DPD_SAMPLE_DISABLE, DPD_SAMPLE);
1293 }
1294
1295 /**
1296  * tegra_io_pad_power_enable() - enable power to I/O pad
1297  * @id: Tegra I/O pad ID for which to enable power
1298  *
1299  * Returns: 0 on success or a negative error code on failure.
1300  */
1301 int tegra_io_pad_power_enable(enum tegra_io_pad id)
1302 {
1303         unsigned long request, status;
1304         u32 mask;
1305         int err;
1306
1307         mutex_lock(&pmc->powergates_lock);
1308
1309         err = tegra_io_pad_prepare(pmc, id, &request, &status, &mask);
1310         if (err < 0) {
1311                 dev_err(pmc->dev, "failed to prepare I/O pad: %d\n", err);
1312                 goto unlock;
1313         }
1314
1315         tegra_pmc_writel(pmc, IO_DPD_REQ_CODE_OFF | mask, request);
1316
1317         err = tegra_io_pad_poll(pmc, status, mask, 0, 250);
1318         if (err < 0) {
1319                 dev_err(pmc->dev, "failed to enable I/O pad: %d\n", err);
1320                 goto unlock;
1321         }
1322
1323         tegra_io_pad_unprepare(pmc);
1324
1325 unlock:
1326         mutex_unlock(&pmc->powergates_lock);
1327         return err;
1328 }
1329 EXPORT_SYMBOL(tegra_io_pad_power_enable);
1330
1331 /**
1332  * tegra_io_pad_power_disable() - disable power to I/O pad
1333  * @id: Tegra I/O pad ID for which to disable power
1334  *
1335  * Returns: 0 on success or a negative error code on failure.
1336  */
1337 int tegra_io_pad_power_disable(enum tegra_io_pad id)
1338 {
1339         unsigned long request, status;
1340         u32 mask;
1341         int err;
1342
1343         mutex_lock(&pmc->powergates_lock);
1344
1345         err = tegra_io_pad_prepare(pmc, id, &request, &status, &mask);
1346         if (err < 0) {
1347                 dev_err(pmc->dev, "failed to prepare I/O pad: %d\n", err);
1348                 goto unlock;
1349         }
1350
1351         tegra_pmc_writel(pmc, IO_DPD_REQ_CODE_ON | mask, request);
1352
1353         err = tegra_io_pad_poll(pmc, status, mask, mask, 250);
1354         if (err < 0) {
1355                 dev_err(pmc->dev, "failed to disable I/O pad: %d\n", err);
1356                 goto unlock;
1357         }
1358
1359         tegra_io_pad_unprepare(pmc);
1360
1361 unlock:
1362         mutex_unlock(&pmc->powergates_lock);
1363         return err;
1364 }
1365 EXPORT_SYMBOL(tegra_io_pad_power_disable);
1366
1367 static int tegra_io_pad_is_powered(struct tegra_pmc *pmc, enum tegra_io_pad id)
1368 {
1369         unsigned long request, status;
1370         u32 mask, value;
1371         int err;
1372
1373         err = tegra_io_pad_get_dpd_register_bit(pmc, id, &request, &status,
1374                                                 &mask);
1375         if (err)
1376                 return err;
1377
1378         value = tegra_pmc_readl(pmc, status);
1379
1380         return !(value & mask);
1381 }
1382
1383 static int tegra_io_pad_set_voltage(struct tegra_pmc *pmc, enum tegra_io_pad id,
1384                                     int voltage)
1385 {
1386         const struct tegra_io_pad_soc *pad;
1387         u32 value;
1388
1389         pad = tegra_io_pad_find(pmc, id);
1390         if (!pad)
1391                 return -ENOENT;
1392
1393         if (pad->voltage == UINT_MAX)
1394                 return -ENOTSUPP;
1395
1396         mutex_lock(&pmc->powergates_lock);
1397
1398         if (pmc->soc->has_impl_33v_pwr) {
1399                 value = tegra_pmc_readl(pmc, PMC_IMPL_E_33V_PWR);
1400
1401                 if (voltage == TEGRA_IO_PAD_VOLTAGE_1V8)
1402                         value &= ~BIT(pad->voltage);
1403                 else
1404                         value |= BIT(pad->voltage);
1405
1406                 tegra_pmc_writel(pmc, value, PMC_IMPL_E_33V_PWR);
1407         } else {
1408                 /* write-enable PMC_PWR_DET_VALUE[pad->voltage] */
1409                 value = tegra_pmc_readl(pmc, PMC_PWR_DET);
1410                 value |= BIT(pad->voltage);
1411                 tegra_pmc_writel(pmc, value, PMC_PWR_DET);
1412
1413                 /* update I/O voltage */
1414                 value = tegra_pmc_readl(pmc, PMC_PWR_DET_VALUE);
1415
1416                 if (voltage == TEGRA_IO_PAD_VOLTAGE_1V8)
1417                         value &= ~BIT(pad->voltage);
1418                 else
1419                         value |= BIT(pad->voltage);
1420
1421                 tegra_pmc_writel(pmc, value, PMC_PWR_DET_VALUE);
1422         }
1423
1424         mutex_unlock(&pmc->powergates_lock);
1425
1426         usleep_range(100, 250);
1427
1428         return 0;
1429 }
1430
1431 static int tegra_io_pad_get_voltage(struct tegra_pmc *pmc, enum tegra_io_pad id)
1432 {
1433         const struct tegra_io_pad_soc *pad;
1434         u32 value;
1435
1436         pad = tegra_io_pad_find(pmc, id);
1437         if (!pad)
1438                 return -ENOENT;
1439
1440         if (pad->voltage == UINT_MAX)
1441                 return -ENOTSUPP;
1442
1443         if (pmc->soc->has_impl_33v_pwr)
1444                 value = tegra_pmc_readl(pmc, PMC_IMPL_E_33V_PWR);
1445         else
1446                 value = tegra_pmc_readl(pmc, PMC_PWR_DET_VALUE);
1447
1448         if ((value & BIT(pad->voltage)) == 0)
1449                 return TEGRA_IO_PAD_VOLTAGE_1V8;
1450
1451         return TEGRA_IO_PAD_VOLTAGE_3V3;
1452 }
1453
1454 /**
1455  * tegra_io_rail_power_on() - enable power to I/O rail
1456  * @id: Tegra I/O pad ID for which to enable power
1457  *
1458  * See also: tegra_io_pad_power_enable()
1459  */
1460 int tegra_io_rail_power_on(unsigned int id)
1461 {
1462         return tegra_io_pad_power_enable(id);
1463 }
1464 EXPORT_SYMBOL(tegra_io_rail_power_on);
1465
1466 /**
1467  * tegra_io_rail_power_off() - disable power to I/O rail
1468  * @id: Tegra I/O pad ID for which to disable power
1469  *
1470  * See also: tegra_io_pad_power_disable()
1471  */
1472 int tegra_io_rail_power_off(unsigned int id)
1473 {
1474         return tegra_io_pad_power_disable(id);
1475 }
1476 EXPORT_SYMBOL(tegra_io_rail_power_off);
1477
1478 #ifdef CONFIG_PM_SLEEP
1479 enum tegra_suspend_mode tegra_pmc_get_suspend_mode(void)
1480 {
1481         return pmc->suspend_mode;
1482 }
1483
1484 void tegra_pmc_set_suspend_mode(enum tegra_suspend_mode mode)
1485 {
1486         if (mode < TEGRA_SUSPEND_NONE || mode >= TEGRA_MAX_SUSPEND_MODE)
1487                 return;
1488
1489         pmc->suspend_mode = mode;
1490 }
1491
1492 void tegra_pmc_enter_suspend_mode(enum tegra_suspend_mode mode)
1493 {
1494         unsigned long long rate = 0;
1495         u64 ticks;
1496         u32 value;
1497
1498         switch (mode) {
1499         case TEGRA_SUSPEND_LP1:
1500                 rate = 32768;
1501                 break;
1502
1503         case TEGRA_SUSPEND_LP2:
1504                 rate = pmc->rate;
1505                 break;
1506
1507         default:
1508                 break;
1509         }
1510
1511         if (WARN_ON_ONCE(rate == 0))
1512                 rate = 100000000;
1513
1514         ticks = pmc->cpu_good_time * rate + USEC_PER_SEC - 1;
1515         do_div(ticks, USEC_PER_SEC);
1516         tegra_pmc_writel(pmc, ticks, PMC_CPUPWRGOOD_TIMER);
1517
1518         ticks = pmc->cpu_off_time * rate + USEC_PER_SEC - 1;
1519         do_div(ticks, USEC_PER_SEC);
1520         tegra_pmc_writel(pmc, ticks, PMC_CPUPWROFF_TIMER);
1521
1522         value = tegra_pmc_readl(pmc, PMC_CNTRL);
1523         value &= ~PMC_CNTRL_SIDE_EFFECT_LP0;
1524         value |= PMC_CNTRL_CPU_PWRREQ_OE;
1525         tegra_pmc_writel(pmc, value, PMC_CNTRL);
1526 }
1527 #endif
1528
1529 static int tegra_pmc_parse_dt(struct tegra_pmc *pmc, struct device_node *np)
1530 {
1531         u32 value, values[2];
1532
1533         if (of_property_read_u32(np, "nvidia,suspend-mode", &value)) {
1534         } else {
1535                 switch (value) {
1536                 case 0:
1537                         pmc->suspend_mode = TEGRA_SUSPEND_LP0;
1538                         break;
1539
1540                 case 1:
1541                         pmc->suspend_mode = TEGRA_SUSPEND_LP1;
1542                         break;
1543
1544                 case 2:
1545                         pmc->suspend_mode = TEGRA_SUSPEND_LP2;
1546                         break;
1547
1548                 default:
1549                         pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1550                         break;
1551                 }
1552         }
1553
1554         pmc->suspend_mode = tegra_pm_validate_suspend_mode(pmc->suspend_mode);
1555
1556         if (of_property_read_u32(np, "nvidia,cpu-pwr-good-time", &value))
1557                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1558
1559         pmc->cpu_good_time = value;
1560
1561         if (of_property_read_u32(np, "nvidia,cpu-pwr-off-time", &value))
1562                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1563
1564         pmc->cpu_off_time = value;
1565
1566         if (of_property_read_u32_array(np, "nvidia,core-pwr-good-time",
1567                                        values, ARRAY_SIZE(values)))
1568                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1569
1570         pmc->core_osc_time = values[0];
1571         pmc->core_pmu_time = values[1];
1572
1573         if (of_property_read_u32(np, "nvidia,core-pwr-off-time", &value))
1574                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1575
1576         pmc->core_off_time = value;
1577
1578         pmc->corereq_high = of_property_read_bool(np,
1579                                 "nvidia,core-power-req-active-high");
1580
1581         pmc->sysclkreq_high = of_property_read_bool(np,
1582                                 "nvidia,sys-clock-req-active-high");
1583
1584         pmc->combined_req = of_property_read_bool(np,
1585                                 "nvidia,combined-power-req");
1586
1587         pmc->cpu_pwr_good_en = of_property_read_bool(np,
1588                                 "nvidia,cpu-pwr-good-en");
1589
1590         if (of_property_read_u32_array(np, "nvidia,lp0-vec", values,
1591                                        ARRAY_SIZE(values)))
1592                 if (pmc->suspend_mode == TEGRA_SUSPEND_LP0)
1593                         pmc->suspend_mode = TEGRA_SUSPEND_LP1;
1594
1595         pmc->lp0_vec_phys = values[0];
1596         pmc->lp0_vec_size = values[1];
1597
1598         return 0;
1599 }
1600
1601 static void tegra_pmc_init(struct tegra_pmc *pmc)
1602 {
1603         if (pmc->soc->init)
1604                 pmc->soc->init(pmc);
1605 }
1606
1607 static void tegra_pmc_init_tsense_reset(struct tegra_pmc *pmc)
1608 {
1609         static const char disabled[] = "emergency thermal reset disabled";
1610         u32 pmu_addr, ctrl_id, reg_addr, reg_data, pinmux;
1611         struct device *dev = pmc->dev;
1612         struct device_node *np;
1613         u32 value, checksum;
1614
1615         if (!pmc->soc->has_tsense_reset)
1616                 return;
1617
1618         np = of_get_child_by_name(pmc->dev->of_node, "i2c-thermtrip");
1619         if (!np) {
1620                 dev_warn(dev, "i2c-thermtrip node not found, %s.\n", disabled);
1621                 return;
1622         }
1623
1624         if (of_property_read_u32(np, "nvidia,i2c-controller-id", &ctrl_id)) {
1625                 dev_err(dev, "I2C controller ID missing, %s.\n", disabled);
1626                 goto out;
1627         }
1628
1629         if (of_property_read_u32(np, "nvidia,bus-addr", &pmu_addr)) {
1630                 dev_err(dev, "nvidia,bus-addr missing, %s.\n", disabled);
1631                 goto out;
1632         }
1633
1634         if (of_property_read_u32(np, "nvidia,reg-addr", &reg_addr)) {
1635                 dev_err(dev, "nvidia,reg-addr missing, %s.\n", disabled);
1636                 goto out;
1637         }
1638
1639         if (of_property_read_u32(np, "nvidia,reg-data", &reg_data)) {
1640                 dev_err(dev, "nvidia,reg-data missing, %s.\n", disabled);
1641                 goto out;
1642         }
1643
1644         if (of_property_read_u32(np, "nvidia,pinmux-id", &pinmux))
1645                 pinmux = 0;
1646
1647         value = tegra_pmc_readl(pmc, PMC_SENSOR_CTRL);
1648         value |= PMC_SENSOR_CTRL_SCRATCH_WRITE;
1649         tegra_pmc_writel(pmc, value, PMC_SENSOR_CTRL);
1650
1651         value = (reg_data << PMC_SCRATCH54_DATA_SHIFT) |
1652                 (reg_addr << PMC_SCRATCH54_ADDR_SHIFT);
1653         tegra_pmc_writel(pmc, value, PMC_SCRATCH54);
1654
1655         value = PMC_SCRATCH55_RESET_TEGRA;
1656         value |= ctrl_id << PMC_SCRATCH55_CNTRL_ID_SHIFT;
1657         value |= pinmux << PMC_SCRATCH55_PINMUX_SHIFT;
1658         value |= pmu_addr << PMC_SCRATCH55_I2CSLV1_SHIFT;
1659
1660         /*
1661          * Calculate checksum of SCRATCH54, SCRATCH55 fields. Bits 23:16 will
1662          * contain the checksum and are currently zero, so they are not added.
1663          */
1664         checksum = reg_addr + reg_data + (value & 0xff) + ((value >> 8) & 0xff)
1665                 + ((value >> 24) & 0xff);
1666         checksum &= 0xff;
1667         checksum = 0x100 - checksum;
1668
1669         value |= checksum << PMC_SCRATCH55_CHECKSUM_SHIFT;
1670
1671         tegra_pmc_writel(pmc, value, PMC_SCRATCH55);
1672
1673         value = tegra_pmc_readl(pmc, PMC_SENSOR_CTRL);
1674         value |= PMC_SENSOR_CTRL_ENABLE_RST;
1675         tegra_pmc_writel(pmc, value, PMC_SENSOR_CTRL);
1676
1677         dev_info(pmc->dev, "emergency thermal reset enabled\n");
1678
1679 out:
1680         of_node_put(np);
1681 }
1682
1683 static int tegra_io_pad_pinctrl_get_groups_count(struct pinctrl_dev *pctl_dev)
1684 {
1685         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
1686
1687         return pmc->soc->num_io_pads;
1688 }
1689
1690 static const char *tegra_io_pad_pinctrl_get_group_name(struct pinctrl_dev *pctl,
1691                                                        unsigned int group)
1692 {
1693         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl);
1694
1695         return pmc->soc->io_pads[group].name;
1696 }
1697
1698 static int tegra_io_pad_pinctrl_get_group_pins(struct pinctrl_dev *pctl_dev,
1699                                                unsigned int group,
1700                                                const unsigned int **pins,
1701                                                unsigned int *num_pins)
1702 {
1703         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
1704
1705         *pins = &pmc->soc->io_pads[group].id;
1706         *num_pins = 1;
1707
1708         return 0;
1709 }
1710
1711 static const struct pinctrl_ops tegra_io_pad_pinctrl_ops = {
1712         .get_groups_count = tegra_io_pad_pinctrl_get_groups_count,
1713         .get_group_name = tegra_io_pad_pinctrl_get_group_name,
1714         .get_group_pins = tegra_io_pad_pinctrl_get_group_pins,
1715         .dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
1716         .dt_free_map = pinconf_generic_dt_free_map,
1717 };
1718
1719 static int tegra_io_pad_pinconf_get(struct pinctrl_dev *pctl_dev,
1720                                     unsigned int pin, unsigned long *config)
1721 {
1722         enum pin_config_param param = pinconf_to_config_param(*config);
1723         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
1724         const struct tegra_io_pad_soc *pad;
1725         int ret;
1726         u32 arg;
1727
1728         pad = tegra_io_pad_find(pmc, pin);
1729         if (!pad)
1730                 return -EINVAL;
1731
1732         switch (param) {
1733         case PIN_CONFIG_POWER_SOURCE:
1734                 ret = tegra_io_pad_get_voltage(pmc, pad->id);
1735                 if (ret < 0)
1736                         return ret;
1737
1738                 arg = ret;
1739                 break;
1740
1741         case PIN_CONFIG_LOW_POWER_MODE:
1742                 ret = tegra_io_pad_is_powered(pmc, pad->id);
1743                 if (ret < 0)
1744                         return ret;
1745
1746                 arg = !ret;
1747                 break;
1748
1749         default:
1750                 return -EINVAL;
1751         }
1752
1753         *config = pinconf_to_config_packed(param, arg);
1754
1755         return 0;
1756 }
1757
1758 static int tegra_io_pad_pinconf_set(struct pinctrl_dev *pctl_dev,
1759                                     unsigned int pin, unsigned long *configs,
1760                                     unsigned int num_configs)
1761 {
1762         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
1763         const struct tegra_io_pad_soc *pad;
1764         enum pin_config_param param;
1765         unsigned int i;
1766         int err;
1767         u32 arg;
1768
1769         pad = tegra_io_pad_find(pmc, pin);
1770         if (!pad)
1771                 return -EINVAL;
1772
1773         for (i = 0; i < num_configs; ++i) {
1774                 param = pinconf_to_config_param(configs[i]);
1775                 arg = pinconf_to_config_argument(configs[i]);
1776
1777                 switch (param) {
1778                 case PIN_CONFIG_LOW_POWER_MODE:
1779                         if (arg)
1780                                 err = tegra_io_pad_power_disable(pad->id);
1781                         else
1782                                 err = tegra_io_pad_power_enable(pad->id);
1783                         if (err)
1784                                 return err;
1785                         break;
1786                 case PIN_CONFIG_POWER_SOURCE:
1787                         if (arg != TEGRA_IO_PAD_VOLTAGE_1V8 &&
1788                             arg != TEGRA_IO_PAD_VOLTAGE_3V3)
1789                                 return -EINVAL;
1790                         err = tegra_io_pad_set_voltage(pmc, pad->id, arg);
1791                         if (err)
1792                                 return err;
1793                         break;
1794                 default:
1795                         return -EINVAL;
1796                 }
1797         }
1798
1799         return 0;
1800 }
1801
1802 static const struct pinconf_ops tegra_io_pad_pinconf_ops = {
1803         .pin_config_get = tegra_io_pad_pinconf_get,
1804         .pin_config_set = tegra_io_pad_pinconf_set,
1805         .is_generic = true,
1806 };
1807
1808 static struct pinctrl_desc tegra_pmc_pctl_desc = {
1809         .pctlops = &tegra_io_pad_pinctrl_ops,
1810         .confops = &tegra_io_pad_pinconf_ops,
1811 };
1812
1813 static int tegra_pmc_pinctrl_init(struct tegra_pmc *pmc)
1814 {
1815         int err;
1816
1817         if (!pmc->soc->num_pin_descs)
1818                 return 0;
1819
1820         tegra_pmc_pctl_desc.name = dev_name(pmc->dev);
1821         tegra_pmc_pctl_desc.pins = pmc->soc->pin_descs;
1822         tegra_pmc_pctl_desc.npins = pmc->soc->num_pin_descs;
1823
1824         pmc->pctl_dev = devm_pinctrl_register(pmc->dev, &tegra_pmc_pctl_desc,
1825                                               pmc);
1826         if (IS_ERR(pmc->pctl_dev)) {
1827                 err = PTR_ERR(pmc->pctl_dev);
1828                 dev_err(pmc->dev, "failed to register pin controller: %d\n",
1829                         err);
1830                 return err;
1831         }
1832
1833         return 0;
1834 }
1835
1836 static ssize_t reset_reason_show(struct device *dev,
1837                                  struct device_attribute *attr, char *buf)
1838 {
1839         u32 value;
1840
1841         value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);
1842         value &= pmc->soc->regs->rst_source_mask;
1843         value >>= pmc->soc->regs->rst_source_shift;
1844
1845         if (WARN_ON(value >= pmc->soc->num_reset_sources))
1846                 return sprintf(buf, "%s\n", "UNKNOWN");
1847
1848         return sprintf(buf, "%s\n", pmc->soc->reset_sources[value]);
1849 }
1850
1851 static DEVICE_ATTR_RO(reset_reason);
1852
1853 static ssize_t reset_level_show(struct device *dev,
1854                                 struct device_attribute *attr, char *buf)
1855 {
1856         u32 value;
1857
1858         value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);
1859         value &= pmc->soc->regs->rst_level_mask;
1860         value >>= pmc->soc->regs->rst_level_shift;
1861
1862         if (WARN_ON(value >= pmc->soc->num_reset_levels))
1863                 return sprintf(buf, "%s\n", "UNKNOWN");
1864
1865         return sprintf(buf, "%s\n", pmc->soc->reset_levels[value]);
1866 }
1867
1868 static DEVICE_ATTR_RO(reset_level);
1869
1870 static void tegra_pmc_reset_sysfs_init(struct tegra_pmc *pmc)
1871 {
1872         struct device *dev = pmc->dev;
1873         int err = 0;
1874
1875         if (pmc->soc->reset_sources) {
1876                 err = device_create_file(dev, &dev_attr_reset_reason);
1877                 if (err < 0)
1878                         dev_warn(dev,
1879                                  "failed to create attr \"reset_reason\": %d\n",
1880                                  err);
1881         }
1882
1883         if (pmc->soc->reset_levels) {
1884                 err = device_create_file(dev, &dev_attr_reset_level);
1885                 if (err < 0)
1886                         dev_warn(dev,
1887                                  "failed to create attr \"reset_level\": %d\n",
1888                                  err);
1889         }
1890 }
1891
1892 static int tegra_pmc_irq_translate(struct irq_domain *domain,
1893                                    struct irq_fwspec *fwspec,
1894                                    unsigned long *hwirq,
1895                                    unsigned int *type)
1896 {
1897         if (WARN_ON(fwspec->param_count < 2))
1898                 return -EINVAL;
1899
1900         *hwirq = fwspec->param[0];
1901         *type = fwspec->param[1];
1902
1903         return 0;
1904 }
1905
1906 static int tegra_pmc_irq_alloc(struct irq_domain *domain, unsigned int virq,
1907                                unsigned int num_irqs, void *data)
1908 {
1909         struct tegra_pmc *pmc = domain->host_data;
1910         const struct tegra_pmc_soc *soc = pmc->soc;
1911         struct irq_fwspec *fwspec = data;
1912         unsigned int i;
1913         int err = 0;
1914
1915         if (WARN_ON(num_irqs > 1))
1916                 return -EINVAL;
1917
1918         for (i = 0; i < soc->num_wake_events; i++) {
1919                 const struct tegra_wake_event *event = &soc->wake_events[i];
1920
1921                 if (fwspec->param_count == 2) {
1922                         struct irq_fwspec spec;
1923
1924                         if (event->id != fwspec->param[0])
1925                                 continue;
1926
1927                         err = irq_domain_set_hwirq_and_chip(domain, virq,
1928                                                             event->id,
1929                                                             &pmc->irq, pmc);
1930                         if (err < 0)
1931                                 break;
1932
1933                         spec.fwnode = &pmc->dev->of_node->fwnode;
1934                         spec.param_count = 3;
1935                         spec.param[0] = GIC_SPI;
1936                         spec.param[1] = event->irq;
1937                         spec.param[2] = fwspec->param[1];
1938
1939                         err = irq_domain_alloc_irqs_parent(domain, virq,
1940                                                            num_irqs, &spec);
1941
1942                         break;
1943                 }
1944
1945                 if (fwspec->param_count == 3) {
1946                         if (event->gpio.instance != fwspec->param[0] ||
1947                             event->gpio.pin != fwspec->param[1])
1948                                 continue;
1949
1950                         err = irq_domain_set_hwirq_and_chip(domain, virq,
1951                                                             event->id,
1952                                                             &pmc->irq, pmc);
1953
1954                         /* GPIO hierarchies stop at the PMC level */
1955                         if (!err && domain->parent)
1956                                 err = irq_domain_disconnect_hierarchy(domain->parent,
1957                                                                       virq);
1958                         break;
1959                 }
1960         }
1961
1962         /* If there is no wake-up event, there is no PMC mapping */
1963         if (i == soc->num_wake_events)
1964                 err = irq_domain_disconnect_hierarchy(domain, virq);
1965
1966         return err;
1967 }
1968
1969 static const struct irq_domain_ops tegra_pmc_irq_domain_ops = {
1970         .translate = tegra_pmc_irq_translate,
1971         .alloc = tegra_pmc_irq_alloc,
1972 };
1973
1974 static int tegra210_pmc_irq_set_wake(struct irq_data *data, unsigned int on)
1975 {
1976         struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
1977         unsigned int offset, bit;
1978         u32 value;
1979
1980         offset = data->hwirq / 32;
1981         bit = data->hwirq % 32;
1982
1983         /* clear wake status */
1984         tegra_pmc_writel(pmc, 0, PMC_SW_WAKE_STATUS);
1985         tegra_pmc_writel(pmc, 0, PMC_SW_WAKE2_STATUS);
1986
1987         tegra_pmc_writel(pmc, 0, PMC_WAKE_STATUS);
1988         tegra_pmc_writel(pmc, 0, PMC_WAKE2_STATUS);
1989
1990         /* enable PMC wake */
1991         if (data->hwirq >= 32)
1992                 offset = PMC_WAKE2_MASK;
1993         else
1994                 offset = PMC_WAKE_MASK;
1995
1996         value = tegra_pmc_readl(pmc, offset);
1997
1998         if (on)
1999                 value |= BIT(bit);
2000         else
2001                 value &= ~BIT(bit);
2002
2003         tegra_pmc_writel(pmc, value, offset);
2004
2005         return 0;
2006 }
2007
2008 static int tegra210_pmc_irq_set_type(struct irq_data *data, unsigned int type)
2009 {
2010         struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2011         unsigned int offset, bit;
2012         u32 value;
2013
2014         offset = data->hwirq / 32;
2015         bit = data->hwirq % 32;
2016
2017         if (data->hwirq >= 32)
2018                 offset = PMC_WAKE2_LEVEL;
2019         else
2020                 offset = PMC_WAKE_LEVEL;
2021
2022         value = tegra_pmc_readl(pmc, offset);
2023
2024         switch (type) {
2025         case IRQ_TYPE_EDGE_RISING:
2026         case IRQ_TYPE_LEVEL_HIGH:
2027                 value |= BIT(bit);
2028                 break;
2029
2030         case IRQ_TYPE_EDGE_FALLING:
2031         case IRQ_TYPE_LEVEL_LOW:
2032                 value &= ~BIT(bit);
2033                 break;
2034
2035         case IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING:
2036                 value ^= BIT(bit);
2037                 break;
2038
2039         default:
2040                 return -EINVAL;
2041         }
2042
2043         tegra_pmc_writel(pmc, value, offset);
2044
2045         return 0;
2046 }
2047
2048 static int tegra186_pmc_irq_set_wake(struct irq_data *data, unsigned int on)
2049 {
2050         struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2051         unsigned int offset, bit;
2052         u32 value;
2053
2054         offset = data->hwirq / 32;
2055         bit = data->hwirq % 32;
2056
2057         /* clear wake status */
2058         writel(0x1, pmc->wake + WAKE_AOWAKE_STATUS_W(data->hwirq));
2059
2060         /* route wake to tier 2 */
2061         value = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(offset));
2062
2063         if (!on)
2064                 value &= ~(1 << bit);
2065         else
2066                 value |= 1 << bit;
2067
2068         writel(value, pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(offset));
2069
2070         /* enable wakeup event */
2071         writel(!!on, pmc->wake + WAKE_AOWAKE_MASK_W(data->hwirq));
2072
2073         return 0;
2074 }
2075
2076 static int tegra186_pmc_irq_set_type(struct irq_data *data, unsigned int type)
2077 {
2078         struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2079         u32 value;
2080
2081         value = readl(pmc->wake + WAKE_AOWAKE_CNTRL(data->hwirq));
2082
2083         switch (type) {
2084         case IRQ_TYPE_EDGE_RISING:
2085         case IRQ_TYPE_LEVEL_HIGH:
2086                 value |= WAKE_AOWAKE_CNTRL_LEVEL;
2087                 break;
2088
2089         case IRQ_TYPE_EDGE_FALLING:
2090         case IRQ_TYPE_LEVEL_LOW:
2091                 value &= ~WAKE_AOWAKE_CNTRL_LEVEL;
2092                 break;
2093
2094         case IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING:
2095                 value ^= WAKE_AOWAKE_CNTRL_LEVEL;
2096                 break;
2097
2098         default:
2099                 return -EINVAL;
2100         }
2101
2102         writel(value, pmc->wake + WAKE_AOWAKE_CNTRL(data->hwirq));
2103
2104         return 0;
2105 }
2106
2107 static void tegra_irq_mask_parent(struct irq_data *data)
2108 {
2109         if (data->parent_data)
2110                 irq_chip_mask_parent(data);
2111 }
2112
2113 static void tegra_irq_unmask_parent(struct irq_data *data)
2114 {
2115         if (data->parent_data)
2116                 irq_chip_unmask_parent(data);
2117 }
2118
2119 static void tegra_irq_eoi_parent(struct irq_data *data)
2120 {
2121         if (data->parent_data)
2122                 irq_chip_eoi_parent(data);
2123 }
2124
2125 static int tegra_irq_set_affinity_parent(struct irq_data *data,
2126                                          const struct cpumask *dest,
2127                                          bool force)
2128 {
2129         if (data->parent_data)
2130                 return irq_chip_set_affinity_parent(data, dest, force);
2131
2132         return -EINVAL;
2133 }
2134
2135 static int tegra_pmc_irq_init(struct tegra_pmc *pmc)
2136 {
2137         struct irq_domain *parent = NULL;
2138         struct device_node *np;
2139
2140         np = of_irq_find_parent(pmc->dev->of_node);
2141         if (np) {
2142                 parent = irq_find_host(np);
2143                 of_node_put(np);
2144         }
2145
2146         if (!parent)
2147                 return 0;
2148
2149         pmc->irq.name = dev_name(pmc->dev);
2150         pmc->irq.irq_mask = tegra_irq_mask_parent;
2151         pmc->irq.irq_unmask = tegra_irq_unmask_parent;
2152         pmc->irq.irq_eoi = tegra_irq_eoi_parent;
2153         pmc->irq.irq_set_affinity = tegra_irq_set_affinity_parent;
2154         pmc->irq.irq_set_type = pmc->soc->irq_set_type;
2155         pmc->irq.irq_set_wake = pmc->soc->irq_set_wake;
2156
2157         pmc->domain = irq_domain_add_hierarchy(parent, 0, 96, pmc->dev->of_node,
2158                                                &tegra_pmc_irq_domain_ops, pmc);
2159         if (!pmc->domain) {
2160                 dev_err(pmc->dev, "failed to allocate domain\n");
2161                 return -ENOMEM;
2162         }
2163
2164         return 0;
2165 }
2166
2167 static int tegra_pmc_clk_notify_cb(struct notifier_block *nb,
2168                                    unsigned long action, void *ptr)
2169 {
2170         struct tegra_pmc *pmc = container_of(nb, struct tegra_pmc, clk_nb);
2171         struct clk_notifier_data *data = ptr;
2172
2173         switch (action) {
2174         case PRE_RATE_CHANGE:
2175                 mutex_lock(&pmc->powergates_lock);
2176                 break;
2177
2178         case POST_RATE_CHANGE:
2179                 pmc->rate = data->new_rate;
2180                 fallthrough;
2181
2182         case ABORT_RATE_CHANGE:
2183                 mutex_unlock(&pmc->powergates_lock);
2184                 break;
2185
2186         default:
2187                 WARN_ON_ONCE(1);
2188                 return notifier_from_errno(-EINVAL);
2189         }
2190
2191         return NOTIFY_OK;
2192 }
2193
2194 static void pmc_clk_fence_udelay(u32 offset)
2195 {
2196         tegra_pmc_readl(pmc, offset);
2197         /* pmc clk propagation delay 2 us */
2198         udelay(2);
2199 }
2200
2201 static u8 pmc_clk_mux_get_parent(struct clk_hw *hw)
2202 {
2203         struct pmc_clk *clk = to_pmc_clk(hw);
2204         u32 val;
2205
2206         val = tegra_pmc_readl(pmc, clk->offs) >> clk->mux_shift;
2207         val &= PMC_CLK_OUT_MUX_MASK;
2208
2209         return val;
2210 }
2211
2212 static int pmc_clk_mux_set_parent(struct clk_hw *hw, u8 index)
2213 {
2214         struct pmc_clk *clk = to_pmc_clk(hw);
2215         u32 val;
2216
2217         val = tegra_pmc_readl(pmc, clk->offs);
2218         val &= ~(PMC_CLK_OUT_MUX_MASK << clk->mux_shift);
2219         val |= index << clk->mux_shift;
2220         tegra_pmc_writel(pmc, val, clk->offs);
2221         pmc_clk_fence_udelay(clk->offs);
2222
2223         return 0;
2224 }
2225
2226 static int pmc_clk_is_enabled(struct clk_hw *hw)
2227 {
2228         struct pmc_clk *clk = to_pmc_clk(hw);
2229         u32 val;
2230
2231         val = tegra_pmc_readl(pmc, clk->offs) & BIT(clk->force_en_shift);
2232
2233         return val ? 1 : 0;
2234 }
2235
2236 static void pmc_clk_set_state(unsigned long offs, u32 shift, int state)
2237 {
2238         u32 val;
2239
2240         val = tegra_pmc_readl(pmc, offs);
2241         val = state ? (val | BIT(shift)) : (val & ~BIT(shift));
2242         tegra_pmc_writel(pmc, val, offs);
2243         pmc_clk_fence_udelay(offs);
2244 }
2245
2246 static int pmc_clk_enable(struct clk_hw *hw)
2247 {
2248         struct pmc_clk *clk = to_pmc_clk(hw);
2249
2250         pmc_clk_set_state(clk->offs, clk->force_en_shift, 1);
2251
2252         return 0;
2253 }
2254
2255 static void pmc_clk_disable(struct clk_hw *hw)
2256 {
2257         struct pmc_clk *clk = to_pmc_clk(hw);
2258
2259         pmc_clk_set_state(clk->offs, clk->force_en_shift, 0);
2260 }
2261
2262 static const struct clk_ops pmc_clk_ops = {
2263         .get_parent = pmc_clk_mux_get_parent,
2264         .set_parent = pmc_clk_mux_set_parent,
2265         .determine_rate = __clk_mux_determine_rate,
2266         .is_enabled = pmc_clk_is_enabled,
2267         .enable = pmc_clk_enable,
2268         .disable = pmc_clk_disable,
2269 };
2270
2271 static struct clk *
2272 tegra_pmc_clk_out_register(struct tegra_pmc *pmc,
2273                            const struct pmc_clk_init_data *data,
2274                            unsigned long offset)
2275 {
2276         struct clk_init_data init;
2277         struct pmc_clk *pmc_clk;
2278
2279         pmc_clk = devm_kzalloc(pmc->dev, sizeof(*pmc_clk), GFP_KERNEL);
2280         if (!pmc_clk)
2281                 return ERR_PTR(-ENOMEM);
2282
2283         init.name = data->name;
2284         init.ops = &pmc_clk_ops;
2285         init.parent_names = data->parents;
2286         init.num_parents = data->num_parents;
2287         init.flags = CLK_SET_RATE_NO_REPARENT | CLK_SET_RATE_PARENT |
2288                      CLK_SET_PARENT_GATE;
2289
2290         pmc_clk->hw.init = &init;
2291         pmc_clk->offs = offset;
2292         pmc_clk->mux_shift = data->mux_shift;
2293         pmc_clk->force_en_shift = data->force_en_shift;
2294
2295         return clk_register(NULL, &pmc_clk->hw);
2296 }
2297
2298 static int pmc_clk_gate_is_enabled(struct clk_hw *hw)
2299 {
2300         struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2301
2302         return tegra_pmc_readl(pmc, gate->offs) & BIT(gate->shift) ? 1 : 0;
2303 }
2304
2305 static int pmc_clk_gate_enable(struct clk_hw *hw)
2306 {
2307         struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2308
2309         pmc_clk_set_state(gate->offs, gate->shift, 1);
2310
2311         return 0;
2312 }
2313
2314 static void pmc_clk_gate_disable(struct clk_hw *hw)
2315 {
2316         struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2317
2318         pmc_clk_set_state(gate->offs, gate->shift, 0);
2319 }
2320
2321 static const struct clk_ops pmc_clk_gate_ops = {
2322         .is_enabled = pmc_clk_gate_is_enabled,
2323         .enable = pmc_clk_gate_enable,
2324         .disable = pmc_clk_gate_disable,
2325 };
2326
2327 static struct clk *
2328 tegra_pmc_clk_gate_register(struct tegra_pmc *pmc, const char *name,
2329                             const char *parent_name, unsigned long offset,
2330                             u32 shift)
2331 {
2332         struct clk_init_data init;
2333         struct pmc_clk_gate *gate;
2334
2335         gate = devm_kzalloc(pmc->dev, sizeof(*gate), GFP_KERNEL);
2336         if (!gate)
2337                 return ERR_PTR(-ENOMEM);
2338
2339         init.name = name;
2340         init.ops = &pmc_clk_gate_ops;
2341         init.parent_names = &parent_name;
2342         init.num_parents = 1;
2343         init.flags = 0;
2344
2345         gate->hw.init = &init;
2346         gate->offs = offset;
2347         gate->shift = shift;
2348
2349         return clk_register(NULL, &gate->hw);
2350 }
2351
2352 static void tegra_pmc_clock_register(struct tegra_pmc *pmc,
2353                                      struct device_node *np)
2354 {
2355         struct clk *clk;
2356         struct clk_onecell_data *clk_data;
2357         unsigned int num_clks;
2358         int i, err;
2359
2360         num_clks = pmc->soc->num_pmc_clks;
2361         if (pmc->soc->has_blink_output)
2362                 num_clks += 1;
2363
2364         if (!num_clks)
2365                 return;
2366
2367         clk_data = devm_kmalloc(pmc->dev, sizeof(*clk_data), GFP_KERNEL);
2368         if (!clk_data)
2369                 return;
2370
2371         clk_data->clks = devm_kcalloc(pmc->dev, TEGRA_PMC_CLK_MAX,
2372                                       sizeof(*clk_data->clks), GFP_KERNEL);
2373         if (!clk_data->clks)
2374                 return;
2375
2376         clk_data->clk_num = TEGRA_PMC_CLK_MAX;
2377
2378         for (i = 0; i < TEGRA_PMC_CLK_MAX; i++)
2379                 clk_data->clks[i] = ERR_PTR(-ENOENT);
2380
2381         for (i = 0; i < pmc->soc->num_pmc_clks; i++) {
2382                 const struct pmc_clk_init_data *data;
2383
2384                 data = pmc->soc->pmc_clks_data + i;
2385
2386                 clk = tegra_pmc_clk_out_register(pmc, data, PMC_CLK_OUT_CNTRL);
2387                 if (IS_ERR(clk)) {
2388                         dev_warn(pmc->dev, "unable to register clock %s: %d\n",
2389                                  data->name, PTR_ERR_OR_ZERO(clk));
2390                         return;
2391                 }
2392
2393                 err = clk_register_clkdev(clk, data->name, NULL);
2394                 if (err) {
2395                         dev_warn(pmc->dev,
2396                                  "unable to register %s clock lookup: %d\n",
2397                                  data->name, err);
2398                         return;
2399                 }
2400
2401                 clk_data->clks[data->clk_id] = clk;
2402         }
2403
2404         if (pmc->soc->has_blink_output) {
2405                 tegra_pmc_writel(pmc, 0x0, PMC_BLINK_TIMER);
2406                 clk = tegra_pmc_clk_gate_register(pmc,
2407                                                   "pmc_blink_override",
2408                                                   "clk_32k",
2409                                                   PMC_DPD_PADS_ORIDE,
2410                                                   PMC_DPD_PADS_ORIDE_BLINK);
2411                 if (IS_ERR(clk)) {
2412                         dev_warn(pmc->dev,
2413                                  "unable to register pmc_blink_override: %d\n",
2414                                  PTR_ERR_OR_ZERO(clk));
2415                         return;
2416                 }
2417
2418                 clk = tegra_pmc_clk_gate_register(pmc, "pmc_blink",
2419                                                   "pmc_blink_override",
2420                                                   PMC_CNTRL,
2421                                                   PMC_CNTRL_BLINK_EN);
2422                 if (IS_ERR(clk)) {
2423                         dev_warn(pmc->dev,
2424                                  "unable to register pmc_blink: %d\n",
2425                                  PTR_ERR_OR_ZERO(clk));
2426                         return;
2427                 }
2428
2429                 err = clk_register_clkdev(clk, "pmc_blink", NULL);
2430                 if (err) {
2431                         dev_warn(pmc->dev,
2432                                  "unable to register pmc_blink lookup: %d\n",
2433                                  err);
2434                         return;
2435                 }
2436
2437                 clk_data->clks[TEGRA_PMC_CLK_BLINK] = clk;
2438         }
2439
2440         err = of_clk_add_provider(np, of_clk_src_onecell_get, clk_data);
2441         if (err)
2442                 dev_warn(pmc->dev, "failed to add pmc clock provider: %d\n",
2443                          err);
2444 }
2445
2446 static int tegra_pmc_probe(struct platform_device *pdev)
2447 {
2448         void __iomem *base;
2449         struct resource *res;
2450         int err;
2451
2452         /*
2453          * Early initialisation should have configured an initial
2454          * register mapping and setup the soc data pointer. If these
2455          * are not valid then something went badly wrong!
2456          */
2457         if (WARN_ON(!pmc->base || !pmc->soc))
2458                 return -ENODEV;
2459
2460         err = tegra_pmc_parse_dt(pmc, pdev->dev.of_node);
2461         if (err < 0)
2462                 return err;
2463
2464         /* take over the memory region from the early initialization */
2465         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2466         base = devm_ioremap_resource(&pdev->dev, res);
2467         if (IS_ERR(base))
2468                 return PTR_ERR(base);
2469
2470         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "wake");
2471         if (res) {
2472                 pmc->wake = devm_ioremap_resource(&pdev->dev, res);
2473                 if (IS_ERR(pmc->wake))
2474                         return PTR_ERR(pmc->wake);
2475         } else {
2476                 pmc->wake = base;
2477         }
2478
2479         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "aotag");
2480         if (res) {
2481                 pmc->aotag = devm_ioremap_resource(&pdev->dev, res);
2482                 if (IS_ERR(pmc->aotag))
2483                         return PTR_ERR(pmc->aotag);
2484         } else {
2485                 pmc->aotag = base;
2486         }
2487
2488         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "scratch");
2489         if (res) {
2490                 pmc->scratch = devm_ioremap_resource(&pdev->dev, res);
2491                 if (IS_ERR(pmc->scratch))
2492                         return PTR_ERR(pmc->scratch);
2493         } else {
2494                 pmc->scratch = base;
2495         }
2496
2497         pmc->clk = devm_clk_get(&pdev->dev, "pclk");
2498         if (IS_ERR(pmc->clk)) {
2499                 err = PTR_ERR(pmc->clk);
2500
2501                 if (err != -ENOENT) {
2502                         dev_err(&pdev->dev, "failed to get pclk: %d\n", err);
2503                         return err;
2504                 }
2505
2506                 pmc->clk = NULL;
2507         }
2508
2509         /*
2510          * PCLK clock rate can't be retrieved using CLK API because it
2511          * causes lockup if CPU enters LP2 idle state from some other
2512          * CLK notifier, hence we're caching the rate's value locally.
2513          */
2514         if (pmc->clk) {
2515                 pmc->clk_nb.notifier_call = tegra_pmc_clk_notify_cb;
2516                 err = clk_notifier_register(pmc->clk, &pmc->clk_nb);
2517                 if (err) {
2518                         dev_err(&pdev->dev,
2519                                 "failed to register clk notifier\n");
2520                         return err;
2521                 }
2522
2523                 pmc->rate = clk_get_rate(pmc->clk);
2524         }
2525
2526         pmc->dev = &pdev->dev;
2527
2528         tegra_pmc_init(pmc);
2529
2530         tegra_pmc_init_tsense_reset(pmc);
2531
2532         tegra_pmc_reset_sysfs_init(pmc);
2533
2534         if (IS_ENABLED(CONFIG_DEBUG_FS)) {
2535                 err = tegra_powergate_debugfs_init();
2536                 if (err < 0)
2537                         goto cleanup_sysfs;
2538         }
2539
2540         err = register_restart_handler(&tegra_pmc_restart_handler);
2541         if (err) {
2542                 dev_err(&pdev->dev, "unable to register restart handler, %d\n",
2543                         err);
2544                 goto cleanup_debugfs;
2545         }
2546
2547         err = tegra_pmc_pinctrl_init(pmc);
2548         if (err)
2549                 goto cleanup_restart_handler;
2550
2551         err = tegra_powergate_init(pmc, pdev->dev.of_node);
2552         if (err < 0)
2553                 goto cleanup_powergates;
2554
2555         err = tegra_pmc_irq_init(pmc);
2556         if (err < 0)
2557                 goto cleanup_powergates;
2558
2559         mutex_lock(&pmc->powergates_lock);
2560         iounmap(pmc->base);
2561         pmc->base = base;
2562         mutex_unlock(&pmc->powergates_lock);
2563
2564         tegra_pmc_clock_register(pmc, pdev->dev.of_node);
2565         platform_set_drvdata(pdev, pmc);
2566
2567         return 0;
2568
2569 cleanup_powergates:
2570         tegra_powergate_remove_all(pdev->dev.of_node);
2571 cleanup_restart_handler:
2572         unregister_restart_handler(&tegra_pmc_restart_handler);
2573 cleanup_debugfs:
2574         debugfs_remove(pmc->debugfs);
2575 cleanup_sysfs:
2576         device_remove_file(&pdev->dev, &dev_attr_reset_reason);
2577         device_remove_file(&pdev->dev, &dev_attr_reset_level);
2578         clk_notifier_unregister(pmc->clk, &pmc->clk_nb);
2579
2580         return err;
2581 }
2582
2583 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_ARM)
2584 static int tegra_pmc_suspend(struct device *dev)
2585 {
2586         struct tegra_pmc *pmc = dev_get_drvdata(dev);
2587
2588         tegra_pmc_writel(pmc, virt_to_phys(tegra_resume), PMC_SCRATCH41);
2589
2590         return 0;
2591 }
2592
2593 static int tegra_pmc_resume(struct device *dev)
2594 {
2595         struct tegra_pmc *pmc = dev_get_drvdata(dev);
2596
2597         tegra_pmc_writel(pmc, 0x0, PMC_SCRATCH41);
2598
2599         return 0;
2600 }
2601
2602 static SIMPLE_DEV_PM_OPS(tegra_pmc_pm_ops, tegra_pmc_suspend, tegra_pmc_resume);
2603
2604 #endif
2605
2606 static const char * const tegra20_powergates[] = {
2607         [TEGRA_POWERGATE_CPU] = "cpu",
2608         [TEGRA_POWERGATE_3D] = "3d",
2609         [TEGRA_POWERGATE_VENC] = "venc",
2610         [TEGRA_POWERGATE_VDEC] = "vdec",
2611         [TEGRA_POWERGATE_PCIE] = "pcie",
2612         [TEGRA_POWERGATE_L2] = "l2",
2613         [TEGRA_POWERGATE_MPE] = "mpe",
2614 };
2615
2616 static const struct tegra_pmc_regs tegra20_pmc_regs = {
2617         .scratch0 = 0x50,
2618         .dpd_req = 0x1b8,
2619         .dpd_status = 0x1bc,
2620         .dpd2_req = 0x1c0,
2621         .dpd2_status = 0x1c4,
2622         .rst_status = 0x1b4,
2623         .rst_source_shift = 0x0,
2624         .rst_source_mask = 0x7,
2625         .rst_level_shift = 0x0,
2626         .rst_level_mask = 0x0,
2627 };
2628
2629 static void tegra20_pmc_init(struct tegra_pmc *pmc)
2630 {
2631         u32 value, osc, pmu, off;
2632
2633         /* Always enable CPU power request */
2634         value = tegra_pmc_readl(pmc, PMC_CNTRL);
2635         value |= PMC_CNTRL_CPU_PWRREQ_OE;
2636         tegra_pmc_writel(pmc, value, PMC_CNTRL);
2637
2638         value = tegra_pmc_readl(pmc, PMC_CNTRL);
2639
2640         if (pmc->sysclkreq_high)
2641                 value &= ~PMC_CNTRL_SYSCLK_POLARITY;
2642         else
2643                 value |= PMC_CNTRL_SYSCLK_POLARITY;
2644
2645         if (pmc->corereq_high)
2646                 value &= ~PMC_CNTRL_PWRREQ_POLARITY;
2647         else
2648                 value |= PMC_CNTRL_PWRREQ_POLARITY;
2649
2650         /* configure the output polarity while the request is tristated */
2651         tegra_pmc_writel(pmc, value, PMC_CNTRL);
2652
2653         /* now enable the request */
2654         value = tegra_pmc_readl(pmc, PMC_CNTRL);
2655         value |= PMC_CNTRL_SYSCLK_OE;
2656         tegra_pmc_writel(pmc, value, PMC_CNTRL);
2657
2658         /* program core timings which are applicable only for suspend state */
2659         if (pmc->suspend_mode != TEGRA_SUSPEND_NONE) {
2660                 osc = DIV_ROUND_UP(pmc->core_osc_time * 8192, 1000000);
2661                 pmu = DIV_ROUND_UP(pmc->core_pmu_time * 32768, 1000000);
2662                 off = DIV_ROUND_UP(pmc->core_off_time * 32768, 1000000);
2663                 tegra_pmc_writel(pmc, ((osc << 8) & 0xff00) | (pmu & 0xff),
2664                                  PMC_COREPWRGOOD_TIMER);
2665                 tegra_pmc_writel(pmc, off, PMC_COREPWROFF_TIMER);
2666         }
2667 }
2668
2669 static void tegra20_pmc_setup_irq_polarity(struct tegra_pmc *pmc,
2670                                            struct device_node *np,
2671                                            bool invert)
2672 {
2673         u32 value;
2674
2675         value = tegra_pmc_readl(pmc, PMC_CNTRL);
2676
2677         if (invert)
2678                 value |= PMC_CNTRL_INTR_POLARITY;
2679         else
2680                 value &= ~PMC_CNTRL_INTR_POLARITY;
2681
2682         tegra_pmc_writel(pmc, value, PMC_CNTRL);
2683 }
2684
2685 static const struct tegra_pmc_soc tegra20_pmc_soc = {
2686         .num_powergates = ARRAY_SIZE(tegra20_powergates),
2687         .powergates = tegra20_powergates,
2688         .num_cpu_powergates = 0,
2689         .cpu_powergates = NULL,
2690         .has_tsense_reset = false,
2691         .has_gpu_clamps = false,
2692         .needs_mbist_war = false,
2693         .has_impl_33v_pwr = false,
2694         .maybe_tz_only = false,
2695         .num_io_pads = 0,
2696         .io_pads = NULL,
2697         .num_pin_descs = 0,
2698         .pin_descs = NULL,
2699         .regs = &tegra20_pmc_regs,
2700         .init = tegra20_pmc_init,
2701         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
2702         .reset_sources = NULL,
2703         .num_reset_sources = 0,
2704         .reset_levels = NULL,
2705         .num_reset_levels = 0,
2706         .pmc_clks_data = NULL,
2707         .num_pmc_clks = 0,
2708         .has_blink_output = true,
2709 };
2710
2711 static const char * const tegra30_powergates[] = {
2712         [TEGRA_POWERGATE_CPU] = "cpu0",
2713         [TEGRA_POWERGATE_3D] = "3d0",
2714         [TEGRA_POWERGATE_VENC] = "venc",
2715         [TEGRA_POWERGATE_VDEC] = "vdec",
2716         [TEGRA_POWERGATE_PCIE] = "pcie",
2717         [TEGRA_POWERGATE_L2] = "l2",
2718         [TEGRA_POWERGATE_MPE] = "mpe",
2719         [TEGRA_POWERGATE_HEG] = "heg",
2720         [TEGRA_POWERGATE_SATA] = "sata",
2721         [TEGRA_POWERGATE_CPU1] = "cpu1",
2722         [TEGRA_POWERGATE_CPU2] = "cpu2",
2723         [TEGRA_POWERGATE_CPU3] = "cpu3",
2724         [TEGRA_POWERGATE_CELP] = "celp",
2725         [TEGRA_POWERGATE_3D1] = "3d1",
2726 };
2727
2728 static const u8 tegra30_cpu_powergates[] = {
2729         TEGRA_POWERGATE_CPU,
2730         TEGRA_POWERGATE_CPU1,
2731         TEGRA_POWERGATE_CPU2,
2732         TEGRA_POWERGATE_CPU3,
2733 };
2734
2735 static const char * const tegra30_reset_sources[] = {
2736         "POWER_ON_RESET",
2737         "WATCHDOG",
2738         "SENSOR",
2739         "SW_MAIN",
2740         "LP0"
2741 };
2742
2743 static const struct tegra_pmc_soc tegra30_pmc_soc = {
2744         .num_powergates = ARRAY_SIZE(tegra30_powergates),
2745         .powergates = tegra30_powergates,
2746         .num_cpu_powergates = ARRAY_SIZE(tegra30_cpu_powergates),
2747         .cpu_powergates = tegra30_cpu_powergates,
2748         .has_tsense_reset = true,
2749         .has_gpu_clamps = false,
2750         .needs_mbist_war = false,
2751         .has_impl_33v_pwr = false,
2752         .maybe_tz_only = false,
2753         .num_io_pads = 0,
2754         .io_pads = NULL,
2755         .num_pin_descs = 0,
2756         .pin_descs = NULL,
2757         .regs = &tegra20_pmc_regs,
2758         .init = tegra20_pmc_init,
2759         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
2760         .reset_sources = tegra30_reset_sources,
2761         .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
2762         .reset_levels = NULL,
2763         .num_reset_levels = 0,
2764         .pmc_clks_data = tegra_pmc_clks_data,
2765         .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
2766         .has_blink_output = true,
2767 };
2768
2769 static const char * const tegra114_powergates[] = {
2770         [TEGRA_POWERGATE_CPU] = "crail",
2771         [TEGRA_POWERGATE_3D] = "3d",
2772         [TEGRA_POWERGATE_VENC] = "venc",
2773         [TEGRA_POWERGATE_VDEC] = "vdec",
2774         [TEGRA_POWERGATE_MPE] = "mpe",
2775         [TEGRA_POWERGATE_HEG] = "heg",
2776         [TEGRA_POWERGATE_CPU1] = "cpu1",
2777         [TEGRA_POWERGATE_CPU2] = "cpu2",
2778         [TEGRA_POWERGATE_CPU3] = "cpu3",
2779         [TEGRA_POWERGATE_CELP] = "celp",
2780         [TEGRA_POWERGATE_CPU0] = "cpu0",
2781         [TEGRA_POWERGATE_C0NC] = "c0nc",
2782         [TEGRA_POWERGATE_C1NC] = "c1nc",
2783         [TEGRA_POWERGATE_DIS] = "dis",
2784         [TEGRA_POWERGATE_DISB] = "disb",
2785         [TEGRA_POWERGATE_XUSBA] = "xusba",
2786         [TEGRA_POWERGATE_XUSBB] = "xusbb",
2787         [TEGRA_POWERGATE_XUSBC] = "xusbc",
2788 };
2789
2790 static const u8 tegra114_cpu_powergates[] = {
2791         TEGRA_POWERGATE_CPU0,
2792         TEGRA_POWERGATE_CPU1,
2793         TEGRA_POWERGATE_CPU2,
2794         TEGRA_POWERGATE_CPU3,
2795 };
2796
2797 static const struct tegra_pmc_soc tegra114_pmc_soc = {
2798         .num_powergates = ARRAY_SIZE(tegra114_powergates),
2799         .powergates = tegra114_powergates,
2800         .num_cpu_powergates = ARRAY_SIZE(tegra114_cpu_powergates),
2801         .cpu_powergates = tegra114_cpu_powergates,
2802         .has_tsense_reset = true,
2803         .has_gpu_clamps = false,
2804         .needs_mbist_war = false,
2805         .has_impl_33v_pwr = false,
2806         .maybe_tz_only = false,
2807         .num_io_pads = 0,
2808         .io_pads = NULL,
2809         .num_pin_descs = 0,
2810         .pin_descs = NULL,
2811         .regs = &tegra20_pmc_regs,
2812         .init = tegra20_pmc_init,
2813         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
2814         .reset_sources = tegra30_reset_sources,
2815         .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
2816         .reset_levels = NULL,
2817         .num_reset_levels = 0,
2818         .pmc_clks_data = tegra_pmc_clks_data,
2819         .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
2820         .has_blink_output = true,
2821 };
2822
2823 static const char * const tegra124_powergates[] = {
2824         [TEGRA_POWERGATE_CPU] = "crail",
2825         [TEGRA_POWERGATE_3D] = "3d",
2826         [TEGRA_POWERGATE_VENC] = "venc",
2827         [TEGRA_POWERGATE_PCIE] = "pcie",
2828         [TEGRA_POWERGATE_VDEC] = "vdec",
2829         [TEGRA_POWERGATE_MPE] = "mpe",
2830         [TEGRA_POWERGATE_HEG] = "heg",
2831         [TEGRA_POWERGATE_SATA] = "sata",
2832         [TEGRA_POWERGATE_CPU1] = "cpu1",
2833         [TEGRA_POWERGATE_CPU2] = "cpu2",
2834         [TEGRA_POWERGATE_CPU3] = "cpu3",
2835         [TEGRA_POWERGATE_CELP] = "celp",
2836         [TEGRA_POWERGATE_CPU0] = "cpu0",
2837         [TEGRA_POWERGATE_C0NC] = "c0nc",
2838         [TEGRA_POWERGATE_C1NC] = "c1nc",
2839         [TEGRA_POWERGATE_SOR] = "sor",
2840         [TEGRA_POWERGATE_DIS] = "dis",
2841         [TEGRA_POWERGATE_DISB] = "disb",
2842         [TEGRA_POWERGATE_XUSBA] = "xusba",
2843         [TEGRA_POWERGATE_XUSBB] = "xusbb",
2844         [TEGRA_POWERGATE_XUSBC] = "xusbc",
2845         [TEGRA_POWERGATE_VIC] = "vic",
2846         [TEGRA_POWERGATE_IRAM] = "iram",
2847 };
2848
2849 static const u8 tegra124_cpu_powergates[] = {
2850         TEGRA_POWERGATE_CPU0,
2851         TEGRA_POWERGATE_CPU1,
2852         TEGRA_POWERGATE_CPU2,
2853         TEGRA_POWERGATE_CPU3,
2854 };
2855
2856 #define TEGRA_IO_PAD(_id, _dpd, _voltage, _name)        \
2857         ((struct tegra_io_pad_soc) {                    \
2858                 .id     = (_id),                        \
2859                 .dpd    = (_dpd),                       \
2860                 .voltage = (_voltage),                  \
2861                 .name   = (_name),                      \
2862         })
2863
2864 #define TEGRA_IO_PIN_DESC(_id, _dpd, _voltage, _name)   \
2865         ((struct pinctrl_pin_desc) {                    \
2866                 .number = (_id),                        \
2867                 .name   = (_name)                       \
2868         })
2869
2870 #define TEGRA124_IO_PAD_TABLE(_pad)                                   \
2871         /* .id                          .dpd  .voltage  .name */      \
2872         _pad(TEGRA_IO_PAD_AUDIO,        17,   UINT_MAX, "audio"),     \
2873         _pad(TEGRA_IO_PAD_BB,           15,   UINT_MAX, "bb"),        \
2874         _pad(TEGRA_IO_PAD_CAM,          36,   UINT_MAX, "cam"),       \
2875         _pad(TEGRA_IO_PAD_COMP,         22,   UINT_MAX, "comp"),      \
2876         _pad(TEGRA_IO_PAD_CSIA,         0,    UINT_MAX, "csia"),      \
2877         _pad(TEGRA_IO_PAD_CSIB,         1,    UINT_MAX, "csb"),       \
2878         _pad(TEGRA_IO_PAD_CSIE,         44,   UINT_MAX, "cse"),       \
2879         _pad(TEGRA_IO_PAD_DSI,          2,    UINT_MAX, "dsi"),       \
2880         _pad(TEGRA_IO_PAD_DSIB,         39,   UINT_MAX, "dsib"),      \
2881         _pad(TEGRA_IO_PAD_DSIC,         40,   UINT_MAX, "dsic"),      \
2882         _pad(TEGRA_IO_PAD_DSID,         41,   UINT_MAX, "dsid"),      \
2883         _pad(TEGRA_IO_PAD_HDMI,         28,   UINT_MAX, "hdmi"),      \
2884         _pad(TEGRA_IO_PAD_HSIC,         19,   UINT_MAX, "hsic"),      \
2885         _pad(TEGRA_IO_PAD_HV,           38,   UINT_MAX, "hv"),        \
2886         _pad(TEGRA_IO_PAD_LVDS,         57,   UINT_MAX, "lvds"),      \
2887         _pad(TEGRA_IO_PAD_MIPI_BIAS,    3,    UINT_MAX, "mipi-bias"), \
2888         _pad(TEGRA_IO_PAD_NAND,         13,   UINT_MAX, "nand"),      \
2889         _pad(TEGRA_IO_PAD_PEX_BIAS,     4,    UINT_MAX, "pex-bias"),  \
2890         _pad(TEGRA_IO_PAD_PEX_CLK1,     5,    UINT_MAX, "pex-clk1"),  \
2891         _pad(TEGRA_IO_PAD_PEX_CLK2,     6,    UINT_MAX, "pex-clk2"),  \
2892         _pad(TEGRA_IO_PAD_PEX_CNTRL,    32,   UINT_MAX, "pex-cntrl"), \
2893         _pad(TEGRA_IO_PAD_SDMMC1,       33,   UINT_MAX, "sdmmc1"),    \
2894         _pad(TEGRA_IO_PAD_SDMMC3,       34,   UINT_MAX, "sdmmc3"),    \
2895         _pad(TEGRA_IO_PAD_SDMMC4,       35,   UINT_MAX, "sdmmc4"),    \
2896         _pad(TEGRA_IO_PAD_SYS_DDC,      58,   UINT_MAX, "sys_ddc"),   \
2897         _pad(TEGRA_IO_PAD_UART,         14,   UINT_MAX, "uart"),      \
2898         _pad(TEGRA_IO_PAD_USB0,         9,    UINT_MAX, "usb0"),      \
2899         _pad(TEGRA_IO_PAD_USB1,         10,   UINT_MAX, "usb1"),      \
2900         _pad(TEGRA_IO_PAD_USB2,         11,   UINT_MAX, "usb2"),      \
2901         _pad(TEGRA_IO_PAD_USB_BIAS,     12,   UINT_MAX, "usb_bias")
2902
2903 static const struct tegra_io_pad_soc tegra124_io_pads[] = {
2904         TEGRA124_IO_PAD_TABLE(TEGRA_IO_PAD)
2905 };
2906
2907 static const struct pinctrl_pin_desc tegra124_pin_descs[] = {
2908         TEGRA124_IO_PAD_TABLE(TEGRA_IO_PIN_DESC)
2909 };
2910
2911 static const struct tegra_pmc_soc tegra124_pmc_soc = {
2912         .num_powergates = ARRAY_SIZE(tegra124_powergates),
2913         .powergates = tegra124_powergates,
2914         .num_cpu_powergates = ARRAY_SIZE(tegra124_cpu_powergates),
2915         .cpu_powergates = tegra124_cpu_powergates,
2916         .has_tsense_reset = true,
2917         .has_gpu_clamps = true,
2918         .needs_mbist_war = false,
2919         .has_impl_33v_pwr = false,
2920         .maybe_tz_only = false,
2921         .num_io_pads = ARRAY_SIZE(tegra124_io_pads),
2922         .io_pads = tegra124_io_pads,
2923         .num_pin_descs = ARRAY_SIZE(tegra124_pin_descs),
2924         .pin_descs = tegra124_pin_descs,
2925         .regs = &tegra20_pmc_regs,
2926         .init = tegra20_pmc_init,
2927         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
2928         .reset_sources = tegra30_reset_sources,
2929         .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
2930         .reset_levels = NULL,
2931         .num_reset_levels = 0,
2932         .pmc_clks_data = tegra_pmc_clks_data,
2933         .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
2934         .has_blink_output = true,
2935 };
2936
2937 static const char * const tegra210_powergates[] = {
2938         [TEGRA_POWERGATE_CPU] = "crail",
2939         [TEGRA_POWERGATE_3D] = "3d",
2940         [TEGRA_POWERGATE_VENC] = "venc",
2941         [TEGRA_POWERGATE_PCIE] = "pcie",
2942         [TEGRA_POWERGATE_MPE] = "mpe",
2943         [TEGRA_POWERGATE_SATA] = "sata",
2944         [TEGRA_POWERGATE_CPU1] = "cpu1",
2945         [TEGRA_POWERGATE_CPU2] = "cpu2",
2946         [TEGRA_POWERGATE_CPU3] = "cpu3",
2947         [TEGRA_POWERGATE_CPU0] = "cpu0",
2948         [TEGRA_POWERGATE_C0NC] = "c0nc",
2949         [TEGRA_POWERGATE_SOR] = "sor",
2950         [TEGRA_POWERGATE_DIS] = "dis",
2951         [TEGRA_POWERGATE_DISB] = "disb",
2952         [TEGRA_POWERGATE_XUSBA] = "xusba",
2953         [TEGRA_POWERGATE_XUSBB] = "xusbb",
2954         [TEGRA_POWERGATE_XUSBC] = "xusbc",
2955         [TEGRA_POWERGATE_VIC] = "vic",
2956         [TEGRA_POWERGATE_IRAM] = "iram",
2957         [TEGRA_POWERGATE_NVDEC] = "nvdec",
2958         [TEGRA_POWERGATE_NVJPG] = "nvjpg",
2959         [TEGRA_POWERGATE_AUD] = "aud",
2960         [TEGRA_POWERGATE_DFD] = "dfd",
2961         [TEGRA_POWERGATE_VE2] = "ve2",
2962 };
2963
2964 static const u8 tegra210_cpu_powergates[] = {
2965         TEGRA_POWERGATE_CPU0,
2966         TEGRA_POWERGATE_CPU1,
2967         TEGRA_POWERGATE_CPU2,
2968         TEGRA_POWERGATE_CPU3,
2969 };
2970
2971 #define TEGRA210_IO_PAD_TABLE(_pad)                                        \
2972         /*   .id                        .dpd     .voltage  .name */        \
2973         _pad(TEGRA_IO_PAD_AUDIO,       17,       5,        "audio"),       \
2974         _pad(TEGRA_IO_PAD_AUDIO_HV,    61,       18,       "audio-hv"),    \
2975         _pad(TEGRA_IO_PAD_CAM,         36,       10,       "cam"),         \
2976         _pad(TEGRA_IO_PAD_CSIA,        0,        UINT_MAX, "csia"),        \
2977         _pad(TEGRA_IO_PAD_CSIB,        1,        UINT_MAX, "csib"),        \
2978         _pad(TEGRA_IO_PAD_CSIC,        42,       UINT_MAX, "csic"),        \
2979         _pad(TEGRA_IO_PAD_CSID,        43,       UINT_MAX, "csid"),        \
2980         _pad(TEGRA_IO_PAD_CSIE,        44,       UINT_MAX, "csie"),        \
2981         _pad(TEGRA_IO_PAD_CSIF,        45,       UINT_MAX, "csif"),        \
2982         _pad(TEGRA_IO_PAD_DBG,         25,       19,       "dbg"),         \
2983         _pad(TEGRA_IO_PAD_DEBUG_NONAO, 26,       UINT_MAX, "debug-nonao"), \
2984         _pad(TEGRA_IO_PAD_DMIC,        50,       20,       "dmic"),        \
2985         _pad(TEGRA_IO_PAD_DP,          51,       UINT_MAX, "dp"),          \
2986         _pad(TEGRA_IO_PAD_DSI,         2,        UINT_MAX, "dsi"),         \
2987         _pad(TEGRA_IO_PAD_DSIB,        39,       UINT_MAX, "dsib"),        \
2988         _pad(TEGRA_IO_PAD_DSIC,        40,       UINT_MAX, "dsic"),        \
2989         _pad(TEGRA_IO_PAD_DSID,        41,       UINT_MAX, "dsid"),        \
2990         _pad(TEGRA_IO_PAD_EMMC,        35,       UINT_MAX, "emmc"),        \
2991         _pad(TEGRA_IO_PAD_EMMC2,       37,       UINT_MAX, "emmc2"),       \
2992         _pad(TEGRA_IO_PAD_GPIO,        27,       21,       "gpio"),        \
2993         _pad(TEGRA_IO_PAD_HDMI,        28,       UINT_MAX, "hdmi"),        \
2994         _pad(TEGRA_IO_PAD_HSIC,        19,       UINT_MAX, "hsic"),        \
2995         _pad(TEGRA_IO_PAD_LVDS,        57,       UINT_MAX, "lvds"),        \
2996         _pad(TEGRA_IO_PAD_MIPI_BIAS,   3,        UINT_MAX, "mipi-bias"),   \
2997         _pad(TEGRA_IO_PAD_PEX_BIAS,    4,        UINT_MAX, "pex-bias"),    \
2998         _pad(TEGRA_IO_PAD_PEX_CLK1,    5,        UINT_MAX, "pex-clk1"),    \
2999         _pad(TEGRA_IO_PAD_PEX_CLK2,    6,        UINT_MAX, "pex-clk2"),    \
3000         _pad(TEGRA_IO_PAD_PEX_CNTRL,   UINT_MAX, 11,       "pex-cntrl"),   \
3001         _pad(TEGRA_IO_PAD_SDMMC1,      33,       12,       "sdmmc1"),      \
3002         _pad(TEGRA_IO_PAD_SDMMC3,      34,       13,       "sdmmc3"),      \
3003         _pad(TEGRA_IO_PAD_SPI,         46,       22,       "spi"),         \
3004         _pad(TEGRA_IO_PAD_SPI_HV,      47,       23,       "spi-hv"),      \
3005         _pad(TEGRA_IO_PAD_UART,        14,       2,        "uart"),        \
3006         _pad(TEGRA_IO_PAD_USB0,        9,        UINT_MAX, "usb0"),        \
3007         _pad(TEGRA_IO_PAD_USB1,        10,       UINT_MAX, "usb1"),        \
3008         _pad(TEGRA_IO_PAD_USB2,        11,       UINT_MAX, "usb2"),        \
3009         _pad(TEGRA_IO_PAD_USB3,        18,       UINT_MAX, "usb3"),        \
3010         _pad(TEGRA_IO_PAD_USB_BIAS,    12,       UINT_MAX, "usb-bias")
3011
3012 static const struct tegra_io_pad_soc tegra210_io_pads[] = {
3013         TEGRA210_IO_PAD_TABLE(TEGRA_IO_PAD)
3014 };
3015
3016 static const struct pinctrl_pin_desc tegra210_pin_descs[] = {
3017         TEGRA210_IO_PAD_TABLE(TEGRA_IO_PIN_DESC)
3018 };
3019
3020 static const char * const tegra210_reset_sources[] = {
3021         "POWER_ON_RESET",
3022         "WATCHDOG",
3023         "SENSOR",
3024         "SW_MAIN",
3025         "LP0",
3026         "AOTAG"
3027 };
3028
3029 static const struct tegra_wake_event tegra210_wake_events[] = {
3030         TEGRA_WAKE_IRQ("rtc", 16, 2),
3031         TEGRA_WAKE_IRQ("pmu", 51, 86),
3032 };
3033
3034 static const struct tegra_pmc_soc tegra210_pmc_soc = {
3035         .num_powergates = ARRAY_SIZE(tegra210_powergates),
3036         .powergates = tegra210_powergates,
3037         .num_cpu_powergates = ARRAY_SIZE(tegra210_cpu_powergates),
3038         .cpu_powergates = tegra210_cpu_powergates,
3039         .has_tsense_reset = true,
3040         .has_gpu_clamps = true,
3041         .needs_mbist_war = true,
3042         .has_impl_33v_pwr = false,
3043         .maybe_tz_only = true,
3044         .num_io_pads = ARRAY_SIZE(tegra210_io_pads),
3045         .io_pads = tegra210_io_pads,
3046         .num_pin_descs = ARRAY_SIZE(tegra210_pin_descs),
3047         .pin_descs = tegra210_pin_descs,
3048         .regs = &tegra20_pmc_regs,
3049         .init = tegra20_pmc_init,
3050         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3051         .irq_set_wake = tegra210_pmc_irq_set_wake,
3052         .irq_set_type = tegra210_pmc_irq_set_type,
3053         .reset_sources = tegra210_reset_sources,
3054         .num_reset_sources = ARRAY_SIZE(tegra210_reset_sources),
3055         .reset_levels = NULL,
3056         .num_reset_levels = 0,
3057         .num_wake_events = ARRAY_SIZE(tegra210_wake_events),
3058         .wake_events = tegra210_wake_events,
3059         .pmc_clks_data = tegra_pmc_clks_data,
3060         .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3061         .has_blink_output = true,
3062 };
3063
3064 #define TEGRA186_IO_PAD_TABLE(_pad)                                          \
3065         /*   .id                        .dpd      .voltage  .name */         \
3066         _pad(TEGRA_IO_PAD_CSIA,         0,        UINT_MAX, "csia"),         \
3067         _pad(TEGRA_IO_PAD_CSIB,         1,        UINT_MAX, "csib"),         \
3068         _pad(TEGRA_IO_PAD_DSI,          2,        UINT_MAX, "dsi"),          \
3069         _pad(TEGRA_IO_PAD_MIPI_BIAS,    3,        UINT_MAX, "mipi-bias"),    \
3070         _pad(TEGRA_IO_PAD_PEX_CLK_BIAS, 4,        UINT_MAX, "pex-clk-bias"), \
3071         _pad(TEGRA_IO_PAD_PEX_CLK3,     5,        UINT_MAX, "pex-clk3"),     \
3072         _pad(TEGRA_IO_PAD_PEX_CLK2,     6,        UINT_MAX, "pex-clk2"),     \
3073         _pad(TEGRA_IO_PAD_PEX_CLK1,     7,        UINT_MAX, "pex-clk1"),     \
3074         _pad(TEGRA_IO_PAD_USB0,         9,        UINT_MAX, "usb0"),         \
3075         _pad(TEGRA_IO_PAD_USB1,         10,       UINT_MAX, "usb1"),         \
3076         _pad(TEGRA_IO_PAD_USB2,         11,       UINT_MAX, "usb2"),         \
3077         _pad(TEGRA_IO_PAD_USB_BIAS,     12,       UINT_MAX, "usb-bias"),     \
3078         _pad(TEGRA_IO_PAD_UART,         14,       UINT_MAX, "uart"),         \
3079         _pad(TEGRA_IO_PAD_AUDIO,        17,       UINT_MAX, "audio"),        \
3080         _pad(TEGRA_IO_PAD_HSIC,         19,       UINT_MAX, "hsic"),         \
3081         _pad(TEGRA_IO_PAD_DBG,          25,       UINT_MAX, "dbg"),          \
3082         _pad(TEGRA_IO_PAD_HDMI_DP0,     28,       UINT_MAX, "hdmi-dp0"),     \
3083         _pad(TEGRA_IO_PAD_HDMI_DP1,     29,       UINT_MAX, "hdmi-dp1"),     \
3084         _pad(TEGRA_IO_PAD_PEX_CNTRL,    32,       UINT_MAX, "pex-cntrl"),    \
3085         _pad(TEGRA_IO_PAD_SDMMC2_HV,    34,       5,        "sdmmc2-hv"),    \
3086         _pad(TEGRA_IO_PAD_SDMMC4,       36,       UINT_MAX, "sdmmc4"),       \
3087         _pad(TEGRA_IO_PAD_CAM,          38,       UINT_MAX, "cam"),          \
3088         _pad(TEGRA_IO_PAD_DSIB,         40,       UINT_MAX, "dsib"),         \
3089         _pad(TEGRA_IO_PAD_DSIC,         41,       UINT_MAX, "dsic"),         \
3090         _pad(TEGRA_IO_PAD_DSID,         42,       UINT_MAX, "dsid"),         \
3091         _pad(TEGRA_IO_PAD_CSIC,         43,       UINT_MAX, "csic"),         \
3092         _pad(TEGRA_IO_PAD_CSID,         44,       UINT_MAX, "csid"),         \
3093         _pad(TEGRA_IO_PAD_CSIE,         45,       UINT_MAX, "csie"),         \
3094         _pad(TEGRA_IO_PAD_CSIF,         46,       UINT_MAX, "csif"),         \
3095         _pad(TEGRA_IO_PAD_SPI,          47,       UINT_MAX, "spi"),          \
3096         _pad(TEGRA_IO_PAD_UFS,          49,       UINT_MAX, "ufs"),          \
3097         _pad(TEGRA_IO_PAD_DMIC_HV,      52,       2,        "dmic-hv"),      \
3098         _pad(TEGRA_IO_PAD_EDP,          53,       UINT_MAX, "edp"),          \
3099         _pad(TEGRA_IO_PAD_SDMMC1_HV,    55,       4,        "sdmmc1-hv"),    \
3100         _pad(TEGRA_IO_PAD_SDMMC3_HV,    56,       6,        "sdmmc3-hv"),    \
3101         _pad(TEGRA_IO_PAD_CONN,         60,       UINT_MAX, "conn"),         \
3102         _pad(TEGRA_IO_PAD_AUDIO_HV,     61,       1,        "audio-hv"),     \
3103         _pad(TEGRA_IO_PAD_AO_HV,        UINT_MAX, 0,        "ao-hv")
3104
3105 static const struct tegra_io_pad_soc tegra186_io_pads[] = {
3106         TEGRA186_IO_PAD_TABLE(TEGRA_IO_PAD)
3107 };
3108
3109 static const struct pinctrl_pin_desc tegra186_pin_descs[] = {
3110         TEGRA186_IO_PAD_TABLE(TEGRA_IO_PIN_DESC)
3111 };
3112
3113 static const struct tegra_pmc_regs tegra186_pmc_regs = {
3114         .scratch0 = 0x2000,
3115         .dpd_req = 0x74,
3116         .dpd_status = 0x78,
3117         .dpd2_req = 0x7c,
3118         .dpd2_status = 0x80,
3119         .rst_status = 0x70,
3120         .rst_source_shift = 0x2,
3121         .rst_source_mask = 0x3c,
3122         .rst_level_shift = 0x0,
3123         .rst_level_mask = 0x3,
3124 };
3125
3126 static void tegra186_pmc_setup_irq_polarity(struct tegra_pmc *pmc,
3127                                             struct device_node *np,
3128                                             bool invert)
3129 {
3130         struct resource regs;
3131         void __iomem *wake;
3132         u32 value;
3133         int index;
3134
3135         index = of_property_match_string(np, "reg-names", "wake");
3136         if (index < 0) {
3137                 dev_err(pmc->dev, "failed to find PMC wake registers\n");
3138                 return;
3139         }
3140
3141         of_address_to_resource(np, index, &regs);
3142
3143         wake = ioremap(regs.start, resource_size(&regs));
3144         if (!wake) {
3145                 dev_err(pmc->dev, "failed to map PMC wake registers\n");
3146                 return;
3147         }
3148
3149         value = readl(wake + WAKE_AOWAKE_CTRL);
3150
3151         if (invert)
3152                 value |= WAKE_AOWAKE_CTRL_INTR_POLARITY;
3153         else
3154                 value &= ~WAKE_AOWAKE_CTRL_INTR_POLARITY;
3155
3156         writel(value, wake + WAKE_AOWAKE_CTRL);
3157
3158         iounmap(wake);
3159 }
3160
3161 static const char * const tegra186_reset_sources[] = {
3162         "SYS_RESET",
3163         "AOWDT",
3164         "MCCPLEXWDT",
3165         "BPMPWDT",
3166         "SCEWDT",
3167         "SPEWDT",
3168         "APEWDT",
3169         "BCCPLEXWDT",
3170         "SENSOR",
3171         "AOTAG",
3172         "VFSENSOR",
3173         "SWREST",
3174         "SC7",
3175         "HSM",
3176         "CORESIGHT"
3177 };
3178
3179 static const char * const tegra186_reset_levels[] = {
3180         "L0", "L1", "L2", "WARM"
3181 };
3182
3183 static const struct tegra_wake_event tegra186_wake_events[] = {
3184         TEGRA_WAKE_IRQ("pmu", 24, 209),
3185         TEGRA_WAKE_GPIO("power", 29, 1, TEGRA186_AON_GPIO(FF, 0)),
3186         TEGRA_WAKE_IRQ("rtc", 73, 10),
3187 };
3188
3189 static const struct tegra_pmc_soc tegra186_pmc_soc = {
3190         .num_powergates = 0,
3191         .powergates = NULL,
3192         .num_cpu_powergates = 0,
3193         .cpu_powergates = NULL,
3194         .has_tsense_reset = false,
3195         .has_gpu_clamps = false,
3196         .needs_mbist_war = false,
3197         .has_impl_33v_pwr = true,
3198         .maybe_tz_only = false,
3199         .num_io_pads = ARRAY_SIZE(tegra186_io_pads),
3200         .io_pads = tegra186_io_pads,
3201         .num_pin_descs = ARRAY_SIZE(tegra186_pin_descs),
3202         .pin_descs = tegra186_pin_descs,
3203         .regs = &tegra186_pmc_regs,
3204         .init = NULL,
3205         .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
3206         .irq_set_wake = tegra186_pmc_irq_set_wake,
3207         .irq_set_type = tegra186_pmc_irq_set_type,
3208         .reset_sources = tegra186_reset_sources,
3209         .num_reset_sources = ARRAY_SIZE(tegra186_reset_sources),
3210         .reset_levels = tegra186_reset_levels,
3211         .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
3212         .num_wake_events = ARRAY_SIZE(tegra186_wake_events),
3213         .wake_events = tegra186_wake_events,
3214         .pmc_clks_data = NULL,
3215         .num_pmc_clks = 0,
3216         .has_blink_output = false,
3217 };
3218
3219 #define TEGRA194_IO_PAD_TABLE(_pad)                                              \
3220         /*   .id                          .dpd      .voltage  .name */           \
3221         _pad(TEGRA_IO_PAD_CSIA,           0,        UINT_MAX, "csia"),           \
3222         _pad(TEGRA_IO_PAD_CSIB,           1,        UINT_MAX, "csib"),           \
3223         _pad(TEGRA_IO_PAD_MIPI_BIAS,      3,        UINT_MAX, "mipi-bias"),      \
3224         _pad(TEGRA_IO_PAD_PEX_CLK_BIAS,   4,        UINT_MAX, "pex-clk-bias"),   \
3225         _pad(TEGRA_IO_PAD_PEX_CLK3,       5,        UINT_MAX, "pex-clk3"),       \
3226         _pad(TEGRA_IO_PAD_PEX_CLK2,       6,        UINT_MAX, "pex-clk2"),       \
3227         _pad(TEGRA_IO_PAD_PEX_CLK1,       7,        UINT_MAX, "pex-clk1"),       \
3228         _pad(TEGRA_IO_PAD_EQOS,           8,        UINT_MAX, "eqos"),           \
3229         _pad(TEGRA_IO_PAD_PEX_CLK_2_BIAS, 9,        UINT_MAX, "pex-clk-2-bias"), \
3230         _pad(TEGRA_IO_PAD_PEX_CLK_2,      10,       UINT_MAX, "pex-clk-2"),      \
3231         _pad(TEGRA_IO_PAD_DAP3,           11,       UINT_MAX, "dap3"),           \
3232         _pad(TEGRA_IO_PAD_DAP5,           12,       UINT_MAX, "dap5"),           \
3233         _pad(TEGRA_IO_PAD_UART,           14,       UINT_MAX, "uart"),           \
3234         _pad(TEGRA_IO_PAD_PWR_CTL,        15,       UINT_MAX, "pwr-ctl"),        \
3235         _pad(TEGRA_IO_PAD_SOC_GPIO53,     16,       UINT_MAX, "soc-gpio53"),     \
3236         _pad(TEGRA_IO_PAD_AUDIO,          17,       UINT_MAX, "audio"),          \
3237         _pad(TEGRA_IO_PAD_GP_PWM2,        18,       UINT_MAX, "gp-pwm2"),        \
3238         _pad(TEGRA_IO_PAD_GP_PWM3,        19,       UINT_MAX, "gp-pwm3"),        \
3239         _pad(TEGRA_IO_PAD_SOC_GPIO12,     20,       UINT_MAX, "soc-gpio12"),     \
3240         _pad(TEGRA_IO_PAD_SOC_GPIO13,     21,       UINT_MAX, "soc-gpio13"),     \
3241         _pad(TEGRA_IO_PAD_SOC_GPIO10,     22,       UINT_MAX, "soc-gpio10"),     \
3242         _pad(TEGRA_IO_PAD_UART4,          23,       UINT_MAX, "uart4"),          \
3243         _pad(TEGRA_IO_PAD_UART5,          24,       UINT_MAX, "uart5"),          \
3244         _pad(TEGRA_IO_PAD_DBG,            25,       UINT_MAX, "dbg"),            \
3245         _pad(TEGRA_IO_PAD_HDMI_DP3,       26,       UINT_MAX, "hdmi-dp3"),       \
3246         _pad(TEGRA_IO_PAD_HDMI_DP2,       27,       UINT_MAX, "hdmi-dp2"),       \
3247         _pad(TEGRA_IO_PAD_HDMI_DP0,       28,       UINT_MAX, "hdmi-dp0"),       \
3248         _pad(TEGRA_IO_PAD_HDMI_DP1,       29,       UINT_MAX, "hdmi-dp1"),       \
3249         _pad(TEGRA_IO_PAD_PEX_CNTRL,      32,       UINT_MAX, "pex-cntrl"),      \
3250         _pad(TEGRA_IO_PAD_PEX_CTL2,       33,       UINT_MAX, "pex-ctl2"),       \
3251         _pad(TEGRA_IO_PAD_PEX_L0_RST_N,   34,       UINT_MAX, "pex-l0-rst"),     \
3252         _pad(TEGRA_IO_PAD_PEX_L1_RST_N,   35,       UINT_MAX, "pex-l1-rst"),     \
3253         _pad(TEGRA_IO_PAD_SDMMC4,         36,       UINT_MAX, "sdmmc4"),         \
3254         _pad(TEGRA_IO_PAD_PEX_L5_RST_N,   37,       UINT_MAX, "pex-l5-rst"),     \
3255         _pad(TEGRA_IO_PAD_CAM,            38,       UINT_MAX, "cam"),            \
3256         _pad(TEGRA_IO_PAD_CSIC,           43,       UINT_MAX, "csic"),           \
3257         _pad(TEGRA_IO_PAD_CSID,           44,       UINT_MAX, "csid"),           \
3258         _pad(TEGRA_IO_PAD_CSIE,           45,       UINT_MAX, "csie"),           \
3259         _pad(TEGRA_IO_PAD_CSIF,           46,       UINT_MAX, "csif"),           \
3260         _pad(TEGRA_IO_PAD_SPI,            47,       UINT_MAX, "spi"),            \
3261         _pad(TEGRA_IO_PAD_UFS,            49,       UINT_MAX, "ufs"),            \
3262         _pad(TEGRA_IO_PAD_CSIG,           50,       UINT_MAX, "csig"),           \
3263         _pad(TEGRA_IO_PAD_CSIH,           51,       UINT_MAX, "csih"),           \
3264         _pad(TEGRA_IO_PAD_EDP,            53,       UINT_MAX, "edp"),            \
3265         _pad(TEGRA_IO_PAD_SDMMC1_HV,      55,       4,        "sdmmc1-hv"),      \
3266         _pad(TEGRA_IO_PAD_SDMMC3_HV,      56,       6,        "sdmmc3-hv"),      \
3267         _pad(TEGRA_IO_PAD_CONN,           60,       UINT_MAX, "conn"),           \
3268         _pad(TEGRA_IO_PAD_AUDIO_HV,       61,       1,        "audio-hv"),       \
3269         _pad(TEGRA_IO_PAD_AO_HV,          UINT_MAX, 0,        "ao-hv")
3270
3271 static const struct tegra_io_pad_soc tegra194_io_pads[] = {
3272         TEGRA194_IO_PAD_TABLE(TEGRA_IO_PAD)
3273 };
3274
3275 static const struct pinctrl_pin_desc tegra194_pin_descs[] = {
3276         TEGRA194_IO_PAD_TABLE(TEGRA_IO_PIN_DESC)
3277 };
3278
3279 static const struct tegra_pmc_regs tegra194_pmc_regs = {
3280         .scratch0 = 0x2000,
3281         .dpd_req = 0x74,
3282         .dpd_status = 0x78,
3283         .dpd2_req = 0x7c,
3284         .dpd2_status = 0x80,
3285         .rst_status = 0x70,
3286         .rst_source_shift = 0x2,
3287         .rst_source_mask = 0x7c,
3288         .rst_level_shift = 0x0,
3289         .rst_level_mask = 0x3,
3290 };
3291
3292 static const char * const tegra194_reset_sources[] = {
3293         "SYS_RESET_N",
3294         "AOWDT",
3295         "BCCPLEXWDT",
3296         "BPMPWDT",
3297         "SCEWDT",
3298         "SPEWDT",
3299         "APEWDT",
3300         "LCCPLEXWDT",
3301         "SENSOR",
3302         "AOTAG",
3303         "VFSENSOR",
3304         "MAINSWRST",
3305         "SC7",
3306         "HSM",
3307         "CSITE",
3308         "RCEWDT",
3309         "PVA0WDT",
3310         "PVA1WDT",
3311         "L1A_ASYNC",
3312         "BPMPBOOT",
3313         "FUSECRC",
3314 };
3315
3316 static const struct tegra_wake_event tegra194_wake_events[] = {
3317         TEGRA_WAKE_IRQ("pmu", 24, 209),
3318         TEGRA_WAKE_GPIO("power", 29, 1, TEGRA194_AON_GPIO(EE, 4)),
3319         TEGRA_WAKE_IRQ("rtc", 73, 10),
3320 };
3321
3322 static const struct tegra_pmc_soc tegra194_pmc_soc = {
3323         .num_powergates = 0,
3324         .powergates = NULL,
3325         .num_cpu_powergates = 0,
3326         .cpu_powergates = NULL,
3327         .has_tsense_reset = false,
3328         .has_gpu_clamps = false,
3329         .needs_mbist_war = false,
3330         .has_impl_33v_pwr = true,
3331         .maybe_tz_only = false,
3332         .num_io_pads = ARRAY_SIZE(tegra194_io_pads),
3333         .io_pads = tegra194_io_pads,
3334         .num_pin_descs = ARRAY_SIZE(tegra194_pin_descs),
3335         .pin_descs = tegra194_pin_descs,
3336         .regs = &tegra194_pmc_regs,
3337         .init = NULL,
3338         .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
3339         .irq_set_wake = tegra186_pmc_irq_set_wake,
3340         .irq_set_type = tegra186_pmc_irq_set_type,
3341         .reset_sources = tegra194_reset_sources,
3342         .num_reset_sources = ARRAY_SIZE(tegra194_reset_sources),
3343         .reset_levels = tegra186_reset_levels,
3344         .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
3345         .num_wake_events = ARRAY_SIZE(tegra194_wake_events),
3346         .wake_events = tegra194_wake_events,
3347         .pmc_clks_data = NULL,
3348         .num_pmc_clks = 0,
3349         .has_blink_output = false,
3350 };
3351
3352 static const struct tegra_pmc_regs tegra234_pmc_regs = {
3353         .scratch0 = 0x2000,
3354         .dpd_req = 0,
3355         .dpd_status = 0,
3356         .dpd2_req = 0,
3357         .dpd2_status = 0,
3358         .rst_status = 0x70,
3359         .rst_source_shift = 0x2,
3360         .rst_source_mask = 0xfc,
3361         .rst_level_shift = 0x0,
3362         .rst_level_mask = 0x3,
3363 };
3364
3365 static const char * const tegra234_reset_sources[] = {
3366         "SYS_RESET_N",
3367         "AOWDT",
3368         "BCCPLEXWDT",
3369         "BPMPWDT",
3370         "SCEWDT",
3371         "SPEWDT",
3372         "APEWDT",
3373         "LCCPLEXWDT",
3374         "SENSOR",
3375         "AOTAG",
3376         "VFSENSOR",
3377         "MAINSWRST",
3378         "SC7",
3379         "HSM",
3380         "CSITE",
3381         "RCEWDT",
3382         "PVA0WDT",
3383         "PVA1WDT",
3384         "L1A_ASYNC",
3385         "BPMPBOOT",
3386         "FUSECRC",
3387 };
3388
3389 static const struct tegra_pmc_soc tegra234_pmc_soc = {
3390         .num_powergates = 0,
3391         .powergates = NULL,
3392         .num_cpu_powergates = 0,
3393         .cpu_powergates = NULL,
3394         .has_tsense_reset = false,
3395         .has_gpu_clamps = false,
3396         .needs_mbist_war = false,
3397         .has_impl_33v_pwr = true,
3398         .maybe_tz_only = false,
3399         .num_io_pads = 0,
3400         .io_pads = NULL,
3401         .num_pin_descs = 0,
3402         .pin_descs = NULL,
3403         .regs = &tegra234_pmc_regs,
3404         .init = NULL,
3405         .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
3406         .irq_set_wake = tegra186_pmc_irq_set_wake,
3407         .irq_set_type = tegra186_pmc_irq_set_type,
3408         .reset_sources = tegra234_reset_sources,
3409         .num_reset_sources = ARRAY_SIZE(tegra234_reset_sources),
3410         .reset_levels = tegra186_reset_levels,
3411         .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
3412         .num_wake_events = 0,
3413         .wake_events = NULL,
3414         .pmc_clks_data = NULL,
3415         .num_pmc_clks = 0,
3416         .has_blink_output = false,
3417 };
3418
3419 static const struct of_device_id tegra_pmc_match[] = {
3420         { .compatible = "nvidia,tegra234-pmc", .data = &tegra234_pmc_soc },
3421         { .compatible = "nvidia,tegra194-pmc", .data = &tegra194_pmc_soc },
3422         { .compatible = "nvidia,tegra186-pmc", .data = &tegra186_pmc_soc },
3423         { .compatible = "nvidia,tegra210-pmc", .data = &tegra210_pmc_soc },
3424         { .compatible = "nvidia,tegra132-pmc", .data = &tegra124_pmc_soc },
3425         { .compatible = "nvidia,tegra124-pmc", .data = &tegra124_pmc_soc },
3426         { .compatible = "nvidia,tegra114-pmc", .data = &tegra114_pmc_soc },
3427         { .compatible = "nvidia,tegra30-pmc", .data = &tegra30_pmc_soc },
3428         { .compatible = "nvidia,tegra20-pmc", .data = &tegra20_pmc_soc },
3429         { }
3430 };
3431
3432 static struct platform_driver tegra_pmc_driver = {
3433         .driver = {
3434                 .name = "tegra-pmc",
3435                 .suppress_bind_attrs = true,
3436                 .of_match_table = tegra_pmc_match,
3437 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_ARM)
3438                 .pm = &tegra_pmc_pm_ops,
3439 #endif
3440         },
3441         .probe = tegra_pmc_probe,
3442 };
3443 builtin_platform_driver(tegra_pmc_driver);
3444
3445 static bool __init tegra_pmc_detect_tz_only(struct tegra_pmc *pmc)
3446 {
3447         u32 value, saved;
3448
3449         saved = readl(pmc->base + pmc->soc->regs->scratch0);
3450         value = saved ^ 0xffffffff;
3451
3452         if (value == 0xffffffff)
3453                 value = 0xdeadbeef;
3454
3455         /* write pattern and read it back */
3456         writel(value, pmc->base + pmc->soc->regs->scratch0);
3457         value = readl(pmc->base + pmc->soc->regs->scratch0);
3458
3459         /* if we read all-zeroes, access is restricted to TZ only */
3460         if (value == 0) {
3461                 pr_info("access to PMC is restricted to TZ\n");
3462                 return true;
3463         }
3464
3465         /* restore original value */
3466         writel(saved, pmc->base + pmc->soc->regs->scratch0);
3467
3468         return false;
3469 }
3470
3471 /*
3472  * Early initialization to allow access to registers in the very early boot
3473  * process.
3474  */
3475 static int __init tegra_pmc_early_init(void)
3476 {
3477         const struct of_device_id *match;
3478         struct device_node *np;
3479         struct resource regs;
3480         unsigned int i;
3481         bool invert;
3482
3483         mutex_init(&pmc->powergates_lock);
3484
3485         np = of_find_matching_node_and_match(NULL, tegra_pmc_match, &match);
3486         if (!np) {
3487                 /*
3488                  * Fall back to legacy initialization for 32-bit ARM only. All
3489                  * 64-bit ARM device tree files for Tegra are required to have
3490                  * a PMC node.
3491                  *
3492                  * This is for backwards-compatibility with old device trees
3493                  * that didn't contain a PMC node. Note that in this case the
3494                  * SoC data can't be matched and therefore powergating is
3495                  * disabled.
3496                  */
3497                 if (IS_ENABLED(CONFIG_ARM) && soc_is_tegra()) {
3498                         pr_warn("DT node not found, powergating disabled\n");
3499
3500                         regs.start = 0x7000e400;
3501                         regs.end = 0x7000e7ff;
3502                         regs.flags = IORESOURCE_MEM;
3503
3504                         pr_warn("Using memory region %pR\n", &regs);
3505                 } else {
3506                         /*
3507                          * At this point we're not running on Tegra, so play
3508                          * nice with multi-platform kernels.
3509                          */
3510                         return 0;
3511                 }
3512         } else {
3513                 /*
3514                  * Extract information from the device tree if we've found a
3515                  * matching node.
3516                  */
3517                 if (of_address_to_resource(np, 0, &regs) < 0) {
3518                         pr_err("failed to get PMC registers\n");
3519                         of_node_put(np);
3520                         return -ENXIO;
3521                 }
3522         }
3523
3524         pmc->base = ioremap(regs.start, resource_size(&regs));
3525         if (!pmc->base) {
3526                 pr_err("failed to map PMC registers\n");
3527                 of_node_put(np);
3528                 return -ENXIO;
3529         }
3530
3531         if (np) {
3532                 pmc->soc = match->data;
3533
3534                 if (pmc->soc->maybe_tz_only)
3535                         pmc->tz_only = tegra_pmc_detect_tz_only(pmc);
3536
3537                 /* Create a bitmap of the available and valid partitions */
3538                 for (i = 0; i < pmc->soc->num_powergates; i++)
3539                         if (pmc->soc->powergates[i])
3540                                 set_bit(i, pmc->powergates_available);
3541
3542                 /*
3543                  * Invert the interrupt polarity if a PMC device tree node
3544                  * exists and contains the nvidia,invert-interrupt property.
3545                  */
3546                 invert = of_property_read_bool(np, "nvidia,invert-interrupt");
3547
3548                 pmc->soc->setup_irq_polarity(pmc, np, invert);
3549
3550                 of_node_put(np);
3551         }
3552
3553         return 0;
3554 }
3555 early_initcall(tegra_pmc_early_init);