nxp lpc23/24xx common keil例程 通用文件

源代码在线查看: startup.s

软件大小: 17 K
上传用户: ty1234
关键词: common keil nxp lpc
下载地址: 免注册下载 普通下载 VIP

相关代码

				;/*****************************************************************************
				;*   startup.s: startup file for NXP LPC23xx Family Microprocessors
				;*
				;*   Copyright(C) 2006, NXP Semiconductor
				;*   All rights reserved.
				;*
				;*   History
				;*   2006.09.01  ver 1.00    Prelimnary version, first Release
				;*
				;*****************************************************************************/
					PRESERVE8
				
				;/*
				; *  The STARTUP.S code is executed after CPU Reset. This file may be 
				; *  translated with the following SET symbols. In uVision these SET 
				; *  symbols are entered under Options - ASM - Define.
				; *
				; *  REMAP: when set the startup code initializes the register MEMMAP 
				; *  which overwrites the settings of the CPU configuration pins. The 
				; *  startup and interrupt vectors are remapped from:
				; *     0x00000000  default setting (not remapped)
				; *     0x40000000  when RAM_MODE is used
				; *
				; *  RAM_MODE: when set the device is configured for code execution
				; *  from on-chip RAM starting at address 0x40000000. 
				; */
				
				; Standard definitions of Mode bits and Interrupt (I & F) flags in PSRs
				
				Mode_USR        EQU     0x10
				Mode_FIQ        EQU     0x11
				Mode_IRQ        EQU     0x12
				Mode_SVC        EQU     0x13
				Mode_ABT        EQU     0x17
				Mode_UND        EQU     0x1B
				Mode_SYS        EQU     0x1F
				
				I_Bit           EQU     0x80            ; when I bit is set, IRQ is disabled
				F_Bit           EQU     0x40            ; when F bit is set, FIQ is disabled
				
				;//  Stack Configuration (Stack Sizes in Bytes)
				;//    Undefined Mode      
				;//    Supervisor Mode     
				;//    Abort Mode          
				;//    Fast Interrupt Mode 
				;//    Interrupt Mode      
				;//    User/System Mode    
				;// 
				
				UND_Stack_Size  EQU     0x00000000
				SVC_Stack_Size  EQU     0x00000100
				ABT_Stack_Size  EQU     0x00000000
				FIQ_Stack_Size  EQU     0x00000100
				IRQ_Stack_Size  EQU     0x00000100
				USR_Stack_Size  EQU     0x00000200
				
				Stack_Size      EQU     (UND_Stack_Size + SVC_Stack_Size + ABT_Stack_Size + \
				                         FIQ_Stack_Size + IRQ_Stack_Size + USR_Stack_Size)
				
								IMPORT  FIQ_Handler
				
				                AREA    STACK, NOINIT, READWRITE, ALIGN=3
				Stack_Mem       SPACE   Stack_Size
				
				Stack_Top       EQU     Stack_Mem + Stack_Size
				
				;//  Heap Configuration
				;//     Heap Size (in Bytes) 
				;// 
				
				Heap_Size       EQU     0x00000000
				
				                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
				Heap_Mem        SPACE   Heap_Size
				
				; Area Definition and Entry Point
				;  Startup Code must be linked first at Address at which it expects to run.
				
				                AREA    RESET, CODE, READONLY
				                ARM
				
				; Exception Vectors
				;  Mapped to Address 0.
				;  Absolute addressing mode must be used.
				;  Dummy Handlers are implemented as infinite loops which can be modified.
				
				Vectors         LDR     PC, Reset_Addr         
				                LDR     PC, Undef_Addr
				                LDR     PC, SWI_Addr
				                LDR     PC, PAbt_Addr
				                LDR     PC, DAbt_Addr
				                NOP                            ; Reserved Vector 
				;               LDR     PC, IRQ_Addr
				                LDR     PC, [PC, #-0x0120]     ; Vector from VicVectAddr
				                LDR     PC, FIQ_Addr
				
				Reset_Addr      DCD     Reset_Handler
				Undef_Addr      DCD     Undef_Handler
				SWI_Addr        DCD     SWI_Handler
				PAbt_Addr       DCD     PAbt_Handler
				DAbt_Addr       DCD     DAbt_Handler
				                DCD		0xB9206E28             ; Reserved Address 
				IRQ_Addr        DCD     IRQ_Handler
				FIQ_Addr        DCD     FIQ_Handler
				
				Undef_Handler   B       Undef_Handler
				SWI_Handler     B       SWI_Handler
				PAbt_Handler    B       PAbt_Handler
				DAbt_Handler    B       DAbt_Handler
				IRQ_Handler     B       IRQ_Handler
				;FIQ_Handler     B       FIQ_Handler
				
				; Reset Handler
				
				                EXPORT  Reset_Handler
				Reset_Handler   
				
				; Setup Stack for each mode
				                LDR     R0, =Stack_Top
				
				;  Enter Undefined Instruction Mode and set its Stack Pointer
				                MSR     CPSR_c, #Mode_UND:OR:I_Bit:OR:F_Bit
				                MOV     SP, R0
				                SUB     R0, R0, #UND_Stack_Size
				
				;  Enter Abort Mode and set its Stack Pointer
				                MSR     CPSR_c, #Mode_ABT:OR:I_Bit:OR:F_Bit
				                MOV     SP, R0
				                SUB     R0, R0, #ABT_Stack_Size
				
				;  Enter FIQ Mode and set its Stack Pointer
				                MSR     CPSR_c, #Mode_FIQ:OR:I_Bit:OR:F_Bit
				                MOV     SP, R0
				                SUB     R0, R0, #FIQ_Stack_Size
				
				;  Enter IRQ Mode and set its Stack Pointer
				                MSR     CPSR_c, #Mode_IRQ:OR:I_Bit:OR:F_Bit
				                MOV     SP, R0
				                SUB     R0, R0, #IRQ_Stack_Size
				
				;  Enter Supervisor Mode and set its Stack Pointer
				                MSR     CPSR_c, #Mode_SVC:OR:I_Bit:OR:F_Bit
				                MOV     SP, R0
				                SUB     R0, R0, #SVC_Stack_Size
				
				;  Enter User Mode and set its Stack Pointer
				                MSR     CPSR_c, #Mode_USR
				                MOV     SP, R0
				                SUB     SL, SP, #USR_Stack_Size
								
								IMPORT	TargetResetInit
								BL		TargetResetInit
				
				; Enter the C code
				
				                IMPORT  __main
				                LDR     R0, =__main
				                BX      R0
				
				
				; User Initial Stack & Heap
				                AREA    |.text|, CODE, READONLY
				
				                IMPORT  __use_two_region_memory
				                EXPORT  __user_initial_stackheap
				__user_initial_stackheap
				
				                LDR     R0, =  Heap_Mem
				                LDR     R1, =(Stack_Mem + USR_Stack_Size)
				                LDR     R2, = (Heap_Mem +      Heap_Size)
				                LDR     R3, = Stack_Mem
				                BX      LR
				
				                END
							

相关资源