l51_bank.a51

Keil uVision2

CNT             SET     CNT+1
                ENDM
ENDIF  ; close block IF ?B_MODE = 4 *******************************************


IF ?B_VAR_BANKING  ;***********************************************************

;******************************************************************************
;                                                                             *
; THEORY OF OPERATION                                                         *
; -------------------                                                         *
; This section describes how the extended LX51 linker/locater manages the     *
; extended address spaces that are addressed with the new C51 memory types    *
; 'far' and 'far const'.  The C51 Compiler uses 3 byte pointer generic        *
; pointer to access these memory areas.  'far' variables are placed in the    *
; memory class HDATA and 'far const' variables get the memory class 'HCONST'. *
; The LX51 linker/locater allows you to locate these memory classes in the    *
; logical 16 MBYTE CODE or 16 MBYTE XDATA spaces.                             *
;                                                                             *
; The memory access itself is performed via eight different subroutines that  *
; can be configured in this assembler module.  These routines are:            *
;    ?C?CLDXPTR, ?C?CSTXPTR  ; load/store BYTE (char)  in extended memory     *
;    ?C?ILDXPTR, ?C?ISTXPTR  ; load/store WORD (int)   in extended memory     *
;    ?C?PLDXPTR, ?C?PSTXPTR  ; load/store 3-BYTE PTR   in extended memory     *
;    ?C?LLDXPTR, ?C?LSTXPTR  ; load/store DWORD (long) in extended memory     *
;                                                                             *
; Each function gets as a parameter the memory address with 3 BYTE POINTER    *
; representation in the CPU registers R1/R2/R3.  The register R3 holds the    *
; memory type.  The C51 compiler uses the following memory types:             *
;                                                                             *
; R3 Value | Memory Type | Memory Class | Address Range                       *
; -----------------------+--------------+--------------------------           *
;    00    | data/idata  | DATA/IDATA   | I:0x00     .. I:0xFF                *
;    01    | xdata       | XDATA        | X:0x0000   .. X:0xFFFF              *
;  02..7F  | far         | HDATA        | X:0x010000 .. X:0x7E0000            *
;  80..FD  | far const   | HCONST       | C:0x800000 .. C:0xFD0000 (see note) *
;    FE    | pdata       | XDATA        | one 256-byte page in XDATA memory   *
;    FF    | code        | CODE         | C:0x0000   .. C:0xFFFF              *
;                                                                             *
; Note: the far const memory area is mapped into the banked memory areas.     *
;                                                                             *
; The R3 values 00, 01, FE and FF are already handled within the C51 run-time *
; library.  Only the values 02..FE are passed to the XPTR access functions    *
; described below.  The AX51 macro assembler provides the MBYTE operator      *
; that calculates the R3 value that needs to be passed to the XPTR access     *
; function.   AX51 Assembler example for using XPTR access functions:         *
;     MOV  R1,#LOW   (variable)   ; gives LSB address byte of variable        *
;     MOV  R1,#HIGH  (variable)   ; gives MSB address byte of variable        *
;     MOV  R1,#MBYTE (variable)   ; gives memory type byte of variable        *
;     CALL ?C?CLDXPTR             ; load BYTE variable into A                 *
;******************************************************************************

PUBLIC ?C?CLDXPTR, ?C?CSTXPTR, ?C?ILDXPTR, ?C?ISTXPTR
PUBLIC ?C?PLDXPTR, ?C?PSTXPTR, ?C?LLDXPTR, ?C?LSTXPTR

?C?LIB_CODE     SEGMENT CODE
                RSEG    ?C?LIB_CODE


IF  ?B_MODE = 0 OR ?B_MODE = 1   ;*********************************************

; Define Helper Macros

  ; Shift Bank No in Accu to correct bit position

  IF  ?B_FIRSTBIT = 0
  CONV_MSPC     MACRO
                ANL	A,#LOW (MASK)
                ENDM
  ENDIF

  IF  ?B_FIRSTBIT = 1
  CONV_MSPC     MACRO
                RL      A
                ANL	A,#LOW (MASK SHL 1)
                ENDM
  ENDIF

  IF  ?B_FIRSTBIT = 2
  CONV_MSPC     MACRO
                RL      A
                RL      A
                ANL	A,#LOW (MASK SHL 2)
                ENDM
  ENDIF

  IF  ?B_FIRSTBIT = 3
  CONV_MSPC     MACRO
                SWAP    A
                RR      A
                ANL	A,#LOW (MASK SHL 3)
                ENDM
  ENDIF

  IF  ?B_FIRSTBIT = 4
  CONV_MSPC     MACRO
                SWAP    A
                ANL	A,#LOW (MASK SHL 4)
                ENDM
  ENDIF

  IF  ?B_FIRSTBIT = 5
  CONV_MSPC     MACRO
                SWAP    A
                RL      A
                ANL	A,#LOW (MASK SHL 5)
                ENDM
  ENDIF

  IF  ?B_FIRSTBIT = 6
  CONV_MSPC     MACRO
                RR      A
                RR      A
                ANL	A,#LOW (MASK SHL 6)
                ENDM
  ENDIF

  IF  ?B_FIRSTBIT = 7
  CONV_MSPC     MACRO
                RR      A
                ANL	A,#LOW (MASK SHL 7)
                ENDM
  ENDIF


