/*
 * Copyright (c) 2008, Google Inc.
 * All rights reserved.
 * Copyright (c) 2009-2010, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the 
 *    distribution.
 *  * Neither the name of Google, Inc. nor the names of its contributors
 *    may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */


/* TODO:
 * - style cleanup
 * - do we need to do *all* of this at boot?
 */

.text
.code 32

#define DSB .byte 0x4f, 0xf0, 0x7f, 0xf5
#define ISB .byte 0x6f, 0xf0, 0x7f, 0xf5

/*
 ; LVT Ring Osc counter
 ; used to determine sense amp settings
 ; Clobbers registers r0, r4, r5, r6, r7, r9, r10, r11
*/
.equ CLK_CTL_BASE,     0xA8600000
.equ A_GLBL_CLK_ENA,   0x0000
.equ A_PRPH_WEB_NS_REG,0x0080
.equ A_MSM_CLK_RINGOSC,0x00D0
.equ A_TCXO_CNT,       0x00D4
.equ A_TCXO_CNT_DONE,  0x00D8
.equ A_RINGOSC_CNT,    0x00DC
.equ A_MISC_CLK_CTL,   0x0108
.equ CLK_TEST,         0xA8600114       
.equ SPSS_CSR_BASE,    0xAC100000 
.equ A_SCRINGOSC,      0x0510

//;; Number of TCXO cycles to count ring oscillations
.equ TCXO_CNT_VAL,     0x100

//; Halcyon addresses
.equ TCSR_CONF_FUSE_1, 0xAB600060 //; TCSR_CONF_FUSE_1 register
.equ TCSR_CONF_FUSE_4, 0xAB60006C //; TCSR_CONF_FUSE_4 register

//; SCORPION_L1_ACC (1:0) Fuses bit location
.equ L1_ACC_BIT_0,     12       //;12th bit of TCSR_CONF_FUSE_4
.equ L1_ACC_BIT_1,     13       //;13th bit of TCSR_CONF_FUSE_4
//; SCORPION_L2_ACC (2:0) Fuses bit location
.equ L2_ACC_BIT_0,     25       //;25th bit of TCSR_CONF_FUSE_1
.equ L2_ACC_BIT_1,     10       //;10th bit of TCSR_CONF_FUSE_4
.equ L2_ACC_BIT_2,     11       //;11th bit of TCSR_CONF_FUSE_4

//; CP15: PVR2F0 values according to  SCORPION_L1_ACC (1:0)
.equ PVR2F0_00,        0x00000000
.equ PVR2F0_01,        0x04000000
.equ PVR2F0_10,        0x08000000
.equ PVR2F0_11,        0x0C000000

//; CP15: PVR2F1 values according to  SCORPION_L1_ACC (1:0)
.equ PVR2F1_00,        0x00000008
.equ PVR2F1_01,        0x00000008
.equ PVR2F1_10,        0x00000208
.equ PVR2F1_11,        0x00000208

//; CP15: PVR0F2 values according to  SCORPION_L1_ACC (1:0)
.equ PVR0F2_00,        0x00000000
.equ PVR0F2_01,        0x00000000
.equ PVR0F2_10,        0x00000200
.equ PVR0F2_11,        0x00000200

//; CP15: PVR0F0 values according to  SCORPION_L1_ACC (1:0)
.equ PVR0F0_00,        0x7F000000
.equ PVR0F0_01,        0x7F000400
.equ PVR0F0_10,        0x7F000000
.equ PVR0F0_11,        0x7F000400

//; CP15: L2VR3F1 values according to  SCORPION_L2_ACC (2:0)
.equ L2VR3F1_000,      0x00FFFF60
.equ L2VR3F1_001,      0x00FFFF40
.equ L2VR3F1_010,      0x00FFFC60
.equ L2VR3F1_011,      0x00FFFC40
.equ L2VR3F1_100,      0x00FCFF60
.equ L2VR3F1_101,      0x00FCFF40
.equ L2VR3F1_110,      0x00FCFC60
.equ L2VR3F1_111,      0x00FCFC40

