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