arm: tegra: Move driver files to drivers/platform
[linux-3.10.git] / arch / arm / mach-tegra / sleep-t30.S
1 /*
2  * Copyright (c) 2010-2014, NVIDIA CORPORATION.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15  */
16
17 #include <linux/const.h>
18 #include <linux/init.h>
19 #include <linux/linkage.h>
20
21 #include <asm/assembler.h>
22 #include <asm/cache.h>
23 #include <asm/domain.h>
24 #include <asm/memory.h>
25 #include <asm/page.h>
26 #include <asm/ptrace.h>
27 #include <asm/asm-offsets.h>
28 #include <asm/glue-cache.h>
29 #include <asm/glue-proc.h>
30 #include <asm/cp15.h>
31
32 #include "sleep.h"
33 #include <linux/platform/tegra/clock.h>
34 #include <linux/platform/tegra/reset.h>
35
36 #define EMC_CFG                         0xc
37 #define EMC_ADR_CFG                     0x10
38 #define EMC_TIMING_CONTROL              0x28
39 #define EMC_REFRESH                     0x70
40 #define EMC_NOP                         0xdc
41 #define EMC_SELF_REF                    0xe0
42 #define EMC_MRW                         0xe8
43 #define EMC_REQ_CTRL                    0x2b0
44 #define EMC_EMC_STATUS                  0x2b4
45 #define EMC_FBIO_CFG5                   0x104
46 #define EMC_AUTO_CAL_CONFIG             0x2a4
47 #define EMC_AUTO_CAL_INTERVAL           0x2a8
48 #define EMC_AUTO_CAL_STATUS             0x2ac
49 #define EMC_CFG_DIG_DLL                 0x2bc
50 #define EMC_ZCAL_INTERVAL               0x2e0
51 #define EMC_ZQ_CAL                      0x2ec
52 #define EMC_XM2VTTGENPADCTRL            0x310
53 #define EMC_XM2VTTGENPADCTRL2           0x314
54
55 #define PMC_CTRL                        0x0
56 #define PMC_CTRL_SIDE_EFFECT_LP0        (1 << 14)  /* enter LP0 when CPU pwr gated */
57
58 #define PMC_PWRGATE_TOGGLE              0x30
59 #define PMC_REMOVE_CLAMPING_CMD         0x34
60 #define PMC_PWRGATE_STATUS              0x38
61
62 #define PMC_PWRGATE_PARTID_L2C          (0x5)
63
64 #define PMC_IO_DPD_REQ                  0x1b8
65 #define PMC_IO_DPD_STATUS               0x1bc
66 #define PMC_IO_DPD2_REQ                 0x1c0
67 #define PMC_IO_DPD2_REQ_CODE_DPD_OFF    (1 << 30)
68 #define PMC_IO_DPD2_REQ_DISC_BIAS       (1 << 27)
69 #define PMC_SCRATCH1_ECO                0x264
70 #define PMC_POR_DPD_CTRL                0x264
71
72 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
73 #define PMC_IO_DPD3_REQ                 0x45c
74 #define PMC_IO_DPD3_STATUS              0x460
75
76 #define EMC_SEL_DPD_CTRL                0x3d8
77
78 #define PMC_POR_DPD_CTRL                0x264
79 #endif
80
81 #define FLOW_IPC_STS                    0x500
82 #define FLOW_IPC_STS_AP2BB_MSC_STS_0    (1 << 4)
83
84 #define CLK_RESET_CCLK_BURST            0x20
85 #define CCLK_BURST_PLLX_DIV2_BYPASS_LP  (1<<16)
86 #define CLK_RESET_CCLK_DIVIDER          0x24
87 #define CLK_RESET_SCLK_BURST            0x28
88 #define CLK_RESET_SCLK_DIVIDER          0x2c
89
90 #define CLK_RESET_PLLC_BASE             0x80
91 #define CLK_RESET_PLLM_BASE             0x90
92 #define CLK_RESET_PLLP_BASE             0xa0
93 #define CLK_RESET_PLLA_BASE             0xb0
94 #define CLK_RESET_PLLX_BASE             0xe0
95
96 #define CLK_RESET_PLLP_RESHIFT          0x528
97 #define CLK_RESET_PLLP_RESHIFT_DEFAULT  0x3b
98 #define CLK_RESET_PLLP_RESHIFT_ENABLE   0x3
99
100 #define CLK_RESET_PLLC_MISC             0x8c
101 #define CLK_RESET_PLLM_MISC             0x9c
102 #define CLK_RESET_PLLP_MISC             0xac
103 #define CLK_RESET_PLLA_MISC             0xbc
104 #define CLK_RESET_PLLX_MISC             0xe4
105 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
106 #define CLK_RESET_PLLX_MISC3            0x518
107 #define CLK_RESET_PLLM_MISC_IDDQ        5
108 #define CLK_RESET_PLLC_MISC_IDDQ        26
109 #define CLK_RESET_PLLX_MISC3_IDDQ       3
110 #endif
111
112 #define CLK_RESET_PLLP_OUTA             0xa4
113 #define CLK_RESET_PLLP_OUTB             0xa8
114
115 #define PMC_PLLP_WB0_OVERRIDE           0xf8
116 #define PMC_PLLM_WB0_OVERRIDE           0x1dc
117
118 #define CLK_RESET_CLK_SOURCE_EMC        0x19c
119 #define CLK_RESET_CLK_SOURCE_MSELECT    0x3b4
120 #define CLK_RESET_CLK_ENB_H_SET         0x328
121 #define CLK_RESET_CLK_ENB_H_CLR         0x32c
122 #define CLK_RESET_CLK_RST_DEV_H_SET             0x308
123 #define CLK_RESET_CLK_RST_DEV_H_CLR             0x30c
124 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
125 #define CLK_RESET_CLK_ENB_W_SET         0x448
126 #define CLK_RESET_CLK_ENB_W_CLR         0x44c
127 #endif
128
129 #define I2C_CNFG        0x0
130 #define I2C_ADDR0       0x4
131 #define I2C_DATA1       0xc
132 #define I2C_DATA2       0x10
133 #define I2C_STATUS      0x1c
134
135 #define MSELECT_CLKM                    (0x3 << 30)
136
137 #define FLOW_CONTROL_CLUSTER_CONTROL    0x2c
138
139 #define TEGRA_RTC_MSEC  0x10
140
141 #if USE_PLL_LOCK_BITS
142 #define LOCK_DELAY              PLL_POST_LOCK_DELAY
143 #else
144 #define LOCK_DELAY              0xff /* 255uS delay for PLL stabilization */
145 #endif
146
147 #define USE_PLLP_ON_SLEEP_ENTRY 0
148
149 #define TEGRA30_POWER_HOTPLUG_SHUTDOWN  (1 << 27) /* Hotplug shutdown */
150
151 .macro emc_device_mask, rd, base
152         ldr     \rd, [\base, #EMC_ADR_CFG]
153         tst     \rd, #0x1
154         moveq   \rd, #(0x1<<8)          @ just 1 device
155         movne   \rd, #(0x3<<8)          @ 2 devices
156 .endm
157
158 .macro emc_timing_update, rd, base
159         mov     \rd, #1
160         str     \rd, [\base, #EMC_TIMING_CONTROL]
161 1001:
162         ldr     \rd, [\base, #EMC_EMC_STATUS]
163         tst     \rd, #(0x1<<23)         @ wait until EMC_STATUS_TIMING_UPDATE_STALLED is clear
164         bne     1001b
165 .endm
166
167 #if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_PM_SLEEP)
168 /*
169  * tegra30_hotplug_shutdown(void)
170  *
171  * Powergates the current CPU.
172  * Should never return.
173  */
174 ENTRY(tegra30_hotplug_shutdown)
175         mov     r6, lr
176         bl      tegra_cpu_exit_coherency
177
178         /* Powergate this CPU */
179         mov     r0, #TEGRA30_POWER_HOTPLUG_SHUTDOWN
180         bl      tegra30_cpu_shutdown
181         mov     pc, r6                  @ should never get here
182 ENDPROC(tegra30_hotplug_shutdown)
183
184 /*
185  * tegra30_cpu_shutdown(unsigned long flags)
186  *
187  * Puts the current CPU in wait-for-event mode on the flow controller
188  * and powergates it -- flags (in R0) indicate the request type.
189  * Must never be called for CPU 0.
190  *
191  * corrupts r0-r4, r12
192  */
193 ENTRY(tegra30_cpu_shutdown)
194         cpu_id  r3
195 #ifndef CONFIG_ARCH_TEGRA_HAS_SYMMETRIC_CPU_PWR_GATE
196         cmp     r3, #0
197         moveq   pc, lr          @ Must never be called for CPU 0
198 #endif
199
200         ldr     r12, =TEGRA_FLOW_CTRL_VIRT
201         cpu_to_csr_reg r1, r3
202         add     r1, r1, r12     @ virtual CSR address for this CPU
203         cpu_to_halt_reg r2, r3
204         add     r2, r2, r12     @ virtual HALT_EVENTS address for this CPU
205
206         /*
207          * Clear this CPU's "event" and "interrupt" flags and power gate
208          * it when halting but not before it is in the "WFE" state.
209          */
210         movw    r12, \
211                 FLOW_CTRL_CSR_INTR_FLAG | FLOW_CTRL_CSR_EVENT_FLAG | \
212                 FLOW_CTRL_CSR_ENABLE
213 #if defined(CONFIG_ARCH_TEGRA_11x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
214         mov     r4, #(1 << 8)                   @ wfi bitmap
215 #else
216         mov     r4, #(1 << 4)                   @ wfe bitmap
217 #endif
218         orr     r12, r12, r4, lsl r3
219         str     r12, [r1]
220
221         /* Halt this CPU. */
222         mov     r3, #0x400
223 delay_1:
224         subs    r3, r3, #1                      @ delay as a part of wfe war.
225         bge     delay_1;
226         cpsid   a                               @ disable imprecise aborts.
227         ldr     r3, [r1]                        @ read CSR
228         str     r3, [r1]                        @ clear CSR
229         tst     r0, #TEGRA30_POWER_HOTPLUG_SHUTDOWN
230 #ifdef CONFIG_ARCH_TEGRA_HAS_SYMMETRIC_CPU_PWR_GATE
231         mov     r3, #FLOW_CTRL_WAITEVENT
232         orreq   r3, r3, #FLOW_CTRL_HALT_GIC_IRQ
233         orreq   r3, r3, #FLOW_CTRL_HALT_GIC_FIQ
234 #else
235         moveq   r3, #FLOW_CTRL_WAIT_FOR_INTERRUPT       @ For LP2
236         movne   r3, #FLOW_CTRL_WAITEVENT                @ For hotplug
237 #endif
238         str     r3, [r2]
239         ldr     r0, [r2]
240         b       wfe_war
241
242 __cpu_reset_again:
243         dsb
244         .align 5
245 #if defined(CONFIG_ARCH_TEGRA_11x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
246         wfi                                     @ CPU should be power gated here
247 #else
248         wfe                                     @ CPU should be power gated here
249 #endif
250 wfe_war:
251         b       __cpu_reset_again
252
253         /*
254          * 38 nop's, which fills reset of wfe cache line and
255          * 4 more cachelines with nop
256          */
257         .rept 38
258         nop
259         .endr
260         b       .                               @ should never get here
261
262 ENDPROC(tegra30_cpu_shutdown)
263 #endif
264
265 #ifdef CONFIG_PM_SLEEP
266 /*
267  * tegra3_sleep_core_finish(unsigned long int)
268  *
269  * enters suspend in LP0 or LP1 by turning off the mmu and jumping to
270  * tegra3_tear_down_core in IRAM
271  */
272 ENTRY(tegra3_sleep_core_finish)
273         mov     r4, r0
274         bl      tegra_flush_cache
275         mov     r0, r4
276         bl      tegra_cpu_exit_coherency
277
278         /* preload all the address literals that are needed for the
279          * CPU power-gating process, to avoid loads from SDRAM (which are
280          * not supported once SDRAM is put into self-refresh.
281          * LP0 / LP1 use physical address, since the MMU needs to be
282          * disabled before putting SDRAM into self-refresh to avoid
283          * memory access due to page table walks */
284         mov32   r4, TEGRA_PMC_BASE
285         mov32   r5, TEGRA_CLK_RESET_BASE
286         mov32   r6, TEGRA_FLOW_CTRL_BASE
287         mov32   r7, TEGRA_TMRUS_BASE
288
289         mov32   r1, tegra3_tear_down_core
290         mov32   r2, tegra3_iram_start
291         sub     r1, r1, r2
292         mov32   r2, TEGRA_IRAM_CODE_AREA
293         add     r1, r1, r2
294         mov     r11, #0
295         b       tegra_turn_off_mmu
296 ENDPROC(tegra3_sleep_core_finish)
297
298 ENTRY(tegra3_stop_mc_clk_finish)
299         mov     r4, r0
300         bl      tegra_flush_cache
301         mov     r0, r4
302         bl      tegra_cpu_exit_coherency
303
304         /* preload all the address literals that are needed for the
305          * CPU power-gating process, to avoid loads from SDRAM (which are
306          * not supported once SDRAM is put into self-refresh.
307          * LP0 / LP1 use physical address, since the MMU needs to be
308          * disabled before putting SDRAM into self-refresh to avoid
309          * memory access due to page table walks */
310         mov32   r4, TEGRA_PMC_BASE
311         mov32   r5, TEGRA_CLK_RESET_BASE
312         mov32   r6, TEGRA_FLOW_CTRL_BASE
313         mov32   r7, TEGRA_TMRUS_BASE
314
315         mov32   r1, tegra3_stop_mc_clk
316         mov32   r2, tegra3_iram_start
317         sub     r1, r1, r2
318         mov32   r2, TEGRA_IRAM_CODE_AREA
319         add     r1, r1, r2
320         mov     r11, #1
321         b       tegra_turn_off_mmu
322 ENDPROC(tegra3_stop_mc_clk_finish)
323
324 /*
325  * tegra3_sleep_cpu_secondary_finish(unsigned long v2p)
326  *
327  * Enters LP2 on secondary CPU by exiting coherency and powergating the CPU.
328  */
329 ENTRY(tegra3_sleep_cpu_secondary_finish)
330         mov     r6, lr
331
332         bl      tegra_flush_l1_cache
333         bl      tegra_cpu_exit_coherency
334
335         /* Powergate this CPU. */
336         mov     r0, #0                          @ power mode flags (!hotplug)
337         bl      tegra30_cpu_shutdown
338         mov     r0, #1                          @ never return here
339         mov     pc, r6
340 ENDPROC(tegra3_sleep_cpu_secondary_finish)
341
342 /*
343  * tegra3_tear_down_cpu
344  *
345  * Switches the CPU cluster to PLL-P and enters sleep.
346  */
347 ENTRY(tegra3_tear_down_cpu)
348         mov32   r4, TEGRA_PMC_BASE
349         mov32   r5, TEGRA_CLK_RESET_BASE
350         mov32   r6, TEGRA_FLOW_CTRL_BASE
351         mov32   r7, TEGRA_TMRUS_BASE
352 #if USE_PLLP_ON_SLEEP_ENTRY
353         bl      tegra_cpu_pllp
354 #endif
355         b       tegra3_enter_sleep
356 ENDPROC(tegra3_tear_down_cpu)
357
358 /* START OF ROUTINES COPIED TO IRAM */
359         .align L1_CACHE_SHIFT
360         .globl tegra3_iram_start
361 tegra3_iram_start:
362
363 /*
364  * tegra3_lp1_reset
365  *
366  * reset vector for LP1 restore; copied into IRAM during suspend.
367  * brings the system back up to a safe starting point (SDRAM out of
368  * self-refresh, PLLC, PLLM and PLLP reenabled, CPU running on PLLP,
369  * system clock running on the same PLL that it suspended at), and
370  * jumps to tegra_lp2_startup to restore PLLX and virtual addressing.
371  * physical address of tegra_lp2_startup expected to be stored in
372  * PMC_SCRATCH41
373  *
374  * NOTE: THIS *MUST* BE RELOCATED TO TEGRA_IRAM_CODE_AREA AND MUST BE FIRST.
375  */
376 .macro pll_enable, rd, car, base, misc
377         ldr     \rd, [\car, #\base]
378         tst     \rd, #(1<<30)
379         orreq   \rd, \rd, #(1<<30)
380         streq   \rd, [\car, #\base]
381 #if USE_PLL_LOCK_BITS
382         .if     \misc
383         ldr     \rd, [\car, #\misc]
384         bic     \rd, \rd, #(1<<18)
385         str     \rd, [\car, #\misc]
386         ldr     \rd, [\car, #\misc]
387         ldr     \rd, [\car, #\misc]
388         orr     \rd, \rd, #(1<<18)
389         str     \rd, [\car, #\misc]
390         .endif
391 #endif
392 .endm
393
394 .macro pll_locked, rd, car, base
395 #if USE_PLL_LOCK_BITS
396 1:
397         ldr     \rd, [\car, #\base]
398         tst     \rd, #(1<<27)
399         beq     1b
400 #endif
401 .endm
402
403 .macro pll_iddq_exit, rd, car, iddq, iddq_bit
404         ldr     \rd, [\car, #\iddq]
405         bic     \rd, \rd, #(1<<\iddq_bit)
406         str     \rd, [\car, #\iddq]
407 .endm
408
409 .macro pll_iddq_entry, rd, car, iddq, iddq_bit
410         ldr     \rd, [\car, #\iddq]
411         orr     \rd, \rd, #(1<<\iddq_bit)
412         str     \rd, [\car, #\iddq]
413 .endm
414
415 /* Prepare to set the Core to the lowest voltage if supported.
416  * Start by setting the I2C clocks to make the I2C transfer.
417  * rd, re and rf are temporary registers.
418  * car = TEGRA_CLK_RESET_BASE
419  * volt = core voltage + pmu register offset
420  */
421 .macro set_voltage, rd, re, rf, car, volt
422 #ifdef CONFIG_TEGRA_LP1_LOW_COREVOLTAGE
423 1:
424         /* Reset(Set/Clr) the DVC-I2C Controller*/
425         mov \rd, #(1 << 15)
426         str \rd, [\car, #CLK_RESET_CLK_RST_DEV_H_SET]
427
428         mov32   r7, TEGRA_TMRUS_BASE
429         /* Wait for 2us */
430         wait_for_us \re, r7, r9
431         add \re, \re, #2
432         wait_until \re, r7, r9
433
434         mov \rd, #(1 << 15)
435         str \rd, [\car, #CLK_RESET_CLK_RST_DEV_H_CLR]
436
437         /* Enable the DVC-I2C Controller */
438         mov \rd, #(1 << 15)
439         str \rd, [\car, #CLK_RESET_CLK_ENB_H_SET]
440         /* I2C transfer protocol:
441          * 4 packets: Slaveaddr + WriteConfigure + Data1 + Data2 */
442
443         /* First, check if entries are valid, bail out otherwise */
444         ldr \rd, lp1_register_pmuslave_addr
445         cmp \rd, #0
446         beq 3f
447
448         ldr \re, lp1_register_i2c_base_addr
449         str \rd, [\re, #I2C_ADDR0]
450
451         mov32 \rd, 0x2
452         str \rd, [\re, #I2C_CNFG]
453
454         ldr \rd, \volt
455         str \rd, [\re, #I2C_DATA1]
456
457         mov32 \rd, 0
458         str \rd, [\re, #I2C_DATA2]
459
460         mov32 \rd, 0xA02
461         str \rd, [\re, #I2C_CNFG]
462
463         /* Check the transaction status before proceeding */
464         wait_for_us \rd, r7, r9
465         mov32 \rf, 0x7D0   /* Wait for 2ms and try transaction again */
466         add \rf, \rd, \rf
467 2:
468         add \rd, \rd, #0xFA /* Check status every 250us */
469         wait_until \rd, r7, r9
470         cmp \rf, \rd /* Waited for 2ms, I2C transaction didn't happen. Exit */
471         beq 3f
472
473         ldr r9, [\re, #I2C_STATUS]
474         cmp r9, #0
475         bne 2b
476
477 3:
478         /* Disable the DVC-I2C Controller */
479         mov \rd, #(1 << 15)
480         str \rd, [\car, #CLK_RESET_CLK_ENB_H_CLR]
481 #endif
482 .endm
483
484 ENTRY(tegra3_lp1_reset)
485         /* the CPU and system bus are running from CLKM and executing from
486          * IRAM when this code is executed
487          * switch all SCLK/CCLK clocks to CLKM and set non STDBY clock source
488          * enable PLLP, PLLM, PLLC, and PLLX. */
489
490         /* If resuming from MC clock stop state then enable EMC clock
491          * other PLLs are not disabled */
492         ldr     r8, [r12, #RESET_DATA(MASK_MC_CLK)]
493         tst     r8, r11         @ if memory clock stopped
494         mov32   r2, TEGRA_PMC_BASE
495         beq     resume_lp1
496
497         /* If PLLM was enabled before entering MC clock stop state
498          * then enable it else continue enabling EMC clock */
499         mov32   r0, TEGRA_CLK_RESET_BASE
500         ldr     r1, pllm_state
501         tst     r1, #0
502         bne     enable_mc
503
504         pll_iddq_exit r1, r0, CLK_RESET_PLLM_MISC, CLK_RESET_PLLM_MISC_IDDQ
505
506         mov32   r7, TEGRA_TMRUS_BASE
507         ldr     r1, [r7]
508         add     r1, r1, #2
509         wait_until r1, r7, r3
510         /* enable PLLM via PMC */
511         ldr     r1, [r2, #PMC_PLLP_WB0_OVERRIDE]
512         orr     r1, r1, #(1<<12)
513         str     r1, [r2, #PMC_PLLP_WB0_OVERRIDE]
514
515         pll_enable r1, r0, CLK_RESET_PLLM_BASE, 0
516         pll_locked r1, r0, CLK_RESET_PLLM_BASE
517
518         mov32   r7, TEGRA_TMRUS_BASE
519         ldr     r1, [r7]
520         add     r1, r1, #LOCK_DELAY
521         wait_until r1, r7, r3
522
523 enable_mc:
524         mov32   r0, TEGRA_CLK_RESET_BASE
525         mov     r1, #(1 << 25)
526         str     r1, [r0, #CLK_RESET_CLK_ENB_H_SET]
527         b       emc_exit_selfrefresh
528
529 resume_lp1:
530         mov32   r0, TEGRA_CLK_RESET_BASE
531
532         ldr     r7, [r12, #RESET_DATA(SECURE_FW_PRESENT)]
533         cmp     r7, #1
534         beq     1f
535
536         /* secure code handles 32KHz to CLKM/OSC clock switch */
537         mov     r1, #(1<<28)
538         str     r1, [r0, #CLK_RESET_SCLK_BURST]
539         str     r1, [r0, #CLK_RESET_CCLK_BURST]
540         mov     r1, #0
541         str     r1, [r0, #CLK_RESET_SCLK_DIVIDER]
542         str     r1, [r0, #CLK_RESET_CCLK_DIVIDER]
543
544 1:
545 #if defined(CONFIG_ARCH_TEGRA_3x_SOC)
546         /* enable PLLM via PMC */
547         mov32   r2, TEGRA_PMC_BASE
548         ldr     r1, [r2, #PMC_PLLP_WB0_OVERRIDE]
549         orr     r1, r1, #(1<<12)
550         str     r1, [r2, #PMC_PLLP_WB0_OVERRIDE]
551
552         pll_enable r1, r0, CLK_RESET_PLLM_BASE, CLK_RESET_PLLM_MISC
553         pll_enable r1, r0, CLK_RESET_PLLC_BASE, CLK_RESET_PLLC_MISC
554         pll_enable r1, r0, CLK_RESET_PLLX_BASE, CLK_RESET_PLLX_MISC
555 #else
556         pll_iddq_exit r1, r0, CLK_RESET_PLLM_MISC, CLK_RESET_PLLM_MISC_IDDQ
557         pll_iddq_exit r1, r0, CLK_RESET_PLLC_MISC, CLK_RESET_PLLC_MISC_IDDQ
558         pll_iddq_exit r1, r0, CLK_RESET_PLLX_MISC3, CLK_RESET_PLLX_MISC3_IDDQ
559
560         mov32   r7, TEGRA_TMRUS_BASE
561         ldr     r1, [r7]
562         add     r1, r1, #2
563         wait_until r1, r7, r3
564
565         /* enable PLLM via PMC */
566         mov32   r2, TEGRA_PMC_BASE
567         ldr     r1, [r2, #PMC_PLLP_WB0_OVERRIDE]
568         orr     r1, r1, #(1<<12)
569         str     r1, [r2, #PMC_PLLP_WB0_OVERRIDE]
570
571         pll_enable r1, r0, CLK_RESET_PLLM_BASE, 0
572         pll_enable r1, r0, CLK_RESET_PLLC_BASE, 0
573         pll_enable r1, r0, CLK_RESET_PLLX_BASE, 0
574 #endif
575         pll_enable r1, r0, CLK_RESET_PLLP_BASE, CLK_RESET_PLLP_MISC
576
577         pll_locked r1, r0, CLK_RESET_PLLM_BASE
578         pll_locked r1, r0, CLK_RESET_PLLP_BASE
579         pll_locked r1, r0, CLK_RESET_PLLC_BASE
580         pll_locked r1, r0, CLK_RESET_PLLX_BASE
581
582 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
583         ldr     r1, [r0, #CLK_RESET_PLLP_BASE]
584         bic     r1, r1, #(1<<31)                /* disable PllP bypass */
585         str     r1, [r0, #CLK_RESET_PLLP_BASE]
586
587         mov     r1, #CLK_RESET_PLLP_RESHIFT_DEFAULT
588         str     r1, [r0, #CLK_RESET_PLLP_RESHIFT]
589 #endif
590
591         mov32   r7, TEGRA_TMRUS_BASE
592         ldr     r1, [r7]
593         add     r1, r1, #LOCK_DELAY
594         wait_until r1, r7, r3
595
596 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
597         /* re-enable cl_dvfs logic clock (if dfll running, it's in open loop) */
598         mov     r4, #(1 << 27)
599         str     r4, [r0, #CLK_RESET_CLK_ENB_W_SET]
600 #endif
601
602 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
603         /* re-enable cl_dvfs logic clock (if dfll running, it's in open loop) */
604         mov     r4, #(1 << 27)
605         str     r4, [r0, #CLK_RESET_CLK_ENB_W_SET]
606 #endif
607
608         /* Restore the Core voltage back to high */
609         set_voltage r1, r4, r3, r0, lp1_register_core_highvolt
610
611 #if defined(CONFIG_ARCH_TEGRA_3x_SOC) || \
612 defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
613         add     r5, pc, #tegra3_sdram_pad_save-(.+8)    @ r5 --> saved data
614 #endif
615 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
616         add     r5, pc, #tegra11_sdram_pad_save-(.+8)   @ r5 --> saved data
617 #endif
618
619         ldr     r4, [r5, #0x18]
620         str     r4, [r0, #CLK_RESET_CLK_SOURCE_MSELECT]
621
622         ldr     r4, [r5, #0x1C]
623         str     r4, [r0, #CLK_RESET_SCLK_BURST]
624 #if defined(CONFIG_ARCH_TEGRA_3x_SOC)
625         mov32   r4, ((1<<28) | (8))     @ burst policy is PLLX
626         str     r4, [r0, #CLK_RESET_CCLK_BURST]
627 #else
628         /* first restore PLLX div2 state, 2us delay, then CPU clock source */
629         ldr     r4, [r5, #0x20]
630         tst     r4, #CCLK_BURST_PLLX_DIV2_BYPASS_LP
631         ldr     r1, [r0, #CLK_RESET_CCLK_BURST]
632         biceq   r1, r1, #CCLK_BURST_PLLX_DIV2_BYPASS_LP
633         orrne   r1, r1, #CCLK_BURST_PLLX_DIV2_BYPASS_LP
634         str     r1, [r0, #CLK_RESET_CCLK_BURST]
635         ldr     r1, [r7]
636         add     r1, r1, #2
637         wait_until r1, r7, r3
638         str     r4, [r0, #CLK_RESET_CCLK_BURST]
639 #endif
640
641 #if defined (CONFIG_CACHE_L2X0)
642         /* power up L2 */
643         ldr     r0, [r2, #PMC_PWRGATE_STATUS]
644         tst     r0, #(1<<PMC_PWRGATE_PARTID_L2C)
645         bne     powerup_l2_done
646         movw    r0, #(1<<8) | PMC_PWRGATE_PARTID_L2C
647         str     r0, [r2, #PMC_PWRGATE_TOGGLE]
648 powerup_l2_wait:
649         ldr     r0, [r2, #PMC_PWRGATE_STATUS]
650         tst     r0, #(1<<PMC_PWRGATE_PARTID_L2C)
651         beq     powerup_l2_wait
652 powerup_l2_done:
653         mov     r0, #PMC_PWRGATE_PARTID_L2C
654         str     r0, [r2, #PMC_REMOVE_CLAMPING_CMD]
655 #endif
656
657 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
658
659         /* If we are waking up from LP1, unconditionally continue
660          * resume.
661          */
662         mov32   r4, TEGRA_PMC_BASE
663         ldr     r0, [r4, #PMC_LP_STATE_SCRATCH_REG]
664         mov     r0, r0, lsr #PMC_LP_STATE_BIT_OFFSET
665         and     r0, r0, #PMC_LP_STATE_BIT_MASK
666         cmp     r0, #PMC_LP_STATE_LP1BB
667         beq     self_refresh_skip
668 #endif
669
670 emc_exit_selfrefresh:
671 #if defined(CONFIG_ARCH_TEGRA_3x_SOC) || \
672 defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
673         mov32   r0, TEGRA_EMC_BASE              @ r0 reserved for emc base
674         add     r5, pc, #tegra3_sdram_pad_save-(.+8)    @ r5 --> saved data
675 #endif
676 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
677         mov32   r0, TEGRA_EMC0_BASE             @ r0 reserved for emc base
678         add     r5, pc, #tegra11_sdram_pad_save-(.+8)   @ r5 --> saved data
679 #endif
680
681 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
682         /* Take BGBIAS pads out of DPD */
683         mov32   r1, 0x40020000
684         str     r1, [r2, #PMC_IO_DPD3_REQ]
685
686 dram_exit_sr_wait4:
687         ldr     r1, [r2, #PMC_IO_DPD3_STATUS]
688         tst     r1, #(1 << 17)
689         bne     dram_exit_sr_wait4
690
691         /* Take VTTGEN pads out of DPD */
692         mov32   r1, 0x4CD00000
693         str     r1, [r2, #PMC_IO_DPD3_REQ]
694
695 dram_exit_sr_wait3:
696         ldr     r1, [r2, #PMC_IO_DPD3_STATUS]
697         tst     r1, #(1 << 20)
698         bne     dram_exit_sr_wait3
699
700         /* Take func pads out of dpd explicitly */
701         mov32   r1, 0x430DFFFF
702         str     r1, [r2, #PMC_IO_DPD3_REQ]
703
704 dram_exit_sr_wait2:
705         ldr     r1, [r2, #PMC_IO_DPD3_STATUS]
706         tst     r1, #(1 << 18)
707         bne     dram_exit_sr_wait2
708
709         mov32   r1, 0x40400000
710         str     r1, [r2, #PMC_IO_DPD_REQ]
711
712 dram_exit_sr_wait1:
713         ldr     r1, [r2, #PMC_IO_DPD_STATUS]
714         tst     r1, #(1 << 22)
715         bne     dram_exit_sr_wait1
716
717         ldr     r1, [r2, #PMC_POR_DPD_CTRL]
718         bic     r1, r1, #0x80000003
719         str     r1, [r2, #PMC_POR_DPD_CTRL]
720 #endif
721
722         ldr     r1, [r5, #0x14] @ PMC_IO_DPD_STATUS
723         mvn     r1, r1
724         bic     r1, r1, #(0x1<<31)
725         orr     r1, r1, #(0x1<<30)
726         str     r1, [r2, #PMC_IO_DPD_REQ]
727
728 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
729         ldr     r1, [r5, #0x24] @ PMC_IO_DPD3_STATUS
730         mvn     r1, r1
731         bic     r1, r1, #(0x1<<31)
732         orr     r1, r1, #(0x1<<30)
733         str     r1, [r2, #PMC_IO_DPD3_REQ]
734 #endif
735
736 exit_self_refresh:
737         ldr     r1, [r5, #0xC]
738         str     r1, [r0, #EMC_XM2VTTGENPADCTRL]
739         ldr     r1, [r5, #0x10]
740         str     r1, [r0, #EMC_XM2VTTGENPADCTRL2]
741         ldr     r1, [r5, #0x8]
742         str     r1, [r0, #EMC_AUTO_CAL_INTERVAL]
743
744         ldr     r1, [r0, #EMC_CFG_DIG_DLL]
745         orr     r1, r1, #(0x1<<30)              @ set DLL_RESET
746         str     r1, [r0, #EMC_CFG_DIG_DLL]
747
748         emc_timing_update r1, r0
749
750 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
751         mov32   r1, TEGRA_EMC1_BASE
752         cmp     r0, r1
753 #endif
754         ldr     r1, [r0, #EMC_AUTO_CAL_CONFIG]
755         orr     r1, r1, #(0x1<<31)              @ set AUTO_CAL_ACTIVE
756 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
757         orreq   r1, r1, #(0x1<<27)              @ set slave mode for channel 1
758 #endif
759         str     r1, [r0, #EMC_AUTO_CAL_CONFIG]
760
761 emc_wait_audo_cal_onetime:
762         ldr     r1, [r0, #EMC_AUTO_CAL_STATUS]
763         tst     r1, #(0x1<<31)          @ wait until AUTO_CAL_ACTIVE is clear
764         bne     emc_wait_audo_cal_onetime
765
766         ldr     r1, [r0, #EMC_CFG]
767         bic     r1, r1, #(1<<31)        @ disable DRAM_CLK_STOP
768         str     r1, [r0, #EMC_CFG]
769
770         mov     r1, #0
771         str     r1, [r0, #EMC_SELF_REF] @ take DRAM out of self refresh
772         mov     r1, #1
773 #if defined(CONFIG_ARCH_TEGRA_3x_SOC) || defined(CONFIG_ARCH_TEGRA_14x_SOC)
774         str     r1, [r0, #EMC_NOP]
775         str     r1, [r0, #EMC_NOP]
776 #endif
777 #if defined(CONFIG_ARCH_TEGRA_3x_SOC)
778         str     r1, [r0, #EMC_REFRESH]
779 #endif
780
781         emc_device_mask r1, r0
782
783 exit_selfrefresh_loop:
784         ldr     r2, [r0, #EMC_EMC_STATUS]
785         ands    r2, r2, r1
786         bne     exit_selfrefresh_loop
787
788         lsr     r1, r1, #8              @ devSel, bit0:dev0 bit1:dev1
789
790         mov32   r7, TEGRA_TMRUS_BASE
791         ldr     r2, [r0, #EMC_FBIO_CFG5]
792
793         and     r2, r2, #3
794         cmp     r2, #2
795         beq     emc_lpddr2
796
797         mov32   r2, 0x80000011
798         str     r2, [r0, #EMC_ZQ_CAL]
799         ldr     r2, [r7]
800         add     r2, r2, #10
801         wait_until r2, r7, r3
802
803         tst     r1, #2
804         beq zcal_done
805
806         mov32   r2, 0x40000011
807         str     r2, [r0, #EMC_ZQ_CAL]
808         ldr     r2, [r7]
809         add     r2, r2, #10
810         wait_until r2, r7, r3
811         b zcal_done
812
813 emc_lpddr2:
814
815         mov32   r2, 0x800A00AB
816         str     r2, [r0, #EMC_MRW]
817         ldr     r2, [r7]
818         add     r2, r2, #1
819         wait_until r2, r7, r3
820
821         tst     r1, #2
822         beq zcal_done
823
824         mov32   r2, 0x400A00AB
825         str     r2, [r0, #EMC_MRW]
826         ldr     r2, [r7]
827         add     r2, r2, #1
828         wait_until r2, r7, r3
829
830 zcal_done:
831
832         mov     r1, #0
833         str     r1, [r0, #EMC_REQ_CTRL]
834         ldr     r1, [r5, #0x4]
835         str     r1, [r0, #EMC_ZCAL_INTERVAL]
836         ldr     r1, [r5, #0x0]
837         str     r1, [r0, #EMC_CFG]
838
839         emc_timing_update r1, r0
840
841         ldr     r2, [r7]
842         add     r2, r2, #5
843         wait_until r2, r7, r3
844
845 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
846         mov32   r1, TEGRA_EMC1_BASE
847         cmp     r0, r1
848         movne   r0, r1
849         addne   r5, r5, #0x24
850         bne     exit_self_refresh
851 #endif
852
853 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
854         /* In the LP1 case, we need to set the Memory status from
855          * AP to BB, so that memory transactions can take place
856          */
857         mov32   r4, TEGRA_PMC_BASE
858         mov     r1, #PMC_IPC_SET_MEM_STS
859         str     r1, [r4, #PMC_IPC_SET]
860 self_refresh_skip:
861 #endif
862         mov32   r0, TEGRA_PMC_BASE
863         ldr     r0, [r0, #PMC_SCRATCH41]
864         mov     pc, r0
865 ENDPROC(tegra3_lp1_reset)
866
867 #if defined(CONFIG_ARCH_TEGRA_3x_SOC) || \
868 defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
869         .align  L1_CACHE_SHIFT
870         .type   tegra3_sdram_pad_save, %object
871 tegra3_sdram_pad_save:
872         .word   0
873         .word   0
874         .word   0
875         .word   0
876         .word   0
877         .word   0
878         .word   0
879         .word   0
880         .word   0
881         .word   0
882
883 tegra3_sdram_pad_address:
884         .word   TEGRA_EMC_BASE + EMC_CFG                                @0x0
885         .word   TEGRA_EMC_BASE + EMC_ZCAL_INTERVAL                      @0x4
886         .word   TEGRA_EMC_BASE + EMC_AUTO_CAL_INTERVAL                  @0x8
887         .word   TEGRA_EMC_BASE + EMC_XM2VTTGENPADCTRL                   @0xc
888         .word   TEGRA_EMC_BASE + EMC_XM2VTTGENPADCTRL2                  @0x10
889         .word   TEGRA_PMC_BASE + PMC_IO_DPD_STATUS                      @0x14
890         .word   TEGRA_CLK_RESET_BASE + CLK_RESET_CLK_SOURCE_MSELECT     @0x18
891         .word   TEGRA_CLK_RESET_BASE + CLK_RESET_SCLK_BURST             @0x1c
892         .word   TEGRA_CLK_RESET_BASE + CLK_RESET_CCLK_BURST             @0x20
893         .word   TEGRA_PMC_BASE + PMC_IO_DPD3_STATUS                     @0x24
894 #endif
895 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
896         .align  L1_CACHE_SHIFT
897         .type   tegra11_sdram_pad_save, %object
898 tegra11_sdram_pad_save:
899         .word   0
900         .word   0
901         .word   0
902         .word   0
903         .word   0
904         .word   0
905         .word   0
906         .word   0
907         .word   0
908         .word   0
909         .word   0
910         .word   0
911         .word   0
912         .word   0
913
914 tegra11_sdram_pad_address:
915         .word   TEGRA_EMC0_BASE + EMC_CFG                               @0x0
916         .word   TEGRA_EMC0_BASE + EMC_ZCAL_INTERVAL                     @0x4
917         .word   TEGRA_EMC0_BASE + EMC_AUTO_CAL_INTERVAL                 @0x8
918         .word   TEGRA_EMC0_BASE + EMC_XM2VTTGENPADCTRL                  @0xc
919         .word   TEGRA_EMC0_BASE + EMC_XM2VTTGENPADCTRL2                 @0x10
920         .word   TEGRA_PMC_BASE + PMC_IO_DPD_STATUS                      @0x14
921         .word   TEGRA_CLK_RESET_BASE + CLK_RESET_CLK_SOURCE_MSELECT     @0x18
922         .word   TEGRA_CLK_RESET_BASE + CLK_RESET_SCLK_BURST             @0x1c
923         .word   TEGRA_CLK_RESET_BASE + CLK_RESET_CCLK_BURST             @0x20
924         .word   TEGRA_EMC1_BASE + EMC_CFG                               @0x24
925         .word   TEGRA_EMC1_BASE + EMC_ZCAL_INTERVAL                     @0x28
926         .word   TEGRA_EMC1_BASE + EMC_AUTO_CAL_INTERVAL                 @0x2c
927         .word   TEGRA_EMC1_BASE + EMC_XM2VTTGENPADCTRL                  @0x30
928         .word   TEGRA_EMC1_BASE + EMC_XM2VTTGENPADCTRL2                 @0x34
929 #endif
930
931 #ifdef CONFIG_TEGRA_LP1_LOW_COREVOLTAGE
932         .globl lp1_register_pmuslave_addr
933         .globl lp1_register_i2c_base_addr
934         .globl lp1_register_core_lowvolt
935         .globl lp1_register_core_highvolt
936 lp1_register_pmuslave_addr:
937         .word   0
938 lp1_register_i2c_base_addr:
939         .word   0
940 lp1_register_core_lowvolt:
941         .word   0
942 lp1_register_core_highvolt:
943         .word   0
944 #endif
945
946 pllm_state:
947         .word   0
948
949 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
950 lp_enter_state:
951         .word   0
952 #endif
953
954 /* tegra3_tear_down_core
955  *
956  * LP0 entry check conditions w.r.t BB take place here
957  */
958 tegra3_tear_down_core:
959 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
960         /* Checking for BB-idle or Paging case */
961         ldr     r0, [r4, #PMC_IPC_STS]
962         tst     r0, #PMC_IPC_STS_MEM_REQ | PMC_IPC_STS_MEM_REQ_SOON
963         bne     lp1bb_entry
964
965         /* Write PMC_IPC_CLR[mem_sts] = 1 */
966         mov     r1, #PMC_IPC_CLR_MEM_STS
967         str     r1, [r4, #PMC_IPC_CLR]
968
969         /* Clear FLOW_IPC_STS[AP2BB_MSC_STS[0]] */
970         ldr     r1, [r6, #FLOW_IPC_STS]
971         bic     r1, #FLOW_IPC_STS_AP2BB_MSC_STS_0
972         str     r1, [r6, #FLOW_IPC_STS]
973
974         b       tegra3_lp0_tear_down_core
975
976 /* lp1bb_entry
977  * Set up mem_req active low to be a wake event.
978  * Configure the EVP reset vector.
979  * Set up LIC to accept pmc wake events as interrupts.
980  * Clear previously set warmboot and side_effect bits
981  * Invoke remaining LP routines.
982  */
983 lp1bb_entry:
984         bl      tegra148_lp1bb_clear_warmboot_flag
985         mov     r0, #PMC_LP_STATE_LP1BB
986         str     r0, lp_enter_state
987         bl      tegra148_set_lp_state
988         bl      tegra148_set_mem_req_interrupt
989         bl      tegra3_save_config
990         bl      tegra3_cpu_clk32k
991         b       tegra3_enter_sleep
992
993 /* Based on LP state being entered, sets mem_req=0
994  * or mem_req=1 as a wake interrupt
995  */
996 tegra148_set_mem_req_interrupt:
997         /* Clear the PMC_CTRL2_WAKE_DET_EN bit */
998         ldr     r0, [r4, #PMC_CTRL2]
999         bic     r0, r0, #PMC_CTRL2_WAKE_DET_EN
1000         str     r0, [r4, #PMC_CTRL2]
1001
1002         /* Program the wake_level2 registers */
1003         ldr     r0, [r4, #PMC_WAKE2_LEVEL]
1004         ldr     r1, lp_enter_state
1005         cmp     r1, #PMC_LP_STATE_LP1BB
1006         biceq   r0, r0, #PMC_WAKE2_BB_MEM_REQ
1007         orrne   r0, r0, #PMC_WAKE2_BB_MEM_REQ
1008         str     r0, [r4, #PMC_WAKE2_LEVEL]
1009
1010         /* Wait for 1ms for write to take effect */
1011         mov32   r7, TEGRA_TMRUS_BASE
1012         wait_for_us r1, r7, r9
1013         add r1, r1, #100
1014         wait_until r1, r7, r9
1015
1016         /* Program the auto_wake_lvl regsiters */
1017         ldr     r0, [r4, #PMC_AUTO_WAKE_LVL]
1018         orr     r0, r0, #1
1019         str     r0, [r4, #PMC_AUTO_WAKE_LVL]
1020
1021         /* Wait for 1ms for write to take effect */
1022         mov32   r7, TEGRA_TMRUS_BASE
1023         wait_for_us r1, r7, r9
1024         add r1, r1, #100
1025         wait_until r1, r7, r9
1026
1027         /* Configure mem_req active low to be wake event */
1028         ldr     r0, [r4, #PMC_WAKE2_MASK]
1029         orr     r0, r0, #PMC_WAKE2_BB_MEM_REQ
1030         str     r0, [r4, #PMC_WAKE2_MASK]
1031
1032         ldr     r0, [r4, #PMC_CTRL2]
1033         orr     r0, r0, #PMC_CTRL2_WAKE_DET_EN
1034         str     r0, [r4, #PMC_CTRL2]
1035
1036         /* Set up the LIC to accept pmc_wake events as interrupts */
1037         ldr     r8, =TEGRA_TERTIARY_ICTLR_BASE
1038         ldr     r0, =TRI_ICTLR_PMC_WAKE_INT
1039         str     r0, [r8, #TRI_ICTLR_CPU_IER_SET]
1040         mov     pc, lr
1041
1042 /*
1043  * tegra148_lp1bb_clear_warmboot_flag
1044  * Clears side effect bit in case it was set during
1045  * suspend entry. Also clears Warmboot0 flag.
1046  */
1047 tegra148_lp1bb_clear_warmboot_flag:
1048         ldr     r0, [r4, #PMC_SCRATCH0]
1049         bic     r0, r0, #1
1050         str     r0, [r4, #PMC_SCRATCH0]
1051         ldr     r0, [r4, #PMC_CTRL]
1052         bic     r0, r0, #PMC_CTRL_SIDE_EFFECT_LP0
1053         str     r0, [r4, #PMC_CTRL]
1054         mov     pc, lr
1055
1056 /* Based on value of lp_enter_state, update LP state
1057  * scratch register
1058  */
1059 tegra148_set_lp_state:
1060         ldr     r0, lp_enter_state
1061         mov     r0, r0, lsl #PMC_LP_STATE_BIT_OFFSET
1062         ldr     r1, [r4, #PMC_LP_STATE_SCRATCH_REG]
1063         mov     r2, #PMC_LP_STATE_BIT_MASK
1064         bic     r1, r2, lsl #PMC_LP_STATE_BIT_OFFSET
1065         orr     r1, r0
1066         str     r1, [r4, #PMC_LP_STATE_SCRATCH_REG]
1067         mov     pc, lr
1068
1069 /* tegra3_lp0_tear_down_core
1070  *
1071  * copied into and executed from IRAM
1072  * puts memory in self-refresh for LP0 and LP1
1073  */
1074 tegra3_lp0_tear_down_core:
1075         ldr     r0, [r4, #PMC_CTRL]
1076         tst     r0, #PMC_CTRL_SIDE_EFFECT_LP0
1077         moveq   r0, #PMC_LP_STATE_LP1
1078         movne   r0, #PMC_LP_STATE_LP0
1079         str     r0, lp_enter_state
1080         bleq    tegra148_set_mem_req_interrupt
1081         bl      tegra148_set_lp_state
1082 #endif
1083         bl      tegra3_save_config
1084         bl      tegra3_sdram_self_refresh
1085         bl      tegra3_cpu_clk32k
1086         b       tegra3_enter_sleep
1087
1088 tegra3_stop_mc_clk:
1089         bl      tegra3_save_config
1090         bl      tegra3_sdram_self_refresh
1091         mov     r1, #(1 << 25)
1092         str     r1, [r5, #CLK_RESET_CLK_ENB_H_CLR]
1093
1094         /* Store PLLM state
1095          * If PLLP_WB0_OVERRIDE(Bit 11) is set then store
1096          * value OVERRIDE_ENABLE(Bit 12) else store CAR value */
1097         ldr     r0, [r4, #PMC_PLLP_WB0_OVERRIDE]
1098         and     r1, r0, #(1 << 12)
1099         lsr     r1, #12
1100         and     r0, r0, #(1 << 11)
1101         lsr     r0, #11
1102         and     r1, r1, r0
1103
1104         ldr     r2, [r5, #CLK_RESET_PLLM_BASE]
1105         and     r2, r2, #(1 << 30)
1106         lsr     r2, #30
1107         bic     r2, r2, r0
1108
1109         orr     r1, r1, r2
1110
1111         str     r1, pllm_state
1112
1113         /* disable PLLM via PMC in LP1 */
1114         ldr     r0, [r4, #PMC_PLLP_WB0_OVERRIDE]
1115         bic     r0, r0, #(1 << 12)
1116         str     r0, [r4, #PMC_PLLP_WB0_OVERRIDE]
1117
1118         /* disable PLLM in CAR */
1119         ldr     r0, [r5, #CLK_RESET_PLLM_BASE]
1120         bic     r0, r0, #(1 << 30)
1121         str     r0, [r5, #CLK_RESET_PLLM_BASE]
1122
1123         b       tegra3_enter_sleep
1124
1125 /*
1126  * tegra3_cpu_clk32k
1127  *
1128  * In LP0 and LP1 all plls will be turned off.  Switch the system clock
1129  * to the 32khz clock (clks) and CPU to clkm.
1130  * r4 = TEGRA_PMC_BASE
1131  * r5 = TEGRA_CLK_RESET_BASE
1132  * r6 = TEGRA_FLOW_CTRL_BASE
1133  * r7 = TEGRA_TMRUS_BASE
1134  */
1135 tegra3_cpu_clk32k:
1136         ldr     r0, [r4, #PMC_CTRL]
1137         tst     r0, #PMC_CTRL_SIDE_EFFECT_LP0
1138         beq     lp1_clocks_prepare
1139
1140         /* enable PLLM auto-restart via PMC in LP0; restore override settings */
1141         ldr     r0, [r4, #PMC_SCRATCH2]
1142         str     r0, [r4, #PMC_PLLM_WB0_OVERRIDE]
1143         ldr     r0, [r4, #PMC_PLLP_WB0_OVERRIDE]
1144         orr     r0, r0, #((1 << 12) | (1 << 11))
1145         str     r0, [r4, #PMC_PLLP_WB0_OVERRIDE]
1146
1147 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
1148         ldr r1, [r4, #PMC_SCRATCH1_ECO]
1149         orr r1, r1, #0x3F
1150         str r1, [r4, #PMC_SCRATCH1_ECO]
1151 #endif
1152
1153 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
1154         ldr r1, [r4, #PMC_POR_DPD_CTRL]
1155         orr r1, r1, #0x47
1156         str r1, [r4, #PMC_POR_DPD_CTRL]
1157 #endif
1158
1159         mov     pc, lr
1160
1161 lp1_clocks_prepare:
1162         /* start by jumping to clkm to safely disable PLLs, then jump
1163          * to clks */
1164         mov     r0, #(1 << 28)
1165         str     r0, [r5, #CLK_RESET_SCLK_BURST]
1166         /* 2 us delay between changing sclk and cclk */
1167         wait_for_us r1, r7, r9
1168         add     r1, r1, #2
1169         wait_until r1, r7, r9
1170         mov     r0, #(1 << 28)
1171         str     r0, [r5, #CLK_RESET_CCLK_BURST]
1172         mov     r0, #0
1173         str     r0, [r5, #CLK_RESET_CCLK_DIVIDER]
1174         str     r0, [r5, #CLK_RESET_SCLK_DIVIDER]
1175
1176         /* switch the clock source for mselect to be CLK_M */
1177         ldr     r0, [r5, #CLK_RESET_CLK_SOURCE_MSELECT]
1178         orr     r0, r0, #MSELECT_CLKM
1179         str     r0, [r5, #CLK_RESET_CLK_SOURCE_MSELECT]
1180
1181         /* Lower the Core voltage through an i2c communication */
1182         set_voltage r0, r1, r3, r5, lp1_register_core_lowvolt
1183
1184 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1185         /* disable cl_dvfs logic clock (if dfll running, it's in open loop) */
1186         mov     r0, #(1 << 27)
1187         str     r0, [r5, #CLK_RESET_CLK_ENB_W_CLR]
1188 #endif
1189         /* 2 us delay between changing sclk and disabling PLLs */
1190         wait_for_us r1, r7, r9
1191         add     r1, r1, #2
1192         wait_until r1, r7, r9
1193
1194 #if !defined(CONFIG_ARCH_TEGRA_14x_SOC)
1195         /* disable PLLM via PMC in LP1 */
1196         ldr     r0, [r4, #PMC_PLLP_WB0_OVERRIDE]
1197         bic     r0, r0, #(1 << 12)
1198         str     r0, [r4, #PMC_PLLP_WB0_OVERRIDE]
1199 #endif
1200
1201         ldr     r11, [r4, #PMC_SCRATCH37]       @ load the LP1 flags
1202         tst     r11, #TEGRA_POWER_LP1_AUDIO     @ check if voice call is going on
1203 #if !defined(CONFIG_ARCH_TEGRA_14x_SOC)
1204         bne     powerdown_pll_cx                @ if yes, do not turn off pll-p/pll-a
1205 #else
1206         /*
1207          * BB needs PLLP and EMC on voice call/LP1BB. EMC may be clocked by
1208          * PLLC so we need to check the EMC source PLL to determine whether
1209          * PLLC can be turned OFF
1210          */
1211         bne     lp1bb_emc_source_check
1212         ldr     r0, lp_enter_state
1213         cmp     r0, #PMC_LP_STATE_LP1BB         @ check if we're entering LP1BB
1214         bne     powerdown_pll_pacx              @ if not, turn off plls p/a/c/x
1215 lp1bb_emc_source_check:
1216         /* find source pll of EMC */
1217         ldr     r0, [r5, #CLK_RESET_CLK_SOURCE_EMC]
1218         mov     r0, r0, lsr #0x1d
1219         cmp     r0, #0x1                        @ EMC clocked by PLLC_OUT0?
1220         beq     powerdown_pll_x                 @ if yes, just turn off pll-x
1221         cmp     r0, #0x7                        @ EMC clocked by PLLC_UD?
1222         beq     powerdown_pll_x                 @ if yes, just turn off pll-x
1223         b       powerdown_pll_cx                @ if not, turn off pll-c/pll-x
1224 #endif
1225 powerdown_pll_pacx:
1226         ldr     r0, [r6, #FLOW_CONTROL_CLUSTER_CONTROL]
1227         tst     r0, #1
1228         ldr     r0, [r5, #CLK_RESET_PLLP_BASE]
1229         bic     r0, r0, #(1<<30)
1230 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1231         orreq   r0, r0, #(1<<31)                @ enable PllP bypass on fast
1232 #endif
1233         str     r0, [r5, #CLK_RESET_PLLP_BASE]
1234 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1235         mov     r0, #CLK_RESET_PLLP_RESHIFT_ENABLE
1236         str     r0, [r5, #CLK_RESET_PLLP_RESHIFT]
1237 #endif
1238         ldr     r0, [r5, #CLK_RESET_PLLA_BASE]
1239         bic     r0, r0, #(1<<30)
1240         str     r0, [r5, #CLK_RESET_PLLA_BASE]
1241
1242 powerdown_pll_cx:
1243         ldr     r0, [r5, #CLK_RESET_PLLC_BASE]
1244         bic     r0, r0, #(1<<30)
1245         str     r0, [r5, #CLK_RESET_PLLC_BASE]
1246 powerdown_pll_x:
1247         ldr     r0, [r5, #CLK_RESET_PLLX_BASE]
1248         bic     r0, r0, #(1<<30)
1249         str     r0, [r5, #CLK_RESET_PLLX_BASE]
1250 #if !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1251         /*
1252          * FIXME: put PLLM/C into IDDQ (need additional testing)
1253          * pll_iddq_entry r1, r5, CLK_RESET_PLLM_MISC, CLK_RESET_PLLM_MISC_IDDQ
1254          * pll_iddq_entry r1, r5, CLK_RESET_PLLC_MISC, CLK_RESET_PLLC_MISC_IDDQ
1255          */
1256         pll_iddq_entry r1, r5, CLK_RESET_PLLX_MISC3, CLK_RESET_PLLX_MISC3_IDDQ
1257 #endif
1258
1259         /*
1260          * Switch to STDBY clock (CLKS), bits 28:31 == 0
1261          * Enable burst on CPU IRQ (bit 24)
1262          * Set clock sources to CLKM (clock source 0)
1263          */
1264         mov     r0, #(1 << 24)
1265         str     r0, [r5, #CLK_RESET_SCLK_BURST]
1266         mov     pc, lr
1267
1268 /*
1269  * tegra3_enter_sleep
1270  *
1271  * uses flow controller to enter sleep state
1272  * executes from IRAM with SDRAM in selfrefresh when target state is LP0 or LP1
1273  * executes from SDRAM with target state is LP2
1274  * r4 = TEGRA_PMC_BASE
1275  * r5 = TEGRA_CLK_RESET_BASE
1276  * r6 = TEGRA_FLOW_CTRL_BASE
1277  * r7 = TEGRA_TMRUS_BASE
1278  */
1279 tegra3_enter_sleep:
1280         ldr     r1, [r7]
1281         str     r1, [r4, #PMC_SCRATCH38]
1282         dsb
1283         cpu_id  r1
1284
1285         cpu_to_csr_reg  r2, r1
1286         ldr     r0, [r6, r2]
1287         orr     r0, r0, #FLOW_CTRL_CSR_INTR_FLAG | FLOW_CTRL_CSR_EVENT_FLAG
1288         orr     r0, r0, #FLOW_CTRL_CSR_ENABLE
1289         str     r0, [r6, r2]
1290
1291 #if defined(CONFIG_ARCH_TEGRA_11x_SOC) || defined(CONFIG_ARCH_TEGRA_14x_SOC) \
1292         || defined(CONFIG_ARCH_TEGRA_12x_SOC)
1293         tst     r0, #FLOW_CTRL_IMMEDIATE_WAKE
1294         movne   r0, #FLOW_CTRL_WAITEVENT
1295         moveq   r0, #FLOW_CTRL_WAIT_FOR_INTERRUPT
1296         orr     r0, r0, #FLOW_CTRL_HALT_LIC_IRQ | FLOW_CTRL_HALT_LIC_FIQ
1297 #else
1298         mov     r0, #FLOW_CTRL_WAIT_FOR_INTERRUPT
1299         orr     r0, r0, #FLOW_CTRL_HALT_CPU_IRQ | FLOW_CTRL_HALT_CPU_FIQ
1300 #endif
1301         cpu_to_halt_reg r2, r1
1302         str     r0, [r6, r2]
1303         dsb
1304         ldr     r0, [r6, r2] /* memory barrier */
1305
1306 #ifndef CONFIG_ARM_SAVE_DEBUG_CONTEXT_NO_LOCK
1307         /* Set the Debug OS Double Lock for Debug Arch v7.1 or greater.
1308            With this lock set, the debugger is completely locked out.
1309            Disable this to debug WFI/powergating failures.
1310         */
1311         mrc     p15, 0, r3, c0, c1, 2   @ ID_DFR0
1312         and     r3, r3, #0xF            @ coprocessor debug model
1313         cmp     r3, #5                  @ debug arch >= v7.1?
1314
1315         mov32   r1, 0xC5ACCE55
1316         mcrge   p14, 0, r1, c1, c3, 4   @ DBGOSDLR
1317 #endif
1318 halted:
1319         isb
1320         dsb
1321         wfi     /* CPU should be power gated here */
1322
1323         /* !!!FIXME!!! Implement halt failure handler */
1324         b       halted
1325
1326 /*
1327  * tegra3_sdram_self_refresh
1328  *
1329  * called with MMU off and caches disabled
1330  * puts sdram in self refresh
1331  * must execute from IRAM
1332  * r4 = TEGRA_PMC_BASE
1333  * r5 = TEGRA_CLK_RESET_BASE
1334  * r6 = TEGRA_FLOW_CTRL_BASE
1335  * r7 = TEGRA_TMRUS_BASE
1336  */
1337
1338 tegra3_save_config:
1339
1340 #if defined(CONFIG_ARCH_TEGRA_3x_SOC) || \
1341 defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
1342         adr     r2, tegra3_sdram_pad_address
1343         adr     r8, tegra3_sdram_pad_save
1344 #endif
1345 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
1346         adr     r2, tegra11_sdram_pad_address
1347         adr     r8, tegra11_sdram_pad_save
1348 #endif
1349         mov     r9, r2
1350
1351 padsave:
1352         ldr     r0, [r2], #4                    @ r0 is emc register address
1353
1354         ldr     r1, [r0]
1355         str     r1, [r8], #4                    @ save emc register
1356
1357         cmp     r8, r9
1358         bne     padsave
1359 padsave_done:
1360
1361         dsb
1362         mov     pc, lr
1363
1364 tegra3_sdram_self_refresh:
1365 #if defined(CONFIG_ARCH_TEGRA_3x_SOC) || \
1366 defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
1367         mov32   r0, TEGRA_EMC_BASE              @ r0 reserved for emc base
1368 #endif
1369 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
1370         mov32   r0, TEGRA_EMC0_BASE             @ r0 reserved for emc base
1371 #endif
1372 enter_self_refresh:
1373 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
1374         /* Enable SEL_DPD */
1375         ldr     r1, [r0, #EMC_SEL_DPD_CTRL]
1376         orr     r1, r1, #0xF
1377         orr     r1, r1, #0xF0
1378         orr     r1, r1, #0x100
1379         str     r1, [r0, #EMC_SEL_DPD_CTRL]
1380 #endif
1381         mov     r1, #0
1382         str     r1, [r0, #EMC_ZCAL_INTERVAL]
1383         str     r1, [r0, #EMC_AUTO_CAL_INTERVAL]
1384         ldr     r1, [r0, #EMC_CFG]
1385         bic     r1, r1, #(1<<28)
1386 #if defined(CONFIG_ARCH_TEGRA_11x_SOC) || \
1387 defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
1388         bic     r1, r1, #(1<<29)
1389 #endif
1390         str     r1, [r0, #EMC_CFG]              @ disable DYN_SELF_REF
1391
1392         emc_timing_update r1, r0
1393
1394         ldr     r1, [r7]
1395         add     r1, r1, #5
1396         wait_until r1, r7, r2
1397
1398 emc_wait_audo_cal:
1399         ldr     r1, [r0, #EMC_AUTO_CAL_STATUS]
1400         tst     r1, #(0x1<<31)          @ wait until AUTO_CAL_ACTIVE is clear
1401         bne     emc_wait_audo_cal
1402
1403         mov     r1, #3
1404         str     r1, [r0, #EMC_REQ_CTRL]         @ stall incoming DRAM requests
1405
1406 emcidle:
1407         ldr     r1, [r0, #EMC_EMC_STATUS]
1408         tst     r1, #4
1409         beq     emcidle
1410
1411         mov     r1, #1
1412         str     r1, [r0, #EMC_SELF_REF]
1413
1414         emc_device_mask r1, r0
1415
1416 emcself:
1417         ldr     r2, [r0, #EMC_EMC_STATUS]
1418         and     r2, r2, r1
1419         cmp     r2, r1
1420         bne     emcself                         @ loop until DDR in self-refresh
1421
1422         ldr     r1, [r0, #EMC_XM2VTTGENPADCTRL]
1423         mov32   r2, 0xF8F8FFFF          @ clear XM2VTTGEN_DRVUP and XM2VTTGEN_DRVDN
1424         and     r1, r1, r2
1425         str     r1, [r0, #EMC_XM2VTTGENPADCTRL]
1426         ldr     r1, [r0, #EMC_XM2VTTGENPADCTRL2]
1427 #if defined(CONFIG_ARCH_TEGRA_3x_SOC)
1428         orr     r1, r1, #7                      @ set E_NO_VTTGEN
1429 #endif
1430 #if defined(CONFIG_ARCH_TEGRA_11x_SOC) || \
1431 defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
1432         orr     r1, r1, #0x3f                   @ set E_NO_VTTGEN
1433 #endif
1434         str     r1, [r0, #EMC_XM2VTTGENPADCTRL2]
1435
1436         emc_timing_update r1, r0
1437
1438 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
1439         mov32   r1, TEGRA_EMC1_BASE
1440         cmp     r0, r1
1441         movne   r0, r1
1442         bne     enter_self_refresh
1443 #endif
1444
1445         ldr     r1, [r4, #PMC_CTRL]
1446         tst     r1, #PMC_CTRL_SIDE_EFFECT_LP0
1447         bne     pmc_io_dpd_skip
1448
1449 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
1450         ldr     r1, [r4, #PMC_POR_DPD_CTRL]
1451         orr     r1, r1, #0x80000003
1452         str     r1, [r4, #PMC_POR_DPD_CTRL]
1453 #endif
1454
1455 #if !defined(CONFIG_ARCH_TEGRA_12x_SOC)
1456         mov32   r1, 0x8EC00000
1457         str     r1, [r4, #PMC_IO_DPD_REQ]
1458 #endif
1459 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
1460         /* Put func pads in dpd explicitly */
1461         mov32   r1, 0x80400000
1462         str     r1, [r4, #PMC_IO_DPD_REQ]
1463
1464 dram_sr_wait1:
1465         ldr     r1, [r4, #PMC_IO_DPD_STATUS]
1466         tst     r1, #(1 << 22)
1467         beq     dram_sr_wait1
1468
1469         mov32   r1, 0x830DFFFF
1470         str     r1, [r4, #PMC_IO_DPD3_REQ]
1471
1472 dram_sr_wait2:
1473         ldr     r1, [r4, #PMC_IO_DPD3_STATUS]
1474         tst     r1, #(1 << 18)
1475         beq     dram_sr_wait2
1476
1477         /* Put VTTGEN pads in DPD */
1478         mov32   r1, 0x8CD00000
1479         str     r1, [r4, #PMC_IO_DPD3_REQ]
1480
1481 dram_sr_wait3:
1482         ldr     r1, [r4, #PMC_IO_DPD3_STATUS]
1483         tst     r1, #(1 << 20)
1484         beq     dram_sr_wait3
1485
1486         /* Put BGBIAS pads in DPD */
1487         mov32   r1, 0x80020000
1488         str     r1, [r4, #PMC_IO_DPD3_REQ]
1489
1490 dram_sr_wait4:
1491         ldr     r1, [r4, #PMC_IO_DPD3_STATUS]
1492         tst     r1, #(1 << 17)
1493         beq     dram_sr_wait4
1494
1495 #endif
1496         dsb
1497         mov     pc, lr
1498
1499 pmc_io_dpd_skip:
1500 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
1501         /*
1502          * Make sure the BGBIAS pads are not in DPD so that when the system
1503          * comes out of LP0 at max EMC frequency we can read memory.
1504          */
1505         ldr     r1, =PMC_IO_DPD2_REQ_CODE_DPD_OFF
1506         orr     r1, r1, #PMC_IO_DPD2_REQ_DISC_BIAS
1507         str     r1, [r4, #PMC_IO_DPD2_REQ]
1508 #endif
1509         dsb
1510         mov     pc, lr
1511
1512         .ltorg
1513 /* dummy symbol for end of IRAM */
1514         .align L1_CACHE_SHIFT
1515         .globl tegra3_iram_end
1516 tegra3_iram_end:
1517         b       .
1518 #endif