.globl SET_SA
SET_SA:

        //;--------------------------------------------------------------------
        //; Fuse bits used to determine sense amp settings
        //;--------------------------------------------------------------------

        //; Reading L1_ACC
        LDR     r4, = 0x0

        //; Read L1_ACC_BIT_0
        LDR     r1, =TCSR_CONF_FUSE_4
        LDR     r2, =L1_ACC_BIT_0
        LDR     r3, [r1]
        MOV     r3, r3, LSR r2
        AND     r3, r3, #1
        ORR     r4, r3, r4

        //; Read L1_ACC_BIT_1
        LDR     r1, =TCSR_CONF_FUSE_4
        LDR     r2, =L1_ACC_BIT_1
        LDR     r3, [r1]
        MOV     r3, r3, LSR r2
        AND     r3, r3, #1
        MOV     r3, r3, LSL #1
        ORR     r4, r3, r4

l1_ck_0:
        //; if L1_[1:0] == 00
        LDR     r5, = 0x0
        CMP     r4, r5
        BNE     l1_ck_1
        LDR     r0, =PVR0F0_00
        LDR     r1, =PVR0F2_00
        LDR     r2, =PVR2F0_00
        LDR     r3, =PVR2F1_00
        B       WRITE_L1_SA_SETTINGS

l1_ck_1:
        //; if L1_[1:0] == 01
        LDR     r1, = 0x01
        CMP     r4, r1
        BNE     l1_ck_2
        LDR     r0, =PVR0F0_01
        LDR     r1, =PVR0F2_01
        LDR     r2, =PVR2F0_01
        LDR     r3, =PVR2F1_01
        B       WRITE_L1_SA_SETTINGS

l1_ck_2:
        //; if L1_[2:0] == 10
        LDR     r1, = 0x02
        CMP     r4, r1
        BNE     l1_ck_3
        LDR     r0, =PVR0F0_10
        LDR     r1, =PVR0F2_10
        LDR     r2, =PVR2F0_10
        LDR     r3, =PVR2F1_10
        B       WRITE_L1_SA_SETTINGS

l1_ck_3:
        //; if L1_[2:0] == 11
        LDR     r1, = 0x03
        CMP     r4, r1
        LDR     r0, =PVR0F0_11
        LDR     r1, =PVR0F2_11
        LDR     r2, =PVR2F0_11
        LDR     r3, =PVR2F1_11
        B       WRITE_L1_SA_SETTINGS


WRITE_L1_SA_SETTINGS:

        //;WCP15_PVR0F0   r0
        MCR     p15, 0x0, r0, c15, c15, 0x0   //; write R0 to PVR0F0

        //;WCP15_PVR0F2   r1
        MCR     p15, 0x0, r1, c15, c15, 0x2   //; write R1 to PVR0F2

        //;WCP15_PVR2F0   r2
        MCR     p15, 0x2, r2, c15, c15, 0x0   //; write R2 to PVR2F0

        // Disable predecode repair cache on certain Scorpion revisions
        // (Raptor V2 and earlier, or Halcyon V1)
        MRC    p15, 0, r1, c0, c0, 0      //; MIDR
        BIC    r2, r1, #0xf0              //; check for Halcyon V1
        LDR    r4, =0x511f0000
        CMP    r2, r4
        BNE    PVR2F1

DPRC:
        MRC    p15, 0, r1, c15, c15, 2    //; PVR0F2
        ORR    r1, r1, #0x10              //; enable bit 4
        MCR    p15, 0, r1, c15, c15, 2    //; disable predecode repair cache

