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-2024, NVIDIA CORPORATION. All rights reserved.
   7  *
   8  * Author:
   9  *      Colin Cross <[email protected]>
  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/interrupt.h>
  27 #include <linux/io.h>
  28 #include <linux/iopoll.h>
  29 #include <linux/irqdomain.h>
  30 #include <linux/irq.h>
  31 #include <linux/kernel.h>
  32 #include <linux/of_address.h>
  33 #include <linux/of_clk.h>
  34 #include <linux/of.h>
  35 #include <linux/of_irq.h>
  36 #include <linux/of_platform.h>
  37 #include <linux/pinctrl/pinconf-generic.h>
  38 #include <linux/pinctrl/pinconf.h>
  39 #include <linux/pinctrl/pinctrl.h>
  40 #include <linux/platform_device.h>
  41 #include <linux/pm_domain.h>
  42 #include <linux/pm_opp.h>
  43 #include <linux/power_supply.h>
  44 #include <linux/reboot.h>
  45 #include <linux/regmap.h>
  46 #include <linux/reset.h>
  47 #include <linux/seq_file.h>
  48 #include <linux/slab.h>
  49 #include <linux/spinlock.h>
  50 #include <linux/syscore_ops.h>
  51
  52 #include <soc/tegra/common.h>
  53 #include <soc/tegra/fuse.h>
  54 #include <soc/tegra/pmc.h>
  55
  56 #include <dt-bindings/interrupt-controller/arm-gic.h>
  57 #include <dt-bindings/pinctrl/pinctrl-tegra-io-pad.h>
  58 #include <dt-bindings/gpio/tegra186-gpio.h>
  59 #include <dt-bindings/gpio/tegra194-gpio.h>
  60 #include <dt-bindings/gpio/tegra234-gpio.h>
  61 #include <dt-bindings/soc/tegra-pmc.h>
  62
  63 #define PMC_CNTRL                       0x0
  64 #define  PMC_CNTRL_INTR_POLARITY        BIT(17) /* inverts INTR polarity */
  65 #define  PMC_CNTRL_CPU_PWRREQ_OE        BIT(16) /* CPU pwr req enable */
  66 #define  PMC_CNTRL_CPU_PWRREQ_POLARITY  BIT(15) /* CPU pwr req polarity */
  67 #define  PMC_CNTRL_SIDE_EFFECT_LP0      BIT(14) /* LP0 when CPU pwr gated */
  68 #define  PMC_CNTRL_SYSCLK_OE            BIT(11) /* system clock enable */
  69 #define  PMC_CNTRL_SYSCLK_POLARITY      BIT(10) /* sys clk polarity */
  70 #define  PMC_CNTRL_PWRREQ_POLARITY      BIT(8)
  71 #define  PMC_CNTRL_BLINK_EN             7
  72 #define  PMC_CNTRL_MAIN_RST             BIT(4)
  73
  74 #define PMC_WAKE_MASK                   0x0c
  75 #define PMC_WAKE_LEVEL                  0x10
  76 #define PMC_WAKE_STATUS                 0x14
  77 #define PMC_SW_WAKE_STATUS              0x18
  78 #define PMC_DPD_PADS_ORIDE              0x1c
  79 #define  PMC_DPD_PADS_ORIDE_BLINK       20
  80
  81 #define DPD_SAMPLE                      0x020
  82 #define  DPD_SAMPLE_ENABLE              BIT(0)
  83 #define  DPD_SAMPLE_DISABLE             (0 << 0)
  84
  85 #define PWRGATE_TOGGLE                  0x30
  86 #define  PWRGATE_TOGGLE_START           BIT(8)
  87
  88 #define REMOVE_CLAMPING                 0x34
  89
  90 #define PWRGATE_STATUS                  0x38
  91
  92 #define PMC_BLINK_TIMER                 0x40
  93 #define PMC_IMPL_E_33V_PWR              0x40
  94
  95 #define PMC_PWR_DET                     0x48
  96
  97 #define PMC_SCRATCH0_MODE_RECOVERY      BIT(31)
  98 #define PMC_SCRATCH0_MODE_BOOTLOADER    BIT(30)
  99 #define PMC_SCRATCH0_MODE_RCM           BIT(1)
 100 #define PMC_SCRATCH0_MODE_MASK          (PMC_SCRATCH0_MODE_RECOVERY | \
 101                                          PMC_SCRATCH0_MODE_BOOTLOADER | \
 102                                          PMC_SCRATCH0_MODE_RCM)
 103
 104 #define PMC_CPUPWRGOOD_TIMER            0xc8
 105 #define PMC_CPUPWROFF_TIMER             0xcc
 106 #define PMC_COREPWRGOOD_TIMER           0x3c
 107 #define PMC_COREPWROFF_TIMER            0xe0
 108
 109 #define PMC_PWR_DET_VALUE               0xe4
 110
 111 #define PMC_USB_DEBOUNCE_DEL            0xec
 112 #define PMC_USB_AO                      0xf0
 113
 114 #define PMC_SCRATCH37                   0x130
 115 #define PMC_SCRATCH41                   0x140
 116
 117 #define PMC_WAKE2_MASK                  0x160
 118 #define PMC_WAKE2_LEVEL                 0x164
 119 #define PMC_WAKE2_STATUS                0x168
 120 #define PMC_SW_WAKE2_STATUS             0x16c
 121
 122 #define PMC_CLK_OUT_CNTRL               0x1a8
 123 #define  PMC_CLK_OUT_MUX_MASK           GENMASK(1, 0)
 124 #define PMC_SENSOR_CTRL                 0x1b0
 125 #define  PMC_SENSOR_CTRL_SCRATCH_WRITE  BIT(2)
 126 #define  PMC_SENSOR_CTRL_ENABLE_RST     BIT(1)
 127
 128 #define  PMC_RST_STATUS_POR             0
 129 #define  PMC_RST_STATUS_WATCHDOG        1
 130 #define  PMC_RST_STATUS_SENSOR          2
 131 #define  PMC_RST_STATUS_SW_MAIN         3
 132 #define  PMC_RST_STATUS_LP0             4
 133 #define  PMC_RST_STATUS_AOTAG           5
 134
 135 #define IO_DPD_REQ                      0x1b8
 136 #define  IO_DPD_REQ_CODE_IDLE           (0U << 30)
 137 #define  IO_DPD_REQ_CODE_OFF            (1U << 30)
 138 #define  IO_DPD_REQ_CODE_ON             (2U << 30)
 139 #define  IO_DPD_REQ_CODE_MASK           (3U << 30)
 140
 141 #define IO_DPD_STATUS                   0x1bc
 142 #define IO_DPD2_REQ                     0x1c0
 143 #define IO_DPD2_STATUS                  0x1c4
 144 #define SEL_DPD_TIM                     0x1c8
 145
 146 #define PMC_UTMIP_UHSIC_TRIGGERS        0x1ec
 147 #define PMC_UTMIP_UHSIC_SAVED_STATE     0x1f0
 148
 149 #define PMC_UTMIP_TERM_PAD_CFG          0x1f8
 150 #define PMC_UTMIP_UHSIC_SLEEP_CFG       0x1fc
 151 #define PMC_UTMIP_UHSIC_FAKE            0x218
 152
 153 #define PMC_SCRATCH54                   0x258
 154 #define  PMC_SCRATCH54_DATA_SHIFT       8
 155 #define  PMC_SCRATCH54_ADDR_SHIFT       0
 156
 157 #define PMC_SCRATCH55                   0x25c
 158 #define  PMC_SCRATCH55_RESET_TEGRA      BIT(31)
 159 #define  PMC_SCRATCH55_CNTRL_ID_SHIFT   27
 160 #define  PMC_SCRATCH55_PINMUX_SHIFT     24
 161 #define  PMC_SCRATCH55_16BITOP          BIT(15)
 162 #define  PMC_SCRATCH55_CHECKSUM_SHIFT   16
 163 #define  PMC_SCRATCH55_I2CSLV1_SHIFT    0
 164
 165 #define  PMC_UTMIP_UHSIC_LINE_WAKEUP    0x26c
 166
 167 #define PMC_UTMIP_BIAS_MASTER_CNTRL     0x270
 168 #define PMC_UTMIP_MASTER_CONFIG         0x274
 169 #define PMC_UTMIP_UHSIC2_TRIGGERS       0x27c
 170 #define PMC_UTMIP_MASTER2_CONFIG        0x29c
 171
 172 #define GPU_RG_CNTRL                    0x2d4
 173
 174 #define PMC_UTMIP_PAD_CFG0              0x4c0
 175 #define PMC_UTMIP_UHSIC_SLEEP_CFG1      0x4d0
 176 #define PMC_UTMIP_SLEEPWALK_P3          0x4e0
 177 /* Tegra186 and later */
 178 #define WAKE_AOWAKE_CNTRL(x) (0x000 + ((x) << 2))
 179 #define WAKE_AOWAKE_CNTRL_LEVEL (1 << 3)
 180 #define WAKE_AOWAKE_CNTRL_SR_CAPTURE_EN (1 << 1)
 181 #define WAKE_AOWAKE_MASK_W(x) (0x180 + ((x) << 2))
 182 #define WAKE_AOWAKE_MASK_R(x) (0x300 + ((x) << 2))
 183 #define WAKE_AOWAKE_STATUS_W(x) (0x30c + ((x) << 2))
 184 #define WAKE_AOWAKE_STATUS_R(x) (0x48c + ((x) << 2))
 185 #define WAKE_AOWAKE_TIER0_ROUTING(x) (0x4b4 + ((x) << 2))
 186 #define WAKE_AOWAKE_TIER1_ROUTING(x) (0x4c0 + ((x) << 2))
 187 #define WAKE_AOWAKE_TIER2_ROUTING(x) (0x4cc + ((x) << 2))
 188 #define WAKE_AOWAKE_SW_STATUS_W_0       0x49c
 189 #define WAKE_AOWAKE_SW_STATUS(x)        (0x4a0 + ((x) << 2))
 190 #define WAKE_LATCH_SW                   0x498
 191
 192 #define WAKE_AOWAKE_CTRL 0x4f4
 193 #define  WAKE_AOWAKE_CTRL_INTR_POLARITY BIT(0)
 194
 195 #define SW_WAKE_ID              83 /* wake83 */
 196
 197 /* for secure PMC */
 198 #define TEGRA_SMC_PMC           0xc2fffe00
 199 #define  TEGRA_SMC_PMC_READ     0xaa
 200 #define  TEGRA_SMC_PMC_WRITE    0xbb
 201
 202 struct pmc_clk {
 203         struct clk_hw   hw;
 204         unsigned long   offs;
 205         u32             mux_shift;
 206         u32             force_en_shift;
 207 };
 208
 209 #define to_pmc_clk(_hw) container_of(_hw, struct pmc_clk, hw)
 210
 211 struct pmc_clk_gate {
 212         struct clk_hw   hw;
 213         unsigned long   offs;
 214         u32             shift;
 215 };
 216
 217 #define to_pmc_clk_gate(_hw) container_of(_hw, struct pmc_clk_gate, hw)
 218
 219 struct pmc_clk_init_data {
 220         char *name;
 221         const char *const *parents;
 222         int num_parents;
 223         int clk_id;
 224         u8 mux_shift;
 225         u8 force_en_shift;
 226 };
 227
 228 static const char * const clk_out1_parents[] = { "osc", "osc_div2",
 229         "osc_div4", "extern1",
 230 };
 231
 232 static const char * const clk_out2_parents[] = { "osc", "osc_div2",
 233         "osc_div4", "extern2",
 234 };
 235
 236 static const char * const clk_out3_parents[] = { "osc", "osc_div2",
 237         "osc_div4", "extern3",
 238 };
 239
 240 static const struct pmc_clk_init_data tegra_pmc_clks_data[] = {
 241         {
 242                 .name = "pmc_clk_out_1",
 243                 .parents = clk_out1_parents,
 244                 .num_parents = ARRAY_SIZE(clk_out1_parents),
 245                 .clk_id = TEGRA_PMC_CLK_OUT_1,
 246                 .mux_shift = 6,
 247                 .force_en_shift = 2,
 248         },
 249         {
 250                 .name = "pmc_clk_out_2",
 251                 .parents = clk_out2_parents,
 252                 .num_parents = ARRAY_SIZE(clk_out2_parents),
 253                 .clk_id = TEGRA_PMC_CLK_OUT_2,
 254                 .mux_shift = 14,
 255                 .force_en_shift = 10,
 256         },
 257         {
 258                 .name = "pmc_clk_out_3",
 259                 .parents = clk_out3_parents,
 260                 .num_parents = ARRAY_SIZE(clk_out3_parents),
 261                 .clk_id = TEGRA_PMC_CLK_OUT_3,
 262                 .mux_shift = 22,
 263                 .force_en_shift = 18,
 264         },
 265 };
 266
 267 struct tegra_powergate {
 268         struct generic_pm_domain genpd;
 269         struct tegra_pmc *pmc;
 270         unsigned int id;
 271         struct clk **clks;
 272         unsigned int num_clks;
 273         unsigned long *clk_rates;
 274         struct reset_control *reset;
 275 };
 276
 277 struct tegra_io_pad_soc {
 278         enum tegra_io_pad id;
 279         unsigned int dpd;
 280         unsigned int request;
 281         unsigned int status;
 282         unsigned int voltage;
 283         const char *name;
 284 };
 285
 286 struct tegra_pmc_regs {
 287         unsigned int scratch0;
 288         unsigned int rst_status;
 289         unsigned int rst_source_shift;
 290         unsigned int rst_source_mask;
 291         unsigned int rst_level_shift;
 292         unsigned int rst_level_mask;
 293 };
 294
 295 struct tegra_wake_event {
 296         const char *name;
 297         unsigned int id;
 298         unsigned int irq;
 299         struct {
 300                 unsigned int instance;
 301                 unsigned int pin;
 302         } gpio;
 303 };
 304
 305 #define TEGRA_WAKE_SIMPLE(_name, _id)                   \
 306         {                                               \
 307                 .name = _name,                          \
 308                 .id = _id,                              \
 309                 .irq = 0,                               \
 310                 .gpio = {                               \
 311                         .instance = UINT_MAX,           \
 312                         .pin = UINT_MAX,                \
 313                 },                                      \
 314         }
 315
 316 #define TEGRA_WAKE_IRQ(_name, _id, _irq)                \
 317         {                                               \
 318                 .name = _name,                          \
 319                 .id = _id,                              \
 320                 .irq = _irq,                            \
 321                 .gpio = {                               \
 322                         .instance = UINT_MAX,           \
 323                         .pin = UINT_MAX,                \
 324                 },                                      \
 325         }
 326
 327 #define TEGRA_WAKE_GPIO(_name, _id, _instance, _pin)    \
 328         {                                               \
 329                 .name = _name,                          \
 330                 .id = _id,                              \
 331                 .irq = 0,                               \
 332                 .gpio = {                               \
 333                         .instance = _instance,          \
 334                         .pin = _pin,                    \
 335                 },                                      \
 336         }
 337
 338 struct tegra_pmc_soc {
 339         unsigned int num_powergates;
 340         const char *const *powergates;
 341         unsigned int num_cpu_powergates;
 342         const u8 *cpu_powergates;
 343
 344         bool has_tsense_reset;
 345         bool has_gpu_clamps;
 346         bool needs_mbist_war;
 347         bool has_impl_33v_pwr;
 348         bool maybe_tz_only;
 349
 350         const struct tegra_io_pad_soc *io_pads;
 351         unsigned int num_io_pads;
 352
 353         const struct pinctrl_pin_desc *pin_descs;
 354         unsigned int num_pin_descs;
 355
 356         const struct tegra_pmc_regs *regs;
 357         void (*init)(struct tegra_pmc *pmc);
 358         void (*setup_irq_polarity)(struct tegra_pmc *pmc,
 359                                    struct device_node *np,
 360                                    bool invert);
 361         void (*set_wake_filters)(struct tegra_pmc *pmc);
 362         int (*irq_set_wake)(struct irq_data *data, unsigned int on);
 363         int (*irq_set_type)(struct irq_data *data, unsigned int type);
 364         int (*powergate_set)(struct tegra_pmc *pmc, unsigned int id,
 365                              bool new_state);
 366
 367         const char * const *reset_sources;
 368         unsigned int num_reset_sources;
 369         const char * const *reset_levels;
 370         unsigned int num_reset_levels;
 371
 372         /*
 373          * These describe events that can wake the system from sleep (i.e.
 374          * LP0 or SC7). Wakeup from other sleep states (such as LP1 or LP2)
 375          * are dealt with in the LIC.
 376          */
 377         const struct tegra_wake_event *wake_events;
 378         unsigned int num_wake_events;
 379         unsigned int max_wake_events;
 380         unsigned int max_wake_vectors;
 381
 382         const struct pmc_clk_init_data *pmc_clks_data;
 383         unsigned int num_pmc_clks;
 384         bool has_blink_output;
 385         bool has_usb_sleepwalk;
 386         bool supports_core_domain;
 387         bool has_single_mmio_aperture;
 388 };
 389
 390 /**
 391  * struct tegra_pmc - NVIDIA Tegra PMC
 392  * @dev: pointer to PMC device structure
 393  * @base: pointer to I/O remapped register region
 394  * @wake: pointer to I/O remapped region for WAKE registers
 395  * @aotag: pointer to I/O remapped region for AOTAG registers
 396  * @scratch: pointer to I/O remapped region for scratch registers
 397  * @clk: pointer to pclk clock
 398  * @soc: pointer to SoC data structure
 399  * @tz_only: flag specifying if the PMC can only be accessed via TrustZone
 400  * @rate: currently configured rate of pclk
 401  * @suspend_mode: lowest suspend mode available
 402  * @cpu_good_time: CPU power good time (in microseconds)
 403  * @cpu_off_time: CPU power off time (in microsecends)
 404  * @core_osc_time: core power good OSC time (in microseconds)
 405  * @core_pmu_time: core power good PMU time (in microseconds)
 406  * @core_off_time: core power off time (in microseconds)
 407  * @corereq_high: core power request is active-high
 408  * @sysclkreq_high: system clock request is active-high
 409  * @combined_req: combined power request for CPU & core
 410  * @cpu_pwr_good_en: CPU power good signal is enabled
 411  * @lp0_vec_phys: physical base address of the LP0 warm boot code
 412  * @lp0_vec_size: size of the LP0 warm boot code
 413  * @powergates_available: Bitmap of available power gates
 414  * @powergates_lock: mutex for power gate register access
 415  * @pctl_dev: pin controller exposed by the PMC
 416  * @domain: IRQ domain provided by the PMC
 417  * @irq: chip implementation for the IRQ domain
 418  * @clk_nb: pclk clock changes handler
 419  * @core_domain_state_synced: flag marking the core domain's state as synced
 420  * @core_domain_registered: flag marking the core domain as registered
 421  * @wake_type_level_map: Bitmap indicating level type for non-dual edge wakes
 422  * @wake_type_dual_edge_map: Bitmap indicating if a wake is dual-edge or not
 423  * @wake_sw_status_map: Bitmap to hold raw status of wakes without mask
 424  * @wake_cntrl_level_map: Bitmap to hold wake levels to be programmed in
 425  *     cntrl register associated with each wake during system suspend.
 426  */
 427 struct tegra_pmc {
 428         struct device *dev;
 429         void __iomem *base;
 430         void __iomem *wake;
 431         void __iomem *aotag;
 432         void __iomem *scratch;
 433         struct clk *clk;
 434
 435         const struct tegra_pmc_soc *soc;
 436         bool tz_only;
 437
 438         unsigned long rate;
 439
 440         enum tegra_suspend_mode suspend_mode;
 441         u32 cpu_good_time;
 442         u32 cpu_off_time;
 443         u32 core_osc_time;
 444         u32 core_pmu_time;
 445         u32 core_off_time;
 446         bool corereq_high;
 447         bool sysclkreq_high;
 448         bool combined_req;
 449         bool cpu_pwr_good_en;
 450         u32 lp0_vec_phys;
 451         u32 lp0_vec_size;
 452         DECLARE_BITMAP(powergates_available, TEGRA_POWERGATE_MAX);
 453
 454         struct mutex powergates_lock;
 455
 456         struct pinctrl_dev *pctl_dev;
 457
 458         struct irq_domain *domain;
 459         struct irq_chip irq;
 460
 461         struct notifier_block clk_nb;
 462
 463         bool core_domain_state_synced;
 464         bool core_domain_registered;
 465
 466         unsigned long *wake_type_level_map;
 467         unsigned long *wake_type_dual_edge_map;
 468         unsigned long *wake_sw_status_map;
 469         unsigned long *wake_cntrl_level_map;
 470         struct syscore_ops syscore;
 471 };
 472
 473 static struct tegra_pmc *pmc = &(struct tegra_pmc) {
 474         .base = NULL,
 475         .suspend_mode = TEGRA_SUSPEND_NOT_READY,
 476 };
 477
 478 static inline struct tegra_powergate *
 479 to_powergate(struct generic_pm_domain *domain)
 480 {
 481         return container_of(domain, struct tegra_powergate, genpd);
 482 }
 483
 484 static u32 tegra_pmc_readl(struct tegra_pmc *pmc, unsigned long offset)
 485 {
 486         struct arm_smccc_res res;
 487
 488         if (pmc->tz_only) {
 489                 arm_smccc_smc(TEGRA_SMC_PMC, TEGRA_SMC_PMC_READ, offset, 0, 0,
 490                               0, 0, 0, &res);
 491                 if (res.a0) {
 492                         if (pmc->dev)
 493                                 dev_warn(pmc->dev, "%s(): SMC failed: %lu\n",
 494                                          __func__, res.a0);
 495                         else
 496                                 pr_warn("%s(): SMC failed: %lu\n", __func__,
 497                                         res.a0);
 498                 }
 499
 500                 return res.a1;
 501         }
 502
 503         return readl(pmc->base + offset);
 504 }
 505
 506 static void tegra_pmc_writel(struct tegra_pmc *pmc, u32 value,
 507                              unsigned long offset)
 508 {
 509         struct arm_smccc_res res;
 510
 511         if (pmc->tz_only) {
 512                 arm_smccc_smc(TEGRA_SMC_PMC, TEGRA_SMC_PMC_WRITE, offset,
 513                               value, 0, 0, 0, 0, &res);
 514                 if (res.a0) {
 515                         if (pmc->dev)
 516                                 dev_warn(pmc->dev, "%s(): SMC failed: %lu\n",
 517                                          __func__, res.a0);
 518                         else
 519                                 pr_warn("%s(): SMC failed: %lu\n", __func__,
 520                                         res.a0);
 521                 }
 522         } else {
 523                 writel(value, pmc->base + offset);
 524         }
 525 }
 526
 527 static u32 tegra_pmc_scratch_readl(struct tegra_pmc *pmc, unsigned long offset)
 528 {
 529         if (pmc->tz_only)
 530                 return tegra_pmc_readl(pmc, offset);
 531
 532         return readl(pmc->scratch + offset);
 533 }
 534
 535 static void tegra_pmc_scratch_writel(struct tegra_pmc *pmc, u32 value,
 536                                      unsigned long offset)
 537 {
 538         if (pmc->tz_only)
 539                 tegra_pmc_writel(pmc, value, offset);
 540         else
 541                 writel(value, pmc->scratch + offset);
 542 }
 543
 544 /*
 545  * TODO Figure out a way to call this with the struct tegra_pmc * passed in.
 546  * This currently doesn't work because readx_poll_timeout() can only operate
 547  * on functions that take a single argument.
 548  */
 549 static inline bool tegra_powergate_state(int id)
 550 {
 551         if (id == TEGRA_POWERGATE_3D && pmc->soc->has_gpu_clamps)
 552                 return (tegra_pmc_readl(pmc, GPU_RG_CNTRL) & 0x1) == 0;
 553         else
 554                 return (tegra_pmc_readl(pmc, PWRGATE_STATUS) & BIT(id)) != 0;
 555 }
 556
 557 static inline bool tegra_powergate_is_valid(struct tegra_pmc *pmc, int id)
 558 {
 559         return (pmc->soc && pmc->soc->powergates[id]);
 560 }
 561
 562 static inline bool tegra_powergate_is_available(struct tegra_pmc *pmc, int id)
 563 {
 564         return test_bit(id, pmc->powergates_available);
 565 }
 566
 567 static int tegra_powergate_lookup(struct tegra_pmc *pmc, const char *name)
 568 {
 569         unsigned int i;
 570
 571         if (!pmc || !pmc->soc || !name)
 572                 return -EINVAL;
 573
 574         for (i = 0; i < pmc->soc->num_powergates; i++) {
 575                 if (!tegra_powergate_is_valid(pmc, i))
 576                         continue;
 577
 578                 if (!strcmp(name, pmc->soc->powergates[i]))
 579                         return i;
 580         }
 581
 582         return -ENODEV;
 583 }
 584
 585 static int tegra20_powergate_set(struct tegra_pmc *pmc, unsigned int id,
 586                                  bool new_state)
 587 {
 588         unsigned int retries = 100;
 589         bool status;
 590         int ret;
 591
 592         /*
 593          * As per TRM documentation, the toggle command will be dropped by PMC
 594          * if there is contention with a HW-initiated toggling (i.e. CPU core
 595          * power-gated), the command should be retried in that case.
 596          */
 597         do {
 598                 tegra_pmc_writel(pmc, PWRGATE_TOGGLE_START | id, PWRGATE_TOGGLE);
 599
 600                 /* wait for PMC to execute the command */
 601                 ret = readx_poll_timeout(tegra_powergate_state, id, status,
 602                                          status == new_state, 1, 10);
 603         } while (ret == -ETIMEDOUT && retries--);
 604
 605         return ret;
 606 }
 607
 608 static inline bool tegra_powergate_toggle_ready(struct tegra_pmc *pmc)
 609 {
 610         return !(tegra_pmc_readl(pmc, PWRGATE_TOGGLE) & PWRGATE_TOGGLE_START);
 611 }
 612
 613 static int tegra114_powergate_set(struct tegra_pmc *pmc, unsigned int id,
 614                                   bool new_state)
 615 {
 616         bool status;
 617         int err;
 618
 619         /* wait while PMC power gating is contended */
 620         err = readx_poll_timeout(tegra_powergate_toggle_ready, pmc, status,
 621                                  status == true, 1, 100);
 622         if (err)
 623                 return err;
 624
 625         tegra_pmc_writel(pmc, PWRGATE_TOGGLE_START | id, PWRGATE_TOGGLE);
 626
 627         /* wait for PMC to accept the command */
 628         err = readx_poll_timeout(tegra_powergate_toggle_ready, pmc, status,
 629                                  status == true, 1, 100);
 630         if (err)
 631                 return err;
 632
 633         /* wait for PMC to execute the command */
 634         err = readx_poll_timeout(tegra_powergate_state, id, status,
 635                                  status == new_state, 10, 100000);
 636         if (err)
 637                 return err;
 638
 639         return 0;
 640 }
 641
 642 /**
 643  * tegra_powergate_set() - set the state of a partition
 644  * @pmc: power management controller
 645  * @id: partition ID
 646  * @new_state: new state of the partition
 647  */
 648 static int tegra_powergate_set(struct tegra_pmc *pmc, unsigned int id,
 649                                bool new_state)
 650 {
 651         int err;
 652
 653         if (id == TEGRA_POWERGATE_3D && pmc->soc->has_gpu_clamps)
 654                 return -EINVAL;
 655
 656         mutex_lock(&pmc->powergates_lock);
 657
 658         if (tegra_powergate_state(id) == new_state) {
 659                 mutex_unlock(&pmc->powergates_lock);
 660                 return 0;
 661         }
 662
 663         err = pmc->soc->powergate_set(pmc, id, new_state);
 664
 665         mutex_unlock(&pmc->powergates_lock);
 666
 667         return err;
 668 }
 669
 670 static int __tegra_powergate_remove_clamping(struct tegra_pmc *pmc,
 671                                              unsigned int id)
 672 {
 673         u32 mask;
 674
 675         mutex_lock(&pmc->powergates_lock);
 676
 677         /*
 678          * On Tegra124 and later, the clamps for the GPU are controlled by a
 679          * separate register (with different semantics).
 680          */
 681         if (id == TEGRA_POWERGATE_3D) {
 682                 if (pmc->soc->has_gpu_clamps) {
 683                         tegra_pmc_writel(pmc, 0, GPU_RG_CNTRL);
 684                         goto out;
 685                 }
 686         }
 687
 688         /*
 689          * Tegra 2 has a bug where PCIE and VDE clamping masks are
 690          * swapped relatively to the partition ids
 691          */
 692         if (id == TEGRA_POWERGATE_VDEC)
 693                 mask = (1 << TEGRA_POWERGATE_PCIE);
 694         else if (id == TEGRA_POWERGATE_PCIE)
 695                 mask = (1 << TEGRA_POWERGATE_VDEC);
 696         else
 697                 mask = (1 << id);
 698
 699         tegra_pmc_writel(pmc, mask, REMOVE_CLAMPING);
 700
 701 out:
 702         mutex_unlock(&pmc->powergates_lock);
 703
 704         return 0;
 705 }
 706
 707 static int tegra_powergate_prepare_clocks(struct tegra_powergate *pg)
 708 {
 709         unsigned long safe_rate = 100 * 1000 * 1000;
 710         unsigned int i;
 711         int err;
 712
 713         for (i = 0; i < pg->num_clks; i++) {
 714                 pg->clk_rates[i] = clk_get_rate(pg->clks[i]);
 715
 716                 if (!pg->clk_rates[i]) {
 717                         err = -EINVAL;
 718                         goto out;
 719                 }
 720
 721                 if (pg->clk_rates[i] <= safe_rate)
 722                         continue;
 723
 724                 /*
 725                  * We don't know whether voltage state is okay for the
 726                  * current clock rate, hence it's better to temporally
 727                  * switch clock to a safe rate which is suitable for
 728                  * all voltages, before enabling the clock.
 729                  */
 730                 err = clk_set_rate(pg->clks[i], safe_rate);
 731                 if (err)
 732                         goto out;
 733         }
 734
 735         return 0;
 736
 737 out:
 738         while (i--)
 739                 clk_set_rate(pg->clks[i], pg->clk_rates[i]);
 740
 741         return err;
 742 }
 743
 744 static int tegra_powergate_unprepare_clocks(struct tegra_powergate *pg)
 745 {
 746         unsigned int i;
 747         int err;
 748
 749         for (i = 0; i < pg->num_clks; i++) {
 750                 err = clk_set_rate(pg->clks[i], pg->clk_rates[i]);
 751                 if (err)
 752                         return err;
 753         }
 754
 755         return 0;
 756 }
 757
 758 static void tegra_powergate_disable_clocks(struct tegra_powergate *pg)
 759 {
 760         unsigned int i;
 761
 762         for (i = 0; i < pg->num_clks; i++)
 763                 clk_disable_unprepare(pg->clks[i]);
 764 }
 765
 766 static int tegra_powergate_enable_clocks(struct tegra_powergate *pg)
 767 {
 768         unsigned int i;
 769         int err;
 770
 771         for (i = 0; i < pg->num_clks; i++) {
 772                 err = clk_prepare_enable(pg->clks[i]);
 773                 if (err)
 774                         goto out;
 775         }
 776
 777         return 0;
 778
 779 out:
 780         while (i--)
 781                 clk_disable_unprepare(pg->clks[i]);
 782
 783         return err;
 784 }
 785
 786 static int tegra_powergate_power_up(struct tegra_powergate *pg,
 787                                     bool disable_clocks)
 788 {
 789         int err;
 790
 791         err = reset_control_assert(pg->reset);
 792         if (err)
 793                 return err;
 794
 795         usleep_range(10, 20);
 796
 797         err = tegra_powergate_set(pg->pmc, pg->id, true);
 798         if (err < 0)
 799                 return err;
 800
 801         usleep_range(10, 20);
 802
 803         err = tegra_powergate_prepare_clocks(pg);
 804         if (err)
 805                 goto powergate_off;
 806
 807         err = tegra_powergate_enable_clocks(pg);
 808         if (err)
 809                 goto unprepare_clks;
 810
 811         usleep_range(10, 20);
 812
 813         err = __tegra_powergate_remove_clamping(pg->pmc, pg->id);
 814         if (err)
 815                 goto disable_clks;
 816
 817         usleep_range(10, 20);
 818
 819         err = reset_control_deassert(pg->reset);
 820         if (err)
 821                 goto disable_clks;
 822
 823         usleep_range(10, 20);
 824
 825         if (pg->pmc->soc->needs_mbist_war)
 826                 err = tegra210_clk_handle_mbist_war(pg->id);
 827         if (err)
 828                 goto disable_clks;
 829
 830         if (disable_clocks)
 831                 tegra_powergate_disable_clocks(pg);
 832
 833         err = tegra_powergate_unprepare_clocks(pg);
 834         if (err)
 835                 return err;
 836
 837         return 0;
 838
 839 disable_clks:
 840         tegra_powergate_disable_clocks(pg);
 841         usleep_range(10, 20);
 842
 843 unprepare_clks:
 844         tegra_powergate_unprepare_clocks(pg);
 845
 846 powergate_off:
 847         tegra_powergate_set(pg->pmc, pg->id, false);
 848
 849         return err;
 850 }
 851
 852 static int tegra_powergate_power_down(struct tegra_powergate *pg)
 853 {
 854         int err;
 855
 856         err = tegra_powergate_prepare_clocks(pg);
 857         if (err)
 858                 return err;
 859
 860         err = tegra_powergate_enable_clocks(pg);
 861         if (err)
 862                 goto unprepare_clks;
 863
 864         usleep_range(10, 20);
 865
 866         err = reset_control_assert(pg->reset);
 867         if (err)
 868                 goto disable_clks;
 869
 870         usleep_range(10, 20);
 871
 872         tegra_powergate_disable_clocks(pg);
 873
 874         usleep_range(10, 20);
 875
 876         err = tegra_powergate_set(pg->pmc, pg->id, false);
 877         if (err)
 878                 goto assert_resets;
 879
 880         err = tegra_powergate_unprepare_clocks(pg);
 881         if (err)
 882                 return err;
 883
 884         return 0;
 885
 886 assert_resets:
 887         tegra_powergate_enable_clocks(pg);
 888         usleep_range(10, 20);
 889         reset_control_deassert(pg->reset);
 890         usleep_range(10, 20);
 891
 892 disable_clks:
 893         tegra_powergate_disable_clocks(pg);
 894
 895 unprepare_clks:
 896         tegra_powergate_unprepare_clocks(pg);
 897
 898         return err;
 899 }
 900
 901 static int tegra_genpd_power_on(struct generic_pm_domain *domain)
 902 {
 903         struct tegra_powergate *pg = to_powergate(domain);
 904         struct device *dev = pg->pmc->dev;
 905         int err;
 906
 907         err = tegra_powergate_power_up(pg, true);
 908         if (err) {
 909                 dev_err(dev, "failed to turn on PM domain %s: %d\n",
 910                         pg->genpd.name, err);
 911                 goto out;
 912         }
 913
 914         reset_control_release(pg->reset);
 915
 916 out:
 917         return err;
 918 }
 919
 920 static int tegra_genpd_power_off(struct generic_pm_domain *domain)
 921 {
 922         struct tegra_powergate *pg = to_powergate(domain);
 923         struct device *dev = pg->pmc->dev;
 924         int err;
 925
 926         err = reset_control_acquire(pg->reset);
 927         if (err < 0) {
 928                 dev_err(dev, "failed to acquire resets for PM domain %s: %d\n",
 929                         pg->genpd.name, err);
 930                 return err;
 931         }
 932
 933         err = tegra_powergate_power_down(pg);
 934         if (err) {
 935                 dev_err(dev, "failed to turn off PM domain %s: %d\n",
 936                         pg->genpd.name, err);
 937                 reset_control_release(pg->reset);
 938         }
 939
 940         return err;
 941 }
 942
 943 /**
 944  * tegra_powergate_power_on() - power on partition
 945  * @id: partition ID
 946  */
 947 int tegra_powergate_power_on(unsigned int id)
 948 {
 949         if (!tegra_powergate_is_available(pmc, id))
 950                 return -EINVAL;
 951
 952         return tegra_powergate_set(pmc, id, true);
 953 }
 954 EXPORT_SYMBOL(tegra_powergate_power_on);
 955
 956 /**
 957  * tegra_powergate_power_off() - power off partition
 958  * @id: partition ID
 959  */
 960 int tegra_powergate_power_off(unsigned int id)
 961 {
 962         if (!tegra_powergate_is_available(pmc, id))
 963                 return -EINVAL;
 964
 965         return tegra_powergate_set(pmc, id, false);
 966 }
 967 EXPORT_SYMBOL(tegra_powergate_power_off);
 968
 969 /**
 970  * tegra_powergate_is_powered() - check if partition is powered
 971  * @pmc: power management controller
 972  * @id: partition ID
 973  */
 974 static int tegra_powergate_is_powered(struct tegra_pmc *pmc, unsigned int id)
 975 {
 976         if (!tegra_powergate_is_valid(pmc, id))
 977                 return -EINVAL;
 978
 979         return tegra_powergate_state(id);
 980 }
 981
 982 /**
 983  * tegra_powergate_remove_clamping() - remove power clamps for partition
 984  * @id: partition ID
 985  */
 986 int tegra_powergate_remove_clamping(unsigned int id)
 987 {
 988         if (!tegra_powergate_is_available(pmc, id))
 989                 return -EINVAL;
 990
 991         return __tegra_powergate_remove_clamping(pmc, id);
 992 }
 993 EXPORT_SYMBOL(tegra_powergate_remove_clamping);
 994
 995 /**
 996  * tegra_powergate_sequence_power_up() - power up partition
 997  * @id: partition ID
 998  * @clk: clock for partition
 999  * @rst: reset for partition
1000  *
1001  * Must be called with clk disabled, and returns with clk enabled.
1002  */
1003 int tegra_powergate_sequence_power_up(unsigned int id, struct clk *clk,
1004                                       struct reset_control *rst)
1005 {
1006         struct tegra_powergate *pg;
1007         int err;
1008
1009         if (!tegra_powergate_is_available(pmc, id))
1010                 return -EINVAL;
1011
1012         pg = kzalloc(sizeof(*pg), GFP_KERNEL);
1013         if (!pg)
1014                 return -ENOMEM;
1015
1016         pg->clk_rates = kzalloc(sizeof(*pg->clk_rates), GFP_KERNEL);
1017         if (!pg->clk_rates) {
1018                 kfree(pg->clks);
1019                 return -ENOMEM;
1020         }
1021
1022         pg->id = id;
1023         pg->clks = &clk;
1024         pg->num_clks = 1;
1025         pg->reset = rst;
1026         pg->pmc = pmc;
1027
1028         err = tegra_powergate_power_up(pg, false);
1029         if (err)
1030                 dev_err(pmc->dev, "failed to turn on partition %d: %d\n", id,
1031                         err);
1032
1033         kfree(pg->clk_rates);
1034         kfree(pg);
1035
1036         return err;
1037 }
1038 EXPORT_SYMBOL(tegra_powergate_sequence_power_up);
1039
1040 /**
1041  * tegra_get_cpu_powergate_id() - convert from CPU ID to partition ID
1042  * @pmc: power management controller
1043  * @cpuid: CPU partition ID
1044  *
1045  * Returns the partition ID corresponding to the CPU partition ID or a
1046  * negative error code on failure.
1047  */
1048 static int tegra_get_cpu_powergate_id(struct tegra_pmc *pmc,
1049                                       unsigned int cpuid)
1050 {
1051         if (pmc->soc && cpuid < pmc->soc->num_cpu_powergates)
1052                 return pmc->soc->cpu_powergates[cpuid];
1053
1054         return -EINVAL;
1055 }
1056
1057 /**
1058  * tegra_pmc_cpu_is_powered() - check if CPU partition is powered
1059  * @cpuid: CPU partition ID
1060  */
1061 bool tegra_pmc_cpu_is_powered(unsigned int cpuid)
1062 {
1063         int id;
1064
1065         id = tegra_get_cpu_powergate_id(pmc, cpuid);
1066         if (id < 0)
1067                 return false;
1068
1069         return tegra_powergate_is_powered(pmc, id);
1070 }
1071
1072 /**
1073  * tegra_pmc_cpu_power_on() - power on CPU partition
1074  * @cpuid: CPU partition ID
1075  */
1076 int tegra_pmc_cpu_power_on(unsigned int cpuid)
1077 {
1078         int id;
1079
1080         id = tegra_get_cpu_powergate_id(pmc, cpuid);
1081         if (id < 0)
1082                 return id;
1083
1084         return tegra_powergate_set(pmc, id, true);
1085 }
1086
1087 /**
1088  * tegra_pmc_cpu_remove_clamping() - remove power clamps for CPU partition
1089  * @cpuid: CPU partition ID
1090  */
1091 int tegra_pmc_cpu_remove_clamping(unsigned int cpuid)
1092 {
1093         int id;
1094
1095         id = tegra_get_cpu_powergate_id(pmc, cpuid);
1096         if (id < 0)
1097                 return id;
1098
1099         return tegra_powergate_remove_clamping(id);
1100 }
1101
1102 static void tegra_pmc_program_reboot_reason(const char *cmd)
1103 {
1104         u32 value;
1105
1106         value = tegra_pmc_scratch_readl(pmc, pmc->soc->regs->scratch0);
1107         value &= ~PMC_SCRATCH0_MODE_MASK;
1108
1109         if (cmd) {
1110                 if (strcmp(cmd, "recovery") == 0)
1111                         value |= PMC_SCRATCH0_MODE_RECOVERY;
1112
1113                 if (strcmp(cmd, "bootloader") == 0)
1114                         value |= PMC_SCRATCH0_MODE_BOOTLOADER;
1115
1116                 if (strcmp(cmd, "forced-recovery") == 0)
1117                         value |= PMC_SCRATCH0_MODE_RCM;
1118         }
1119
1120         tegra_pmc_scratch_writel(pmc, value, pmc->soc->regs->scratch0);
1121 }
1122
1123 static int tegra_pmc_reboot_notify(struct notifier_block *this,
1124                                    unsigned long action, void *data)
1125 {
1126         if (action == SYS_RESTART)
1127                 tegra_pmc_program_reboot_reason(data);
1128
1129         return NOTIFY_DONE;
1130 }
1131
1132 static struct notifier_block tegra_pmc_reboot_notifier = {
1133         .notifier_call = tegra_pmc_reboot_notify,
1134 };
1135
1136 static void tegra_pmc_restart(void)
1137 {
1138         u32 value;
1139
1140         /* reset everything but PMC_SCRATCH0 and PMC_RST_STATUS */
1141         value = tegra_pmc_readl(pmc, PMC_CNTRL);
1142         value |= PMC_CNTRL_MAIN_RST;
1143         tegra_pmc_writel(pmc, value, PMC_CNTRL);
1144 }
1145
1146 static int tegra_pmc_restart_handler(struct sys_off_data *data)
1147 {
1148         tegra_pmc_restart();
1149
1150         return NOTIFY_DONE;
1151 }
1152
1153 static int tegra_pmc_power_off_handler(struct sys_off_data *data)
1154 {
1155         /*
1156          * Reboot Nexus 7 into special bootloader mode if USB cable is
1157          * connected in order to display battery status and power off.
1158          */
1159         if (of_machine_is_compatible("asus,grouper") &&
1160             power_supply_is_system_supplied()) {
1161                 const u32 go_to_charger_mode = 0xa5a55a5a;
1162
1163                 tegra_pmc_writel(pmc, go_to_charger_mode, PMC_SCRATCH37);
1164                 tegra_pmc_restart();
1165         }
1166
1167         return NOTIFY_DONE;
1168 }
1169
1170 static int powergate_show(struct seq_file *s, void *data)
1171 {
1172         unsigned int i;
1173         int status;
1174
1175         seq_printf(s, " powergate powered\n");
1176         seq_printf(s, "------------------\n");
1177
1178         for (i = 0; i < pmc->soc->num_powergates; i++) {
1179                 status = tegra_powergate_is_powered(pmc, i);
1180                 if (status < 0)
1181                         continue;
1182
1183                 seq_printf(s, " %9s %7s\n", pmc->soc->powergates[i],
1184                            status ? "yes" : "no");
1185         }
1186
1187         return 0;
1188 }
1189
1190 DEFINE_SHOW_ATTRIBUTE(powergate);
1191
1192 static int tegra_powergate_of_get_clks(struct tegra_powergate *pg,
1193                                        struct device_node *np)
1194 {
1195         struct clk *clk;
1196         unsigned int i, count;
1197         int err;
1198
1199         count = of_clk_get_parent_count(np);
1200         if (count == 0)
1201                 return -ENODEV;
1202
1203         pg->clks = kcalloc(count, sizeof(clk), GFP_KERNEL);
1204         if (!pg->clks)
1205                 return -ENOMEM;
1206
1207         pg->clk_rates = kcalloc(count, sizeof(*pg->clk_rates), GFP_KERNEL);
1208         if (!pg->clk_rates) {
1209                 kfree(pg->clks);
1210                 return -ENOMEM;
1211         }
1212
1213         for (i = 0; i < count; i++) {
1214                 pg->clks[i] = of_clk_get(np, i);
1215                 if (IS_ERR(pg->clks[i])) {
1216                         err = PTR_ERR(pg->clks[i]);
1217                         goto err;
1218                 }
1219         }
1220
1221         pg->num_clks = count;
1222
1223         return 0;
1224
1225 err:
1226         while (i--)
1227                 clk_put(pg->clks[i]);
1228
1229         kfree(pg->clk_rates);
1230         kfree(pg->clks);
1231
1232         return err;
1233 }
1234
1235 static int tegra_powergate_of_get_resets(struct tegra_powergate *pg,
1236                                          struct device_node *np, bool off)
1237 {
1238         struct device *dev = pg->pmc->dev;
1239         int err;
1240
1241         pg->reset = of_reset_control_array_get_exclusive_released(np);
1242         if (IS_ERR(pg->reset)) {
1243                 err = PTR_ERR(pg->reset);
1244                 dev_err(dev, "failed to get device resets: %d\n", err);
1245                 return err;
1246         }
1247
1248         err = reset_control_acquire(pg->reset);
1249         if (err < 0) {
1250                 pr_err("failed to acquire resets: %d\n", err);
1251                 goto out;
1252         }
1253
1254         if (off) {
1255                 err = reset_control_assert(pg->reset);
1256         } else {
1257                 err = reset_control_deassert(pg->reset);
1258                 if (err < 0)
1259                         goto out;
1260
1261                 reset_control_release(pg->reset);
1262         }
1263
1264 out:
1265         if (err) {
1266                 reset_control_release(pg->reset);
1267                 reset_control_put(pg->reset);
1268         }
1269
1270         return err;
1271 }
1272
1273 static int tegra_powergate_add(struct tegra_pmc *pmc, struct device_node *np)
1274 {
1275         struct device *dev = pmc->dev;
1276         struct tegra_powergate *pg;
1277         int id, err = 0;
1278         bool off;
1279
1280         pg = kzalloc(sizeof(*pg), GFP_KERNEL);
1281         if (!pg)
1282                 return -ENOMEM;
1283
1284         id = tegra_powergate_lookup(pmc, np->name);
1285         if (id < 0) {
1286                 dev_err(dev, "powergate lookup failed for %pOFn: %d\n", np, id);
1287                 err = -ENODEV;
1288                 goto free_mem;
1289         }
1290
1291         /*
1292          * Clear the bit for this powergate so it cannot be managed
1293          * directly via the legacy APIs for controlling powergates.
1294          */
1295         clear_bit(id, pmc->powergates_available);
1296
1297         pg->id = id;
1298         pg->genpd.name = np->name;
1299         pg->genpd.power_off = tegra_genpd_power_off;
1300         pg->genpd.power_on = tegra_genpd_power_on;
1301         pg->pmc = pmc;
1302
1303         off = !tegra_powergate_is_powered(pmc, pg->id);
1304
1305         err = tegra_powergate_of_get_clks(pg, np);
1306         if (err < 0) {
1307                 dev_err(dev, "failed to get clocks for %pOFn: %d\n", np, err);
1308                 goto set_available;
1309         }
1310
1311         err = tegra_powergate_of_get_resets(pg, np, off);
1312         if (err < 0) {
1313                 dev_err(dev, "failed to get resets for %pOFn: %d\n", np, err);
1314                 goto remove_clks;
1315         }
1316
1317         if (!IS_ENABLED(CONFIG_PM_GENERIC_DOMAINS)) {
1318                 if (off)
1319                         WARN_ON(tegra_powergate_power_up(pg, true));
1320
1321                 goto remove_resets;
1322         }
1323
1324         err = pm_genpd_init(&pg->genpd, NULL, off);
1325         if (err < 0) {
1326                 dev_err(dev, "failed to initialise PM domain %pOFn: %d\n", np,
1327                        err);
1328                 goto remove_resets;
1329         }
1330
1331         err = of_genpd_add_provider_simple(np, &pg->genpd);
1332         if (err < 0) {
1333                 dev_err(dev, "failed to add PM domain provider for %pOFn: %d\n",
1334                         np, err);
1335                 goto remove_genpd;
1336         }
1337
1338         dev_dbg(dev, "added PM domain %s\n", pg->genpd.name);
1339
1340         return 0;
1341
1342 remove_genpd:
1343         pm_genpd_remove(&pg->genpd);
1344
1345 remove_resets:
1346         reset_control_put(pg->reset);
1347
1348 remove_clks:
1349         while (pg->num_clks--)
1350                 clk_put(pg->clks[pg->num_clks]);
1351
1352         kfree(pg->clks);
1353
1354 set_available:
1355         set_bit(id, pmc->powergates_available);
1356
1357 free_mem:
1358         kfree(pg);
1359
1360         return err;
1361 }
1362
1363 bool tegra_pmc_core_domain_state_synced(void)
1364 {
1365         return pmc->core_domain_state_synced;
1366 }
1367
1368 static int
1369 tegra_pmc_core_pd_set_performance_state(struct generic_pm_domain *genpd,
1370                                         unsigned int level)
1371 {
1372         struct dev_pm_opp *opp;
1373         int err;
1374
1375         opp = dev_pm_opp_find_level_ceil(&genpd->dev, &level);
1376         if (IS_ERR(opp)) {
1377                 dev_err(&genpd->dev, "failed to find OPP for level %u: %pe\n",
1378                         level, opp);
1379                 return PTR_ERR(opp);
1380         }
1381
1382         mutex_lock(&pmc->powergates_lock);
1383         err = dev_pm_opp_set_opp(pmc->dev, opp);
1384         mutex_unlock(&pmc->powergates_lock);
1385
1386         dev_pm_opp_put(opp);
1387
1388         if (err) {
1389                 dev_err(&genpd->dev, "failed to set voltage to %duV: %d\n",
1390                         level, err);
1391                 return err;
1392         }
1393
1394         return 0;
1395 }
1396
1397 static int tegra_pmc_core_pd_add(struct tegra_pmc *pmc, struct device_node *np)
1398 {
1399         struct generic_pm_domain *genpd;
1400         const char *rname[] = { "core", NULL};
1401         int err;
1402
1403         genpd = devm_kzalloc(pmc->dev, sizeof(*genpd), GFP_KERNEL);
1404         if (!genpd)
1405                 return -ENOMEM;
1406
1407         genpd->name = "core";
1408         genpd->set_performance_state = tegra_pmc_core_pd_set_performance_state;
1409
1410         err = devm_pm_opp_set_regulators(pmc->dev, rname);
1411         if (err)
1412                 return dev_err_probe(pmc->dev, err,
1413                                      "failed to set core OPP regulator\n");
1414
1415         err = pm_genpd_init(genpd, NULL, false);
1416         if (err) {
1417                 dev_err(pmc->dev, "failed to init core genpd: %d\n", err);
1418                 return err;
1419         }
1420
1421         err = of_genpd_add_provider_simple(np, genpd);
1422         if (err) {
1423                 dev_err(pmc->dev, "failed to add core genpd: %d\n", err);
1424                 goto remove_genpd;
1425         }
1426
1427         pmc->core_domain_registered = true;
1428
1429         return 0;
1430
1431 remove_genpd:
1432         pm_genpd_remove(genpd);
1433
1434         return err;
1435 }
1436
1437 static int tegra_powergate_init(struct tegra_pmc *pmc,
1438                                 struct device_node *parent)
1439 {
1440         struct of_phandle_args child_args, parent_args;
1441         struct device_node *np, *child;
1442         int err = 0;
1443
1444         /*
1445          * Core power domain is the parent of powergate domains, hence it
1446          * should be registered first.
1447          */
1448         np = of_get_child_by_name(parent, "core-domain");
1449         if (np) {
1450                 err = tegra_pmc_core_pd_add(pmc, np);
1451                 of_node_put(np);
1452                 if (err)
1453                         return err;
1454         }
1455
1456         np = of_get_child_by_name(parent, "powergates");
1457         if (!np)
1458                 return 0;
1459
1460         for_each_child_of_node(np, child) {
1461                 err = tegra_powergate_add(pmc, child);
1462                 if (err < 0) {
1463                         of_node_put(child);
1464                         break;
1465                 }
1466
1467                 if (of_parse_phandle_with_args(child, "power-domains",
1468                                                "#power-domain-cells",
1469                                                0, &parent_args))
1470                         continue;
1471
1472                 child_args.np = child;
1473                 child_args.args_count = 0;
1474
1475                 err = of_genpd_add_subdomain(&parent_args, &child_args);
1476                 of_node_put(parent_args.np);
1477                 if (err) {
1478                         of_node_put(child);
1479                         break;
1480                 }
1481         }
1482
1483         of_node_put(np);
1484
1485         return err;
1486 }
1487
1488 static void tegra_powergate_remove(struct generic_pm_domain *genpd)
1489 {
1490         struct tegra_powergate *pg = to_powergate(genpd);
1491
1492         reset_control_put(pg->reset);
1493
1494         while (pg->num_clks--)
1495                 clk_put(pg->clks[pg->num_clks]);
1496
1497         kfree(pg->clks);
1498
1499         set_bit(pg->id, pmc->powergates_available);
1500
1501         kfree(pg);
1502 }
1503
1504 static void tegra_powergate_remove_all(struct device_node *parent)
1505 {
1506         struct generic_pm_domain *genpd;
1507         struct device_node *np, *child;
1508
1509         np = of_get_child_by_name(parent, "powergates");
1510         if (!np)
1511                 return;
1512
1513         for_each_child_of_node(np, child) {
1514                 of_genpd_del_provider(child);
1515
1516                 genpd = of_genpd_remove_last(child);
1517                 if (IS_ERR(genpd))
1518                         continue;
1519
1520                 tegra_powergate_remove(genpd);
1521         }
1522
1523         of_node_put(np);
1524
1525         np = of_get_child_by_name(parent, "core-domain");
1526         if (np) {
1527                 of_genpd_del_provider(np);
1528                 of_genpd_remove_last(np);
1529         }
1530 }
1531
1532 static const struct tegra_io_pad_soc *
1533 tegra_io_pad_find(struct tegra_pmc *pmc, enum tegra_io_pad id)
1534 {
1535         unsigned int i;
1536
1537         for (i = 0; i < pmc->soc->num_io_pads; i++)
1538                 if (pmc->soc->io_pads[i].id == id)
1539                         return &pmc->soc->io_pads[i];
1540
1541         return NULL;
1542 }
1543
1544 static int tegra_io_pad_prepare(struct tegra_pmc *pmc,
1545                                 const struct tegra_io_pad_soc *pad,
1546                                 unsigned long *request,
1547                                 unsigned long *status,
1548                                 u32 *mask)
1549 {
1550         unsigned long rate, value;
1551
1552         if (pad->dpd == UINT_MAX)
1553                 return -EINVAL;
1554
1555         *request = pad->request;
1556         *status = pad->status;
1557         *mask = BIT(pad->dpd);
1558
1559         if (pmc->clk) {
1560                 rate = pmc->rate;
1561                 if (!rate) {
1562                         dev_err(pmc->dev, "failed to get clock rate\n");
1563                         return -ENODEV;
1564                 }
1565
1566                 tegra_pmc_writel(pmc, DPD_SAMPLE_ENABLE, DPD_SAMPLE);
1567
1568                 /* must be at least 200 ns, in APB (PCLK) clock cycles */
1569                 value = DIV_ROUND_UP(1000000000, rate);
1570                 value = DIV_ROUND_UP(200, value);
1571                 tegra_pmc_writel(pmc, value, SEL_DPD_TIM);
1572         }
1573
1574         return 0;
1575 }
1576
1577 static int tegra_io_pad_poll(struct tegra_pmc *pmc, unsigned long offset,
1578                              u32 mask, u32 val, unsigned long timeout)
1579 {
1580         u32 value;
1581
1582         timeout = jiffies + msecs_to_jiffies(timeout);
1583
1584         while (time_after(timeout, jiffies)) {
1585                 value = tegra_pmc_readl(pmc, offset);
1586                 if ((value & mask) == val)
1587                         return 0;
1588
1589                 usleep_range(250, 1000);
1590         }
1591
1592         return -ETIMEDOUT;
1593 }
1594
1595 static void tegra_io_pad_unprepare(struct tegra_pmc *pmc)
1596 {
1597         if (pmc->clk)
1598                 tegra_pmc_writel(pmc, DPD_SAMPLE_DISABLE, DPD_SAMPLE);
1599 }
1600
1601 /**
1602  * tegra_io_pad_power_enable() - enable power to I/O pad
1603  * @id: Tegra I/O pad ID for which to enable power
1604  *
1605  * Returns: 0 on success or a negative error code on failure.
1606  */
1607 int tegra_io_pad_power_enable(enum tegra_io_pad id)
1608 {
1609         const struct tegra_io_pad_soc *pad;
1610         unsigned long request, status;
1611         u32 mask;
1612         int err;
1613
1614         pad = tegra_io_pad_find(pmc, id);
1615         if (!pad) {
1616                 dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);
1617                 return -ENOENT;
1618         }
1619
1620         mutex_lock(&pmc->powergates_lock);
1621
1622         err = tegra_io_pad_prepare(pmc, pad, &request, &status, &mask);
1623         if (err < 0) {
1624                 dev_err(pmc->dev, "failed to prepare I/O pad: %d\n", err);
1625                 goto unlock;
1626         }
1627
1628         tegra_pmc_writel(pmc, IO_DPD_REQ_CODE_OFF | mask, request);
1629
1630         err = tegra_io_pad_poll(pmc, status, mask, 0, 250);
1631         if (err < 0) {
1632                 dev_err(pmc->dev, "failed to enable I/O pad: %d\n", err);
1633                 goto unlock;
1634         }
1635
1636         tegra_io_pad_unprepare(pmc);
1637
1638 unlock:
1639         mutex_unlock(&pmc->powergates_lock);
1640         return err;
1641 }
1642 EXPORT_SYMBOL(tegra_io_pad_power_enable);
1643
1644 /**
1645  * tegra_io_pad_power_disable() - disable power to I/O pad
1646  * @id: Tegra I/O pad ID for which to disable power
1647  *
1648  * Returns: 0 on success or a negative error code on failure.
1649  */
1650 int tegra_io_pad_power_disable(enum tegra_io_pad id)
1651 {
1652         const struct tegra_io_pad_soc *pad;
1653         unsigned long request, status;
1654         u32 mask;
1655         int err;
1656
1657         pad = tegra_io_pad_find(pmc, id);
1658         if (!pad) {
1659                 dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);
1660                 return -ENOENT;
1661         }
1662
1663         mutex_lock(&pmc->powergates_lock);
1664
1665         err = tegra_io_pad_prepare(pmc, pad, &request, &status, &mask);
1666         if (err < 0) {
1667                 dev_err(pmc->dev, "failed to prepare I/O pad: %d\n", err);
1668                 goto unlock;
1669         }
1670
1671         tegra_pmc_writel(pmc, IO_DPD_REQ_CODE_ON | mask, request);
1672
1673         err = tegra_io_pad_poll(pmc, status, mask, mask, 250);
1674         if (err < 0) {
1675                 dev_err(pmc->dev, "failed to disable I/O pad: %d\n", err);
1676                 goto unlock;
1677         }
1678
1679         tegra_io_pad_unprepare(pmc);
1680
1681 unlock:
1682         mutex_unlock(&pmc->powergates_lock);
1683         return err;
1684 }
1685 EXPORT_SYMBOL(tegra_io_pad_power_disable);
1686
1687 static int tegra_io_pad_is_powered(struct tegra_pmc *pmc, enum tegra_io_pad id)
1688 {
1689         const struct tegra_io_pad_soc *pad;
1690         unsigned long status;
1691         u32 mask, value;
1692
1693         pad = tegra_io_pad_find(pmc, id);
1694         if (!pad) {
1695                 dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);
1696                 return -ENOENT;
1697         }
1698
1699         if (pad->dpd == UINT_MAX)
1700                 return -EINVAL;
1701
1702         status = pad->status;
1703         mask = BIT(pad->dpd);
1704
1705         value = tegra_pmc_readl(pmc, status);
1706
1707         return !(value & mask);
1708 }
1709
1710 static int tegra_io_pad_set_voltage(struct tegra_pmc *pmc, enum tegra_io_pad id,
1711                                     int voltage)
1712 {
1713         const struct tegra_io_pad_soc *pad;
1714         u32 value;
1715
1716         pad = tegra_io_pad_find(pmc, id);
1717         if (!pad)
1718                 return -ENOENT;
1719
1720         if (pad->voltage == UINT_MAX)
1721                 return -ENOTSUPP;
1722
1723         mutex_lock(&pmc->powergates_lock);
1724
1725         if (pmc->soc->has_impl_33v_pwr) {
1726                 value = tegra_pmc_readl(pmc, PMC_IMPL_E_33V_PWR);
1727
1728                 if (voltage == TEGRA_IO_PAD_VOLTAGE_1V8)
1729                         value &= ~BIT(pad->voltage);
1730                 else
1731                         value |= BIT(pad->voltage);
1732
1733                 tegra_pmc_writel(pmc, value, PMC_IMPL_E_33V_PWR);
1734         } else {
1735                 /* write-enable PMC_PWR_DET_VALUE[pad->voltage] */
1736                 value = tegra_pmc_readl(pmc, PMC_PWR_DET);
1737                 value |= BIT(pad->voltage);
1738                 tegra_pmc_writel(pmc, value, PMC_PWR_DET);
1739
1740                 /* update I/O voltage */
1741                 value = tegra_pmc_readl(pmc, PMC_PWR_DET_VALUE);
1742
1743                 if (voltage == TEGRA_IO_PAD_VOLTAGE_1V8)
1744                         value &= ~BIT(pad->voltage);
1745                 else
1746                         value |= BIT(pad->voltage);
1747
1748                 tegra_pmc_writel(pmc, value, PMC_PWR_DET_VALUE);
1749         }
1750
1751         mutex_unlock(&pmc->powergates_lock);
1752
1753         usleep_range(100, 250);
1754
1755         return 0;
1756 }
1757
1758 static int tegra_io_pad_get_voltage(struct tegra_pmc *pmc, enum tegra_io_pad id)
1759 {
1760         const struct tegra_io_pad_soc *pad;
1761         u32 value;
1762
1763         pad = tegra_io_pad_find(pmc, id);
1764         if (!pad)
1765                 return -ENOENT;
1766
1767         if (pad->voltage == UINT_MAX)
1768                 return -ENOTSUPP;
1769
1770         if (pmc->soc->has_impl_33v_pwr)
1771                 value = tegra_pmc_readl(pmc, PMC_IMPL_E_33V_PWR);
1772         else
1773                 value = tegra_pmc_readl(pmc, PMC_PWR_DET_VALUE);
1774
1775         if ((value & BIT(pad->voltage)) == 0)
1776                 return TEGRA_IO_PAD_VOLTAGE_1V8;
1777
1778         return TEGRA_IO_PAD_VOLTAGE_3V3;
1779 }
1780
1781 #ifdef CONFIG_PM_SLEEP
1782 enum tegra_suspend_mode tegra_pmc_get_suspend_mode(void)
1783 {
1784         return pmc->suspend_mode;
1785 }
1786
1787 void tegra_pmc_set_suspend_mode(enum tegra_suspend_mode mode)
1788 {
1789         if (mode < TEGRA_SUSPEND_NONE || mode >= TEGRA_MAX_SUSPEND_MODE)
1790                 return;
1791
1792         pmc->suspend_mode = mode;
1793 }
1794
1795 void tegra_pmc_enter_suspend_mode(enum tegra_suspend_mode mode)
1796 {
1797         unsigned long long rate = 0;
1798         u64 ticks;
1799         u32 value;
1800
1801         switch (mode) {
1802         case TEGRA_SUSPEND_LP1:
1803                 rate = 32768;
1804                 break;
1805
1806         case TEGRA_SUSPEND_LP2:
1807                 rate = pmc->rate;
1808                 break;
1809
1810         default:
1811                 break;
1812         }
1813
1814         if (WARN_ON_ONCE(rate == 0))
1815                 rate = 100000000;
1816
1817         ticks = pmc->cpu_good_time * rate + USEC_PER_SEC - 1;
1818         do_div(ticks, USEC_PER_SEC);
1819         tegra_pmc_writel(pmc, ticks, PMC_CPUPWRGOOD_TIMER);
1820
1821         ticks = pmc->cpu_off_time * rate + USEC_PER_SEC - 1;
1822         do_div(ticks, USEC_PER_SEC);
1823         tegra_pmc_writel(pmc, ticks, PMC_CPUPWROFF_TIMER);
1824
1825         value = tegra_pmc_readl(pmc, PMC_CNTRL);
1826         value &= ~PMC_CNTRL_SIDE_EFFECT_LP0;
1827         value |= PMC_CNTRL_CPU_PWRREQ_OE;
1828         tegra_pmc_writel(pmc, value, PMC_CNTRL);
1829 }
1830 #endif
1831
1832 static int tegra_pmc_parse_dt(struct tegra_pmc *pmc, struct device_node *np)
1833 {
1834         u32 value, values[2];
1835
1836         if (of_property_read_u32(np, "nvidia,suspend-mode", &value)) {
1837                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1838         } else {
1839                 switch (value) {
1840                 case 0:
1841                         pmc->suspend_mode = TEGRA_SUSPEND_LP0;
1842                         break;
1843
1844                 case 1:
1845                         pmc->suspend_mode = TEGRA_SUSPEND_LP1;
1846                         break;
1847
1848                 case 2:
1849                         pmc->suspend_mode = TEGRA_SUSPEND_LP2;
1850                         break;
1851
1852                 default:
1853                         pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1854                         break;
1855                 }
1856         }
1857
1858         pmc->suspend_mode = tegra_pm_validate_suspend_mode(pmc->suspend_mode);
1859
1860         if (of_property_read_u32(np, "nvidia,cpu-pwr-good-time", &value))
1861                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1862
1863         pmc->cpu_good_time = value;
1864
1865         if (of_property_read_u32(np, "nvidia,cpu-pwr-off-time", &value))
1866                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1867
1868         pmc->cpu_off_time = value;
1869
1870         if (of_property_read_u32_array(np, "nvidia,core-pwr-good-time",
1871                                        values, ARRAY_SIZE(values)))
1872                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1873
1874         pmc->core_osc_time = values[0];
1875         pmc->core_pmu_time = values[1];
1876
1877         if (of_property_read_u32(np, "nvidia,core-pwr-off-time", &value))
1878                 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1879
1880         pmc->core_off_time = value;
1881
1882         pmc->corereq_high = of_property_read_bool(np,
1883                                 "nvidia,core-power-req-active-high");
1884
1885         pmc->sysclkreq_high = of_property_read_bool(np,
1886                                 "nvidia,sys-clock-req-active-high");
1887
1888         pmc->combined_req = of_property_read_bool(np,
1889                                 "nvidia,combined-power-req");
1890
1891         pmc->cpu_pwr_good_en = of_property_read_bool(np,
1892                                 "nvidia,cpu-pwr-good-en");
1893
1894         if (of_property_read_u32_array(np, "nvidia,lp0-vec", values,
1895                                        ARRAY_SIZE(values)))
1896                 if (pmc->suspend_mode == TEGRA_SUSPEND_LP0)
1897                         pmc->suspend_mode = TEGRA_SUSPEND_LP1;
1898
1899         pmc->lp0_vec_phys = values[0];
1900         pmc->lp0_vec_size = values[1];
1901
1902         return 0;
1903 }
1904
1905 static int tegra_pmc_init(struct tegra_pmc *pmc)
1906 {
1907         if (pmc->soc->max_wake_events > 0) {
1908                 pmc->wake_type_level_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);
1909                 if (!pmc->wake_type_level_map)
1910                         return -ENOMEM;
1911
1912                 pmc->wake_type_dual_edge_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);
1913                 if (!pmc->wake_type_dual_edge_map)
1914                         return -ENOMEM;
1915
1916                 pmc->wake_sw_status_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);
1917                 if (!pmc->wake_sw_status_map)
1918                         return -ENOMEM;
1919
1920                 pmc->wake_cntrl_level_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);
1921                 if (!pmc->wake_cntrl_level_map)
1922                         return -ENOMEM;
1923         }
1924
1925         if (pmc->soc->init)
1926                 pmc->soc->init(pmc);
1927
1928         return 0;
1929 }
1930
1931 static void tegra_pmc_init_tsense_reset(struct tegra_pmc *pmc)
1932 {
1933         static const char disabled[] = "emergency thermal reset disabled";
1934         u32 pmu_addr, ctrl_id, reg_addr, reg_data, pinmux;
1935         struct device *dev = pmc->dev;
1936         struct device_node *np;
1937         u32 value, checksum;
1938
1939         if (!pmc->soc->has_tsense_reset)
1940                 return;
1941
1942         np = of_get_child_by_name(pmc->dev->of_node, "i2c-thermtrip");
1943         if (!np) {
1944                 dev_warn(dev, "i2c-thermtrip node not found, %s.\n", disabled);
1945                 return;
1946         }
1947
1948         if (of_property_read_u32(np, "nvidia,i2c-controller-id", &ctrl_id)) {
1949                 dev_err(dev, "I2C controller ID missing, %s.\n", disabled);
1950                 goto out;
1951         }
1952
1953         if (of_property_read_u32(np, "nvidia,bus-addr", &pmu_addr)) {
1954                 dev_err(dev, "nvidia,bus-addr missing, %s.\n", disabled);
1955                 goto out;
1956         }
1957
1958         if (of_property_read_u32(np, "nvidia,reg-addr", &reg_addr)) {
1959                 dev_err(dev, "nvidia,reg-addr missing, %s.\n", disabled);
1960                 goto out;
1961         }
1962
1963         if (of_property_read_u32(np, "nvidia,reg-data", &reg_data)) {
1964                 dev_err(dev, "nvidia,reg-data missing, %s.\n", disabled);
1965                 goto out;
1966         }
1967
1968         if (of_property_read_u32(np, "nvidia,pinmux-id", &pinmux))
1969                 pinmux = 0;
1970
1971         value = tegra_pmc_readl(pmc, PMC_SENSOR_CTRL);
1972         value |= PMC_SENSOR_CTRL_SCRATCH_WRITE;
1973         tegra_pmc_writel(pmc, value, PMC_SENSOR_CTRL);
1974
1975         value = (reg_data << PMC_SCRATCH54_DATA_SHIFT) |
1976                 (reg_addr << PMC_SCRATCH54_ADDR_SHIFT);
1977         tegra_pmc_writel(pmc, value, PMC_SCRATCH54);
1978
1979         value = PMC_SCRATCH55_RESET_TEGRA;
1980         value |= ctrl_id << PMC_SCRATCH55_CNTRL_ID_SHIFT;
1981         value |= pinmux << PMC_SCRATCH55_PINMUX_SHIFT;
1982         value |= pmu_addr << PMC_SCRATCH55_I2CSLV1_SHIFT;
1983
1984         /*
1985          * Calculate checksum of SCRATCH54, SCRATCH55 fields. Bits 23:16 will
1986          * contain the checksum and are currently zero, so they are not added.
1987          */
1988         checksum = reg_addr + reg_data + (value & 0xff) + ((value >> 8) & 0xff)
1989                 + ((value >> 24) & 0xff);
1990         checksum &= 0xff;
1991         checksum = 0x100 - checksum;
1992
1993         value |= checksum << PMC_SCRATCH55_CHECKSUM_SHIFT;
1994
1995         tegra_pmc_writel(pmc, value, PMC_SCRATCH55);
1996
1997         value = tegra_pmc_readl(pmc, PMC_SENSOR_CTRL);
1998         value |= PMC_SENSOR_CTRL_ENABLE_RST;
1999         tegra_pmc_writel(pmc, value, PMC_SENSOR_CTRL);
2000
2001         dev_info(pmc->dev, "emergency thermal reset enabled\n");
2002
2003 out:
2004         of_node_put(np);
2005 }
2006
2007 static int tegra_io_pad_pinctrl_get_groups_count(struct pinctrl_dev *pctl_dev)
2008 {
2009         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
2010
2011         return pmc->soc->num_io_pads;
2012 }
2013
2014 static const char *tegra_io_pad_pinctrl_get_group_name(struct pinctrl_dev *pctl,
2015                                                        unsigned int group)
2016 {
2017         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl);
2018
2019         return pmc->soc->io_pads[group].name;
2020 }
2021
2022 static int tegra_io_pad_pinctrl_get_group_pins(struct pinctrl_dev *pctl_dev,
2023                                                unsigned int group,
2024                                                const unsigned int **pins,
2025                                                unsigned int *num_pins)
2026 {
2027         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
2028
2029         *pins = &pmc->soc->io_pads[group].id;
2030         *num_pins = 1;
2031
2032         return 0;
2033 }
2034
2035 static const struct pinctrl_ops tegra_io_pad_pinctrl_ops = {
2036         .get_groups_count = tegra_io_pad_pinctrl_get_groups_count,
2037         .get_group_name = tegra_io_pad_pinctrl_get_group_name,
2038         .get_group_pins = tegra_io_pad_pinctrl_get_group_pins,
2039         .dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
2040         .dt_free_map = pinconf_generic_dt_free_map,
2041 };
2042
2043 static int tegra_io_pad_pinconf_get(struct pinctrl_dev *pctl_dev,
2044                                     unsigned int pin, unsigned long *config)
2045 {
2046         enum pin_config_param param = pinconf_to_config_param(*config);
2047         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
2048         const struct tegra_io_pad_soc *pad;
2049         int ret;
2050         u32 arg;
2051
2052         pad = tegra_io_pad_find(pmc, pin);
2053         if (!pad)
2054                 return -EINVAL;
2055
2056         switch (param) {
2057         case PIN_CONFIG_POWER_SOURCE:
2058                 ret = tegra_io_pad_get_voltage(pmc, pad->id);
2059                 if (ret < 0)
2060                         return ret;
2061
2062                 arg = ret;
2063                 break;
2064
2065         case PIN_CONFIG_MODE_LOW_POWER:
2066                 ret = tegra_io_pad_is_powered(pmc, pad->id);
2067                 if (ret < 0)
2068                         return ret;
2069
2070                 arg = !ret;
2071                 break;
2072
2073         default:
2074                 return -EINVAL;
2075         }
2076
2077         *config = pinconf_to_config_packed(param, arg);
2078
2079         return 0;
2080 }
2081
2082 static int tegra_io_pad_pinconf_set(struct pinctrl_dev *pctl_dev,
2083                                     unsigned int pin, unsigned long *configs,
2084                                     unsigned int num_configs)
2085 {
2086         struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
2087         const struct tegra_io_pad_soc *pad;
2088         enum pin_config_param param;
2089         unsigned int i;
2090         int err;
2091         u32 arg;
2092
2093         pad = tegra_io_pad_find(pmc, pin);
2094         if (!pad)
2095                 return -EINVAL;
2096
2097         for (i = 0; i < num_configs; ++i) {
2098                 param = pinconf_to_config_param(configs[i]);
2099                 arg = pinconf_to_config_argument(configs[i]);
2100
2101                 switch (param) {
2102                 case PIN_CONFIG_MODE_LOW_POWER:
2103                         if (arg)
2104                                 err = tegra_io_pad_power_disable(pad->id);
2105                         else
2106                                 err = tegra_io_pad_power_enable(pad->id);
2107                         if (err)
2108                                 return err;
2109                         break;
2110                 case PIN_CONFIG_POWER_SOURCE:
2111                         if (arg != TEGRA_IO_PAD_VOLTAGE_1V8 &&
2112                             arg != TEGRA_IO_PAD_VOLTAGE_3V3)
2113                                 return -EINVAL;
2114                         err = tegra_io_pad_set_voltage(pmc, pad->id, arg);
2115                         if (err)
2116                                 return err;
2117                         break;
2118                 default:
2119                         return -EINVAL;
2120                 }
2121         }
2122
2123         return 0;
2124 }
2125
2126 static const struct pinconf_ops tegra_io_pad_pinconf_ops = {
2127         .pin_config_get = tegra_io_pad_pinconf_get,
2128         .pin_config_set = tegra_io_pad_pinconf_set,
2129         .is_generic = true,
2130 };
2131
2132 static struct pinctrl_desc tegra_pmc_pctl_desc = {
2133         .pctlops = &tegra_io_pad_pinctrl_ops,
2134         .confops = &tegra_io_pad_pinconf_ops,
2135 };
2136
2137 static int tegra_pmc_pinctrl_init(struct tegra_pmc *pmc)
2138 {
2139         int err;
2140
2141         if (!pmc->soc->num_pin_descs)
2142                 return 0;
2143
2144         tegra_pmc_pctl_desc.name = dev_name(pmc->dev);
2145         tegra_pmc_pctl_desc.pins = pmc->soc->pin_descs;
2146         tegra_pmc_pctl_desc.npins = pmc->soc->num_pin_descs;
2147
2148         pmc->pctl_dev = devm_pinctrl_register(pmc->dev, &tegra_pmc_pctl_desc,
2149                                               pmc);
2150         if (IS_ERR(pmc->pctl_dev)) {
2151                 err = PTR_ERR(pmc->pctl_dev);
2152                 dev_err(pmc->dev, "failed to register pin controller: %d\n",
2153                         err);
2154                 return err;
2155         }
2156
2157         return 0;
2158 }
2159
2160 static ssize_t reset_reason_show(struct device *dev,
2161                                  struct device_attribute *attr, char *buf)
2162 {
2163         u32 value;
2164
2165         value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);
2166         value &= pmc->soc->regs->rst_source_mask;
2167         value >>= pmc->soc->regs->rst_source_shift;
2168
2169         if (WARN_ON(value >= pmc->soc->num_reset_sources))
2170                 return sprintf(buf, "%s\n", "UNKNOWN");
2171
2172         return sprintf(buf, "%s\n", pmc->soc->reset_sources[value]);
2173 }
2174
2175 static DEVICE_ATTR_RO(reset_reason);
2176
2177 static ssize_t reset_level_show(struct device *dev,
2178                                 struct device_attribute *attr, char *buf)
2179 {
2180         u32 value;
2181
2182         value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);
2183         value &= pmc->soc->regs->rst_level_mask;
2184         value >>= pmc->soc->regs->rst_level_shift;
2185
2186         if (WARN_ON(value >= pmc->soc->num_reset_levels))
2187                 return sprintf(buf, "%s\n", "UNKNOWN");
2188
2189         return sprintf(buf, "%s\n", pmc->soc->reset_levels[value]);
2190 }
2191
2192 static DEVICE_ATTR_RO(reset_level);
2193
2194 static void tegra_pmc_reset_sysfs_init(struct tegra_pmc *pmc)
2195 {
2196         struct device *dev = pmc->dev;
2197         int err = 0;
2198
2199         if (pmc->soc->reset_sources) {
2200                 err = device_create_file(dev, &dev_attr_reset_reason);
2201                 if (err < 0)
2202                         dev_warn(dev,
2203                                  "failed to create attr \"reset_reason\": %d\n",
2204                                  err);
2205         }
2206
2207         if (pmc->soc->reset_levels) {
2208                 err = device_create_file(dev, &dev_attr_reset_level);
2209                 if (err < 0)
2210                         dev_warn(dev,
2211                                  "failed to create attr \"reset_level\": %d\n",
2212                                  err);
2213         }
2214 }
2215
2216 static int tegra_pmc_irq_translate(struct irq_domain *domain,
2217                                    struct irq_fwspec *fwspec,
2218                                    unsigned long *hwirq,
2219                                    unsigned int *type)
2220 {
2221         if (WARN_ON(fwspec->param_count < 2))
2222                 return -EINVAL;
2223
2224         *hwirq = fwspec->param[0];
2225         *type = fwspec->param[1];
2226
2227         return 0;
2228 }
2229
2230 static int tegra_pmc_irq_alloc(struct irq_domain *domain, unsigned int virq,
2231                                unsigned int num_irqs, void *data)
2232 {
2233         struct tegra_pmc *pmc = domain->host_data;
2234         const struct tegra_pmc_soc *soc = pmc->soc;
2235         struct irq_fwspec *fwspec = data;
2236         unsigned int i;
2237         int err = 0;
2238
2239         if (WARN_ON(num_irqs > 1))
2240                 return -EINVAL;
2241
2242         for (i = 0; i < soc->num_wake_events; i++) {
2243                 const struct tegra_wake_event *event = &soc->wake_events[i];
2244
2245                 /* IRQ and simple wake events */
2246                 if (fwspec->param_count == 2) {
2247                         struct irq_fwspec spec;
2248
2249                         if (event->id != fwspec->param[0])
2250                                 continue;
2251
2252                         err = irq_domain_set_hwirq_and_chip(domain, virq,
2253                                                             event->id,
2254                                                             &pmc->irq, pmc);
2255                         if (err < 0)
2256                                 break;
2257
2258                         /* simple hierarchies stop at the PMC level */
2259                         if (event->irq == 0) {
2260                                 err = irq_domain_disconnect_hierarchy(domain->parent, virq);
2261                                 break;
2262                         }
2263
2264                         spec.fwnode = &pmc->dev->of_node->fwnode;
2265                         spec.param_count = 3;
2266                         spec.param[0] = GIC_SPI;
2267                         spec.param[1] = event->irq;
2268                         spec.param[2] = fwspec->param[1];
2269
2270                         err = irq_domain_alloc_irqs_parent(domain, virq,
2271                                                            num_irqs, &spec);
2272
2273                         break;
2274                 }
2275
2276                 /* GPIO wake events */
2277                 if (fwspec->param_count == 3) {
2278                         if (event->gpio.instance != fwspec->param[0] ||
2279                             event->gpio.pin != fwspec->param[1])
2280                                 continue;
2281
2282                         err = irq_domain_set_hwirq_and_chip(domain, virq,
2283                                                             event->id,
2284                                                             &pmc->irq, pmc);
2285
2286                         /* GPIO hierarchies stop at the PMC level */
2287                         if (!err && domain->parent)
2288                                 err = irq_domain_disconnect_hierarchy(domain->parent,
2289                                                                       virq);
2290                         break;
2291                 }
2292         }
2293
2294         /* If there is no wake-up event, there is no PMC mapping */
2295         if (i == soc->num_wake_events)
2296                 err = irq_domain_disconnect_hierarchy(domain, virq);
2297
2298         return err;
2299 }
2300
2301 static const struct irq_domain_ops tegra_pmc_irq_domain_ops = {
2302         .translate = tegra_pmc_irq_translate,
2303         .alloc = tegra_pmc_irq_alloc,
2304 };
2305
2306 static int tegra210_pmc_irq_set_wake(struct irq_data *data, unsigned int on)
2307 {
2308         struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2309         unsigned int offset, bit;
2310         u32 value;
2311
2312         offset = data->hwirq / 32;
2313         bit = data->hwirq % 32;
2314
2315         /* clear wake status */
2316         tegra_pmc_writel(pmc, 0, PMC_SW_WAKE_STATUS);
2317         tegra_pmc_writel(pmc, 0, PMC_SW_WAKE2_STATUS);
2318
2319         tegra_pmc_writel(pmc, 0, PMC_WAKE_STATUS);
2320         tegra_pmc_writel(pmc, 0, PMC_WAKE2_STATUS);
2321
2322         /* enable PMC wake */
2323         if (data->hwirq >= 32)
2324                 offset = PMC_WAKE2_MASK;
2325         else
2326                 offset = PMC_WAKE_MASK;
2327
2328         value = tegra_pmc_readl(pmc, offset);
2329
2330         if (on)
2331                 value |= BIT(bit);
2332         else
2333                 value &= ~BIT(bit);
2334
2335         tegra_pmc_writel(pmc, value, offset);
2336
2337         return 0;
2338 }
2339
2340 static int tegra210_pmc_irq_set_type(struct irq_data *data, unsigned int type)
2341 {
2342         struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2343         unsigned int offset, bit;
2344         u32 value;
2345
2346         offset = data->hwirq / 32;
2347         bit = data->hwirq % 32;
2348
2349         if (data->hwirq >= 32)
2350                 offset = PMC_WAKE2_LEVEL;
2351         else
2352                 offset = PMC_WAKE_LEVEL;
2353
2354         value = tegra_pmc_readl(pmc, offset);
2355
2356         switch (type) {
2357         case IRQ_TYPE_EDGE_RISING:
2358         case IRQ_TYPE_LEVEL_HIGH:
2359                 value |= BIT(bit);
2360                 break;
2361
2362         case IRQ_TYPE_EDGE_FALLING:
2363         case IRQ_TYPE_LEVEL_LOW:
2364                 value &= ~BIT(bit);
2365                 break;
2366
2367         case IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING:
2368                 value ^= BIT(bit);
2369                 break;
2370
2371         default:
2372                 return -EINVAL;
2373         }
2374
2375         tegra_pmc_writel(pmc, value, offset);
2376
2377         return 0;
2378 }
2379
2380 static void tegra186_pmc_set_wake_filters(struct tegra_pmc *pmc)
2381 {
2382         u32 value;
2383
2384         /* SW Wake (wake83) needs SR_CAPTURE filter to be enabled */
2385         value = readl(pmc->wake + WAKE_AOWAKE_CNTRL(SW_WAKE_ID));
2386         value |= WAKE_AOWAKE_CNTRL_SR_CAPTURE_EN;
2387         writel(value, pmc->wake + WAKE_AOWAKE_CNTRL(SW_WAKE_ID));
2388         dev_dbg(pmc->dev, "WAKE_AOWAKE_CNTRL_83 = 0x%x\n", value);
2389 }
2390
2391 static int tegra186_pmc_irq_set_wake(struct irq_data *data, unsigned int on)
2392 {
2393         struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2394         unsigned int offset, bit;
2395         u32 value;
2396
2397         offset = data->hwirq / 32;
2398         bit = data->hwirq % 32;
2399
2400         /* clear wake status */
2401         writel(0x1, pmc->wake + WAKE_AOWAKE_STATUS_W(data->hwirq));
2402
2403         /* route wake to tier 2 */
2404         value = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(offset));
2405
2406         if (!on)
2407                 value &= ~(1 << bit);
2408         else
2409                 value |= 1 << bit;
2410
2411         writel(value, pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(offset));
2412
2413         /* enable wakeup event */
2414         writel(!!on, pmc->wake + WAKE_AOWAKE_MASK_W(data->hwirq));
2415
2416         return 0;
2417 }
2418
2419 static int tegra186_pmc_irq_set_type(struct irq_data *data, unsigned int type)
2420 {
2421         struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2422         u32 value;
2423
2424         value = readl(pmc->wake + WAKE_AOWAKE_CNTRL(data->hwirq));
2425
2426         switch (type) {
2427         case IRQ_TYPE_EDGE_RISING:
2428         case IRQ_TYPE_LEVEL_HIGH:
2429                 value |= WAKE_AOWAKE_CNTRL_LEVEL;
2430                 set_bit(data->hwirq, pmc->wake_type_level_map);
2431                 clear_bit(data->hwirq, pmc->wake_type_dual_edge_map);
2432                 break;
2433
2434         case IRQ_TYPE_EDGE_FALLING:
2435         case IRQ_TYPE_LEVEL_LOW:
2436                 value &= ~WAKE_AOWAKE_CNTRL_LEVEL;
2437                 clear_bit(data->hwirq, pmc->wake_type_level_map);
2438                 clear_bit(data->hwirq, pmc->wake_type_dual_edge_map);
2439                 break;
2440
2441         case IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING:
2442                 value ^= WAKE_AOWAKE_CNTRL_LEVEL;
2443                 clear_bit(data->hwirq, pmc->wake_type_level_map);
2444                 set_bit(data->hwirq, pmc->wake_type_dual_edge_map);
2445                 break;
2446
2447         default:
2448                 return -EINVAL;
2449         }
2450
2451         writel(value, pmc->wake + WAKE_AOWAKE_CNTRL(data->hwirq));
2452
2453         return 0;
2454 }
2455
2456 static void tegra_irq_mask_parent(struct irq_data *data)
2457 {
2458         if (data->parent_data)
2459                 irq_chip_mask_parent(data);
2460 }
2461
2462 static void tegra_irq_unmask_parent(struct irq_data *data)
2463 {
2464         if (data->parent_data)
2465                 irq_chip_unmask_parent(data);
2466 }
2467
2468 static void tegra_irq_eoi_parent(struct irq_data *data)
2469 {
2470         if (data->parent_data)
2471                 irq_chip_eoi_parent(data);
2472 }
2473
2474 static int tegra_irq_set_affinity_parent(struct irq_data *data,
2475                                          const struct cpumask *dest,
2476                                          bool force)
2477 {
2478         if (data->parent_data)
2479                 return irq_chip_set_affinity_parent(data, dest, force);
2480
2481         return -EINVAL;
2482 }
2483
2484 static int tegra_pmc_irq_init(struct tegra_pmc *pmc)
2485 {
2486         struct irq_domain *parent = NULL;
2487         struct device_node *np;
2488
2489         np = of_irq_find_parent(pmc->dev->of_node);
2490         if (np) {
2491                 parent = irq_find_host(np);
2492                 of_node_put(np);
2493         }
2494
2495         if (!parent)
2496                 return 0;
2497
2498         pmc->irq.name = dev_name(pmc->dev);
2499         pmc->irq.irq_mask = tegra_irq_mask_parent;
2500         pmc->irq.irq_unmask = tegra_irq_unmask_parent;
2501         pmc->irq.irq_eoi = tegra_irq_eoi_parent;
2502         pmc->irq.irq_set_affinity = tegra_irq_set_affinity_parent;
2503         pmc->irq.irq_set_type = pmc->soc->irq_set_type;
2504         pmc->irq.irq_set_wake = pmc->soc->irq_set_wake;
2505
2506         pmc->domain = irq_domain_add_hierarchy(parent, 0, 96, pmc->dev->of_node,
2507                                                &tegra_pmc_irq_domain_ops, pmc);
2508         if (!pmc->domain) {
2509                 dev_err(pmc->dev, "failed to allocate domain\n");
2510                 return -ENOMEM;
2511         }
2512
2513         return 0;
2514 }
2515
2516 static int tegra_pmc_clk_notify_cb(struct notifier_block *nb,
2517                                    unsigned long action, void *ptr)
2518 {
2519         struct tegra_pmc *pmc = container_of(nb, struct tegra_pmc, clk_nb);
2520         struct clk_notifier_data *data = ptr;
2521
2522         switch (action) {
2523         case PRE_RATE_CHANGE:
2524                 mutex_lock(&pmc->powergates_lock);
2525                 break;
2526
2527         case POST_RATE_CHANGE:
2528                 pmc->rate = data->new_rate;
2529                 fallthrough;
2530
2531         case ABORT_RATE_CHANGE:
2532                 mutex_unlock(&pmc->powergates_lock);
2533                 break;
2534
2535         default:
2536                 WARN_ON_ONCE(1);
2537                 return notifier_from_errno(-EINVAL);
2538         }
2539
2540         return NOTIFY_OK;
2541 }
2542
2543 static void pmc_clk_fence_udelay(u32 offset)
2544 {
2545         tegra_pmc_readl(pmc, offset);
2546         /* pmc clk propagation delay 2 us */
2547         udelay(2);
2548 }
2549
2550 static u8 pmc_clk_mux_get_parent(struct clk_hw *hw)
2551 {
2552         struct pmc_clk *clk = to_pmc_clk(hw);
2553         u32 val;
2554
2555         val = tegra_pmc_readl(pmc, clk->offs) >> clk->mux_shift;
2556         val &= PMC_CLK_OUT_MUX_MASK;
2557
2558         return val;
2559 }
2560
2561 static int pmc_clk_mux_set_parent(struct clk_hw *hw, u8 index)
2562 {
2563         struct pmc_clk *clk = to_pmc_clk(hw);
2564         u32 val;
2565
2566         val = tegra_pmc_readl(pmc, clk->offs);
2567         val &= ~(PMC_CLK_OUT_MUX_MASK << clk->mux_shift);
2568         val |= index << clk->mux_shift;
2569         tegra_pmc_writel(pmc, val, clk->offs);
2570         pmc_clk_fence_udelay(clk->offs);
2571
2572         return 0;
2573 }
2574
2575 static int pmc_clk_is_enabled(struct clk_hw *hw)
2576 {
2577         struct pmc_clk *clk = to_pmc_clk(hw);
2578         u32 val;
2579
2580         val = tegra_pmc_readl(pmc, clk->offs) & BIT(clk->force_en_shift);
2581
2582         return val ? 1 : 0;
2583 }
2584
2585 static void pmc_clk_set_state(unsigned long offs, u32 shift, int state)
2586 {
2587         u32 val;
2588
2589         val = tegra_pmc_readl(pmc, offs);
2590         val = state ? (val | BIT(shift)) : (val & ~BIT(shift));
2591         tegra_pmc_writel(pmc, val, offs);
2592         pmc_clk_fence_udelay(offs);
2593 }
2594
2595 static int pmc_clk_enable(struct clk_hw *hw)
2596 {
2597         struct pmc_clk *clk = to_pmc_clk(hw);
2598
2599         pmc_clk_set_state(clk->offs, clk->force_en_shift, 1);
2600
2601         return 0;
2602 }
2603
2604 static void pmc_clk_disable(struct clk_hw *hw)
2605 {
2606         struct pmc_clk *clk = to_pmc_clk(hw);
2607
2608         pmc_clk_set_state(clk->offs, clk->force_en_shift, 0);
2609 }
2610
2611 static const struct clk_ops pmc_clk_ops = {
2612         .get_parent = pmc_clk_mux_get_parent,
2613         .set_parent = pmc_clk_mux_set_parent,
2614         .determine_rate = __clk_mux_determine_rate,
2615         .is_enabled = pmc_clk_is_enabled,
2616         .enable = pmc_clk_enable,
2617         .disable = pmc_clk_disable,
2618 };
2619
2620 static struct clk *
2621 tegra_pmc_clk_out_register(struct tegra_pmc *pmc,
2622                            const struct pmc_clk_init_data *data,
2623                            unsigned long offset)
2624 {
2625         struct clk_init_data init;
2626         struct pmc_clk *pmc_clk;
2627
2628         pmc_clk = devm_kzalloc(pmc->dev, sizeof(*pmc_clk), GFP_KERNEL);
2629         if (!pmc_clk)
2630                 return ERR_PTR(-ENOMEM);
2631
2632         init.name = data->name;
2633         init.ops = &pmc_clk_ops;
2634         init.parent_names = data->parents;
2635         init.num_parents = data->num_parents;
2636         init.flags = CLK_SET_RATE_NO_REPARENT | CLK_SET_RATE_PARENT |
2637                      CLK_SET_PARENT_GATE;
2638
2639         pmc_clk->hw.init = &init;
2640         pmc_clk->offs = offset;
2641         pmc_clk->mux_shift = data->mux_shift;
2642         pmc_clk->force_en_shift = data->force_en_shift;
2643
2644         return clk_register(NULL, &pmc_clk->hw);
2645 }
2646
2647 static int pmc_clk_gate_is_enabled(struct clk_hw *hw)
2648 {
2649         struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2650
2651         return tegra_pmc_readl(pmc, gate->offs) & BIT(gate->shift) ? 1 : 0;
2652 }
2653
2654 static int pmc_clk_gate_enable(struct clk_hw *hw)
2655 {
2656         struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2657
2658         pmc_clk_set_state(gate->offs, gate->shift, 1);
2659
2660         return 0;
2661 }
2662
2663 static void pmc_clk_gate_disable(struct clk_hw *hw)
2664 {
2665         struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2666
2667         pmc_clk_set_state(gate->offs, gate->shift, 0);
2668 }
2669
2670 static const struct clk_ops pmc_clk_gate_ops = {
2671         .is_enabled = pmc_clk_gate_is_enabled,
2672         .enable = pmc_clk_gate_enable,
2673         .disable = pmc_clk_gate_disable,
2674 };
2675
2676 static struct clk *
2677 tegra_pmc_clk_gate_register(struct tegra_pmc *pmc, const char *name,
2678                             const char *parent_name, unsigned long offset,
2679                             u32 shift)
2680 {
2681         struct clk_init_data init;
2682         struct pmc_clk_gate *gate;
2683
2684         gate = devm_kzalloc(pmc->dev, sizeof(*gate), GFP_KERNEL);
2685         if (!gate)
2686                 return ERR_PTR(-ENOMEM);
2687
2688         init.name = name;
2689         init.ops = &pmc_clk_gate_ops;
2690         init.parent_names = &parent_name;
2691         init.num_parents = 1;
2692         init.flags = 0;
2693
2694         gate->hw.init = &init;
2695         gate->offs = offset;
2696         gate->shift = shift;
2697
2698         return clk_register(NULL, &gate->hw);
2699 }
2700
2701 static void tegra_pmc_clock_register(struct tegra_pmc *pmc,
2702                                      struct device_node *np)
2703 {
2704         struct clk *clk;
2705         struct clk_onecell_data *clk_data;
2706         unsigned int num_clks;
2707         int i, err;
2708
2709         num_clks = pmc->soc->num_pmc_clks;
2710         if (pmc->soc->has_blink_output)
2711                 num_clks += 1;
2712
2713         if (!num_clks)
2714                 return;
2715
2716         clk_data = devm_kmalloc(pmc->dev, sizeof(*clk_data), GFP_KERNEL);
2717         if (!clk_data)
2718                 return;
2719
2720         clk_data->clks = devm_kcalloc(pmc->dev, TEGRA_PMC_CLK_MAX,
2721                                       sizeof(*clk_data->clks), GFP_KERNEL);
2722         if (!clk_data->clks)
2723                 return;
2724
2725         clk_data->clk_num = TEGRA_PMC_CLK_MAX;
2726
2727         for (i = 0; i < TEGRA_PMC_CLK_MAX; i++)
2728                 clk_data->clks[i] = ERR_PTR(-ENOENT);
2729
2730         for (i = 0; i < pmc->soc->num_pmc_clks; i++) {
2731                 const struct pmc_clk_init_data *data;
2732
2733                 data = pmc->soc->pmc_clks_data + i;
2734
2735                 clk = tegra_pmc_clk_out_register(pmc, data, PMC_CLK_OUT_CNTRL);
2736                 if (IS_ERR(clk)) {
2737                         dev_warn(pmc->dev, "unable to register clock %s: %d\n",
2738                                  data->name, PTR_ERR_OR_ZERO(clk));
2739                         return;
2740                 }
2741
2742                 err = clk_register_clkdev(clk, data->name, NULL);
2743                 if (err) {
2744                         dev_warn(pmc->dev,
2745                                  "unable to register %s clock lookup: %d\n",
2746                                  data->name, err);
2747                         return;
2748                 }
2749
2750                 clk_data->clks[data->clk_id] = clk;
2751         }
2752
2753         if (pmc->soc->has_blink_output) {
2754                 tegra_pmc_writel(pmc, 0x0, PMC_BLINK_TIMER);
2755                 clk = tegra_pmc_clk_gate_register(pmc,
2756                                                   "pmc_blink_override",
2757                                                   "clk_32k",
2758                                                   PMC_DPD_PADS_ORIDE,
2759                                                   PMC_DPD_PADS_ORIDE_BLINK);
2760                 if (IS_ERR(clk)) {
2761                         dev_warn(pmc->dev,
2762                                  "unable to register pmc_blink_override: %d\n",
2763                                  PTR_ERR_OR_ZERO(clk));
2764                         return;
2765                 }
2766
2767                 clk = tegra_pmc_clk_gate_register(pmc, "pmc_blink",
2768                                                   "pmc_blink_override",
2769                                                   PMC_CNTRL,
2770                                                   PMC_CNTRL_BLINK_EN);
2771                 if (IS_ERR(clk)) {
2772                         dev_warn(pmc->dev,
2773                                  "unable to register pmc_blink: %d\n",
2774                                  PTR_ERR_OR_ZERO(clk));
2775                         return;
2776                 }
2777
2778                 err = clk_register_clkdev(clk, "pmc_blink", NULL);
2779                 if (err) {
2780                         dev_warn(pmc->dev,
2781                                  "unable to register pmc_blink lookup: %d\n",
2782                                  err);
2783                         return;
2784                 }
2785
2786                 clk_data->clks[TEGRA_PMC_CLK_BLINK] = clk;
2787         }
2788
2789         err = of_clk_add_provider(np, of_clk_src_onecell_get, clk_data);
2790         if (err)
2791                 dev_warn(pmc->dev, "failed to add pmc clock provider: %d\n",
2792                          err);
2793 }
2794
2795 static const struct regmap_range pmc_usb_sleepwalk_ranges[] = {
2796         regmap_reg_range(PMC_USB_DEBOUNCE_DEL, PMC_USB_AO),
2797         regmap_reg_range(PMC_UTMIP_UHSIC_TRIGGERS, PMC_UTMIP_UHSIC_SAVED_STATE),
2798         regmap_reg_range(PMC_UTMIP_TERM_PAD_CFG, PMC_UTMIP_UHSIC_FAKE),
2799         regmap_reg_range(PMC_UTMIP_UHSIC_LINE_WAKEUP, PMC_UTMIP_UHSIC_LINE_WAKEUP),
2800         regmap_reg_range(PMC_UTMIP_BIAS_MASTER_CNTRL, PMC_UTMIP_MASTER_CONFIG),
2801         regmap_reg_range(PMC_UTMIP_UHSIC2_TRIGGERS, PMC_UTMIP_MASTER2_CONFIG),
2802         regmap_reg_range(PMC_UTMIP_PAD_CFG0, PMC_UTMIP_UHSIC_SLEEP_CFG1),
2803         regmap_reg_range(PMC_UTMIP_SLEEPWALK_P3, PMC_UTMIP_SLEEPWALK_P3),
2804 };
2805
2806 static const struct regmap_access_table pmc_usb_sleepwalk_table = {
2807         .yes_ranges = pmc_usb_sleepwalk_ranges,
2808         .n_yes_ranges = ARRAY_SIZE(pmc_usb_sleepwalk_ranges),
2809 };
2810
2811 static int tegra_pmc_regmap_readl(void *context, unsigned int offset, unsigned int *value)
2812 {
2813         struct tegra_pmc *pmc = context;
2814
2815         *value = tegra_pmc_readl(pmc, offset);
2816         return 0;
2817 }
2818
2819 static int tegra_pmc_regmap_writel(void *context, unsigned int offset, unsigned int value)
2820 {
2821         struct tegra_pmc *pmc = context;
2822
2823         tegra_pmc_writel(pmc, value, offset);
2824         return 0;
2825 }
2826
2827 static const struct regmap_config usb_sleepwalk_regmap_config = {
2828         .name = "usb_sleepwalk",
2829         .reg_bits = 32,
2830         .val_bits = 32,
2831         .reg_stride = 4,
2832         .fast_io = true,
2833         .rd_table = &pmc_usb_sleepwalk_table,
2834         .wr_table = &pmc_usb_sleepwalk_table,
2835         .reg_read = tegra_pmc_regmap_readl,
2836         .reg_write = tegra_pmc_regmap_writel,
2837 };
2838
2839 static int tegra_pmc_regmap_init(struct tegra_pmc *pmc)
2840 {
2841         struct regmap *regmap;
2842         int err;
2843
2844         if (pmc->soc->has_usb_sleepwalk) {
2845                 regmap = devm_regmap_init(pmc->dev, NULL, pmc, &usb_sleepwalk_regmap_config);
2846                 if (IS_ERR(regmap)) {
2847                         err = PTR_ERR(regmap);
2848                         dev_err(pmc->dev, "failed to allocate register map (%d)\n", err);
2849                         return err;
2850                 }
2851         }
2852
2853         return 0;
2854 }
2855
2856 static void tegra_pmc_reset_suspend_mode(void *data)
2857 {
2858         pmc->suspend_mode = TEGRA_SUSPEND_NOT_READY;
2859 }
2860
2861 static int tegra_pmc_probe(struct platform_device *pdev)
2862 {
2863         void __iomem *base;
2864         struct resource *res;
2865         int err;
2866
2867         /*
2868          * Early initialisation should have configured an initial
2869          * register mapping and setup the soc data pointer. If these
2870          * are not valid then something went badly wrong!
2871          */
2872         if (WARN_ON(!pmc->base || !pmc->soc))
2873                 return -ENODEV;
2874
2875         err = tegra_pmc_parse_dt(pmc, pdev->dev.of_node);
2876         if (err < 0)
2877                 return err;
2878
2879         err = devm_add_action_or_reset(&pdev->dev, tegra_pmc_reset_suspend_mode,
2880                                        NULL);
2881         if (err)
2882                 return err;
2883
2884         /* take over the memory region from the early initialization */
2885         base = devm_platform_ioremap_resource(pdev, 0);
2886         if (IS_ERR(base))
2887                 return PTR_ERR(base);
2888
2889         if (pmc->soc->has_single_mmio_aperture) {
2890                 pmc->wake = base;
2891                 pmc->aotag = base;
2892                 pmc->scratch = base;
2893         } else {
2894                 pmc->wake = devm_platform_ioremap_resource_byname(pdev, "wake");
2895                 if (IS_ERR(pmc->wake))
2896                         return PTR_ERR(pmc->wake);
2897
2898                 pmc->aotag = devm_platform_ioremap_resource_byname(pdev, "aotag");
2899                 if (IS_ERR(pmc->aotag))
2900                         return PTR_ERR(pmc->aotag);
2901
2902                 /* "scratch" is an optional aperture */
2903                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
2904                                                 "scratch");
2905                 if (res) {
2906                         pmc->scratch = devm_ioremap_resource(&pdev->dev, res);
2907                         if (IS_ERR(pmc->scratch))
2908                                 return PTR_ERR(pmc->scratch);
2909                 } else {
2910                         pmc->scratch = NULL;
2911                 }
2912         }
2913
2914         pmc->clk = devm_clk_get_optional(&pdev->dev, "pclk");
2915         if (IS_ERR(pmc->clk))
2916                 return dev_err_probe(&pdev->dev, PTR_ERR(pmc->clk),
2917                                      "failed to get pclk\n");
2918
2919         /*
2920          * PMC should be last resort for restarting since it soft-resets
2921          * CPU without resetting everything else.
2922          */
2923         if (pmc->scratch) {
2924                 err = devm_register_reboot_notifier(&pdev->dev,
2925                                                     &tegra_pmc_reboot_notifier);
2926                 if (err) {
2927                         dev_err(&pdev->dev,
2928                                 "unable to register reboot notifier, %d\n",
2929                                 err);
2930                         return err;
2931                 }
2932         }
2933
2934         err = devm_register_sys_off_handler(&pdev->dev,
2935                                             SYS_OFF_MODE_RESTART,
2936                                             SYS_OFF_PRIO_LOW,
2937                                             tegra_pmc_restart_handler, NULL);
2938         if (err) {
2939                 dev_err(&pdev->dev, "failed to register sys-off handler: %d\n",
2940                         err);
2941                 return err;
2942         }
2943
2944         /*
2945          * PMC should be primary power-off method if it soft-resets CPU,
2946          * asking bootloader to shutdown hardware.
2947          */
2948         err = devm_register_sys_off_handler(&pdev->dev,
2949                                             SYS_OFF_MODE_POWER_OFF,
2950                                             SYS_OFF_PRIO_FIRMWARE,
2951                                             tegra_pmc_power_off_handler, NULL);
2952         if (err) {
2953                 dev_err(&pdev->dev, "failed to register sys-off handler: %d\n",
2954                         err);
2955                 return err;
2956         }
2957
2958         /*
2959          * PCLK clock rate can't be retrieved using CLK API because it
2960          * causes lockup if CPU enters LP2 idle state from some other
2961          * CLK notifier, hence we're caching the rate's value locally.
2962          */
2963         if (pmc->clk) {
2964                 pmc->clk_nb.notifier_call = tegra_pmc_clk_notify_cb;
2965                 err = devm_clk_notifier_register(&pdev->dev, pmc->clk,
2966                                                  &pmc->clk_nb);
2967                 if (err) {
2968                         dev_err(&pdev->dev,
2969                                 "failed to register clk notifier\n");
2970                         return err;
2971                 }
2972
2973                 pmc->rate = clk_get_rate(pmc->clk);
2974         }
2975
2976         pmc->dev = &pdev->dev;
2977
2978         err = tegra_pmc_init(pmc);
2979         if (err < 0) {
2980                 dev_err(&pdev->dev, "failed to initialize PMC: %d\n", err);
2981                 return err;
2982         }
2983
2984         tegra_pmc_init_tsense_reset(pmc);
2985
2986         tegra_pmc_reset_sysfs_init(pmc);
2987
2988         err = tegra_pmc_pinctrl_init(pmc);
2989         if (err)
2990                 goto cleanup_sysfs;
2991
2992         err = tegra_pmc_regmap_init(pmc);
2993         if (err < 0)
2994                 goto cleanup_sysfs;
2995
2996         err = tegra_powergate_init(pmc, pdev->dev.of_node);
2997         if (err < 0)
2998                 goto cleanup_powergates;
2999
3000         err = tegra_pmc_irq_init(pmc);
3001         if (err < 0)
3002                 goto cleanup_powergates;
3003
3004         mutex_lock(&pmc->powergates_lock);
3005         iounmap(pmc->base);
3006         pmc->base = base;
3007         mutex_unlock(&pmc->powergates_lock);
3008
3009         tegra_pmc_clock_register(pmc, pdev->dev.of_node);
3010         platform_set_drvdata(pdev, pmc);
3011         tegra_pm_init_suspend();
3012
3013         /* Some wakes require specific filter configuration */
3014         if (pmc->soc->set_wake_filters)
3015                 pmc->soc->set_wake_filters(pmc);
3016
3017         debugfs_create_file("powergate", 0444, NULL, NULL, &powergate_fops);
3018
3019         return 0;
3020
3021 cleanup_powergates:
3022         tegra_powergate_remove_all(pdev->dev.of_node);
3023 cleanup_sysfs:
3024         device_remove_file(&pdev->dev, &dev_attr_reset_reason);
3025         device_remove_file(&pdev->dev, &dev_attr_reset_level);
3026
3027         return err;
3028 }
3029
3030 /*
3031  * Ensures that sufficient time is passed for a register write to
3032  * serialize into the 32KHz domain.
3033  */
3034 static void wke_32kwritel(struct tegra_pmc *pmc, u32 value, unsigned int offset)
3035 {
3036         writel(value, pmc->wake + offset);
3037         udelay(130);
3038 }
3039
3040 static void wke_write_wake_level(struct tegra_pmc *pmc, int wake, int level)
3041 {
3042         unsigned int offset = WAKE_AOWAKE_CNTRL(wake);
3043         u32 value;
3044
3045         value = readl(pmc->wake + offset);
3046         if (level)
3047                 value |= WAKE_AOWAKE_CNTRL_LEVEL;
3048         else
3049                 value &= ~WAKE_AOWAKE_CNTRL_LEVEL;
3050
3051         writel(value, pmc->wake + offset);
3052 }
3053
3054 static void wke_write_wake_levels(struct tegra_pmc *pmc)
3055 {
3056         unsigned int i;
3057
3058         for (i = 0; i < pmc->soc->max_wake_events; i++)
3059                 wke_write_wake_level(pmc, i, test_bit(i, pmc->wake_cntrl_level_map));
3060 }
3061
3062 static void wke_clear_sw_wake_status(struct tegra_pmc *pmc)
3063 {
3064         wke_32kwritel(pmc, 1, WAKE_AOWAKE_SW_STATUS_W_0);
3065 }
3066
3067 static void wke_read_sw_wake_status(struct tegra_pmc *pmc)
3068 {
3069         unsigned long status;
3070         unsigned int wake, i;
3071
3072         for (i = 0; i < pmc->soc->max_wake_events; i++)
3073                 wke_write_wake_level(pmc, i, 0);
3074
3075         wke_clear_sw_wake_status(pmc);
3076
3077         wke_32kwritel(pmc, 1, WAKE_LATCH_SW);
3078
3079         /*
3080          * WAKE_AOWAKE_SW_STATUS is edge triggered, so in order to
3081          * obtain the current status of the input wake signals, change
3082          * the polarity of the wake level from 0->1 while latching to force
3083          * a positive edge if the sampled signal is '1'.
3084          */
3085         for (i = 0; i < pmc->soc->max_wake_events; i++)
3086                 wke_write_wake_level(pmc, i, 1);
3087
3088         /*
3089          * Wait for the update to be synced into the 32kHz domain,
3090          * and let enough time lapse, so that the wake signals have time to
3091          * be sampled.
3092          */
3093         udelay(300);
3094
3095         wke_32kwritel(pmc, 0, WAKE_LATCH_SW);
3096
3097         bitmap_zero(pmc->wake_sw_status_map, pmc->soc->max_wake_events);
3098
3099         for (i = 0; i < pmc->soc->max_wake_vectors; i++) {
3100                 status = readl(pmc->wake + WAKE_AOWAKE_SW_STATUS(i));
3101
3102                 for_each_set_bit(wake, &status, 32)
3103                         set_bit(wake + (i * 32), pmc->wake_sw_status_map);
3104         }
3105 }
3106
3107 static void wke_clear_wake_status(struct tegra_pmc *pmc)
3108 {
3109         unsigned long status;
3110         unsigned int i, wake;
3111         u32 mask;
3112
3113         for (i = 0; i < pmc->soc->max_wake_vectors; i++) {
3114                 mask = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(i));
3115                 status = readl(pmc->wake + WAKE_AOWAKE_STATUS_R(i)) & mask;
3116
3117                 for_each_set_bit(wake, &status, 32)
3118                         wke_32kwritel(pmc, 0x1, WAKE_AOWAKE_STATUS_W((i * 32) + wake));
3119         }
3120 }
3121
3122 /* translate sc7 wake sources back into IRQs to catch edge triggered wakeups */
3123 static void tegra186_pmc_process_wake_events(struct tegra_pmc *pmc, unsigned int index,
3124                                              unsigned long status)
3125 {
3126         unsigned int wake;
3127
3128         dev_dbg(pmc->dev, "Wake[%d:%d]  status=%#lx\n", (index * 32) + 31, index * 32, status);
3129
3130         for_each_set_bit(wake, &status, 32) {
3131                 irq_hw_number_t hwirq = wake + 32 * index;
3132                 struct irq_desc *desc;
3133                 unsigned int irq;
3134
3135                 irq = irq_find_mapping(pmc->domain, hwirq);
3136
3137                 desc = irq_to_desc(irq);
3138                 if (!desc || !desc->action || !desc->action->name) {
3139                         dev_dbg(pmc->dev, "Resume caused by WAKE%ld, IRQ %d\n", hwirq, irq);
3140                         continue;
3141                 }
3142
3143                 dev_dbg(pmc->dev, "Resume caused by WAKE%ld, %s\n", hwirq, desc->action->name);
3144                 generic_handle_irq(irq);
3145         }
3146 }
3147
3148 static void tegra186_pmc_wake_syscore_resume(void)
3149 {
3150         u32 status, mask;
3151         unsigned int i;
3152
3153         for (i = 0; i < pmc->soc->max_wake_vectors; i++) {
3154                 mask = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(i));
3155                 status = readl(pmc->wake + WAKE_AOWAKE_STATUS_R(i)) & mask;
3156
3157                 tegra186_pmc_process_wake_events(pmc, i, status);
3158         }
3159 }
3160
3161 static int tegra186_pmc_wake_syscore_suspend(void)
3162 {
3163         wke_read_sw_wake_status(pmc);
3164
3165         /* flip the wakeup trigger for dual-edge triggered pads
3166          * which are currently asserting as wakeups
3167          */
3168         bitmap_andnot(pmc->wake_cntrl_level_map, pmc->wake_type_dual_edge_map,
3169                       pmc->wake_sw_status_map, pmc->soc->max_wake_events);
3170         bitmap_or(pmc->wake_cntrl_level_map, pmc->wake_cntrl_level_map,
3171                   pmc->wake_type_level_map, pmc->soc->max_wake_events);
3172
3173         /* Clear PMC Wake Status registers while going to suspend */
3174         wke_clear_wake_status(pmc);
3175         wke_write_wake_levels(pmc);
3176
3177         return 0;
3178 }
3179
3180 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_ARM)
3181 static int tegra_pmc_suspend(struct device *dev)
3182 {
3183         struct tegra_pmc *pmc = dev_get_drvdata(dev);
3184
3185         tegra_pmc_writel(pmc, virt_to_phys(tegra_resume), PMC_SCRATCH41);
3186
3187         return 0;
3188 }
3189
3190 static int tegra_pmc_resume(struct device *dev)
3191 {
3192         struct tegra_pmc *pmc = dev_get_drvdata(dev);
3193
3194         tegra_pmc_writel(pmc, 0x0, PMC_SCRATCH41);
3195
3196         return 0;
3197 }
3198
3199 static SIMPLE_DEV_PM_OPS(tegra_pmc_pm_ops, tegra_pmc_suspend, tegra_pmc_resume);
3200
3201 #endif
3202
3203 static const char * const tegra20_powergates[] = {
3204         [TEGRA_POWERGATE_CPU] = "cpu",
3205         [TEGRA_POWERGATE_3D] = "td",
3206         [TEGRA_POWERGATE_VENC] = "venc",
3207         [TEGRA_POWERGATE_VDEC] = "vdec",
3208         [TEGRA_POWERGATE_PCIE] = "pcie",
3209         [TEGRA_POWERGATE_L2] = "l2",
3210         [TEGRA_POWERGATE_MPE] = "mpe",
3211 };
3212
3213 static const struct tegra_pmc_regs tegra20_pmc_regs = {
3214         .scratch0 = 0x50,
3215         .rst_status = 0x1b4,
3216         .rst_source_shift = 0x0,
3217         .rst_source_mask = 0x7,
3218         .rst_level_shift = 0x0,
3219         .rst_level_mask = 0x0,
3220 };
3221
3222 static void tegra20_pmc_init(struct tegra_pmc *pmc)
3223 {
3224         u32 value, osc, pmu, off;
3225
3226         /* Always enable CPU power request */
3227         value = tegra_pmc_readl(pmc, PMC_CNTRL);
3228         value |= PMC_CNTRL_CPU_PWRREQ_OE;
3229         tegra_pmc_writel(pmc, value, PMC_CNTRL);
3230
3231         value = tegra_pmc_readl(pmc, PMC_CNTRL);
3232
3233         if (pmc->sysclkreq_high)
3234                 value &= ~PMC_CNTRL_SYSCLK_POLARITY;
3235         else
3236                 value |= PMC_CNTRL_SYSCLK_POLARITY;
3237
3238         if (pmc->corereq_high)
3239                 value &= ~PMC_CNTRL_PWRREQ_POLARITY;
3240         else
3241                 value |= PMC_CNTRL_PWRREQ_POLARITY;
3242
3243         /* configure the output polarity while the request is tristated */
3244         tegra_pmc_writel(pmc, value, PMC_CNTRL);
3245
3246         /* now enable the request */
3247         value = tegra_pmc_readl(pmc, PMC_CNTRL);
3248         value |= PMC_CNTRL_SYSCLK_OE;
3249         tegra_pmc_writel(pmc, value, PMC_CNTRL);
3250
3251         /* program core timings which are applicable only for suspend state */
3252         if (pmc->suspend_mode != TEGRA_SUSPEND_NONE) {
3253                 osc = DIV_ROUND_UP(pmc->core_osc_time * 8192, 1000000);
3254                 pmu = DIV_ROUND_UP(pmc->core_pmu_time * 32768, 1000000);
3255                 off = DIV_ROUND_UP(pmc->core_off_time * 32768, 1000000);
3256                 tegra_pmc_writel(pmc, ((osc << 8) & 0xff00) | (pmu & 0xff),
3257                                  PMC_COREPWRGOOD_TIMER);
3258                 tegra_pmc_writel(pmc, off, PMC_COREPWROFF_TIMER);
3259         }
3260 }
3261
3262 static void tegra20_pmc_setup_irq_polarity(struct tegra_pmc *pmc,
3263                                            struct device_node *np,
3264                                            bool invert)
3265 {
3266         u32 value;
3267
3268         value = tegra_pmc_readl(pmc, PMC_CNTRL);
3269
3270         if (invert)
3271                 value |= PMC_CNTRL_INTR_POLARITY;
3272         else
3273                 value &= ~PMC_CNTRL_INTR_POLARITY;
3274
3275         tegra_pmc_writel(pmc, value, PMC_CNTRL);
3276 }
3277
3278 static const struct tegra_pmc_soc tegra20_pmc_soc = {
3279         .supports_core_domain = true,
3280         .num_powergates = ARRAY_SIZE(tegra20_powergates),
3281         .powergates = tegra20_powergates,
3282         .num_cpu_powergates = 0,
3283         .cpu_powergates = NULL,
3284         .has_tsense_reset = false,
3285         .has_gpu_clamps = false,
3286         .needs_mbist_war = false,
3287         .has_impl_33v_pwr = false,
3288         .maybe_tz_only = false,
3289         .num_io_pads = 0,
3290         .io_pads = NULL,
3291         .num_pin_descs = 0,
3292         .pin_descs = NULL,
3293         .regs = &tegra20_pmc_regs,
3294         .init = tegra20_pmc_init,
3295         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3296         .powergate_set = tegra20_powergate_set,
3297         .reset_sources = NULL,
3298         .num_reset_sources = 0,
3299         .reset_levels = NULL,
3300         .num_reset_levels = 0,
3301         .pmc_clks_data = NULL,
3302         .num_pmc_clks = 0,
3303         .has_blink_output = true,
3304         .has_usb_sleepwalk = true,
3305         .has_single_mmio_aperture = true,
3306 };
3307
3308 static const char * const tegra30_powergates[] = {
3309         [TEGRA_POWERGATE_CPU] = "cpu0",
3310         [TEGRA_POWERGATE_3D] = "td",
3311         [TEGRA_POWERGATE_VENC] = "venc",
3312         [TEGRA_POWERGATE_VDEC] = "vdec",
3313         [TEGRA_POWERGATE_PCIE] = "pcie",
3314         [TEGRA_POWERGATE_L2] = "l2",
3315         [TEGRA_POWERGATE_MPE] = "mpe",
3316         [TEGRA_POWERGATE_HEG] = "heg",
3317         [TEGRA_POWERGATE_SATA] = "sata",
3318         [TEGRA_POWERGATE_CPU1] = "cpu1",
3319         [TEGRA_POWERGATE_CPU2] = "cpu2",
3320         [TEGRA_POWERGATE_CPU3] = "cpu3",
3321         [TEGRA_POWERGATE_CELP] = "celp",
3322         [TEGRA_POWERGATE_3D1] = "td2",
3323 };
3324
3325 static const u8 tegra30_cpu_powergates[] = {
3326         TEGRA_POWERGATE_CPU,
3327         TEGRA_POWERGATE_CPU1,
3328         TEGRA_POWERGATE_CPU2,
3329         TEGRA_POWERGATE_CPU3,
3330 };
3331
3332 static const char * const tegra30_reset_sources[] = {
3333         "POWER_ON_RESET",
3334         "WATCHDOG",
3335         "SENSOR",
3336         "SW_MAIN",
3337         "LP0"
3338 };
3339
3340 static const struct tegra_pmc_soc tegra30_pmc_soc = {
3341         .supports_core_domain = true,
3342         .num_powergates = ARRAY_SIZE(tegra30_powergates),
3343         .powergates = tegra30_powergates,
3344         .num_cpu_powergates = ARRAY_SIZE(tegra30_cpu_powergates),
3345         .cpu_powergates = tegra30_cpu_powergates,
3346         .has_tsense_reset = true,
3347         .has_gpu_clamps = false,
3348         .needs_mbist_war = false,
3349         .has_impl_33v_pwr = false,
3350         .maybe_tz_only = false,
3351         .num_io_pads = 0,
3352         .io_pads = NULL,
3353         .num_pin_descs = 0,
3354         .pin_descs = NULL,
3355         .regs = &tegra20_pmc_regs,
3356         .init = tegra20_pmc_init,
3357         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3358         .powergate_set = tegra20_powergate_set,
3359         .reset_sources = tegra30_reset_sources,
3360         .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
3361         .reset_levels = NULL,
3362         .num_reset_levels = 0,
3363         .pmc_clks_data = tegra_pmc_clks_data,
3364         .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3365         .has_blink_output = true,
3366         .has_usb_sleepwalk = true,
3367         .has_single_mmio_aperture = true,
3368 };
3369
3370 static const char * const tegra114_powergates[] = {
3371         [TEGRA_POWERGATE_CPU] = "crail",
3372         [TEGRA_POWERGATE_3D] = "td",
3373         [TEGRA_POWERGATE_VENC] = "venc",
3374         [TEGRA_POWERGATE_VDEC] = "vdec",
3375         [TEGRA_POWERGATE_MPE] = "mpe",
3376         [TEGRA_POWERGATE_HEG] = "heg",
3377         [TEGRA_POWERGATE_CPU1] = "cpu1",
3378         [TEGRA_POWERGATE_CPU2] = "cpu2",
3379         [TEGRA_POWERGATE_CPU3] = "cpu3",
3380         [TEGRA_POWERGATE_CELP] = "celp",
3381         [TEGRA_POWERGATE_CPU0] = "cpu0",
3382         [TEGRA_POWERGATE_C0NC] = "c0nc",
3383         [TEGRA_POWERGATE_C1NC] = "c1nc",
3384         [TEGRA_POWERGATE_DIS] = "dis",
3385         [TEGRA_POWERGATE_DISB] = "disb",
3386         [TEGRA_POWERGATE_XUSBA] = "xusba",
3387         [TEGRA_POWERGATE_XUSBB] = "xusbb",
3388         [TEGRA_POWERGATE_XUSBC] = "xusbc",
3389 };
3390
3391 static const u8 tegra114_cpu_powergates[] = {
3392         TEGRA_POWERGATE_CPU0,
3393         TEGRA_POWERGATE_CPU1,
3394         TEGRA_POWERGATE_CPU2,
3395         TEGRA_POWERGATE_CPU3,
3396 };
3397
3398 static const struct tegra_pmc_soc tegra114_pmc_soc = {
3399         .supports_core_domain = false,
3400         .num_powergates = ARRAY_SIZE(tegra114_powergates),
3401         .powergates = tegra114_powergates,
3402         .num_cpu_powergates = ARRAY_SIZE(tegra114_cpu_powergates),
3403         .cpu_powergates = tegra114_cpu_powergates,
3404         .has_tsense_reset = true,
3405         .has_gpu_clamps = false,
3406         .needs_mbist_war = false,
3407         .has_impl_33v_pwr = false,
3408         .maybe_tz_only = false,
3409         .num_io_pads = 0,
3410         .io_pads = NULL,
3411         .num_pin_descs = 0,
3412         .pin_descs = NULL,
3413         .regs = &tegra20_pmc_regs,
3414         .init = tegra20_pmc_init,
3415         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3416         .powergate_set = tegra114_powergate_set,
3417         .reset_sources = tegra30_reset_sources,
3418         .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
3419         .reset_levels = NULL,
3420         .num_reset_levels = 0,
3421         .pmc_clks_data = tegra_pmc_clks_data,
3422         .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3423         .has_blink_output = true,
3424         .has_usb_sleepwalk = true,
3425         .has_single_mmio_aperture = true,
3426 };
3427
3428 static const char * const tegra124_powergates[] = {
3429         [TEGRA_POWERGATE_CPU] = "crail",
3430         [TEGRA_POWERGATE_3D] = "3d",
3431         [TEGRA_POWERGATE_VENC] = "venc",
3432         [TEGRA_POWERGATE_PCIE] = "pcie",
3433         [TEGRA_POWERGATE_VDEC] = "vdec",
3434         [TEGRA_POWERGATE_MPE] = "mpe",
3435         [TEGRA_POWERGATE_HEG] = "heg",
3436         [TEGRA_POWERGATE_SATA] = "sata",
3437         [TEGRA_POWERGATE_CPU1] = "cpu1",
3438         [TEGRA_POWERGATE_CPU2] = "cpu2",
3439         [TEGRA_POWERGATE_CPU3] = "cpu3",
3440         [TEGRA_POWERGATE_CELP] = "celp",
3441         [TEGRA_POWERGATE_CPU0] = "cpu0",
3442         [TEGRA_POWERGATE_C0NC] = "c0nc",
3443         [TEGRA_POWERGATE_C1NC] = "c1nc",
3444         [TEGRA_POWERGATE_SOR] = "sor",
3445         [TEGRA_POWERGATE_DIS] = "dis",
3446         [TEGRA_POWERGATE_DISB] = "disb",
3447         [TEGRA_POWERGATE_XUSBA] = "xusba",
3448         [TEGRA_POWERGATE_XUSBB] = "xusbb",
3449         [TEGRA_POWERGATE_XUSBC] = "xusbc",
3450         [TEGRA_POWERGATE_VIC] = "vic",
3451         [TEGRA_POWERGATE_IRAM] = "iram",
3452 };
3453
3454 static const u8 tegra124_cpu_powergates[] = {
3455         TEGRA_POWERGATE_CPU0,
3456         TEGRA_POWERGATE_CPU1,
3457         TEGRA_POWERGATE_CPU2,
3458         TEGRA_POWERGATE_CPU3,
3459 };
3460
3461 #define TEGRA_IO_PAD(_id, _dpd, _request, _status, _voltage, _name)     \
3462         ((struct tegra_io_pad_soc) {                                    \
3463                 .id             = (_id),                                \
3464                 .dpd            = (_dpd),                               \
3465                 .request        = (_request),                           \
3466                 .status         = (_status),                            \
3467                 .voltage        = (_voltage),                           \
3468                 .name           = (_name),                              \
3469         })
3470
3471 #define TEGRA_IO_PIN_DESC(_id, _name)   \
3472         ((struct pinctrl_pin_desc) {    \
3473                 .number = (_id),        \
3474                 .name   = (_name),      \
3475         })
3476
3477 static const struct tegra_io_pad_soc tegra124_io_pads[] = {
3478         TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO, 17, 0x1b8, 0x1bc, UINT_MAX, "audio"),
3479         TEGRA_IO_PAD(TEGRA_IO_PAD_BB, 15, 0x1b8, 0x1bc, UINT_MAX, "bb"),
3480         TEGRA_IO_PAD(TEGRA_IO_PAD_CAM, 4, 0x1c0, 0x1c4, UINT_MAX, "cam"),
3481         TEGRA_IO_PAD(TEGRA_IO_PAD_COMP, 22, 0x1b8, 0x1bc, UINT_MAX, "comp"),
3482         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0x1b8, 0x1bc, UINT_MAX, "csia"),
3483         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0x1b8, 0x1bc, UINT_MAX, "csib"),
3484         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 12, 0x1c0, 0x1c4, UINT_MAX, "csie"),
3485         TEGRA_IO_PAD(TEGRA_IO_PAD_DSI, 2, 0x1b8, 0x1bc, UINT_MAX, "dsi"),
3486         TEGRA_IO_PAD(TEGRA_IO_PAD_DSIB, 7, 0x1c0, 0x1c4, UINT_MAX, "dsib"),
3487         TEGRA_IO_PAD(TEGRA_IO_PAD_DSIC, 8, 0x1c0, 0x1c4, UINT_MAX, "dsic"),
3488         TEGRA_IO_PAD(TEGRA_IO_PAD_DSID, 9, 0x1c0, 0x1c4, UINT_MAX, "dsid"),
3489         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI, 28, 0x1b8, 0x1bc, UINT_MAX, "hdmi"),
3490         TEGRA_IO_PAD(TEGRA_IO_PAD_HSIC, 19, 0x1b8, 0x1bc, UINT_MAX, "hsic"),
3491         TEGRA_IO_PAD(TEGRA_IO_PAD_HV, 6, 0x1c0, 0x1c4, UINT_MAX, "hv"),
3492         TEGRA_IO_PAD(TEGRA_IO_PAD_LVDS, 25, 0x1c0, 0x1c4, UINT_MAX, "lvds"),
3493         TEGRA_IO_PAD(TEGRA_IO_PAD_MIPI_BIAS, 3, 0x1b8, 0x1bc, UINT_MAX, "mipi-bias"),
3494         TEGRA_IO_PAD(TEGRA_IO_PAD_NAND, 13, 0x1b8, 0x1bc, UINT_MAX, "nand"),
3495         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_BIAS, 4, 0x1b8, 0x1bc, UINT_MAX, "pex-bias"),
3496         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK1, 5, 0x1b8, 0x1bc, UINT_MAX, "pex-clk1"),
3497         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK2, 6, 0x1b8, 0x1bc, UINT_MAX, "pex-clk2"),
3498         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CNTRL, 0, 0x1c0, 0x1c4, UINT_MAX, "pex-cntrl"),
3499         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1, 1, 0x1c0, 0x1c4, UINT_MAX, "sdmmc1"),
3500         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3, 2, 0x1c0, 0x1c4, UINT_MAX, "sdmmc3"),
3501         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC4, 3, 0x1c0, 0x1c4, UINT_MAX, "sdmmc4"),
3502         TEGRA_IO_PAD(TEGRA_IO_PAD_SYS_DDC, 26, 0x1c0, 0x1c4, UINT_MAX, "sys_ddc"),
3503         TEGRA_IO_PAD(TEGRA_IO_PAD_UART, 14, 0x1b8, 0x1bc, UINT_MAX, "uart"),
3504         TEGRA_IO_PAD(TEGRA_IO_PAD_USB0, 9, 0x1b8, 0x1bc, UINT_MAX, "usb0"),
3505         TEGRA_IO_PAD(TEGRA_IO_PAD_USB1, 10, 0x1b8, 0x1bc, UINT_MAX, "usb1"),
3506         TEGRA_IO_PAD(TEGRA_IO_PAD_USB2, 11, 0x1b8, 0x1bc, UINT_MAX, "usb2"),
3507         TEGRA_IO_PAD(TEGRA_IO_PAD_USB_BIAS, 12, 0x1b8, 0x1bc, UINT_MAX, "usb_bias"),
3508 };
3509
3510 static const struct pinctrl_pin_desc tegra124_pin_descs[] = {
3511         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO, "audio"),
3512         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_BB, "bb"),
3513         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CAM, "cam"),
3514         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_COMP, "comp"),
3515         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
3516         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
3517         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
3518         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSI, "dsi"),
3519         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIB, "dsib"),
3520         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIC, "dsic"),
3521         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSID, "dsid"),
3522         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI, "hdmi"),
3523         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HSIC, "hsic"),
3524         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HV, "hv"),
3525         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_LVDS, "lvds"),
3526         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_MIPI_BIAS, "mipi-bias"),
3527         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_NAND, "nand"),
3528         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_BIAS, "pex-bias"),
3529         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK1, "pex-clk1"),
3530         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK2, "pex-clk2"),
3531         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CNTRL, "pex-cntrl"),
3532         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1, "sdmmc1"),
3533         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3, "sdmmc3"),
3534         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC4, "sdmmc4"),
3535         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SYS_DDC, "sys_ddc"),
3536         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART, "uart"),
3537         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB0, "usb0"),
3538         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB1, "usb1"),
3539         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB2, "usb2"),
3540         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB_BIAS, "usb_bias"),
3541 };
3542
3543 static const struct tegra_pmc_soc tegra124_pmc_soc = {
3544         .supports_core_domain = false,
3545         .num_powergates = ARRAY_SIZE(tegra124_powergates),
3546         .powergates = tegra124_powergates,
3547         .num_cpu_powergates = ARRAY_SIZE(tegra124_cpu_powergates),
3548         .cpu_powergates = tegra124_cpu_powergates,
3549         .has_tsense_reset = true,
3550         .has_gpu_clamps = true,
3551         .needs_mbist_war = false,
3552         .has_impl_33v_pwr = false,
3553         .maybe_tz_only = false,
3554         .num_io_pads = ARRAY_SIZE(tegra124_io_pads),
3555         .io_pads = tegra124_io_pads,
3556         .num_pin_descs = ARRAY_SIZE(tegra124_pin_descs),
3557         .pin_descs = tegra124_pin_descs,
3558         .regs = &tegra20_pmc_regs,
3559         .init = tegra20_pmc_init,
3560         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3561         .powergate_set = tegra114_powergate_set,
3562         .reset_sources = tegra30_reset_sources,
3563         .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
3564         .reset_levels = NULL,
3565         .num_reset_levels = 0,
3566         .pmc_clks_data = tegra_pmc_clks_data,
3567         .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3568         .has_blink_output = true,
3569         .has_usb_sleepwalk = true,
3570         .has_single_mmio_aperture = true,
3571 };
3572
3573 static const char * const tegra210_powergates[] = {
3574         [TEGRA_POWERGATE_CPU] = "crail",
3575         [TEGRA_POWERGATE_3D] = "3d",
3576         [TEGRA_POWERGATE_VENC] = "venc",
3577         [TEGRA_POWERGATE_PCIE] = "pcie",
3578         [TEGRA_POWERGATE_MPE] = "mpe",
3579         [TEGRA_POWERGATE_SATA] = "sata",
3580         [TEGRA_POWERGATE_CPU1] = "cpu1",
3581         [TEGRA_POWERGATE_CPU2] = "cpu2",
3582         [TEGRA_POWERGATE_CPU3] = "cpu3",
3583         [TEGRA_POWERGATE_CPU0] = "cpu0",
3584         [TEGRA_POWERGATE_C0NC] = "c0nc",
3585         [TEGRA_POWERGATE_SOR] = "sor",
3586         [TEGRA_POWERGATE_DIS] = "dis",
3587         [TEGRA_POWERGATE_DISB] = "disb",
3588         [TEGRA_POWERGATE_XUSBA] = "xusba",
3589         [TEGRA_POWERGATE_XUSBB] = "xusbb",
3590         [TEGRA_POWERGATE_XUSBC] = "xusbc",
3591         [TEGRA_POWERGATE_VIC] = "vic",
3592         [TEGRA_POWERGATE_IRAM] = "iram",
3593         [TEGRA_POWERGATE_NVDEC] = "nvdec",
3594         [TEGRA_POWERGATE_NVJPG] = "nvjpg",
3595         [TEGRA_POWERGATE_AUD] = "aud",
3596         [TEGRA_POWERGATE_DFD] = "dfd",
3597         [TEGRA_POWERGATE_VE2] = "ve2",
3598 };
3599
3600 static const u8 tegra210_cpu_powergates[] = {
3601         TEGRA_POWERGATE_CPU0,
3602         TEGRA_POWERGATE_CPU1,
3603         TEGRA_POWERGATE_CPU2,
3604         TEGRA_POWERGATE_CPU3,
3605 };
3606
3607 static const struct tegra_io_pad_soc tegra210_io_pads[] = {
3608         TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO, 17, 0x1b8, 0x1bc, 5, "audio"),
3609         TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO_HV, 29, 0x1c0, 0x1c4, 18, "audio-hv"),
3610         TEGRA_IO_PAD(TEGRA_IO_PAD_CAM, 4, 0x1c0, 0x1c4, 10, "cam"),
3611         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0x1b8, 0x1bc, UINT_MAX, "csia"),
3612         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0x1b8, 0x1bc, UINT_MAX, "csib"),
3613         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIC, 10, 0x1c0, 0x1c4, UINT_MAX, "csic"),
3614         TEGRA_IO_PAD(TEGRA_IO_PAD_CSID, 11, 0x1c0, 0x1c4, UINT_MAX, "csid"),
3615         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 12, 0x1c0, 0x1c4, UINT_MAX, "csie"),
3616         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIF, 13, 0x1c0, 0x1c4, UINT_MAX, "csif"),
3617         TEGRA_IO_PAD(TEGRA_IO_PAD_DBG, 25, 0x1b8, 0x1bc, 19, "dbg"),
3618         TEGRA_IO_PAD(TEGRA_IO_PAD_DEBUG_NONAO, 26, 0x1b8, 0x1bc, UINT_MAX, "debug-nonao"),
3619         TEGRA_IO_PAD(TEGRA_IO_PAD_DMIC, 18, 0x1c0, 0x1c4, 20, "dmic"),
3620         TEGRA_IO_PAD(TEGRA_IO_PAD_DP, 19, 0x1c0, 0x1c4, UINT_MAX, "dp"),
3621         TEGRA_IO_PAD(TEGRA_IO_PAD_DSI, 2, 0x1b8, 0x1bc, UINT_MAX, "dsi"),
3622         TEGRA_IO_PAD(TEGRA_IO_PAD_DSIB, 7, 0x1c0, 0x1c4, UINT_MAX, "dsib"),
3623         TEGRA_IO_PAD(TEGRA_IO_PAD_DSIC, 8, 0x1c0, 0x1c4, UINT_MAX, "dsic"),
3624         TEGRA_IO_PAD(TEGRA_IO_PAD_DSID, 9, 0x1c0, 0x1c4, UINT_MAX, "dsid"),
3625         TEGRA_IO_PAD(TEGRA_IO_PAD_EMMC, 3, 0x1c0, 0x1c4, UINT_MAX, "emmc"),
3626         TEGRA_IO_PAD(TEGRA_IO_PAD_EMMC2, 5, 0x1c0, 0x1c4, UINT_MAX, "emmc2"),
3627         TEGRA_IO_PAD(TEGRA_IO_PAD_GPIO, 27, 0x1b8, 0x1bc, 21, "gpio"),
3628         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI, 28, 0x1b8, 0x1bc, UINT_MAX, "hdmi"),
3629         TEGRA_IO_PAD(TEGRA_IO_PAD_HSIC, 19, 0x1b8, 0x1bc, UINT_MAX, "hsic"),
3630         TEGRA_IO_PAD(TEGRA_IO_PAD_LVDS, 25, 0x1c0, 0x1c4, UINT_MAX, "lvds"),
3631         TEGRA_IO_PAD(TEGRA_IO_PAD_MIPI_BIAS, 3, 0x1b8, 0x1bc, UINT_MAX, "mipi-bias"),
3632         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_BIAS, 4, 0x1b8, 0x1bc, UINT_MAX, "pex-bias"),
3633         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK1, 5, 0x1b8, 0x1bc, UINT_MAX, "pex-clk1"),
3634         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK2, 6, 0x1b8, 0x1bc, UINT_MAX, "pex-clk2"),
3635         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CNTRL, UINT_MAX, UINT_MAX, UINT_MAX, 11, "pex-cntrl"),
3636         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1, 1, 0x1c0, 0x1c4, 12, "sdmmc1"),
3637         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3, 2, 0x1c0, 0x1c4, 13, "sdmmc3"),
3638         TEGRA_IO_PAD(TEGRA_IO_PAD_SPI, 14, 0x1c0, 0x1c4, 22, "spi"),
3639         TEGRA_IO_PAD(TEGRA_IO_PAD_SPI_HV, 15, 0x1c0, 0x1c4, 23, "spi-hv"),
3640         TEGRA_IO_PAD(TEGRA_IO_PAD_UART, 14, 0x1b8, 0x1bc, 2, "uart"),
3641         TEGRA_IO_PAD(TEGRA_IO_PAD_USB0, 9, 0x1b8, 0x1bc, UINT_MAX, "usb0"),
3642         TEGRA_IO_PAD(TEGRA_IO_PAD_USB1, 10, 0x1b8, 0x1bc, UINT_MAX, "usb1"),
3643         TEGRA_IO_PAD(TEGRA_IO_PAD_USB2, 11, 0x1b8, 0x1bc, UINT_MAX, "usb2"),
3644         TEGRA_IO_PAD(TEGRA_IO_PAD_USB3, 18, 0x1b8, 0x1bc, UINT_MAX, "usb3"),
3645         TEGRA_IO_PAD(TEGRA_IO_PAD_USB_BIAS, 12, 0x1b8, 0x1bc, UINT_MAX, "usb-bias"),
3646 };
3647
3648 static const struct pinctrl_pin_desc tegra210_pin_descs[] = {
3649         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO, "audio"),
3650         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO_HV, "audio-hv"),
3651         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CAM, "cam"),
3652         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
3653         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
3654         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIC, "csic"),
3655         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSID, "csid"),
3656         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
3657         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIF, "csif"),
3658         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DBG, "dbg"),
3659         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DEBUG_NONAO, "debug-nonao"),
3660         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DMIC, "dmic"),
3661         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DP, "dp"),
3662         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSI, "dsi"),
3663         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIB, "dsib"),
3664         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIC, "dsic"),
3665         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSID, "dsid"),
3666         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EMMC, "emmc"),
3667         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EMMC2, "emmc2"),
3668         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_GPIO, "gpio"),
3669         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI, "hdmi"),
3670         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HSIC, "hsic"),
3671         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_LVDS, "lvds"),
3672         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_MIPI_BIAS, "mipi-bias"),
3673         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_BIAS, "pex-bias"),
3674         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK1, "pex-clk1"),
3675         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK2, "pex-clk2"),
3676         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CNTRL, "pex-cntrl"),
3677         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1, "sdmmc1"),
3678         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3, "sdmmc3"),
3679         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SPI, "spi"),
3680         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SPI_HV, "spi-hv"),
3681         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART, "uart"),
3682         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB0, "usb0"),
3683         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB1, "usb1"),
3684         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB2, "usb2"),
3685         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB3, "usb3"),
3686         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB_BIAS, "usb-bias"),
3687 };
3688
3689 static const char * const tegra210_reset_sources[] = {
3690         "POWER_ON_RESET",
3691         "WATCHDOG",
3692         "SENSOR",
3693         "SW_MAIN",
3694         "LP0",
3695         "AOTAG"
3696 };
3697
3698 static const struct tegra_wake_event tegra210_wake_events[] = {
3699         TEGRA_WAKE_IRQ("rtc", 16, 2),
3700         TEGRA_WAKE_IRQ("pmu", 51, 86),
3701 };
3702
3703 static const struct tegra_pmc_soc tegra210_pmc_soc = {
3704         .supports_core_domain = false,
3705         .num_powergates = ARRAY_SIZE(tegra210_powergates),
3706         .powergates = tegra210_powergates,
3707         .num_cpu_powergates = ARRAY_SIZE(tegra210_cpu_powergates),
3708         .cpu_powergates = tegra210_cpu_powergates,
3709         .has_tsense_reset = true,
3710         .has_gpu_clamps = true,
3711         .needs_mbist_war = true,
3712         .has_impl_33v_pwr = false,
3713         .maybe_tz_only = true,
3714         .num_io_pads = ARRAY_SIZE(tegra210_io_pads),
3715         .io_pads = tegra210_io_pads,
3716         .num_pin_descs = ARRAY_SIZE(tegra210_pin_descs),
3717         .pin_descs = tegra210_pin_descs,
3718         .regs = &tegra20_pmc_regs,
3719         .init = tegra20_pmc_init,
3720         .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3721         .powergate_set = tegra114_powergate_set,
3722         .irq_set_wake = tegra210_pmc_irq_set_wake,
3723         .irq_set_type = tegra210_pmc_irq_set_type,
3724         .reset_sources = tegra210_reset_sources,
3725         .num_reset_sources = ARRAY_SIZE(tegra210_reset_sources),
3726         .reset_levels = NULL,
3727         .num_reset_levels = 0,
3728         .num_wake_events = ARRAY_SIZE(tegra210_wake_events),
3729         .wake_events = tegra210_wake_events,
3730         .pmc_clks_data = tegra_pmc_clks_data,
3731         .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3732         .has_blink_output = true,
3733         .has_usb_sleepwalk = true,
3734         .has_single_mmio_aperture = true,
3735 };
3736
3737 static const struct tegra_io_pad_soc tegra186_io_pads[] = {
3738         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0x74, 0x78, UINT_MAX, "csia"),
3739         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0x74, 0x78, UINT_MAX, "csib"),
3740         TEGRA_IO_PAD(TEGRA_IO_PAD_DSI, 2, 0x74, 0x78, UINT_MAX, "dsi"),
3741         TEGRA_IO_PAD(TEGRA_IO_PAD_MIPI_BIAS, 3, 0x74, 0x78, UINT_MAX, "mipi-bias"),
3742         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK_BIAS, 4, 0x74, 0x78, UINT_MAX, "pex-clk-bias"),
3743         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK3, 5, 0x74, 0x78, UINT_MAX, "pex-clk3"),
3744         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK2, 6, 0x74, 0x78, UINT_MAX, "pex-clk2"),
3745         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK1, 7, 0x74, 0x78, UINT_MAX, "pex-clk1"),
3746         TEGRA_IO_PAD(TEGRA_IO_PAD_USB0, 9, 0x74, 0x78, UINT_MAX, "usb0"),
3747         TEGRA_IO_PAD(TEGRA_IO_PAD_USB1, 10, 0x74, 0x78, UINT_MAX, "usb1"),
3748         TEGRA_IO_PAD(TEGRA_IO_PAD_USB2, 11, 0x74, 0x78, UINT_MAX, "usb2"),
3749         TEGRA_IO_PAD(TEGRA_IO_PAD_USB_BIAS, 12, 0x74, 0x78, UINT_MAX, "usb-bias"),
3750         TEGRA_IO_PAD(TEGRA_IO_PAD_UART, 14, 0x74, 0x78, UINT_MAX, "uart"),
3751         TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO, 17, 0x74, 0x78, UINT_MAX, "audio"),
3752         TEGRA_IO_PAD(TEGRA_IO_PAD_HSIC, 19, 0x74, 0x78, UINT_MAX, "hsic"),
3753         TEGRA_IO_PAD(TEGRA_IO_PAD_DBG, 25, 0x74, 0x78, UINT_MAX, "dbg"),
3754         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP0, 28, 0x74, 0x78, UINT_MAX, "hdmi-dp0"),
3755         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP1, 29, 0x74, 0x78, UINT_MAX, "hdmi-dp1"),
3756         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CNTRL, 0, 0x7c, 0x80, UINT_MAX, "pex-cntrl"),
3757         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC2_HV, 2, 0x7c, 0x80, 5, "sdmmc2-hv"),
3758         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC4, 4, 0x7c, 0x80, UINT_MAX, "sdmmc4"),
3759         TEGRA_IO_PAD(TEGRA_IO_PAD_CAM, 6, 0x7c, 0x80, UINT_MAX, "cam"),
3760         TEGRA_IO_PAD(TEGRA_IO_PAD_DSIB, 8, 0x7c, 0x80, UINT_MAX, "dsib"),
3761         TEGRA_IO_PAD(TEGRA_IO_PAD_DSIC, 9, 0x7c, 0x80, UINT_MAX, "dsic"),
3762         TEGRA_IO_PAD(TEGRA_IO_PAD_DSID, 10, 0x7c, 0x80, UINT_MAX, "dsid"),
3763         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIC, 11, 0x7c, 0x80, UINT_MAX, "csic"),
3764         TEGRA_IO_PAD(TEGRA_IO_PAD_CSID, 12, 0x7c, 0x80, UINT_MAX, "csid"),
3765         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 13, 0x7c, 0x80, UINT_MAX, "csie"),
3766         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIF, 14, 0x7c, 0x80, UINT_MAX, "csif"),
3767         TEGRA_IO_PAD(TEGRA_IO_PAD_SPI, 15, 0x7c, 0x80, UINT_MAX, "spi"),
3768         TEGRA_IO_PAD(TEGRA_IO_PAD_UFS, 17, 0x7c, 0x80, UINT_MAX, "ufs"),
3769         TEGRA_IO_PAD(TEGRA_IO_PAD_DMIC_HV, 20, 0x7c, 0x80, 2, "dmic-hv"),
3770         TEGRA_IO_PAD(TEGRA_IO_PAD_EDP, 21, 0x7c, 0x80, UINT_MAX, "edp"),
3771         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1_HV, 23, 0x7c, 0x80, 4, "sdmmc1-hv"),
3772         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3_HV, 24, 0x7c, 0x80, 6, "sdmmc3-hv"),
3773         TEGRA_IO_PAD(TEGRA_IO_PAD_CONN, 28, 0x7c, 0x80, UINT_MAX, "conn"),
3774         TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO_HV, 29, 0x7c, 0x80, 1, "audio-hv"),
3775         TEGRA_IO_PAD(TEGRA_IO_PAD_AO_HV, UINT_MAX, UINT_MAX, UINT_MAX, 0, "ao-hv"),
3776 };
3777
3778 static const struct pinctrl_pin_desc tegra186_pin_descs[] = {
3779         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
3780         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
3781         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSI, "dsi"),
3782         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_MIPI_BIAS, "mipi-bias"),
3783         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK_BIAS, "pex-clk-bias"),
3784         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK3, "pex-clk3"),
3785         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK2, "pex-clk2"),
3786         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK1, "pex-clk1"),
3787         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB0, "usb0"),
3788         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB1, "usb1"),
3789         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB2, "usb2"),
3790         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB_BIAS, "usb-bias"),
3791         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART, "uart"),
3792         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO, "audio"),
3793         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HSIC, "hsic"),
3794         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DBG, "dbg"),
3795         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP0, "hdmi-dp0"),
3796         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP1, "hdmi-dp1"),
3797         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CNTRL, "pex-cntrl"),
3798         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC2_HV, "sdmmc2-hv"),
3799         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC4, "sdmmc4"),
3800         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CAM, "cam"),
3801         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIB, "dsib"),
3802         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIC, "dsic"),
3803         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSID, "dsid"),
3804         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIC, "csic"),
3805         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSID, "csid"),
3806         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
3807         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIF, "csif"),
3808         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SPI, "spi"),
3809         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UFS, "ufs"),
3810         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DMIC_HV, "dmic-hv"),
3811         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EDP, "edp"),
3812         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1_HV, "sdmmc1-hv"),
3813         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3_HV, "sdmmc3-hv"),
3814         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CONN, "conn"),
3815         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO_HV, "audio-hv"),
3816         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AO_HV, "ao-hv"),
3817 };
3818
3819 static const struct tegra_pmc_regs tegra186_pmc_regs = {
3820         .scratch0 = 0x2000,
3821         .rst_status = 0x70,
3822         .rst_source_shift = 0x2,
3823         .rst_source_mask = 0x3c,
3824         .rst_level_shift = 0x0,
3825         .rst_level_mask = 0x3,
3826 };
3827
3828 static void tegra186_pmc_init(struct tegra_pmc *pmc)
3829 {
3830         pmc->syscore.suspend = tegra186_pmc_wake_syscore_suspend;
3831         pmc->syscore.resume = tegra186_pmc_wake_syscore_resume;
3832
3833         register_syscore_ops(&pmc->syscore);
3834 }
3835
3836 static void tegra186_pmc_setup_irq_polarity(struct tegra_pmc *pmc,
3837                                             struct device_node *np,
3838                                             bool invert)
3839 {
3840         struct resource regs;
3841         void __iomem *wake;
3842         u32 value;
3843         int index;
3844
3845         index = of_property_match_string(np, "reg-names", "wake");
3846         if (index < 0) {
3847                 dev_err(pmc->dev, "failed to find PMC wake registers\n");
3848                 return;
3849         }
3850
3851         of_address_to_resource(np, index, &regs);
3852
3853         wake = ioremap(regs.start, resource_size(&regs));
3854         if (!wake) {
3855                 dev_err(pmc->dev, "failed to map PMC wake registers\n");
3856                 return;
3857         }
3858
3859         value = readl(wake + WAKE_AOWAKE_CTRL);
3860
3861         if (invert)
3862                 value |= WAKE_AOWAKE_CTRL_INTR_POLARITY;
3863         else
3864                 value &= ~WAKE_AOWAKE_CTRL_INTR_POLARITY;
3865
3866         writel(value, wake + WAKE_AOWAKE_CTRL);
3867
3868         iounmap(wake);
3869 }
3870
3871 static const char * const tegra186_reset_sources[] = {
3872         "SYS_RESET",
3873         "AOWDT",
3874         "MCCPLEXWDT",
3875         "BPMPWDT",
3876         "SCEWDT",
3877         "SPEWDT",
3878         "APEWDT",
3879         "BCCPLEXWDT",
3880         "SENSOR",
3881         "AOTAG",
3882         "VFSENSOR",
3883         "SWREST",
3884         "SC7",
3885         "HSM",
3886         "CORESIGHT"
3887 };
3888
3889 static const char * const tegra186_reset_levels[] = {
3890         "L0", "L1", "L2", "WARM"
3891 };
3892
3893 static const struct tegra_wake_event tegra186_wake_events[] = {
3894         TEGRA_WAKE_IRQ("pmu", 24, 209),
3895         TEGRA_WAKE_GPIO("power", 29, 1, TEGRA186_AON_GPIO(FF, 0)),
3896         TEGRA_WAKE_IRQ("rtc", 73, 10),
3897 };
3898
3899 static const struct tegra_pmc_soc tegra186_pmc_soc = {
3900         .supports_core_domain = false,
3901         .num_powergates = 0,
3902         .powergates = NULL,
3903         .num_cpu_powergates = 0,
3904         .cpu_powergates = NULL,
3905         .has_tsense_reset = false,
3906         .has_gpu_clamps = false,
3907         .needs_mbist_war = false,
3908         .has_impl_33v_pwr = true,
3909         .maybe_tz_only = false,
3910         .num_io_pads = ARRAY_SIZE(tegra186_io_pads),
3911         .io_pads = tegra186_io_pads,
3912         .num_pin_descs = ARRAY_SIZE(tegra186_pin_descs),
3913         .pin_descs = tegra186_pin_descs,
3914         .regs = &tegra186_pmc_regs,
3915         .init = tegra186_pmc_init,
3916         .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
3917         .set_wake_filters = tegra186_pmc_set_wake_filters,
3918         .irq_set_wake = tegra186_pmc_irq_set_wake,
3919         .irq_set_type = tegra186_pmc_irq_set_type,
3920         .reset_sources = tegra186_reset_sources,
3921         .num_reset_sources = ARRAY_SIZE(tegra186_reset_sources),
3922         .reset_levels = tegra186_reset_levels,
3923         .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
3924         .num_wake_events = ARRAY_SIZE(tegra186_wake_events),
3925         .wake_events = tegra186_wake_events,
3926         .max_wake_events = 96,
3927         .max_wake_vectors = 3,
3928         .pmc_clks_data = NULL,
3929         .num_pmc_clks = 0,
3930         .has_blink_output = false,
3931         .has_usb_sleepwalk = false,
3932         .has_single_mmio_aperture = false,
3933 };
3934
3935 static const struct tegra_io_pad_soc tegra194_io_pads[] = {
3936         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0x74, 0x78, UINT_MAX, "csia"),
3937         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0x74, 0x78, UINT_MAX, "csib"),
3938         TEGRA_IO_PAD(TEGRA_IO_PAD_MIPI_BIAS, 3, 0x74, 0x78, UINT_MAX, "mipi-bias"),
3939         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK_BIAS, 4, 0x74, 0x78, UINT_MAX, "pex-clk-bias"),
3940         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK3, 5, 0x74, 0x78, UINT_MAX, "pex-clk3"),
3941         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK2, 6, 0x74, 0x78, UINT_MAX, "pex-clk2"),
3942         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK1, 7, 0x74, 0x78, UINT_MAX, "pex-clk1"),
3943         TEGRA_IO_PAD(TEGRA_IO_PAD_EQOS, 8, 0x74, 0x78, UINT_MAX, "eqos"),
3944         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK_2_BIAS, 9, 0x74, 0x78, UINT_MAX, "pex-clk-2-bias"),
3945         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK_2, 10, 0x74, 0x78, UINT_MAX, "pex-clk-2"),
3946         TEGRA_IO_PAD(TEGRA_IO_PAD_DAP3, 11, 0x74, 0x78, UINT_MAX, "dap3"),
3947         TEGRA_IO_PAD(TEGRA_IO_PAD_DAP5, 12, 0x74, 0x78, UINT_MAX, "dap5"),
3948         TEGRA_IO_PAD(TEGRA_IO_PAD_UART, 14, 0x74, 0x78, UINT_MAX, "uart"),
3949         TEGRA_IO_PAD(TEGRA_IO_PAD_PWR_CTL, 15, 0x74, 0x78, UINT_MAX, "pwr-ctl"),
3950         TEGRA_IO_PAD(TEGRA_IO_PAD_SOC_GPIO53, 16, 0x74, 0x78, UINT_MAX, "soc-gpio53"),
3951         TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO, 17, 0x74, 0x78, UINT_MAX, "audio"),
3952         TEGRA_IO_PAD(TEGRA_IO_PAD_GP_PWM2, 18, 0x74, 0x78, UINT_MAX, "gp-pwm2"),
3953         TEGRA_IO_PAD(TEGRA_IO_PAD_GP_PWM3, 19, 0x74, 0x78, UINT_MAX, "gp-pwm3"),
3954         TEGRA_IO_PAD(TEGRA_IO_PAD_SOC_GPIO12, 20, 0x74, 0x78, UINT_MAX, "soc-gpio12"),
3955         TEGRA_IO_PAD(TEGRA_IO_PAD_SOC_GPIO13, 21, 0x74, 0x78, UINT_MAX, "soc-gpio13"),
3956         TEGRA_IO_PAD(TEGRA_IO_PAD_SOC_GPIO10, 22, 0x74, 0x78, UINT_MAX, "soc-gpio10"),
3957         TEGRA_IO_PAD(TEGRA_IO_PAD_UART4, 23, 0x74, 0x78, UINT_MAX, "uart4"),
3958         TEGRA_IO_PAD(TEGRA_IO_PAD_UART5, 24, 0x74, 0x78, UINT_MAX, "uart5"),
3959         TEGRA_IO_PAD(TEGRA_IO_PAD_DBG, 25, 0x74, 0x78, UINT_MAX, "dbg"),
3960         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP3, 26, 0x74, 0x78, UINT_MAX, "hdmi-dp3"),
3961         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP2, 27, 0x74, 0x78, UINT_MAX, "hdmi-dp2"),
3962         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP0, 28, 0x74, 0x78, UINT_MAX, "hdmi-dp0"),
3963         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP1, 29, 0x74, 0x78, UINT_MAX, "hdmi-dp1"),
3964         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CNTRL, 0, 0x7c, 0x80, UINT_MAX, "pex-cntrl"),
3965         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CTL2, 1, 0x7c, 0x80, UINT_MAX, "pex-ctl2"),
3966         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_L0_RST, 2, 0x7c, 0x80, UINT_MAX, "pex-l0-rst"),
3967         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_L1_RST, 3, 0x7c, 0x80, UINT_MAX, "pex-l1-rst"),
3968         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC4, 4, 0x7c, 0x80, UINT_MAX, "sdmmc4"),
3969         TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_L5_RST, 5, 0x7c, 0x80, UINT_MAX, "pex-l5-rst"),
3970         TEGRA_IO_PAD(TEGRA_IO_PAD_CAM, 6, 0x7c, 0x80, UINT_MAX, "cam"),
3971         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIC, 11, 0x7c, 0x80, UINT_MAX, "csic"),
3972         TEGRA_IO_PAD(TEGRA_IO_PAD_CSID, 12, 0x7c, 0x80, UINT_MAX, "csid"),
3973         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 13, 0x7c, 0x80, UINT_MAX, "csie"),
3974         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIF, 14, 0x7c, 0x80, UINT_MAX, "csif"),
3975         TEGRA_IO_PAD(TEGRA_IO_PAD_SPI, 15, 0x7c, 0x80, UINT_MAX, "spi"),
3976         TEGRA_IO_PAD(TEGRA_IO_PAD_UFS, 17, 0x7c, 0x80, UINT_MAX, "ufs"),
3977         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIG, 18, 0x7c, 0x80, UINT_MAX, "csig"),
3978         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIH, 19, 0x7c, 0x80, UINT_MAX, "csih"),
3979         TEGRA_IO_PAD(TEGRA_IO_PAD_EDP, 21, 0x7c, 0x80, UINT_MAX, "edp"),
3980         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1_HV, 23, 0x7c, 0x80, 4, "sdmmc1-hv"),
3981         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3_HV, 24, 0x7c, 0x80, 6, "sdmmc3-hv"),
3982         TEGRA_IO_PAD(TEGRA_IO_PAD_CONN, 28, 0x7c, 0x80, UINT_MAX, "conn"),
3983         TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO_HV, 29, 0x7c, 0x80, 1, "audio-hv"),
3984         TEGRA_IO_PAD(TEGRA_IO_PAD_AO_HV, UINT_MAX, UINT_MAX, UINT_MAX, 0, "ao-hv"),
3985 };
3986
3987 static const struct pinctrl_pin_desc tegra194_pin_descs[] = {
3988         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
3989         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
3990         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_MIPI_BIAS, "mipi-bias"),
3991         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK_BIAS, "pex-clk-bias"),
3992         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK3, "pex-clk3"),
3993         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK2, "pex-clk2"),
3994         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK1, "pex-clk1"),
3995         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EQOS, "eqos"),
3996         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK_2_BIAS, "pex-clk-2-bias"),
3997         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK_2, "pex-clk-2"),
3998         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DAP3, "dap3"),
3999         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DAP5, "dap5"),
4000         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART, "uart"),
4001         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PWR_CTL, "pwr-ctl"),
4002         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SOC_GPIO53, "soc-gpio53"),
4003         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO, "audio"),
4004         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_GP_PWM2, "gp-pwm2"),
4005         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_GP_PWM3, "gp-pwm3"),
4006         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SOC_GPIO12, "soc-gpio12"),
4007         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SOC_GPIO13, "soc-gpio13"),
4008         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SOC_GPIO10, "soc-gpio10"),
4009         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART4, "uart4"),
4010         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART5, "uart5"),
4011         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DBG, "dbg"),
4012         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP3, "hdmi-dp3"),
4013         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP2, "hdmi-dp2"),
4014         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP0, "hdmi-dp0"),
4015         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP1, "hdmi-dp1"),
4016         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CNTRL, "pex-cntrl"),
4017         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CTL2, "pex-ctl2"),
4018         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_L0_RST, "pex-l0-rst"),
4019         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_L1_RST, "pex-l1-rst"),
4020         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC4, "sdmmc4"),
4021         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_L5_RST, "pex-l5-rst"),
4022         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CAM, "cam"),
4023         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIC, "csic"),
4024         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSID, "csid"),
4025         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
4026         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIF, "csif"),
4027         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SPI, "spi"),
4028         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UFS, "ufs"),
4029         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIG, "csig"),
4030         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIH, "csih"),
4031         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EDP, "edp"),
4032         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1_HV, "sdmmc1-hv"),
4033         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3_HV, "sdmmc3-hv"),
4034         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CONN, "conn"),
4035         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO_HV, "audio-hv"),
4036         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AO_HV, "ao-hv"),
4037 };
4038
4039 static const struct tegra_pmc_regs tegra194_pmc_regs = {
4040         .scratch0 = 0x2000,
4041         .rst_status = 0x70,
4042         .rst_source_shift = 0x2,
4043         .rst_source_mask = 0x7c,
4044         .rst_level_shift = 0x0,
4045         .rst_level_mask = 0x3,
4046 };
4047
4048 static const char * const tegra194_reset_sources[] = {
4049         "SYS_RESET_N",
4050         "AOWDT",
4051         "BCCPLEXWDT",
4052         "BPMPWDT",
4053         "SCEWDT",
4054         "SPEWDT",
4055         "APEWDT",
4056         "LCCPLEXWDT",
4057         "SENSOR",
4058         "AOTAG",
4059         "VFSENSOR",
4060         "MAINSWRST",
4061         "SC7",
4062         "HSM",
4063         "CSITE",
4064         "RCEWDT",
4065         "PVA0WDT",
4066         "PVA1WDT",
4067         "L1A_ASYNC",
4068         "BPMPBOOT",
4069         "FUSECRC",
4070 };
4071
4072 static const struct tegra_wake_event tegra194_wake_events[] = {
4073         TEGRA_WAKE_GPIO("eqos", 20, 0, TEGRA194_MAIN_GPIO(G, 4)),
4074         TEGRA_WAKE_IRQ("pmu", 24, 209),
4075         TEGRA_WAKE_GPIO("power", 29, 1, TEGRA194_AON_GPIO(EE, 4)),
4076         TEGRA_WAKE_IRQ("rtc", 73, 10),
4077         TEGRA_WAKE_SIMPLE("usb3-port-0", 76),
4078         TEGRA_WAKE_SIMPLE("usb3-port-1", 77),
4079         TEGRA_WAKE_SIMPLE("usb3-port-2-3", 78),
4080         TEGRA_WAKE_SIMPLE("usb2-port-0", 79),
4081         TEGRA_WAKE_SIMPLE("usb2-port-1", 80),
4082         TEGRA_WAKE_SIMPLE("usb2-port-2", 81),
4083         TEGRA_WAKE_SIMPLE("usb2-port-3", 82),
4084 };
4085
4086 static const struct tegra_pmc_soc tegra194_pmc_soc = {
4087         .supports_core_domain = false,
4088         .num_powergates = 0,
4089         .powergates = NULL,
4090         .num_cpu_powergates = 0,
4091         .cpu_powergates = NULL,
4092         .has_tsense_reset = false,
4093         .has_gpu_clamps = false,
4094         .needs_mbist_war = false,
4095         .has_impl_33v_pwr = true,
4096         .maybe_tz_only = false,
4097         .num_io_pads = ARRAY_SIZE(tegra194_io_pads),
4098         .io_pads = tegra194_io_pads,
4099         .num_pin_descs = ARRAY_SIZE(tegra194_pin_descs),
4100         .pin_descs = tegra194_pin_descs,
4101         .regs = &tegra194_pmc_regs,
4102         .init = tegra186_pmc_init,
4103         .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
4104         .set_wake_filters = tegra186_pmc_set_wake_filters,
4105         .irq_set_wake = tegra186_pmc_irq_set_wake,
4106         .irq_set_type = tegra186_pmc_irq_set_type,
4107         .reset_sources = tegra194_reset_sources,
4108         .num_reset_sources = ARRAY_SIZE(tegra194_reset_sources),
4109         .reset_levels = tegra186_reset_levels,
4110         .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
4111         .num_wake_events = ARRAY_SIZE(tegra194_wake_events),
4112         .wake_events = tegra194_wake_events,
4113         .max_wake_events = 96,
4114         .max_wake_vectors = 3,
4115         .pmc_clks_data = NULL,
4116         .num_pmc_clks = 0,
4117         .has_blink_output = false,
4118         .has_usb_sleepwalk = false,
4119         .has_single_mmio_aperture = false,
4120 };
4121
4122 static const struct tegra_io_pad_soc tegra234_io_pads[] = {
4123         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0xe0c0, 0xe0c4, UINT_MAX, "csia"),
4124         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0xe0c0, 0xe0c4, UINT_MAX, "csib"),
4125         TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP0, 0, 0xe0d0, 0xe0d4, UINT_MAX, "hdmi-dp0"),
4126         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIC, 2, 0xe0c0, 0xe0c4, UINT_MAX, "csic"),
4127         TEGRA_IO_PAD(TEGRA_IO_PAD_CSID, 3, 0xe0c0, 0xe0c4, UINT_MAX, "csid"),
4128         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 4, 0xe0c0, 0xe0c4, UINT_MAX, "csie"),
4129         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIF, 5, 0xe0c0, 0xe0c4, UINT_MAX, "csif"),
4130         TEGRA_IO_PAD(TEGRA_IO_PAD_UFS, 0, 0xe064, 0xe068, UINT_MAX, "ufs"),
4131         TEGRA_IO_PAD(TEGRA_IO_PAD_EDP, 1, 0xe05c, 0xe060, UINT_MAX, "edp"),
4132         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1_HV, 0, 0xe054, 0xe058, 4, "sdmmc1-hv"),
4133         TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3_HV, UINT_MAX, UINT_MAX, UINT_MAX, 6, "sdmmc3-hv"),
4134         TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO_HV, UINT_MAX, UINT_MAX, UINT_MAX, 1, "audio-hv"),
4135         TEGRA_IO_PAD(TEGRA_IO_PAD_AO_HV, UINT_MAX, UINT_MAX, UINT_MAX, 0, "ao-hv"),
4136         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIG, 6, 0xe0c0, 0xe0c4, UINT_MAX, "csig"),
4137         TEGRA_IO_PAD(TEGRA_IO_PAD_CSIH, 7, 0xe0c0, 0xe0c4, UINT_MAX, "csih"),
4138 };
4139
4140 static const struct pinctrl_pin_desc tegra234_pin_descs[] = {
4141         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
4142         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
4143         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP0, "hdmi-dp0"),
4144         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIC, "csic"),
4145         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSID, "csid"),
4146         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
4147         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIF, "csif"),
4148         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UFS, "ufs"),
4149         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EDP, "edp"),
4150         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1_HV, "sdmmc1-hv"),
4151         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3_HV, "sdmmc3-hv"),
4152         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO_HV, "audio-hv"),
4153         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AO_HV, "ao-hv"),
4154         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIG, "csig"),
4155         TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIH, "csih"),
4156 };
4157
4158 static const struct tegra_pmc_regs tegra234_pmc_regs = {
4159         .scratch0 = 0x2000,
4160         .rst_status = 0x70,
4161         .rst_source_shift = 0x2,
4162         .rst_source_mask = 0xfc,
4163         .rst_level_shift = 0x0,
4164         .rst_level_mask = 0x3,
4165 };
4166
4167 static const char * const tegra234_reset_sources[] = {
4168         "SYS_RESET_N",  /* 0x0 */
4169         "AOWDT",
4170         "BCCPLEXWDT",
4171         "BPMPWDT",
4172         "SCEWDT",
4173         "SPEWDT",
4174         "APEWDT",
4175         "LCCPLEXWDT",
4176         "SENSOR",       /* 0x8 */
4177         NULL,
4178         NULL,
4179         "MAINSWRST",
4180         "SC7",
4181         "HSM",
4182         NULL,
4183         "RCEWDT",
4184         NULL,           /* 0x10 */
4185         NULL,
4186         NULL,
4187         "BPMPBOOT",
4188         "FUSECRC",
4189         "DCEWDT",
4190         "PSCWDT",
4191         "PSC",
4192         "CSITE_SW",     /* 0x18 */
4193         "POD",
4194         "SCPM",
4195         "VREFRO_POWERBAD",
4196         "VMON",
4197         "FMON",
4198         "FSI_R5WDT",
4199         "FSI_THERM",
4200         "FSI_R52C0WDT", /* 0x20 */
4201         "FSI_R52C1WDT",
4202         "FSI_R52C2WDT",
4203         "FSI_R52C3WDT",
4204         "FSI_FMON",
4205         "FSI_VMON",     /* 0x25 */
4206 };
4207
4208 static const struct tegra_wake_event tegra234_wake_events[] = {
4209         TEGRA_WAKE_GPIO("sd-wake", 8, 0, TEGRA234_MAIN_GPIO(G, 7)),
4210         TEGRA_WAKE_GPIO("eqos", 20, 0, TEGRA234_MAIN_GPIO(G, 4)),
4211         TEGRA_WAKE_IRQ("pmu", 24, 209),
4212         TEGRA_WAKE_GPIO("power", 29, 1, TEGRA234_AON_GPIO(EE, 4)),
4213         TEGRA_WAKE_GPIO("mgbe", 56, 0, TEGRA234_MAIN_GPIO(Y, 3)),
4214         TEGRA_WAKE_IRQ("rtc", 73, 10),
4215         TEGRA_WAKE_IRQ("sw-wake", SW_WAKE_ID, 179),
4216 };
4217
4218 static const struct tegra_pmc_soc tegra234_pmc_soc = {
4219         .supports_core_domain = false,
4220         .num_powergates = 0,
4221         .powergates = NULL,
4222         .num_cpu_powergates = 0,
4223         .cpu_powergates = NULL,
4224         .has_tsense_reset = false,
4225         .has_gpu_clamps = false,
4226         .needs_mbist_war = false,
4227         .has_impl_33v_pwr = true,
4228         .maybe_tz_only = false,
4229         .num_io_pads = ARRAY_SIZE(tegra234_io_pads),
4230         .io_pads = tegra234_io_pads,
4231         .num_pin_descs = ARRAY_SIZE(tegra234_pin_descs),
4232         .pin_descs = tegra234_pin_descs,
4233         .regs = &tegra234_pmc_regs,
4234         .init = tegra186_pmc_init,
4235         .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
4236         .set_wake_filters = tegra186_pmc_set_wake_filters,
4237         .irq_set_wake = tegra186_pmc_irq_set_wake,
4238         .irq_set_type = tegra186_pmc_irq_set_type,
4239         .reset_sources = tegra234_reset_sources,
4240         .num_reset_sources = ARRAY_SIZE(tegra234_reset_sources),
4241         .reset_levels = tegra186_reset_levels,
4242         .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
4243         .num_wake_events = ARRAY_SIZE(tegra234_wake_events),
4244         .wake_events = tegra234_wake_events,
4245         .max_wake_events = 96,
4246         .max_wake_vectors = 3,
4247         .pmc_clks_data = NULL,
4248         .num_pmc_clks = 0,
4249         .has_blink_output = false,
4250         .has_single_mmio_aperture = false,
4251 };
4252
4253 static const struct of_device_id tegra_pmc_match[] = {
4254         { .compatible = "nvidia,tegra234-pmc", .data = &tegra234_pmc_soc },
4255         { .compatible = "nvidia,tegra194-pmc", .data = &tegra194_pmc_soc },
4256         { .compatible = "nvidia,tegra186-pmc", .data = &tegra186_pmc_soc },
4257         { .compatible = "nvidia,tegra210-pmc", .data = &tegra210_pmc_soc },
4258         { .compatible = "nvidia,tegra132-pmc", .data = &tegra124_pmc_soc },
4259         { .compatible = "nvidia,tegra124-pmc", .data = &tegra124_pmc_soc },
4260         { .compatible = "nvidia,tegra114-pmc", .data = &tegra114_pmc_soc },
4261         { .compatible = "nvidia,tegra30-pmc", .data = &tegra30_pmc_soc },
4262         { .compatible = "nvidia,tegra20-pmc", .data = &tegra20_pmc_soc },
4263         { }
4264 };
4265
4266 static void tegra_pmc_sync_state(struct device *dev)
4267 {
4268         int err;
4269
4270         /*
4271          * Newer device-trees have power domains, but we need to prepare all
4272          * device drivers with runtime PM and OPP support first, otherwise
4273          * state syncing is unsafe.
4274          */
4275         if (!pmc->soc->supports_core_domain)
4276                 return;
4277
4278         /*
4279          * Older device-trees don't have core PD, and thus, there are
4280          * no dependencies that will block the state syncing. We shouldn't
4281          * mark the domain as synced in this case.
4282          */
4283         if (!pmc->core_domain_registered)
4284                 return;
4285
4286         pmc->core_domain_state_synced = true;
4287
4288         /* this is a no-op if core regulator isn't used */
4289         mutex_lock(&pmc->powergates_lock);
4290         err = dev_pm_opp_sync_regulators(dev);
4291         mutex_unlock(&pmc->powergates_lock);
4292
4293         if (err)
4294                 dev_err(dev, "failed to sync regulators: %d\n", err);
4295 }
4296
4297 static struct platform_driver tegra_pmc_driver = {
4298         .driver = {
4299                 .name = "tegra-pmc",
4300                 .suppress_bind_attrs = true,
4301                 .of_match_table = tegra_pmc_match,
4302 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_ARM)
4303                 .pm = &tegra_pmc_pm_ops,
4304 #endif
4305                 .sync_state = tegra_pmc_sync_state,
4306         },
4307         .probe = tegra_pmc_probe,
4308 };
4309 builtin_platform_driver(tegra_pmc_driver);
4310
4311 static bool __init tegra_pmc_detect_tz_only(struct tegra_pmc *pmc)
4312 {
4313         u32 value, saved;
4314
4315         saved = readl(pmc->base + pmc->soc->regs->scratch0);
4316         value = saved ^ 0xffffffff;
4317
4318         if (value == 0xffffffff)
4319                 value = 0xdeadbeef;
4320
4321         /* write pattern and read it back */
4322         writel(value, pmc->base + pmc->soc->regs->scratch0);
4323         value = readl(pmc->base + pmc->soc->regs->scratch0);
4324
4325         /* if we read all-zeroes, access is restricted to TZ only */
4326         if (value == 0) {
4327                 pr_info("access to PMC is restricted to TZ\n");
4328                 return true;
4329         }
4330
4331         /* restore original value */
4332         writel(saved, pmc->base + pmc->soc->regs->scratch0);
4333
4334         return false;
4335 }
4336
4337 /*
4338  * Early initialization to allow access to registers in the very early boot
4339  * process.
4340  */
4341 static int __init tegra_pmc_early_init(void)
4342 {
4343         const struct of_device_id *match;
4344         struct device_node *np;
4345         struct resource regs;
4346         unsigned int i;
4347         bool invert;
4348
4349         mutex_init(&pmc->powergates_lock);
4350
4351         np = of_find_matching_node_and_match(NULL, tegra_pmc_match, &match);
4352         if (!np) {
4353                 /*
4354                  * Fall back to legacy initialization for 32-bit ARM only. All
4355                  * 64-bit ARM device tree files for Tegra are required to have
4356                  * a PMC node.
4357                  *
4358                  * This is for backwards-compatibility with old device trees
4359                  * that didn't contain a PMC node. Note that in this case the
4360                  * SoC data can't be matched and therefore powergating is
4361                  * disabled.
4362                  */
4363                 if (IS_ENABLED(CONFIG_ARM) && soc_is_tegra()) {
4364                         pr_warn("DT node not found, powergating disabled\n");
4365
4366                         regs.start = 0x7000e400;
4367                         regs.end = 0x7000e7ff;
4368                         regs.flags = IORESOURCE_MEM;
4369
4370                         pr_warn("Using memory region %pR\n", &regs);
4371                 } else {
4372                         /*
4373                          * At this point we're not running on Tegra, so play
4374                          * nice with multi-platform kernels.
4375                          */
4376                         return 0;
4377                 }
4378         } else {
4379                 /*
4380                  * Extract information from the device tree if we've found a
4381                  * matching node.
4382                  */
4383                 if (of_address_to_resource(np, 0, &regs) < 0) {
4384                         pr_err("failed to get PMC registers\n");
4385                         of_node_put(np);
4386                         return -ENXIO;
4387                 }
4388         }
4389
4390         pmc->base = ioremap(regs.start, resource_size(&regs));
4391         if (!pmc->base) {
4392                 pr_err("failed to map PMC registers\n");
4393                 of_node_put(np);
4394                 return -ENXIO;
4395         }
4396
4397         if (of_device_is_available(np)) {
4398                 pmc->soc = match->data;
4399
4400                 if (pmc->soc->maybe_tz_only)
4401                         pmc->tz_only = tegra_pmc_detect_tz_only(pmc);
4402
4403                 /* Create a bitmap of the available and valid partitions */
4404                 for (i = 0; i < pmc->soc->num_powergates; i++)
4405                         if (pmc->soc->powergates[i])
4406                                 set_bit(i, pmc->powergates_available);
4407
4408                 /*
4409                  * Invert the interrupt polarity if a PMC device tree node
4410                  * exists and contains the nvidia,invert-interrupt property.
4411                  */
4412                 invert = of_property_read_bool(np, "nvidia,invert-interrupt");
4413
4414                 pmc->soc->setup_irq_polarity(pmc, np, invert);
4415
4416                 of_node_put(np);
4417         }
4418
4419         return 0;
4420 }
4421 early_initcall(tegra_pmc_early_init);