| /****************************************************************************** | |
| FILE : datapage.c | |
| PURPOSE : paged data access runtime routines | |
| MACHINE : Motorola 68HC12 (Target) | |
| LANGUAGE : ANSI-C | |
| HISTORY : 21.7.96 first version created | |
| ******************************************************************************/ | |
| /* | |
| According to the -Cp option of the compiler the | |
| __DPAGE__, __PPAGE__ and __EPAGE__ macros are defined. | |
| If none of them is given as argument, then no page accesses should occur and | |
| this runtime routine should not be used ! | |
| To be on the save side, the runtime routines are created anyway. | |
| If some of the -Cp options are given an adapted versions which only covers the | |
| needed cases is produced. | |
| */ | |
| /* if no compiler option -Cp is given, it is assumed that all possible are given : */ | |
| /* Compile with option -DHCS12 to activate this code */ | |
| #if defined(HCS12) || defined(_HCS12) /* HCS12 family has PPAGE register only at 0x30 */ | |
| #define PPAGE_ADDR (0x30+REGISTER_BASE) | |
| #ifndef __PPAGE__ /* may be set already by option -CPPPAGE */ | |
| #define __PPAGE__ | |
| #endif | |
| /* Compile with option -DDG128 to activate this code */ | |
| #elif defined DG128 /* HC912DG128 derivative has PPAGE register only at 0xFF */ | |
| #define PPAGE_ADDR (0xFF+REGISTER_BASE) | |
| #ifndef __PPAGE__ /* may be set already by option -CPPPAGE */ | |
| #define __PPAGE__ | |
| #endif | |
| #elif defined(HC812A4) | |
| /* all setting default to A4 already */ | |
| #endif | |
| #if !defined(__EPAGE__) && !defined(__PPAGE__) && !defined(__DPAGE__) | |
| /* as default use all page registers */ | |
| #define __DPAGE__ | |
| #define __EPAGE__ | |
| #define __PPAGE__ | |
| #endif | |
| /* modify the following defines to your memory configuration */ | |
| #define EPAGE_LOW_BOUND 0x400u | |
| #define EPAGE_HIGH_BOUND 0x7ffu | |
| #define DPAGE_LOW_BOUND 0x7000u | |
| #define DPAGE_HIGH_BOUND 0x7fffu | |
| #define PPAGE_LOW_BOUND (DPAGE_HIGH_BOUND+1) | |
| #define PPAGE_HIGH_BOUND 0xBFFFu | |
| #define REGISTER_BASE 0x0u | |
| #ifndef DPAGE_ADDR | |
| #define DPAGE_ADDR (0x34u+REGISTER_BASE) | |
| #endif | |
| #ifndef EPAGE_ADDR | |
| #define EPAGE_ADDR (0x36u+REGISTER_BASE) | |
| #endif | |
| #ifndef PPAGE_ADDR | |
| #define PPAGE_ADDR (0x35u+REGISTER_BASE) | |
| #endif | |
| /* | |
| The following parts about the defines are assumed in the code of _GET_PAGE_REG : | |
| - the memory region controlled by DPAGE is above the area controlled by the EPAGE and | |
| below the area controlled by the PPAGE. | |
| - the lower bound of the PPAGE area is equal to be the higher bound of the DPAGE area + 1 | |
| */ | |
| #if EPAGE_LOW_BOUND >= EPAGE_HIGH_BOUND || EPAGE_HIGH_BOUND >= DPAGE_LOW_BOUND || DPAGE_LOW_BOUND >= DPAGE_HIGH_BOUND || DPAGE_HIGH_BOUND >= PPAGE_LOW_BOUND || PPAGE_LOW_BOUND >= PPAGE_HIGH_BOUND | |
| #error /* please adapt _GET_PAGE_REG for this non default page configuration */ | |
| #endif | |
| #if DPAGE_HIGH_BOUND+1 != PPAGE_LOW_BOUND | |
| #error /* please adapt _GET_PAGE_REG for this non default page configuration */ | |
| #endif | |
| #include "hidef.h" | |
| #include "non_bank.sgm" | |
| #include "runtime.sgm" | |
| /* this module does either control if any access is in the bounds of the specified page or */ | |
| /* ,if only one page is specified, just use this page. */ | |
| /* This behavior is controlled by the define USE_SEVERAL_PAGES. */ | |
| /* If !USE_SEVERAL_PAGES does increase the performance significantly */ | |
| /* NOTE : When !USE_SEVERAL_PAGES, the page is also set for accesses outside of the area controlled */ | |
| /* by this single page. But this is usually no problem because the page is set again before any other access */ | |
| #if !defined(__DPAGE__) && !defined(__EPAGE__) && !defined(__PPAGE__) | |
| /* no page at all is specified */ | |
| /* only specifing the right pages will speed up these functions a lot */ | |
| #define USE_SEVERAL_PAGES 1 | |
| #elif defined(__DPAGE__) && defined(__EPAGE__) || defined(__DPAGE__) && defined(__PPAGE__) || defined(__EPAGE__) && defined(__PPAGE__) | |
| /* more than one page register is used */ | |
| #define USE_SEVERAL_PAGES 1 | |
| #else | |
| #define USE_SEVERAL_PAGES 0 | |
| #if defined(__DPAGE__) /* check which pages are used */ | |
| #define PAGE_ADDR PPAGE_ADDR | |
| #elif defined(__EPAGE__) | |
| #define PAGE_ADDR EPAGE_ADDR | |
| #elif defined(__PPAGE__) | |
| #define PAGE_ADDR PPAGE_ADDR | |
| #else /* we dont know which page, decide it at runtime */ | |
| #error /* must not happen */ | |
| #endif | |
| #endif | |
| #if USE_SEVERAL_PAGES /* only needed for several pages support */ | |
| /*--------------------------- _GET_PAGE_REG -------------------------------- | |
| Runtime routine to detect the right register depending on the 16 bit offset part | |
| of an address. | |
| This function is only used by the functions below. | |
| Depending on the compiler options -Cp different versions of _GET_PAGE_REG are produced. | |
| Arguments : | |
| - Y : offset part of an address | |
| Result : | |
| if address Y is controlled by a page register : | |
| - X : address of page register if Y is controlled by an page register | |
| - Zero flag cleared | |
| - all other registers remain unchanged | |
| if address Y is not controlled by a page register : | |
| - Zero flag is set | |
| - all registers remain unchanged | |
| --------------------------- _GET_PAGE_REG ----------------------------------*/ | |
| #if defined(__DPAGE__) | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| static void NEAR _GET_PAGE_REG(void) { /*lint -esym(528, _GET_PAGE_REG) used in asm code */ | |
| asm { | |
| L_DPAGE: | |
| CPY #DPAGE_LOW_BOUND ; test of lower bound of DPAGE | |
| #if defined(__EPAGE__) | |
| BLO L_EPAGE ; EPAGE accesses are possible | |
| #else | |
| BLO L_NOPAGE ; no paged memory below accesses | |
| #endif | |
| CPY #DPAGE_HIGH_BOUND ; test of higher bound DPAGE/lower bound PPAGE | |
| #if defined(__PPAGE__) | |
| BHI L_PPAGE ; EPAGE accesses are possible | |
| #else | |
| BHI L_NOPAGE ; no paged memory above accesses | |
| #endif | |
| FOUND_DPAGE: | |
| LDX #DPAGE_ADDR ; load page register address and clear zero flag | |
| RTS | |
| #if defined(__PPAGE__) | |
| L_PPAGE: | |
| CPY #PPAGE_HIGH_BOUND ; test of higher bound of PPAGE | |
| BHI L_NOPAGE | |
| FOUND_PPAGE: | |
| LDX #PPAGE_ADDR ; load page register address and clear zero flag | |
| RTS | |
| #endif | |
| #if defined(__EPAGE__) | |
| L_EPAGE: | |
| CPY #EPAGE_LOW_BOUND ; test of lower bound of EPAGE | |
| BLO L_NOPAGE | |
| CPY #EPAGE_HIGH_BOUND ; test of higher bound of EPAGE | |
| BHI L_NOPAGE | |
| FOUND_EPAGE: | |
| LDX #EPAGE_ADDR ; load page register address and clear zero flag | |
| RTS | |
| #endif | |
| L_NOPAGE: | |
| ORCC #0x04 ; sets zero flag | |
| RTS | |
| } | |
| } | |
| #else /* !defined(__DPAGE__) */ | |
| #if defined( __PPAGE__ ) | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| static void NEAR _GET_PAGE_REG(void) { /*lint -esym(528, _GET_PAGE_REG) used in asm code */ | |
| asm { | |
| L_PPAGE: | |
| CPY #PPAGE_LOW_BOUND ; test of lower bound of PPAGE | |
| #if defined( __EPAGE__ ) | |
| BLO L_EPAGE | |
| #else | |
| BLO L_NOPAGE ; no paged memory below | |
| #endif | |
| CPY #PPAGE_HIGH_BOUND ; test of higher bound PPAGE | |
| BHI L_NOPAGE | |
| FOUND_PPAGE: | |
| LDX #PPAGE_ADDR ; load page register address and clear zero flag | |
| RTS | |
| #if defined( __EPAGE__ ) | |
| L_EPAGE: | |
| CPY #EPAGE_LOW_BOUND ; test of lower bound of EPAGE | |
| BLO L_NOPAGE | |
| CPY #EPAGE_HIGH_BOUND ; test of higher bound of EPAGE | |
| BHI L_NOPAGE | |
| FOUND_EPAGE: | |
| LDX #EPAGE_ADDR ; load page register address and clear zero flag | |
| RTS | |
| #endif | |
| L_NOPAGE: ; not in any allowed page area | |
| ; its a far access to a non paged variable | |
| ORCC #0x04 ; sets zero flag | |
| RTS | |
| } | |
| } | |
| #else /* !defined(__DPAGE__ ) && !defined( __PPAGE__) */ | |
| #if defined(__EPAGE__) | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| static void NEAR _GET_PAGE_REG(void) { /*lint -esym(528, _GET_PAGE_REG) used in asm code */ | |
| asm { | |
| L_EPAGE: | |
| CPY #EPAGE_LOW_BOUND ; test of lower bound of EPAGE | |
| BLO L_NOPAGE | |
| CPY #EPAGE_HIGH_BOUND ; test of higher bound of EPAGE | |
| BHI L_NOPAGE | |
| FOUND_EPAGE: | |
| LDX #EPAGE_ADDR ; load page register address and clear zero flag | |
| RTS | |
| L_NOPAGE: ; not in any allowed page area | |
| ; its a far access to a non paged variable | |
| ORCC #0x04 ; sets zero flag | |
| RTS | |
| } | |
| } | |
| #endif /* defined(__EPAGE__) */ | |
| #endif /* defined(__PPAGE__) */ | |
| #endif /* defined(__DPAGE__) */ | |
| #endif /* USE_SEVERAL_PAGES */ | |
| /*--------------------------- _SET_PAGE -------------------------------- | |
| Runtime routine to set the right page register. This routine is used if the compiler | |
| does not know the right page register, i.e. if the option -Cp is used for more than | |
| one pageregister or if the runtime option is used for one of the -Cp options. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address in the B register | |
| Result : | |
| - page part written into the correct page register. | |
| - the old page register content is destroyed | |
| - all processor registers remains unchanged | |
| --------------------------- _SET_PAGE ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _SET_PAGE(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| STAB 0,X ; set page register | |
| L_NOPAGE: | |
| PULX ; restore X register | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| STAB PAGE_ADDR ; set page register | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _LOAD_FAR_8 -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address in the B register | |
| Result : | |
| - value to be read in the B register | |
| - all other registers remains unchanged | |
| - all page register still contain the same value | |
| --------------------------- _LOAD_FAR_8 ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _LOAD_FAR_8(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| PSHA ; save A register | |
| LDAA 0,X ; save page register | |
| STAB 0,X ; set page register | |
| LDAB 0,Y ; actual load, overwrites page | |
| STAA 0,X ; restore page register | |
| PULA ; restore A register | |
| PULX ; restore X register | |
| RTS | |
| L_NOPAGE: | |
| LDAB 0,Y ; actual load, overwrites page | |
| PULX ; restore X register | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| PSHA ; save A register | |
| LDAA PAGE_ADDR ; save page register | |
| STAB PAGE_ADDR ; set page register | |
| LDAB 0,Y ; actual load, overwrites page | |
| STAA PAGE_ADDR ; restore page register | |
| PULA ; restore A register | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _LOAD_FAR_16 -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address in the B register | |
| Result : | |
| - value to be read in the Y register | |
| - all other registers remains unchanged | |
| - all page register still contain the same value | |
| --------------------------- _LOAD_FAR_16 ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _LOAD_FAR_16(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| PSHA ; save A register | |
| LDAA 0,X ; save page register | |
| STAB 0,X ; set page register | |
| LDY 0,Y ; actual load, overwrites address | |
| STAA 0,X ; restore page register | |
| PULA ; restore A register | |
| PULX ; restore X register | |
| RTS | |
| L_NOPAGE: | |
| LDY 0,Y ; actual load, overwrites address | |
| PULX ; restore X register | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| PSHA ; save A register | |
| LDAA PAGE_ADDR ; save page register | |
| STAB PAGE_ADDR ; set page register | |
| LDY 0,Y ; actual load, overwrites address | |
| STAA PAGE_ADDR ; restore page register | |
| PULA ; restore A register | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _LOAD_FAR_24 -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address in the B register | |
| Result : | |
| - value to be read in the Y:B registers | |
| - all other registers remains unchanged | |
| - all page register still contain the same value | |
| --------------------------- _LOAD_FAR_24 ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _LOAD_FAR_24(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| PSHA ; save A register | |
| LDAA 0,X ; save page register | |
| STAB 0,X ; set page register | |
| LDAB 0,Y ; actual load, overwrites page of address | |
| LDY 1,Y ; actual load, overwrites offset of address | |
| STAA 0,X ; restore page register | |
| PULA ; restore A register | |
| PULX ; restore X register | |
| RTS | |
| L_NOPAGE: | |
| LDAB 0,Y ; actual load, overwrites page of address | |
| LDY 1,Y ; actual load, overwrites offset of address | |
| PULX ; restore X register | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| PSHA ; save A register | |
| LDAA PAGE_ADDR ; save page register | |
| STAB PAGE_ADDR ; set page register | |
| LDAB 0,Y ; actual load, overwrites page of address | |
| LDY 1,Y ; actual load, overwrites offset of address | |
| STAA PAGE_ADDR ; restore page register | |
| PULA ; restore A register | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _LOAD_FAR_32 -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address in the B register | |
| Result : | |
| - low 16 bit of value to be read in the D registers | |
| - high 16 bit of value to be read in the Y registers | |
| - all other registers remains unchanged | |
| - all page register still contain the same value | |
| --------------------------- _LOAD_FAR_32 ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _LOAD_FAR_32(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| LDAA 0,X ; save page register | |
| PSHA ; put it onto the stack | |
| STAB 0,X ; set page register | |
| LDD 2,Y ; actual load, low word | |
| LDY 0,Y ; actual load, high word | |
| MOVB 1,SP+,0,X ; restore page register | |
| PULX ; restore X register | |
| RTS | |
| L_NOPAGE: | |
| LDD 2,Y ; actual load, low word | |
| LDY 0,Y ; actual load, high word | |
| PULX ; restore X register | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| LDAA PAGE_ADDR ; save page register | |
| PSHA ; put it onto the stack | |
| STAB PAGE_ADDR ; set page register | |
| LDD 2,Y ; actual load, low word | |
| LDY 0,Y ; actual load, high word | |
| MOVB 1,SP+,PAGE_ADDR; restore page register | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _STORE_FAR_8 -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address in the B register | |
| - value to be stored in the B register | |
| Result : | |
| - value stored at the address | |
| - all registers remains unchanged | |
| - all page register still contain the same value | |
| --------------------------- _STORE_FAR_8 ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _STORE_FAR_8(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| PSHB ; save B register | |
| LDAB 0,X ; save page register | |
| MOVB 0,SP, 0,X ; set page register | |
| STAA 0,Y ; store the value passed in A | |
| STAB 0,X ; restore page register | |
| PULB ; restore B register | |
| PULX ; restore X register | |
| RTS | |
| L_NOPAGE: | |
| STAA 0,Y ; store the value passed in A | |
| PULX ; restore X register | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| PSHB ; save A register | |
| LDAB PAGE_ADDR ; save page register | |
| MOVB 0,SP,PAGE_ADDR ; set page register | |
| STAA 0,Y ; store the value passed in A | |
| STAB PAGE_ADDR ; restore page register | |
| PULB ; restore B register | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _STORE_FAR_16 -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address in the B register | |
| - value to be stored in the X register | |
| Result : | |
| - value stored at the address | |
| - all registers remains unchanged | |
| - all page register still contain the same value | |
| --------------------------- _STORE_FAR_16 ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _STORE_FAR_16(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| PSHA | |
| LDAA 0,X ; save page register | |
| STAB 0,X ; set page register | |
| MOVW 1,SP, 0,Y ; store the value passed in X | |
| STAA 0,X ; restore page register | |
| PULA ; restore A register | |
| PULX ; restore X register | |
| RTS | |
| L_NOPAGE: | |
| STX 0,Y ; store the value passed in X | |
| PULX ; restore X register | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| PSHA ; save A register | |
| LDAA PAGE_ADDR ; save page register | |
| STAB PAGE_ADDR ; set page register | |
| STX 0,Y ; store the value passed in X | |
| STAA PAGE_ADDR ; restore page register | |
| PULA ; restore A register | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _STORE_FAR_24 -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address in the B register | |
| - value to be stored in the X:A registers (X : low 16 bit, A : high 8 bit) | |
| Result : | |
| - value stored at the address | |
| - all registers remains unchanged | |
| - all page register still contain the same value | |
| --------------------------- _STORE_FAR_24 ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _STORE_FAR_24(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| PSHA | |
| LDAA 0,X ; save page register | |
| STAB 0,X ; set page register | |
| MOVW 1,SP, 1,Y ; store the value passed in X | |
| MOVB 0,SP, 0,Y ; store the value passed in A | |
| STAA 0,X ; restore page register | |
| PULA ; restore A register | |
| PULX ; restore X register | |
| RTS | |
| L_NOPAGE: | |
| STX 1,Y ; store the value passed in X | |
| STAA 0,Y ; store the value passed in X | |
| PULX ; restore X register | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| PSHA ; save A register | |
| LDAA PAGE_ADDR ; save page register | |
| STAB PAGE_ADDR ; set page register | |
| MOVB 0,SP, 0,Y ; store the value passed in A | |
| STX 1,Y ; store the value passed in X | |
| STAA PAGE_ADDR ; restore page register | |
| PULA ; restore A register | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _STORE_FAR_32 -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of an address in the Y register | |
| - page part of an address is on the stack at 3,SP (just below the return address) | |
| - value to be stored in the X:D registers (D : low 16 bit, X : high 16 bit) | |
| Result : | |
| - value stored at the address | |
| - all registers remains unchanged | |
| - the page part is removed from the stack | |
| - all page register still contain the same value | |
| --------------------------- _STORE_FAR_32 ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _STORE_FAR_32(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| PSHX ; save X register | |
| __PIC_JSR(_GET_PAGE_REG) | |
| BEQ L_NOPAGE | |
| PSHD | |
| LDAA 0,X ; save page register | |
| MOVB 6,SP, 0,X ; set page register | |
| MOVW 2,SP, 0,Y ; store the value passed in X (high word) | |
| MOVW 0,SP, 2,Y ; store the value passed in D (low word) | |
| STAA 0,X ; restore page register | |
| PULD ; restore A register | |
| BRA done | |
| L_NOPAGE: | |
| MOVW 0,SP, 0,Y ; store the value passed in X (high word) | |
| STD 2,Y ; store the value passed in D (low word) | |
| done: | |
| PULX ; restore X register | |
| MOVW 0,SP, 1,+SP ; move return address | |
| RTS | |
| } | |
| #else /* USE_SEVERAL_PAGES */ | |
| asm { | |
| PSHD ; save D register | |
| LDAA PAGE_ADDR ; save page register | |
| LDAB 4,SP ; load page part of address | |
| STAB PAGE_ADDR ; set page register | |
| STX 0,Y ; store the value passed in X | |
| MOVW 0,SP, 2,Y ; store the value passed in D (low word) | |
| STAA PAGE_ADDR ; restore page register | |
| PULD ; restore D register | |
| MOVW 0,SP, 1,+SP ; move return address | |
| RTS | |
| } | |
| #endif /* USE_SEVERAL_PAGES */ | |
| } | |
| /*--------------------------- _FAR_COPY -------------------------------- | |
| This runtime routine is used to access paged memory via a runtime function. | |
| It may also be used if the compiler option -Cp is not used with the runtime argument. | |
| Arguments : | |
| - offset part of the source int the X register | |
| - page part of the source in the A register | |
| - offset part of the dest int the Y register | |
| - page part of the dest in the B register | |
| - number of bytes to be copied at 2,SP. The number of bytes is always > 0 | |
| Result : | |
| - memory area copied | |
| - no registers are saved, i.e. all registers may be destroied | |
| - all page register still contain the same value | |
| stack-structure at the loop-label: | |
| 0,SP : destination offset | |
| 2,SP : source page | |
| 3,SP : destination page | |
| 4,SP : source offset | |
| 6,SP : return address | |
| 8,SP : counter, > 0 | |
| --------------------------- _FAR_COPY ----------------------------------*/ | |
| #ifdef __cplusplus | |
| extern "C" | |
| #endif | |
| #pragma NO_ENTRY | |
| #pragma NO_EXIT | |
| #pragma NO_FRAME | |
| void NEAR _FAR_COPY(void) { | |
| #if USE_SEVERAL_PAGES | |
| asm { | |
| DEX ; source addr-=1, because loop counter ends at 1 | |
| PSHX ; save source offset | |
| PSHD ; save both pages | |
| DEY ; destination addr-=1, because loop counter ends at 1 | |
| PSHY ; save destination offset | |
| LDX 8,SP ; load counter, assuming counter > 0 | |
| loop: | |
| LDD 4,SP ; load source offset | |
| LEAY D,X ; calcutate actual source address | |
| LDAB 2,SP ; load source page | |
| __PIC_JSR (_LOAD_FAR_8); load 1 source byte | |
| PSHB ; save value | |
| LDD 0+1,SP ; load destination offset | |
| LEAY D,X ; calcutate acual destination address | |
| PULA ; restore value | |
| LDAB 3,SP ; load destination page | |
| __PIC_JSR (_STORE_FAR_8); store one byte | |
| DEX | |
| BNE loop | |
| LDX 6,SP ; load return address | |
| LEAS 10,SP ; release stack | |
| JMP 0,X ; return | |
| } | |
| #else | |
| asm { | |
| PSHD ; store page registers | |
| TFR X,D | |
| ADDD 4,SP ; calculate source end address | |
| STD 4,SP | |
| PULB ; reload source page | |
| LDAA PAGE_ADDR ; save page register | |
| PSHA | |
| loop: | |
| STAB PAGE_ADDR ; set source page | |
| LDAA 1,X+ ; load value | |
| MOVB 1,SP, PAGE_ADDR ; set destination page | |
| STAA 1,Y+ | |
| CPX 4,SP | |
| BNE loop | |
| LDAA 2,SP+ ; restore old page value and release stack | |
| STAA PAGE_ADDR ; store it into page register | |
| LDX 4,SP+ ; release stack and load return address | |
| JMP 0,X ; return | |
| } | |
| #endif | |
| } | |