PVR2F1:
        //;WCP15_PVR2F1   r3
        MCR     p15, 0x2, r3, c15, c15, 0x1   //; write R3 to PVR2F1

        //; Reading L2_ACC
        LDR     r4, = 0x0

        //; Read L2_ACC_BIT_0
        LDR     r1, =TCSR_CONF_FUSE_1
        LDR     r2, =L2_ACC_BIT_0
        LDR     r3, [r1]
        MOV     r3, r3, LSR r2
        AND     r3, r3, #1
        ORR     r4, r3, r4

        //; Read L2_ACC_BIT_1
        LDR     r1, =TCSR_CONF_FUSE_4
        LDR     r2, =L2_ACC_BIT_1
        LDR     r3, [r1]
        MOV     r3, r3, LSR r2
        AND     r3, r3, #1
        MOV     r3, r3, LSL #1
        ORR     r4, r3, r4

        //; Read L2_ACC_BIT_2
        LDR     r1, =TCSR_CONF_FUSE_4
        LDR     r2, =L2_ACC_BIT_2
        LDR     r3, [r1]
        MOV     r3, r3, LSR r2
        AND     r3, r3, #1
        MOV     r3, r3, LSL #2
        ORR     r4, r3, r4

l2_ck_0:
        //; if L2_[2:0] == 000
        LDR     r5, = 0x0
        CMP     r4, r5
        BNE     l2_ck_1
        LDR     r0, =L2VR3F1_000
        B       WRITE_L2_SA_SETTINGS

l2_ck_1:
        //; if L2_[2:0] == 001
        LDR     r5, = 0x1
        CMP     r4, r5
        BNE     l2_ck_2
        LDR     r0, =L2VR3F1_001
        B       WRITE_L2_SA_SETTINGS

l2_ck_2:
        //; if L2_[2:0] == 010
        LDR     r5, = 0x2
        CMP     r4, r5
        BNE     l2_ck_3
        LDR     r0, =L2VR3F1_010
        B       WRITE_L2_SA_SETTINGS

l2_ck_3:
        //; if L2_[2:0] == 011
        LDR     r5, = 0x3
        CMP     r4, r5
        BNE     l2_ck_4
        LDR     r0, =L2VR3F1_011
        B       WRITE_L2_SA_SETTINGS

l2_ck_4:
        //; if L2_[2:0] == 100
        LDR     r5, = 0x4
        CMP     r4, r5
        BNE     l2_ck_5
        LDR     r0, =L2VR3F1_100
        B       WRITE_L2_SA_SETTINGS

l2_ck_5:
        //; if L2_[2:0] == 101
        LDR     r5, = 0x5
        CMP     r4, r5
        BNE     l2_ck_6
        LDR     r0, =L2VR3F1_101
        B       WRITE_L2_SA_SETTINGS

l2_ck_6:
        //; if L2_[2:0] == 110
        LDR     r5, = 0x6
        CMP     r4, r5
        BNE     l2_ck_7
        LDR     r0, =L2VR3F1_110
        B       WRITE_L2_SA_SETTINGS

l2_ck_7:
        //; if L2_[2:0] == 111
        LDR     r5, = 0x7
        CMP     r4, r5
        LDR     r0, =L2VR3F1_111
        B       WRITE_L2_SA_SETTINGS

WRITE_L2_SA_SETTINGS:
        //;WCP15_L2VR3F1  r0
        MCR     p15, 0x3, r0, c15, c15, 0x1     //;write r0 to L2VR3F1
	DSB
	ISB

        LDR     r0, =0                   //;make sure the registers we touched
        LDR     r1, =0                   //;are cleared when we return
        LDR     r2, =0
        LDR     r3, =0
        LDR     r4, =0
        LDR     r5, =0

        //; routine complete
        B       _cpu_early_init_complete

.ltorg


