ARM: Tegra: Add CONFIG_TEGRA_USE_SECURE_KERNEL
[linux-3.10.git] / arch / arm / mach-tegra / headsmp.S
1 /*
2  * arch/arm/mach-tegra/headsmp.S
3  *
4  * CPU initialization routines for Tegra SoCs
5  *
6  * Copyright (c) 2009-2013, NVIDIA CORPORATION.  All rights reserved.
7  * Copyright (c) 2011 Google, Inc.
8  * Author: Colin Cross <ccross@android.com>
9  *         Gary King <gking@nvidia.com>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License.
14  *
15  * This program is distributed in the hope that it will be useful, but WITHOUT
16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
18  * more details.
19  */
20
21 #include <linux/linkage.h>
22 #include <linux/init.h>
23
24 #include <asm/assembler.h>
25 #include <asm/cache.h>
26 #include <asm/page.h>
27 #include <asm/hardware/cache-l2x0.h>
28
29 #include "flowctrl.h"
30 #include "iomap.h"
31 #include "sleep.h"
32 #include "reset.h"
33
34 #define APB_MISC_GP_HIDREV      0x804
35 #define PMC_SCRATCH41   0x140
36
37 #define DEBUG_CPU_RESET_HANDLER 0       /* Non-zero enables debug code */
38
39 #define RESET_DATA_PHYS (TEGRA_RESET_HANDLER_BASE \
40         + __tegra_cpu_reset_handler_data - __tegra_cpu_reset_handler_start)
41
42 #ifdef CONFIG_SMP
43 /*
44  *      tegra_secondary_startup
45  *
46  *       Initial secondary processor boot vector; jumps to kernel's
47  *       secondary_startup routine. Used for initial boot and hotplug
48  *       of secondary CPUs.
49  */
50         __CPUINIT
51 ENTRY(tegra_secondary_startup)
52         bl      __invalidate_cpu_state
53
54         /* enable user space perf counter access */
55         /* only accessible in secure state       */
56         mrc     p15, 0, r0, c9, c12, 0
57         lsr     r0, #11
58         and     r0, r0, #0x1f
59         mov     r1, #1
60         lsl     r1, r1, r0
61         sub     r1, r1, #1
62         movt    r1, #0x8000
63         mcr     p15, 0, r1, c9, c14, 2
64         mov     r0, #1
65         mcr     p15, 0, r0, c9, c14, 0
66
67         b       secondary_startup
68 ENDPROC(tegra_secondary_startup)
69 #endif
70
71         .section ".text.head", "ax"
72 #ifdef CONFIG_PM_SLEEP
73 /*
74  *      tegra_resume
75  *
76  *        CPU boot vector when restarting the a CPU following
77  *        an LP2 transition. Also branched to by LP0 and LP1 resume after
78  *        re-enabling sdram.
79  */
80 ENTRY(tegra_resume)
81 #ifdef CONFIG_TEGRA_USE_SECURE_KERNEL
82         mov32   r1, TEGRA_TMRUS_BASE
83         ldr     r0, [r1]
84         adr     r1, tegra_resume_entry_time
85         str     r0, [r1]
86 #endif
87
88         bl      __invalidate_cpu_state
89
90         cpu_id  r0
91 #ifndef CONFIG_TEGRA_VIRTUAL_CPUID
92         cmp     r0, #0                          @ CPU0?
93         bne     cpu_resume                      @ no
94 #endif
95
96 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
97         @ Clear the flow controller flags for this CPU.
98         cpu_to_csr_reg  r1, r0
99         mov32   r2, TEGRA_FLOW_CTRL_BASE
100         ldr     r1, [r2, r1]
101         orr     r1, r1, #(1 << 15) | (1 << 14)  @ write to clear event & intr
102         movw    r0, #0x3FFD     @ enable, enable_ext, cluster_switch, immed, & bitmaps
103         bic     r1, r1, r0
104         str     r1, [r2]
105 #endif /* !CONFIG_ARCH_TEGRA_2x_SOC */
106
107 #if defined(CONFIG_HAVE_ARM_SCU)
108         /* enable SCU */
109         mov32   r0, TEGRA_ARM_PERIF_BASE
110         ldr     r1, [r0]
111         orr     r1, r1, #1
112 #ifdef CONFIG_ARCH_TEGRA_14x_SOC
113         orr     r1, r1, #8
114 #endif
115         str     r1, [r0]
116 #endif /* CONFIG_HAVE_ARM_SCU */
117
118 #ifdef CONFIG_TEGRA_USE_SECURE_KERNEL
119 #ifndef CONFIG_ARCH_TEGRA_11x_SOC
120         mov32   r1, TEGRA_TMRUS_BASE
121         ldr     r0, [r1]
122         adr     r1, tegra_resume_smc_entry_time
123         str     r0, [r1]
124
125         /* wake up */
126         mov     r0, #0x00000003
127         bl      tegra_generic_smc
128
129         mov32   r1, TEGRA_TMRUS_BASE
130         ldr     r0, [r1]
131         adr     r1, tegra_resume_smc_exit_time
132         str     r0, [r1]
133 #endif /* !CONFIG_ARCH_TEGRA_11x_SOC */
134 #endif /* CONFIG_TEGRA_USE_SECURE_KERNEL */
135
136 #ifdef CONFIG_CACHE_L2X0
137 #if !defined(CONFIG_TEGRA_USE_SECURE_KERNEL) && \
138                 !defined(CONFIG_ARCH_TEGRA_14x_SOC)
139         adr     r0, tegra_resume_l2_init
140         ldr     r1, [r0]
141         tst     r1, #1
142         beq     no_l2_init
143         /* Enable L2 */
144         bic     r1, #1
145         str     r1, [r0]
146         mov32   r3, TEGRA_ARM_PL310_BASE
147 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
148         mov32   r0, 0x331                       /* tag latency */
149         mov32   r1, 0x441                       /* data latency */
150 #elif defined(CONFIG_ARCH_TEGRA_3x_SOC) || defined(CONFIG_ARCH_TEGRA_14x_SOC)
151 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
152         mov32   r0, TEGRA_FLOW_CTRL_BASE + 0x2c /* FLOW_CTRL_CLUSTER_CONTROL */
153         mov32   r2, RESET_DATA_PHYS
154         ldr     r1, [r0]
155         tst     r1, #1                          /* 0 == G, 1 == LP */
156         ldrne   r0, [r2, #RESET_DATA(C1_L2_TAG_LATENCY)]
157         ldrne   r1, [r2, #RESET_DATA(C1_L2_DATA_LATENCY)]
158         ldreq   r0, [r2, #RESET_DATA(C0_L2_TAG_LATENCY)]
159         ldreq   r1, [r2, #RESET_DATA(C0_L2_DATA_LATENCY)]
160 #else /* !CONFIG_TEGRA_SILICON_PLATFORM */
161         mov32   r0, #0x770                      /* tag latency */
162         mov32   r1, #0x770                      /* data latency */
163 #endif /* ?CONFIG_TEGRA_SILICON_PLATFORM */
164 #endif /* CONFIG_ARCH_TEGRA_3x_SOC || CONFIG_ARCH_TEGRA_14x_SOC */
165         str     r0, [r3, #L2X0_TAG_LATENCY_CTRL]
166         str     r1, [r3, #L2X0_DATA_LATENCY_CTRL]
167 #ifndef CONFIG_TEGRA_FPGA_PLATFORM
168 #ifdef CONFIG_ARCH_TEGRA_14x_SOC
169         mov32   r0, 0x40000007  /* Enable double line fill */
170 #else
171         mov     r0, #7
172 #endif
173         str     r0, [r3, #L2X0_PREFETCH_CTRL]
174 #endif /* !CONFIG_TEGRA_FPGA_PLATFORM */
175         mov     r0, #3
176         str     r0, [r3, #L2X0_POWER_CTRL]
177         /* figure out aux ctrl */
178         ldr     r2, [r3, #L2X0_CACHE_TYPE]
179         and     r2, r2, #0x700
180         lsl     r2, r2, #(17-8)
181         mov32   r4, 0x7C400001
182         orr     r2, r2, r4
183         ldr     r4, [r3, #L2X0_AUX_CTRL]
184         mov32   r5, 0x8200c3fe
185         and     r4, r4, r5
186         orr     r2, r2, r4
187         str     r2, [r3, #L2X0_AUX_CTRL]
188         mov     r2, #1
189         str     r2, [r3, #L2X0_CTRL]
190 #endif /* ?CONFIG_TEGRA_USE_SECURE_KERNEL */
191 #endif /* CONFIG_CACHE_L2X0 */
192 no_l2_init:
193         b       cpu_resume
194 ENDPROC(tegra_resume)
195
196 #ifdef CONFIG_TEGRA_USE_SECURE_KERNEL
197         .globl tegra_resume_timestamps_start
198 #ifndef CONFIG_ARCH_TEGRA_11x_SOC
199         .globl tegra_resume_smc_entry_time
200         .globl tegra_resume_smc_exit_time
201 #endif /* !CONFIG_ARCH_TEGRA_11x_SOC */
202         .globl tegra_resume_entry_time
203         .globl tegra_resume_timestamps_end
204 tegra_resume_timestamps_start:
205 #ifndef CONFIG_ARCH_TEGRA_11x_SOC
206 tegra_resume_smc_entry_time:
207         .long   0
208 tegra_resume_smc_exit_time:
209         .long   0
210 #endif /* !CONFIG_ARCH_TEGRA_11x_SOC */
211 tegra_resume_entry_time:
212         .long   0
213 tegra_resume_timestamps_end:
214 #endif /* CONFIG_TEGRA_USE_SECURE_KERNEL */
215 #ifdef CONFIG_CACHE_L2X0
216         .globl tegra_resume_l2_init
217 tegra_resume_l2_init:
218         .long 0
219 #endif /* CONFIG_CACHE_L2X0 */
220 #endif /* CONFIG_PM_SLEEP */
221
222 /*
223  *      __invalidate_cpu_state
224  *
225  *        Invalidates volatile CPU state (SCU tags, caches, branch address
226  *        arrays, exclusive monitor, etc.) so that they can be safely
227  *        enabled. Instruction caching and branch prediction are enabled.
228  *
229  *        Cortex-A15 has an integrated SCU in L2 memory system, we only
230  *        need to set the correct L2 cache data RAM latency and enable
231  *        i-cache/branch prediction.
232  */
233 __invalidate_cpu_state:
234         clrex
235         mov     r0, #0
236         mcr     p15, 0, r0, c1, c0, 1   @ disable SMP, prefetch, broadcast
237         isb
238         mrc     p15, 0, r0, c0, c0, 0   @ main ID register
239         ubfx    r1, r0, #4, #28
240         ldr     r0, =0x00f0000
241         bic     r1, r1, r0
242         ldr     r0, =0x410fc09
243         teq     r1, r0
244         beq     cortex_a9
245
246         mrc     p15, 0x1, r0, c15, c0, 3        @ L2 prefetch control reg
247         tst     r0, #0x1000
248         orreq   r0, r0, #0x1000                 @ disable throttling
249         mcreq   p15, 0x1, r0, c15, c0, 3
250
251         /*      This is only needed for cluster 0 with integrated L2 cache */
252         mrc     p15, 0, r0, c0, c0, 5
253         ubfx    r0, r0, #8, #4
254         tst     r0, #1
255         bne     __enable_i_cache_branch_pred
256         mrc     p15, 0x1, r0, c9, c0, 2
257         and     r1, r0, #7
258         cmp     r1, #2
259         beq     __enable_i_cache_branch_pred
260         bic     r0, r0, #7
261         orr     r0, r0, #2
262         mcr     p15, 0x1, r0, c9, c0, 2
263         mrc     p15, 0x1, r0, c15, c0, 0        @ L2 ACTLR
264         orr     r0, r0, #0x80                   @ hazard detection timeout
265         mcr     p15, 0x1, r0, c15, c0, 0
266 __enable_i_cache_branch_pred:
267         mov     r0, #0x1800
268         mcr     p15, 0, r0, c1, c0, 0   @ enable branch prediction, i-cache
269         mov     pc, lr
270         /* no fall through, just return to the caller */
271
272 cortex_a9:
273         /* Following is for Cortex-A9 */
274         mcr     p15, 0, r0, c7, c5, 0   @ invalidate BTAC, i-cache
275         mcr     p15, 0, r0, c7, c5, 6   @ invalidate branch pred array
276         mcr     p15, 0, r0, c8, c5, 0   @ invalidate instruction TLB
277         mcr     p15, 0, r0, c8, c6, 0   @ invalidate data TLB
278         mcr     p15, 0, r0, c8, c7, 0   @ invalidate unified TLB
279         dsb
280         isb
281
282 #if defined(CONFIG_HAVE_ARM_SCU)
283         cpu_id  r0
284         cmp     r0, #0
285         mov32   r1, (TEGRA_ARM_PERIF_BASE + 0xC)
286         movne   r0, r0, lsl #2
287         movne   r2, #0xf
288         movne   r2, r2, lsl r0
289         strne   r2, [r1]                @ invalidate SCU tags for CPU
290 #endif
291
292         dsb
293         mov     r0, #0x1800
294         mcr     p15, 0, r0, c1, c0, 0   @ enable branch prediction, i-cache
295         isb
296
297         /* Invalidates L1 d-cache during initial cpu boot (corrupt r0-r6) */
298
299         mov     r0, #0
300         mcr     p15, 2, r0, c0, c0, 0
301         mrc     p15, 1, r0, c0, c0, 0
302
303         movw    r1, #0x7fff
304         and     r2, r1, r0, lsr #13
305
306         movw    r1, #0x3ff
307
308         and     r3, r1, r0, lsr #3      @ NumWays - 1
309         add     r2, r2, #1      @ NumSets
310
311         and     r0, r0, #0x7
312         add     r0, r0, #4      @ SetShift
313
314         clz     r1, r3          @ WayShift
315         add     r4, r3, #1      @ NumWays
316 1:      sub     r2, r2, #1      @ NumSets--
317         mov     r3, r4          @ Temp = NumWays
318 2:      subs    r3, r3, #1      @ Temp--
319         mov     r5, r3, lsl r1
320         mov     r6, r2, lsl r0
321         orr     r5, r5, r6      @ Reg = (Temp<<WayShift)|(NumSets<<SetShift)
322         mcr     p15, 0, r5, c7, c6, 2
323         bgt     2b
324         cmp     r2, #0
325         bgt     1b
326         dsb
327         isb
328         mov     pc, lr
329
330 /*
331  * __tegra_cpu_reset_handler_halt_failed:
332  *
333  * Alternate entry point for reset handler for cases where the
334  * WFI halt failed to take effect.
335  *
336  */
337         .align L1_CACHE_SHIFT
338 ENTRY(__tegra_cpu_reset_handler_start)
339
340 /*
341  * __tegra_cpu_reset_handler:
342  *
343  * Common handler for all CPU reset events.
344  *
345  * Register usage within the reset handler:
346  *
347  *      R7  = CPU present (to the OS) mask
348  *      R8  = CPU in LP1 state mask
349  *      R9  = CPU in LP2 state mask
350  *      R10 = CPU number
351  *      R11 = CPU mask
352  *      R12 = pointer to reset handler data
353  *
354  * NOTE: This code is copied to IRAM. All code and data accesses
355  *       must be position-independent.
356  */
357
358         .align L1_CACHE_SHIFT
359 ENTRY(__tegra_cpu_reset_handler)
360
361 /* DO NOT put any code before the !defined(CONFIG_ARM_SAVE_DEBUG_CONTEXT)
362    block below. It must be the first thing in this subroutine. */
363
364 #if !defined(CONFIG_ARM_SAVE_DEBUG_CONTEXT) || DEBUG_CPU_RESET_HANDLER
365         /* If Debug Architecture v7.1 or later, unlock the OS lock. */
366         mrc     p15, 0, r0, c0, c1, 2           @ ID_DFR0
367         and     r0, r0, #0xF                    @ coprocessor debug model
368         cmp     r0, #5                          @ debug arch >= v7.1?
369         movge   r0, #0                          @ yes, unlock debug
370         mcrge   p14, 0, r0, c1, c0, 4           @ DBGOSLAR
371 #endif
372 #if DEBUG_CPU_RESET_HANDLER
373         b       .
374 #endif
375 #ifndef CONFIG_TEGRA_USE_SECURE_KERNEL
376         cpsid   aif, 0x13                       @ SVC mode, interrupts disabled
377         mrc     p15, 0, r0, c0, c0, 0           @ read main ID register
378         and     r5, r0, #0x00f00000             @ variant
379         and     r6, r0, #0x0000000f             @ revision
380         orr     r6, r6, r5, lsr #20-4           @ combine variant and revision
381 #ifdef CONFIG_ARM_ERRATA_743622
382         teq     r6, #0x20                       @ present in r2p0
383         teqne   r6, #0x21                       @ present in r2p1
384         teqne   r6, #0x22                       @ present in r2p2
385         teqne   r6, #0x27                       @ present in r2p7
386         teqne   r6, #0x29                       @ present in r2p9
387         mrceq   p15, 0, r10, c15, c0, 1         @ read diagnostic register
388         orreq   r10, r10, #1 << 6               @ set bit #6
389         mcreq   p15, 0, r10, c15, c0, 1         @ write diagnostic register
390 #endif
391 #endif
392         mrc     p15, 0, r10, c0, c0, 5          @ MPIDR
393         and     r10, r10, #0x3                  @ R10 = CPU number
394         mov     r11, #1
395         mov     r11, r11, lsl r10               @ R11 = CPU mask
396         adr     r12, __tegra_cpu_reset_handler_data
397
398 #ifdef CONFIG_SMP
399         /* Does the OS know about this CPU? */
400         ldr     r7, [r12, #RESET_DATA(MASK_PRESENT)]
401         tst     r7, r11                         @ if !present
402         bleq    __die                           @ CPU not present (to OS)
403 #endif
404
405 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
406         /* If CPU1, don't let CPU0 reset CPU1 now that CPU1 is coming up. */
407         mov32   r6, TEGRA_PMC_BASE
408         mov     r0, #0
409         cmp     r10, #0
410         strne   r0, [r6, #PMC_SCRATCH41]
411 #endif
412
413 #ifdef CONFIG_PM_SLEEP
414         /* Waking up from LP1? */
415         ldr     r8, [r12, #RESET_DATA(MASK_LP1)]
416         tst     r8, r11                         @ if in_lp1
417         beq     __is_not_lp1
418         cmp     r10, #0
419         bne     __die                           @ only CPU0 can be here
420         ldr     lr, [r12, #RESET_DATA(STARTUP_LP1)]
421         cmp     lr, #0
422         bleq    __die                           @ no LP1 startup handler
423         bx      lr
424 __is_not_lp1:
425 #endif
426
427         /* Waking up from LP2? */
428         ldr     r9, [r12, #RESET_DATA(MASK_LP2)]
429         tst     r9, r11                         @ if in_lp2
430         beq     __is_not_lp2
431         ldr     lr, [r12, #RESET_DATA(STARTUP_LP2)]
432         cmp     lr, #0
433         bleq    __die                           @ no LP2 startup handler
434         bx      lr
435
436 __is_not_lp2:
437
438 #ifdef CONFIG_SMP
439 #ifndef CONFIG_TEGRA_VIRTUAL_CPUID
440         /* Can only be secondary boot (initial or hotplug) but CPU 0
441            cannot be here. */
442         cmp     r10, #0
443         bleq    __die                           @ CPU0 cannot be here
444 #endif
445         ldr     lr, [r12, #RESET_DATA(STARTUP_SECONDARY)]
446         cmp     lr, #0
447         bleq    __die                           @ no secondary startup handler
448         bx      lr
449 #endif
450
451 /*
452  * We don't know why the CPU reset. Just kill it.
453  * The LR register will contain the address we died at + 4.
454  */
455
456 __die:
457         sub     lr, lr, #4
458         mov32   r7, TEGRA_PMC_BASE
459         str     lr, [r7, #PMC_SCRATCH41]
460
461         mov32   r7, TEGRA_CLK_RESET_BASE
462
463         /* Are we on Tegra20? */
464         mov32   r6, TEGRA_APB_MISC_BASE
465         ldr     r0, [r6, #APB_MISC_GP_HIDREV]
466         and     r0, r0, #0xff00
467         cmp     r0, #(0x20 << 8)
468         bne     1f
469
470 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
471         mov32   r0, 0x1111
472         mov     r1, r0, lsl r10
473         str     r1, [r7, #0x340]                @ CLK_RST_CPU_CMPLX_SET
474 #endif
475 1:
476 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
477         mov32   r6, TEGRA_FLOW_CTRL_BASE
478
479         cmp     r10, #0
480         moveq   r1, #FLOW_CTRL_HALT_CPU0_EVENTS
481         moveq   r2, #FLOW_CTRL_CPU0_CSR
482         movne   r1, r10, lsl #3
483         addne   r2, r1, #(FLOW_CTRL_CPU1_CSR-8)
484         addne   r1, r1, #(FLOW_CTRL_HALT_CPU1_EVENTS-8)
485
486         /* Clear CPU "event" and "interrupt" flags and power gate
487            it when halting but not before it is in the "WFI" state. */
488         ldr     r0, [r6, +r2]
489         orr     r0, r0, #FLOW_CTRL_CSR_INTR_FLAG | FLOW_CTRL_CSR_EVENT_FLAG
490         orr     r0, r0, #FLOW_CTRL_CSR_ENABLE
491         str     r0, [r6, +r2]
492
493         /* Unconditionally halt this CPU */
494         mov     r0, #FLOW_CTRL_WAITEVENT
495         str     r0, [r6, +r1]
496         ldr     r0, [r6, +r1]                   @ memory barrier
497
498         dsb
499         isb
500         wfi                                     @ CPU should be power gated here
501
502         /* If the CPU didn't power gate above just kill it's clock. */
503
504         mov     r0, r11, lsl #8
505         str     r0, [r7, #348]                  @ CLK_CPU_CMPLX_SET
506 #endif
507
508         /* If the CPU still isn't dead, just spin here. */
509         b       .
510 ENDPROC(__tegra_cpu_reset_handler)
511
512         .align L1_CACHE_SHIFT
513         .type   __tegra_cpu_reset_handler_data, %object
514         .globl  __tegra_cpu_reset_handler_data
515 __tegra_cpu_reset_handler_data:
516         .rept   TEGRA_RESET_DATA_SIZE
517         .long   0
518         .endr
519         .size   __tegra_cpu_reset_handler_data, \
520         . - __tegra_cpu_reset_handler_data
521         .align L1_CACHE_SHIFT
522 ENTRY(__tegra_cpu_reset_handler_end)
523
524         .globl  __tegra_cpu_reset_handler_data_offset
525         .equ    __tegra_cpu_reset_handler_data_offset, \
526         __tegra_cpu_reset_handler_data - __tegra_cpu_reset_handler_start