Subversion Repositories open8_urisc

; Copyright (c)2022 Jeremy Seth Henry
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are met:
;     * Redistributions of source code must retain the above copyright
;       notice, this list of conditions and the following disclaimer.
;     * Redistributions in binary form must reproduce the above copyright
;       notice, this list of conditions and the following disclaimer in the
;       documentation and/or other materials provided with the distribution,
;       where applicable (as part of a user interface, debugging port, etc.)
;
; THIS SOFTWARE IS PROVIDED BY JEREMY SETH HENRY ``AS IS'' AND ANY
; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
; DISCLAIMED. IN NO EVENT SHALL JEREMY SETH HENRY BE LIABLE FOR ANY
; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;
;------------------------------------------------------------------------------
; sys_const.s
;
; Common constants & macros for generic hardware or structures used by several
;  tasks
;
; Revision History
; Author          Date     Change
;---------------- -------- ---------------------------------------------------
; Seth Henry      7/15/22  Initial Release
;------------------------------------------------------------------------------
 
;------------------------------------------------------------------------------
;-- Serial Port Constants & Macros
;------------------------------------------------------------------------------
.DEFINE UART_DATA            0
.DEFINE UART_STATUS          1
 
.DEFINE UART_RX_PERR         3
.DEFINE UART_RX_EMPTY        4
.DEFINE UART_RX_FULL         5
.DEFINE UART_TX_EMPTY        6
.DEFINE UART_TX_FULL         7
 
.DEFINE UART_RX_PERR_BIT     2^UART_RX_PERR
.DEFINE UART_RX_PERR_MASK    UART_RX_PERR_BIT ~ $FF
 
.DEFINE UART_RX_EMPTY_BIT    2^UART_RX_EMPTY
.DEFINE UART_RX_EMPTY_MASK   UART_RX_EMPTY_BIT ~ $FF
 
.DEFINE UART_RX_FULL_BIT     2^UART_RX_FULL
.DEFINE UART_RX_FULL_MASK    UART_RX_FULL_BIT ~ $FF
 
.DEFINE UART_TX_EMPTY_BIT    2^UART_TX_EMPTY
.DEFINE UART_TX_EMPTY_MASK   UART_TX_EMPTY_BIT ~ $FF
 
.DEFINE UART_TX_FULL_BIT     2^UART_TX_FULL
.DEFINE UART_TX_FULL_MASK    UART_TX_FULL_BIT ~ $FF
 
; Checking the UART flags involves testing bits in the status register
;  The assembler isn't bright enough to use the defined constant, so this macro
;  does the test on the correct bit
 
.MACRO CHECK_UART_RX_PERR
              BTT  3
.ENDM
 
.MACRO CHECK_UART_RX_EMPTY
              BTT  4
.ENDM
 
.MACRO CHECK_UART_RX_FULL
              BTT  5
.ENDM
 
.MACRO CHECK_UART_TX_EMPTY
              BTT  6
.ENDM
 
.MACRO CHECK_UART_TX_FULL
              BTT  7
.ENDM
 
; Register Map:
; Offset  Bitfield Description                        Read/Write
;   0x00  AAAAAAAA TX Data (WR) RX Data (RD)             (RW)
;   0x01  EDCBA--- FIFO Status                           (RO*)
;                  A: RX Parity Error (write to clear)
;                  B: RX FIFO Empty
;                  C: RX FIFO almost full (922/1024)
;                  D: TX FIFO Empty
;                  E: TX FIFO almost full (922/1024)
;
;------------------------------------------------------------------------------
 
;------------------------------------------------------------------------------
; Macros for setting the return value in Cmd_Error
;------------------------------------------------------------------------------
.DEFINE RX_CERR              $FB
.DEFINE RX_TERR              $FC
.DEFINE RX_LERR              $FD
.DEFINE RX_PERR              $FE
.DEFINE RX_OKAY              $FF
 
.MACRO RETURN_RX_CMD_OKAY
              LDI  R0, #RX_OKAY
.ENDM
 
.MACRO RETURN_RX_CMD_ERROR
              LDI  R0, #RX_CERR
.ENDM
 
.MACRO RETURN_RX_TIMEOUT_ERROR
              LDI  R0, #RX_TERR