.globl __cpu_early_init
__cpu_early_init:
        //; Zero out r0 for use throughout this code. All other GPRs
        //; (r1-r3) are set throughout this code to help establish
        //; a consistent startup state for any code that follows.
        //; Users should add code at the end of this routine to establish
        //; their own stack address (r13), add translation page tables, enable
        //; the caches, etc.
        MOV    r0,  #0x0


        //; Remove hardcoded cache settings. appsbl_handler.s calls Set_SA
        //;   API to dynamically configure cache for slow/nominal/fast parts

        //; DCIALL to invalidate L2 cache bank (needs to be run 4 times, once per bank)
        //; This must be done early in code (prior to enabling the caches)
        MOV    r1, #0x2
        MCR    p15, 0, r1, c9, c0, 6   //; DCIALL bank D ([15:14] == 2'b00)
        ORR    r1, r1, #0x00004000
        MCR    p15, 0, r1, c9, c0, 6   //; DCIALL bank C ([15:14] == 2'b01)
        ADD    r1, r1, #0x00004000
        MCR    p15, 0, r1, c9, c0, 6   //; DCIALL bank B ([15:14] == 2'b10)
        ADD    r1, r1, #0x00004000
        MCR    p15, 0, r1, c9, c0, 6   //; DCIALL bank A ([15:14] == 2'b11)

        //; Initialize the BPCR - setup Global History Mask (GHRM) to all 1's
        //; and have all address bits (AM) participate.
        //; Different settings can be used to improve performance
        // MOVW   r1, #0x01FF
.word 0xe30011ff  // hardcoded MOVW instruction due to lack of compiler support
        // MOVT   r1, #0x01FF