ENDIF  ; close block IF  ?B_MODE = 0 OR ?B_MODE = 1   *************************


IF  ?B_MODE = 0 ;**************************************************************

; Select Bank depending on value in R3
SEL_BNK         MACRO   SaveA
IF NOT NUL SaveA
                PUSH    ACC
ENDIF
                CALL    SELECT_BANK_R3
IF NOT NUL SaveA
                POP     ACC 
ENDIF
                ENDM

; Pop previous Bank and select it again
POP_BNK         MACRO   SaveA
LOCAL BNK_EA1
IF NOT NUL SaveA
		MOV	DPL,A
ENDIF
                POP     ACC            ; bank information
                ANL     A,#?B_MASK
IF ?B_RTX = 1
                JBC     EA,BNK_EA1
ENDIF
                ORL     ?B_CURRENTBANK, #?B_MASK
                ANL     ?B_CURRENTBANK, A
IF NOT NUL SaveA
		MOV	A,DPL
ENDIF
                RET

    BNK_EA1:                           ; interrupts where enabled
IF ?B_RTX = 1
                ORL     ?B_CURRENTBANK, #?B_MASK
                ANL     ?B_CURRENTBANK, A
                SETB    EA             ; enable interrupts again
IF NOT NUL SaveA
		MOV	A,DPL
ENDIF
                RET
ENDIF
                ENDM


SELECT_BANK_R3:
		MOV	A,R3
		DEC     A
		CONV_MSPC               
                MOV     DPL,R1
                MOV     DPH,R2
                CJNE    R3,#80H,SEL_BANK_LAB  ; set CY
SEL_BANK_lab:            
IF ?B_RTX = 1
                JBC     EA,SEL_BANK_EA1
ENDIF
                ORL     ?B_CURRENTBANK, #?B_MASK
                ANL     ?B_CURRENTBANK, A
                RET

    SEL_BANK_EA1:                      ; interrupts where enabled
IF ?B_RTX = 1
                ORL     ?B_CURRENTBANK, #?B_MASK
                ANL     ?B_CURRENTBANK, A
                SETB    EA             ; enable interrupts again
                RET
ENDIF

ENDIF  ; close block IF ?B_MODE = 0 *******************************************

IF ?B_MODE = 1 ;***************************************************************

; Select Bank depending on value in R3
SEL_BNK         MACRO   SaveA
LOCAL lab
IF NOT NUL SaveA
                PUSH    ACC
ENDIF
                CALL    SELECT_BANK_R3
IF NOT NUL SaveA
                POP	ACC
ENDIF
                ENDM

; Pop previous Bank and select it again
POP_BNK         MACRO   SaveA
IF NOT NUL SaveA
                POP     DPL
		XCH	A,DPL
		PUSH	DPL
ELSE
                POP     ACC
ENDIF
                MOV     DPTR,#?B_XDATAPORT
                MOV     ?B_CURRENTBANK,A
                MOVX    @DPTR,A
IF NOT NUL SaveA
                POP     ACC
ENDIF
                RET
                ENDM


SELECT_BANK_R3:
		MOV	A,R3
		DEC     A
		CONV_MSPC               
                MOV     DPTR,#?B_XDATAPORT
                MOV     ?B_CURRENTBANK,A
                MOVX    @DPTR,A
                MOV     DPL,R1
                MOV     DPH,R2
                CJNE    R3,#80H,SEL_BANK_LAB  ; set CY
SEL_BANK_LAB:
                RET

ENDIF  ; close block IF ?B_MODE = 1 *******************************************

IF  ?B_MODE = 4 ;**************************************************************

; Select Bank depending on value in R3
SEL_BNK         MACRO   SaveA
LOCAL lab
IF NOT NUL SaveA
                PUSH	ACC
ENDIF
                CALL    SELECT_BANK_R3
IF NOT NUL SaveA
                POP	ACC
ENDIF
                MOV     DPL,R1
                MOV     DPH,R2
                CJNE    R3,#80H,lab
lab:            
                ENDM

; Pop previous Bank and select it again
POP_BNK         MACRO   SaveA
IF NOT NUL SaveA
                POP     DPL
		XCH	A,DPL
		PUSH	DPL
                CALL    ?B_RESTORE_BANK
                POP     ACC
                RET
ELSE
                POP     ACC
                MOV     DPTR,#?BANK?SWITCH
                JMP     @A+DPTR