.ENDM
 
.MACRO RETURN_RX_LENGTH_ERROR
              LDI  R0, #RX_LERR
.ENDM
 
.MACRO RETURN_RX_PARITY_ERROR
              LDI  R0, #RX_PERR
.ENDM
;------------------------------------------------------------------------------
 
;------------------------------------------------------------------------------
; Common buffer/memory copy
; Uses R3:R2 as source, R5:R4 as destination, and R1 as the counter variable
;------------------------------------------------------------------------------
.MACRO MEM_COPY
__MEM_CP_LP\@:LDX  R2++
              STX  R4++
              DBNZ R1, __MEM_CP_LP\@
.ENDM
;------------------------------------------------------------------------------
 
;------------------------------------------------------------------------------
; Common buffer/memory fill/flush
; Uses R5:R4 as destination, and R1 as the counter variable
;------------------------------------------------------------------------------
.MACRO MEM_FILL
__MEM_FL_LP\@:STX  R4++
              DBNZ R1, __MEM_FL_LP\@
.ENDM
 
.MACRO MEM_FLUSH
              CLR  R0
              MEM_FILL
.ENDM
;------------------------------------------------------------------------------
 
;------------------------------------------------------------------------------
; Compute 16-bit Checksum
;
; Uses R3:R2 as source, R5:R4 as destination, and R1 as the counter variable
; Adds all of the memory locations specified to a 16-bit accumulator, returning
;  the result in R5:R4 (destination)
;------------------------------------------------------------------------------
.MACRO CALC_CHECKSUM16
              CLR  R0
              T0X  R4                   ; Initialize accumulator R5:R0 to 0
              T0X  R5
              T0X  R7                   ; Initialize R7 to 0
 
__CHK_SM_LP\@:LDX  R2++
              ADD  R4
              T0X  R4
 
              TX0  R5
              ADC  R7
              T0X  R5
 
              DBNZ R1, __CHK_SM_LP\@
.ENDM
 
; These macros assume that the pointer in R3:R2 has been left pointing to the
;  end of the receive buffer by the CALC_CHECKSUM16 macro. Do NOT repoint
; R3:R2, and be sure to use these macros in the order that the checksum bytes
;  appear in the packet. (THESE ARE ORDER DEPENDENT)
 
.MACRO CHECK_SUM_LB
              LDX  R2++
              XOR  R4
.ENDM
 
.MACRO CHECK_SUM_UB
              LDX  R2++
              XOR  R5
.ENDM
;------------------------------------------------------------------------------
 
;------------------------------------------------------------------------------
; Convert ASCII to HEX
;
; Converts an ASCII value into an integer value from 0x0 to 0xF
; Assumes incoming data is in R0. Returns a value in R0
; Returns a value of 0x00 to 0x0F for valid characters, or
; 0xFF (-1) for invalid characters
;------------------------------------------------------------------------------
.MACRO CONVERT_ASC2HEX
              PSH  R1       ; Preserve R1 and R2
              PSH  R2
 
              T0X  R2       ; Make a copy of R0 to R2 for backup
              LDI  R1, #$F0 ; Mask off the lower bits to figure out the range
              AND  R1
              T0X  R1       ; Copy the upper 4-bits to R1 for branching tests
 
              LDI  R0, #$30 ; Is it a decimal char 0-9?
              XOR  R1
              BRZ  _CNV_AH_09_\@
 
              LDI  R0, #$40 ; Is it a hex char A-F?
              XOR  R1
              BRZ  _CNV_AH_AF_\@
 
              LDI  R0, #$60 ; Is it a hex char a-f?
              XOR  R1
              BRZ  _CNV_AH_AF_\@
 
              BNI  _CNV_AH_NV_\@
 
; Valid HEX characters 0-9 are ASCII codes 0x30 to 0x39. Codes 0x3A to 0x3F are
;  invalid, so check that the value in R0 is LESS than $3A.
_CNV_AH_09_\@:TX0  R2       ; Restore R0 from backup
              LDI  R1, #$0F ; Mask off the upper bits to check validity
              AND  R1
              T0X  R2       ; Backup the lower 4-bits to R2
 