.word 0xe34011ff  // hardcoded MOVT instruction due to lack of compiler support
        MCR    p15, 7, r1, c15, c0, 2   //; WCP15_BPCR


        //; Initialize all I$ Victim Registers to 0 for startup
        MCR    p15, 0, r0, c9, c1, 0    //; WCP15_ICVIC0    r0
        MCR    p15, 0, r0, c9, c1, 1    //; WCP15_ICVIC1    r0
        MCR    p15, 0, r0, c9, c1, 2    //; WCP15_ICVIC2    r0
        MCR    p15, 0, r0, c9, c1, 3    //; WCP15_ICVIC3    r0
        MCR    p15, 0, r0, c9, c1, 4    //; WCP15_ICVIC4    r0
        MCR    p15, 0, r0, c9, c1, 5    //; WCP15_ICVIC5    r0
        MCR    p15, 0, r0, c9, c1, 6    //; WCP15_ICVIC5    r0
        MCR    p15, 0, r0, c9, c1, 7    //; WCP15_ICVIC7    r0

        //; Initialize all I$ Locked Victim Registers (Unlocked Floors) to 0
        MCR    p15, 1, r0, c9, c1, 0    //; WCP15_ICFLOOR0  r0
        MCR    p15, 1, r0, c9, c1, 1    //; WCP15_ICFLOOR1  r0
        MCR    p15, 1, r0, c9, c1, 2    //; WCP15_ICFLOOR2  r0
        MCR    p15, 1, r0, c9, c1, 3    //; WCP15_ICFLOOR3  r0
        MCR    p15, 1, r0, c9, c1, 4    //; WCP15_ICFLOOR4  r0
        MCR    p15, 1, r0, c9, c1, 5    //; WCP15_ICFLOOR5  r0
        MCR    p15, 1, r0, c9, c1, 6    //; WCP15_ICFLOOR6  r0
        MCR    p15, 1, r0, c9, c1, 7    //; WCP15_ICFLOOR7  r0

        //; Initialize all D$ Victim Registers to 0
        MCR    p15, 2, r0, c9, c1, 0    //; WP15_DCVIC0    r0
        MCR    p15, 2, r0, c9, c1, 1    //; WP15_DCVIC1    r0
        MCR    p15, 2, r0, c9, c1, 2    //; WP15_DCVIC2    r0
        MCR    p15, 2, r0, c9, c1, 3    //; WP15_DCVIC3    r0
        MCR    p15, 2, r0, c9, c1, 4    //; WP15_DCVIC4    r0
        MCR    p15, 2, r0, c9, c1, 5    //; WP15_DCVIC5    r0
        MCR    p15, 2, r0, c9, c1, 6    //; WP15_DCVIC6    r0
        MCR    p15, 2, r0, c9, c1, 7    //; WP15_DCVIC7    r0

        //; Initialize all D$ Locked VDCtim Registers (Unlocked Floors) to 0
        MCR    p15, 3, r0, c9, c1, 0    //; WCP15_DCFLOOR0  r0
        MCR    p15, 3, r0, c9, c1, 1    //; WCP15_DCFLOOR1  r0
        MCR    p15, 3, r0, c9, c1, 2    //; WCP15_DCFLOOR2  r0
        MCR    p15, 3, r0, c9, c1, 3    //; WCP15_DCFLOOR3  r0
        MCR    p15, 3, r0, c9, c1, 4    //; WCP15_DCFLOOR4  r0
        MCR    p15, 3, r0, c9, c1, 5    //; WCP15_DCFLOOR5  r0
        MCR    p15, 3, r0, c9, c1, 6    //; WCP15_DCFLOOR6  r0
        MCR    p15, 3, r0, c9, c1, 7    //; WCP15_DCFLOOR7  r0

        //; Initialize ASID to zero
        MCR    p15, 0, r0, c13, c0, 1   //; WCP15_CONTEXTIDR r0

        //; ICIALL to invalidate entire I-Cache
        MCR    p15, 0, r0, c7, c5, 0    //; ICIALLU

        //; DCIALL to invalidate entire D-Cache
        MCR    p15, 0, r0, c9, c0, 6    //; DCIALL  r0

	//; Initialize ADFSR to zero
        MCR    p15, 0, r0, c5, c1, 0    //; ADFSR   r0

	//; Initialize EFSR to zero
        MCR    p15, 7, r0, c15, c0, 1   //; EFSR    r0

        //; The VBAR (Vector Base Address Register) should be initialized
        //; early in your code. We are setting it to zero
        MCR    p15, 0, r0, c12, c0, 0   //; WCP15_VBAR  r0

        //; Ensure the MCR's above have completed their operation before continuing
        DSB
        ISB

        //; Setup CCPR - Cache Coherency Policy Register
        //; setup CCPR[L1ISHP, L2ISHP] both to 0b00 (no forcing)
        //; setup CCPR[L1OSHP, L2OSHP] both to 0b10 (force non-cacheable)
        MOVW   r2, #0x88
        MCR    p15, 0, r2, c10, c4, 2

        //;-------------------------------------------------------------------
        //; There are a number of registers that must be set prior to enabling
        //; the MMU. The DCAR is one of these registers. We are setting
        //; it to zero (no access) to easily detect improper setup in subsequent
        //; code sequences
        //;-------------------------------------------------------------------
        //; Setup DACR (Domain Access Control Register) to zero
        MCR    p15, 0, r0, c3, c0, 0    //; WCP15_DACR  r0

        //; Setup DCLKCR to allow normal D-Cache line fills
        MCR    p15, 1, r0, c9, c0, 7    //; WCP15_DCLKCR r0

        //; Setup the TLBLKCR
        //; Victim = 6'b000000; Floor = 6'b000000;
        //; IASIDCFG = 2'b00 (State-Machine); IALLCFG = 2'b01 (Flash); BNA = 1'b0;
        MOV    r1, #0x02
        MCR    p15, 0, r1, c10, c1, 3     //; WCP15_TLBLKCR  r1

        //;Make sure TLBLKCR is complete before continuing
        ISB

        //; Invalidate the UTLB
        MCR    p15, 0, r0, c8, c7, 0      //; UTLBIALL

        //; Make sure UTLB request has been presented to macro before continuing
        ISB

