URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [NEC_78K0R_IAR/] [cstartup.s26] - Rev 664
Go to most recent revision | Compare with Previous | Blame | View Log
;
; This file should only be included in the 78K0R_Kx3L demo. The 78K0R_Kx3 demo
; uses the standard startup file. This is work around a bug in the startup
; file provided with the IAR tools.
;
;------------------------------------------------------------------------------
; CSTARTUP source for 78K
;
; This module contains the code executed before the C/C++ "main"
; function is called.
;
; The code usually must be tailored to suit a specific hardware
; configuration.
;
; Assembler options:
;
; -D__STANDARD_MODEL__ To assemble for use with compiler standard
; code model.
;
; -D__BANKED_MODEL__ To assemble for use with compiler banked
; code model.
;
; -D__NEAR_MODEL__ To assemble for use with compiler near
; code model.
;
; -D__FAR_MODEL__ To assemble for use with compiler far
; code model.
;
; Linker options:
;
; -D_CODEBANK_REG=0 To link for use with "standard" code model,
; no banked functions.
;
; -D_CODEBANK_REG='addr' To link for use with "banked" code model or
; "standard" code model with banked functions.
; 'addr' = bank switch register address.
;
;------------------------------------------------------------------------------
; Copyright (c) 2003-2008 IAR Systems AB.
; $Revision: 2 $
;------------------------------------------------------------------------------
#if !defined(__STANDARD_MODEL__) && !defined(__BANKED_MODEL__) && !defined(__NEAR_MODEL__) && !defined(__FAR_MODEL__)
#error One of the macros __STANDARD_MODEL__, __BANKED_MODEL__, __NEAR_MODEL__ or __FAR_MODEL__ must be defined !
#endif
;------------------------------------------------------------------------------
; The stack segment.
; The stack size is defined in the linker command file
;------------------------------------------------------------------------------
MODULE ?CSTARTUP
RSEG CSTACK:DATA:ROOT(1)
;------------------------------------------------------------------------------
; The interrupt vector segment.
; Interrupt functions with defined vectors will reserve
; space in this area as well as conformingly written assembly
; language interrupt handlers
;------------------------------------------------------------------------------
COMMON INTVEC:CODE:ROOT(1)
DC16 __program_start_fr ; Reset vector
;------------------------------------------------------------------------------
; The actual startup code
;
; Entry: __program_start
;------------------------------------------------------------------------------
RSEG RCODE:CODE:ROOT(0)
PUBLIC ?C_STARTUP
PUBLIC `@cstart` ; NEC debugger specific
PUBLIC __program_start_fr
EXTERN __low_level_init
EXTERN __MAIN_CALL
#if defined(__STANDARD_MODEL__) || defined(__BANKED_MODEL__)
EXTERN _CODEBANK_REG
#else
EXTERN _NEAR_CONST_LOCATION
PMC DEFINE 0xFFFFE
#endif
#if defined(__BANKED_MODEL__)
EXTERN ?FAR_CALL_L07
SFRTYPE BANK_REG BYTE, READ, WRITE = _CODEBANK_REG
#endif
REQUIRE __MAIN_CALL
;------------------------------------------------------------------------------
; Perform the run-time initialization.
;------------------------------------------------------------------------------
?C_STARTUP:
`@cstart`:
__program_start_fr:
DI
#if defined(__BANKED_MODEL__)
MOV BANK_REG, #0 ; Banked, clear bank register
#elif defined(__STANDARD_MODEL__)
MOVW AX, #_CODEBANK_REG
OR A, X
BZ nobank ; Standard, no banked functions, no bank register (=0)
MOVW HL, #_CODEBANK_REG
XOR A, A
MOV [HL], A ; Standard with banked functions, clear bank register
nobank:
#else
MOV A, #(_NEAR_CONST_LOCATION & 1) ; Near/Far, set mirror area
MOV1 CY, A.0
MOV1 PMC.0, CY
#endif
#if __CORE__ != __78K0S__
MOVW SP, #sfe(CSTACK)
#else
MOVW AX, #sfe(CSTACK)
MOVW SP, AX
#endif
; Init stack segment for 78K0R, as the generated code may sometimes
; access the 4th byte of a return address before it is initialized
#if __CORE__ == __78K0R__
MOVW HL, #sfb(CSTACK)
MOVW BC, #LWRD(sizeof(CSTACK))
CMP0 C
SKZ
INC B
MOV A, #0xCD
loop_s:
MOV [HL], A
INCW HL
DEC C
BNZ loop_s
DEC B
BNZ loop_s
#endif
#if __CORE__ == __78K0R__
MOV CS, #0
#endif
;------------------------------------------------------------------------------
; Here is the place to put user initializations.
;------------------------------------------------------------------------------
; User initialization code
;------------------------------------------------------------------------------
; Call __low_level_init to perform initialization before initializing
; segments and calling main.
; If the function returns 0, no segment initialization should take place.
;
; Link with your own version of __low_level_init to override the
; default action: to do nothing but return 1.
;------------------------------------------------------------------------------
#if defined(__FAR_MODEL__)
CALL F:__low_level_init
#elif defined(__BANKED_MODEL__)
MOV E, #byte3(__low_level_init)
MOVW HL, #lwrd(__low_level_init)
CALL ?FAR_CALL_L07
#else
CALL __low_level_init
#endif
OR A, X
#if __CORE__ == __78K0R__
SKNZ
BR N:__MAIN_CALL
#else
BZ __MAIN_CALL
#endif
ENDMOD
#if defined(__NEAR_MODEL__) || defined(__FAR_MODEL__)
;------------------------------------------------------------------------------
; Segment initialization
;
; FAR_Z "uninitialized far data" are filled with zero
;------------------------------------------------------------------------------
MODULE ?__INIT_FAR_Z
RSEG FAR_Z:DATA(0)
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __INIT_FAR_Z
__INIT_FAR_Z:
MOV ES, #BYTE3(sfb(FAR_Z))
MOVW HL, #LWRD(sfb(FAR_Z))
MOV D, #BYTE3(sizeof(FAR_Z))
MOVW BC, #LWRD(sizeof(FAR_Z))
CMP0 C
SKZ
INC B
CMP0 B
SKZ
INC D
CLRB A
loop:
MOV ES:[HL], A
INCW HL
MOV A, H
OR A, L
CLRB A
SKNZ
INC ES
DEC C
BNZ loop
DEC B
BNZ loop
DEC D
BNZ loop
ENDMOD
#endif
;------------------------------------------------------------------------------
; Segment initialization
;
; NEAR_Z "uninitialized near data" are filled with zero
;------------------------------------------------------------------------------
MODULE ?__INIT_NEAR_Z
RSEG NEAR_Z:DATA(0)
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __INIT_NEAR_Z
__INIT_NEAR_Z:
#if __CORE__ == __78K0R__
LIMIT sfb(NEAR_Z)>=0xF0000,1,1,"NEAR_I not placed in near memory"
#endif
MOVW HL, #sfb(NEAR_Z)
MOVW BC, #sizeof(NEAR_Z)
#if __CORE__ == __78K0R__
CMP0 C
SKZ
INC B
CLRB A
#else
MOV A, C
OR A, A
BZ cont
INC B
XOR A, A
cont:
#endif
loop:
MOV [HL], A
INCW HL
#if __CORE__ == __78K0R__
DEC C
BNZ loop
DEC B
BNZ loop
#else
DBNZ C, loop
DBNZ B, loop
#endif
ENDMOD
;------------------------------------------------------------------------------
; Segment initialization
;
; SADDR_Z "uninitialized saddr data" are filled with zero
;------------------------------------------------------------------------------
MODULE ?__INIT_SADDR_Z
RSEG SADDR_Z:DATA(0)
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __INIT_SADDR_Z
__INIT_SADDR_Z:
#if __CORE__ == __78K0R__
LIMIT sfb(SADDR_Z),0xFFE20,0xFFF1F,"SADDR_Z not within saddr memory range"
LIMIT sfe(SADDR_Z),0xFFE20,0xFFF1F,"SADDR_Z not within saddr memory range"
#else
LIMIT sfb(SADDR_Z),0xFE20,0xFF1F,"SADDR_Z not within saddr memory range"
LIMIT sfe(SADDR_Z),0xFE20,0xFF1F,"SADDR_Z not within saddr memory range"
#endif
MOVW HL, #sfb(SADDR_Z)
MOV B, #sizeof(SADDR_Z)
#if __CORE__ == __78K0R__
CLRB A
#else
XOR A, A
#endif
loop:
MOV [HL], A
INCW HL
#if __CORE__ == __78K0R__
DEC B
BNZ loop
#else
DBNZ B, loop
#endif
ENDMOD
;------------------------------------------------------------------------------
; Segment initialization
;
; WRKSEG short address work area is filled with zero
;------------------------------------------------------------------------------
MODULE ?__INIT_WRKSEG
RSEG WRKSEG:DATA(0)
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __INIT_WRKSEG
__INIT_WRKSEG:
#if __CORE__ == __78K0R__
LIMIT sfb(WRKSEG),0xFFE20,0xFFF1F,"WRKSEG not within saddr memory range"
LIMIT sfe(WRKSEG),0xFFE20,0xFFF1F,"WRKSEG not within saddr memory range"
#else
LIMIT sfb(WRKSEG),0xFE20,0xFF1F,"WRKSEG not within saddr memory range"
LIMIT sfe(WRKSEG),0xFE20,0xFF1F,"WRKSEG not within saddr memory range"
#endif
MOVW HL, #sfb(WRKSEG)
MOV B, #sizeof(WRKSEG)
#if __CORE__ == __78K0R__
CLRB A
#else
XOR A, A
#endif
loop:
MOV [HL], A
INCW HL
#if __CORE__ == __78K0R__
DEC B
BNZ loop
#else
DBNZ B, loop
#endif
ENDMOD
#if defined(__NEAR_MODEL__) || defined(__FAR_MODEL__)
;------------------------------------------------------------------------------
; Segment initialization
;
; FAR_ID is copied to FAR_I "initialized far data"
;------------------------------------------------------------------------------
MODULE ?__INIT_FAR_I
RSEG FAR_I:DATA(0)
RSEG FAR_ID:DATA(0)
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __INIT_FAR_I
__INIT_FAR_I:
; First make sure FAR_I and FAR_ID have the same size
LIMIT sizeof(FAR_I)-sizeof(FAR_ID),0,0,"FAR_I and FAR_ID not same size"
; Sanity check
LIMIT (sfb(FAR_I)-sfb(FAR_ID))==0,0,0,"FAR_I and FAR_ID have same start address"
; FAR_I and FAR_ID must start at the same offset in a 64k page, unless sizeof
; FAR_I is less than 64k, then it's enugh if both segments reside within a 64k
; boundary
LIMIT (((sfb(FAR_I)^sfb(FAR_ID)) & 0xFFFF) == 0) || ( (sizeof(FAR_I)< 0x10000) && (((sfb(FAR_I)^sfe(FAR_I)) & 0xF0000) == 0) && (((sfb(FAR_I)^sfe(FAR_I)) & 0xF0000) == 0) ),1,1,"FAR_I and FAR_ID have same start address"
; LIMIT (sfb(FAR_I)^sfb(FAR_ID)) & 0xFFFF,0,0,"FAR_I and FAR_ID must start at the same offset into a 64k page"
MOV ES, #BYTE3(sfb(FAR_ID))
MOVW HL, #LWRD(sfb(FAR_ID))
MOV CS, #BYTE3(sizeof(FAR_ID)) ; CS is used as counter
MOVW AX, #LWRD(sizeof(FAR_ID))
MOVW BC, AX
CMP0 C
SKZ
INC B
CMP0 B
SKZ
INC CS ; counter
MOV A, #BYTE3(sfb(FAR_I))
MOVW DE, #LWRD(sfb(FAR_I))
MOV X, A
loop:
MOV A, ES:[HL]
XCH A, X
XCH A, ES
XCH A, X
MOV ES:[DE], A
XCH A, X
XCH A, ES
XCH A, X
INCW HL
MOV A, H
OR A, L
SKNZ
INC ES
INCW DE
MOV A, D
OR A, E
SKNZ
INC X
DEC C
BNZ loop
DEC B
BNZ loop
DEC CS ; counter
BNZ loop
ENDMOD
#endif
;------------------------------------------------------------------------------
; Segment initialization
;
; NEAR_ID is copied to NEAR_I "initialized near data"
;------------------------------------------------------------------------------
MODULE ?__INIT_NEAR_I
RSEG NEAR_I:DATA(0)
RSEG NEAR_ID:DATA(0)
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __INIT_NEAR_I
__INIT_NEAR_I:
#if __CORE__ == __78K0R__
LIMIT sfb(NEAR_I)>=0xF0000,1,1,"NEAR_I not placed in near memory"
#endif
LIMIT sizeof(NEAR_I)-sizeof(NEAR_ID),0,0,"NEAR_I and NEAR_ID not same size"
#if __CORE__ == __78K0R__
MOV ES, #BYTE3(sfb(NEAR_ID))
#endif
MOVW HL, #sfb(NEAR_ID)
MOVW BC, #sizeof(NEAR_ID)
#if __CORE__ == __78K0R__
CMP0 C
SKZ
INC B
#else
MOV A, C
OR A, A
BZ cont
INC B
cont:
#endif
MOVW DE, #sfb(NEAR_I)
loop:
#if __CORE__ != __78K0R__
MOV A, [HL]
#else
MOV A, ES:[HL]
#endif
MOV [DE], A
INCW HL
INCW DE
#if __CORE__ == __78K0R__
DEC C
BNZ loop
DEC B
BNZ loop
#else
DBNZ C, loop
DBNZ B, loop
#endif
ENDMOD
;------------------------------------------------------------------------------
; Segment initialization
;
; SADDR_ID is copied to SADDR_I "initialized saddr data"
;------------------------------------------------------------------------------
MODULE ?__INIT_SADDR_I
RSEG SADDR_I:DATA(0)
RSEG SADDR_ID:DATA(0)
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __INIT_SADDR_I
__INIT_SADDR_I:
#if __CORE__ == __78K0R__
LIMIT sfb(SADDR_I),0xFFE20,0xFFF1F,"SADDR_I not within saddr memory range"
LIMIT sfe(SADDR_I),0xFFE20,0xFFF1F,"SADDR_I not within saddr memory range"
#else
LIMIT sfb(SADDR_I),0xFE20,0xFF1F,"SADDR_I not within saddr memory range"
LIMIT sfe(SADDR_I),0xFE20,0xFF1F,"SADDR_I not within saddr memory range"
#endif
LIMIT sizeof(SADDR_I)-sizeof(SADDR_ID),0,0,"SADDR_I and SADDR_ID not same size"
#if __CORE__ == __78K0R__
MOV ES, #BYTE3(sfb(SADDR_ID))
#endif
MOVW HL, #sfb(SADDR_ID)
MOV B, #sizeof(SADDR_ID)
MOVW DE, #sfb(SADDR_I)
loop:
#if __CORE__ != __78K0R__
MOV A, [HL]
#else
MOV A, ES:[HL]
#endif
MOV [DE], A
INCW HL
INCW DE
#if __CORE__ == __78K0R__
DEC B
BNZ loop
#else
DBNZ B, loop
#endif
ENDMOD
;------------------------------------------------------------------------------
; Initialize constructors
;
; This segment part is required by the compiler when it is
; necessary to call constructors of global objects.
;------------------------------------------------------------------------------
MODULE ?__INIT_CTORS
RSEG DIFUNCT(0)
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __INIT_CTORS
EXTERN __call_ctors
#if defined(__BANKED_MODEL__)
EXTERN ?FAR_CALL_L07
#endif
__INIT_CTORS:
#if __CORE__ == __78K0R__
MOV X, #byte3(sfe(DIFUNCT))
PUSH AX
MOVW AX, #lwrd(sfe(DIFUNCT))
PUSH AX
MOV X, #byte3(sfb(DIFUNCT))
PUSH AX
MOVW AX, #lwrd(sfb(DIFUNCT))
PUSH AX
CALL F:__call_ctors
#elif defined(__BANKED_MODEL__)
MOVW AX, #sfb(DIFUNCT)
MOVW BC, #sfe(DIFUNCT)
MOV E, #byte3(__call_ctors)
MOVW HL, #lwrd(__call_ctors)
CALL ?FAR_CALL_L07
#else
MOVW AX, #sfb(DIFUNCT)
MOVW BC, #sfe(DIFUNCT)
CALL __call_ctors
#endif
ENDMOD
;------------------------------------------------------------------------------
; Enter main
;
; Call the actual "main" function
;------------------------------------------------------------------------------
MODULE ?__MAIN_CALL
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __MAIN_CALL
PUBLIC `@cend` ; NEC debugger specific
EXTERN main
EXTERN exit
#if defined(__BANKED_MODEL__)
EXTERN ?FAR_CALL_L07
#endif
__MAIN_CALL:
#if defined(__FAR_MODEL__)
CALL F:main
CALL F:exit
#elif defined(__BANKED_MODEL__)
MOV E, #byte3(main)
MOVW HL, #lwrd(main)
CALL ?FAR_CALL_L07
MOV E, #byte3(exit)
MOVW HL, #lwrd(exit)
CALL ?FAR_CALL_L07
#else
CALL main
CALL exit
#endif
`@cend`:
; STOP ; Should not return
ENDMOD
;------------------------------------------------------------------------------
; Low level initialization function
;
; Entry: __low_level_init
;
; The only action of this default version of '__low_level_init' is to
; return 1. By doing so it signals that normal initialization of data
; segments should be done.
;
; A customized version of '__low_level_init' may be created in order to
; perform initialization before initializing segments and calling main
; and/or to skip initialization of data segments under certain
; circumstances.
;------------------------------------------------------------------------------
MODULE ?__low_level_init_stub
RSEG RCODE:CODE:NOROOT(0)
PUBLIC __low_level_init
__low_level_init: ; By returning 1 this function
MOVW AX, #1 ; indicates that the normal
RET ; initialization should take place
ENDMOD
END
Go to most recent revision | Compare with Previous | Blame | View Log