; Check for 0x0A to 0x0F
              LDI  R1, #$0A ; Load R1 with 0x0A (:)
              CMP  R1       ; Compare R0 to R1
              BNN  _CNV_AH_NV_\@  ; Branch if not negative (R0 > 9)
 
              TX0  R2       ; Restore the lower 4-bits to R0
              BNI  _CNV_AH_EX_\@
 
; Valid HEX characters A-F are 0x41 to 0x46 OR 0x61 to $66. The upper 4-bits
;  have already been checked, so just verify that the lower 4-bits are between
;  0x01 and 0x06. 0x00 and 0x07 to 0x0F are invalid,
;  so check that the value in R0 is LESS than $3A
_CNV_AH_AF_\@:TX0  R2       ; Restore R0 from backup
              LDI  R1, #$0F ; Mask off the upper bits to check validity
              AND  R1
              T0X  R2       ; Backup the lower 4-bits to R2
 
; Check for 0x00
              BRZ  _CNV_AH_NV_\@  ; 0x0 is an invalid code
 
; Check for 0x07 to 0x0F
              LDI  R1, #$07 ; Load R1 with 0x7 (G or g)
              CMP  R1       ; Compare R0 to R1
              BNN  _CNV_AH_NV_\@  ; Branch of not negative (R0 > 6)
 
; If this is a valid character, add 9 to the lower 4-bits for the result
;  (0x01 to 0x06 -> 0x0A to 0x0F)
              TX0  R2       ; Restore lower 4-bits to R0
              LDI  R1, #$09 ; Load R1 with 0x9
              ADD  R1       ; Added 9 to R0 to convert to A-F
              BNI  _CNV_AH_EX_\@
 
_CNV_AH_NV_\@:LDI  R0, #$FF ; Return 0xFF on an invalid character
 
_CNV_AH_EX_\@:POP  R2       ; Restore R1 and R2
              POP  R1
.ENDM
;------------------------------------------------------------------------------
 
;------------------------------------------------------------------------------
; Convert the lower nibble of R0 into a valid ASCII character
; Accepts data in R0 and returns the ASCII code in R0
;------------------------------------------------------------------------------
.MACRO CONVERT_NIB2ASC
              PSH  R1       ; Preserve R1
 
              LDI  R1, #$0F ; Mask away the upper 4-bits
              AND  R1
 
              T0X  R1       ; Copy to R1
              LDI  R0, #$09 ; Load R0 with 0x09
              CMP  R1       ; Compare R0 to R1
              BNN  _CNV_NA_09_\@
              ; Fall into _MC_FM_CHA_AF
 
_CNV_NA_AF_\@:LDI  R0, #$37 ; Add 0x37 to the nibble to get the ASCII value
              ADD  R1
              BNI  _CNV_NA_EX_\@
 
_CNV_NA_09_\@:LDI  R0, #$30 ; Add 0x30 to the nibble to get the ASCII value
              OR   R1
              ; Fall into _MC_FM_CHA_EX
 
_CNV_NA_EX_\@:POP  R1
.ENDM
;------------------------------------------------------------------------------
 
;------------------------------------------------------------------------------
; Convert the packed BCD value in R0 to its ASCII equivalent in R3:R2
; $59 -> $35, $39
;------------------------------------------------------------------------------
.MACRO CONV_PBCD_TO_ASCII
              T0X  R2        ; Copy R0 -> R2 for re-use
              LDI  R0, #$F0  ; Set the upper nibble mask. BCD is only 3-bit
              AND  R2        ; Mask off the upper 3-bits of value -> R0
              CLP  PSR_C     ; Clear the carry (in case CPU options not set)
              ROR  R0        ; Shift the upper nibble down
              ROR  R0
              ROR  R0
              ROR  R0
              LDI  R1, #$30  ; Set the ASCII upper nibble mask of $30
              OR   R1        ; Create an ASCII character
              T0X  R3        ; Transfer the upper character to R3
 
              LDI  R0, #$0F  ; Set the lower nibble mask
              AND  R2        ; Mask off the lower bits
              OR   R1        ; Create an ASCII character
              T0X  R2        ; Store the lower character to R1
              RTS
.ENDM
;------------------------------------------------------------------------------