SYSI2:
        //; setup L2CR1 to some default Instruction and data prefetching values
        //; Users may want specific settings for various performance enhancements
        //; In Halcyon we do not have broadcasting barriers. So we need to turn
        //  ; on bit 8 of L2CR1; which DBB:( Disable barrier broadcast )
        LDR    r2, =0x133
        MCR    p15, 3, r2, c15, c0, 3     //; WCP15_L2CR1  r0


        //; Enable Z bit to enable branch prediction (default is off)
        MRC    p15, 0, r2, c1, c0, 0      //; RCP15_SCTLR  r2
        ORR    r2, r2, #0x00000800
        MCR    p15, 0, r2, c1, c0, 0      //; WCP15_SCTLR  r2

        //; Make sure Link stack is initialized with branch and links to sequential addresses
        //; This aids in creating a predictable startup environment
        BL      SEQ1
SEQ1:   BL      SEQ2
SEQ2:   BL      SEQ3
SEQ3:   BL      SEQ4
SEQ4:   BL      SEQ5
SEQ5:   BL      SEQ6
SEQ6:   BL      SEQ7
SEQ7:   BL      SEQ8
SEQ8:

        //; REMOVE FOLLOWING THREE INSTRUCTIONS WHEN POWER COLLAPSE IS ENA
        //;Make sure the DBGOSLSR[LOCK] bit is cleared to allow access to the debug registers
        //; Writing anything but the "secret code" to the DBGOSLAR clears the DBGOSLSR[LOCK] bit
        MCR    p14, 0, r0, c1, c0, 4       //; WCP14_DBGOSLAR r0


        //; Read the DBGPRSR to clear the DBGPRSR[STICKYPD]
        //; Any read to DBGPRSR clear the STICKYPD bit
        //; ISB guarantees the read completes before attempting to
        //; execute a CP14 instruction.
        MRC    p14, 0, r3, c1, c5, 4       //; RCP14_DBGPRSR r3
        ISB

        //; Initialize the Watchpoint Control Registers to zero (optional)
        //;;; MCR    p14, 0, r0, c0, c0, 7       ; WCP14_DBGWCR0  r0
        //;;; MCR    p14, 0, r0, c0, c1, 7       ; WCP14_DBGWCR1  r0


        //;----------------------------------------------------------------------
        //; The saved Program Status Registers (SPSRs) should be setup
        //; prior to any automatic mode switches. The following
        //; code sets these registers up to a known state. Users will need to
        //; customize these settings to meet their needs.
        //;----------------------------------------------------------------------
        MOV    r2,  #0x1f
        MOV    r1,  #0xd7                 //;ABT mode
        msr    cpsr_c, r1                 //;ABT mode
        msr    spsr_cxfs, r2              //;clear the spsr
        MOV    r1,  #0xdb                 //;UND mode
        msr    cpsr_c, r1                 //;UND mode
        msr    spsr_cxfs, r2              //;clear the spsr
        MOV    r1,  #0xd1                 //;FIQ mode
        msr    cpsr_c, r1                 //;FIQ mode
        msr    spsr_cxfs, r2              //;clear the spsr
        MOV    r1,  #0xd2                 //;IRQ mode
        msr    cpsr_c, r1                 //;IRQ mode
        msr    spsr_cxfs, r2              //;clear the spsr
        MOV    r1,  #0xd6                 //;Monitor mode
        msr    cpsr_c, r1                 //;Monitor mode
        msr    spsr_cxfs, r2              //;clear the spsr
        MOV    r1,  #0xd3                 //;SVC mode
        msr    cpsr_c, r1                 //;SVC mode
        msr    spsr_cxfs, r2              //;clear the spsr


        //;----------------------------------------------------------------------
        //; Enabling Error reporting is something users may want to do at
        //; some other point in time. We have chosen some default settings
        //; that should be reviewed. Most of these registers come up in an
        //; unpredictable state after reset.
        //;----------------------------------------------------------------------
//;Start of error and control setting

        //; setup L2CR0 with various L2/TCM control settings
        //; enable out of order bus attributes and error reporting
        //; this register comes up unpredictable after reset
        // MOVW   r1, #0x0F0F
