ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[linux-3.10.git] / arch / arm / mach-tegra / sleep-t20.S
1 /*
2  * Copyright (c) 2010-2012, NVIDIA Corporation. All rights reserved.
3  * Copyright (c) 2011, Google, Inc.
4  *
5  * Author: Colin Cross <ccross@android.com>
6  *         Gary King <gking@nvidia.com>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms and conditions of the GNU General Public License,
10  * version 2, as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <linux/const.h>
22 #include <linux/init.h>
23 #include <linux/linkage.h>
24
25 #include <asm/assembler.h>
26 #include <asm/cache.h>
27 #include <asm/domain.h>
28 #include <asm/memory.h>
29 #include <asm/page.h>
30 #include <asm/ptrace.h>
31 #include <asm/asm-offsets.h>
32 #include <asm/glue-cache.h>
33 #include <asm/glue-proc.h>
34
35 #include "sleep.h"
36 #include "flowctrl.h"
37
38 #define EMC_CFG                         0xc
39 #define EMC_ADR_CFG                     0x10
40 #define EMC_REFRESH                     0x70
41 #define EMC_NOP                         0xdc
42 #define EMC_SELF_REF                    0xe0
43 #define EMC_REQ_CTRL                    0x2b0
44 #define EMC_EMC_STATUS                  0x2b4
45
46 #define CLK_RESET_CCLK_BURST            0x20
47 #define CLK_RESET_CCLK_DIVIDER          0x24
48 #define CLK_RESET_SCLK_BURST            0x28
49 #define CLK_RESET_SCLK_DIVIDER          0x2c
50
51 #define CLK_RESET_PLLC_BASE             0x80
52 #define CLK_RESET_PLLM_BASE             0x90
53 #define CLK_RESET_PLLP_BASE             0xa0
54 #define CLK_RESET_PLLP_OUTA             0xa4
55 #define CLK_RESET_PLLP_OUTB             0xa8
56 #define CLK_RESET_PLLP_MISC             0xac
57 #define CLK_RESET_PLLX_BASE             0xe0
58 #define CLK_RESET_PLLX_MISC             0xe4
59
60 #define CLK_RESET_RST_CPU_CMPLX_SET     0x340
61
62 #if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_PM_SLEEP)
63 /*
64  * tegra20_hotplug_shutdown(void)
65  *
66  * puts the current cpu in reset
67  * should never return
68  */
69 ENTRY(tegra20_hotplug_shutdown)
70         mov     r6, lr
71         bl      tegra_cpu_exit_coherency
72
73         /* Put this CPU down */
74         cpu_id  r0
75         bl      tegra20_cpu_shutdown
76         mov     pc, r6                  @ should never get here
77 ENDPROC(tegra20_hotplug_shutdown)
78 #endif
79
80 #if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_PM_SLEEP)
81 /*
82  * tegra20_cpu_shutdown(int cpu)
83  *
84  * r0 is cpu to reset
85  *
86  * puts the specified CPU in wait-for-event mode on the flow controller
87  * and puts the CPU in reset
88  * can be called on the current cpu or another cpu
89  * if called on the current cpu, does not return
90  * MUST NOT BE CALLED FOR CPU 0.
91  *
92  * corrupts r0-r3, r12
93  */
94 ENTRY(tegra20_cpu_shutdown)
95         cmp     r0, #0
96         moveq   pc, lr                  @ must not be called for CPU 0
97
98         mov32   r1, TEGRA_PMC_VIRT + PMC_SCRATCH41
99         mov     r12, #CPU_RESETTABLE
100         str     r12, [r1]
101
102         cpu_to_halt_reg r1, r0
103         mov32   r3, TEGRA_FLOW_CTRL_VIRT
104         mov     r2, #FLOW_CTRL_WAITEVENT | FLOW_CTRL_JTAG_RESUME
105         str     r2, [r3, r1]            @ put flow controller in wait event mode
106         ldr     r2, [r3, r1]
107         isb
108         dsb
109         movw    r1, 0x1011
110         mov     r1, r1, lsl r0
111         mov32   r3, TEGRA_CLK_RESET_VIRT
112         str     r1, [r3, #CLK_RESET_RST_CPU_CMPLX_SET]  @ put slave CPU in reset
113         isb
114         dsb
115         cpu_id  r3
116         cmp     r3, r0
117         beq     .
118         mov     pc, lr
119 ENDPROC(tegra20_cpu_shutdown)
120 #endif
121
122 #ifdef CONFIG_PM_SLEEP
123 /*
124  * tegra2_cpu_clear_resettable(void)
125  *
126  * Called to clear the "resettable soon" flag in PMC_SCRATCH41 when
127  * it is expected that the secondary CPU will be idle soon.
128  */
129 ENTRY(tegra2_cpu_clear_resettable)
130         mov32   r1, TEGRA_PMC_VIRT + PMC_SCRATCH41
131         mov     r12, #CPU_NOT_RESETTABLE
132         str     r12, [r1]
133         mov     pc, lr
134 ENDPROC(tegra2_cpu_clear_resettable)
135
136 /*
137  * tegra2_cpu_set_resettable_soon(void)
138  *
139  * Called to set the "resettable soon" flag in PMC_SCRATCH41 when
140  * it is expected that the secondary CPU will be idle soon.
141  */
142 ENTRY(tegra2_cpu_set_resettable_soon)
143         mov32   r1, TEGRA_PMC_VIRT + PMC_SCRATCH41
144         mov     r12, #CPU_RESETTABLE_SOON
145         str     r12, [r1]
146         mov     pc, lr
147 ENDPROC(tegra2_cpu_set_resettable_soon)
148
149 /*
150  * tegra2_cpu_is_resettable_soon(void)
151  *
152  * Returns true if the "resettable soon" flag in PMC_SCRATCH41 has been
153  * set because it is expected that the secondary CPU will be idle soon.
154  */
155 ENTRY(tegra2_cpu_is_resettable_soon)
156         mov32   r1, TEGRA_PMC_VIRT + PMC_SCRATCH41
157         ldr     r12, [r1]
158         cmp     r12, #CPU_RESETTABLE_SOON
159         moveq   r0, #1
160         movne   r0, #0
161         mov     pc, lr
162 ENDPROC(tegra2_cpu_is_resettable_soon)
163
164 /*
165  * tegra2_sleep_core(unsigned long v2p)
166  *
167  * enters suspend in LP0 or LP1 by turning off the mmu and jumping to
168  * tegra2_tear_down_core in IRAM
169  */
170 ENTRY(tegra2_sleep_core_finish)
171         mov     r4, r0
172         bl      tegra_flush_cache
173         mov     r0, r4
174         bl      tegra_cpu_exit_coherency
175         mov32   r1, tegra2_tear_down_core
176         mov32   r2, tegra2_iram_start
177         sub     r1, r1, r2
178         mov32   r2, TEGRA_IRAM_CODE_AREA
179         add     r1, r1, r2
180         mov     r11, #0
181         b       tegra_turn_off_mmu
182 ENDPROC(tegra2_sleep_core_finish)
183
184 /*
185  * tegra2_sleep_cpu_secondary_finish(unsigned long v2p)
186  *
187  * Enters WFI on secondary CPU by exiting coherency.
188  */
189 ENTRY(tegra2_finish_sleep_cpu_secondary)
190         mrc     p15, 0, r11, c1, c0, 1  @ save actlr before exiting coherency
191
192         dsb
193         bl      tegra_flush_l1_cache
194
195         bl      tegra_cpu_exit_coherency
196
197         mov32   r0, TEGRA_PMC_VIRT + PMC_SCRATCH41
198         mov     r3, #CPU_RESETTABLE
199         str     r3, [r0]
200
201         bl      cpu_do_idle
202
203         /*
204          * cpu may be reset while in wfi, which will return through
205          * tegra_resume to tegra_cpu_resume_phys to tegra_cpu_resume
206          * or interrupt may wake wfi, which will return here
207          * cpu state is unchanged - MMU is on, cache is on, coherency
208          * is off, and the data cache is off
209          *
210          * r11 contains the original actlr
211          */
212         bl      tegra_pen_lock
213
214         mov32   r3, TEGRA_PMC_VIRT
215         add     r0, r3, #PMC_SCRATCH41
216         mov     r3, #CPU_NOT_RESETTABLE
217         str     r3, [r0]
218
219         bl      tegra_pen_unlock
220
221         mcr     p15, 0, r11, c1, c0, 1  @ reenable coherency
222
223         /* Invalidate the TLBs & BTAC */
224         mov     r1, #0
225         mcr     p15, 0, r1, c8, c3, 0   @ invalidate shared TLBs
226         mcr     p15, 0, r1, c7, c1, 6   @ invalidate shared BTAC
227         dsb
228         isb
229
230         @ the cpu was running with coherency disabled, caches may be out of date
231 #ifdef MULTI_CACHE
232         mov32   r10, cpu_cache
233         mov     lr, pc
234         ldr     pc, [r10, #CACHE_FLUSH_KERN_ALL]
235 #else
236         bl      __cpuc_flush_kern_all
237 #endif
238
239         ldmia   sp!, {r1 - r3}          @ pop phys pgd, virt SP, phys resume fn
240         mov     r0, #0                  @ return success
241         mov     sp, r2                  @ sp is stored in r2 by __cpu_suspend
242         ldmfd   sp!, {r4 - r11, pc}
243 ENDPROC(tegra2_finish_sleep_cpu_secondary)
244
245 /*
246  * tegra2_tear_down_cpu
247  *
248  * Switches the CPU cluster to PLL-P and enters sleep.
249  */
250 ENTRY(tegra2_tear_down_cpu)
251         bl      tegra_cpu_pllp
252         b       tegra2_enter_sleep
253 ENDPROC(tegra2_tear_down_cpu)
254
255 /* START OF ROUTINES COPIED TO IRAM */
256         .align L1_CACHE_SHIFT
257         .globl tegra2_iram_start
258 tegra2_iram_start:
259
260 /*
261  * tegra2_lp1_reset
262  *
263  * reset vector for LP1 restore; copied into IRAM during suspend.
264  * brings the system back up to a safe starting point (SDRAM out of
265  * self-refresh, PLLC, PLLM and PLLP reenabled, CPU running on PLLP,
266  * system clock running on the same PLL that it suspended at), and
267  * jumps to tegra_lp2_startup to restore PLLX and virtual addressing.
268  * physical address of tegra_lp2_startup expected to be stored in
269  * PMC_SCRATCH41
270  *
271  * NOTE: THIS *MUST* BE RELOCATED TO TEGRA_IRAM_CODE_AREA AND MUST BE FIRST.
272  */
273 ENTRY(tegra2_lp1_reset)
274         /*
275          * the CPU and system bus are running at 32KHz and executing from
276          * IRAM when this code is executed; immediately switch to CLKM and
277          * enable PLLP.
278          */
279         mov32   r0, TEGRA_CLK_RESET_BASE
280 #if !defined(CONFIG_TEGRA_USE_SECURE_KERNEL)
281         /* secure code handles 32KHz to CLKM/OSC clock switch */
282         mov     r1, #(1 << 28)
283         str     r1, [r0, #CLK_RESET_SCLK_BURST]
284         str     r1, [r0, #CLK_RESET_CCLK_BURST]
285         mov     r1, #0
286         str     r1, [r0, #CLK_RESET_SCLK_DIVIDER]
287         str     r1, [r0, #CLK_RESET_CCLK_DIVIDER]
288 #endif
289         ldr     r1, [r0, #CLK_RESET_PLLM_BASE]
290         tst     r1, #(1 << 30)
291         orreq   r1, r1, #(1 << 30)
292         streq   r1, [r0, #CLK_RESET_PLLM_BASE]
293         ldr     r1, [r0, #CLK_RESET_PLLP_BASE]
294         tst     r1, #(1 << 30)
295         orreq   r1, r1, #(1 << 30)
296         streq   r1, [r0, #CLK_RESET_PLLP_BASE]
297         ldr     r1, [r0, #CLK_RESET_PLLC_BASE]
298         tst     r1, #(1 << 30)
299         orreq   r1, r1, #(1 << 30)
300         streq   r1, [r0, #CLK_RESET_PLLC_BASE]
301
302         adr     r2, tegra2_sdram_pad_address
303         adr     r4, tegra2_sdram_pad_save
304         mov     r5, #0
305
306 padload:
307         ldr     r0, [r2, r5]            @ r0 is emc register address
308
309         ldr     r1, [r4, r5]
310         str     r1, [r0]                @ set emc register to safe vals
311
312         add     r5, r5, #4
313         ldr     r0, tegra2_sdram_pad_size
314         cmp     r0, r5
315         bne     padload
316
317 padload_done:
318         mov32   r7, TEGRA_TMRUS_BASE
319         ldr     r1, [r7]
320         add     r1, r1, #0xff           @ 255uS delay for PLL stabilization
321
322 1:      ldr     r0, [r7]
323         cmp     r0, r1
324         dmb
325         bmi     1b
326
327         adr     r4, tegra2_sclk_save
328         ldr     r4, [r4]
329         mov32   r0, TEGRA_CLK_RESET_BASE
330         str     r4, [r0, #CLK_RESET_SCLK_BURST]
331         ldr     r4, =((1 << 28) | (4))  @ burst policy is PLLP
332         str     r4, [r0, #CLK_RESET_CCLK_BURST]
333
334         mov32   r0, TEGRA_EMC_BASE
335         ldr     r1, [r0, #EMC_CFG]
336         bic     r1, r1, #(1 << 31)      @ disable DRAM_CLK_STOP
337         str     r1, [r0, #EMC_CFG]
338
339         mov     r1, #0
340         str     r1, [r0, #EMC_SELF_REF] @ take DRAM out of self refresh
341         mov     r1, #1
342         str     r1, [r0, #EMC_NOP]
343         str     r1, [r0, #EMC_NOP]
344         str     r1, [r0, #EMC_REFRESH]
345
346         ldr     r1, [r0, #EMC_ADR_CFG]
347         tst     r1, #(0x3 << 24)
348         moveq   r1, #(0x1 << 8)         @ just 1 device
349         movne   r1, #(0x3 << 8)         @ 2 devices
350
351 exit_selfrefresh_loop:
352         ldr     r2, [r0, #EMC_EMC_STATUS]
353         ands    r2, r2, r1
354         bne     exit_selfrefresh_loop
355
356         mov     r1, #0
357         str     r1, [r0, #EMC_REQ_CTRL]
358
359         ldr     r0, =TEGRA_PMC_BASE
360         ldr     r0, [r0, #PMC_SCRATCH41]
361         mov     pc, r0
362 ENDPROC(tegra2_lp1_reset)
363
364 /*
365  * tegra2_tear_down_core
366  *
367  * copied into and executed from IRAM
368  * puts memory in self-refresh for LP0 and LP1
369  */
370 tegra2_tear_down_core:
371         bl      tegra2_sdram_self_refresh
372         bl      tegra2_cpu_clk32k
373         b       tegra2_enter_sleep
374
375 /*
376  * tegra2_cpu_clk32k
377  *
378  * In LP0 and LP1 all plls will be turned off.  Switch the CPU and system clock
379  * to the 32khz clock (clks)
380  */
381 tegra2_cpu_clk32k:
382         /* start by jumping to clkm to safely disable PLLs, then jump
383          * to clks */
384         mov     r0, #(1 << 28)
385         str     r0, [r5, #CLK_RESET_SCLK_BURST]
386         str     r0, [r5, #CLK_RESET_CCLK_BURST]
387         mov     r0, #0
388         str     r0, [r5, #CLK_RESET_CCLK_DIVIDER]
389         str     r0, [r5, #CLK_RESET_SCLK_DIVIDER]
390
391         /* 2 us delay between changing sclk and disabling PLLs */
392         mov32   r7, TEGRA_TMRUS_BASE
393         ldr     r1, [r7]
394         add     r1, r1, #3
395
396 1:      ldr     r0, [r7]
397         cmp     r0, r1
398         dmb
399         bmi     1b
400
401         /* switch to CLKS */
402         mov     r0, #0  /* burst policy = 32KHz */
403         str     r0, [r5, #CLK_RESET_SCLK_BURST]
404
405         /* disable PLLP, PLLM, PLLC in LP0 and LP1 states */
406         ldr     r0, [r5, #CLK_RESET_PLLM_BASE]
407         bic     r0, r0, #(1 << 30)
408         str     r0, [r5, #CLK_RESET_PLLM_BASE]
409         ldr     r0, [r5, #CLK_RESET_PLLP_BASE]
410         bic     r0, r0, #(1 << 30)
411         str     r0, [r5, #CLK_RESET_PLLP_BASE]
412         ldr     r0, [r5, #CLK_RESET_PLLC_BASE]
413         bic     r0, r0, #(1 << 30)
414         str     r0, [r5, #CLK_RESET_PLLC_BASE]
415         mov     pc, lr
416
417 /*
418  * tegra2_enter_sleep
419  *
420  * uses flow controller to enter sleep state
421  * executes from IRAM with SDRAM in selfrefresh when target state is LP0 and LP1
422  * executes from SDRAM with target state is LP2
423  */
424 tegra2_enter_sleep:
425         mov32   r7, TEGRA_TMRUS_BASE
426         ldr     r1, [r7]
427         mov32   r4, TEGRA_PMC_BASE
428         str     r1, [r4, #PMC_SCRATCH38]
429         dsb
430         mov32   r6, TEGRA_FLOW_CTRL_BASE
431
432         mov     r0, #FLOW_CTRL_WAIT_FOR_INTERRUPT
433         orr     r0, r0, #FLOW_CTRL_HALT_CPU_IRQ | FLOW_CTRL_HALT_CPU_FIQ
434         cpu_id  r1
435         cpu_to_halt_reg r1, r1
436         str     r0, [r6, r1]
437         dsb
438         ldr     r0, [r6, r1] /* memory barrier */
439
440 halted: dsb
441         wfe     /* CPU should be power gated here */
442         isb
443         b       halted
444
445 /*
446  * tegra2_sdram_self_refresh
447  *
448  * called with MMU off and caches disabled
449  * puts sdram in self refresh
450  * must execute from IRAM
451  */
452 tegra2_sdram_self_refresh:
453         mov32   r1, TEGRA_EMC_BASE
454         mov     r2, #3
455         str     r2, [r1, #EMC_REQ_CTRL]         @ stall incoming DRAM requests
456
457 emcidle:ldr     r2, [r1, #EMC_EMC_STATUS]
458         tst     r2, #4
459         beq     emcidle
460
461         mov     r2, #1
462         str     r2, [r1, #EMC_SELF_REF]
463
464         ldr     r2, [r1, #EMC_ADR_CFG]
465         tst     r2, #(0x3 << 24)
466         moveq   r2, #(0x1 << 8)                 @ just 1 device
467         movne   r2, #(0x3 << 8)                 @ 2 devices
468
469 emcself:ldr     r3, [r1, #EMC_EMC_STATUS]
470         and     r3, r3, r2
471         cmp     r3, r2
472         bne     emcself                         @ loop until DDR in self-refresh
473
474         adr     r2, tegra2_sdram_pad_address
475         adr     r3, tegra2_sdram_pad_safe
476         adr     r4, tegra2_sdram_pad_save
477         mov     r5, #0
478
479 padsave:
480         ldr     r0, [r2, r5]                    @ r0 is emc register address
481
482         ldr     r1, [r0]
483         str     r1, [r4, r5]                    @ save emc register
484
485         ldr     r1, [r3, r5]
486         str     r1, [r0]                        @ set emc register to safe vals
487
488         add     r5, r5, #4
489         ldr     r0, tegra2_sdram_pad_size
490         cmp     r0, r5
491         bne     padsave
492 padsave_done:
493
494         mov32   r5, TEGRA_CLK_RESET_BASE
495         ldr     r0, [r5, #CLK_RESET_SCLK_BURST]
496         adr     r2, tegra2_sclk_save
497         str     r0, [r2]
498         dsb
499         mov     pc, lr
500
501 tegra2_sdram_pad_address:
502         .word   TEGRA_APB_MISC_BASE + 0x8c8 /* XM2CFGCPADCTRL */
503         .word   TEGRA_APB_MISC_BASE + 0x8cc /* XM2CFGDPADCTRL */
504         .word   TEGRA_APB_MISC_BASE + 0x8d0 /* XM2CLKCFGPADCTRL */
505         .word   TEGRA_APB_MISC_BASE + 0x8d4 /* XM2COMPPADCTRL */
506         .word   TEGRA_APB_MISC_BASE + 0x8d8 /* XM2VTTGENPADCTRL */
507         .word   TEGRA_APB_MISC_BASE + 0x8e4 /* XM2CFGCPADCTRL2 */
508         .word   TEGRA_APB_MISC_BASE + 0x8e8 /* XM2CFGDPADCTRL2 */
509
510 tegra2_sdram_pad_size:
511         .word   tegra2_sdram_pad_size - tegra2_sdram_pad_address
512
513 tegra2_sdram_pad_safe:
514         .word   0x8
515         .word   0x8
516         .word   0x0
517         .word   0x8
518         .word   0x5500
519         .word   0x08080040
520         .word   0x0
521
522 tegra2_sclk_save:
523         .word   0x0
524
525 tegra2_sdram_pad_save:
526         .word   0
527         .word   0
528         .word   0
529         .word   0
530         .word   0
531         .word   0
532         .word   0
533
534         .ltorg
535 /* dummy symbol for end of IRAM */
536         .align L1_CACHE_SHIFT
537         .globl tegra2_iram_end
538 tegra2_iram_end:
539         b       .
540 #endif