main.s

pxa270 NOR FLASH驱动代码

    ;
    ldr    r0, =0xFFFF0005         ; Display pattern: 0xFFFF0005
    setHexLED r0, r2
    ;
    ; Dump the registers
    ;
    bl    DumpProcessorRegisters
    ;
    ; Flash the LEDs if returned
    ;
1000
    ldr    r1, =0xFFFF
    maskHexLED r1, r2, r3
    pauseMilliSecs #250, r1, r2, r3
    ldr    r1, =0
    maskHexLED r1, r2, r3
    pauseMilliSecs #500, r1, r2, r3
    b      %B1000

SWI_Handler
    ;
    ; Capture the register set
    ;
    stmfd  sp!, {r0}               ; Save registers
    ldr    r0, =regset
    str    r1,  [r0, #4]
    str    r2,  [r0, #8]
    str    r3,  [r0, #12]
    str    r4,  [r0, #16]
    str    r5,  [r0, #20]
    str    r6,  [r0, #24]
    str    r7,  [r0, #28]
    str    r8,  [r0, #32]
    str    r9,  [r0, #36]
    str    r10, [r0, #40]
    str    r11, [r0, #44]
    str    r12, [r0, #48]
    str    r14, [r0, #56]
    str    r15, [r0, #60]
    ldmfd  sp!, {r0}               ; Restore registers and return
    ;
    ; Store the remaining registers
    ;
    ldr    r1, =regset
    str    r0,  [r1, #0]
    str    r13, [r1, #52]
    mrs    r2, CPSR                ; get the processor status
    str    r2, [r1, #64]
    ;
    ; Display the LED error codes here
    ;
    ldr    r0, =0xFFFF0006         ; Display pattern: 0xFFFF0006
    setHexLED r0, r2
    ;
    ; Dump the registers
    ;
    bl    DumpProcessorRegisters
    ;
    ; Flash the LEDs if returned
    ;
1100
    ldr    r1, =0xFFFF
    maskHexLED r1, r2, r3
    pauseMilliSecs #250, r1, r2, r3
    ldr    r1, =0
    maskHexLED r1, r2, r3
    pauseMilliSecs #500, r1, r2, r3
    b      %B1100

Prefetch_Handler
    ;
    ; Capture the register set
    ;
    stmfd  sp!, {r0}               ; Save registers
    ldr    r0, =regset
    str    r1,  [r0, #4]
    str    r2,  [r0, #8]
    str    r3,  [r0, #12]
    str    r4,  [r0, #16]
    str    r5,  [r0, #20]
    str    r6,  [r0, #24]
    str    r7,  [r0, #28]
    str    r8,  [r0, #32]
    str    r9,  [r0, #36]
    str    r10, [r0, #40]
    str    r11, [r0, #44]
    str    r12, [r0, #48]
    str    r14, [r0, #56]
    str    r15, [r0, #60]
    ldmfd  sp!, {r0}               ; Restore registers and return
    ;
    ; Store the remaining registers
    ;
    ldr    r1, =regset
    str    r0,  [r1, #0]
    str    r13, [r1, #52]
    mrs    r2, CPSR                ; get the processor status
    str    r2, [r1, #64]
    ;
    ; Display the LED error codes here
    ;
    ldr    r0, =0xFFFF0007         ; Display pattern: 0xFFFF0007
    setHexLED r0, r2
    ;
    ; Dump the registers
    ;
    bl    DumpProcessorRegisters
    ;
    ; Flash the LEDs if returned
    ;
1200
    ldr    r1, =0xFFFF
    maskHexLED r1, r2, r3
    pauseMilliSecs #250, r1, r2, r3
    ldr    r1, =0
    maskHexLED r1, r2, r3
    pauseMilliSecs #500, r1, r2, r3
    b      %B1200

Abort_Handler
    ;
    ; Capture the register set
    ;
    stmfd  sp!, {r0}               ; Save registers
    ldr    r0, =regset
    str    r1,  [r0, #4]
    str    r2,  [r0, #8]
    str    r3,  [r0, #12]
    str    r4,  [r0, #16]
    str    r5,  [r0, #20]
    str    r6,  [r0, #24]
    str    r7,  [r0, #28]
    str    r8,  [r0, #32]
    str    r9,  [r0, #36]
    str    r10, [r0, #40]
    str    r11, [r0, #44]
    str    r12, [r0, #48]
    str    r14, [r0, #56]
    str    r15, [r0, #60]
    ldmfd  sp!, {r0}               ; Restore registers and return
    ;
    ; Store the remaining registers
    ;
    ldr    r1, =regset
    str    r0,  [r1, #0]
    str    r13, [r1, #52]
    mrs    r2, CPSR                ; get the processor status
    str    r2, [r1, #64]
    ;
    ; Display the LED error codes here
    ;
    ldr    r0, =0xFFFF0008         ; Display pattern: 0xFFFF0008
    setHexLED r0, r2
    ;
    ; Dump the registers
    ;
    bl    DumpProcessorRegisters
    ;
    ; Flash the LEDs if returned
    ;
1300
    ldr    r1, =0xFFFF
    maskHexLED r1, r2, r3
    pauseMilliSecs #250, r1, r2, r3
    ldr    r1, =0
    maskHexLED r1, r2, r3
    pauseMilliSecs #500, r1, r2, r3
    b     %B1300

IRQ_Handler
    ;
    ; Capture the register set
    ;
    stmfd  sp!, {r0}               ; Save registers
    ldr    r0, =regset
    str    r1,  [r0, #4]
    str    r2,  [r0, #8]
    str    r3,  [r0, #12]
    str    r4,  [r0, #16]
    str    r5,  [r0, #20]
    str    r6,  [r0, #24]
    str    r7,  [r0, #28]
    str    r8,  [r0, #32]
    str    r9,  [r0, #36]
    str    r10, [r0, #40]
    str    r11, [r0, #44]
    str    r12, [r0, #48]
    str    r14, [r0, #56]
    str    r15, [r0, #60]
    ldmfd  sp!, {r0}               ; Restore registers and return
    ;
    ; Store the remaining registers
    ;
    ldr    r1, =regset
    str    r0,  [r1, #0]
    str    r13, [r1, #52]
    mrs    r2, CPSR                ; get the processor status
    str    r2, [r1, #64]
    ;
    ; Display the LED error codes here
    ;
    ldr    r0, =0xFFFF0009         ; Display pattern: 0xFFFF0009
    setHexLED r0, r2
    ;
    ; Dump the registers
    ;
    bl    DumpProcessorRegisters
    ;
    ; Flash the LEDs if returned
    ;
1400
    ldr    r1, =0xFFFF
    maskHexLED r1, r2, r3
    pauseMilliSecs #250, r1, r2, r3
    ldr    r1, =0
    maskHexLED r1, r2, r3
    pauseMilliSecs #500, r1, r2, r3
    b      %B1400

FIQ_Handler
    ;
    ; Capture the register set
    ;
    stmfd  sp!, {r0}               ; Save registers
    ldr    r0, =regset
    str    r1,  [r0, #4]
    str    r2,  [r0, #8]
    str    r3,  [r0, #12]
    str    r4,  [r0, #16]
    str    r5,  [r0, #20]
    str    r6,  [r0, #24]
    str    r7,  [r0, #28]
    str    r8,  [r0, #32]
    str    r9,  [r0, #36]
    str    r10, [r0, #40]
    str    r11, [r0, #44]
    str    r12, [r0, #48]
    str    r14, [r0, #56]
    str    r15, [r0, #60]
    ldmfd  sp!, {r0}               ; Restore registers and return
    ;
    ; Store the remaining registers
    ;
    ldr    r1, =regset
    str    r0,  [r1, #0]
    str    r13, [r1, #52]
    mrs    r2, CPSR                ; get the processor status
    str    r2, [r1, #64]
    ;
    ; Display the LED error codes here
    ;
    ldr    r0, =0xFFFF000A         ; Display pattern: 0xFFFF000A
    setHexLED r0, r2
    ;
    ; Dump the registers
    ;
    bl    DumpProcessorRegisters
    ;
    ; Flash the LEDs if returned
    ;
1500
    ldr    r1, =0xFFFF
    maskHexLED r1, r2, r3
    pauseMilliSecs #250, r1, r2, r3
    ldr    r1, =0
    maskHexLED r1, r2, r3
    pauseMilliSecs #500, r1, r2, r3
    b      %B1500

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	INCLUDE  xllp_Pm_SleepContext.inc
;**************************************************************************************************
;
; XllpPmChecksumSleepDataPh
;
; Does not assume a stack or MMU enable/disable state.
; 
; Inputs: 
;       R0: Base address of area to checksum
;       R1: Number of 4-byte words in area
;       Assumes return address in link register
;
; Returns:
;       R0: Checksum
;
; Uses: R0, R1, R2, R3
;
; Note: must be identical with XllpPmChecksumSleepDataVi
;


XllpPmChecksumSleepDataPh  FUNCTION

    ; do Checksum on the buffer

    ldr     r2, =(0x5A72)                  ; Pick a non-zero seed.
XllpPmChecksumSleepDataPh_Lab1
    ldr     r3, [r0], #4                   ; get value and increment pointer
    add     r2, r2,   r3
    mov     r2, r2,   ROR #31              ; Rotate left by one bit position
    subs    r1, r1,   #1                   ; Count down for entire buffer size
    bne     XllpPmChecksumSleepDataPh_Lab1
    mov     r0, r2

	mov  pc, lr          ; return

    ENDFUNC

;; End of XllpPmChecksumSleepDataPh ()

;**************************************************************************************************
;
;   XllpPmValidateResumeFromSleep  FUNCTION
; 
; Parameters:
;   R0: value of PSPR (Power Manager Scratch Pad Register) at reset.
;       - Assumed to be physical address of saved data area
;   R1: contains a condensed copy of the RCSR and PSSR. 
;       (RCSR (bits 15:0 in 15:0 of R1) + PSSR (bits 15:0 in 31:16 of R1)
;
; Return value: in R0.
;   0x00: Success.  Sleep and valid checksum in data area
;   0x01: Not a sleep reset.
;   0x02: Other reset in addition to sleep reset.  (This may eventually become a success case.)
;   0x03: Bad checksum for saved data area.
; 
; Assumes no stack, MMU disabled.
;       Already initialized:
;           GPIOs, memory controller
;
; Uses (destroys) R0,r1,r2,r3,r4,r5,r6
;

XllpPmValidateResumeFromSleep  FUNCTION

    tst r1, #xlli_RCSR_SMR
    moveq r0, #01 ; Not sleep, return with code.
    beq   XllpPmValidateResumeFromSleep_Lab1    ; lr not corrupted.
    ; Sleep detected.  Validate checksum.

    ; Save parameters for future use if successful
    mov r4, r0      ; PSPR, containing phys addr of save area
    mov r5, r1      ; condensed copy of the RCSR and PSSR.
    mov r6, lr

    add r0, r0, #SleepState_WordCount ; WordCount is first checksummable location
    ldr r1, [r0]                     ; Get actual wordcount to checksum
                                     ;  r0..r3 lost in checksum routine
    ldr r2, =XLLI_MAX_SLEEP_DATA_COUNT ; Sanity check
    cmp r1, r2
    movgt r0, #03 ; bad data size, so declare bad checksum.
	bgt	  XllpPmValidateResumeFromSleep_Lab1    ; lr not corrupted

    bl XllpPmChecksumSleepDataPh     ; Actual checksum in R0
    ldr r2, [r4, #SleepState_CHKSUM] ; Pre-sleep checksum

    mov     r1, r0
    cmp     r2, r0 
    mov     r0, #0                     ; Assume success
    movne   r0, #03                    ; Bad checksum code.

    mov     r1, r5      ; Restore value.  Will be needed later

    ; Need to restore link register
    mov lr, r6

XllpPmValidateResumeFromSleep_Lab1
  ; lr ready for return

	mov  pc, lr          ; return

    ENDFUNC

;; End of XllpPmValidateResumeFromSleep()

;**************************************************************************************************
;
; XllpPmGoToContextRestoration  FUNCTION
;
; Restores pre-sleep MMU configuration and jumps to stored address of context 
;   restoration function
;
; Inputs: 
;   R0:  phys addr of sleep save area
;   R1:  condensed copy of the RCSR and PSSR as needed by 
;         context restoration code
;
;  Does not return, treat as void Fn ()
;
; Assumes: MMU disabled, validated data save area for MMU values
;

XllpPmGoToContextRestoration  FUNCTION

    ;    r0: contains start address
    ;    r2: contains count
    ;    uses: r2,r3,r4,r5,r6

    ldr r11, [r0, #SleepState_Cp15_DACR_MMU]   ; load the MMU domain access info
    ldr r9,  [r0, #SleepState_Cp15_TTBR_MMU]      ; load the MMU TTB info 
    ldr r8,  [r0, #SleepState_Cp15_ACR_MMU]      ; load the MMU control info 
    ldr r7,  [r0, #SleepState_Cp15_AUXCR_MMU ]  ; 
    ldr r6,  [r0, #SleepState_Cp15_PID_MMU ] ; 
    ldr r5,  [r0, #SleepState_AwakeAddr ]   ; load the LR address

    IF :DEF: XLLP_RESUME_DELAY
        ldr         r3, =FPGA_REGS_BASE_PHYSICAL         
        ldr         r4, =0x88801111
        setHexLED   r3, r4
        ldr     r4, =0x10;
XllpPmGoToContextRestoration_Lab1
        subs    r4, r4, #1
        bne     XllpPmGoToContextRestoration_Lab1
    ENDIF ; :DEF: XLLP_RESUME_DELAY

    mcr p15, 0, r11, c3, c0, 0      ; setup access to domain 0
    mcr p15, 0, r9,  c2, c0, 0      ; TTB address
    mcr p15, 0, r2,  c8, c7, 0      ; Invalidate I+D TLBs
    ldr r0, [r0, #SleepState_SleepDataAreaVA]

    b   XllpPmGoToContextRestoration_Lab2          ; Make sure everything is in the cache
    ALIGN 32
XllpPmGoToContextRestoration_Lab2
    mcr p15, 0, r8,  c1, c0, 0      ; restore MMU control
    mcr p15, 0, r7,  c1, c1, 0      ; restore MMU Aux control
    mcr p15, 0, r6, c13, c0, 0      ; restore PID

    mov  pc, r5                     ;  & jump to new virtual address (back up Power management stack)
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop

    ENDFUNC

;; End of XllpPmGoToContextRestoration()

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

    END