.word 0xe3001f0f  // hardcoded MOVW instruction due to lack of compiler support
        // MOVT   r1, #0xC005
.word 0xe34c1005  // hardcoded MOVW instruction due to lack of compiler support
        MCR    p15, 3, r1, c15, c0, 1    //; WCP15_L2CR0  r1

        //; setup L2CPUCR
        //; MOV    r2, #0xFF
        //; Enable I and D cache parity
        //;L2CPUCR[7:5] = 3~Rh7 ~V enable parity error reporting for modified,
        //;tag, and data parity errors
        MOV    r2, #0xe0
        MCR    p15, 3, r2, c15, c0, 2    //; WCP15_L2CPUCR  r2

        //; setup SPCR
        //; enable all error reporting (reset value is unpredicatble for most bits)
        MOV    r3, #0x0F
        MCR    p15, 0, r3, c9, c7, 0     //; WCP15_SPCR  r3

        //; setup DMACHCRs (reset value unpredictable)
        //; control setting and enable all error reporting
        MOV   r1, #0x0F

        //; DMACHCR0 = 0000000F
        MOV   r2, #0x00                  //; channel 0
        MCR   p15, 0, r2, c11, c0, 0     //; WCP15_DMASELR  r2
        MCR   p15, 0, r1, c11, c0, 2     //; WCP15_DMACHCR  r1

        //; DMACHCR1 = 0000000F
        MOV   r2, #0x01                  //; channel 1
        MCR   p15, 0, r2, c11, c0, 0     //; WCP15_DMASELR  r2
        MCR   p15, 0, r1, c11, c0, 2     //; WCP15_DMACHCR  r1

        //; DMACHCR2 = 0000000F
        MOV   r2, #0x02                  //; channel 2
        MCR   p15, 0, r2, c11, c0, 0     //; WCP15_DMASELR  r2
        MCR   p15, 0, r1, c11, c0, 2     //; WCP15_DMACHCR  r1

        //; DMACHCR3 = 0000000F
        MOV   r2, #0x03                  //; channel 3
        MCR   p15, 0, r2, c11, c0, 0     //; WCP15_DMASELR  r2
        MCR   p15, 0, r1, c11, c0, 2     //; WCP15_DMACHCR  r1

        //; Set ACTLR (reset unpredictable)
        //; Set AVIVT control, error reporting, etc.
        //; MOV   r3, #0x07
        //; Enable I and D cache parity
        //;ACTLR[2:0] = 3'h7 - enable parity error reporting from L2/I$/D$)
        //;ACTLR[5:4] = 2'h3 - enable parity
        //;ACTLR[19:18] =2'h3 - always generate and check parity(when MMU disabled).
        //;Value to be written #0xC0037
        // MOVW   r3, #0x0037
.word 0xe3003037  // hardcoded MOVW instruction due to lack of compiler support
        // MOVT   r3, #0x000C
.word 0xe340300c  // hardcoded MOVW instruction due to lack of compiler support
        MCR   p15, 0, r3, c1, c0, 1      //; WCP15_ACTLR  r3

//;End of error and control setting

        //;----------------------------------------------------------------------
        //; Unlock ETM and read StickyPD to halt the ETM clocks from running.
        //; This is required for power saving whether the ETM is used or not.
        //;----------------------------------------------------------------------

        //;Clear ETMOSLSR[LOCK] bit
        MOV   r1, #0x00000000
        MCR   p14, 1, r1, c1, c0, 4        //; WCP14_ETMOSLAR      r1

        //;Clear ETMPDSR[STICKYPD] bit
        MRC   p14, 1, r2, c1, c5, 4        //; RCP14_ETMPDSR       r2