ENDIF
                ENDM

ENDIF  ; close block IF ?B_MODE = 4 *******************************************



; CLDXPTR: Load   BYTE in A             via Address given in R1/R2/R3
?C?CLDXPTR:     PUSH    ?B_CURRENTBANK
                SEL_BNK
                JNC     CLDCODE
                MOVX    A,@DPTR
                SJMP    RETURN_A
CLDCODE:        CLR     A
                MOVC    A,@A+DPTR
RETURN_A:       POP_BNK 1


; CSTXPTR: Store  BYTE in A             via Address given in R1/R2/R3
?C?CSTXPTR:     PUSH    ?B_CURRENTBANK
                SEL_BNK 1          
                JNC     CSTCODE
                MOVX    @DPTR,A
CSTCODE:        SJMP	RETURN_A       ; correct 10.5.2002


; ILDXPTR: Load   WORD in A(LSB)/B(HSB) via Address given in R1/R2/R3 
?C?ILDXPTR:     PUSH    ?B_CURRENTBANK
                SEL_BNK
                JNC     ILDCODE
                MOVX    A,@DPTR
                MOV     B,A
                INC     DPTR
                MOVX    A,@DPTR
                SJMP    RETURN_A
ILDCODE:        CLR     A
                MOVC    A,@A+DPTR
                MOV     B,A
                MOV     A,#1
                MOVC    A,@A+DPTR
                SJMP    RETURN_A


; ISTXPTR: Store  WORD in A(HSB)/B(LSB) via Address given in R1/R2/R3 
?C?ISTXPTR:     PUSH    ?B_CURRENTBANK
                SEL_BNK 1
                JNC     ISTCODE
                MOVX    @DPTR,A
                INC     DPTR
                MOV     A,B
                MOVX    @DPTR,A
ISTCODE:        SJMP    RETURN_NO_A


; PLDXPTR: Load    PTR in R1/R2/R3      via Address given in R1/R2/R3 
?C?PLDXPTR:     PUSH    ?B_CURRENTBANK
                SEL_BNK
                JNC     PLDCODE
                MOVX    A,@DPTR
                MOV     R3,A
                INC     DPTR
                MOVX    A,@DPTR
                MOV     R2,A
                INC     DPTR
                MOVX    A,@DPTR
                MOV     R1,A
                SJMP    RETURN_NO_A
PLDCODE:        CLR     A
                MOVC    A,@A+DPTR
                MOV     R3,A
                MOV     A,#1
                MOVC    A,@A+DPTR
                MOV     R2,A
                MOV     A,#2
                MOVC    A,@A+DPTR
                MOV     R1,A
RETURN_NO_A:    POP_BNK

; PSTXPTR: Store   PTR in R0/A/B        via Address given in R1/R2/R3 
?C?PSTXPTR:     PUSH    ?B_CURRENTBANK
                SEL_BNK 1
                JNC     PSTCODE
                XCH     A,B
                MOVX    @DPTR,A
                INC     DPTR
                XCH     A,B
                MOVX    @DPTR,A
                INC     DPTR
                MOV     A,R0
                MOVX    @DPTR,A
PSTCODE:        SJMP    RETURN_NO_A 

; LLDXPTR: Load  DWORD in R4/R5/R6/R7   via Address given in R1/R2/R3 
?C?LLDXPTR:     PUSH    ?B_CURRENTBANK
                SEL_BNK
                JNC     LLDCODE
                MOVX    A,@DPTR
                MOV     R4,A
                INC     DPTR
                MOVX    A,@DPTR
                MOV     R5,A
                INC     DPTR
                MOVX    A,@DPTR
                MOV     R6,A
                INC     DPTR
                MOVX    A,@DPTR
                MOV     R7,A
                SJMP    RETURN_NO_A
LLDCODE:        CLR     A
                MOVC    A,@A+DPTR
                MOV     R4,A
                MOV     A,#1
                MOVC    A,@A+DPTR
                MOV     R5,A
                MOV     A,#2
                MOVC    A,@A+DPTR
                MOV     R6,A
                MOV     A,#3
                MOVC    A,@A+DPTR
                MOV     R7,A
                SJMP    RETURN_NO_A

; LSTXPTR: Store DWORD in R4/R5/R6/R7   via Address given in R1/R2/R3 
?C?LSTXPTR:     PUSH    ?B_CURRENTBANK
                SEL_BNK
                JNC     LSTCODE
                MOV     A,R4
                MOVX    @DPTR,A
                INC     DPTR
                MOV     A,R5
                MOVX    @DPTR,A
                INC     DPTR
                MOV     A,R6
                MOVX    @DPTR,A
                INC     DPTR
                MOV     A,R7
                MOVX    @DPTR,A
LSTCODE:        SJMP    RETURN_NO_A

 
ENDIF  ; close block IF ?B_VAR_BANKING ****************************************

                END