?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 6.14-rc1
[linux-stable.git] / drivers / soc / tegra / pmc.c
bloba08c377933c5052f6a1a8081e05cb4905870d507
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 <ccross@google.com>
10 */
11
12 #define pr_fmt(fmt) "tegra-pmc: " fmt
13
14 #include <linux/arm-smccc.h>
15 #include <linux/clk.h>
16 #include <linux/clk-provider.h>
17 #include <linux/clkdev.h>
18 #include <linux/clk/clk-conf.h>
19 #include <linux/clk/tegra.h>
20 #include <linux/debugfs.h>
21 #include <linux/delay.h>
22 #include <linux/device.h>
23 #include <linux/err.h>
24 #include <linux/export.h>
25 #include <linux/init.h>
26 #include <linux/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;
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_scoped(np, child) {
1461 err = tegra_powergate_add(pmc, child);
1462 if (err < 0)
1463 break;
1464
1465 if (of_parse_phandle_with_args(child, "power-domains",
1466 "#power-domain-cells",
1467 0, &parent_args))
1468 continue;
1469
1470 child_args.np = child;
1471 child_args.args_count = 0;
1472
1473 err = of_genpd_add_subdomain(&parent_args, &child_args);
1474 of_node_put(parent_args.np);
1475 if (err)
1476 break;
1477 }
1478
1479 of_node_put(np);
1480
1481 return err;
1482 }
1483
1484 static void tegra_powergate_remove(struct generic_pm_domain *genpd)
1485 {
1486 struct tegra_powergate *pg = to_powergate(genpd);
1487
1488 reset_control_put(pg->reset);
1489
1490 while (pg->num_clks--)
1491 clk_put(pg->clks[pg->num_clks]);
1492
1493 kfree(pg->clks);
1494
1495 set_bit(pg->id, pmc->powergates_available);
1496
1497 kfree(pg);
1498 }
1499
1500 static void tegra_powergate_remove_all(struct device_node *parent)
1501 {
1502 struct generic_pm_domain *genpd;
1503 struct device_node *np, *child;
1504
1505 np = of_get_child_by_name(parent, "powergates");
1506 if (!np)
1507 return;
1508
1509 for_each_child_of_node(np, child) {
1510 of_genpd_del_provider(child);
1511
1512 genpd = of_genpd_remove_last(child);
1513 if (IS_ERR(genpd))
1514 continue;
1515
1516 tegra_powergate_remove(genpd);
1517 }
1518
1519 of_node_put(np);
1520
1521 np = of_get_child_by_name(parent, "core-domain");
1522 if (np) {
1523 of_genpd_del_provider(np);
1524 of_genpd_remove_last(np);
1525 }
1526 }
1527
1528 static const struct tegra_io_pad_soc *
1529 tegra_io_pad_find(struct tegra_pmc *pmc, enum tegra_io_pad id)
1530 {
1531 unsigned int i;
1532
1533 for (i = 0; i < pmc->soc->num_io_pads; i++)
1534 if (pmc->soc->io_pads[i].id == id)
1535 return &pmc->soc->io_pads[i];
1536
1537 return NULL;
1538 }
1539
1540 static int tegra_io_pad_prepare(struct tegra_pmc *pmc,
1541 const struct tegra_io_pad_soc *pad,
1542 unsigned long *request,
1543 unsigned long *status,
1544 u32 *mask)
1545 {
1546 unsigned long rate, value;
1547
1548 if (pad->dpd == UINT_MAX)
1549 return -EINVAL;
1550
1551 *request = pad->request;
1552 *status = pad->status;
1553 *mask = BIT(pad->dpd);
1554
1555 if (pmc->clk) {
1556 rate = pmc->rate;
1557 if (!rate) {
1558 dev_err(pmc->dev, "failed to get clock rate\n");
1559 return -ENODEV;
1560 }
1561
1562 tegra_pmc_writel(pmc, DPD_SAMPLE_ENABLE, DPD_SAMPLE);
1563
1564 /* must be at least 200 ns, in APB (PCLK) clock cycles */
1565 value = DIV_ROUND_UP(1000000000, rate);
1566 value = DIV_ROUND_UP(200, value);
1567 tegra_pmc_writel(pmc, value, SEL_DPD_TIM);
1568 }
1569
1570 return 0;
1571 }
1572
1573 static int tegra_io_pad_poll(struct tegra_pmc *pmc, unsigned long offset,
1574 u32 mask, u32 val, unsigned long timeout)
1575 {
1576 u32 value;
1577
1578 timeout = jiffies + msecs_to_jiffies(timeout);
1579
1580 while (time_after(timeout, jiffies)) {
1581 value = tegra_pmc_readl(pmc, offset);
1582 if ((value & mask) == val)
1583 return 0;
1584
1585 usleep_range(250, 1000);
1586 }
1587
1588 return -ETIMEDOUT;
1589 }
1590
1591 static void tegra_io_pad_unprepare(struct tegra_pmc *pmc)
1592 {
1593 if (pmc->clk)
1594 tegra_pmc_writel(pmc, DPD_SAMPLE_DISABLE, DPD_SAMPLE);
1595 }
1596
1597 /**
1598 * tegra_io_pad_power_enable() - enable power to I/O pad
1599 * @id: Tegra I/O pad ID for which to enable power
1600 *
1601 * Returns: 0 on success or a negative error code on failure.
1602 */
1603 int tegra_io_pad_power_enable(enum tegra_io_pad id)
1604 {
1605 const struct tegra_io_pad_soc *pad;
1606 unsigned long request, status;
1607 u32 mask;
1608 int err;
1609
1610 pad = tegra_io_pad_find(pmc, id);
1611 if (!pad) {
1612 dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);
1613 return -ENOENT;
1614 }
1615
1616 mutex_lock(&pmc->powergates_lock);
1617
1618 err = tegra_io_pad_prepare(pmc, pad, &request, &status, &mask);
1619 if (err < 0) {
1620 dev_err(pmc->dev, "failed to prepare I/O pad: %d\n", err);
1621 goto unlock;
1622 }
1623
1624 tegra_pmc_writel(pmc, IO_DPD_REQ_CODE_OFF | mask, request);
1625
1626 err = tegra_io_pad_poll(pmc, status, mask, 0, 250);
1627 if (err < 0) {
1628 dev_err(pmc->dev, "failed to enable I/O pad: %d\n", err);
1629 goto unlock;
1630 }
1631
1632 tegra_io_pad_unprepare(pmc);
1633
1634 unlock:
1635 mutex_unlock(&pmc->powergates_lock);
1636 return err;
1637 }
1638 EXPORT_SYMBOL(tegra_io_pad_power_enable);
1639
1640 /**
1641 * tegra_io_pad_power_disable() - disable power to I/O pad
1642 * @id: Tegra I/O pad ID for which to disable power
1643 *
1644 * Returns: 0 on success or a negative error code on failure.
1645 */
1646 int tegra_io_pad_power_disable(enum tegra_io_pad id)
1647 {
1648 const struct tegra_io_pad_soc *pad;
1649 unsigned long request, status;
1650 u32 mask;
1651 int err;
1652
1653 pad = tegra_io_pad_find(pmc, id);
1654 if (!pad) {
1655 dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);
1656 return -ENOENT;
1657 }
1658
1659 mutex_lock(&pmc->powergates_lock);
1660
1661 err = tegra_io_pad_prepare(pmc, pad, &request, &status, &mask);
1662 if (err < 0) {
1663 dev_err(pmc->dev, "failed to prepare I/O pad: %d\n", err);
1664 goto unlock;
1665 }
1666
1667 tegra_pmc_writel(pmc, IO_DPD_REQ_CODE_ON | mask, request);
1668
1669 err = tegra_io_pad_poll(pmc, status, mask, mask, 250);
1670 if (err < 0) {
1671 dev_err(pmc->dev, "failed to disable I/O pad: %d\n", err);
1672 goto unlock;
1673 }
1674
1675 tegra_io_pad_unprepare(pmc);
1676
1677 unlock:
1678 mutex_unlock(&pmc->powergates_lock);
1679 return err;
1680 }
1681 EXPORT_SYMBOL(tegra_io_pad_power_disable);
1682
1683 static int tegra_io_pad_is_powered(struct tegra_pmc *pmc, enum tegra_io_pad id)
1684 {
1685 const struct tegra_io_pad_soc *pad;
1686 unsigned long status;
1687 u32 mask, value;
1688
1689 pad = tegra_io_pad_find(pmc, id);
1690 if (!pad) {
1691 dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);
1692 return -ENOENT;
1693 }
1694
1695 if (pad->dpd == UINT_MAX)
1696 return -EINVAL;
1697
1698 status = pad->status;
1699 mask = BIT(pad->dpd);
1700
1701 value = tegra_pmc_readl(pmc, status);
1702
1703 return !(value & mask);
1704 }
1705
1706 static int tegra_io_pad_set_voltage(struct tegra_pmc *pmc, enum tegra_io_pad id,
1707 int voltage)
1708 {
1709 const struct tegra_io_pad_soc *pad;
1710 u32 value;
1711
1712 pad = tegra_io_pad_find(pmc, id);
1713 if (!pad)
1714 return -ENOENT;
1715
1716 if (pad->voltage == UINT_MAX)
1717 return -ENOTSUPP;
1718
1719 mutex_lock(&pmc->powergates_lock);
1720
1721 if (pmc->soc->has_impl_33v_pwr) {
1722 value = tegra_pmc_readl(pmc, PMC_IMPL_E_33V_PWR);
1723
1724 if (voltage == TEGRA_IO_PAD_VOLTAGE_1V8)
1725 value &= ~BIT(pad->voltage);
1726 else
1727 value |= BIT(pad->voltage);
1728
1729 tegra_pmc_writel(pmc, value, PMC_IMPL_E_33V_PWR);
1730 } else {
1731 /* write-enable PMC_PWR_DET_VALUE[pad->voltage] */
1732 value = tegra_pmc_readl(pmc, PMC_PWR_DET);
1733 value |= BIT(pad->voltage);
1734 tegra_pmc_writel(pmc, value, PMC_PWR_DET);
1735
1736 /* update I/O voltage */
1737 value = tegra_pmc_readl(pmc, PMC_PWR_DET_VALUE);
1738
1739 if (voltage == TEGRA_IO_PAD_VOLTAGE_1V8)
1740 value &= ~BIT(pad->voltage);
1741 else
1742 value |= BIT(pad->voltage);
1743
1744 tegra_pmc_writel(pmc, value, PMC_PWR_DET_VALUE);
1745 }
1746
1747 mutex_unlock(&pmc->powergates_lock);
1748
1749 usleep_range(100, 250);
1750
1751 return 0;
1752 }
1753
1754 static int tegra_io_pad_get_voltage(struct tegra_pmc *pmc, enum tegra_io_pad id)
1755 {
1756 const struct tegra_io_pad_soc *pad;
1757 u32 value;
1758
1759 pad = tegra_io_pad_find(pmc, id);
1760 if (!pad)
1761 return -ENOENT;
1762
1763 if (pad->voltage == UINT_MAX)
1764 return -ENOTSUPP;
1765
1766 if (pmc->soc->has_impl_33v_pwr)
1767 value = tegra_pmc_readl(pmc, PMC_IMPL_E_33V_PWR);
1768 else
1769 value = tegra_pmc_readl(pmc, PMC_PWR_DET_VALUE);
1770
1771 if ((value & BIT(pad->voltage)) == 0)
1772 return TEGRA_IO_PAD_VOLTAGE_1V8;
1773
1774 return TEGRA_IO_PAD_VOLTAGE_3V3;
1775 }
1776
1777 #ifdef CONFIG_PM_SLEEP
1778 enum tegra_suspend_mode tegra_pmc_get_suspend_mode(void)
1779 {
1780 return pmc->suspend_mode;
1781 }
1782
1783 void tegra_pmc_set_suspend_mode(enum tegra_suspend_mode mode)
1784 {
1785 if (mode < TEGRA_SUSPEND_NONE || mode >= TEGRA_MAX_SUSPEND_MODE)
1786 return;
1787
1788 pmc->suspend_mode = mode;
1789 }
1790
1791 void tegra_pmc_enter_suspend_mode(enum tegra_suspend_mode mode)
1792 {
1793 unsigned long long rate = 0;
1794 u64 ticks;
1795 u32 value;
1796
1797 switch (mode) {
1798 case TEGRA_SUSPEND_LP1:
1799 rate = 32768;
1800 break;
1801
1802 case TEGRA_SUSPEND_LP2:
1803 rate = pmc->rate;
1804 break;
1805
1806 default:
1807 break;
1808 }
1809
1810 if (WARN_ON_ONCE(rate == 0))
1811 rate = 100000000;
1812
1813 ticks = pmc->cpu_good_time * rate + USEC_PER_SEC - 1;
1814 do_div(ticks, USEC_PER_SEC);
1815 tegra_pmc_writel(pmc, ticks, PMC_CPUPWRGOOD_TIMER);
1816
1817 ticks = pmc->cpu_off_time * rate + USEC_PER_SEC - 1;
1818 do_div(ticks, USEC_PER_SEC);
1819 tegra_pmc_writel(pmc, ticks, PMC_CPUPWROFF_TIMER);
1820
1821 value = tegra_pmc_readl(pmc, PMC_CNTRL);
1822 value &= ~PMC_CNTRL_SIDE_EFFECT_LP0;
1823 value |= PMC_CNTRL_CPU_PWRREQ_OE;
1824 tegra_pmc_writel(pmc, value, PMC_CNTRL);
1825 }
1826 #endif
1827
1828 static int tegra_pmc_parse_dt(struct tegra_pmc *pmc, struct device_node *np)
1829 {
1830 u32 value, values[2];
1831
1832 if (of_property_read_u32(np, "nvidia,suspend-mode", &value)) {
1833 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1834 } else {
1835 switch (value) {
1836 case 0:
1837 pmc->suspend_mode = TEGRA_SUSPEND_LP0;
1838 break;
1839
1840 case 1:
1841 pmc->suspend_mode = TEGRA_SUSPEND_LP1;
1842 break;
1843
1844 case 2:
1845 pmc->suspend_mode = TEGRA_SUSPEND_LP2;
1846 break;
1847
1848 default:
1849 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1850 break;
1851 }
1852 }
1853
1854 pmc->suspend_mode = tegra_pm_validate_suspend_mode(pmc->suspend_mode);
1855
1856 if (of_property_read_u32(np, "nvidia,cpu-pwr-good-time", &value))
1857 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1858
1859 pmc->cpu_good_time = value;
1860
1861 if (of_property_read_u32(np, "nvidia,cpu-pwr-off-time", &value))
1862 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1863
1864 pmc->cpu_off_time = value;
1865
1866 if (of_property_read_u32_array(np, "nvidia,core-pwr-good-time",
1867 values, ARRAY_SIZE(values)))
1868 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1869
1870 pmc->core_osc_time = values[0];
1871 pmc->core_pmu_time = values[1];
1872
1873 if (of_property_read_u32(np, "nvidia,core-pwr-off-time", &value))
1874 pmc->suspend_mode = TEGRA_SUSPEND_NONE;
1875
1876 pmc->core_off_time = value;
1877
1878 pmc->corereq_high = of_property_read_bool(np,
1879 "nvidia,core-power-req-active-high");
1880
1881 pmc->sysclkreq_high = of_property_read_bool(np,
1882 "nvidia,sys-clock-req-active-high");
1883
1884 pmc->combined_req = of_property_read_bool(np,
1885 "nvidia,combined-power-req");
1886
1887 pmc->cpu_pwr_good_en = of_property_read_bool(np,
1888 "nvidia,cpu-pwr-good-en");
1889
1890 if (of_property_read_u32_array(np, "nvidia,lp0-vec", values,
1891 ARRAY_SIZE(values)))
1892 if (pmc->suspend_mode == TEGRA_SUSPEND_LP0)
1893 pmc->suspend_mode = TEGRA_SUSPEND_LP1;
1894
1895 pmc->lp0_vec_phys = values[0];
1896 pmc->lp0_vec_size = values[1];
1897
1898 return 0;
1899 }
1900
1901 static int tegra_pmc_init(struct tegra_pmc *pmc)
1902 {
1903 if (pmc->soc->max_wake_events > 0) {
1904 pmc->wake_type_level_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);
1905 if (!pmc->wake_type_level_map)
1906 return -ENOMEM;
1907
1908 pmc->wake_type_dual_edge_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);
1909 if (!pmc->wake_type_dual_edge_map)
1910 return -ENOMEM;
1911
1912 pmc->wake_sw_status_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);
1913 if (!pmc->wake_sw_status_map)
1914 return -ENOMEM;
1915
1916 pmc->wake_cntrl_level_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);
1917 if (!pmc->wake_cntrl_level_map)
1918 return -ENOMEM;
1919 }
1920
1921 if (pmc->soc->init)
1922 pmc->soc->init(pmc);
1923
1924 return 0;
1925 }
1926
1927 static void tegra_pmc_init_tsense_reset(struct tegra_pmc *pmc)
1928 {
1929 static const char disabled[] = "emergency thermal reset disabled";
1930 u32 pmu_addr, ctrl_id, reg_addr, reg_data, pinmux;
1931 struct device *dev = pmc->dev;
1932 struct device_node *np;
1933 u32 value, checksum;
1934
1935 if (!pmc->soc->has_tsense_reset)
1936 return;
1937
1938 np = of_get_child_by_name(pmc->dev->of_node, "i2c-thermtrip");
1939 if (!np) {
1940 dev_warn(dev, "i2c-thermtrip node not found, %s.\n", disabled);
1941 return;
1942 }
1943
1944 if (of_property_read_u32(np, "nvidia,i2c-controller-id", &ctrl_id)) {
1945 dev_err(dev, "I2C controller ID missing, %s.\n", disabled);
1946 goto out;
1947 }
1948
1949 if (of_property_read_u32(np, "nvidia,bus-addr", &pmu_addr)) {
1950 dev_err(dev, "nvidia,bus-addr missing, %s.\n", disabled);
1951 goto out;
1952 }
1953
1954 if (of_property_read_u32(np, "nvidia,reg-addr", &reg_addr)) {
1955 dev_err(dev, "nvidia,reg-addr missing, %s.\n", disabled);
1956 goto out;
1957 }
1958
1959 if (of_property_read_u32(np, "nvidia,reg-data", &reg_data)) {
1960 dev_err(dev, "nvidia,reg-data missing, %s.\n", disabled);
1961 goto out;
1962 }
1963
1964 if (of_property_read_u32(np, "nvidia,pinmux-id", &pinmux))
1965 pinmux = 0;
1966
1967 value = tegra_pmc_readl(pmc, PMC_SENSOR_CTRL);
1968 value |= PMC_SENSOR_CTRL_SCRATCH_WRITE;
1969 tegra_pmc_writel(pmc, value, PMC_SENSOR_CTRL);
1970
1971 value = (reg_data << PMC_SCRATCH54_DATA_SHIFT) |
1972 (reg_addr << PMC_SCRATCH54_ADDR_SHIFT);
1973 tegra_pmc_writel(pmc, value, PMC_SCRATCH54);
1974
1975 value = PMC_SCRATCH55_RESET_TEGRA;
1976 value |= ctrl_id << PMC_SCRATCH55_CNTRL_ID_SHIFT;
1977 value |= pinmux << PMC_SCRATCH55_PINMUX_SHIFT;
1978 value |= pmu_addr << PMC_SCRATCH55_I2CSLV1_SHIFT;
1979
1980 /*
1981 * Calculate checksum of SCRATCH54, SCRATCH55 fields. Bits 23:16 will
1982 * contain the checksum and are currently zero, so they are not added.
1983 */
1984 checksum = reg_addr + reg_data + (value & 0xff) + ((value >> 8) & 0xff)
1985 + ((value >> 24) & 0xff);
1986 checksum &= 0xff;
1987 checksum = 0x100 - checksum;
1988
1989 value |= checksum << PMC_SCRATCH55_CHECKSUM_SHIFT;
1990
1991 tegra_pmc_writel(pmc, value, PMC_SCRATCH55);
1992
1993 value = tegra_pmc_readl(pmc, PMC_SENSOR_CTRL);
1994 value |= PMC_SENSOR_CTRL_ENABLE_RST;
1995 tegra_pmc_writel(pmc, value, PMC_SENSOR_CTRL);
1996
1997 dev_info(pmc->dev, "emergency thermal reset enabled\n");
1998
1999 out:
2000 of_node_put(np);
2001 }
2002
2003 static int tegra_io_pad_pinctrl_get_groups_count(struct pinctrl_dev *pctl_dev)
2004 {
2005 struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
2006
2007 return pmc->soc->num_io_pads;
2008 }
2009
2010 static const char *tegra_io_pad_pinctrl_get_group_name(struct pinctrl_dev *pctl,
2011 unsigned int group)
2012 {
2013 struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl);
2014
2015 return pmc->soc->io_pads[group].name;
2016 }
2017
2018 static int tegra_io_pad_pinctrl_get_group_pins(struct pinctrl_dev *pctl_dev,
2019 unsigned int group,
2020 const unsigned int **pins,
2021 unsigned int *num_pins)
2022 {
2023 struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
2024
2025 *pins = &pmc->soc->io_pads[group].id;
2026 *num_pins = 1;
2027
2028 return 0;
2029 }
2030
2031 static const struct pinctrl_ops tegra_io_pad_pinctrl_ops = {
2032 .get_groups_count = tegra_io_pad_pinctrl_get_groups_count,
2033 .get_group_name = tegra_io_pad_pinctrl_get_group_name,
2034 .get_group_pins = tegra_io_pad_pinctrl_get_group_pins,
2035 .dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
2036 .dt_free_map = pinconf_generic_dt_free_map,
2037 };
2038
2039 static int tegra_io_pad_pinconf_get(struct pinctrl_dev *pctl_dev,
2040 unsigned int pin, unsigned long *config)
2041 {
2042 enum pin_config_param param = pinconf_to_config_param(*config);
2043 struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
2044 const struct tegra_io_pad_soc *pad;
2045 int ret;
2046 u32 arg;
2047
2048 pad = tegra_io_pad_find(pmc, pin);
2049 if (!pad)
2050 return -EINVAL;
2051
2052 switch (param) {
2053 case PIN_CONFIG_POWER_SOURCE:
2054 ret = tegra_io_pad_get_voltage(pmc, pad->id);
2055 if (ret < 0)
2056 return ret;
2057
2058 arg = ret;
2059 break;
2060
2061 case PIN_CONFIG_MODE_LOW_POWER:
2062 ret = tegra_io_pad_is_powered(pmc, pad->id);
2063 if (ret < 0)
2064 return ret;
2065
2066 arg = !ret;
2067 break;
2068
2069 default:
2070 return -EINVAL;
2071 }
2072
2073 *config = pinconf_to_config_packed(param, arg);
2074
2075 return 0;
2076 }
2077
2078 static int tegra_io_pad_pinconf_set(struct pinctrl_dev *pctl_dev,
2079 unsigned int pin, unsigned long *configs,
2080 unsigned int num_configs)
2081 {
2082 struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);
2083 const struct tegra_io_pad_soc *pad;
2084 enum pin_config_param param;
2085 unsigned int i;
2086 int err;
2087 u32 arg;
2088
2089 pad = tegra_io_pad_find(pmc, pin);
2090 if (!pad)
2091 return -EINVAL;
2092
2093 for (i = 0; i < num_configs; ++i) {
2094 param = pinconf_to_config_param(configs[i]);
2095 arg = pinconf_to_config_argument(configs[i]);
2096
2097 switch (param) {
2098 case PIN_CONFIG_MODE_LOW_POWER:
2099 if (arg)
2100 err = tegra_io_pad_power_disable(pad->id);
2101 else
2102 err = tegra_io_pad_power_enable(pad->id);
2103 if (err)
2104 return err;
2105 break;
2106 case PIN_CONFIG_POWER_SOURCE:
2107 if (arg != TEGRA_IO_PAD_VOLTAGE_1V8 &&
2108 arg != TEGRA_IO_PAD_VOLTAGE_3V3)
2109 return -EINVAL;
2110 err = tegra_io_pad_set_voltage(pmc, pad->id, arg);
2111 if (err)
2112 return err;
2113 break;
2114 default:
2115 return -EINVAL;
2116 }
2117 }
2118
2119 return 0;
2120 }
2121
2122 static const struct pinconf_ops tegra_io_pad_pinconf_ops = {
2123 .pin_config_get = tegra_io_pad_pinconf_get,
2124 .pin_config_set = tegra_io_pad_pinconf_set,
2125 .is_generic = true,
2126 };
2127
2128 static struct pinctrl_desc tegra_pmc_pctl_desc = {
2129 .pctlops = &tegra_io_pad_pinctrl_ops,
2130 .confops = &tegra_io_pad_pinconf_ops,
2131 };
2132
2133 static int tegra_pmc_pinctrl_init(struct tegra_pmc *pmc)
2134 {
2135 int err;
2136
2137 if (!pmc->soc->num_pin_descs)
2138 return 0;
2139
2140 tegra_pmc_pctl_desc.name = dev_name(pmc->dev);
2141 tegra_pmc_pctl_desc.pins = pmc->soc->pin_descs;
2142 tegra_pmc_pctl_desc.npins = pmc->soc->num_pin_descs;
2143
2144 pmc->pctl_dev = devm_pinctrl_register(pmc->dev, &tegra_pmc_pctl_desc,
2145 pmc);
2146 if (IS_ERR(pmc->pctl_dev)) {
2147 err = PTR_ERR(pmc->pctl_dev);
2148 dev_err(pmc->dev, "failed to register pin controller: %d\n",
2149 err);
2150 return err;
2151 }
2152
2153 return 0;
2154 }
2155
2156 static ssize_t reset_reason_show(struct device *dev,
2157 struct device_attribute *attr, char *buf)
2158 {
2159 u32 value;
2160
2161 value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);
2162 value &= pmc->soc->regs->rst_source_mask;
2163 value >>= pmc->soc->regs->rst_source_shift;
2164
2165 if (WARN_ON(value >= pmc->soc->num_reset_sources))
2166 return sprintf(buf, "%s\n", "UNKNOWN");
2167
2168 return sprintf(buf, "%s\n", pmc->soc->reset_sources[value]);
2169 }
2170
2171 static DEVICE_ATTR_RO(reset_reason);
2172
2173 static ssize_t reset_level_show(struct device *dev,
2174 struct device_attribute *attr, char *buf)
2175 {
2176 u32 value;
2177
2178 value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);
2179 value &= pmc->soc->regs->rst_level_mask;
2180 value >>= pmc->soc->regs->rst_level_shift;
2181
2182 if (WARN_ON(value >= pmc->soc->num_reset_levels))
2183 return sprintf(buf, "%s\n", "UNKNOWN");
2184
2185 return sprintf(buf, "%s\n", pmc->soc->reset_levels[value]);
2186 }
2187
2188 static DEVICE_ATTR_RO(reset_level);
2189
2190 static void tegra_pmc_reset_sysfs_init(struct tegra_pmc *pmc)
2191 {
2192 struct device *dev = pmc->dev;
2193 int err = 0;
2194
2195 if (pmc->soc->reset_sources) {
2196 err = device_create_file(dev, &dev_attr_reset_reason);
2197 if (err < 0)
2198 dev_warn(dev,
2199 "failed to create attr \"reset_reason\": %d\n",
2200 err);
2201 }
2202
2203 if (pmc->soc->reset_levels) {
2204 err = device_create_file(dev, &dev_attr_reset_level);
2205 if (err < 0)
2206 dev_warn(dev,
2207 "failed to create attr \"reset_level\": %d\n",
2208 err);
2209 }
2210 }
2211
2212 static int tegra_pmc_irq_translate(struct irq_domain *domain,
2213 struct irq_fwspec *fwspec,
2214 unsigned long *hwirq,
2215 unsigned int *type)
2216 {
2217 if (WARN_ON(fwspec->param_count < 2))
2218 return -EINVAL;
2219
2220 *hwirq = fwspec->param[0];
2221 *type = fwspec->param[1];
2222
2223 return 0;
2224 }
2225
2226 static int tegra_pmc_irq_alloc(struct irq_domain *domain, unsigned int virq,
2227 unsigned int num_irqs, void *data)
2228 {
2229 struct tegra_pmc *pmc = domain->host_data;
2230 const struct tegra_pmc_soc *soc = pmc->soc;
2231 struct irq_fwspec *fwspec = data;
2232 unsigned int i;
2233 int err = 0;
2234
2235 if (WARN_ON(num_irqs > 1))
2236 return -EINVAL;
2237
2238 for (i = 0; i < soc->num_wake_events; i++) {
2239 const struct tegra_wake_event *event = &soc->wake_events[i];
2240
2241 /* IRQ and simple wake events */
2242 if (fwspec->param_count == 2) {
2243 struct irq_fwspec spec;
2244
2245 if (event->id != fwspec->param[0])
2246 continue;
2247
2248 err = irq_domain_set_hwirq_and_chip(domain, virq,
2249 event->id,
2250 &pmc->irq, pmc);
2251 if (err < 0)
2252 break;
2253
2254 /* simple hierarchies stop at the PMC level */
2255 if (event->irq == 0) {
2256 err = irq_domain_disconnect_hierarchy(domain->parent, virq);
2257 break;
2258 }
2259
2260 spec.fwnode = &pmc->dev->of_node->fwnode;
2261 spec.param_count = 3;
2262 spec.param[0] = GIC_SPI;
2263 spec.param[1] = event->irq;
2264 spec.param[2] = fwspec->param[1];
2265
2266 err = irq_domain_alloc_irqs_parent(domain, virq,
2267 num_irqs, &spec);
2268
2269 break;
2270 }
2271
2272 /* GPIO wake events */
2273 if (fwspec->param_count == 3) {
2274 if (event->gpio.instance != fwspec->param[0] ||
2275 event->gpio.pin != fwspec->param[1])
2276 continue;
2277
2278 err = irq_domain_set_hwirq_and_chip(domain, virq,
2279 event->id,
2280 &pmc->irq, pmc);
2281
2282 /* GPIO hierarchies stop at the PMC level */
2283 if (!err && domain->parent)
2284 err = irq_domain_disconnect_hierarchy(domain->parent,
2285 virq);
2286 break;
2287 }
2288 }
2289
2290 /* If there is no wake-up event, there is no PMC mapping */
2291 if (i == soc->num_wake_events)
2292 err = irq_domain_disconnect_hierarchy(domain, virq);
2293
2294 return err;
2295 }
2296
2297 static const struct irq_domain_ops tegra_pmc_irq_domain_ops = {
2298 .translate = tegra_pmc_irq_translate,
2299 .alloc = tegra_pmc_irq_alloc,
2300 };
2301
2302 static int tegra210_pmc_irq_set_wake(struct irq_data *data, unsigned int on)
2303 {
2304 struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2305 unsigned int offset, bit;
2306 u32 value;
2307
2308 offset = data->hwirq / 32;
2309 bit = data->hwirq % 32;
2310
2311 /* clear wake status */
2312 tegra_pmc_writel(pmc, 0, PMC_SW_WAKE_STATUS);
2313 tegra_pmc_writel(pmc, 0, PMC_SW_WAKE2_STATUS);
2314
2315 tegra_pmc_writel(pmc, 0, PMC_WAKE_STATUS);
2316 tegra_pmc_writel(pmc, 0, PMC_WAKE2_STATUS);
2317
2318 /* enable PMC wake */
2319 if (data->hwirq >= 32)
2320 offset = PMC_WAKE2_MASK;
2321 else
2322 offset = PMC_WAKE_MASK;
2323
2324 value = tegra_pmc_readl(pmc, offset);
2325
2326 if (on)
2327 value |= BIT(bit);
2328 else
2329 value &= ~BIT(bit);
2330
2331 tegra_pmc_writel(pmc, value, offset);
2332
2333 return 0;
2334 }
2335
2336 static int tegra210_pmc_irq_set_type(struct irq_data *data, unsigned int type)
2337 {
2338 struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2339 unsigned int offset, bit;
2340 u32 value;
2341
2342 offset = data->hwirq / 32;
2343 bit = data->hwirq % 32;
2344
2345 if (data->hwirq >= 32)
2346 offset = PMC_WAKE2_LEVEL;
2347 else
2348 offset = PMC_WAKE_LEVEL;
2349
2350 value = tegra_pmc_readl(pmc, offset);
2351
2352 switch (type) {
2353 case IRQ_TYPE_EDGE_RISING:
2354 case IRQ_TYPE_LEVEL_HIGH:
2355 value |= BIT(bit);
2356 break;
2357
2358 case IRQ_TYPE_EDGE_FALLING:
2359 case IRQ_TYPE_LEVEL_LOW:
2360 value &= ~BIT(bit);
2361 break;
2362
2363 case IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING:
2364 value ^= BIT(bit);
2365 break;
2366
2367 default:
2368 return -EINVAL;
2369 }
2370
2371 tegra_pmc_writel(pmc, value, offset);
2372
2373 return 0;
2374 }
2375
2376 static void tegra186_pmc_set_wake_filters(struct tegra_pmc *pmc)
2377 {
2378 u32 value;
2379
2380 /* SW Wake (wake83) needs SR_CAPTURE filter to be enabled */
2381 value = readl(pmc->wake + WAKE_AOWAKE_CNTRL(SW_WAKE_ID));
2382 value |= WAKE_AOWAKE_CNTRL_SR_CAPTURE_EN;
2383 writel(value, pmc->wake + WAKE_AOWAKE_CNTRL(SW_WAKE_ID));
2384 dev_dbg(pmc->dev, "WAKE_AOWAKE_CNTRL_83 = 0x%x\n", value);
2385 }
2386
2387 static int tegra186_pmc_irq_set_wake(struct irq_data *data, unsigned int on)
2388 {
2389 struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2390 unsigned int offset, bit;
2391 u32 value;
2392
2393 offset = data->hwirq / 32;
2394 bit = data->hwirq % 32;
2395
2396 /* clear wake status */
2397 writel(0x1, pmc->wake + WAKE_AOWAKE_STATUS_W(data->hwirq));
2398
2399 /* route wake to tier 2 */
2400 value = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(offset));
2401
2402 if (!on)
2403 value &= ~(1 << bit);
2404 else
2405 value |= 1 << bit;
2406
2407 writel(value, pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(offset));
2408
2409 /* enable wakeup event */
2410 writel(!!on, pmc->wake + WAKE_AOWAKE_MASK_W(data->hwirq));
2411
2412 return 0;
2413 }
2414
2415 static int tegra186_pmc_irq_set_type(struct irq_data *data, unsigned int type)
2416 {
2417 struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);
2418 u32 value;
2419
2420 value = readl(pmc->wake + WAKE_AOWAKE_CNTRL(data->hwirq));
2421
2422 switch (type) {
2423 case IRQ_TYPE_EDGE_RISING:
2424 case IRQ_TYPE_LEVEL_HIGH:
2425 value |= WAKE_AOWAKE_CNTRL_LEVEL;
2426 set_bit(data->hwirq, pmc->wake_type_level_map);
2427 clear_bit(data->hwirq, pmc->wake_type_dual_edge_map);
2428 break;
2429
2430 case IRQ_TYPE_EDGE_FALLING:
2431 case IRQ_TYPE_LEVEL_LOW:
2432 value &= ~WAKE_AOWAKE_CNTRL_LEVEL;
2433 clear_bit(data->hwirq, pmc->wake_type_level_map);
2434 clear_bit(data->hwirq, pmc->wake_type_dual_edge_map);
2435 break;
2436
2437 case IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING:
2438 value ^= WAKE_AOWAKE_CNTRL_LEVEL;
2439 clear_bit(data->hwirq, pmc->wake_type_level_map);
2440 set_bit(data->hwirq, pmc->wake_type_dual_edge_map);
2441 break;
2442
2443 default:
2444 return -EINVAL;
2445 }
2446
2447 writel(value, pmc->wake + WAKE_AOWAKE_CNTRL(data->hwirq));
2448
2449 return 0;
2450 }
2451
2452 static void tegra_irq_mask_parent(struct irq_data *data)
2453 {
2454 if (data->parent_data)
2455 irq_chip_mask_parent(data);
2456 }
2457
2458 static void tegra_irq_unmask_parent(struct irq_data *data)
2459 {
2460 if (data->parent_data)
2461 irq_chip_unmask_parent(data);
2462 }
2463
2464 static void tegra_irq_eoi_parent(struct irq_data *data)
2465 {
2466 if (data->parent_data)
2467 irq_chip_eoi_parent(data);
2468 }
2469
2470 static int tegra_irq_set_affinity_parent(struct irq_data *data,
2471 const struct cpumask *dest,
2472 bool force)
2473 {
2474 if (data->parent_data)
2475 return irq_chip_set_affinity_parent(data, dest, force);
2476
2477 return -EINVAL;
2478 }
2479
2480 static int tegra_pmc_irq_init(struct tegra_pmc *pmc)
2481 {
2482 struct irq_domain *parent = NULL;
2483 struct device_node *np;
2484
2485 np = of_irq_find_parent(pmc->dev->of_node);
2486 if (np) {
2487 parent = irq_find_host(np);
2488 of_node_put(np);
2489 }
2490
2491 if (!parent)
2492 return 0;
2493
2494 pmc->irq.name = dev_name(pmc->dev);
2495 pmc->irq.irq_mask = tegra_irq_mask_parent;
2496 pmc->irq.irq_unmask = tegra_irq_unmask_parent;
2497 pmc->irq.irq_eoi = tegra_irq_eoi_parent;
2498 pmc->irq.irq_set_affinity = tegra_irq_set_affinity_parent;
2499 pmc->irq.irq_set_type = pmc->soc->irq_set_type;
2500 pmc->irq.irq_set_wake = pmc->soc->irq_set_wake;
2501
2502 pmc->domain = irq_domain_add_hierarchy(parent, 0, 96, pmc->dev->of_node,
2503 &tegra_pmc_irq_domain_ops, pmc);
2504 if (!pmc->domain) {
2505 dev_err(pmc->dev, "failed to allocate domain\n");
2506 return -ENOMEM;
2507 }
2508
2509 return 0;
2510 }
2511
2512 static int tegra_pmc_clk_notify_cb(struct notifier_block *nb,
2513 unsigned long action, void *ptr)
2514 {
2515 struct tegra_pmc *pmc = container_of(nb, struct tegra_pmc, clk_nb);
2516 struct clk_notifier_data *data = ptr;
2517
2518 switch (action) {
2519 case PRE_RATE_CHANGE:
2520 mutex_lock(&pmc->powergates_lock);
2521 break;
2522
2523 case POST_RATE_CHANGE:
2524 pmc->rate = data->new_rate;
2525 fallthrough;
2526
2527 case ABORT_RATE_CHANGE:
2528 mutex_unlock(&pmc->powergates_lock);
2529 break;
2530
2531 default:
2532 WARN_ON_ONCE(1);
2533 return notifier_from_errno(-EINVAL);
2534 }
2535
2536 return NOTIFY_OK;
2537 }
2538
2539 static void pmc_clk_fence_udelay(u32 offset)
2540 {
2541 tegra_pmc_readl(pmc, offset);
2542 /* pmc clk propagation delay 2 us */
2543 udelay(2);
2544 }
2545
2546 static u8 pmc_clk_mux_get_parent(struct clk_hw *hw)
2547 {
2548 struct pmc_clk *clk = to_pmc_clk(hw);
2549 u32 val;
2550
2551 val = tegra_pmc_readl(pmc, clk->offs) >> clk->mux_shift;
2552 val &= PMC_CLK_OUT_MUX_MASK;
2553
2554 return val;
2555 }
2556
2557 static int pmc_clk_mux_set_parent(struct clk_hw *hw, u8 index)
2558 {
2559 struct pmc_clk *clk = to_pmc_clk(hw);
2560 u32 val;
2561
2562 val = tegra_pmc_readl(pmc, clk->offs);
2563 val &= ~(PMC_CLK_OUT_MUX_MASK << clk->mux_shift);
2564 val |= index << clk->mux_shift;
2565 tegra_pmc_writel(pmc, val, clk->offs);
2566 pmc_clk_fence_udelay(clk->offs);
2567
2568 return 0;
2569 }
2570
2571 static int pmc_clk_is_enabled(struct clk_hw *hw)
2572 {
2573 struct pmc_clk *clk = to_pmc_clk(hw);
2574 u32 val;
2575
2576 val = tegra_pmc_readl(pmc, clk->offs) & BIT(clk->force_en_shift);
2577
2578 return val ? 1 : 0;
2579 }
2580
2581 static void pmc_clk_set_state(unsigned long offs, u32 shift, int state)
2582 {
2583 u32 val;
2584
2585 val = tegra_pmc_readl(pmc, offs);
2586 val = state ? (val | BIT(shift)) : (val & ~BIT(shift));
2587 tegra_pmc_writel(pmc, val, offs);
2588 pmc_clk_fence_udelay(offs);
2589 }
2590
2591 static int pmc_clk_enable(struct clk_hw *hw)
2592 {
2593 struct pmc_clk *clk = to_pmc_clk(hw);
2594
2595 pmc_clk_set_state(clk->offs, clk->force_en_shift, 1);
2596
2597 return 0;
2598 }
2599
2600 static void pmc_clk_disable(struct clk_hw *hw)
2601 {
2602 struct pmc_clk *clk = to_pmc_clk(hw);
2603
2604 pmc_clk_set_state(clk->offs, clk->force_en_shift, 0);
2605 }
2606
2607 static const struct clk_ops pmc_clk_ops = {
2608 .get_parent = pmc_clk_mux_get_parent,
2609 .set_parent = pmc_clk_mux_set_parent,
2610 .determine_rate = __clk_mux_determine_rate,
2611 .is_enabled = pmc_clk_is_enabled,
2612 .enable = pmc_clk_enable,
2613 .disable = pmc_clk_disable,
2614 };
2615
2616 static struct clk *
2617 tegra_pmc_clk_out_register(struct tegra_pmc *pmc,
2618 const struct pmc_clk_init_data *data,
2619 unsigned long offset)
2620 {
2621 struct clk_init_data init;
2622 struct pmc_clk *pmc_clk;
2623
2624 pmc_clk = devm_kzalloc(pmc->dev, sizeof(*pmc_clk), GFP_KERNEL);
2625 if (!pmc_clk)
2626 return ERR_PTR(-ENOMEM);
2627
2628 init.name = data->name;
2629 init.ops = &pmc_clk_ops;
2630 init.parent_names = data->parents;
2631 init.num_parents = data->num_parents;
2632 init.flags = CLK_SET_RATE_NO_REPARENT | CLK_SET_RATE_PARENT |
2633 CLK_SET_PARENT_GATE;
2634
2635 pmc_clk->hw.init = &init;
2636 pmc_clk->offs = offset;
2637 pmc_clk->mux_shift = data->mux_shift;
2638 pmc_clk->force_en_shift = data->force_en_shift;
2639
2640 return clk_register(NULL, &pmc_clk->hw);
2641 }
2642
2643 static int pmc_clk_gate_is_enabled(struct clk_hw *hw)
2644 {
2645 struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2646
2647 return tegra_pmc_readl(pmc, gate->offs) & BIT(gate->shift) ? 1 : 0;
2648 }
2649
2650 static int pmc_clk_gate_enable(struct clk_hw *hw)
2651 {
2652 struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2653
2654 pmc_clk_set_state(gate->offs, gate->shift, 1);
2655
2656 return 0;
2657 }
2658
2659 static void pmc_clk_gate_disable(struct clk_hw *hw)
2660 {
2661 struct pmc_clk_gate *gate = to_pmc_clk_gate(hw);
2662
2663 pmc_clk_set_state(gate->offs, gate->shift, 0);
2664 }
2665
2666 static const struct clk_ops pmc_clk_gate_ops = {
2667 .is_enabled = pmc_clk_gate_is_enabled,
2668 .enable = pmc_clk_gate_enable,
2669 .disable = pmc_clk_gate_disable,
2670 };
2671
2672 static struct clk *
2673 tegra_pmc_clk_gate_register(struct tegra_pmc *pmc, const char *name,
2674 const char *parent_name, unsigned long offset,
2675 u32 shift)
2676 {
2677 struct clk_init_data init;
2678 struct pmc_clk_gate *gate;
2679
2680 gate = devm_kzalloc(pmc->dev, sizeof(*gate), GFP_KERNEL);
2681 if (!gate)
2682 return ERR_PTR(-ENOMEM);
2683
2684 init.name = name;
2685 init.ops = &pmc_clk_gate_ops;
2686 init.parent_names = &parent_name;
2687 init.num_parents = 1;
2688 init.flags = 0;
2689
2690 gate->hw.init = &init;
2691 gate->offs = offset;
2692 gate->shift = shift;
2693
2694 return clk_register(NULL, &gate->hw);
2695 }
2696
2697 static void tegra_pmc_clock_register(struct tegra_pmc *pmc,
2698 struct device_node *np)
2699 {
2700 struct clk *clk;
2701 struct clk_onecell_data *clk_data;
2702 unsigned int num_clks;
2703 int i, err;
2704
2705 num_clks = pmc->soc->num_pmc_clks;
2706 if (pmc->soc->has_blink_output)
2707 num_clks += 1;
2708
2709 if (!num_clks)
2710 return;
2711
2712 clk_data = devm_kmalloc(pmc->dev, sizeof(*clk_data), GFP_KERNEL);
2713 if (!clk_data)
2714 return;
2715
2716 clk_data->clks = devm_kcalloc(pmc->dev, TEGRA_PMC_CLK_MAX,
2717 sizeof(*clk_data->clks), GFP_KERNEL);
2718 if (!clk_data->clks)
2719 return;
2720
2721 clk_data->clk_num = TEGRA_PMC_CLK_MAX;
2722
2723 for (i = 0; i < TEGRA_PMC_CLK_MAX; i++)
2724 clk_data->clks[i] = ERR_PTR(-ENOENT);
2725
2726 for (i = 0; i < pmc->soc->num_pmc_clks; i++) {
2727 const struct pmc_clk_init_data *data;
2728
2729 data = pmc->soc->pmc_clks_data + i;
2730
2731 clk = tegra_pmc_clk_out_register(pmc, data, PMC_CLK_OUT_CNTRL);
2732 if (IS_ERR(clk)) {
2733 dev_warn(pmc->dev, "unable to register clock %s: %d\n",
2734 data->name, PTR_ERR_OR_ZERO(clk));
2735 return;
2736 }
2737
2738 err = clk_register_clkdev(clk, data->name, NULL);
2739 if (err) {
2740 dev_warn(pmc->dev,
2741 "unable to register %s clock lookup: %d\n",
2742 data->name, err);
2743 return;
2744 }
2745
2746 clk_data->clks[data->clk_id] = clk;
2747 }
2748
2749 if (pmc->soc->has_blink_output) {
2750 tegra_pmc_writel(pmc, 0x0, PMC_BLINK_TIMER);
2751 clk = tegra_pmc_clk_gate_register(pmc,
2752 "pmc_blink_override",
2753 "clk_32k",
2754 PMC_DPD_PADS_ORIDE,
2755 PMC_DPD_PADS_ORIDE_BLINK);
2756 if (IS_ERR(clk)) {
2757 dev_warn(pmc->dev,
2758 "unable to register pmc_blink_override: %d\n",
2759 PTR_ERR_OR_ZERO(clk));
2760 return;
2761 }
2762
2763 clk = tegra_pmc_clk_gate_register(pmc, "pmc_blink",
2764 "pmc_blink_override",
2765 PMC_CNTRL,
2766 PMC_CNTRL_BLINK_EN);
2767 if (IS_ERR(clk)) {
2768 dev_warn(pmc->dev,
2769 "unable to register pmc_blink: %d\n",
2770 PTR_ERR_OR_ZERO(clk));
2771 return;
2772 }
2773
2774 err = clk_register_clkdev(clk, "pmc_blink", NULL);
2775 if (err) {
2776 dev_warn(pmc->dev,
2777 "unable to register pmc_blink lookup: %d\n",
2778 err);
2779 return;
2780 }
2781
2782 clk_data->clks[TEGRA_PMC_CLK_BLINK] = clk;
2783 }
2784
2785 err = of_clk_add_provider(np, of_clk_src_onecell_get, clk_data);
2786 if (err)
2787 dev_warn(pmc->dev, "failed to add pmc clock provider: %d\n",
2788 err);
2789 }
2790
2791 static const struct regmap_range pmc_usb_sleepwalk_ranges[] = {
2792 regmap_reg_range(PMC_USB_DEBOUNCE_DEL, PMC_USB_AO),
2793 regmap_reg_range(PMC_UTMIP_UHSIC_TRIGGERS, PMC_UTMIP_UHSIC_SAVED_STATE),
2794 regmap_reg_range(PMC_UTMIP_TERM_PAD_CFG, PMC_UTMIP_UHSIC_FAKE),
2795 regmap_reg_range(PMC_UTMIP_UHSIC_LINE_WAKEUP, PMC_UTMIP_UHSIC_LINE_WAKEUP),
2796 regmap_reg_range(PMC_UTMIP_BIAS_MASTER_CNTRL, PMC_UTMIP_MASTER_CONFIG),
2797 regmap_reg_range(PMC_UTMIP_UHSIC2_TRIGGERS, PMC_UTMIP_MASTER2_CONFIG),
2798 regmap_reg_range(PMC_UTMIP_PAD_CFG0, PMC_UTMIP_UHSIC_SLEEP_CFG1),
2799 regmap_reg_range(PMC_UTMIP_SLEEPWALK_P3, PMC_UTMIP_SLEEPWALK_P3),
2800 };
2801
2802 static const struct regmap_access_table pmc_usb_sleepwalk_table = {
2803 .yes_ranges = pmc_usb_sleepwalk_ranges,
2804 .n_yes_ranges = ARRAY_SIZE(pmc_usb_sleepwalk_ranges),
2805 };
2806
2807 static int tegra_pmc_regmap_readl(void *context, unsigned int offset, unsigned int *value)
2808 {
2809 struct tegra_pmc *pmc = context;
2810
2811 *value = tegra_pmc_readl(pmc, offset);
2812 return 0;
2813 }
2814
2815 static int tegra_pmc_regmap_writel(void *context, unsigned int offset, unsigned int value)
2816 {
2817 struct tegra_pmc *pmc = context;
2818
2819 tegra_pmc_writel(pmc, value, offset);
2820 return 0;
2821 }
2822
2823 static const struct regmap_config usb_sleepwalk_regmap_config = {
2824 .name = "usb_sleepwalk",
2825 .reg_bits = 32,
2826 .val_bits = 32,
2827 .reg_stride = 4,
2828 .fast_io = true,
2829 .rd_table = &pmc_usb_sleepwalk_table,
2830 .wr_table = &pmc_usb_sleepwalk_table,
2831 .reg_read = tegra_pmc_regmap_readl,
2832 .reg_write = tegra_pmc_regmap_writel,
2833 };
2834
2835 static int tegra_pmc_regmap_init(struct tegra_pmc *pmc)
2836 {
2837 struct regmap *regmap;
2838 int err;
2839
2840 if (pmc->soc->has_usb_sleepwalk) {
2841 regmap = devm_regmap_init(pmc->dev, NULL, pmc, &usb_sleepwalk_regmap_config);
2842 if (IS_ERR(regmap)) {
2843 err = PTR_ERR(regmap);
2844 dev_err(pmc->dev, "failed to allocate register map (%d)\n", err);
2845 return err;
2846 }
2847 }
2848
2849 return 0;
2850 }
2851
2852 static void tegra_pmc_reset_suspend_mode(void *data)
2853 {
2854 pmc->suspend_mode = TEGRA_SUSPEND_NOT_READY;
2855 }
2856
2857 static int tegra_pmc_probe(struct platform_device *pdev)
2858 {
2859 void __iomem *base;
2860 struct resource *res;
2861 int err;
2862
2863 /*
2864 * Early initialisation should have configured an initial
2865 * register mapping and setup the soc data pointer. If these
2866 * are not valid then something went badly wrong!
2867 */
2868 if (WARN_ON(!pmc->base || !pmc->soc))
2869 return -ENODEV;
2870
2871 err = tegra_pmc_parse_dt(pmc, pdev->dev.of_node);
2872 if (err < 0)
2873 return err;
2874
2875 err = devm_add_action_or_reset(&pdev->dev, tegra_pmc_reset_suspend_mode,
2876 NULL);
2877 if (err)
2878 return err;
2879
2880 /* take over the memory region from the early initialization */
2881 base = devm_platform_ioremap_resource(pdev, 0);
2882 if (IS_ERR(base))
2883 return PTR_ERR(base);
2884
2885 if (pmc->soc->has_single_mmio_aperture) {
2886 pmc->wake = base;
2887 pmc->aotag = base;
2888 pmc->scratch = base;
2889 } else {
2890 pmc->wake = devm_platform_ioremap_resource_byname(pdev, "wake");
2891 if (IS_ERR(pmc->wake))
2892 return PTR_ERR(pmc->wake);
2893
2894 pmc->aotag = devm_platform_ioremap_resource_byname(pdev, "aotag");
2895 if (IS_ERR(pmc->aotag))
2896 return PTR_ERR(pmc->aotag);
2897
2898 /* "scratch" is an optional aperture */
2899 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
2900 "scratch");
2901 if (res) {
2902 pmc->scratch = devm_ioremap_resource(&pdev->dev, res);
2903 if (IS_ERR(pmc->scratch))
2904 return PTR_ERR(pmc->scratch);
2905 } else {
2906 pmc->scratch = NULL;
2907 }
2908 }
2909
2910 pmc->clk = devm_clk_get_optional(&pdev->dev, "pclk");
2911 if (IS_ERR(pmc->clk))
2912 return dev_err_probe(&pdev->dev, PTR_ERR(pmc->clk),
2913 "failed to get pclk\n");
2914
2915 /*
2916 * PMC should be last resort for restarting since it soft-resets
2917 * CPU without resetting everything else.
2918 */
2919 if (pmc->scratch) {
2920 err = devm_register_reboot_notifier(&pdev->dev,
2921 &tegra_pmc_reboot_notifier);
2922 if (err) {
2923 dev_err(&pdev->dev,
2924 "unable to register reboot notifier, %d\n",
2925 err);
2926 return err;
2927 }
2928 }
2929
2930 err = devm_register_sys_off_handler(&pdev->dev,
2931 SYS_OFF_MODE_RESTART,
2932 SYS_OFF_PRIO_LOW,
2933 tegra_pmc_restart_handler, NULL);
2934 if (err) {
2935 dev_err(&pdev->dev, "failed to register sys-off handler: %d\n",
2936 err);
2937 return err;
2938 }
2939
2940 /*
2941 * PMC should be primary power-off method if it soft-resets CPU,
2942 * asking bootloader to shutdown hardware.
2943 */
2944 err = devm_register_sys_off_handler(&pdev->dev,
2945 SYS_OFF_MODE_POWER_OFF,
2946 SYS_OFF_PRIO_FIRMWARE,
2947 tegra_pmc_power_off_handler, NULL);
2948 if (err) {
2949 dev_err(&pdev->dev, "failed to register sys-off handler: %d\n",
2950 err);
2951 return err;
2952 }
2953
2954 /*
2955 * PCLK clock rate can't be retrieved using CLK API because it
2956 * causes lockup if CPU enters LP2 idle state from some other
2957 * CLK notifier, hence we're caching the rate's value locally.
2958 */
2959 if (pmc->clk) {
2960 pmc->clk_nb.notifier_call = tegra_pmc_clk_notify_cb;
2961 err = devm_clk_notifier_register(&pdev->dev, pmc->clk,
2962 &pmc->clk_nb);
2963 if (err) {
2964 dev_err(&pdev->dev,
2965 "failed to register clk notifier\n");
2966 return err;
2967 }
2968
2969 pmc->rate = clk_get_rate(pmc->clk);
2970 }
2971
2972 pmc->dev = &pdev->dev;
2973
2974 err = tegra_pmc_init(pmc);
2975 if (err < 0) {
2976 dev_err(&pdev->dev, "failed to initialize PMC: %d\n", err);
2977 return err;
2978 }
2979
2980 tegra_pmc_init_tsense_reset(pmc);
2981
2982 tegra_pmc_reset_sysfs_init(pmc);
2983
2984 err = tegra_pmc_pinctrl_init(pmc);
2985 if (err)
2986 goto cleanup_sysfs;
2987
2988 err = tegra_pmc_regmap_init(pmc);
2989 if (err < 0)
2990 goto cleanup_sysfs;
2991
2992 err = tegra_powergate_init(pmc, pdev->dev.of_node);
2993 if (err < 0)
2994 goto cleanup_powergates;
2995
2996 err = tegra_pmc_irq_init(pmc);
2997 if (err < 0)
2998 goto cleanup_powergates;
2999
3000 mutex_lock(&pmc->powergates_lock);
3001 iounmap(pmc->base);
3002 pmc->base = base;
3003 mutex_unlock(&pmc->powergates_lock);
3004
3005 tegra_pmc_clock_register(pmc, pdev->dev.of_node);
3006 platform_set_drvdata(pdev, pmc);
3007 tegra_pm_init_suspend();
3008
3009 /* Some wakes require specific filter configuration */
3010 if (pmc->soc->set_wake_filters)
3011 pmc->soc->set_wake_filters(pmc);
3012
3013 debugfs_create_file("powergate", 0444, NULL, NULL, &powergate_fops);
3014
3015 return 0;
3016
3017 cleanup_powergates:
3018 tegra_powergate_remove_all(pdev->dev.of_node);
3019 cleanup_sysfs:
3020 device_remove_file(&pdev->dev, &dev_attr_reset_reason);
3021 device_remove_file(&pdev->dev, &dev_attr_reset_level);
3022
3023 return err;
3024 }
3025
3026 /*
3027 * Ensures that sufficient time is passed for a register write to
3028 * serialize into the 32KHz domain.
3029 */
3030 static void wke_32kwritel(struct tegra_pmc *pmc, u32 value, unsigned int offset)
3031 {
3032 writel(value, pmc->wake + offset);
3033 udelay(130);
3034 }
3035
3036 static void wke_write_wake_level(struct tegra_pmc *pmc, int wake, int level)
3037 {
3038 unsigned int offset = WAKE_AOWAKE_CNTRL(wake);
3039 u32 value;
3040
3041 value = readl(pmc->wake + offset);
3042 if (level)
3043 value |= WAKE_AOWAKE_CNTRL_LEVEL;
3044 else
3045 value &= ~WAKE_AOWAKE_CNTRL_LEVEL;
3046
3047 writel(value, pmc->wake + offset);
3048 }
3049
3050 static void wke_write_wake_levels(struct tegra_pmc *pmc)
3051 {
3052 unsigned int i;
3053
3054 for (i = 0; i < pmc->soc->max_wake_events; i++)
3055 wke_write_wake_level(pmc, i, test_bit(i, pmc->wake_cntrl_level_map));
3056 }
3057
3058 static void wke_clear_sw_wake_status(struct tegra_pmc *pmc)
3059 {
3060 wke_32kwritel(pmc, 1, WAKE_AOWAKE_SW_STATUS_W_0);
3061 }
3062
3063 static void wke_read_sw_wake_status(struct tegra_pmc *pmc)
3064 {
3065 unsigned long status;
3066 unsigned int wake, i;
3067
3068 for (i = 0; i < pmc->soc->max_wake_events; i++)
3069 wke_write_wake_level(pmc, i, 0);
3070
3071 wke_clear_sw_wake_status(pmc);
3072
3073 wke_32kwritel(pmc, 1, WAKE_LATCH_SW);
3074
3075 /*
3076 * WAKE_AOWAKE_SW_STATUS is edge triggered, so in order to
3077 * obtain the current status of the input wake signals, change
3078 * the polarity of the wake level from 0->1 while latching to force
3079 * a positive edge if the sampled signal is '1'.
3080 */
3081 for (i = 0; i < pmc->soc->max_wake_events; i++)
3082 wke_write_wake_level(pmc, i, 1);
3083
3084 /*
3085 * Wait for the update to be synced into the 32kHz domain,
3086 * and let enough time lapse, so that the wake signals have time to
3087 * be sampled.
3088 */
3089 udelay(300);
3090
3091 wke_32kwritel(pmc, 0, WAKE_LATCH_SW);
3092
3093 bitmap_zero(pmc->wake_sw_status_map, pmc->soc->max_wake_events);
3094
3095 for (i = 0; i < pmc->soc->max_wake_vectors; i++) {
3096 status = readl(pmc->wake + WAKE_AOWAKE_SW_STATUS(i));
3097
3098 for_each_set_bit(wake, &status, 32)
3099 set_bit(wake + (i * 32), pmc->wake_sw_status_map);
3100 }
3101 }
3102
3103 static void wke_clear_wake_status(struct tegra_pmc *pmc)
3104 {
3105 unsigned long status;
3106 unsigned int i, wake;
3107 u32 mask;
3108
3109 for (i = 0; i < pmc->soc->max_wake_vectors; i++) {
3110 mask = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(i));
3111 status = readl(pmc->wake + WAKE_AOWAKE_STATUS_R(i)) & mask;
3112
3113 for_each_set_bit(wake, &status, 32)
3114 wke_32kwritel(pmc, 0x1, WAKE_AOWAKE_STATUS_W((i * 32) + wake));
3115 }
3116 }
3117
3118 /* translate sc7 wake sources back into IRQs to catch edge triggered wakeups */
3119 static void tegra186_pmc_process_wake_events(struct tegra_pmc *pmc, unsigned int index,
3120 unsigned long status)
3121 {
3122 unsigned int wake;
3123
3124 dev_dbg(pmc->dev, "Wake[%d:%d] status=%#lx\n", (index * 32) + 31, index * 32, status);
3125
3126 for_each_set_bit(wake, &status, 32) {
3127 irq_hw_number_t hwirq = wake + 32 * index;
3128 struct irq_desc *desc;
3129 unsigned int irq;
3130
3131 irq = irq_find_mapping(pmc->domain, hwirq);
3132
3133 desc = irq_to_desc(irq);
3134 if (!desc || !desc->action || !desc->action->name) {
3135 dev_dbg(pmc->dev, "Resume caused by WAKE%ld, IRQ %d\n", hwirq, irq);
3136 continue;
3137 }
3138
3139 dev_dbg(pmc->dev, "Resume caused by WAKE%ld, %s\n", hwirq, desc->action->name);
3140 generic_handle_irq(irq);
3141 }
3142 }
3143
3144 static void tegra186_pmc_wake_syscore_resume(void)
3145 {
3146 u32 status, mask;
3147 unsigned int i;
3148
3149 for (i = 0; i < pmc->soc->max_wake_vectors; i++) {
3150 mask = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(i));
3151 status = readl(pmc->wake + WAKE_AOWAKE_STATUS_R(i)) & mask;
3152
3153 tegra186_pmc_process_wake_events(pmc, i, status);
3154 }
3155 }
3156
3157 static int tegra186_pmc_wake_syscore_suspend(void)
3158 {
3159 wke_read_sw_wake_status(pmc);
3160
3161 /* flip the wakeup trigger for dual-edge triggered pads
3162 * which are currently asserting as wakeups
3163 */
3164 bitmap_andnot(pmc->wake_cntrl_level_map, pmc->wake_type_dual_edge_map,
3165 pmc->wake_sw_status_map, pmc->soc->max_wake_events);
3166 bitmap_or(pmc->wake_cntrl_level_map, pmc->wake_cntrl_level_map,
3167 pmc->wake_type_level_map, pmc->soc->max_wake_events);
3168
3169 /* Clear PMC Wake Status registers while going to suspend */
3170 wke_clear_wake_status(pmc);
3171 wke_write_wake_levels(pmc);
3172
3173 return 0;
3174 }
3175
3176 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_ARM)
3177 static int tegra_pmc_suspend(struct device *dev)
3178 {
3179 struct tegra_pmc *pmc = dev_get_drvdata(dev);
3180
3181 tegra_pmc_writel(pmc, virt_to_phys(tegra_resume), PMC_SCRATCH41);
3182
3183 return 0;
3184 }
3185
3186 static int tegra_pmc_resume(struct device *dev)
3187 {
3188 struct tegra_pmc *pmc = dev_get_drvdata(dev);
3189
3190 tegra_pmc_writel(pmc, 0x0, PMC_SCRATCH41);
3191
3192 return 0;
3193 }
3194
3195 static SIMPLE_DEV_PM_OPS(tegra_pmc_pm_ops, tegra_pmc_suspend, tegra_pmc_resume);
3196
3197 #endif
3198
3199 static const char * const tegra20_powergates[] = {
3200 [TEGRA_POWERGATE_CPU] = "cpu",
3201 [TEGRA_POWERGATE_3D] = "td",
3202 [TEGRA_POWERGATE_VENC] = "venc",
3203 [TEGRA_POWERGATE_VDEC] = "vdec",
3204 [TEGRA_POWERGATE_PCIE] = "pcie",
3205 [TEGRA_POWERGATE_L2] = "l2",
3206 [TEGRA_POWERGATE_MPE] = "mpe",
3207 };
3208
3209 static const struct tegra_pmc_regs tegra20_pmc_regs = {
3210 .scratch0 = 0x50,
3211 .rst_status = 0x1b4,
3212 .rst_source_shift = 0x0,
3213 .rst_source_mask = 0x7,
3214 .rst_level_shift = 0x0,
3215 .rst_level_mask = 0x0,
3216 };
3217
3218 static void tegra20_pmc_init(struct tegra_pmc *pmc)
3219 {
3220 u32 value, osc, pmu, off;
3221
3222 /* Always enable CPU power request */
3223 value = tegra_pmc_readl(pmc, PMC_CNTRL);
3224 value |= PMC_CNTRL_CPU_PWRREQ_OE;
3225 tegra_pmc_writel(pmc, value, PMC_CNTRL);
3226
3227 value = tegra_pmc_readl(pmc, PMC_CNTRL);
3228
3229 if (pmc->sysclkreq_high)
3230 value &= ~PMC_CNTRL_SYSCLK_POLARITY;
3231 else
3232 value |= PMC_CNTRL_SYSCLK_POLARITY;
3233
3234 if (pmc->corereq_high)
3235 value &= ~PMC_CNTRL_PWRREQ_POLARITY;
3236 else
3237 value |= PMC_CNTRL_PWRREQ_POLARITY;
3238
3239 /* configure the output polarity while the request is tristated */
3240 tegra_pmc_writel(pmc, value, PMC_CNTRL);
3241
3242 /* now enable the request */
3243 value = tegra_pmc_readl(pmc, PMC_CNTRL);
3244 value |= PMC_CNTRL_SYSCLK_OE;
3245 tegra_pmc_writel(pmc, value, PMC_CNTRL);
3246
3247 /* program core timings which are applicable only for suspend state */
3248 if (pmc->suspend_mode != TEGRA_SUSPEND_NONE) {
3249 osc = DIV_ROUND_UP(pmc->core_osc_time * 8192, 1000000);
3250 pmu = DIV_ROUND_UP(pmc->core_pmu_time * 32768, 1000000);
3251 off = DIV_ROUND_UP(pmc->core_off_time * 32768, 1000000);
3252 tegra_pmc_writel(pmc, ((osc << 8) & 0xff00) | (pmu & 0xff),
3253 PMC_COREPWRGOOD_TIMER);
3254 tegra_pmc_writel(pmc, off, PMC_COREPWROFF_TIMER);
3255 }
3256 }
3257
3258 static void tegra20_pmc_setup_irq_polarity(struct tegra_pmc *pmc,
3259 struct device_node *np,
3260 bool invert)
3261 {
3262 u32 value;
3263
3264 value = tegra_pmc_readl(pmc, PMC_CNTRL);
3265
3266 if (invert)
3267 value |= PMC_CNTRL_INTR_POLARITY;
3268 else
3269 value &= ~PMC_CNTRL_INTR_POLARITY;
3270
3271 tegra_pmc_writel(pmc, value, PMC_CNTRL);
3272 }
3273
3274 static const struct tegra_pmc_soc tegra20_pmc_soc = {
3275 .supports_core_domain = true,
3276 .num_powergates = ARRAY_SIZE(tegra20_powergates),
3277 .powergates = tegra20_powergates,
3278 .num_cpu_powergates = 0,
3279 .cpu_powergates = NULL,
3280 .has_tsense_reset = false,
3281 .has_gpu_clamps = false,
3282 .needs_mbist_war = false,
3283 .has_impl_33v_pwr = false,
3284 .maybe_tz_only = false,
3285 .num_io_pads = 0,
3286 .io_pads = NULL,
3287 .num_pin_descs = 0,
3288 .pin_descs = NULL,
3289 .regs = &tegra20_pmc_regs,
3290 .init = tegra20_pmc_init,
3291 .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3292 .powergate_set = tegra20_powergate_set,
3293 .reset_sources = NULL,
3294 .num_reset_sources = 0,
3295 .reset_levels = NULL,
3296 .num_reset_levels = 0,
3297 .pmc_clks_data = NULL,
3298 .num_pmc_clks = 0,
3299 .has_blink_output = true,
3300 .has_usb_sleepwalk = true,
3301 .has_single_mmio_aperture = true,
3302 };
3303
3304 static const char * const tegra30_powergates[] = {
3305 [TEGRA_POWERGATE_CPU] = "cpu0",
3306 [TEGRA_POWERGATE_3D] = "td",
3307 [TEGRA_POWERGATE_VENC] = "venc",
3308 [TEGRA_POWERGATE_VDEC] = "vdec",
3309 [TEGRA_POWERGATE_PCIE] = "pcie",
3310 [TEGRA_POWERGATE_L2] = "l2",
3311 [TEGRA_POWERGATE_MPE] = "mpe",
3312 [TEGRA_POWERGATE_HEG] = "heg",
3313 [TEGRA_POWERGATE_SATA] = "sata",
3314 [TEGRA_POWERGATE_CPU1] = "cpu1",
3315 [TEGRA_POWERGATE_CPU2] = "cpu2",
3316 [TEGRA_POWERGATE_CPU3] = "cpu3",
3317 [TEGRA_POWERGATE_CELP] = "celp",
3318 [TEGRA_POWERGATE_3D1] = "td2",
3319 };
3320
3321 static const u8 tegra30_cpu_powergates[] = {
3322 TEGRA_POWERGATE_CPU,
3323 TEGRA_POWERGATE_CPU1,
3324 TEGRA_POWERGATE_CPU2,
3325 TEGRA_POWERGATE_CPU3,
3326 };
3327
3328 static const char * const tegra30_reset_sources[] = {
3329 "POWER_ON_RESET",
3330 "WATCHDOG",
3331 "SENSOR",
3332 "SW_MAIN",
3333 "LP0"
3334 };
3335
3336 static const struct tegra_pmc_soc tegra30_pmc_soc = {
3337 .supports_core_domain = true,
3338 .num_powergates = ARRAY_SIZE(tegra30_powergates),
3339 .powergates = tegra30_powergates,
3340 .num_cpu_powergates = ARRAY_SIZE(tegra30_cpu_powergates),
3341 .cpu_powergates = tegra30_cpu_powergates,
3342 .has_tsense_reset = true,
3343 .has_gpu_clamps = false,
3344 .needs_mbist_war = false,
3345 .has_impl_33v_pwr = false,
3346 .maybe_tz_only = false,
3347 .num_io_pads = 0,
3348 .io_pads = NULL,
3349 .num_pin_descs = 0,
3350 .pin_descs = NULL,
3351 .regs = &tegra20_pmc_regs,
3352 .init = tegra20_pmc_init,
3353 .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3354 .powergate_set = tegra20_powergate_set,
3355 .reset_sources = tegra30_reset_sources,
3356 .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
3357 .reset_levels = NULL,
3358 .num_reset_levels = 0,
3359 .pmc_clks_data = tegra_pmc_clks_data,
3360 .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3361 .has_blink_output = true,
3362 .has_usb_sleepwalk = true,
3363 .has_single_mmio_aperture = true,
3364 };
3365
3366 static const char * const tegra114_powergates[] = {
3367 [TEGRA_POWERGATE_CPU] = "crail",
3368 [TEGRA_POWERGATE_3D] = "td",
3369 [TEGRA_POWERGATE_VENC] = "venc",
3370 [TEGRA_POWERGATE_VDEC] = "vdec",
3371 [TEGRA_POWERGATE_MPE] = "mpe",
3372 [TEGRA_POWERGATE_HEG] = "heg",
3373 [TEGRA_POWERGATE_CPU1] = "cpu1",
3374 [TEGRA_POWERGATE_CPU2] = "cpu2",
3375 [TEGRA_POWERGATE_CPU3] = "cpu3",
3376 [TEGRA_POWERGATE_CELP] = "celp",
3377 [TEGRA_POWERGATE_CPU0] = "cpu0",
3378 [TEGRA_POWERGATE_C0NC] = "c0nc",
3379 [TEGRA_POWERGATE_C1NC] = "c1nc",
3380 [TEGRA_POWERGATE_DIS] = "dis",
3381 [TEGRA_POWERGATE_DISB] = "disb",
3382 [TEGRA_POWERGATE_XUSBA] = "xusba",
3383 [TEGRA_POWERGATE_XUSBB] = "xusbb",
3384 [TEGRA_POWERGATE_XUSBC] = "xusbc",
3385 };
3386
3387 static const u8 tegra114_cpu_powergates[] = {
3388 TEGRA_POWERGATE_CPU0,
3389 TEGRA_POWERGATE_CPU1,
3390 TEGRA_POWERGATE_CPU2,
3391 TEGRA_POWERGATE_CPU3,
3392 };
3393
3394 static const struct tegra_pmc_soc tegra114_pmc_soc = {
3395 .supports_core_domain = false,
3396 .num_powergates = ARRAY_SIZE(tegra114_powergates),
3397 .powergates = tegra114_powergates,
3398 .num_cpu_powergates = ARRAY_SIZE(tegra114_cpu_powergates),
3399 .cpu_powergates = tegra114_cpu_powergates,
3400 .has_tsense_reset = true,
3401 .has_gpu_clamps = false,
3402 .needs_mbist_war = false,
3403 .has_impl_33v_pwr = false,
3404 .maybe_tz_only = false,
3405 .num_io_pads = 0,
3406 .io_pads = NULL,
3407 .num_pin_descs = 0,
3408 .pin_descs = NULL,
3409 .regs = &tegra20_pmc_regs,
3410 .init = tegra20_pmc_init,
3411 .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3412 .powergate_set = tegra114_powergate_set,
3413 .reset_sources = tegra30_reset_sources,
3414 .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
3415 .reset_levels = NULL,
3416 .num_reset_levels = 0,
3417 .pmc_clks_data = tegra_pmc_clks_data,
3418 .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3419 .has_blink_output = true,
3420 .has_usb_sleepwalk = true,
3421 .has_single_mmio_aperture = true,
3422 };
3423
3424 static const char * const tegra124_powergates[] = {
3425 [TEGRA_POWERGATE_CPU] = "crail",
3426 [TEGRA_POWERGATE_3D] = "3d",
3427 [TEGRA_POWERGATE_VENC] = "venc",
3428 [TEGRA_POWERGATE_PCIE] = "pcie",
3429 [TEGRA_POWERGATE_VDEC] = "vdec",
3430 [TEGRA_POWERGATE_MPE] = "mpe",
3431 [TEGRA_POWERGATE_HEG] = "heg",
3432 [TEGRA_POWERGATE_SATA] = "sata",
3433 [TEGRA_POWERGATE_CPU1] = "cpu1",
3434 [TEGRA_POWERGATE_CPU2] = "cpu2",
3435 [TEGRA_POWERGATE_CPU3] = "cpu3",
3436 [TEGRA_POWERGATE_CELP] = "celp",
3437 [TEGRA_POWERGATE_CPU0] = "cpu0",
3438 [TEGRA_POWERGATE_C0NC] = "c0nc",
3439 [TEGRA_POWERGATE_C1NC] = "c1nc",
3440 [TEGRA_POWERGATE_SOR] = "sor",
3441 [TEGRA_POWERGATE_DIS] = "dis",
3442 [TEGRA_POWERGATE_DISB] = "disb",
3443 [TEGRA_POWERGATE_XUSBA] = "xusba",
3444 [TEGRA_POWERGATE_XUSBB] = "xusbb",
3445 [TEGRA_POWERGATE_XUSBC] = "xusbc",
3446 [TEGRA_POWERGATE_VIC] = "vic",
3447 [TEGRA_POWERGATE_IRAM] = "iram",
3448 };
3449
3450 static const u8 tegra124_cpu_powergates[] = {
3451 TEGRA_POWERGATE_CPU0,
3452 TEGRA_POWERGATE_CPU1,
3453 TEGRA_POWERGATE_CPU2,
3454 TEGRA_POWERGATE_CPU3,
3455 };
3456
3457 #define TEGRA_IO_PAD(_id, _dpd, _request, _status, _voltage, _name) \
3458 ((struct tegra_io_pad_soc) { \
3459 .id = (_id), \
3460 .dpd = (_dpd), \
3461 .request = (_request), \
3462 .status = (_status), \
3463 .voltage = (_voltage), \
3464 .name = (_name), \
3465 })
3466
3467 #define TEGRA_IO_PIN_DESC(_id, _name) \
3468 ((struct pinctrl_pin_desc) { \
3469 .number = (_id), \
3470 .name = (_name), \
3471 })
3472
3473 static const struct tegra_io_pad_soc tegra124_io_pads[] = {
3474 TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO, 17, 0x1b8, 0x1bc, UINT_MAX, "audio"),
3475 TEGRA_IO_PAD(TEGRA_IO_PAD_BB, 15, 0x1b8, 0x1bc, UINT_MAX, "bb"),
3476 TEGRA_IO_PAD(TEGRA_IO_PAD_CAM, 4, 0x1c0, 0x1c4, UINT_MAX, "cam"),
3477 TEGRA_IO_PAD(TEGRA_IO_PAD_COMP, 22, 0x1b8, 0x1bc, UINT_MAX, "comp"),
3478 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0x1b8, 0x1bc, UINT_MAX, "csia"),
3479 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0x1b8, 0x1bc, UINT_MAX, "csib"),
3480 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 12, 0x1c0, 0x1c4, UINT_MAX, "csie"),
3481 TEGRA_IO_PAD(TEGRA_IO_PAD_DSI, 2, 0x1b8, 0x1bc, UINT_MAX, "dsi"),
3482 TEGRA_IO_PAD(TEGRA_IO_PAD_DSIB, 7, 0x1c0, 0x1c4, UINT_MAX, "dsib"),
3483 TEGRA_IO_PAD(TEGRA_IO_PAD_DSIC, 8, 0x1c0, 0x1c4, UINT_MAX, "dsic"),
3484 TEGRA_IO_PAD(TEGRA_IO_PAD_DSID, 9, 0x1c0, 0x1c4, UINT_MAX, "dsid"),
3485 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI, 28, 0x1b8, 0x1bc, UINT_MAX, "hdmi"),
3486 TEGRA_IO_PAD(TEGRA_IO_PAD_HSIC, 19, 0x1b8, 0x1bc, UINT_MAX, "hsic"),
3487 TEGRA_IO_PAD(TEGRA_IO_PAD_HV, 6, 0x1c0, 0x1c4, UINT_MAX, "hv"),
3488 TEGRA_IO_PAD(TEGRA_IO_PAD_LVDS, 25, 0x1c0, 0x1c4, UINT_MAX, "lvds"),
3489 TEGRA_IO_PAD(TEGRA_IO_PAD_MIPI_BIAS, 3, 0x1b8, 0x1bc, UINT_MAX, "mipi-bias"),
3490 TEGRA_IO_PAD(TEGRA_IO_PAD_NAND, 13, 0x1b8, 0x1bc, UINT_MAX, "nand"),
3491 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_BIAS, 4, 0x1b8, 0x1bc, UINT_MAX, "pex-bias"),
3492 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK1, 5, 0x1b8, 0x1bc, UINT_MAX, "pex-clk1"),
3493 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK2, 6, 0x1b8, 0x1bc, UINT_MAX, "pex-clk2"),
3494 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CNTRL, 0, 0x1c0, 0x1c4, UINT_MAX, "pex-cntrl"),
3495 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1, 1, 0x1c0, 0x1c4, UINT_MAX, "sdmmc1"),
3496 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3, 2, 0x1c0, 0x1c4, UINT_MAX, "sdmmc3"),
3497 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC4, 3, 0x1c0, 0x1c4, UINT_MAX, "sdmmc4"),
3498 TEGRA_IO_PAD(TEGRA_IO_PAD_SYS_DDC, 26, 0x1c0, 0x1c4, UINT_MAX, "sys_ddc"),
3499 TEGRA_IO_PAD(TEGRA_IO_PAD_UART, 14, 0x1b8, 0x1bc, UINT_MAX, "uart"),
3500 TEGRA_IO_PAD(TEGRA_IO_PAD_USB0, 9, 0x1b8, 0x1bc, UINT_MAX, "usb0"),
3501 TEGRA_IO_PAD(TEGRA_IO_PAD_USB1, 10, 0x1b8, 0x1bc, UINT_MAX, "usb1"),
3502 TEGRA_IO_PAD(TEGRA_IO_PAD_USB2, 11, 0x1b8, 0x1bc, UINT_MAX, "usb2"),
3503 TEGRA_IO_PAD(TEGRA_IO_PAD_USB_BIAS, 12, 0x1b8, 0x1bc, UINT_MAX, "usb_bias"),
3504 };
3505
3506 static const struct pinctrl_pin_desc tegra124_pin_descs[] = {
3507 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO, "audio"),
3508 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_BB, "bb"),
3509 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CAM, "cam"),
3510 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_COMP, "comp"),
3511 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
3512 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
3513 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
3514 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSI, "dsi"),
3515 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIB, "dsib"),
3516 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIC, "dsic"),
3517 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSID, "dsid"),
3518 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI, "hdmi"),
3519 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HSIC, "hsic"),
3520 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HV, "hv"),
3521 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_LVDS, "lvds"),
3522 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_MIPI_BIAS, "mipi-bias"),
3523 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_NAND, "nand"),
3524 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_BIAS, "pex-bias"),
3525 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK1, "pex-clk1"),
3526 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK2, "pex-clk2"),
3527 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CNTRL, "pex-cntrl"),
3528 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1, "sdmmc1"),
3529 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3, "sdmmc3"),
3530 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC4, "sdmmc4"),
3531 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SYS_DDC, "sys_ddc"),
3532 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART, "uart"),
3533 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB0, "usb0"),
3534 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB1, "usb1"),
3535 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB2, "usb2"),
3536 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB_BIAS, "usb_bias"),
3537 };
3538
3539 static const struct tegra_pmc_soc tegra124_pmc_soc = {
3540 .supports_core_domain = false,
3541 .num_powergates = ARRAY_SIZE(tegra124_powergates),
3542 .powergates = tegra124_powergates,
3543 .num_cpu_powergates = ARRAY_SIZE(tegra124_cpu_powergates),
3544 .cpu_powergates = tegra124_cpu_powergates,
3545 .has_tsense_reset = true,
3546 .has_gpu_clamps = true,
3547 .needs_mbist_war = false,
3548 .has_impl_33v_pwr = false,
3549 .maybe_tz_only = false,
3550 .num_io_pads = ARRAY_SIZE(tegra124_io_pads),
3551 .io_pads = tegra124_io_pads,
3552 .num_pin_descs = ARRAY_SIZE(tegra124_pin_descs),
3553 .pin_descs = tegra124_pin_descs,
3554 .regs = &tegra20_pmc_regs,
3555 .init = tegra20_pmc_init,
3556 .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3557 .powergate_set = tegra114_powergate_set,
3558 .reset_sources = tegra30_reset_sources,
3559 .num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
3560 .reset_levels = NULL,
3561 .num_reset_levels = 0,
3562 .pmc_clks_data = tegra_pmc_clks_data,
3563 .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3564 .has_blink_output = true,
3565 .has_usb_sleepwalk = true,
3566 .has_single_mmio_aperture = true,
3567 };
3568
3569 static const char * const tegra210_powergates[] = {
3570 [TEGRA_POWERGATE_CPU] = "crail",
3571 [TEGRA_POWERGATE_3D] = "3d",
3572 [TEGRA_POWERGATE_VENC] = "venc",
3573 [TEGRA_POWERGATE_PCIE] = "pcie",
3574 [TEGRA_POWERGATE_MPE] = "mpe",
3575 [TEGRA_POWERGATE_SATA] = "sata",
3576 [TEGRA_POWERGATE_CPU1] = "cpu1",
3577 [TEGRA_POWERGATE_CPU2] = "cpu2",
3578 [TEGRA_POWERGATE_CPU3] = "cpu3",
3579 [TEGRA_POWERGATE_CPU0] = "cpu0",
3580 [TEGRA_POWERGATE_C0NC] = "c0nc",
3581 [TEGRA_POWERGATE_SOR] = "sor",
3582 [TEGRA_POWERGATE_DIS] = "dis",
3583 [TEGRA_POWERGATE_DISB] = "disb",
3584 [TEGRA_POWERGATE_XUSBA] = "xusba",
3585 [TEGRA_POWERGATE_XUSBB] = "xusbb",
3586 [TEGRA_POWERGATE_XUSBC] = "xusbc",
3587 [TEGRA_POWERGATE_VIC] = "vic",
3588 [TEGRA_POWERGATE_IRAM] = "iram",
3589 [TEGRA_POWERGATE_NVDEC] = "nvdec",
3590 [TEGRA_POWERGATE_NVJPG] = "nvjpg",
3591 [TEGRA_POWERGATE_AUD] = "aud",
3592 [TEGRA_POWERGATE_DFD] = "dfd",
3593 [TEGRA_POWERGATE_VE2] = "ve2",
3594 };
3595
3596 static const u8 tegra210_cpu_powergates[] = {
3597 TEGRA_POWERGATE_CPU0,
3598 TEGRA_POWERGATE_CPU1,
3599 TEGRA_POWERGATE_CPU2,
3600 TEGRA_POWERGATE_CPU3,
3601 };
3602
3603 static const struct tegra_io_pad_soc tegra210_io_pads[] = {
3604 TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO, 17, 0x1b8, 0x1bc, 5, "audio"),
3605 TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO_HV, 29, 0x1c0, 0x1c4, 18, "audio-hv"),
3606 TEGRA_IO_PAD(TEGRA_IO_PAD_CAM, 4, 0x1c0, 0x1c4, 10, "cam"),
3607 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0x1b8, 0x1bc, UINT_MAX, "csia"),
3608 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0x1b8, 0x1bc, UINT_MAX, "csib"),
3609 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIC, 10, 0x1c0, 0x1c4, UINT_MAX, "csic"),
3610 TEGRA_IO_PAD(TEGRA_IO_PAD_CSID, 11, 0x1c0, 0x1c4, UINT_MAX, "csid"),
3611 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 12, 0x1c0, 0x1c4, UINT_MAX, "csie"),
3612 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIF, 13, 0x1c0, 0x1c4, UINT_MAX, "csif"),
3613 TEGRA_IO_PAD(TEGRA_IO_PAD_DBG, 25, 0x1b8, 0x1bc, 19, "dbg"),
3614 TEGRA_IO_PAD(TEGRA_IO_PAD_DEBUG_NONAO, 26, 0x1b8, 0x1bc, UINT_MAX, "debug-nonao"),
3615 TEGRA_IO_PAD(TEGRA_IO_PAD_DMIC, 18, 0x1c0, 0x1c4, 20, "dmic"),
3616 TEGRA_IO_PAD(TEGRA_IO_PAD_DP, 19, 0x1c0, 0x1c4, UINT_MAX, "dp"),
3617 TEGRA_IO_PAD(TEGRA_IO_PAD_DSI, 2, 0x1b8, 0x1bc, UINT_MAX, "dsi"),
3618 TEGRA_IO_PAD(TEGRA_IO_PAD_DSIB, 7, 0x1c0, 0x1c4, UINT_MAX, "dsib"),
3619 TEGRA_IO_PAD(TEGRA_IO_PAD_DSIC, 8, 0x1c0, 0x1c4, UINT_MAX, "dsic"),
3620 TEGRA_IO_PAD(TEGRA_IO_PAD_DSID, 9, 0x1c0, 0x1c4, UINT_MAX, "dsid"),
3621 TEGRA_IO_PAD(TEGRA_IO_PAD_EMMC, 3, 0x1c0, 0x1c4, UINT_MAX, "emmc"),
3622 TEGRA_IO_PAD(TEGRA_IO_PAD_EMMC2, 5, 0x1c0, 0x1c4, UINT_MAX, "emmc2"),
3623 TEGRA_IO_PAD(TEGRA_IO_PAD_GPIO, 27, 0x1b8, 0x1bc, 21, "gpio"),
3624 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI, 28, 0x1b8, 0x1bc, UINT_MAX, "hdmi"),
3625 TEGRA_IO_PAD(TEGRA_IO_PAD_HSIC, 19, 0x1b8, 0x1bc, UINT_MAX, "hsic"),
3626 TEGRA_IO_PAD(TEGRA_IO_PAD_LVDS, 25, 0x1c0, 0x1c4, UINT_MAX, "lvds"),
3627 TEGRA_IO_PAD(TEGRA_IO_PAD_MIPI_BIAS, 3, 0x1b8, 0x1bc, UINT_MAX, "mipi-bias"),
3628 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_BIAS, 4, 0x1b8, 0x1bc, UINT_MAX, "pex-bias"),
3629 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK1, 5, 0x1b8, 0x1bc, UINT_MAX, "pex-clk1"),
3630 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK2, 6, 0x1b8, 0x1bc, UINT_MAX, "pex-clk2"),
3631 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CNTRL, UINT_MAX, UINT_MAX, UINT_MAX, 11, "pex-cntrl"),
3632 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1, 1, 0x1c0, 0x1c4, 12, "sdmmc1"),
3633 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3, 2, 0x1c0, 0x1c4, 13, "sdmmc3"),
3634 TEGRA_IO_PAD(TEGRA_IO_PAD_SPI, 14, 0x1c0, 0x1c4, 22, "spi"),
3635 TEGRA_IO_PAD(TEGRA_IO_PAD_SPI_HV, 15, 0x1c0, 0x1c4, 23, "spi-hv"),
3636 TEGRA_IO_PAD(TEGRA_IO_PAD_UART, 14, 0x1b8, 0x1bc, 2, "uart"),
3637 TEGRA_IO_PAD(TEGRA_IO_PAD_USB0, 9, 0x1b8, 0x1bc, UINT_MAX, "usb0"),
3638 TEGRA_IO_PAD(TEGRA_IO_PAD_USB1, 10, 0x1b8, 0x1bc, UINT_MAX, "usb1"),
3639 TEGRA_IO_PAD(TEGRA_IO_PAD_USB2, 11, 0x1b8, 0x1bc, UINT_MAX, "usb2"),
3640 TEGRA_IO_PAD(TEGRA_IO_PAD_USB3, 18, 0x1b8, 0x1bc, UINT_MAX, "usb3"),
3641 TEGRA_IO_PAD(TEGRA_IO_PAD_USB_BIAS, 12, 0x1b8, 0x1bc, UINT_MAX, "usb-bias"),
3642 };
3643
3644 static const struct pinctrl_pin_desc tegra210_pin_descs[] = {
3645 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO, "audio"),
3646 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO_HV, "audio-hv"),
3647 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CAM, "cam"),
3648 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
3649 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
3650 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIC, "csic"),
3651 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSID, "csid"),
3652 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
3653 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIF, "csif"),
3654 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DBG, "dbg"),
3655 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DEBUG_NONAO, "debug-nonao"),
3656 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DMIC, "dmic"),
3657 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DP, "dp"),
3658 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSI, "dsi"),
3659 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIB, "dsib"),
3660 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIC, "dsic"),
3661 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSID, "dsid"),
3662 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EMMC, "emmc"),
3663 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EMMC2, "emmc2"),
3664 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_GPIO, "gpio"),
3665 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI, "hdmi"),
3666 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HSIC, "hsic"),
3667 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_LVDS, "lvds"),
3668 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_MIPI_BIAS, "mipi-bias"),
3669 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_BIAS, "pex-bias"),
3670 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK1, "pex-clk1"),
3671 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK2, "pex-clk2"),
3672 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CNTRL, "pex-cntrl"),
3673 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1, "sdmmc1"),
3674 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3, "sdmmc3"),
3675 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SPI, "spi"),
3676 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SPI_HV, "spi-hv"),
3677 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART, "uart"),
3678 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB0, "usb0"),
3679 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB1, "usb1"),
3680 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB2, "usb2"),
3681 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB3, "usb3"),
3682 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB_BIAS, "usb-bias"),
3683 };
3684
3685 static const char * const tegra210_reset_sources[] = {
3686 "POWER_ON_RESET",
3687 "WATCHDOG",
3688 "SENSOR",
3689 "SW_MAIN",
3690 "LP0",
3691 "AOTAG"
3692 };
3693
3694 static const struct tegra_wake_event tegra210_wake_events[] = {
3695 TEGRA_WAKE_IRQ("rtc", 16, 2),
3696 TEGRA_WAKE_IRQ("pmu", 51, 86),
3697 };
3698
3699 static const struct tegra_pmc_soc tegra210_pmc_soc = {
3700 .supports_core_domain = false,
3701 .num_powergates = ARRAY_SIZE(tegra210_powergates),
3702 .powergates = tegra210_powergates,
3703 .num_cpu_powergates = ARRAY_SIZE(tegra210_cpu_powergates),
3704 .cpu_powergates = tegra210_cpu_powergates,
3705 .has_tsense_reset = true,
3706 .has_gpu_clamps = true,
3707 .needs_mbist_war = true,
3708 .has_impl_33v_pwr = false,
3709 .maybe_tz_only = true,
3710 .num_io_pads = ARRAY_SIZE(tegra210_io_pads),
3711 .io_pads = tegra210_io_pads,
3712 .num_pin_descs = ARRAY_SIZE(tegra210_pin_descs),
3713 .pin_descs = tegra210_pin_descs,
3714 .regs = &tegra20_pmc_regs,
3715 .init = tegra20_pmc_init,
3716 .setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
3717 .powergate_set = tegra114_powergate_set,
3718 .irq_set_wake = tegra210_pmc_irq_set_wake,
3719 .irq_set_type = tegra210_pmc_irq_set_type,
3720 .reset_sources = tegra210_reset_sources,
3721 .num_reset_sources = ARRAY_SIZE(tegra210_reset_sources),
3722 .reset_levels = NULL,
3723 .num_reset_levels = 0,
3724 .num_wake_events = ARRAY_SIZE(tegra210_wake_events),
3725 .wake_events = tegra210_wake_events,
3726 .pmc_clks_data = tegra_pmc_clks_data,
3727 .num_pmc_clks = ARRAY_SIZE(tegra_pmc_clks_data),
3728 .has_blink_output = true,
3729 .has_usb_sleepwalk = true,
3730 .has_single_mmio_aperture = true,
3731 };
3732
3733 static const struct tegra_io_pad_soc tegra186_io_pads[] = {
3734 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0x74, 0x78, UINT_MAX, "csia"),
3735 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0x74, 0x78, UINT_MAX, "csib"),
3736 TEGRA_IO_PAD(TEGRA_IO_PAD_DSI, 2, 0x74, 0x78, UINT_MAX, "dsi"),
3737 TEGRA_IO_PAD(TEGRA_IO_PAD_MIPI_BIAS, 3, 0x74, 0x78, UINT_MAX, "mipi-bias"),
3738 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK_BIAS, 4, 0x74, 0x78, UINT_MAX, "pex-clk-bias"),
3739 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK3, 5, 0x74, 0x78, UINT_MAX, "pex-clk3"),
3740 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK2, 6, 0x74, 0x78, UINT_MAX, "pex-clk2"),
3741 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK1, 7, 0x74, 0x78, UINT_MAX, "pex-clk1"),
3742 TEGRA_IO_PAD(TEGRA_IO_PAD_USB0, 9, 0x74, 0x78, UINT_MAX, "usb0"),
3743 TEGRA_IO_PAD(TEGRA_IO_PAD_USB1, 10, 0x74, 0x78, UINT_MAX, "usb1"),
3744 TEGRA_IO_PAD(TEGRA_IO_PAD_USB2, 11, 0x74, 0x78, UINT_MAX, "usb2"),
3745 TEGRA_IO_PAD(TEGRA_IO_PAD_USB_BIAS, 12, 0x74, 0x78, UINT_MAX, "usb-bias"),
3746 TEGRA_IO_PAD(TEGRA_IO_PAD_UART, 14, 0x74, 0x78, UINT_MAX, "uart"),
3747 TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO, 17, 0x74, 0x78, UINT_MAX, "audio"),
3748 TEGRA_IO_PAD(TEGRA_IO_PAD_HSIC, 19, 0x74, 0x78, UINT_MAX, "hsic"),
3749 TEGRA_IO_PAD(TEGRA_IO_PAD_DBG, 25, 0x74, 0x78, UINT_MAX, "dbg"),
3750 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP0, 28, 0x74, 0x78, UINT_MAX, "hdmi-dp0"),
3751 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP1, 29, 0x74, 0x78, UINT_MAX, "hdmi-dp1"),
3752 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CNTRL, 0, 0x7c, 0x80, UINT_MAX, "pex-cntrl"),
3753 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC2_HV, 2, 0x7c, 0x80, 5, "sdmmc2-hv"),
3754 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC4, 4, 0x7c, 0x80, UINT_MAX, "sdmmc4"),
3755 TEGRA_IO_PAD(TEGRA_IO_PAD_CAM, 6, 0x7c, 0x80, UINT_MAX, "cam"),
3756 TEGRA_IO_PAD(TEGRA_IO_PAD_DSIB, 8, 0x7c, 0x80, UINT_MAX, "dsib"),
3757 TEGRA_IO_PAD(TEGRA_IO_PAD_DSIC, 9, 0x7c, 0x80, UINT_MAX, "dsic"),
3758 TEGRA_IO_PAD(TEGRA_IO_PAD_DSID, 10, 0x7c, 0x80, UINT_MAX, "dsid"),
3759 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIC, 11, 0x7c, 0x80, UINT_MAX, "csic"),
3760 TEGRA_IO_PAD(TEGRA_IO_PAD_CSID, 12, 0x7c, 0x80, UINT_MAX, "csid"),
3761 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 13, 0x7c, 0x80, UINT_MAX, "csie"),
3762 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIF, 14, 0x7c, 0x80, UINT_MAX, "csif"),
3763 TEGRA_IO_PAD(TEGRA_IO_PAD_SPI, 15, 0x7c, 0x80, UINT_MAX, "spi"),
3764 TEGRA_IO_PAD(TEGRA_IO_PAD_UFS, 17, 0x7c, 0x80, UINT_MAX, "ufs"),
3765 TEGRA_IO_PAD(TEGRA_IO_PAD_DMIC_HV, 20, 0x7c, 0x80, 2, "dmic-hv"),
3766 TEGRA_IO_PAD(TEGRA_IO_PAD_EDP, 21, 0x7c, 0x80, UINT_MAX, "edp"),
3767 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1_HV, 23, 0x7c, 0x80, 4, "sdmmc1-hv"),
3768 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3_HV, 24, 0x7c, 0x80, 6, "sdmmc3-hv"),
3769 TEGRA_IO_PAD(TEGRA_IO_PAD_CONN, 28, 0x7c, 0x80, UINT_MAX, "conn"),
3770 TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO_HV, 29, 0x7c, 0x80, 1, "audio-hv"),
3771 TEGRA_IO_PAD(TEGRA_IO_PAD_AO_HV, UINT_MAX, UINT_MAX, UINT_MAX, 0, "ao-hv"),
3772 };
3773
3774 static const struct pinctrl_pin_desc tegra186_pin_descs[] = {
3775 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
3776 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
3777 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSI, "dsi"),
3778 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_MIPI_BIAS, "mipi-bias"),
3779 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK_BIAS, "pex-clk-bias"),
3780 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK3, "pex-clk3"),
3781 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK2, "pex-clk2"),
3782 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK1, "pex-clk1"),
3783 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB0, "usb0"),
3784 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB1, "usb1"),
3785 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB2, "usb2"),
3786 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_USB_BIAS, "usb-bias"),
3787 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART, "uart"),
3788 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO, "audio"),
3789 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HSIC, "hsic"),
3790 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DBG, "dbg"),
3791 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP0, "hdmi-dp0"),
3792 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP1, "hdmi-dp1"),
3793 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CNTRL, "pex-cntrl"),
3794 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC2_HV, "sdmmc2-hv"),
3795 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC4, "sdmmc4"),
3796 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CAM, "cam"),
3797 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIB, "dsib"),
3798 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSIC, "dsic"),
3799 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DSID, "dsid"),
3800 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIC, "csic"),
3801 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSID, "csid"),
3802 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
3803 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIF, "csif"),
3804 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SPI, "spi"),
3805 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UFS, "ufs"),
3806 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DMIC_HV, "dmic-hv"),
3807 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EDP, "edp"),
3808 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1_HV, "sdmmc1-hv"),
3809 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3_HV, "sdmmc3-hv"),
3810 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CONN, "conn"),
3811 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO_HV, "audio-hv"),
3812 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AO_HV, "ao-hv"),
3813 };
3814
3815 static const struct tegra_pmc_regs tegra186_pmc_regs = {
3816 .scratch0 = 0x2000,
3817 .rst_status = 0x70,
3818 .rst_source_shift = 0x2,
3819 .rst_source_mask = 0x3c,
3820 .rst_level_shift = 0x0,
3821 .rst_level_mask = 0x3,
3822 };
3823
3824 static void tegra186_pmc_init(struct tegra_pmc *pmc)
3825 {
3826 pmc->syscore.suspend = tegra186_pmc_wake_syscore_suspend;
3827 pmc->syscore.resume = tegra186_pmc_wake_syscore_resume;
3828
3829 register_syscore_ops(&pmc->syscore);
3830 }
3831
3832 static void tegra186_pmc_setup_irq_polarity(struct tegra_pmc *pmc,
3833 struct device_node *np,
3834 bool invert)
3835 {
3836 struct resource regs;
3837 void __iomem *wake;
3838 u32 value;
3839 int index;
3840
3841 index = of_property_match_string(np, "reg-names", "wake");
3842 if (index < 0) {
3843 dev_err(pmc->dev, "failed to find PMC wake registers\n");
3844 return;
3845 }
3846
3847 of_address_to_resource(np, index, &regs);
3848
3849 wake = ioremap(regs.start, resource_size(&regs));
3850 if (!wake) {
3851 dev_err(pmc->dev, "failed to map PMC wake registers\n");
3852 return;
3853 }
3854
3855 value = readl(wake + WAKE_AOWAKE_CTRL);
3856
3857 if (invert)
3858 value |= WAKE_AOWAKE_CTRL_INTR_POLARITY;
3859 else
3860 value &= ~WAKE_AOWAKE_CTRL_INTR_POLARITY;
3861
3862 writel(value, wake + WAKE_AOWAKE_CTRL);
3863
3864 iounmap(wake);
3865 }
3866
3867 static const char * const tegra186_reset_sources[] = {
3868 "SYS_RESET",
3869 "AOWDT",
3870 "MCCPLEXWDT",
3871 "BPMPWDT",
3872 "SCEWDT",
3873 "SPEWDT",
3874 "APEWDT",
3875 "BCCPLEXWDT",
3876 "SENSOR",
3877 "AOTAG",
3878 "VFSENSOR",
3879 "SWREST",
3880 "SC7",
3881 "HSM",
3882 "CORESIGHT"
3883 };
3884
3885 static const char * const tegra186_reset_levels[] = {
3886 "L0", "L1", "L2", "WARM"
3887 };
3888
3889 static const struct tegra_wake_event tegra186_wake_events[] = {
3890 TEGRA_WAKE_IRQ("pmu", 24, 209),
3891 TEGRA_WAKE_GPIO("power", 29, 1, TEGRA186_AON_GPIO(FF, 0)),
3892 TEGRA_WAKE_IRQ("rtc", 73, 10),
3893 };
3894
3895 static const struct tegra_pmc_soc tegra186_pmc_soc = {
3896 .supports_core_domain = false,
3897 .num_powergates = 0,
3898 .powergates = NULL,
3899 .num_cpu_powergates = 0,
3900 .cpu_powergates = NULL,
3901 .has_tsense_reset = false,
3902 .has_gpu_clamps = false,
3903 .needs_mbist_war = false,
3904 .has_impl_33v_pwr = true,
3905 .maybe_tz_only = false,
3906 .num_io_pads = ARRAY_SIZE(tegra186_io_pads),
3907 .io_pads = tegra186_io_pads,
3908 .num_pin_descs = ARRAY_SIZE(tegra186_pin_descs),
3909 .pin_descs = tegra186_pin_descs,
3910 .regs = &tegra186_pmc_regs,
3911 .init = tegra186_pmc_init,
3912 .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
3913 .set_wake_filters = tegra186_pmc_set_wake_filters,
3914 .irq_set_wake = tegra186_pmc_irq_set_wake,
3915 .irq_set_type = tegra186_pmc_irq_set_type,
3916 .reset_sources = tegra186_reset_sources,
3917 .num_reset_sources = ARRAY_SIZE(tegra186_reset_sources),
3918 .reset_levels = tegra186_reset_levels,
3919 .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
3920 .num_wake_events = ARRAY_SIZE(tegra186_wake_events),
3921 .wake_events = tegra186_wake_events,
3922 .max_wake_events = 96,
3923 .max_wake_vectors = 3,
3924 .pmc_clks_data = NULL,
3925 .num_pmc_clks = 0,
3926 .has_blink_output = false,
3927 .has_usb_sleepwalk = false,
3928 .has_single_mmio_aperture = false,
3929 };
3930
3931 static const struct tegra_io_pad_soc tegra194_io_pads[] = {
3932 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0x74, 0x78, UINT_MAX, "csia"),
3933 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0x74, 0x78, UINT_MAX, "csib"),
3934 TEGRA_IO_PAD(TEGRA_IO_PAD_MIPI_BIAS, 3, 0x74, 0x78, UINT_MAX, "mipi-bias"),
3935 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK_BIAS, 4, 0x74, 0x78, UINT_MAX, "pex-clk-bias"),
3936 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK3, 5, 0x74, 0x78, UINT_MAX, "pex-clk3"),
3937 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK2, 6, 0x74, 0x78, UINT_MAX, "pex-clk2"),
3938 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK1, 7, 0x74, 0x78, UINT_MAX, "pex-clk1"),
3939 TEGRA_IO_PAD(TEGRA_IO_PAD_EQOS, 8, 0x74, 0x78, UINT_MAX, "eqos"),
3940 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK_2_BIAS, 9, 0x74, 0x78, UINT_MAX, "pex-clk-2-bias"),
3941 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CLK_2, 10, 0x74, 0x78, UINT_MAX, "pex-clk-2"),
3942 TEGRA_IO_PAD(TEGRA_IO_PAD_DAP3, 11, 0x74, 0x78, UINT_MAX, "dap3"),
3943 TEGRA_IO_PAD(TEGRA_IO_PAD_DAP5, 12, 0x74, 0x78, UINT_MAX, "dap5"),
3944 TEGRA_IO_PAD(TEGRA_IO_PAD_UART, 14, 0x74, 0x78, UINT_MAX, "uart"),
3945 TEGRA_IO_PAD(TEGRA_IO_PAD_PWR_CTL, 15, 0x74, 0x78, UINT_MAX, "pwr-ctl"),
3946 TEGRA_IO_PAD(TEGRA_IO_PAD_SOC_GPIO53, 16, 0x74, 0x78, UINT_MAX, "soc-gpio53"),
3947 TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO, 17, 0x74, 0x78, UINT_MAX, "audio"),
3948 TEGRA_IO_PAD(TEGRA_IO_PAD_GP_PWM2, 18, 0x74, 0x78, UINT_MAX, "gp-pwm2"),
3949 TEGRA_IO_PAD(TEGRA_IO_PAD_GP_PWM3, 19, 0x74, 0x78, UINT_MAX, "gp-pwm3"),
3950 TEGRA_IO_PAD(TEGRA_IO_PAD_SOC_GPIO12, 20, 0x74, 0x78, UINT_MAX, "soc-gpio12"),
3951 TEGRA_IO_PAD(TEGRA_IO_PAD_SOC_GPIO13, 21, 0x74, 0x78, UINT_MAX, "soc-gpio13"),
3952 TEGRA_IO_PAD(TEGRA_IO_PAD_SOC_GPIO10, 22, 0x74, 0x78, UINT_MAX, "soc-gpio10"),
3953 TEGRA_IO_PAD(TEGRA_IO_PAD_UART4, 23, 0x74, 0x78, UINT_MAX, "uart4"),
3954 TEGRA_IO_PAD(TEGRA_IO_PAD_UART5, 24, 0x74, 0x78, UINT_MAX, "uart5"),
3955 TEGRA_IO_PAD(TEGRA_IO_PAD_DBG, 25, 0x74, 0x78, UINT_MAX, "dbg"),
3956 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP3, 26, 0x74, 0x78, UINT_MAX, "hdmi-dp3"),
3957 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP2, 27, 0x74, 0x78, UINT_MAX, "hdmi-dp2"),
3958 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP0, 28, 0x74, 0x78, UINT_MAX, "hdmi-dp0"),
3959 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP1, 29, 0x74, 0x78, UINT_MAX, "hdmi-dp1"),
3960 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CNTRL, 0, 0x7c, 0x80, UINT_MAX, "pex-cntrl"),
3961 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_CTL2, 1, 0x7c, 0x80, UINT_MAX, "pex-ctl2"),
3962 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_L0_RST, 2, 0x7c, 0x80, UINT_MAX, "pex-l0-rst"),
3963 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_L1_RST, 3, 0x7c, 0x80, UINT_MAX, "pex-l1-rst"),
3964 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC4, 4, 0x7c, 0x80, UINT_MAX, "sdmmc4"),
3965 TEGRA_IO_PAD(TEGRA_IO_PAD_PEX_L5_RST, 5, 0x7c, 0x80, UINT_MAX, "pex-l5-rst"),
3966 TEGRA_IO_PAD(TEGRA_IO_PAD_CAM, 6, 0x7c, 0x80, UINT_MAX, "cam"),
3967 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIC, 11, 0x7c, 0x80, UINT_MAX, "csic"),
3968 TEGRA_IO_PAD(TEGRA_IO_PAD_CSID, 12, 0x7c, 0x80, UINT_MAX, "csid"),
3969 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 13, 0x7c, 0x80, UINT_MAX, "csie"),
3970 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIF, 14, 0x7c, 0x80, UINT_MAX, "csif"),
3971 TEGRA_IO_PAD(TEGRA_IO_PAD_SPI, 15, 0x7c, 0x80, UINT_MAX, "spi"),
3972 TEGRA_IO_PAD(TEGRA_IO_PAD_UFS, 17, 0x7c, 0x80, UINT_MAX, "ufs"),
3973 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIG, 18, 0x7c, 0x80, UINT_MAX, "csig"),
3974 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIH, 19, 0x7c, 0x80, UINT_MAX, "csih"),
3975 TEGRA_IO_PAD(TEGRA_IO_PAD_EDP, 21, 0x7c, 0x80, UINT_MAX, "edp"),
3976 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1_HV, 23, 0x7c, 0x80, 4, "sdmmc1-hv"),
3977 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3_HV, 24, 0x7c, 0x80, 6, "sdmmc3-hv"),
3978 TEGRA_IO_PAD(TEGRA_IO_PAD_CONN, 28, 0x7c, 0x80, UINT_MAX, "conn"),
3979 TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO_HV, 29, 0x7c, 0x80, 1, "audio-hv"),
3980 TEGRA_IO_PAD(TEGRA_IO_PAD_AO_HV, UINT_MAX, UINT_MAX, UINT_MAX, 0, "ao-hv"),
3981 };
3982
3983 static const struct pinctrl_pin_desc tegra194_pin_descs[] = {
3984 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
3985 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
3986 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_MIPI_BIAS, "mipi-bias"),
3987 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK_BIAS, "pex-clk-bias"),
3988 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK3, "pex-clk3"),
3989 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK2, "pex-clk2"),
3990 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK1, "pex-clk1"),
3991 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EQOS, "eqos"),
3992 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK_2_BIAS, "pex-clk-2-bias"),
3993 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CLK_2, "pex-clk-2"),
3994 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DAP3, "dap3"),
3995 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DAP5, "dap5"),
3996 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART, "uart"),
3997 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PWR_CTL, "pwr-ctl"),
3998 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SOC_GPIO53, "soc-gpio53"),
3999 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO, "audio"),
4000 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_GP_PWM2, "gp-pwm2"),
4001 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_GP_PWM3, "gp-pwm3"),
4002 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SOC_GPIO12, "soc-gpio12"),
4003 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SOC_GPIO13, "soc-gpio13"),
4004 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SOC_GPIO10, "soc-gpio10"),
4005 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART4, "uart4"),
4006 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UART5, "uart5"),
4007 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_DBG, "dbg"),
4008 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP3, "hdmi-dp3"),
4009 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP2, "hdmi-dp2"),
4010 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP0, "hdmi-dp0"),
4011 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP1, "hdmi-dp1"),
4012 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CNTRL, "pex-cntrl"),
4013 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_CTL2, "pex-ctl2"),
4014 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_L0_RST, "pex-l0-rst"),
4015 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_L1_RST, "pex-l1-rst"),
4016 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC4, "sdmmc4"),
4017 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_PEX_L5_RST, "pex-l5-rst"),
4018 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CAM, "cam"),
4019 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIC, "csic"),
4020 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSID, "csid"),
4021 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
4022 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIF, "csif"),
4023 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SPI, "spi"),
4024 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UFS, "ufs"),
4025 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIG, "csig"),
4026 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIH, "csih"),
4027 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EDP, "edp"),
4028 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1_HV, "sdmmc1-hv"),
4029 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3_HV, "sdmmc3-hv"),
4030 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CONN, "conn"),
4031 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO_HV, "audio-hv"),
4032 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AO_HV, "ao-hv"),
4033 };
4034
4035 static const struct tegra_pmc_regs tegra194_pmc_regs = {
4036 .scratch0 = 0x2000,
4037 .rst_status = 0x70,
4038 .rst_source_shift = 0x2,
4039 .rst_source_mask = 0x7c,
4040 .rst_level_shift = 0x0,
4041 .rst_level_mask = 0x3,
4042 };
4043
4044 static const char * const tegra194_reset_sources[] = {
4045 "SYS_RESET_N",
4046 "AOWDT",
4047 "BCCPLEXWDT",
4048 "BPMPWDT",
4049 "SCEWDT",
4050 "SPEWDT",
4051 "APEWDT",
4052 "LCCPLEXWDT",
4053 "SENSOR",
4054 "AOTAG",
4055 "VFSENSOR",
4056 "MAINSWRST",
4057 "SC7",
4058 "HSM",
4059 "CSITE",
4060 "RCEWDT",
4061 "PVA0WDT",
4062 "PVA1WDT",
4063 "L1A_ASYNC",
4064 "BPMPBOOT",
4065 "FUSECRC",
4066 };
4067
4068 static const struct tegra_wake_event tegra194_wake_events[] = {
4069 TEGRA_WAKE_GPIO("eqos", 20, 0, TEGRA194_MAIN_GPIO(G, 4)),
4070 TEGRA_WAKE_IRQ("pmu", 24, 209),
4071 TEGRA_WAKE_GPIO("power", 29, 1, TEGRA194_AON_GPIO(EE, 4)),
4072 TEGRA_WAKE_IRQ("rtc", 73, 10),
4073 TEGRA_WAKE_SIMPLE("usb3-port-0", 76),
4074 TEGRA_WAKE_SIMPLE("usb3-port-1", 77),
4075 TEGRA_WAKE_SIMPLE("usb3-port-2-3", 78),
4076 TEGRA_WAKE_SIMPLE("usb2-port-0", 79),
4077 TEGRA_WAKE_SIMPLE("usb2-port-1", 80),
4078 TEGRA_WAKE_SIMPLE("usb2-port-2", 81),
4079 TEGRA_WAKE_SIMPLE("usb2-port-3", 82),
4080 };
4081
4082 static const struct tegra_pmc_soc tegra194_pmc_soc = {
4083 .supports_core_domain = false,
4084 .num_powergates = 0,
4085 .powergates = NULL,
4086 .num_cpu_powergates = 0,
4087 .cpu_powergates = NULL,
4088 .has_tsense_reset = false,
4089 .has_gpu_clamps = false,
4090 .needs_mbist_war = false,
4091 .has_impl_33v_pwr = true,
4092 .maybe_tz_only = false,
4093 .num_io_pads = ARRAY_SIZE(tegra194_io_pads),
4094 .io_pads = tegra194_io_pads,
4095 .num_pin_descs = ARRAY_SIZE(tegra194_pin_descs),
4096 .pin_descs = tegra194_pin_descs,
4097 .regs = &tegra194_pmc_regs,
4098 .init = tegra186_pmc_init,
4099 .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
4100 .set_wake_filters = tegra186_pmc_set_wake_filters,
4101 .irq_set_wake = tegra186_pmc_irq_set_wake,
4102 .irq_set_type = tegra186_pmc_irq_set_type,
4103 .reset_sources = tegra194_reset_sources,
4104 .num_reset_sources = ARRAY_SIZE(tegra194_reset_sources),
4105 .reset_levels = tegra186_reset_levels,
4106 .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
4107 .num_wake_events = ARRAY_SIZE(tegra194_wake_events),
4108 .wake_events = tegra194_wake_events,
4109 .max_wake_events = 96,
4110 .max_wake_vectors = 3,
4111 .pmc_clks_data = NULL,
4112 .num_pmc_clks = 0,
4113 .has_blink_output = false,
4114 .has_usb_sleepwalk = false,
4115 .has_single_mmio_aperture = false,
4116 };
4117
4118 static const struct tegra_io_pad_soc tegra234_io_pads[] = {
4119 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIA, 0, 0xe0c0, 0xe0c4, UINT_MAX, "csia"),
4120 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIB, 1, 0xe0c0, 0xe0c4, UINT_MAX, "csib"),
4121 TEGRA_IO_PAD(TEGRA_IO_PAD_HDMI_DP0, 0, 0xe0d0, 0xe0d4, UINT_MAX, "hdmi-dp0"),
4122 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIC, 2, 0xe0c0, 0xe0c4, UINT_MAX, "csic"),
4123 TEGRA_IO_PAD(TEGRA_IO_PAD_CSID, 3, 0xe0c0, 0xe0c4, UINT_MAX, "csid"),
4124 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIE, 4, 0xe0c0, 0xe0c4, UINT_MAX, "csie"),
4125 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIF, 5, 0xe0c0, 0xe0c4, UINT_MAX, "csif"),
4126 TEGRA_IO_PAD(TEGRA_IO_PAD_UFS, 0, 0xe064, 0xe068, UINT_MAX, "ufs"),
4127 TEGRA_IO_PAD(TEGRA_IO_PAD_EDP, 1, 0xe05c, 0xe060, UINT_MAX, "edp"),
4128 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC1_HV, 0, 0xe054, 0xe058, 4, "sdmmc1-hv"),
4129 TEGRA_IO_PAD(TEGRA_IO_PAD_SDMMC3_HV, UINT_MAX, UINT_MAX, UINT_MAX, 6, "sdmmc3-hv"),
4130 TEGRA_IO_PAD(TEGRA_IO_PAD_AUDIO_HV, UINT_MAX, UINT_MAX, UINT_MAX, 1, "audio-hv"),
4131 TEGRA_IO_PAD(TEGRA_IO_PAD_AO_HV, UINT_MAX, UINT_MAX, UINT_MAX, 0, "ao-hv"),
4132 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIG, 6, 0xe0c0, 0xe0c4, UINT_MAX, "csig"),
4133 TEGRA_IO_PAD(TEGRA_IO_PAD_CSIH, 7, 0xe0c0, 0xe0c4, UINT_MAX, "csih"),
4134 };
4135
4136 static const struct pinctrl_pin_desc tegra234_pin_descs[] = {
4137 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIA, "csia"),
4138 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIB, "csib"),
4139 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_HDMI_DP0, "hdmi-dp0"),
4140 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIC, "csic"),
4141 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSID, "csid"),
4142 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIE, "csie"),
4143 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIF, "csif"),
4144 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_UFS, "ufs"),
4145 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_EDP, "edp"),
4146 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC1_HV, "sdmmc1-hv"),
4147 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_SDMMC3_HV, "sdmmc3-hv"),
4148 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AUDIO_HV, "audio-hv"),
4149 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_AO_HV, "ao-hv"),
4150 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIG, "csig"),
4151 TEGRA_IO_PIN_DESC(TEGRA_IO_PAD_CSIH, "csih"),
4152 };
4153
4154 static const struct tegra_pmc_regs tegra234_pmc_regs = {
4155 .scratch0 = 0x2000,
4156 .rst_status = 0x70,
4157 .rst_source_shift = 0x2,
4158 .rst_source_mask = 0xfc,
4159 .rst_level_shift = 0x0,
4160 .rst_level_mask = 0x3,
4161 };
4162
4163 static const char * const tegra234_reset_sources[] = {
4164 "SYS_RESET_N", /* 0x0 */
4165 "AOWDT",
4166 "BCCPLEXWDT",
4167 "BPMPWDT",
4168 "SCEWDT",
4169 "SPEWDT",
4170 "APEWDT",
4171 "LCCPLEXWDT",
4172 "SENSOR", /* 0x8 */
4173 NULL,
4174 NULL,
4175 "MAINSWRST",
4176 "SC7",
4177 "HSM",
4178 NULL,
4179 "RCEWDT",
4180 NULL, /* 0x10 */
4181 NULL,
4182 NULL,
4183 "BPMPBOOT",
4184 "FUSECRC",
4185 "DCEWDT",
4186 "PSCWDT",
4187 "PSC",
4188 "CSITE_SW", /* 0x18 */
4189 "POD",
4190 "SCPM",
4191 "VREFRO_POWERBAD",
4192 "VMON",
4193 "FMON",
4194 "FSI_R5WDT",
4195 "FSI_THERM",
4196 "FSI_R52C0WDT", /* 0x20 */
4197 "FSI_R52C1WDT",
4198 "FSI_R52C2WDT",
4199 "FSI_R52C3WDT",
4200 "FSI_FMON",
4201 "FSI_VMON", /* 0x25 */
4202 };
4203
4204 static const struct tegra_wake_event tegra234_wake_events[] = {
4205 TEGRA_WAKE_GPIO("sd-wake", 8, 0, TEGRA234_MAIN_GPIO(G, 7)),
4206 TEGRA_WAKE_GPIO("eqos", 20, 0, TEGRA234_MAIN_GPIO(G, 4)),
4207 TEGRA_WAKE_IRQ("pmu", 24, 209),
4208 TEGRA_WAKE_GPIO("power", 29, 1, TEGRA234_AON_GPIO(EE, 4)),
4209 TEGRA_WAKE_GPIO("mgbe", 56, 0, TEGRA234_MAIN_GPIO(Y, 3)),
4210 TEGRA_WAKE_IRQ("rtc", 73, 10),
4211 TEGRA_WAKE_IRQ("sw-wake", SW_WAKE_ID, 179),
4212 };
4213
4214 static const struct tegra_pmc_soc tegra234_pmc_soc = {
4215 .supports_core_domain = false,
4216 .num_powergates = 0,
4217 .powergates = NULL,
4218 .num_cpu_powergates = 0,
4219 .cpu_powergates = NULL,
4220 .has_tsense_reset = false,
4221 .has_gpu_clamps = false,
4222 .needs_mbist_war = false,
4223 .has_impl_33v_pwr = true,
4224 .maybe_tz_only = false,
4225 .num_io_pads = ARRAY_SIZE(tegra234_io_pads),
4226 .io_pads = tegra234_io_pads,
4227 .num_pin_descs = ARRAY_SIZE(tegra234_pin_descs),
4228 .pin_descs = tegra234_pin_descs,
4229 .regs = &tegra234_pmc_regs,
4230 .init = tegra186_pmc_init,
4231 .setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
4232 .set_wake_filters = tegra186_pmc_set_wake_filters,
4233 .irq_set_wake = tegra186_pmc_irq_set_wake,
4234 .irq_set_type = tegra186_pmc_irq_set_type,
4235 .reset_sources = tegra234_reset_sources,
4236 .num_reset_sources = ARRAY_SIZE(tegra234_reset_sources),
4237 .reset_levels = tegra186_reset_levels,
4238 .num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
4239 .num_wake_events = ARRAY_SIZE(tegra234_wake_events),
4240 .wake_events = tegra234_wake_events,
4241 .max_wake_events = 96,
4242 .max_wake_vectors = 3,
4243 .pmc_clks_data = NULL,
4244 .num_pmc_clks = 0,
4245 .has_blink_output = false,
4246 .has_single_mmio_aperture = false,
4247 };
4248
4249 static const struct of_device_id tegra_pmc_match[] = {
4250 { .compatible = "nvidia,tegra234-pmc", .data = &tegra234_pmc_soc },
4251 { .compatible = "nvidia,tegra194-pmc", .data = &tegra194_pmc_soc },
4252 { .compatible = "nvidia,tegra186-pmc", .data = &tegra186_pmc_soc },
4253 { .compatible = "nvidia,tegra210-pmc", .data = &tegra210_pmc_soc },
4254 { .compatible = "nvidia,tegra132-pmc", .data = &tegra124_pmc_soc },
4255 { .compatible = "nvidia,tegra124-pmc", .data = &tegra124_pmc_soc },
4256 { .compatible = "nvidia,tegra114-pmc", .data = &tegra114_pmc_soc },
4257 { .compatible = "nvidia,tegra30-pmc", .data = &tegra30_pmc_soc },
4258 { .compatible = "nvidia,tegra20-pmc", .data = &tegra20_pmc_soc },
4259 { }
4260 };
4261
4262 static void tegra_pmc_sync_state(struct device *dev)
4263 {
4264 int err;
4265
4266 /*
4267 * Newer device-trees have power domains, but we need to prepare all
4268 * device drivers with runtime PM and OPP support first, otherwise
4269 * state syncing is unsafe.
4270 */
4271 if (!pmc->soc->supports_core_domain)
4272 return;
4273
4274 /*
4275 * Older device-trees don't have core PD, and thus, there are
4276 * no dependencies that will block the state syncing. We shouldn't
4277 * mark the domain as synced in this case.
4278 */
4279 if (!pmc->core_domain_registered)
4280 return;
4281
4282 pmc->core_domain_state_synced = true;
4283
4284 /* this is a no-op if core regulator isn't used */
4285 mutex_lock(&pmc->powergates_lock);
4286 err = dev_pm_opp_sync_regulators(dev);
4287 mutex_unlock(&pmc->powergates_lock);
4288
4289 if (err)
4290 dev_err(dev, "failed to sync regulators: %d\n", err);
4291 }
4292
4293 static struct platform_driver tegra_pmc_driver = {
4294 .driver = {
4295 .name = "tegra-pmc",
4296 .suppress_bind_attrs = true,
4297 .of_match_table = tegra_pmc_match,
4298 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_ARM)
4299 .pm = &tegra_pmc_pm_ops,
4300 #endif
4301 .sync_state = tegra_pmc_sync_state,
4302 },
4303 .probe = tegra_pmc_probe,
4304 };
4305 builtin_platform_driver(tegra_pmc_driver);
4306
4307 static bool __init tegra_pmc_detect_tz_only(struct tegra_pmc *pmc)
4308 {
4309 u32 value, saved;
4310
4311 saved = readl(pmc->base + pmc->soc->regs->scratch0);
4312 value = saved ^ 0xffffffff;
4313
4314 if (value == 0xffffffff)
4315 value = 0xdeadbeef;
4316
4317 /* write pattern and read it back */
4318 writel(value, pmc->base + pmc->soc->regs->scratch0);
4319 value = readl(pmc->base + pmc->soc->regs->scratch0);
4320
4321 /* if we read all-zeroes, access is restricted to TZ only */
4322 if (value == 0) {
4323 pr_info("access to PMC is restricted to TZ\n");
4324 return true;
4325 }
4326
4327 /* restore original value */
4328 writel(saved, pmc->base + pmc->soc->regs->scratch0);
4329
4330 return false;
4331 }
4332
4333 /*
4334 * Early initialization to allow access to registers in the very early boot
4335 * process.
4336 */
4337 static int __init tegra_pmc_early_init(void)
4338 {
4339 const struct of_device_id *match;
4340 struct device_node *np;
4341 struct resource regs;
4342 unsigned int i;
4343 bool invert;
4344
4345 mutex_init(&pmc->powergates_lock);
4346
4347 np = of_find_matching_node_and_match(NULL, tegra_pmc_match, &match);
4348 if (!np) {
4349 /*
4350 * Fall back to legacy initialization for 32-bit ARM only. All
4351 * 64-bit ARM device tree files for Tegra are required to have
4352 * a PMC node.
4353 *
4354 * This is for backwards-compatibility with old device trees
4355 * that didn't contain a PMC node. Note that in this case the
4356 * SoC data can't be matched and therefore powergating is
4357 * disabled.
4358 */
4359 if (IS_ENABLED(CONFIG_ARM) && soc_is_tegra()) {
4360 pr_warn("DT node not found, powergating disabled\n");
4361
4362 regs.start = 0x7000e400;
4363 regs.end = 0x7000e7ff;
4364 regs.flags = IORESOURCE_MEM;
4365
4366 pr_warn("Using memory region %pR\n", &regs);
4367 } else {
4368 /*
4369 * At this point we're not running on Tegra, so play
4370 * nice with multi-platform kernels.
4371 */
4372 return 0;
4373 }
4374 } else {
4375 /*
4376 * Extract information from the device tree if we've found a
4377 * matching node.
4378 */
4379 if (of_address_to_resource(np, 0, &regs) < 0) {
4380 pr_err("failed to get PMC registers\n");
4381 of_node_put(np);
4382 return -ENXIO;
4383 }
4384 }
4385
4386 pmc->base = ioremap(regs.start, resource_size(&regs));
4387 if (!pmc->base) {
4388 pr_err("failed to map PMC registers\n");
4389 of_node_put(np);
4390 return -ENXIO;
4391 }
4392
4393 if (of_device_is_available(np)) {
4394 pmc->soc = match->data;
4395
4396 if (pmc->soc->maybe_tz_only)
4397 pmc->tz_only = tegra_pmc_detect_tz_only(pmc);
4398
4399 /* Create a bitmap of the available and valid partitions */
4400 for (i = 0; i < pmc->soc->num_powergates; i++)
4401 if (pmc->soc->powergates[i])
4402 set_bit(i, pmc->powergates_available);
4403
4404 /*
4405 * Invert the interrupt polarity if a PMC device tree node
4406 * exists and contains the nvidia,invert-interrupt property.
4407 */
4408 invert = of_property_read_bool(np, "nvidia,invert-interrupt");
4409
4410 pmc->soc->setup_irq_polarity(pmc, np, invert);
4411
4412 of_node_put(np);
4413 }
4414
4415 return 0;
4416 }
4417 early_initcall(tegra_pmc_early_init);
Linux kernel stable tree