/*
#ifdef APPSBL_ETM_ENABLE
        ;----------------------------------------------------------------------
        ; Optionally Enable the ETM (Embedded Trace Macro) which is used for debug
        ;----------------------------------------------------------------------

        ; enable ETM clock if disabled
        MRC   p15, 7, r1, c15, c0, 5       ; RCP15_CPMR           r1
        ORR   r1, r1, #0x00000008
        MCR   p15, 7, r1, c15, c0, 5       ; WCP15_CPMR           r1
        ISB

        ; set trigger event to counter1 being zero
        MOV   r3, #0x00000040
        MCR   p14, 1, r3, c0, c2, 0        ; WCP14_ETMTRIGGER     r3

        ; clear ETMSR
        MOV   r2, #0x00000000
        MCR   p14, 1, r2, c0, c4, 0        ; WCP14_ETMSR          r2

        ; clear trace enable single address comparator usage
        MCR   p14, 1, r2, c0, c7, 0        ; WCP14_ETMTECR2       r2

        ; set trace enable to always
        MOV   r2, #0x0000006F
        MCR   p14, 1, r2, c0, c8, 0        ; WCP14_ETMTEEVR       r2

        ; clear trace enable address range comparator usage and exclude nothing
        MOV   r2, #0x01000000
        MCR   p14, 1, r2, c0, c9, 0        ; WCP14_ETMTECR1       r2

        ; set view data to always
        MOV   r2, #0x0000006F
        MCR   p14, 1, r2, c0, c12, 0       ; WCP14_ETMVDEVR       r2

        ; clear view data single address comparator usage
        MOV   r2, #0x00000000
        MCR   p14, 1, r2, c0, c13, 0       ;  WCP14_ETMVDCR1       r2

        ; clear view data address range comparator usage and exclude nothing
        MOV   r2, #0x00010000
        MCR   p14, 1, r2, c0, c15, 0       ;  WCP14_ETMVDCR3       r2

        ; set counter1 to 194
        MOV   r2, #0x000000C2
        MCR   p14, 1, r2, c0, c0, 5        ;  WCP14_ETMCNTRLDVR1   r2

        ; set counter1 to never reload
        MOV   r2, #0x0000406F
        MCR   p14, 1, r2, c0, c8, 5        ;  WCP14_ETMCNTRLDEVR1  r2

        ; set counter1 to decrement every cycle
        MOV   r2, #0x0000006F
        MCR   p14, 1, r2, c0, c4, 5        ; WCP14_ETMCNTENR1     r2

        ; Set trace synchronization frequency 1024 bytes
        MOV   r2, #0x00000400
        MCR   p14, 1, r2, c0, c8, 7        ; WCP14_ETMSYNCFR      r2

        ; Program etm control register
        ;  - Set the CPU to ETM clock ratio to 1:1
        ;  - Set the ETM to perform data address tracing
        MOV   r2, #0x00002008
        MCR   p14, 1, r2, c0, c0, 0        ; WCP14_ETMCR          r2
        ISB
#endif *//* APPSBL_ETM_ENABLE */

/*
#ifdef APPSBL_VFP_ENABLE
       ;----------------------------------------------------------------------
       ; Perform the following operations if you intend to make use of
       ; the VFP/Neon unit. Note that the FMXR instruction requires a CPU ID
       ; indicating the VFP unit is present (i.e.Cortex-A8). .
       ; Some tools will require full double precision floating point support
       ; which will become available in Scorpion pass 2
       ;----------------------------------------------------------------------
       ; allow full access to CP 10 and 11 space for VFP/NEON use
        MRC   p15, 0, r1, c1, c0, 2        ; Read CP Access Control Register
        ORR   r1, r1, #0x00F00000          ; enable full access for p10,11
        MCR   p15, 0, r1, c1, c0, 2        ; Write CPACR

        ;make sure the CPACR is complete before continuing
        ISB

       ; Enable VFP itself (certain OSes may want to dynamically set/clear
       ; the enable bit based on the application being executed
        MOV   r1, #0x40000000
        FMXR  FPEXC, r1
#endif *//* APPSBL_VFP_ENABLE */

        /* we have no stack, so just tail-call into the SET_SA routine... */
        b SET_SA


.ltorg