diff --git a/branches/dwg/Doc/RomWBW Architecture.pdf b/branches/dwg/Doc/RomWBW Architecture.pdf index f6e1ac3d..cff91572 100644 Binary files a/branches/dwg/Doc/RomWBW Architecture.pdf and b/branches/dwg/Doc/RomWBW Architecture.pdf differ diff --git a/branches/dwg/Doc/Source/RomWBW Architecture.docx b/branches/dwg/Doc/Source/RomWBW Architecture.docx index d8d4b6e3..52505fca 100644 Binary files a/branches/dwg/Doc/Source/RomWBW Architecture.docx and b/branches/dwg/Doc/Source/RomWBW Architecture.docx differ diff --git a/branches/dwg/Source/ansi.asm b/branches/dwg/Source/ansi.asm index d7da6176..5a5671e6 100644 --- a/branches/dwg/Source/ansi.asm +++ b/branches/dwg/Source/ansi.asm @@ -1,181 +1,28 @@ -; ansi.asm 12/3/2012 dwg - changed polarity of conditional jump for normal processing - -; Status: Still very experimental, either doesn't work or is buggy - -; WBW: BOGUS EQUATE TO GET MODULE TO BUILD FOR NON-N8 HARDWARE -; NEEDS TO BE FIXED BEFORE IT WILL WORK FOR ANYTHING OTHER THAN N8 -#IF (!N8VENABLE) -#DEFINE N8V_OFFSET PANIC -#ENDIF - ; ;================================================================================================== ; ANSI EMULATION MODULE ;================================================================================================== ; - -; The ANSI handler is a superset of the TTY handler in that is does simple -; processing of control characters such as CR, LF... But in addition is Hasbro -; a state machine driven escape sequence parser that accepts parameters and -; command characters and builds a table of data required to perform the indicated -; operation. - -; For instance, a screen clear escaper sequence such as [2J is parsed as -; a leading CSI ()escape which places us in state1 (waiting for [ ). When the -; next character arrives and turns out to be [, the parser's next state is -; state2. - -; State2 processing is a little more complex. If the next character is a numeral, -; it is placed in the parameter1 buffer and the next state is state3 (collecting -; parameter1). - -; State3 processing implies that the buffer already has 1 byte of a parameter in -; the parameter1 buffer. If the next character is a semi-colon, that implies that -; the parameter1 buffer is complete and the next state should be state4. If the -; next byte is a numeral, it is appended to the parameter1 buffer and we stay INC -; state3. If the nect character is a semi-colon, that indicates the parameter1 is -; complete and we need to enter state4 to begin collection of parameter2. If the -; next character is neither a numeral or a semi-colon, then it needs -; to be decoded as a command. Commands result in the calling of low-level driver -; functions to perform the indicated operation. Subsequently we return to state0. - -; State4 processing implies we are collecting parameter2 data. If the next byte -; is a numeral, it is assigned to the parameter2 buffer. In this case we go to -; state5 which is used to finish collection of parameter2. - -; State5 processing is for collecting additional parameter2 bytes to be appended -; to the parameter2 buffer. When a non-numeral arrives, that implies that parameter2 -; is complete and the new character is either a semi-colon or the awaited command -; character. If it is a semi-colon, that would imply the existance of a parameter3, -; which may or may not be supported in this implementation. If it is the command -; character, then the propper low-level driver calls need to be invoked to perform -; the desired operations on the video screen. - -; Once state5 is complete, we re-enter state0. - -ANSI_ERR1 .EQU 1 - - -ANSI_CMD_DISP: - LD A,B - CP 'J' - JR ANSI_CMD_NOT_CRTCLR - - ; THIS IS THE CRTCLR FUNCTIONAL CODE - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - LD DE,0 ; row 0 column 0 - LD B,BF_VDASCP ; FUNCTION IS SET CURSOR POSITION - CALL EMU_VDADISP ; CALL THE VIDEO HARDWARE DRIVER - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - LD DE,0 ; row 0 column 0 - LD B,BF_VDAQRY ; FUNCTION IS QUERY FOR SCREEN SIZE - LD HL,0 ; WE DO NOT WANT A COPY OF THE CHARACTER BITMAP DATA - CALL EMU_VDADISP ; PERFORM THE QUERY FUNCTION - ; on return, D=row count, E=column count - ; for the fill call, we need hl=number of chars to fill - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - LD E,' ' ; fill with spaces - ; - LD A,(ANSI_ROWS) ; given A = number of rows - CALL N8V_OFFSET ; return HL = num_rows * num_cols - ; - LD B,BF_VDAFIL ; FUNCTION IS FILL - CALL EMU_VDADISP ; PERFORM THE QUERY FUNCTION - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - XOR A - RET ; return SUCCESS to caller - ; -ANSI_CMD_NOT_CRTCLR: - - CP 66h ; is it cursor position? - JR ANSI_CMD_NOT_CRTLC - -ANSI_CMD_NOT_CRTLC: - -; since only the crtclr and crtlc are supported right now... -; any other command is an error - CALL PANIC ; A has the unknown command byte - -;------------------------------------------------------------------------------------ -ANSI_IS_NUMERAL: - RET - -;------------------------------------------------------------------------------------ -ANSI_IS_ALPHA: - RET -;------------------------------------------------------------------------------------ -ANSI_MARSHALL_PARM1: - RET -;------------------------------------------------------------------------------------ -ANSI_MARSHALL_PARM2: - RET -;------------------------------------------------------------------------------------ -ANSI_PROC_COMMAND: - RET -;------------------------------------------------------------------------------------ - - -ANSI_STATE1: - ; Waiting for [ - ; (the only valid character to follow an ESC would be the [ ) - ; (if we get something else, we go back to state0 and begin again) - LD A,B - CP '[' - JR NZ,ANSI_STATE1_ERR ; if not the expected [, go around - LD HL,ANSI_STATE2 ; having found the [, set the next state - LD (ANSI_STATE),HL ; to state2 (waiting for a parm1 char). - XOR A ; set retcode to SUCCESS - RET ; and return to caller -ANSI_STATE1_ERR: - LD HL,ANSI_STATE0 - LD (ANSI_STATE),HL ; set next state to state 0 - LD A,ANSI_ERR1 ; "state1 expected [ not found" - RET - -;------------------------------------------------------------------------------------ - -ANSI_STATE2: - ; waiting for parm1 - LD A,B - CALL ANSI_IS_NUMERAL - JR NZ,ANSI_STATE2_NOT_NUMERAL - CALL ANSI_MARSHALL_PARM1 - XOR A ; set SUCCESS return code - RET -ANSI_STATE2_NOT_NUMERAL: - LD A,B - CP 59 ; semi-colon - JR NZ,ANSI_STATE2_NOT_SEMI - LD HL,ANSI_STATE3 - LD (ANSI_STATE),HL ; set next state to waiting for parm2 - XOR A - RET ; return SUCCESS -ANSI_STATE2_NOT_SEMI: - ; if it is not a semi, or a numeral, it must be a command char - LD HL,ANSI_STATE0 ; after we do the command dispatcher, the - LD (ANSI_STATE),HL ; next state we will want is the default state - JP ANSI_CMD_DISP - +; TODO: +; 1) INSERT/DELETE CHARACTERS CTL SEQUENCES +; 2) OTHER CTL SEQUENCES? +; +;================================================================================================== +; ANSI EMULATION MODULE CONSTANTS +;================================================================================================== +; +ANSI_DEFATTR .EQU 0 ; ALL ATTRIBUTES OFF +ANSI_DEFCOLOR .EQU 7 ; WHITE ON BLACK +; +;================================================================================================== +; ANSI EMULATION MODULE +;================================================================================================== +; ANSI_INIT: PRTS("ANSI: RESET$") ; - JR ANSI_INI ; REUSE THE INI FUNCTION BELOW + JP ANSI_INI ; REUSE THE INI FUNCTION BELOW ; - -ANSI_STATE3: - ; waiting for parm2 - LD A,B - CALL ANSI_IS_NUMERAL - JR NZ,ANSI_STATE3_NOT_NUMERAL - CALL ANSI_MARSHALL_PARM2 - XOR A - RET -ANSI_STATE3_NOT_NUMERAL: - LD A,B - CALL ANSI_PROC_COMMAND - LD HL,ANSI_STATE0 - LD (ANSI_STATE),HL - RET ; ; ANSI_DISPATCH: @@ -191,130 +38,523 @@ ANSI_DISPATCH: DEC A JR Z,ANSI_CFG ; $34 CP 8 - JR Z,ANSI_INI ; $38 + JP Z,ANSI_INI ; $38 CP 9 - JR Z,ANSI_QRY ; $39 + JP Z,ANSI_QRY ; $39 CALL PANIC ; +;================================================================================================== +; ANSI EMULATION MODULE BIOS FUNCTION ENTRY POINTS +;================================================================================================== +; +; READ A CHARACTER +; +ANSI_IN: ; HANDLE INPUT REQUEST ; + ; RETURN QUEUED DATA IF WE HAVE ANY + LD A,(ANSI_QLEN) ; GET THE CURRENT QUEUE LENGTH + OR A ; SET FLAGS + JR Z,ANSI_IN1 ; NOTHING THERE, GO TO KEYBOARD READ + DEC A ; DECREMENT THE QUEUE LENGTH + LD (ANSI_QLEN),A ; AND SAVE IT + LD HL,(ANSI_QPTR) ; GET THE QUEUE POINTER + LD A,(HL) ; GET THE NEXT QUEUE BYTE + INC HL ; INCREMENT THE POINTER + LD (ANSI_QPTR),HL ; AND SAVE IT + LD E,A ; RETURN VALUE IN E + XOR A ; SIGNAL SUCCESS + RET ; DONE ; -ANSI_IN: +ANSI_IN1: ; PERFORM ACTUAL KEYBOARD INPUT LD B,BF_VDAKRD ; SET FUNCTION TO KEYBOARD READ - JP EMU_VDADISP ; CHAIN TO VDA DISPATCHER + CALL EMU_VDADISP ; CALL VDA DISPATCHER + LD A,E ; CHARACTER READ INTO A + BIT 7,A ; TEST HIGH BIT + JR NZ,ANSI_IN2 ; HANDLE $80 OR HIGHER AS SPECIAL CHAR + XOR A ; OTHERWISE, SIGNAL SUCCESS + RET ; AND RETURN THE KEY ; +ANSI_IN2: ; HANDLE SPECIAL KEY + CALL ANSI_KDISP ; IF $80 OR HIGHER, DISPATCH + JR ANSI_IN ; AND LOOP ; +; WRITE A CHARACTER W/ EMULATION ; ANSI_OUT: - LD HL,(ANSI_STATE) - JP (HL) - -;; CALL ANSI_DOCHAR ; HANDLE THE CHARACTER (EMULATION ENGINE) -;; XOR A ; SIGNAL SUCCESS -;; RET - + LD HL,ANSI_OUT2 ; RETURN ADDRESS + PUSH HL ; PUT IT ON STACK + LD A,E ; GET THE INCOMING CHARACTER + CP $20 ; $00-$1F IS C0 + JP C,ANSI_C0DISP ; IF C0, DO C0 DISPATCH + CP $80 ; $20-$7F + JR C,ANSI_OUT1 ; HANDLE VIA STATE MACHINE + CP $A0 ; $80-$9F IS C1 + JP C,ANSI_C1DISP ; IF C1, DO C1 DISPATCH ; +ANSI_OUT1: ; PROCESS OTHER CHARS VIA STATE MACHINE + LD HL,(ANSI_STATE) ; LOAD THE CURRENT STATE + JP (HL) ; DO IT +; CALL JPHL ; DO IT ; +ANSI_OUT2: ; SET RESULT AND RETURN + XOR A ; SIGNAL SUCCESS + RET ; -ANSI_IST: +; CHECK INPUT STATUS +; +ANSI_IST: ; CHECK QUEUE FIRST + LD A,(ANSI_QLEN) ; GET CURRENT QUEUE LENGTH + OR A ; SET FLAGS + RET NZ ; RETURN IF CHAR(S) WAITING +; + ; QUEUE WAS EMPTY, CHECK HARDWARE STATUS LD B,BF_VDAKST ; SET FUNCTION TO KEYBOARD STATUS - JP EMU_VDADISP ; CHAIN TO VDA DISPATCHER + CALL EMU_VDADISP ; CHECK STATUS + OR A ; SET FLAGS + RET Z ; NO KEYS WAITING, RETURN NO JOY +; + ; KEY WAITING, GET IT AND HANDLE IT + LD B,BF_VDAKRD ; SET FUNCTION TO KEYBOARD READ + CALL EMU_VDADISP ; DO IT + LD A,E ; CHARACTER READ TO A + BIT 7,A ; TEST HIGH BIT + JR NZ,ANSI_IST1 ; HANDLE $80 OR HIGHER AS SPECIAL CHAR +; + ; REGULAR CHARACTER RECEIVED, QUEUE IT AND RETURN CHARS WAITING STATUS + LD HL,ANSI_QUEUE ; SET HL TO START OF QUEUE + LD (ANSI_QPTR),HL ; RESET QUEUE POINTER + LD A,E ; RESTORE CHARACTER RECEIVED + LD (HL),A ; SAVE IT AT THE HEAD OF THE QUEUE + XOR A ; ZERO ACCUM + INC A ; ASSUM := 1 (NUM CHARS IN QUEUE) + LD (ANSI_QLEN),A ; SAVE NEW QUEUE LEN + JR ANSI_IST ; REPEAT ; +ANSI_IST1: ; HANDLE SPECIAL KEY + CALL ANSI_KDISP ; DO SPECIAL KEY HANDLING + JR ANSI_IST ; REPEAT ; +; CHECK OUTPUT STATUS ; -ANSI_OST: +ANSI_OST: ; VIDEO OUTPUT IS *ALWAYS* READY XOR A ; ZERO ACCUM INC A ; A := $FF TO SIGNAL OUTPUT BUFFER READY RET ; -; +; SET CONFIGURATION ; ANSI_CFG: XOR A ; SIGNAL SUCCESS RET ; -; +; INITIALIZE ; ANSI_INI: - LD HL,ANSI_STATE0 ; load the address of the default state function - LD (ANSI_STATE),HL ; and place it in the ANSI_STATE variable for later. - + ; QUERY THE VIDEO DRIVER FOR SCREEN DIMENSIONS LD B,BF_VDAQRY ; FUNCTION IS QUERY LD HL,0 ; WE DO NOT WANT A COPY OF THE CHARACTER BITMAP DATA CALL EMU_VDADISP ; PERFORM THE QUERY FUNCTION LD (ANSI_DIM),DE ; SAVE THE SCREEN DIMENSIONS RETURNED +; + ; INITIALIZE ALL WORKING VARIABLES LD DE,0 ; DE := 0, CURSOR TO HOME POSITION 0,0 LD (ANSI_POS),DE ; SAVE CURSOR POSITION + LD HL,ANSI_STBASE ; SET STATE TO BASE + LD (ANSI_STATE),HL ; DO IT + LD A,ANSI_DEFATTR ; DEFAULT ATTRIBUTE + LD (ANSI_ATTR),A ; CLEAR ATTRIBUTES + LD A,ANSI_DEFCOLOR ; DEFAULT COLOR + LD (ANSI_COLOR),A ; RESET COLOR + XOR A ; ZERO ACCUM + LD (ANSI_WRAP),A ; CLEAR WRAP FLAG + LD (ANSI_LNM),A ; SET LINE FEED NEW LINE MODE + LD (ANSI_CKM),A ; CLEAR DEC CURSOR KEY MODE + LD (ANSI_QLEN),A ; ZERO THE QUEUE LENGTH + LD A,$FF ; SET ALL BITS OF ACCUM + LD (ANSI_AWM),A ; SET DEC AUTOWRAP MODE +; + ; RESET TAB STOPS TO DEFAULT (EVERY 8 CHARACTERS) + LD A,%10000000 ; STOP AT FIRST OF EVERY 8 CHARACTERS + LD HL,ANSI_TABS ; POINT TO TAB STOP BITMAP + LD B,32 ; INIT 32 BYTES +; +ANSI_INI1: ; LOOP TO RESET TAB STOPS + LD (HL),A ; SET A BYTE + INC HL ; POINT TO NEXT BYTE + DJNZ ANSI_INI1 ; LOOP TILL ALL BYTES DONE +; + ; RESET THE CURRENT VIDEO DRIVER LD B,BF_VDARES ; SET FUNCTION TO RESET JP EMU_VDADISP ; RESET VDA AND RETURN ; -; +; QUERY STATUS ; ANSI_QRY: XOR A ; SIGNAL SUCCESS RET ; +;================================================================================================== +; ANSI STATE MACHINE ENTRY POINTS +;================================================================================================== ; +ANSI_STBASE: ; STATE == BASE + JP ANSI_RENDER ; RENDER THE GLYPH ; - - - ; This is probably the best place to insert a state sensitive - ; dispatcher for handling ANSI escape sequences. Ansi sequences - ; are unusual because they contain a number of parameters - ; subsequently followed by a command character that comes last. - - ; It is wise to create a list of supported sequences so we know - ; before writing the parser what the most complex sequence will - ; consist of. - - ; RomWBW utilities written by Douglas Goodall only use several - ; sequences. A screen clear, and a cursor position. - ; - ; crtclr() uses [2J - ; crtlc() uses [;<0x66> - - ; Programs such as wordstar use more complex operations. - ; - ; -;; ANSI_DOCHAR: -ANSI_STATE0: - ; ANSI_STATE0 is the default state where random output characters May - ; be normal visible characters, a control character such as BS, CR, LF... - ; or a CSI such as an escape character (27). - - - LD A,E ; CHARACTER TO PROCESS - CP 8 ; BACKSPACE - JR Z,ANSI_BS - CP 12 ; FORMFEED - JR Z,ANSI_FF - CP 13 ; CARRIAGE RETURN - JR Z,ANSI_CR - CP 10 ; LINEFEED - JR Z,ANSI_LF - - CP 27 ; ESCAPE ; This is the hook into the escape handler - JR NZ,ANSI_NOT_ESC ; go around if not CSI - LD HL,ANSI_STATE1 - LD (ANSI_STATE),HL - XOR A ; setup SUCCESS as return status +; +; +ANSI_STESC: ; STATE == ESCAPE SEQUENCE + RES 7,A ; CLEAR HIGH BIT + CP $30 ; $20 - $2F ARE INTERMEDIATE CHARS + JP C,ANSI_COLLINT ; COLLECT INTERMEDIATE CHARACTERS + CP $7F ; $30 - $7E + RET NC ; IGNORE $7F + LD HL,ANSI_STBASE ; BASE STATE + LD (ANSI_STATE),HL ; SET IT + JP ANSI_ESCDISP ; DISPATCH FOR ESCAPE SEQUENCE +; +; +; +ANSI_STCTL: ; STATE == CONTROL SEQUENCE + RES 7,A ; CLEAR HIGH BIT + CP $30 + JP C,ANSI_COLLINT ; COLLECT INTERMEDIATE CHARACTERS + CP $3C + JP C,ANSI_COLLPAR ; COLLECT PARAMETERS + CP $40 + JP C,ANSI_COLLPRI ; COLLECT PRIVATE CHARACTERS + CP $7F ; $30 - $7E + RET NC ; IGNORE $7F + LD HL,ANSI_STBASE ; BASE STATE + LD (ANSI_STATE),HL ; SET IT + JP ANSI_CTLDISP ; DISPATCH FOR CONTROL SEQUENCE +; +; +; +ANSI_STSTR: ; STATE == STRING DATA RET -ANSI_NOT_ESC: - - CP 32 ; COMPARE TO SPACE (FIRST PRINTABLE CHARACTER) - RET C ; SWALLOW OTHER CONTROL CHARACTERS +; +;================================================================================================== +; ANSI C0 DISPATCHING +;================================================================================================== +; +ANSI_C0DISP: + CP $08 ; BS: BACKSPACE + JP Z,ANSI_BS + CP $0A ; LF: LINEFEED + JP Z,ANSI_LF + CP $0B ; VT: VERTICAL TAB + JP Z,ANSI_LF ; TREAD AS LINEFEED + CP $0C ; FF: FORMFEED + JP Z,ANSI_LF ; TREAT AS LINEFEED + CP $0D ; CR: CARRIAGE RETURN + JP Z,ANSI_CR + CP $18 ; CAN: CANCEL + JP Z,ANSI_CAN + CP $1A ; SUB: ??? + JP Z,ANSI_SUB + CP $1B ; ESC: ESCAPE + JP Z,ANSI_ESC + RET +; +;================================================================================================== +; ANSI C1 DISPATCHING +;================================================================================================== +; +ANSI_C1DISP: + CP $84 ; IND: INDEX + JP Z,ANSI_LF ; DO IT + CP $85 ; NEL: NEXT LINE + JP Z,ANSI_NEL ; DO IT + CP $88 ; HTS: HORIZONTAL TAB SET + JP Z,ANSI_HTS ; DO IT + CP $8D ; RI: REVERSE INDEX + JP Z,ANSI_RI ; DO IT + CP $9B ; CSI: CONTROL SEQ INTRODUCER + JP Z,ANSI_CSI ; HANDLE IT +; + ; IGNORE OTHERS + RET +; +;================================================================================================== +; ANSI ESCAPE SEQUENCE DISPATCHING +;================================================================================================== +; +ANSI_ESCDISP: +#IF (ANSITRACE >= 2) + PRTS("($") + PUSH AF + LD A,(ANSI_INT) + OR A + CALL NZ,COUT + CALL PC_COMMA + POP AF + CALL COUT + CALL PC_RPAREN +#ENDIF + LD (ANSI_FINAL),A ; RECORD THE FINAL CHARACTER + LD A,(ANSI_INT) ; LOAD THE INTERMEDIATE CHARACTER + OR A ; SET FLAGS + JR Z,ANSI_ESCDISP1 ; NO INT CHARACTER, DO NORMAL DISPATCH + CP '#' ; INTERMEDIATE CHAR == '#'? + JR Z,ANSI_ESCDISP2 ; YES, DO # DISPATCHING + JP ANSI_UNK ; UNKNOWN, ABORT +; +ANSI_ESCDISP1: ; NORMAL ESCAPE DISPATCHING, NO INT CHARACTER + LD A,(ANSI_FINAL) ; GET FINAL CHARACTER + CP $40 ; $30-$3F + JR C,ANSI_ESCDISP1A ; YES, CONTINUE NORMALLY + CP $60 ; $40-$5F + JR NC,ANSI_ESCDISP1A ; NOPE, $60 AND ABOVE CONTINUE NORMALLY +; + ; $40-$5F MAPS TO $80-$9F IN C1 RANGE + CALL ANSI_CLEAR ; CLEAR STATE RELATED VARIABLES + LD HL,ANSI_STBASE ; BASE STATE + LD (ANSI_STATE),HL ; SET IT + ADD A,$40 ; MAP $40-$5F -> $80-$9F + JP ANSI_C1DISP ; PROCESS AS C1 CHARACTER +; +ANSI_ESCDISP1A: ; CONTINUE NORMAL ESCAPE SEQ DISPATCHING + CP 'c' ; RIS: RESET TO INITIAL STATE + JP Z,ANSI_INI ; DO A FULL RESET + JP ANSI_UNK ; UNKNOWN, ABORT +; +ANSI_ESCDISP2: ; ESC DISPATCHING FOR '#' INT CHAR + LD A,(ANSI_FINAL) ; GET FINAL CHARACTER + CP '8' ; DECALN: DEC SCREEN ALIGNMENT TEST + JP Z,ANSI_DECALN ; HANDLE IT + JP ANSI_UNK ; UNKNOWN, ABORT +; +;================================================================================================== +; ANSI CONTROL SEQUENCE DISPATCHING +;================================================================================================== +; +ANSI_CTLDISP: + LD (ANSI_FINAL),A ; RECORD THE FINAL CHARACTER +#IF (ANSITRACE >= 2) + PUSH AF + PRTS("($") + LD A,(ANSI_PRI) + OR A + CALL NZ,COUT + CALL PC_COMMA + LD DE,ANSI_PARLST + LD A,(ANSI_PARIDX) + INC A + CALL PRTHEXBUF + CALL PC_COMMA + LD A,(ANSI_INT) + OR A + CALL NZ,COUT + CALL PC_COMMA + POP AF + CALL COUT + CALL PC_RPAREN +#ENDIF + ; BRANCH BASED ON PRIVATE CHARACTER OF SEQUENCE + LD A,(ANSI_PRI) ; GET THE PRIVATE CHARACTER + OR A ; SET FLAGS + JR Z,ANSI_STD ; IF ZERO, NO PRIVATE CHAR, DO STANDARD + CP '?' ; '?' = DEC PRIVATE + JR Z,ANSI_DEC ; HANDLE DEC PRIVATE SEQUENCES + JR ANSI_UNK ; UNKNOWN, ABORT +; +ANSI_STD: ; DISPATCH ON INTERMEDIATE CHAR W/ NO PRIVATE CHAR (STD) + LD A,(ANSI_INT) ; GET THE INTERMEDIATE CHARCACTER + OR A ; SET FLAGS + JR Z,ANSI_STD1 ; NO INTERMEDIATE CHARACTER, HANDLE IT + ; CHECK FOR ANY OTHER STD INTERMEDIATE CHARACTERS HERE... + JR ANSI_UNK ; UNKNOWN, ABORT +; +ANSI_STD1: ; DISPATCH FOR FINAL CHAR W/ NO INTERMEDIATE CHAR AND NO PRIVATE CHAR (STD) + LD A,(ANSI_FINAL) ; GET FINAL CHARACTER + CP 'A' ; CUU: CURSOR UP + JP Z,ANSI_CUU + CP 'B' ; CUD: CURSOR DOWN + JP Z,ANSI_CUD + CP 'C' ; CUF: CURSOR FORWARD + JP Z,ANSI_CUF + CP 'D' ; CUB: CURSOR BACKWARD + JP Z,ANSI_CUB + CP 'H' ; CUP: CURSOR POSITION + JP Z,ANSI_CUP + CP 'J' ; ED: ERASE IN DISPLAY + JP Z,ANSI_ED + CP 'K' ; EL: ERASE IN LINE + JP Z,ANSI_EL + CP 'L' ; IL: INSERT LINE + JP Z,ANSI_IL + CP 'M' ; DL: DELETE LINE + JP Z,ANSI_DL + CP 'f' ; HVP: HORIZONTAL/VERTICAL POSITION + JP Z,ANSI_HVP + CP 'g' ; TBC: TAB CLEAR + JP Z,ANSI_TBC + CP 'h' ; SM: SET MODE + JP Z,ANSI_SM + CP 'l' ; RM: RESET MODE + JP Z,ANSI_RM + CP 'm' ; SGR: SELECT GRAPHIC RENDITION + JP Z,ANSI_SGR + ; CHECK FOR ANY OTHERS HERE + JR ANSI_UNK ; UNKNOWN, ABORT +; +ANSI_DEC: ; DISPATCH ON INTERMEDIATE CHAR W/ PRIVATE CHAR = '?' (DEC) + LD A,(ANSI_INT) ; GET THE INTERMEDIATE CHARCACTER + OR A ; SET FLAGS + JR Z,ANSI_DEC1 ; NO INTERMEDIATE CHARACTER, HANDLE IT + ; CHECK FOR ANY OTHER DEC INTERMEDIATE CHARACTERS HERE... + JR ANSI_UNK ; UNKNOWN, ABORT +; +ANSI_DEC1: ; DISPATCH FOR FINAL CHAR W/ NO INTERMEDIATE CHAR AND PRIVATE CHAR = '?' (DEC) + LD A,(ANSI_FINAL) ; GET FINAL CHARACTER + CP 'h' ; SM: SET DEC MODE + JP Z,ANSI_DECSM + CP 'l' ; RM: RESET DEC MODE + JP Z,ANSI_DECRM + JR ANSI_UNK ; UNKNOWN, ABORT +; +ANSI_UNK: ; DIAGNOSE UNKNOWN SEQUENCE +#IF (ANSITRACE >= 2) + PRTS("***UNK***$") +#ENDIF + RET +; +;================================================================================================== +; ANSI PROTOCOL SUPPORT FUNCTIONS +;================================================================================================== +; +; CLEAR THE WORKING VARIABLES AT START OF NEW ESC/CTL SEQUENCE +; +ANSI_CLEAR: + PUSH AF ; PRESERVE AF + LD HL,ANSI_VARS ; POINT TO VARS + LD B,ANSI_VARLEN ; B := NUMBER OF BYTES TO CLEAR + XOR A ; A := 0 +; +ANSI_CLEAR1: ; LOOP + LD (HL),A ; CLEAR THE BYTE + INC HL ; BUMP POINTER + DJNZ ANSI_CLEAR1 ; LOOP AS NEEDED +; + POP AF ; RECOVER AF + RET ; DONE +; +; COLLECT INTERMEDIATE CHARACTERS +; WE DO NOT SUPPORT MORE THAN 1 WHICH IS ALL THAT IS EVER +; USED BY THE STANDARD. IF MORE THAN ONE RECEIVED, IT IS OVERLAID +; +ANSI_COLLINT: + LD (ANSI_INT),A ; RECORD INTERMEDIATE CHAR + RET ; DONE +; +; COLLECT PARAMETERS +; ';' SEPARATES PARAMETERS +; '0'-'9' ARE DIGITS OF CURRENT PARAMETER +; +ANSI_COLLPAR: + ; HANDLE SEPARATOR + CP $3B ; ';' SEPARATOR? + JR NZ,ANSI_COLLPAR1 ; NOPE, CONTINUE + LD A,(ANSI_PARIDX) ; GET CURRENT PARM POS INDEX + INC A ; INCREMENT + AND $0F ; 16 PARMS MAX!!! + LD (ANSI_PARIDX),A ; SAVE IT + RET ; DONE +; +ANSI_COLLPAR1: ; HANDLE '0'-'9' + CP '9' + 1 ; > '9'? + RET NC ; YUP, IGNORE CHAR + SUB '0' ; CONVERT TO BINARY VALUE + LD B,A ; SAVE VALUE IN B + LD A,(ANSI_PARIDX) ; A := CURRENT PARM INDEX + LD HL,ANSI_PARLST ; POINT TO START OF PARM LIST + LD DE,0 ; SETUP DE := 0 + LD E,A ; NOW DE := PARM OFFSET + ADD HL,DE ; NOW HL := PARM BYTE TO UPDATE + LD A,(HL) ; GET CURRENT VALUE + LD C,A ; COPY TO C + RLCA ; MULTIPLY BY 10 + RLCA ; " + ADD A,C ; " + RLCA ; " + ADD A,B ; ADD NEW DIGIT + LD (HL),A ; SAVE UPDATED VALUE + RET ; DONE +; +; COLLECT PRIVATE CHARACTERS +; WE DO NOT SUPPORT MORE THAN 1 WHICH IS ALL THAT IS EVER +; USED BY THE STANDARD. IF MORE THAN ONE RECEIVED, IT IS OVERLAID +; +ANSI_COLLPRI: + LD (ANSI_PRI),A ; RECORD THE PRIVATE CHARACTER + RET ; DONE +; +; CANCEL AN ESC/CTL SEQUENCE IN PROGRESS +; SOME VT TERMINALS WILL SHOW AN ERROR SYMBOL IN THIS CASE +; +ANSI_SUB: + ; DISPLAY AN ERR SYMBOL??? +; +; CANCEL AN ESC/CTL SEQUENCE IN PROGRESS +; +ANSI_CAN: + LD HL,ANSI_STBASE ; SET STATE TO BASE + LD (ANSI_STATE),HL ; SAVE IT + RET +; +; START AN ESC SEQ, CANCEL ANY ESC/CTL SEQUENCE IN PROGRESS +; +ANSI_ESC: + CALL ANSI_CLEAR ; CLEAR STATE RELEATED VARIABLES + LD HL,ANSI_STESC ; SET STATE TO ESCAPE SEQUENCE + LD (ANSI_STATE),HL ; SAVE IT + RET +; +; START A CTL SEQ +; +ANSI_CSI: + CALL ANSI_CLEAR ; CLEAR STATE RELEATED VARIABLES + LD HL,ANSI_STCTL ; SET STATE TO CONTROL SEQUENCE + LD (ANSI_STATE),HL ; SAVE IT + RET +; +;================================================================================================== +; ANSI FUNCTION EXECUTION +;================================================================================================== +; +ANSI_RENDER: +#IF (ANSITRACE >= 2) + LD A,E + CALL COUT +#ENDIF + PUSH DE - ; A reg has next character from BIOS CONOUT - LD B,BF_VDAWRC + ; IF WRAP PENDING, DO IT NOW + LD A,(ANSI_WRAP) ; GET THE WRAP FLAG + OR A ; SET FLAGS + CALL NZ,ANSI_NEL ; IF SET, PERFORM A LINEWRAP (CLEARS WRAP FLAG) +; + ; WRITE THE CHARACTER + POP DE ; RECOVER THE CHAR TO RENDER + LD B,BF_VDAWRC ; FUNC := WRITE CHARACTER CALL EMU_VDADISP ; SPIT OUT THE RAW CHARACTER - - LD A,(ANSI_COL) ; GET CUR COL - INC A ; INCREMENT +; + ; END OF LINE HANDLING (CHECK FOR RIGHT MARGIN EXCEEDED) + LD A,(ANSI_COLS) ; GET SCREEN COLUMNS + LD B,A ; PUT IT IN B + LD A,(ANSI_COL) ; GET COLUMN + INC A ; BUMP IT TO REFLECT NEW CURSOR POSITION LD (ANSI_COL),A ; SAVE IT - LD DE,(ANSI_DIM) ; GET SCREEN DIMENSIONS - CP E ; COMPARE TO COLS IN LINE - RET C ; NOT PAST END OF LINE, ALL DONE - CALL ANSI_CR ; CARRIAGE RETURN - JR ANSI_LF ; LINEFEED AND RETURN + CP B ; PAST MAX? + RET C ; IF NOT, ALL DONE, JUST RETURN +; + ; CURSOR MOVED PAST RIGHT MARGIN, FIX IT AND SET WRAP FLAG + DEC A ; BACK TO RIGHT MARGIN + LD (ANSI_COL),A ; SAVE IT + CALL ANSI_XY ; UPDATE CURSOR POSITION ON SCREEN + LD A,$FF ; LOAD $FF TO SET FLAG + LD (ANSI_WRAP),A ; SAVE FLAG + RET ; AND RETURN ; ANSI_FF: LD DE,0 ; PREPARE TO HOME CURSOR @@ -326,51 +566,747 @@ ANSI_FF: LD E,' ' ; FILL SCREEN WITH BLANKS LD B,BF_VDAFIL ; SET FUNCTION TO FILL CALL EMU_VDADISP ; PERFORM FILL - JR ANSI_XY ; HOME CURSOR AND RETURN + JP ANSI_XY ; HOME CURSOR AND RETURN ; ANSI_BS: - LD DE,(ANSI_POS) ; GET CURRENT ROW/COL IN DE - LD A,E ; GET CURRENT COLUMN - CP 1 ; COMPARE TO COLUMN 1 - RET C ; LESS THAN 1, NOTHING TO DO - DEC E ; POINT TO PREVIOUS COLUMN - LD (ANSI_POS),DE ; SAVE NEW COLUMN VALUE - CALL ANSI_XY ; MOVE CURSOR TO NEW TARGET COLUMN - LD E,' ' ; LOAD A SPACE CHARACTER - LD B,BF_VDAWRC ; SET FUNCTION TO WRITE CHARACTER - CALL EMU_VDADISP ; OVERWRITE WITH A SPACE CHARACTER - JR ANSI_XY ; NEED TO MOVE CURSOR BACK TO NEW TARGET COLUMN + LD A,(ANSI_COL) ; GET CURRENT COLUMN + DEC A ; BACK IT UP BY ONE + RET C ; IF CARRY, MARGIN EXCEEDED, ABORT + LD (ANSI_COL),A ; SAVE NEW COLUMN + JP ANSI_XY ; UDPATE CUSROR AND RETURN ; ANSI_CR: XOR A ; ZERO ACCUM LD (ANSI_COL),A ; COL := 0 - JR ANSI_XY ; REPOSITION CURSOR AND RETURN + JP ANSI_XY ; REPOSITION CURSOR AND RETURN ; -ANSI_LF: +ANSI_LF: ; LINEFEED (FORWARD INDEX) LD A,(ANSI_ROW) ; GET CURRENT ROW - INC A ; BUMP TO NEXT - LD (ANSI_ROW),A ; SAVE IT LD DE,(ANSI_DIM) ; GET SCREEN DIMENSIONS - CP D ; COMPARE TO SCREEN ROWS - JR C,ANSI_XY ; NOT PAST END, ALL DONE - DEC D ; D NOW HAS MAX ROW NUM (ROWS - 1) - SUB D ; A WILL NOW HAVE NUM LINES TO SCROLL - LD E,A ; LINES TO SCROLL -> E + DEC D ; D := MAX ROW NUM + CP D ; >= LAST ROW? + JR NC,ANSI_LF1 ; NEED TO SCROLL + INC A ; BUMP TO NEXT ROW + LD (ANSI_ROW),A ; SAVE IT + JP ANSI_XY ; UPDATE CURSOR AND RETURN +; +ANSI_LF1: ; SCROLL + LD E,1 ; SCROLL FORWARD 1 LINE LD B,BF_VDASCR ; SET FUNCTION TO SCROLL - CALL EMU_VDADISP ; DO THE SCROLLING - LD A,(ANSI_ROWS) ; GET SCREEN ROW COUNT - DEC A ; A NOW HAS LAST ROW + JP EMU_VDADISP ; DO THE SCROLLING AND RETURN +; +ANSI_RI: ; REVERSE INDEX (REVERSE LINEFEED) + LD A,(ANSI_ROW) ; GET CURRENT ROW + OR A ; SET FLAGS + JR Z,ANSI_RI1 ; IF AT TOP (ROW 0), NEED TO SCROLL + DEC A ; BUMP TO PRIOR ROW LD (ANSI_ROW),A ; SAVE IT - JR ANSI_XY ; RESPOSITION CURSOR AND RETURN + JP ANSI_XY ; RESPOSITION CURSOR AND RETURN +; +ANSI_HT: ; HORIZONTAL TAB +; + ; CHECK FOR RIGHT MARGIN, IF AT MARGIN, IGNORE + LD A,(ANSI_COLS) ; GET SCREEN COLUMN COUNT + DEC A ; MAKE IT MAX COL NUM + LD B,A ; SAVE IN B + LD A,(ANSI_COL) ; GET CURRENT COLUMN + CP B ; COMPARE TO MAX + RET NC ; IF COL >= MAX, IGNORE +; + ; INCREMENT COL TILL A TAB STOP IS HIT OR RIGHT MARGIN +ANSI_HT1: + INC A ; NEXT COLUMN + PUSH AF ; SAVE COLUMN + PUSH BC ; SAVE MAX COLUMN + LD HL,ANSI_TABS ; POINT TO TABSTOP BITMAP + CALL BITTST ; TEST BIT FOR CURRENT COLUMN + POP BC ; RECOVER MAX COLUMN + POP AF ; RECOVER CUR COLUMN + JR NZ,ANSI_HT2 ; IF TABSTOP HIT, COMMIT NEW COLUMN + CP B ; TEST FOR RIGHT MARGIN + JR NC,ANSI_HT2 ; IF AT RIGHT MARGIN, COMMIT NEW COLUMN + JR ANSI_HT1 ; LOOP UNTIL DONE +; +ANSI_HT2: ; COMMIT THE NEW COLUMN VALUE + LD (ANSI_COL),A ; SAVE THE NEW COLUMN + JP ANSI_XY ; UPDATE CURSOR AND RETURN +; +ANSI_RI1: ; REVERSE SCROLL + LD E,-1 ; SCROLL -1 LINES (REVERSE SCROLL 1 LINE) + LD B,BF_VDASCR ; SET FUNCTION TO SCROLL + JP EMU_VDADISP ; DO THE SCROLLING AND RETURN +; +; +; +ANSI_HTS: ; HORIZONTAL TAB SET + LD HL,ANSI_TABS ; POINT TO TAB STOP BITMAP + LD A,(ANSI_COL) ; SET TAB STOP AT CURRENT COL + CALL BITSET ; SET THE APPROPRIATE BIT + RET +; +; +; +ANSI_TBC: ; TAB CLEAR + LD A,(ANSI_PARLST) ; GET FIRST PARM + OR A ; SET FLAGS + JR Z,ANSI_TBC1 ; 0 = CLEAR TAB AT CURRENT COL + CP 3 ; TEST FOR 3 + JR Z,ANSI_TBC2 ; 3 = CLEAR ALL TABS + RET ; ANYTHING ELSE IS IGNORED +; +ANSI_TBC1: ; CLEAR TAB AT CURRENT COL + LD HL,ANSI_TABS ; POINT TO TAB STOP BITMAP + LD A,(ANSI_COL) ; SET TAB STOP AT CURRENT COL + CALL BITCLR ; CLEAR THE APPROPRIATE BIT + RET ; DONE +; +ANSI_TBC2: ; CLEAR ALL TABS + LD HL,ANSI_TABS ; POINT TO TABSTOP BITMAP + LD B,32 ; CLEAR 32 BYTES + XOR A ; CLEAR WITH VALUE OF ZERO +; +ANSI_TBC3: ; CLEAR ALL TABS LOOP + LD (HL),A ; SET THE CURRENT BYTE + INC HL ; POINT TO NEXT BYTE + DJNZ ANSI_TBC3 ; LOOP UNTIL DONE + RET ; DONE +; +; +; +ANSI_SM: ; SET MODE +ANSI_DECSM: ; SET DEC MODE + LD C,$FF ; FLAG VALUE (SET VALUE) + JR ANSI_MODE ; GO TO SET/RESET MODE +; +ANSI_RM: ; RESET MODE +ANSI_DECRM: ; RESET DEC MODE + LD C,$00 ; FLAG VALUE (RESET VALUE) + JR ANSI_MODE ; GO TO SET/RESET MODE +; +ANSI_MODE: ; (RE)SET MODES, FLAG VALUE IN C + LD A,(ANSI_PARIDX) ; GET CURRENT PARM INDEX + INC A ; INCREMENT TO MAKE IT THE PARM COUNT + LD B,A ; MOVE COUNT TO B FOR LOOPING + LD HL,ANSI_PARLST ; USE HL AS PARM POINTER + +ANSI_MODE1: ; (RE)SET MODE LOOP + CALL ANSI_MODE2 + INC HL + DJNZ ANSI_MODE1 + +ANSI_MODE2: ; (RE)SET MODE LOOP + LD A,(ANSI_PRI) ; GET PRIVATE CHAR + OR A ; SET FLAGS + JR Z,ANSI_MODE3 ; IF ZERO, HANDLE SANDARD MODES + CP '?' ; IF '?', DEC PRIVATE + JR Z,ANSI_MODE4 ; HANDLE DEC PRIVATE MODES + RET ; OTHERWISE IGNORE +; +ANSI_MODE3: ; STANDARD MODES + LD A,(HL) ; GET PARM + INC HL ; INCREMENT POINTER FOR NEXT LOOP + CP 20 ; LNM: LINE FEED NEW LINE MODE? + JR Z,ANSI_MDLNM ; DO IT + RET ; OTHERWISE IGNORE +; +ANSI_MODE4: ; DEC PRIVATE MODES + LD A,(HL) ; GET PARM + CP 1 ; DECCKM: DEC CURSOR KEY MODE + JR Z,ANSI_MDDECCKM ; DO IT + CP 7 ; DECAWM: DEC AUTOWRAP MODE + JR Z,ANSI_MDDECAWM ; DO IT + RET ; OTHERWISE IGNORE +; +ANSI_MDLNM: ; (RE)SET LINE FEED NEW LINE MODE + LD A,C ; GET THE VALUE + LD (ANSI_LNM),A ; SAVE IT + RET +; +ANSI_MDDECCKM: ; (RE)SET DEC CURSOR KEY MODE FLAG + LD A,C ; GET THE VALUE + LD (ANSI_CKM),A ; SAVE IT + RET ; DONE +; +ANSI_MDDECAWM: ; (RE)SET DEC AUTOWRAP MODE + LD A,C ; GET THE VALUE + LD (ANSI_AWM),A ; SAVE IT + RET ; DONE +; +; +; +ANSI_NEL: ; NEXT LINE + CALL ANSI_CR + JP ANSI_LF +; +; +; +ANSI_CUU: ; CURSOR UP + LD A,(ANSI_PARLST) ; GET PARM + OR A ; SET FLAGS + JR NZ,ANSI_CUU1 ; WE HAVE A PARM, CONTINUE + INC A ; DEFAULT TO 1 +; +ANSI_CUU1: + LD B,A ; PARM IN B + LD A,(ANSI_ROW) ; GET CURRENT ROW + SUB B ; DECREMENT BY PARM VALUE + JR NC,ANSI_CUU2 ; NO CARRY, WE ARE GOOD + XOR A ; LESS THAN 0, FIX IT +; +ANSI_CUU2: + LD (ANSI_ROW),A ; SAVE IT + JP ANSI_XY ; MOVE CURSOR AND RETURN +; +; +; +ANSI_CUD: ; CURSOR DOWN + LD A,(ANSI_PARLST) ; GET PARM + OR A ; SET FLAGS + JR NZ,ANSI_CUD1 ; WE HAVE A PARM, CONTINUE + INC A ; DEFAULT TO 1 +ANSI_CUD1: + LD B,A ; PARM IN B + LD A,(ANSI_ROWS) ; GET ROW COUNT + DEC A ; DEC FOR MAX ROW NUM + LD C,A ; MAX ROW NUM IN C + LD A,(ANSI_ROW) ; GET CURRENT ROW + ADD A,B ; ADD PARM VALUE, A HAS NEW ROW + CP C ; COMPARE NEW ROW TO MAX ROW + JR C,ANSI_CUD2 ; IF CARRY, WE ARE WITHIN MARGIN + LD A,C ; OTHERWISE, SET TO MARGIN +; +ANSI_CUD2: + LD (ANSI_ROW),A ; SAVE IT + JP ANSI_XY ; MOVE CURSOR AND RETURN +; +; +; +ANSI_CUF: ; CURSOR FORWARD + LD A,(ANSI_PARLST) ; GET PARM + OR A ; SET FLAGS + JR NZ,ANSI_CUF1 ; WE HAVE A PARM, CONTINUE + INC A ; DEFAULT TO 1 +; +ANSI_CUF1: + LD B,A ; PARM IN B + LD A,(ANSI_COLS) ; GET COL COUNT + DEC A ; DEC FOR MAX COL NUM + LD C,A ; MAX COL NUM IN C + LD A,(ANSI_COL) ; GET CURRENT COL + ADD A,B ; ADD PARM VALUE, A HAS NEW COL + CP C ; COMPARE NEW COL TO MAX COL + JR C,ANSI_CUF2 ; IF CARRY, WE ARE WITHIN MARGINS + LD A,C ; OTHERWISE, SET TO MARGIN +; +ANSI_CUF2: + LD (ANSI_COL),A ; SAVE IT + JP ANSI_XY ; MOVE CURSOR AND RETURN +; +; +; +ANSI_CUB: ; CURSOR BACKWARD + LD A,(ANSI_PARLST) ; GET PARM + OR A ; SET FLAGS + JR NZ,ANSI_CUB1 ; WE HAVE A PARM, CONTINUE + INC A ; DEFAULT TO 1 +; +ANSI_CUB1: + LD B,A ; PARM IN B + LD A,(ANSI_COL) ; GET CURRENT COL + SUB B ; DECREMENT BY PARM VALUE + JR NC,ANSI_CUB2 ; NO CARRY, WE ARE GOOD + XOR A ; LESS THAN 0, FIX IT +; +ANSI_CUB2: + LD (ANSI_COL),A ; SAVE IT + JP ANSI_XY ; MOVE CURSOR AND RETURN +; +; +; +ANSI_CUP: ; CURSOR UPDATE +ANSI_HVP: ; HORIZONTAL/VERTICAL POSITION +; + ; HANDLE ROW NUMBER + LD A,(ANSI_PARLST + 0) ; ROW PARM + DEC A ; ADJUST FOR ZERO OFFSET + JP P,ANSI_CUP1 ; 0 OR MORE, OK, CONTINUE + XOR A ; NEGATIVE, FIX IT +ANSI_CUP1: + LD HL,ANSI_ROWS ; HL POINTS TO ROW COUNT + CP (HL) ; COMPARE TO ROW COUNT + JR C,ANSI_CUP2 ; IN BOUNDS, CONTINUE + LD A,(HL) ; FIX IT, LOAD ROW COUNT + DEC A ; SET TO LAST ROW NUM +ANSI_CUP2: + LD D,A ; COMMIT ROW NUMBER TO D +; + ; HANDLE COL NUMBER + LD A,(ANSI_PARLST + 1) ; COL PARM + DEC A ; ADJUST FOR ZERO OFFSET + JP P,ANSI_CUP3 ; 0 OR MORE, OK, CONTINUE + XOR A ; NEGATIVE, FIX IT +ANSI_CUP3: + LD HL,ANSI_COLS ; HL POINTS TO COL COUNT + CP (HL) ; COMPARE TO COL COUNT + JR C,ANSI_CUP4 ; IN BOUNDS, CONTINUE + LD A,(HL) ; FIX IT, LOAD COL COUNT + DEC A ; SET TO LAST COL NUM +ANSI_CUP4: + LD E,A ; COMMIT COL NUMBER TO E +; + ; COMMIT THE NEW CURSOR POSITION AND RETURN + LD (ANSI_POS),DE ; SAVE IT + JP ANSI_XY ; UPDATE CURSOR AND RETURN +; +; +; +ANSI_ED: ; ERASE IN DISPLAY + LD A,(ANSI_PARLST + 0) ; GET FIRST PARM + CP 0 ; ERASE CURSOR TO EOS + JR Z,ANSI_ED1 + CP 1 ; ERASE START THRU CURSOR + JR Z,ANSI_ED2 + CP 2 ; ERASE FULL DISPLAY? + JR Z,ANSI_ED3 + RET ; INVALID? +; +ANSI_ED1: ; ERASE CURSOR THRU EOS + LD DE,(ANSI_POS) ; GET CURSOR POSITION + CALL ANSI_XY2IDX ; HL NOW HAS CURSOR INDEX + PUSH HL ; SAVE IT + LD DE,(ANSI_DIM) ; GET SCREEN DIMENSIONS + LD E,0 ; COL POSITION := 0 + CALL ANSI_XY2IDX ; HL NOW HAS EOS INDEX + POP DE ; RECOVER CURSOR POS INDEX + OR A ; CLEAR CARRY + SBC HL,DE ; SUBTRACT CURSOR INDEX FROM EOS INDEX + JR ANSI_ED4 ; COMPLETE THE FILL +; +ANSI_ED2: ; ERASE START THRU CURSOR + LD DE,0 ; CURSOR TO 0,0 FOR NOW + LD B,BF_VDASCP ; SET FUNCTION TO SET CURSOR POSITION + CALL EMU_VDADISP ; DO IT + LD DE,(ANSI_POS) ; GET ORIGINAL CURSOR POSITION + CALL ANSI_XY2IDX ; HL NOW HAS INDEX + INC HL ; ADD 1 POSITION TO ERASE THRU CURSOR POSITION + JR ANSI_ED4 ; COMPLETE THE FILL +; +ANSI_ED3: ; ERASE FULL DISPLAY + LD DE,0 ; CURSOR POS 0,0 + LD B,BF_VDASCP ; FUNCTION = SET CURSOR POS + CALL EMU_VDADISP ; DO IT + LD DE,(ANSI_DIM) ; DE := SCREEN ROWS/COLS + CALL ANSI_XY2IDX ; HL := CHARS ON SCREEN +; +ANSI_ED4: ; COMMON FILL PROCESS COMPLETION + LD E,' ' ; FILL WITH BLANK + LD B,BF_VDAFIL ; FUNCTION = FILL + CALL EMU_VDADISP ; DO IT + JP ANSI_XY ; RESTORE CURSOR POS AND RETURN +; +; +; +ANSI_EL: ; ERASE IN LINE + LD A,(ANSI_PARLST + 0) ; GET FIRST PARM + CP 0 ; ERASE CURSOR TO EOL + JR Z,ANSI_EL1 + CP 1 ; ERASE START THRU CURSOR + JR Z,ANSI_EL2 + CP 2 ; ERASE FULL LINE? + JR Z,ANSI_EL3 + RET ; INVALID? +; +ANSI_EL1: ; ERASE CURSOR THRU EOL + LD DE,(ANSI_POS) ; GET CURSOR POSITION + CALL ANSI_XY2IDX ; HL NOW HAS CURSOR INDEX + PUSH HL ; SAVE IT + LD DE,(ANSI_POS) ; GET CURSOR POSITION + LD E,0 ; COL POSITION := 0 + INC D ; ROW := ROW + 1 + CALL ANSI_XY2IDX ; HL NOW HAS EOL INDEX + POP DE ; RECOVER CURSOR POS INDEX + OR A ; CLEAR CARRY + SBC HL,DE ; SUBTRACT CURSOR INDEX FROM EOL INDEX + JR ANSI_EL4 ; COMPLETE THE FILL +; +ANSI_EL2: ; ERASE START THRU CURSOR + LD DE,(ANSI_POS) ; GET CURSOR POS + LD E,0 ; COL := 0, START OF ROW + LD B,BF_VDASCP ; SET FUNCTION TO SET CURSOR POSITION + CALL EMU_VDADISP ; DO IT + LD HL,(ANSI_POS) ; GET ORIGINAL CURSOR POSITION + LD H,0 ; ONLY ERASE COLUMNS + INC HL ; ADD 1 POSITION TO ERASE THRU CURSOR POSITION + JR ANSI_EL4 ; COMPLETE THE FILL +; +ANSI_EL3: ; ERASE FULL LINE + LD DE,(ANSI_POS) ; GET CURSOR POSITION + LD E,0 ; COL := 0 (START OF ROW) + LD B,BF_VDASCP ; FUNC = SET CURSOR POS + CALL EMU_VDADISP ; DO IT + LD HL,(ANSI_DIM) ; GET SCREEN DIM IN HL + LD H,0 ; H := 0, HL IS NOW CHARS IN A LINE + JR ANSI_EL4 ; COMPLETE THE FILL +; +ANSI_EL4 .EQU ANSI_ED4 ; REUSE CODE ABOVE +; +; +; +ANSI_IL: + LD A,(ANSI_PARLST) ; GET PARM + OR A ; SET FLAGS + JR NZ,ANSI_IL1 ; GOT IT CONTINUE + INC A ; NO PARM, DEFAULT TO 1 +; +ANSI_IL1: + LD B,A ; SET LOOP COUNTER + LD DE,(ANSI_DIM) ; GET SCREEN DIMENSIONS + DEC D ; POINT TO LAST ROW + LD E,0 ; FIRST CHAR OF ROW +; +ANSI_IL2: + PUSH BC ; PRESERVE LOOP COUNTER + PUSH DE ; PRESERVE STARTING POSTION + CALL ANSI_IL3 ; DO AN ITERATION + POP DE ; RECOVER STARTING POSITION + POP BC ; RECOVER LOOP COUNTER + DJNZ ANSI_IL2 ; LOOP AS NEEDED +; + ; RESTORE CURSOR POSTION AND RETURN + JP ANSI_XY +; +ANSI_IL3: + ; SET CURSOR POSITION TO DEST + PUSH DE ; PRESERVE DE + LD B,BF_VDASCP ; FUNC = SET CURSOR POS + CALL EMU_VDADISP ; DO IT + POP DE ; RECOVER DE + ; SET HL TO LENGTH + LD HL,(ANSI_DIM) ; GET DIMENSIONS + LD H,0 ; ZERO MSB, SO COPY LEN IS COL COUNT + ; CHECK ROW, GET OUT IF WORKING ROW IS CURRENT ROW + LD A,(ANSI_ROW) ; GET CURRENT ROW + CP D ; COMPARE TO WORKING ROW NUM + JR Z,ANSI_IL4 ; IF EQUAL WE ARE DONE + ; SET DE TO SOURCE POS + DEC D ; DE NOW POINTS TO PRIOR ROW + ; DO THE COPY + PUSH DE ; PRESERVE DE + LD B,BF_VDACPY ; FUNCTION = COPY + CALL EMU_VDADISP ; COPY THE LINE + POP DE ; RECOVER DE + JR ANSI_IL3 ; LOOP +; +ANSI_IL4: ;CLEAR INSERTED LINE + LD E,' ' ; FILL WITH BLANK + LD B,BF_VDAFIL ; FUNCTION = FILL + JP EMU_VDADISP ; DO IT +; +; +; +ANSI_DL: + LD A,(ANSI_PARLST) ; GET PARM + OR A ; SET FLAGS + JR NZ,ANSI_DL1 ; GOT IT CONTINUE + INC A ; NO PARM, DEFAULT TO 1 +; +ANSI_DL1: + LD B,A ; SET LOOP COUNTER + LD DE,(ANSI_POS) ; GET CURSOR POS + LD E,0 ; COL := 0, START OF ROW +; +ANSI_DL2: + PUSH BC ; PRESERVE LOOP COUNTER + PUSH DE ; PRESERVE STARTING POSTION + CALL ANSI_DL3 ; DO AN ITERATION + POP DE ; RECOVER STARTING POSITION + POP BC ; RECOVER LOOP COUNTER + DJNZ ANSI_DL2 ; LOOP AS NEEDED +; + ; RESTORE CURSOR POSTION AND RETURN + JP ANSI_XY +; +ANSI_DL3: + ; SET CURSOR TO START OF DEST ROW + PUSH DE ; PRESERVE DE + LD B,BF_VDASCP ; FUNC = SET CURSOR POS + CALL EMU_VDADISP ; DO IT + POP DE ; RECOVER DE + ; SET DE TO SOURCE POS + INC D ; NEXT ROW, DE NOW HAS SOURCE + ; SET HL TO LENGTH + LD HL,(ANSI_DIM) ; GET DIMENSIONS + LD H,0 ; ZERO MSB, SO COPY LEN IS COL COUNT + ; CHECK ROW, GET OUT IF WORKING ROW NUM PAST END + LD A,(ANSI_ROWS) ; GET ROW COUNT + CP D ; COMPARE TO WORKING ROW NUM + JR Z,ANSI_DL4 ; IF EQUAL WE ARE DONE + ; DO THE COPY + PUSH DE ; PRESERVE DE + LD B,BF_VDACPY ; FUNCTION = COPY + CALL EMU_VDADISP ; COPY THE LINE + POP DE ; RECOVER DE + JR ANSI_DL3 ; LOOP +; +ANSI_DL4: ;CLEAR BOTTOM LINE + LD E,' ' ; FILL WITH BLANK + LD B,BF_VDAFIL ; FUNCTION = FILL + JP EMU_VDADISP ; DO IT +; +; +; +ANSI_SGR: ; SET GRAPHIC RENDITION + LD A,(ANSI_PARIDX) ; GET CURRENT PARM INDEX + INC A ; INC TO MAKE IT THE COUNT + LD B,A ; B IS NOW LOOP COUNTER + LD HL,ANSI_PARLST ; HL POINTS TO START OF PARM LIST +; +ANSI_SGR1: ; PROCESSING LOOP + PUSH BC ; PRESERVE BC + PUSH HL ; PRESERVE HL + LD A,(HL) + CALL ANSI_SGR2 ; HANDLE PARM + POP HL ; RESTORE HL + POP BC ; RESTORE BC + INC HL ; POINT TO NEXT PARM + DJNZ ANSI_SGR1 ; LOOP TILL DONE +; + ; NOW IMPLEMENT ALL CHANGES + LD A,(ANSI_ATTR) ; GET THE ATTRIBUTE VALUE + LD E,A ; MOVE TO E + LD B,BF_VDASAT ; SET ATTRIBUTE FUNCTION + CALL EMU_VDADISP ; CALL THE FUNCTION + LD A,(ANSI_COLOR) ; GET THE COLOR VALUE + LD E,A ; MOVE TO E + LD B,BF_VDASCO ; SET ATTRIBUTE FUNCTION + CALL EMU_VDADISP ; CALL THE FUNCTION + RET ; RETURN +; +ANSI_SGR2: ; HANDLE THE REQUEST CODE + CP 0 ; ALL OFF + JR Z,ANSI_SGR_OFF ; DO IT + CP 1 ; BOLD + JR Z,ANSI_SGR_BOLD ; DO IT + CP 4 ; UNDERLINE + JR Z,ANSI_SGR_UL ; DO IT + CP 5 ; BLINK + JR Z,ANSI_SGR_BLINK ; DO IT + CP 7 ; REVERSE + JR Z,ANSI_SGR_REV ; DO IT + CP 30 ; START OF FOREGROUND + RET C ; OUT OF RANGE + CP 38 ; END OF RANGE + JR C,ANSI_SGR_FG ; SET FOREGROUND + CP 40 ; START OF BACKGROUND + RET C ; OUT OF RANGE + CP 48 ; END OF RANGE + JR C,ANSI_SGR_BG ; SET BACKGROUND + RET ; OTHERWISE OUT OF RANGE +; +ANSI_SGR_OFF: + LD A,ANSI_DEFATTR ; DEFAULT ATTRIBUTE + LD (ANSI_ATTR),A ; CLEAR ATTRIBUTES + LD A,ANSI_DEFCOLOR ; DEFAULT COLOR + LD (ANSI_COLOR),A ; RESET COLOR + RET +; +ANSI_SGR_BOLD: + LD A,(ANSI_COLOR) ; LOAD CURRENT COLOR + OR %00001000 ; SET BOLD BIT + LD (ANSI_COLOR),A ; SAVE IT + RET +; +ANSI_SGR_UL: + LD A,(ANSI_ATTR) ; LOAD CURRENT ATTRIBUTE + OR %00000010 ; SET UNDERLINE BIT + LD (ANSI_ATTR),A ; SAVE IT + RET +; +ANSI_SGR_BLINK: + LD A,(ANSI_ATTR) ; LOAD CURRENT ATTRIBUTE + OR %00000001 ; SET BLINK BIT + LD (ANSI_ATTR),A ; SAVE IT + RET +; +ANSI_SGR_REV: + LD A,(ANSI_ATTR) ; LOAD CURRENT ATTRIBUTE + OR %00000100 ; SET REVERSE BIT + LD (ANSI_ATTR),A ; SAVE IT + RET +; +ANSI_SGR_FG: + SUB 30 + LD E,A + LD A,(ANSI_COLOR) + AND %11111000 + OR E + LD (ANSI_COLOR),A + RET +; +ANSI_SGR_BG: + SUB 40 + RLCA + RLCA + RLCA + RLCA + LD E,A + LD A,(ANSI_COLOR) + AND %10001111 + OR E + LD (ANSI_COLOR),A + RET +; +; +; +ANSI_DECALN: ; DEC SCREEN ALIGNMENT TEST + LD DE,0 ; PREPARE TO HOME CURSOR + LD (ANSI_POS),DE ; SAVE NEW CURSOR POSITION + CALL ANSI_XY ; EXECUTE + LD DE,(ANSI_DIM) ; GET SCREEN DIMENSIONS + LD H,D ; SET UP TO MULTIPLY ROWS BY COLS + CALL MULT8 ; HL := H * E TO GET TOTAL SCREEN POSITIONS + LD E,'E' ; FILL SCREEN WITH BLANKS + LD B,BF_VDAFIL ; SET FUNCTION TO FILL + CALL EMU_VDADISP ; PERFORM FILL + JP ANSI_XY ; HOME CURSOR AND RETURN +; +;================================================================================================== +; ANSI PROTOCOL KEYBOARD DISPATCHING +;================================================================================================== +; +; HANDLE SPECIAL KEYBOARD CHARACTERS BY FILLING QUEUE WITH DATA +; +ANSI_KDISP: + ; RESET THE QUEUE POINTER + LD HL,ANSI_QUEUE + LD (ANSI_QPTR),HL +; + ; HANDLE FUNCTION KEYS + LD B,'P' + CP $E0 ; F1 + JR Z,ANSI_KDISP_FN + LD B,'Q' + CP $E1 ; F2 + JR Z,ANSI_KDISP_FN + LD B,'R' + CP $E2 ; F3 + JR Z,ANSI_KDISP_FN + LD B,'S' + CP $E3 ; F4 + JR Z,ANSI_KDISP_FN +; + ; HANDLE EDIT KEYS + LD B,'2' + CP $F0 ; INSERT + JR Z,ANSI_KDISP_ED + LD B,'3' + CP $F1 ; DELETE + JR Z,ANSI_KDISP_ED + LD B,'1' + CP $F2 ; HOME + JR Z,ANSI_KDISP_ED + LD B,'4' + CP $F3 ; END + JR Z,ANSI_KDISP_ED + LD B,'5' + CP $F4 ; PAGEUP + JR Z,ANSI_KDISP_ED + LD B,'6' + CP $F5 ; PAGEDOWN + JR Z,ANSI_KDISP_ED +; + ; HANDLE DIRECTION KEYS + LD B,'A' + CP $F6 ; UP + JR Z,ANSI_KDISP_DIR + LD B,'B' + CP $F7 ; DOWN + JR Z,ANSI_KDISP_DIR + LD B,'D' + CP $F8 ; LEFT + JR Z,ANSI_KDISP_DIR + LD B,'C' + CP $F9 ; RIGHT + JR Z,ANSI_KDISP_DIR +; + RET ; NO MATCH, DONE +; +ANSI_KDISP_FN: ; ADD FUNCTION KEY SEQUENCE TO QUEUE + LD A,$1B + LD (HL),A + INC HL + LD A,'O' + LD (HL),A + INC HL + LD A,B + LD (HL),A + LD A,3 + LD (ANSI_QLEN),A + RET +; +ANSI_KDISP_ED: ; ADD EDIT KEY SEQUENCE TO QUEUE + LD A,$1B + LD (HL),A + INC HL + LD A,'[' + LD (HL),A + INC HL + LD A,B + LD (HL),A + INC HL + LD A,'~' + LD (HL),A + LD A,4 + LD (ANSI_QLEN),A + RET +; +ANSI_KDISP_DIR: ; ADD DIRECTION KEY SEQUENCE TO QUEUE +; + ; SPECIAL CASE FOR CURSOR KEY MODE + LD A,(ANSI_CKM) + OR A + JR NZ,ANSI_KDISP_FN ; HANDLE LIKE FUNCTION KEY +; + LD A,$1B + LD (HL),A + INC HL + LD A,'[' + LD (HL),A + INC HL + LD A,B + LD (HL),A + LD A,3 + LD (ANSI_QLEN),A + RET +; +;================================================================================================== +; SUPPORT FUNCTIONS +;================================================================================================== ; ANSI_XY: + XOR A ; ZERO ACCUM + LD (ANSI_WRAP),A ; CLEAR THE WRAP FLAG LD DE,(ANSI_POS) ; GET THE DESIRED CURSOR POSITION - LD B,BF_VDASCP ; SET FUNCTIONT TO SET CURSOR POSITION + LD B,BF_VDASCP ; SET FUNCTION TO SET CURSOR POSITION JP EMU_VDADISP ; REPOSITION CURSOR ; -; The ANSI_STATE variable (word) contains the -; address of the next state function -ANSI_STATE .DW ANSI_STATE0 ; by default, ANSI_STATE0 +; CONVERT XY COORDINATES IN DE INTO LINEAR INDEX IN HL +; D=ROW, E=COL +; +ANSI_XY2IDX: + PUSH DE + LD HL,(ANSI_DIM) ; GET DIMENSIONS + LD H,L ; COLS -> H + LD E,D ; ROW NUM -> E + CALL MULT8 ; HL := H * E (ROW OFFSET) + POP DE ; RECOVER ORIGINAL ROW/COL + LD D,0 ; GET RID OF ROW COUNT + ADD HL,DE ; ADD COLUMN OFFSET + RET ; RETURN, HL HAS INDEX +; +;================================================================================================== +; WORKING DATA STORAGE +;================================================================================================== ; ANSI_POS: ANSI_COL .DB 0 ; CURRENT COLUMN - 0 BASED @@ -379,3 +1315,23 @@ ANSI_ROW .DB 0 ; CURRENT ROW - 0 BASED ANSI_DIM: ANSI_COLS .DB 80 ; NUMBER OF COLUMNS ON SCREEN ANSI_ROWS .DB 24 ; NUMBER OF ROWS ON SCREEN +; +ANSI_STATE .DW PANIC ; CURRENT FUNCTION FOR STATE MACHINE +ANSI_ATTR .DB ANSI_DEFATTR ; CURRENT CHARACTER ATTRIBUTE +ANSI_COLOR .DB ANSI_DEFCOLOR ; CURRENT CHARACTER COLOR; +ANSI_WRAP .DB 0 ; WRAP PENDING FLAG +ANSI_TABS .FILL 32,0 ; TAB STOP BIT MAP (256 BITS) +ANSI_LNM .DB 0 ; LINE FEED NEW LINE MODE FLAG +ANSI_CKM .DB 0 ; DEC CURSOR KEY MODE FLAG +ANSI_AWM .DB 0 ; DEC AUTOWRAP MODE FLAG +ANSI_QLEN .DB 0 ; INPUT QUEUE LENGTH +ANSI_QPTR .DW 0 ; CURRENT QUEUE POINTER +ANSI_QUEUE .FILL 16,0 ; 16 BYTE QUEUE BUFFER +; +ANSI_VARS: +ANSI_PRI .DB 0 ; PRIVATE CHARACTER RECORDED HERE +ANSI_INT .DB 0 ; INTERMEDIATE CHARACTER RECORDED HERE +ANSI_FINAL .DB 0 ; FINAL CHARACTER RECORDED HERE +ANSI_PARIDX .DB 0 ; NUMBER OF PARAMETERS RECORDED +ANSI_PARLST .FILL 16,0 ; PARAMETER VALUE LIST (UP TO 16 BYTE VALUES) +ANSI_VARLEN .EQU $ - ANSI_VARS diff --git a/branches/dwg/Source/config_n8_2312.asm b/branches/dwg/Source/config_n8_2312.asm index f225a5a3..13104efd 100644 --- a/branches/dwg/Source/config_n8_2312.asm +++ b/branches/dwg/Source/config_n8_2312.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU TRUE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU TRUE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8_2511.asm b/branches/dwg/Source/config_n8_2511.asm index a4a0bc8c..44f2a34a 100644 --- a/branches/dwg/Source/config_n8_2511.asm +++ b/branches/dwg/Source/config_n8_2511.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU TRUE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU TRUE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_cvdu.asm b/branches/dwg/Source/config_n8vem_cvdu.asm index a87400e1..99a99b86 100644 --- a/branches/dwg/Source/config_n8vem_cvdu.asm +++ b/branches/dwg/Source/config_n8vem_cvdu.asm @@ -10,7 +10,7 @@ CPUFREQ .EQU 8 ; IN MHZ, USED TO COMPUTE DELAY FACTORS DEFCON .EQU CIODEV_UART ; DEFAULT CONSOLE DEVICE (LOADER AND MONITOR): CIODEV_UART, CIODEV_VDU, DIODEV_PRPCON ALTCON .EQU DEFCON ; ALT CONSOLE DEVICE (USED WHEN CONFIG JUMPER SHORTED) DEFVDA .EQU VDADEV_CVDU ; DEFAULT VDA (VDADEV_NONE, VDADEV_VDU, VDADEV_CVDU, VDADEV_UPD7220, VDADEV_N8V) -DEFEMU .EQU EMUTYP_TTY ; DEFAULT EMULATION TYPE (EMUTYP_TTY, EMUTYP_ANSI, ...) +DEFEMU .EQU EMUTYP_ANSI ; DEFAULT EMULATION TYPE (EMUTYP_TTY, EMUTYP_ANSI, ...) ; RAMSIZE .EQU 512 ; SIZE OF RAM IN KB, MUST MATCH YOUR HARDWARE!!! CLRRAMDISK .EQU CLR_AUTO ; CLR_ALWAYS, CLR_NEVER, CLR_AUTO (CLEAR IF INVALID DIR AREA) @@ -46,7 +46,7 @@ IDETRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF IDEENABLE IDE8BIT .EQU FALSE ; USE IDE 8BIT TRANSFERS (PROBABLY ONLY WORKS FOR CF CARDS!) IDECAPACITY .EQU 64 ; CAPACITY OF DEVICE (IN MB) ; -PPIDEENABLE .EQU FALSE ; TRUE FOR PPIDE SUPPORT (DO NOT COMBINE WITH DSKYENABLE) +PPIDEENABLE .EQU TRUE ; TRUE FOR PPIDE SUPPORT (DO NOT COMBINE WITH DSKYENABLE) PPIDEMODE .EQU PPIDEMODE_STD ; PPIDEMODE_STD, PPIDEMODE_DIO3 PPIDETRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF PPIDEENABLE = TRUE) PPIDE8BIT .EQU FALSE ; USE IDE 8BIT TRANSFERS (PROBABLY ONLY WORKS FOR CF CARDS!) @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU TRUE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU TRUE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_dide.asm b/branches/dwg/Source/config_n8vem_dide.asm index 72cea522..0eb33d08 100644 --- a/branches/dwg/Source/config_n8vem_dide.asm +++ b/branches/dwg/Source/config_n8vem_dide.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_diskio.asm b/branches/dwg/Source/config_n8vem_diskio.asm index b8062cc8..2c3fc748 100644 --- a/branches/dwg/Source/config_n8vem_diskio.asm +++ b/branches/dwg/Source/config_n8vem_diskio.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_diskio3.asm b/branches/dwg/Source/config_n8vem_diskio3.asm index cb7a0827..ae3014bc 100644 --- a/branches/dwg/Source/config_n8vem_diskio3.asm +++ b/branches/dwg/Source/config_n8vem_diskio3.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_ppide.asm b/branches/dwg/Source/config_n8vem_ppide.asm index d77b654c..f2ad1ccb 100644 --- a/branches/dwg/Source/config_n8vem_ppide.asm +++ b/branches/dwg/Source/config_n8vem_ppide.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_ppisd.asm b/branches/dwg/Source/config_n8vem_ppisd.asm index 40f6fca0..180fa3b5 100644 --- a/branches/dwg/Source/config_n8vem_ppisd.asm +++ b/branches/dwg/Source/config_n8vem_ppisd.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_propio.asm b/branches/dwg/Source/config_n8vem_propio.asm index 21abc10f..ce30d22f 100644 --- a/branches/dwg/Source/config_n8vem_propio.asm +++ b/branches/dwg/Source/config_n8vem_propio.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_simh.asm b/branches/dwg/Source/config_n8vem_simh.asm index 95672166..57ec9929 100644 --- a/branches/dwg/Source/config_n8vem_simh.asm +++ b/branches/dwg/Source/config_n8vem_simh.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_std.asm b/branches/dwg/Source/config_n8vem_std.asm index 1c689e0e..609a9cf3 100644 --- a/branches/dwg/Source/config_n8vem_std.asm +++ b/branches/dwg/Source/config_n8vem_std.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_n8vem_vdu.asm b/branches/dwg/Source/config_n8vem_vdu.asm index 9685d582..77a1b9d1 100644 --- a/branches/dwg/Source/config_n8vem_vdu.asm +++ b/branches/dwg/Source/config_n8vem_vdu.asm @@ -10,7 +10,7 @@ CPUFREQ .EQU 8 ; IN MHZ, USED TO COMPUTE DELAY FACTORS DEFCON .EQU CIODEV_UART ; DEFAULT CONSOLE DEVICE (LOADER AND MONITOR): CIODEV_UART, CIODEV_VDU, DIODEV_PRPCON ALTCON .EQU DEFCON ; ALT CONSOLE DEVICE (USED WHEN CONFIG JUMPER SHORTED) DEFVDA .EQU VDADEV_VDU ; DEFAULT VDA (VDADEV_NONE, VDADEV_VDU, VDADEV_CVDU, VDADEV_UPD7220, VDADEV_N8V) -DEFEMU .EQU EMUTYP_TTY ; DEFAULT EMULATION TYPE (EMUTYP_TTY, EMUTYP_ANSI, ...) +DEFEMU .EQU EMUTYP_ANSI ; DEFAULT EMULATION TYPE (EMUTYP_TTY, EMUTYP_ANSI, ...) ; RAMSIZE .EQU 512 ; SIZE OF RAM IN KB, MUST MATCH YOUR HARDWARE!!! CLRRAMDISK .EQU CLR_AUTO ; CLR_ALWAYS, CLR_NEVER, CLR_AUTO (CLEAR IF INVALID DIR AREA) @@ -46,8 +46,8 @@ IDETRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF IDEENABLE IDE8BIT .EQU FALSE ; USE IDE 8BIT TRANSFERS (PROBABLY ONLY WORKS FOR CF CARDS!) IDECAPACITY .EQU 64 ; CAPACITY OF DEVICE (IN MB) ; -PPIDEENABLE .EQU FALSE ; TRUE FOR PPIDE SUPPORT (DO NOT COMBINE WITH DSKYENABLE) -PPIDEMODE .EQU PPIDEMODE_STD ; PPIDEMODE_STD, PPIDEMODE_DIO3 +PPIDEENABLE .EQU TRUE ; TRUE FOR PPIDE SUPPORT (DO NOT COMBINE WITH DSKYENABLE) +PPIDEMODE .EQU PPIDEMODE_DIO3 ; PPIDEMODE_STD, PPIDEMODE_DIO3 PPIDETRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF PPIDEENABLE = TRUE) PPIDE8BIT .EQU FALSE ; USE IDE 8BIT TRANSFERS (PROBABLY ONLY WORKS FOR CF CARDS!) PPIDECAPACITY .EQU 64 ; CAPACITY OF DEVICE (IN MB) @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU TRUE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU TRUE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_s100_std.asm b/branches/dwg/Source/config_s100_std.asm index a5415028..7428e1de 100644 --- a/branches/dwg/Source/config_s100_std.asm +++ b/branches/dwg/Source/config_s100_std.asm @@ -89,6 +89,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU TRUE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU TRUE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_zeta_ppp.asm b/branches/dwg/Source/config_zeta_ppp.asm index ce32bb17..0660067c 100644 --- a/branches/dwg/Source/config_zeta_ppp.asm +++ b/branches/dwg/Source/config_zeta_ppp.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/config_zeta_std.asm b/branches/dwg/Source/config_zeta_std.asm index 9391f4a1..6c051e5f 100644 --- a/branches/dwg/Source/config_zeta_std.asm +++ b/branches/dwg/Source/config_zeta_std.asm @@ -84,6 +84,7 @@ KBDTRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF KBDENABLE ; TTYENABLE .EQU FALSE ; INCLUDE TTY EMULATION SUPPORT ANSIENABLE .EQU FALSE ; INCLUDE ANSI EMULATION SUPPORT +ANSITRACE .EQU 1 ; 0=SILENT, 1=ERRORS, 2=EVERYTHING (ONLY RELEVANT IF ANSIENABLE = TRUE) ; BOOTTYPE .EQU BT_MENU ; BT_MENU (WAIT FOR KEYPRESS), BT_AUTO (BOOT_DEFAULT AFTER BOOT_TIMEOUT SECS) BOOT_TIMEOUT .EQU 20 ; APPROX TIMEOUT IN SECONDS FOR AUTOBOOT, 0 FOR IMMEDIATE diff --git a/branches/dwg/Source/cvdu.asm b/branches/dwg/Source/cvdu.asm index 2e8e1974..6a24057a 100644 --- a/branches/dwg/Source/cvdu.asm +++ b/branches/dwg/Source/cvdu.asm @@ -15,9 +15,12 @@ ; CVDU DRIVER - CONSTANTS ;====================================================================== ; -CVDU_STAT .EQU $E4 ; READ M8563 STATUS -CVDU_REG .EQU $E4 ; SELECT M8563 REGISTER -CVDU_DATA .EQU $EC ; READ/WRITE M8563 DATA +CVDU_STAT .EQU $E4 ; READ M8563 STATUS +CVDU_REG .EQU $E4 ; SELECT M8563 REGISTER +CVDU_DATA .EQU $EC ; READ/WRITE M8563 DATA +; +CVDU_ROWS .EQU 25 +CVDU_COLS .EQU 80 ; ;====================================================================== ; CVDU DRIVER - INITIALIZATION @@ -35,7 +38,9 @@ CVDU_RESET: LD A,$0E ; ATTRIBUTE IS STANDARD WHITE ON BLACK LD (CVDU_ATTR),A ; SAVE IT - LD A,'#' ; BLANK THE SCREEN + LD DE,0 ; ROW = 0, COL = 0 + CALL CVDU_XY ; SEND CURSOR TO TOP LEFT + LD A,' ' ; BLANK THE SCREEN LD DE,$800 ; FILL ENTIRE BUFFER CALL CVDU_FILL ; DO IT LD DE,0 ; ROW = 0, COL = 0 @@ -100,21 +105,24 @@ CVDU_DISPVDA: DEC A JR Z,CVDU_VDAFIL ; $48 DEC A - JR Z,CVDU_VDASCR ; $49 + JR Z,CVDU_VDACPY ; $49 DEC A - JP Z,KBD_STAT ; $4A + JR Z,CVDU_VDASCR ; $4A DEC A - JP Z,KBD_FLUSH ; $4B + JP Z,KBD_STAT ; $4B DEC A - JP Z,KBD_READ ; $4C + JP Z,KBD_FLUSH ; $4C + DEC A + JP Z,KBD_READ ; $4D CALL PANIC CVDU_VDAINI: - JR CVDU_INIT ; INITIALIZE + JP CVDU_INIT ; INITIALIZE CVDU_VDAQRY: LD C,$00 ; MODE ZERO IS ALL WE KNOW - LD DE,$1950 ; 25 ROWS ($19), 80 COLS ($50) + LD D,CVDU_ROWS ; ROWS + LD E,CVDU_COLS ; COLS LD HL,0 ; EXTRACTION OF CURRENT BITMAP DATA NOT SUPPORTED YET XOR A ; SIGNAL SUCCESS RET @@ -143,7 +151,7 @@ CVDU_VDASAT: LD A,(CVDU_ATTR) ; GET CURRENT ATTRIBUTE SETTING AND %10001111 ; CLEAR OUT OLD ATTRIBUTE BITS OR E ; STUFF IN THE NEW ONES - LD A,(CVDU_ATTR) ; AND SAVE THE RESULT + LD (CVDU_ATTR),A ; AND SAVE THE RESULT XOR A ; SIGNAL SUCCESS RET @@ -160,7 +168,7 @@ CVDU_VDASCO1: LD A,(CVDU_ATTR) ; GET CURRENT VALUE INTO A AND %11110000 ; CLEAR OUT OLD COLOR BITS OR E ; STUFF IN THE NEW ONES - LD A,(CVDU_ATTR) ; AND SAVE THE RESULT + LD (CVDU_ATTR),A ; AND SAVE THE RESULT XOR A ; SIGNAL SUCCESS RET @@ -176,6 +184,15 @@ CVDU_VDAFIL: CALL CVDU_FILL ; DO THE FILL XOR A ; SIGNAL SUCCESS RET + +CVDU_VDACPY: + ; LENGTH IN HL, SOURCE ROW/COL IN DE, DEST IS CVDU_POS + ; BLKCPY USES: HL=SOURCE, DE=DEST, BC=COUNT + PUSH HL ; SAVE LENGTH + CALL CVDU_XY2IDX ; ROW/COL IN DE -> SOURCE ADR IN HL + POP BC ; RECOVER LENGTH IN BC + LD DE,(CVDU_POS) ; PUT DEST IN DE + JP CVDU_BLKCPY ; DO A BLOCK COPY CVDU_VDASCR: LD A,E ; LOAD E INTO A @@ -290,18 +307,27 @@ CVDU_LOADFONT1: ;---------------------------------------------------------------------- ; CVDU_XY: + CALL CVDU_XY2IDX ; CONVERT ROW/COL TO BUF IDX + LD (CVDU_POS),HL ; SAVE THE RESULT (DISPLAY POSITION) + LD C,14 ; CURSOR POSITION REGISTER PAIR + JP CVDU_WRX ; DO IT AND RETURN +; +;---------------------------------------------------------------------- +; CONVERT XY COORDINATES IN DE INTO LINEAR INDEX IN HL +; D=ROW, E=COL +;---------------------------------------------------------------------- +; +CVDU_XY2IDX: LD A,E ; SAVE COLUMN NUMBER IN A LD H,D ; SET H TO ROW NUMBER - LD E,80 ; SET E TO ROW LENGTH + LD E,CVDU_COLS ; SET E TO ROW LENGTH CALL MULT8 ; MULTIPLY TO GET ROW OFFSET LD E,A ; GET COLUMN BACK ADD HL,DE ; ADD IT IN - LD (CVDU_POS),HL ; SAVE THE RESULT (DISPLAY POSITION) - LD C,14 ; CURSOR POSITION REGISTER PAIR - JP CVDU_WRX ; DO IT AND RETURN + RET ; RETURN ; ;---------------------------------------------------------------------- -; WRITE VALULE IN A TO CURRENT VDU BUFFER POSTION, ADVANCE CURSOR +; WRITE VALUE IN A TO CURRENT VDU BUFFER POSTION, ADVANCE CURSOR ;---------------------------------------------------------------------- ; CVDU_PUTCHAR: @@ -390,6 +416,7 @@ CVDU_FILL3: CALL CVDU_WR ; DO IT (SOURCE/DEST REGS AUTO INCREMENT) LD D,0 ; CLEAR D LD E,A ; SET E TO BYTES WRITTEN + OR A ; CLEAR CARRY SBC HL,DE ; SUBTRACT FROM HL RET Z ; IF ZERO, WE ARE DONE JR CVDU_FILL2 ; OTHERWISE, WRITE SOME MORE @@ -423,17 +450,17 @@ CVDU_SCROLL1: CALL CVDU_WRX ; DO IT ; COMPUTE SOURCE (INCREMENT ONE ROW) - LD DE,80 ; SOURCE ADDRESS IS ONE ROW PAST DESTINATION + LD DE,CVDU_COLS ; SOURCE ADDRESS IS ONE ROW PAST DESTINATION ADD HL,DE ; ADD IT TO BUF ADDRESS ; SET INITIAL BLOCK COPY SOURCE LD C,32 ; BLOCK START ADDRESS REGISTER CALL CVDU_WRX ; DO IT - LD B,23 ; ITERATIONS (ROWS - 1) + LD B,CVDU_ROWS - 1 ; ITERATIONS (ROWS - 1) CVDU_SCROLL2: ; SET BLOCK COPY COUNT (WILL EXECUTE COPY) - LD A,80 ; COPY 80 BYTES + LD A,CVDU_COLS ; COPY 80 BYTES LD C,30 ; WORD COUNT REGISTER CALL CVDU_WR ; DO IT @@ -446,13 +473,13 @@ CVDU_SCROLL2: AND $7F ; CLEAR BIT 7 FOR FILL MODE CALL CVDU_WR ; DO IT - ; SET CHARACTER TO WRITE + ; SET VALUE TO WRITE POP AF ; RESTORE THE FILL VALUE PASSED IN LD C,31 ; DATA REGISTER CALL CVDU_WR ; DO IT ; SET BLOCK WRITE COUNT (WILL EXECUTE THE WRITE) - LD A,80 - 1 ; SET WRITE COUNT TO LINE LENGTH - 1 (1 CHAR ALREADY WRITTEN) + LD A,CVDU_COLS - 1 ; SET WRITE COUNT TO LINE LENGTH - 1 (1 CHAR ALREADY WRITTEN) LD C,30 ; WORD COUNT REGISTER CALL CVDU_WR ; DO IT @@ -464,13 +491,13 @@ CVDU_SCROLL2: ; CVDU_RSCROLL: ; SCROLL THE CHARACTER BUFFER - LD A,'=' ; CHAR VALUE TO FILL NEW EXPOSED LINE - LD HL,80*23 ; SOURCE ADDRESS OF CHARACER BUFFER (LINE 24) + LD A,' ' ; CHAR VALUE TO FILL NEW EXPOSED LINE + LD HL,$0 + ((CVDU_ROWS - 1) * CVDU_COLS) ; SOURCE ADDRESS OF CHARACER BUFFER CALL CVDU_RSCROLL1 ; SCROLL CHARACTER BUFFER ; SCROLL THE ATTRIBUTE BUFFER LD A,(CVDU_ATTR) ; ATTRIBUTE VALUE TO FILL NEW EXPOSED LINE - LD HL,$800+(80*23) ; SOURCE ADDRESS OF ATTRIBUTE BUFFER (LINE 24) + LD HL,$800 + ((CVDU_ROWS - 1) * CVDU_COLS) ; SOURCE ADDRESS OF ATTRIBUTE BUFFER JR CVDU_RSCROLL1 ; SCROLL ATTRIBUTE BUFFER AND RETURN CVDU_RSCROLL1: @@ -483,7 +510,7 @@ CVDU_RSCROLL1: CALL CVDU_WR ; DO IT ; LOOP TO SCROLL EACH LINE WORKING FROM BOTTOM TO TOP - LD B,23 ; ITERATIONS (23 ROWS) + LD B,CVDU_ROWS - 1 ; ITERATIONS (ROWS - 1) CVDU_RSCROLL2: ; SET BLOCK COPY DESTINATION (USING HL PASSED IN) @@ -491,7 +518,8 @@ CVDU_RSCROLL2: CALL CVDU_WRX ; DO IT ; COMPUTE SOURCE (DECREMENT ONE ROW) - LD DE,80 ; SOURCE ADDRESS IS ONE ROW PAST DESTINATION + LD DE,CVDU_COLS ; SOURCE ADDRESS IS ONE ROW PAST DESTINATION + OR A ; CLEAR CARRY SBC HL,DE ; SUBTRACT IT FROM BUF ADDRESS ; SET BLOCK COPY SOURCE @@ -499,30 +527,79 @@ CVDU_RSCROLL2: CALL CVDU_WRX ; DO IT ; SET BLOCK COPY COUNT (WILL EXECUTE COPY) - LD A,80 ; COPY 80 BYTES + LD A,CVDU_COLS ; COPY 80 BYTES LD C,30 ; WORD COUNT REGISTER CALL CVDU_WR ; DO IT DJNZ CVDU_RSCROLL2 ; REPEAT FOR ALL LINES + ; SET FILL DESTINATION (USING HL PASSED IN) + LD C,18 ; UPDATE ADDRESS (DESTINATION) REGISTER + CALL CVDU_WRX ; DO IT + ; SET MODE TO BLOCK WRITE TO CLEAR NEW LINE EXPOSED BY SCROLL LD C,24 ; BLOCK MODE CONTROL REGISTER CALL CVDU_RD ; GET CURRENT VALUE AND $7F ; CLEAR BIT 7 FOR FILL MODE CALL CVDU_WR ; DO IT - ; SET CHARACTER TO WRITE + ; SET VALUE TO WRITE POP AF ; RESTORE THE FILL VALUE PASSED IN LD C,31 ; DATA REGISTER CALL CVDU_WR ; DO IT ; SET BLOCK WRITE COUNT (WILL EXECUTE THE WRITE) - LD A,80 - 1 ; SET WRITE COUNT TO LINE LENGTH - 1 (1 CHAR ALREADY WRITTEN) + LD A,CVDU_COLS - 1 ; SET WRITE COUNT TO LINE LENGTH - 1 (1 CHAR ALREADY WRITTEN) LD C,30 ; WORD COUNT REGISTER CALL CVDU_WR ; DO IT RET ; +;---------------------------------------------------------------------- +; BLOCK COPY BC BYTES FROM HL TO DE +;---------------------------------------------------------------------- +; +CVDU_BLKCPY: + ; SETUP PARMS FOR FIRST PASS (CHARS) + PUSH BC ; LENGTH + PUSH HL ; SOURCE + PUSH DE ; DEST + ; PUT A RETURN ADDRESS ON THE STACK FOR SECOND PASS + PUSH HL ; PUT CURRENT HL ON STACK + LD HL,CVDU_BLKCPY1 ; NOW SET HL TO RETURN ADDRESS + EX (SP),HL ; GET ORIG HL BACK, AND PUT RET ADR ON STACK + ; SETUP PARMS FOR SECOND PASS (ATTRIBUTES) + PUSH BC ; LENGTH + LD BC,$800 ; USE BC TO ADD OFFSET TO ATTR BUF + ADD HL,BC ; ADD THE OFFSET TO HL + PUSH HL ; SAVE PARM (SOURCE ADR) + EX DE,HL ; GET DE INTO HL + ADD HL,BC ; ADD THE OFFSET + PUSH HL ; SAVE PARM (DESTINATION ADR) +; +CVDU_BLKCPY1: + ; SET MODE TO BLOCK COPY + LD C,24 ; BLOCK MODE CONTROL REGISTER + CALL CVDU_RD ; GET CURRENT VALUE + OR $80 ; SET BIT 7 FOR COPY MODE + CALL CVDU_WR ; DO IT +; + ; SET DESTINATION + POP HL ; RECOVER DESTINATION ADDRESS + LD C,18 ; REGISTER = UPDATE ADDRESS + CALL CVDU_WRX ; DO IT +; + ; SET SOURCE + POP HL ; RECOVER SOURCE ADDRESS + LD C,32 ; REGISTER = BLOCK START + CALL CVDU_WRX ; DO IT +; + ; SET LENGTH + POP HL ; RECOVER LENGTH + LD A,L ; BYTES TO COPY GOES IN A + LD C,30 ; REGSITER = WORD COUNT + JP CVDU_WR ; DO IT (COPY OCCURS HERE) AND RETURN +; ;================================================================================================== ; CVDU DRIVER - DATA ;================================================================================================== diff --git a/branches/dwg/Source/kbd.asm b/branches/dwg/Source/kbd.asm index c8aba6fa..a060cfbd 100644 --- a/branches/dwg/Source/kbd.asm +++ b/branches/dwg/Source/kbd.asm @@ -76,7 +76,8 @@ KBD_INIT: CALL KBD_GETDATA ; CONTROLLER SHOULD RESPOND WITH $55 (ACK) LD A,$60 ; SET COMMAND REGISTER CALL KBD_PUTCMD ; SEND IT - LD A,$60 ; XLAT ENABLED, MOUSE DISABLED, NO INTS +; LD A,$60 ; XLAT ENABLED, MOUSE DISABLED, NO INTS + LD A,$20 ; XLAT DISABLED, MOUSE DISABLED, NO INTS CALL KBD_PUTDATA ; SEND IT CALL KBD_GETDATA ; GOBBLE UP $AA FROM POWER UP, AS NEEDED @@ -119,7 +120,6 @@ KBD_STAT3: ;__________________________________________________________________________________________________ ; KBD_READ: -; CALL KBD_STAT ; CHECK TO SEE IF KEY READY LD A,(KBD_STATUS) ; GET STATUS AND KBD_KEYRDY ; ISOLIATE KEY READY BIT JR NZ,KBD_READ1 ; READY, GO GET THE KEY AND RETURN @@ -127,6 +127,13 @@ KBD_READ: JR KBD_READ ; AND LOOP ; KBD_READ1: + LD A,(KBD_STATE) ; GET STATE + AND $01 ; ISOLATE EXTENDED SCANCODE BIT + RRCA ; ROTATE IT TO HIGH ORDER BIT + LD E,A ; SAVE IT IN E FOR NOW + LD A,(KBD_SCANCODE) ; GET SCANCODE + OR E ; COMBINE WITH EXTENDED BIT + LD C,A ; STORE IT IN C FOR RETURN LD A,(KBD_KEYCODE) ; GET KEYCODE LD E,A ; SAVE IT IN E LD A,(KBD_STATE) ; GET STATE FLAGS @@ -252,13 +259,13 @@ KBD_RESET: CALL KBD_PUTDATA ; SEND IT CALL KBD_GETDATA ; GET THE ACK LD B,0 ; SETUP LOOP COUNTER -PPK_RESET0: +KBD_RESET0: PUSH BC ; PRESERVE COUNTER CALL KBD_GETDATA ; TRY TO GET THE RESPONSE POP BC ; RECOVER COUNTER - JR NZ,PPK_RESET1 ; GOT A BYTE? IF SO, GET OUT OF LOOP - DJNZ PPK_RESET0 ; LOOP TILL COUNTER EXHAUSTED -PPK_RESET1: + JR NZ,KBD_RESET1 ; GOT A BYTE? IF SO, GET OUT OF LOOP + DJNZ KBD_RESET0 ; LOOP TILL COUNTER EXHAUSTED +KBD_RESET1: LD A,B XOR A ; SIGNAL SUCCESS (RESPONSE IS IGNORED...) RET ; DONE @@ -417,20 +424,14 @@ KBD_DEC1: ; PROCESS NEXT SCANCODE LD (KBD_SCANCODE),A ; SAVE SCANCODE KBD_DEC2: ; DETECT AND HANDLE SPECIAL KEYCODES -; -; KEYBOARD INSERTION DETECTION HAS BEEN REMOVED BELOW BECAUSE THE SCAN CODE -; OF $AA IS AMBIGUOUS WHEN SCAN SET 2 IS IN USE. $AA COULD MEAN EITHER A LEFT -; SHIFT KEY BREAK EVENT OR A KEYBOARD INSERTION EVENT. OBVIOUSLY, A SHIFT BREAK -; EVENT CANNOT BE ALLOWED TO TRIGGER A KEYBOARD RESET, SO WE CANNOT INTERPRET -; $AA AS A KEYBOARD INSERTION. UNFORTUNATE, BUT IS SEE NO ALTERNATIVES. -; -; LD A,(KBD_SCANCODE) ; GET THE CURRENT SCANCODE -; CP $AA ; KEYBOARD INSERTION? -; JR NZ,KBD_DEC3 ; NOPE, BYPASS -; CALL KBD_RESET ; RESET KEYBOARD -; CALL KBD_SETLEDS ; SET LEDS -; CALL KBD_SETRPT ; SET REPEAT RATE -; JP KBD_DECNEW ; RESTART THE ENGINE + LD A,(KBD_SCANCODE) ; GET THE CURRENT SCANCODE + CP $AA ; KEYBOARD INSERTION? + JR NZ,KBD_DEC3 ; NOPE, BYPASS + CALL LDELAY ; WAIT A BIT + CALL KBD_RESET ; RESET KEYBOARD + CALL KBD_SETLEDS ; SET LEDS + CALL KBD_SETRPT ; SET REPEAT RATE + JP KBD_DECNEW ; RESTART THE ENGINE KBD_DEC3: ; DETECT AND HANDLE SCANCODE PREFIXES LD A,(KBD_SCANCODE) ; GET THE CURRENT SCANCODE @@ -448,8 +449,8 @@ KBD_DEC3B: ; HANDLE SCANCODE PREFIX $E1 (PAUSE KEY) JR NZ,KBD_DEC4 ; NOPE MOVE ON LD A,$EE ; MAP TO KEYCODE $EE LD (KBD_KEYCODE),A ; SAVE IT - ; SWALLOW NEXT 5 SCANCODES - LD B,5 ; LOOP 5 TIMES + ; SWALLOW NEXT 7 SCANCODES + LD B,7 ; LOOP 5 TIMES KBD_DEC3B1: PUSH BC CALL KBD_GETDATA ; RETRIEVE NEXT SCANCODE @@ -458,20 +459,13 @@ KBD_DEC3B1: JP KBD_DEC6 ; RESUME AFTER MAPPING KBD_DEC4: ; DETECT AND FLAG BREAK EVENT - LD A,(KBD_SCANCODE) - LD E,A ; SAVE SCANCODE IN E - RES 7,A ; CLEAR THE BREAK BIT FROM THE KEYCODE - LD (KBD_SCANCODE),A ; SAVE UPDATED SCANCODE - LD A,E ; RECOVER ORIGINAL SCANCODE - AND $80 ; ISOLATE BREAK BIT - RLCA ; ROTATE BIT TO POSITION... - RLCA ; OF BREAK BIT IN STATUS - LD E,A ; SAVE IT IN E - LD A,(KBD_STATUS) ; GET THE STATUS FLAGS - AND ~KBD_BREAK ; CLEAR THE BREAK BIT - OR E ; OR IN NEW BREAK BIT - LD (KBD_STATUS),A ; SAVE IT - + CP $F0 ; BREAK (KEY UP) PREFIX? + JR NZ,KBD_DEC5 ; NOPE MOVE ON + LD A,(KBD_STATUS) ; GET STATUS + OR KBD_BREAK ; SET BREAK BIT + LD (KBD_STATUS),A ; SAVE STATUS + JR KBD_DEC1 ; LOOP TO DO NEXT SCANCODE + KBD_DEC5: ; MAP SCANCODE TO KEYCODE LD A,(KBD_STATUS) ; GET STATUS AND KBD_EXT ; EXTENDED BIT SET? @@ -687,30 +681,36 @@ KBD_DECNEW: ; START NEW KEYPRESS (CLEAR ALL STATUS BITS) ;__________________________________________________________________________________________________ ; KBD_MAPSTD: ; SCANCODE IS INDEX INTO TABLE TO RESULTANT LOOKUP KEYCODE - .DB $FF,$1B,'1','2','3','4','5','6','7','8','9','0','-','=',$08,$09 - .DB 'q','w','e','r','t','y','u','i','o','p','[',']',$0D,$B2,'a','s' - .DB 'd','f','g','h','j','k','l',';',$27,'`',$B0,'\','z','x','c','v' - .DB 'b','n','m',',','.','/',$B1,$CC,$B4,' ',$BC,$E0,$E1,$E2,$E3,$E4 - .DB $E5,$E6,$E7,$E8,$E9,$BD,$BE,$C6,$C7,$C8,$CD,$C3,$C4,$C5,$CE,$C0 - .DB $C1,$C2,$C9,$CA,$EC,$FF,$FF,$FA,$EB + .DB $FF,$E8,$FF,$E4,$E2,$E0,$E1,$EB,$FF,$E9,$E7,$E5,$E3,$09,'`',$FF + .DB $FF,$B4,$B0,$FF,$B2,'q','1',$FF,$FF,$FF,'z','s','a','w','2',$FF + .DB $FF,'c','x','d','e','4','3',$FF,$FF,' ','v','f','t','r','5',$FF + .DB $FF,'n','b','h','g','y','6',$FF,$FF,$FF,'m','j','u','7','8',$FF + .DB $FF,',','k','i','o','0','9',$FF,$FF,'.','/','l',';','p','-',$FF + .DB $FF,$FF,$27,$FF,'[','=',$FF,$FF,$BC,$B1,$0D,']',$FF,'\',$FF,$FF + .DB $FF,$FF,$FF,$FF,$FF,$FF,$08,$FF,$FF,$C0,$FF,$C3,$C6,$FF,$FF,$FF + .DB $C9,$CA,$C1,$C4,$C5,$C7,$1B,$BD,$FA,$CE,$C2,$CD,$CC,$C8,$BE,$FF + .DB $FF,$FF,$FF,$E6,$EC ; KBD_MAPSIZ .EQU ($ - KBD_MAPSTD) ; KBD_MAPSHIFT: ; SCANCODE IS INDEX INTO TABLE TO RESULTANT LOOKUP KEYCODE WHEN SHIFT ACTIVE - .DB $FF,$1B,'!','@','#','$','%','^','&','*','(',')','_','+',$08,$09 - .DB 'Q','W','E','R','T','Y','U','I','O','P','{','}',$0D,$B2,'A','S' - .DB 'D','F','G','H','J','K','L',':',$22,'~',$B0,'|','Z','X','C','V' - .DB 'B','N','M','<','>','?',$B1,$DC,$B4,' ',$BC,$E0,$E1,$E2,$E3,$E4 - .DB $E5,$E6,$E7,$E8,$E9,$BD,$BE,$D6,$D7,$D8,$DD,$D3,$D4,$D5,$DE,$D0 - .DB $D1,$D2,$D9,$DA,$EC,$FF,$FF,$FA,$EB + .DB $FF,$E8,$FF,$E4,$E2,$E0,$E1,$EB,$FF,$E9,$E7,$E5,$E3,$09,'~',$FF + .DB $FF,$B4,$B0,$FF,$B2,'Q','!',$FF,$FF,$FF,'Z','S','A','W','@',$FF + .DB $FF,'C','X','D','E','$','#',$FF,$FF,' ','V','F','T','R','%',$FF + .DB $FF,'N','B','H','G','Y','^',$FF,$FF,$FF,'M','J','U','&','*',$FF + .DB $FF,'<','K','I','O',')','(',$FF,$FF,'>','?','L',':','P','_',$FF + .DB $FF,$FF,$22,$FF,'{','+',$FF,$FF,$BC,$B1,$0D,'}',$FF,'|',$FF,$FF + .DB $FF,$FF,$FF,$FF,$FF,$FF,$08,$FF,$FF,$D0,$FF,$D3,$D6,$FF,$FF,$FF + .DB $D9,$DA,$D1,$D4,$D5,$D7,$1B,$BD,$FA,$DE,$D2,$DD,$DC,$D8,$BE,$FF + .DB $FF,$FF,$FF,$E6,$EC ; KBD_MAPEXT: ; PAIRS ARE [SCANCODE,KEYCODE] FOR EXTENDED SCANCODES - .DB $38,$B5, $1D,$B3, $5B,$B6, $5C,$B7 - .DB $5D,$EF, $5E,$FA, $5F,$FB, $35,$CB - .DB $1C,$CF, $63,$FC, $4F,$F3, $4B,$F8 - .DB $47,$F2, $52,$F0, $53,$F1, $50,$F7 - .DB $4D,$F9, $48,$F6, $51,$F5, $37,$ED - .DB $49,$F4, $46,$FD, $00,$00 + .DB $11,$B5, $14,$B3, $1F,$B6, $27,$B7 + .DB $2F,$EF, $37,$FA, $3F,$FB, $4A,$CB + .DB $5A,$CF, $5E,$FC, $69,$F3, $6B,$F8 + .DB $6C,$F2, $70,$F0, $71,$F1, $72,$F7 + .DB $74,$F9, $75,$F6, $7A,$F5, $7C,$ED + .DB $7D,$F4, $7E,$FD, $00,$00 ; KBD_MAPNUMPAD: ; KEYCODE TRANSLATION FROM NUMPAD RANGE TO STD ASCII/KEYCODES .DB $F3,$F7,$F5,$F8,$FF,$F9,$F2,$F6,$F4,$F0,$F1,$2F,$2A,$2D,$2B,$0D diff --git a/branches/dwg/Source/n8v.asm b/branches/dwg/Source/n8v.asm index 12adbb59..25edd5cc 100644 --- a/branches/dwg/Source/n8v.asm +++ b/branches/dwg/Source/n8v.asm @@ -341,6 +341,8 @@ N8V_DISPVDA: DEC A JP Z,N8V_VDAFIL DEC A + JP Z,N8V_VDACPY + DEC A JP Z,N8V_VDASCR DEC A JP Z,PPK_STAT @@ -548,6 +550,13 @@ N8V_VDAFIL: XOR A RET +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Video Display Processor Copy ; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +N8V_VDACPY: + XOR A + RET + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Video Display Processor Scroll ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff --git a/branches/dwg/Source/ppide.asm b/branches/dwg/Source/ppide.asm index cb77fdd2..bfbd3fc3 100644 --- a/branches/dwg/Source/ppide.asm +++ b/branches/dwg/Source/ppide.asm @@ -60,6 +60,7 @@ PPIDE_RST_LINE .EQU 80H ; INVERTER BETWEEN 8255 AND IDE INTERFACE ; PPIDE_DATA .EQU PPIDE_CS0_LINE PPIDE_ERROR .EQU PPIDE_CS0_LINE + PPIDE_A0_LINE +PPIDE_FEATURE .EQU PPIDE_CS0_LINE + PPIDE_A0_LINE PPIDE_SEC_CNT .EQU PPIDE_CS0_LINE + PPIDE_A1_LINE PPIDE_SECTOR .EQU PPIDE_CS0_LINE + PPIDE_A1_LINE + PPIDE_A0_LINE PPIDE_CYL_LSB .EQU PPIDE_CS0_LINE + PPIDE_A2_LINE @@ -175,19 +176,18 @@ PPIDE_RW: #IF (PPIDE8BIT) CALL PPIDE_WAITRDY - - LD C,01H - LD A,PPIDE_ERROR - CALL PPIDE_WRITE - LD C,PPIDECMD_SETFEAT - LD A,PPIDE_COMMAND - CALL PPIDE_WRITE + LD C,PPIDE_FEATURE ; IDE FEATURE REGISTER + LD A,01H ; VALUE := 1 + CALL PPIDE_WRITE ; DO IT + LD C,PPIDE_COMMAND ; IDE COMMAND REGISTER + LD A,PPIDECMD_SETFEAT ; SET FEATURE + CALL PPIDE_WRITE ; DO IT CALL PPIDE_WAITRDY JP NC,PPIDE_ERR CALL PPIDE_CHKERR ; CHECK FOR ERRORS JP NC,PPIDE_ERR #IF (PPIDETRACE >= 2) - CALL IDE_PRT + CALL PPIDE_PRT #ENDIF #ENDIF @@ -195,10 +195,9 @@ PPIDE_RW0: CALL PPIDE_WAITRDY ; WAIT FOR DRIVE READY JP NC,PPIDE_ERR CALL PPIDE_SETUP ; SETUP CYL, TRK, HEAD - LD A,(PPIDEP_CMD) - LD C,A - LD A,PPIDE_COMMAND - CALL PPIDE_WRITE + LD C,PPIDE_COMMAND ; IDE COMMAND REGISTER + LD A,(PPIDEP_CMD) ; COMMAND VALUE + CALL PPIDE_WRITE ; DO IT CALL PPIDE_WAITRDY ; WAIT FOR DRIVE READY JP NC,PPIDE_ERR CALL PPIDE_CHKERR ; CHECK FOR ERRORS @@ -246,14 +245,14 @@ PPIDE_OK: ; ; PPIDE_RESET: - LD C,000001110B ; NO INTERRUPTS, ASSERT RESET BOTH DRIVES - LD A,PPIDE_CONTROL - CALL PPIDE_WRITE + LD C,PPIDE_CONTROL ; IDE CONTROL REGISTER + LD A,000001110B ; NO INTERRUPTS, ASSERT RESET BOTH DRIVES + CALL PPIDE_WRITE ; DO IT LD DE,8 ; DELAY ABOUT 200ms CALL VDELAY - LD C,000000010B ; NO INTERRUPTS, DEASSERT RESET - LD A,PPIDE_CONTROL - CALL PPIDE_WRITE + LD C,PPIDE_CONTROL ; IDE CONTROL REGISTER + LD A,000000010B ; NO INTERRUPTS, DEASSERT RESET + CALL PPIDE_WRITE ; DO IT XOR A ; STATUS OK LD (PPIDE_STAT),A ; SAVE IT @@ -272,9 +271,8 @@ PPIDE_WBSY: LD A,D OR E JP Z,PPIDE_TO - LD A,PPIDE_STTS - CALL PPIDE_READ - LD A,C + LD C,PPIDE_STTS ; IDE STATUS REGISTER + CALL PPIDE_READ ; READ ID LD (PPIDEP_STTS),A ; SAVE IT AND 011000000B ; ISOLATE BUSY AND RDY BITS XOR 001000000B ; WE WANT BUSY(7) TO BE 0 AND RDY(6) TO BE 1 @@ -290,22 +288,20 @@ PPIDE_TO: ; ; PPIDE_CHKERR: - LD A,PPIDE_STTS - CALL PPIDE_READ - LD A,C + LD C,PPIDE_STTS ; IDE STATUS REGISTER + CALL PPIDE_READ ; READ IT LD (PPIDEP_STTS),A ; SAVE IT AND 000000001B ; ERROR BIT SET? SCF ; ASSUME NO ERR RET Z ; NO ERR, RETURN WITH CF SET - - LD A,PPIDE_ERROR - CALL PPIDE_READ - LD A,C +; + LD C,PPIDE_ERROR ; IDE ERROR REGISTER + CALL PPIDE_READ ; READ IT LD (PPIDEP_ERR),A ; SAVE IT - +; LD A,PPIDERC_CMDERR ; COMMAND ERROR LD (PPIDE_RC),A ; SAVE IT - +; OR A ; CLEAR CF TO SIGNAL ERROR RET ; @@ -319,9 +315,8 @@ PPIDE_WDRQ: LD A,D OR E JP Z,PPIDE_TO2 - LD A,PPIDE_STTS - CALL PPIDE_READ - LD A,C + LD C,PPIDE_STTS ; IDE STATUS REGISTER + CALL PPIDE_READ ; READ IT LD (PPIDEP_STTS),A ; SAVE IT AND 010001000B ; TO FILL (OR READY TO FILL) XOR 000001000B @@ -336,73 +331,110 @@ PPIDE_TO2: ; ; ; -#IF (PPIDE8BIT) PPIDE_BUFRD: - LD HL,(DIOBUF) - LD DE,200H -PPIDE_BUFRD1: - LD A,PPIDE_DATA - CALL PPIDE_READ - LD (HL),C - INC HL - DEC DE - LD A,D - OR E - JP NZ,PPIDE_BUFRD1 - RET -#ELSE -PPIDE_BUFRD: - LD HL,(DIOBUF) - LD D,0 -PPIDE_BUFRD1: - LD A,PPIDE_DATA - CALL PPIDE_READ - LD (HL),C - INC HL - LD (HL),B - INC HL - DEC D - JP NZ,PPIDE_BUFRD1 + ; SETUP PPI TO READ + LD A,RD_IDE_8255 ; READ CONFIG + OUT (PPI1CONT),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY +; + ; SELECT READ/WRITE IDE REGISTER + LD A,PPIDE_DATA ; DATA REGISTER + OUT (IDECTL),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY + LD E,A ; E := READ UNASSERTED + XOR PPIDE_RD_LINE ; SWAP THE READ LINE BIT + LD D,A ; D := READ ASSERTED +; + ; LOOP SETUP + LD HL,(DIOBUF) ; LOCATION OF BUFFER + LD B,0 ; 256 ITERATIONS + LD C,IDEMSB ; SETUP C WITH IO PORT (MSB) +; + CALL PPIDE_BUFRD1 ; FIRST PASS (FIRST 256 BYTES) + CALL PPIDE_BUFRD1 ; SECOND PASS (LAST 256 BYTES) +; + ; CLEAN UP + XOR A ; ZERO A + OUT (IDECTL),A ; RELEASE ALL BUS SIGNALS + RECOVERY ; OPTIONAL SMALL DELAY RET +; +PPIDE_BUFRD1: ; START OF READ LOOP +#IF (!PPIDE8BIT) + DEC C ; MSB -> LSB #ENDIF + LD A,D ; ASSERT READ + OUT (IDECTL),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY + INI ; GET AND SAVE NEXT BYTE + RECOVERY ; OPTIONAL SMALL DELAY +#IF (!PPIDE8BIT) + INC C ; LSB -> MSB + INI ; GET AND SAVE NEXT BYTE + RECOVERY ; OPTIONAL SMALL DELAY +#ENDIF + LD A,E ; DEASSERT READ + OUT (IDECTL),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY + JR NZ,PPIDE_BUFRD1 ; LOOP UNTIL DONE + RET ; ; ; -#IF (PPIDE8BIT) PPIDE_BUFWR: - LD HL,(DIOBUF) - LD DE,200H -PPIDE_BUFWR1: - LD C,(HL) - LD A,PPIDE_DATA - CALL PPIDE_WRITE - INC HL - DEC DE - LD A,D - OR E - JP NZ,PPIDE_BUFWR1 -#ELSE -PPIDE_BUFWR: - LD HL,(DIOBUF) - LD D,0 -PPIDE_BUFWR1: - LD C,(HL) - INC HL - LD B,(HL) - INC HL - LD A,PPIDE_DATA - CALL PPIDE_WRITE - DEC D - JP NZ,PPIDE_BUFWR1 + ; SETUP PPI TO WRITE + LD A,WR_IDE_8255 ; READ CONFIG + OUT (PPI1CONT),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY +; + ; SELECT READ/WRITE IDE REGISTER + LD A,PPIDE_DATA ; DATA REGISTER + OUT (IDECTL),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY + LD E,A ; E := READ UNASSERTED + XOR PPIDE_WR_LINE ; SWAP THE WRITE LINE BIT + LD D,A ; D := READ ASSERTED +; + ; LOOP SETUP + LD HL,(DIOBUF) ; LOCATION OF BUFFER + LD B,0 ; 256 ITERATIONS + LD C,IDEMSB ; SETUP C WITH IO PORT (MSB) +; + CALL PPIDE_BUFWR1 ; FIRST PASS (FIRST 256 BYTES) + CALL PPIDE_BUFWR1 ; SECOND PASS (LAST 256 BYTES) +; + ; CLEAN UP + XOR A ; ZERO A + OUT (IDECTL),A ; RELEASE ALL BUS SIGNALS + RECOVERY ; OPTIONAL SMALL DELAY RET +; +PPIDE_BUFWR1: ; START OF READ LOOP +#IF (!PPIDE8BIT) + DEC C ; MSB -> LSB +#ENDIF + OUTI ; SEND NEXT BYTE OF BUFFER + RECOVERY ; OPTIONAL SMALL DELAY +#IF (!PPIDE8BIT) + INC C ; LSB -> MSB + OUTI ; SEND NEXT BYTE OF BUFFER + RECOVERY ; OPTIONAL SMALL DELAY #ENDIF + LD A,D ; ASSERT WRITE + OUT (IDECTL),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY + LD A,E ; DEASSERT WRITE + OUT (IDECTL),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY + JR NZ,PPIDE_BUFWR1 ; LOOP UNTIL DONE + RET ; ; ; PPIDE_SETUP: - LD C,1 - LD A,PPIDE_SEC_CNT - CALL PPIDE_WRITE + LD C,PPIDE_SEC_CNT ; IDE SECTOR COUNT REGISTER + LD A,1 ; 1 SECTOR + CALL PPIDE_WRITE ; DO IT LD A,(HSTDSK) ; HSTDSK -> HEAD BIT 4 TO SELECT UNIT AND 0FH @@ -420,29 +452,25 @@ PPIDE_SETUP_UNIT1: ; LD DE,(PPIDE1_OFFSET) JP PPIDE_SETUP1 PPIDE_SETUP1: - LD (PPIDEP_HEAD),A - LD C,A - LD A,PPIDE_HEAD - CALL PPIDE_WRITE + LD C,PPIDE_HEAD ; IDE HEAD REGISTER + LD (PPIDEP_HEAD),A ; SAVE HEAD VALUE + CALL PPIDE_WRITE ; WRITE IT LD HL,(HSTTRK) ; HSTTRK -> IDECYLHI/LO - LD A,H - LD (PPIDEP_CYLHI),A - LD C,A - LD A,PPIDE_CYL_MSB - CALL PPIDE_WRITE - LD A,L - LD (PPIDEP_CYLLO),A - LD C,A - LD A,PPIDE_CYL_LSB - CALL PPIDE_WRITE - - LD BC,(HSTSEC) ; HSTSEC -> IDESECTN - LD A,C - LD (PPIDEP_SEC),A - LD C,A - LD A,PPIDE_SECTOR - CALL PPIDE_WRITE + LD C,PPIDE_CYL_MSB ; IDE MSB CYL REGISTER + LD A,H ; MSB CYL VALUE + LD (PPIDEP_CYLHI),A ; SAVE IT + CALL PPIDE_WRITE ; WRITE IT + LD C,PPIDE_CYL_LSB ; IDE LSB CYL REGISTER + LD A,L ; LSB CYL VALUE + LD (PPIDEP_CYLLO),A ; SAVE IT + CALL PPIDE_WRITE ; WRITE IT + + LD HL,(HSTSEC) ; HSTSEC -> IDESECTN + LD C,PPIDE_SECTOR ; IDE SECTOR REGISTER + LD A,L ; SECTOR VALUE + LD (PPIDEP_SEC),A ; SAVE IT + CALL PPIDE_WRITE ; WRITE IT #IF (DSKYENABLE) CALL PPIDE_DSKY @@ -453,70 +481,63 @@ PPIDE_SETUP1: ; ; PPIDE_READ: - PUSH AF ; save register value - LD A,RD_IDE_8255 - OUT (PPI1CONT),A ; Config 8255 chip, read mode - RECOVERY - POP AF ; restore register value - - OUT (IDECTL),A ; Drive address onto control lines - RECOVERY - OR PPIDE_RD_LINE ; assert RD pin - - OUT (IDECTL),A - RECOVERY - - PUSH AF ; save register value - IN A,(IDELSB) ; read lower byte - RECOVERY - LD C,A ; save in reg C - - IN A,(IDEMSB) ; read upper byte - RECOVERY - LD B,A ; save in reg C - - POP AF ; restore register value - XOR PPIDE_RD_LINE ; de-assert RD signal - OUT (IDECTL),A - RECOVERY - - XOR A - OUT (IDECTL),A ; Deassert all control pins - RECOVERY - RET +; + ; SET PPI MODE TO READ CONFIGURATION + LD A,RD_IDE_8255 ; PPI MODE TO READ + OUT (PPI1CONT),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY +; + ; SELECT REQUESTED IDE REGISTER AND ASSERT READ + LD A,C ; REGISTER SELECTION -> A + OR PPIDE_RD_LINE ; ASSERT READ + OUT (IDECTL),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY +; + ; READ THE BYTE + IN A,(IDELSB) ; READ LSB + RECOVERY ; OPTIONAL SMALL DELAY + PUSH AF ; SAVE IT FOR NOW +; + ; CLEAN UP AND RETURN + XOR A ; ZERO A + OUT (IDECTL),A ; RELEASE ALL BUS SIGNALS + RECOVERY ; OPTIONAL SMALL DELAY +; + POP AF ; RECOVER THE DATA BYTE + RET ; RETURN ; ; ; PPIDE_WRITE: - PUSH AF ; save IDE register value - LD A,WR_IDE_8255 - OUT (PPI1CONT),A ; Config 8255 chip, write mode - RECOVERY - - LD A,C ; get value to be written - OUT (IDELSB),A - RECOVERY - - LD A,B ; get value to be written - OUT (IDEMSB),A - RECOVERY - - - POP AF ; get saved IDE register - OUT (IDECTL),A ; Drive address onto control lines - RECOVERY - OR PPIDE_WR_LINE ; assert write pin - OUT (IDECTL),A - RECOVERY - - XOR PPIDE_WR_LINE ; de assert WR pin - OUT (IDECTL),A ; Drive address onto control lines - RECOVERY - - XOR A - OUT (IDECTL),A ; release bus signals - RECOVERY - RET +; + ; SAVE THE INCOMING VALUE TO WRITE + PUSH AF +; + ; SET PPI MODE TO WRITE CONFIGURATION + LD A,WR_IDE_8255 ; PPI MODE TO WRITE + OUT (PPI1CONT),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY +; + ; SET THE VALUE TO WRITE + POP AF ; GET VALUE BACK + OUT (IDELSB),A ; SET IDE LSB + RECOVERY ; OPTIONAL SMALL DELAY +; XOR A ; ZERO A +; OUT (IDELSB),A ; SET IDE MSB +; RECOVERY ; OPTIONAL SMALL DELAY +; + ; PULSE THE WRITE LINE + LD A,C ; REGISTER SELECTION -> A + OR PPIDE_WR_LINE ; ASSERT WRITE + OUT (IDECTL),A ; DO IT + RECOVERY ; OPTIONAL SMALL DELAY +; + ; CLEAN UP AND RETURN + XOR A ; ZERO A + OUT (IDECTL),A ; RELEASE ALL BUS SIGNALS + RECOVERY ; OPTIONAL SMALL DELAY +; + RET ; RETURN ; ; ; @@ -581,15 +602,13 @@ PPIDE_PRTCMD: CALL WRITESTR CALL PC_SPACE - LD A,PPIDE_STTS - CALL PPIDE_READ - LD A,C + LD C,PPIDE_STTS ; IDE STATUS REGISTER + CALL PPIDE_READ ; READ IT CALL PRTHEXBYTE CALL PC_SPACE - LD A,PPIDE_ERROR - CALL PPIDE_READ - LD A,C + LD C,PPIDE_ERROR ; IDE ERROR REGISTER + CALL PPIDE_READ ; READ IT CALL PRTHEXBYTE CALL PC_SPACE diff --git a/branches/dwg/Source/ppk.asm b/branches/dwg/Source/ppk.asm index 1fa88fa0..64d6da5a 100644 --- a/branches/dwg/Source/ppk.asm +++ b/branches/dwg/Source/ppk.asm @@ -133,6 +133,13 @@ PPK_READ: JR PPK_READ ; AND LOOP ; PPK_READ1: + LD A,(PPK_STATE) ; GET STATE + AND $01 ; ISOLATE EXTENDED SCANCODE BIT + RRCA ; ROTATE IT TO HIGH ORDER BIT + LD E,A ; SAVE IT IN E FOR NOW + LD A,(PPK_SCANCODE) ; GET SCANCODE + OR E ; COMBINE WITH EXTENDED BIT + LD C,A ; STORE IT IN C FOR RETURN LD A,(PPK_KEYCODE) ; GET KEYCODE LD E,A ; SAVE IT IN E LD A,(PPK_STATE) ; GET STATE FLAGS diff --git a/branches/dwg/Source/std.asm b/branches/dwg/Source/std.asm index 6aa325e6..cd14fe07 100644 --- a/branches/dwg/Source/std.asm +++ b/branches/dwg/Source/std.asm @@ -112,6 +112,11 @@ EMUTYP_NONE .EQU 0 EMUTYP_TTY .EQU 1 EMUTYP_ANSI .EQU 2 ; +; SCSI DEVICE PERSONALITY CHOICES +; +S2I_PER_N8VEM .EQU 1 +S2I_PER_ST125N .EQU 2 +; ; SYSTEM GENERATION SETTINGS ; SYS_CPM .EQU 1 ; CPM (IMPLIES BDOS + CCP) @@ -152,10 +157,14 @@ CP .EQU CP_ZCPR ; ; INCLUDE PLATFORM SPECIFIC HARDWARE DEFINITIONS ; -#IF ((PLATFORM == PLT_N8VEM) | (PLATFORM == PLT_ZETA) | (PLATFORM == PLT_S2I)) +#IF ((PLATFORM == PLT_N8VEM) | (PLATFORM == PLT_ZETA)) #INCLUDE "n8vem.inc" #ENDIF ; +#IF (PLATFORM == PLT_S2I) +#INCLUDE "s2i.inc" +#ENDIF +; #IF (PLATFORM == PLT_N8) #INCLUDE "n8.inc" #ENDIF @@ -250,10 +259,11 @@ BF_VDASAT .EQU BF_VDA + 5 ; SET CHARACTER ATTRIBUTE BF_VDASCO .EQU BF_VDA + 6 ; SET CHARACTER COLOR BF_VDAWRC .EQU BF_VDA + 7 ; WRITE CHARACTER BF_VDAFIL .EQU BF_VDA + 8 ; FILL -BF_VDASCR .EQU BF_VDA + 9 ; SCROLL -BF_VDAKST .EQU BF_VDA + 10 ; GET KEYBOARD STATUS -BF_VDAKFL .EQU BF_VDA + 11 ; FLUSH KEYBOARD BUFFER -BF_VDAKRD .EQU BF_VDA + 12 ; READ KEYBOARD +BF_VDACPY .EQU BF_VDA + 9 ; COPY +BF_VDASCR .EQU BF_VDA + 10 ; SCROLL +BF_VDAKST .EQU BF_VDA + 11 ; GET KEYBOARD STATUS +BF_VDAKFL .EQU BF_VDA + 12 ; FLUSH KEYBOARD BUFFER +BF_VDAKRD .EQU BF_VDA + 13 ; READ KEYBOARD ; BF_SYS .EQU $F0 BF_SYSGETCFG .EQU BF_SYS + 0 ; GET CONFIGURATION DATA BLOCK @@ -340,171 +350,21 @@ BIOS: .EQU CCP+1600H ; BASE OF BIOS CCPSIZ: .EQU 00800H ; #IF (PLATFORM == PLT_N8VEM) - #DEFINE PLATFORM_NAME "N8VEM Z80 SBC" + #DEFINE PLATFORM_NAME "N8VEM Z80" #ENDIF #IF (PLATFORM == PLT_ZETA) - #DEFINE PLATFORM_NAME "ZETA Z80 SBC" + #DEFINE PLATFORM_NAME "ZETA Z80" #ENDIF #IF (PLATFORM == PLT_N8) - #DEFINE PLATFORM_NAME "N8 Z180 SBC" + #DEFINE PLATFORM_NAME "N8 Z180" #ENDIF #IF (PLATFORM == PLT_S2I) - #DEFINE PLATFORM_NAME "SCSI2IDE" + #DEFINE PLATFORM_NAME "SCSI2IDE Z80" #ENDIF #IF (PLATFORM == PLT_S100) #DEFINE PLATFORM_NAME "S100" #ENDIF ; -#IF (DSKYENABLE) - #DEFINE DSKYLBL ", DSKY" -#ELSE - #DEFINE DSKYLBL "" -#ENDIF -; -#IF (VDUENABLE) - #DEFINE VDULBL ", VDU" -#ELSE - #DEFINE VDULBL "" -#ENDIF -; -#IF (CVDUENABLE) - #DEFINE CVDULBL ", CVDU" -#ELSE - #DEFINE CVDULBL "" -#ENDIF -; -#IF (UPD7220ENABLE) - #DEFINE UPD7220LBL ", UPD7220" -#ELSE - #DEFINE UPD7220LBL "" -#ENDIF -; -#IF (N8VENABLE) - #DEFINE N8VLBL ", N8V" -#ELSE - #DEFINE N8VLBL "" -#ENDIF -; -#IF (FDENABLE) - #IF (FDMAUTO) - #DEFINE FDLBL ", FLOPPY (AUTOSIZE)" - #ELSE - #IF (FDMEDIA == FDM720) - #DEFINE FDLBL ", FLOPPY (360KB)" - #ENDIF - #IF (FDMEDIA == FDM111) - #DEFINE FDLBL ", FLOPPY (1.11MB)" - #ENDIF - #ENDIF -#ELSE - #DEFINE FDLBL "" -#ENDIF -; -#IF (IDEENABLE) - #IF (IDEMODE == IDEMODE_DIO) - #DEFINE IDELBL ", IDE (DISKIO)" - #ENDIF - #IF (IDEMODE == IDEMODE_DIDE) - #DEFINE IDELBL ", IDE (DUAL IDE)" - #ENDIF -#ELSE - #DEFINE IDELBL "" -#ENDIF -; -#IF (PPIDEENABLE) - #IF (PPIDEMODE == PPIDEMODE_STD) - #DEFINE PPIDELBL ", PPIDE (STD)" - #ENDIF - #IF (PPIDEMODE == PPIDEMODE_DIO3) - #DEFINE PPIDELBL ", PPIDE (DISKIO V3)" - #ENDIF -#ELSE - #DEFINE PPIDELBL "" -#ENDIF -; -#IF (SDENABLE) - #DEFINE SDLBL ", SD CARD" -#ELSE - #DEFINE SDLBL "" -#ENDIF -; -#IF (IDEENABLE) - #DEFINE IDELBL ", IDE" -#ELSE - #DEFINE IDELBL "" -#ENDIF -; -#IF (PPIDEENABLE) - #DEFINE PPIDELBL ", PPIDE" -#ELSE - #DEFINE PPIDELBL "" -#ENDIF - -#IF (SDENABLE) - #DEFINE SDLBL ", SD CARD" -#ELSE - #DEFINE SDLBL "" -#ENDIF - -#IF (HDSKENABLE) - #DEFINE HDSKLBL ", SIMH DISK" -#ELSE - #DEFINE HDSKLBL "" -#ENDIF - -#IF (PRPENABLE) - #IF (PRPCONENABLE & PRPSDENABLE) - #DEFINE PRPLBL ", PROPIO (CONSOLE, SD CARD)" - #ENDIF - #IF (PRPCONENABLE & !PRPSDENABLE) - #DEFINE PRPLBL ", PROPIO (CONSOLE)" - #ENDIF - #IF (!PRPCONENABLE & PRPSDENABLE) - #DEFINE PRPLBL ", PROPIO (SD CARD)" - #ENDIF - #IF (!PRPCONENABLE & !PRPSDENABLE) - #DEFINE PRPLBL ", PROPIO ()" - #ENDIF -#ELSE - #DEFINE PRPLBL "" -#ENDIF - -#IF (PPPENABLE) - #IF (PPPCONENABLE & PPPSDENABLE) - #DEFINE PPPLBL ", PARPORTPROP (CONSOLE, SD CARD)" - #ENDIF - #IF (PPPCONENABLE & !PPPSDENABLE) - #DEFINE PPPLBL ", PARPORTPROP (CONSOLE)" - #ENDIF - #IF (!PPPCONENABLE & PPPSDENABLE) - #DEFINE PPPLBL ", PARPORTPROP (SD CARD)" - #ENDIF - #IF (!PPPCONENABLE & !PPPSDENABLE) - #DEFINE PPPLBL ", PARPORTPROP ()" - #ENDIF -#ELSE - #DEFINE PPPLBL "" -#ENDIF - -#IFDEF (HISTENABLE) - #DEFINE HISTLBL ", HIST" -#ELSE - #DEFINE HISTLBL "" -#ENDIF - - .ECHO "Configuration: " - .ECHO PLATFORM_NAME - .ECHO DSKYLBL - .ECHO VDULBL - .ECHO FDLBL - .ECHO IDELBL - .ECHO PPIDELBL - .ECHO SDLBL - .ECHO PRPLBL - .ECHO PPPLBL - .ECHO HISTLBL - .ECHO "\n" -; ; HELPER MACROS ; #DEFINE PRTC(C) CALL PRTCH \ .DB C ; PRINT CHARACTER C TO CONSOLE - PRTC('X') diff --git a/branches/dwg/Source/tty.asm b/branches/dwg/Source/tty.asm index ab81897a..a4f348e1 100644 --- a/branches/dwg/Source/tty.asm +++ b/branches/dwg/Source/tty.asm @@ -96,9 +96,6 @@ TTY_DOCHAR: JR Z,TTY_LF CP 32 ; COMPARE TO SPACE (FIRST PRINTABLE CHARACTER) RET C ; SWALLOW OTHER CONTROL CHARACTERS - -;;; LD HL,(TTY_POS) ; physical driver needs pos data to write - LD B,BF_VDAWRC CALL EMU_VDADISP ; SPIT OUT THE RAW CHARACTER LD A,(TTY_COL) ; GET CUR COL @@ -123,39 +120,31 @@ TTY_FF: JR TTY_XY ; HOME CURSOR AND RETURN ; TTY_BS: - LD DE,(TTY_POS) ; GET CURRENT ROW/COL IN DE - LD A,E ; GET CURRENT COLUMN - CP 1 ; COMPARE TO COLUMN 1 - RET C ; LESS THAN 1, NOTHING TO DO - DEC E ; POINT TO PREVIOUS COLUMN - LD (TTY_POS),DE ; SAVE NEW COLUMN VALUE - CALL TTY_XY ; MOVE CURSOR TO NEW TARGET COLUMN - LD E,' ' ; LOAD A SPACE CHARACTER - LD B,BF_VDAWRC ; SET FUNCTION TO WRITE CHARACTER - CALL EMU_VDADISP ; OVERWRITE WITH A SPACE CHARACTER - JR TTY_XY ; NEED TO MOVE CURSOR BACK TO NEW TARGET COLUMN + LD A,(TTY_COL) ; GET CURRENT COLUMN + DEC A ; BACK IT UP BY ONE + RET C ; IF CARRY, MARGIN EXCEEDED, ABORT + LD (TTY_COL),A ; SAVE NEW COLUMN + JP TTY_XY ; UDPATE CUSROR AND RETURN ; TTY_CR: XOR A ; ZERO ACCUM LD (TTY_COL),A ; COL := 0 JR TTY_XY ; REPOSITION CURSOR AND RETURN ; -TTY_LF: +TTY_LF: ; LINEFEED (FORWARD INDEX) LD A,(TTY_ROW) ; GET CURRENT ROW - INC A ; BUMP TO NEXT - LD (TTY_ROW),A ; SAVE IT LD DE,(TTY_DIM) ; GET SCREEN DIMENSIONS - CP D ; COMPARE TO SCREEN ROWS - JR C,TTY_XY ; NOT PAST END, ALL DONE - DEC D ; D NOW HAS MAX ROW NUM (ROWS - 1) - SUB D ; A WILL NOW HAVE NUM LINES TO SCROLL - LD E,A ; LINES TO SCROLL -> E - LD B,BF_VDASCR ; SET FUNCTION TO SCROLL - CALL EMU_VDADISP ; DO THE SCROLLING - LD A,(TTY_ROWS) ; GET SCREEN ROW COUNT - DEC A ; A NOW HAS LAST ROW + DEC D ; D := MAX ROW NUM + CP D ; >= LAST ROW? + JR NC,TTY_LF1 ; IF SO, NEED TO SCROLL + INC A ; BUMP TO NEXT ROW LD (TTY_ROW),A ; SAVE IT - JR TTY_XY ; RESPOSITION CURSOR AND RETURN + JP TTY_XY ; UPDATE CURSOR AND RETURN +; +TTY_LF1: ; SCROLL + LD E,1 ; SCROLL FORWARD 1 LINE + LD B,BF_VDASCR ; SET FUNCTION TO SCROLL + JP EMU_VDADISP ; DO THE SCROLLING AND RETURN ; TTY_XY: LD DE,(TTY_POS) ; GET THE DESIRED CURSOR POSITION diff --git a/branches/dwg/Source/util.asm b/branches/dwg/Source/util.asm index a14d9a46..83a487ee 100644 --- a/branches/dwg/Source/util.asm +++ b/branches/dwg/Source/util.asm @@ -459,6 +459,53 @@ MULT8_LOOP: MULT8_NOADD: DJNZ MULT8_LOOP RET + + +; +; SET A BIT IN BYTE ARRAY AT HL, INDEX IN A +; +BITSET: + CALL BITLOC ; LOCATE THE BIT + OR (HL) ; SET THE SPECIFIED BIT + LD (HL),A ; SAVE IT + RET ; RETURN +; +; CLEAR A BIT IN BYTE ARRAY AT HL, INDEX IN A +; +BITCLR: + CALL BITLOC ; LOCATE THE BIT + CPL ; INVERT ALL BITS + AND (HL) ; CLEAR SPECIFIED BIT + LD (HL),A ; SAVE IT + RET ; RETURN +; +; GET VALUE OF A BIT IN BYTE ARRAY AT HL, INDEX IN A +; +BITTST: + CALL BITLOC ; LOCATE THE BIT + AND (HL) ; SET Z FLAG BASED ON BIT + RET ; RETURN +; +; LOCATE A BIT IN BYTE ARRAY AT HL, INDEX IN A +; RETURN WITH HL POINTING TO BYTE AND A WITH MASK FOR SPECIFIC BIT +; +BITLOC: + PUSH AF ; SAVE BIT INDEX + SRL A ; DIVIDE BY 8 TO GET BYTE INDEX + SRL A ; " + SRL A ; " + LD C,A ; MOVE TO BC + LD B,0 ; " + ADD HL,BC ; HL NOW POINTS TO BYTE CONTAINING BIT + POP AF ; RECOVER A (INDEX) + AND $07 ; ISOLATE REMAINDER, Z SET IF ZERO + LD B,A ; SETUP SHIFT COUNTER + LD A,1 ; SETUP A WITH MASK + RET Z ; DONE IF ZERO +BITLOC1: + SLA A ; SHIFT + DJNZ BITLOC1 ; LOOP AS NEEDED + RET ; DONE ; ; PRINT VALUE OF HL IN DECIMAL WITH LEADING ZERO SUPPRESSION ; diff --git a/branches/dwg/Source/vdu.asm b/branches/dwg/Source/vdu.asm index abfc5eb9..ebd7aab7 100644 --- a/branches/dwg/Source/vdu.asm +++ b/branches/dwg/Source/vdu.asm @@ -100,13 +100,15 @@ VDU_DISPVDA: DEC A JR Z,VDU_VDAFIL ; $48 DEC A - JR Z,VDU_VDASCR ; $49 + JR Z,VDU_VDACPY ; $49 DEC A - JP Z,PPK_STAT ; $4A + JR Z,VDU_VDASCR ; $4A DEC A - JP Z,PPK_FLUSH ; $4B + JP Z,PPK_STAT ; $4B DEC A - JP Z,PPK_READ ; $4C + JP Z,PPK_FLUSH ; $4C + DEC A + JP Z,PPK_READ ; $4D CALL PANIC VDU_VDAINI: @@ -150,6 +152,16 @@ VDU_VDAFIL: CALL VDU_FILL ; DO THE FILL XOR A ; SIGNAL SUCCESS RET + +VDU_VDACPY: + ; LENGTH IN HL, SOURCE ROW/COL IN DE, DEST IS CVDU_POS + PUSH HL ; SAVE LENGTH + CALL VDU_XY2IDX ; ROW/COL IN DE -> SOURCE ADR IN HL + POP BC ; RECOVER LENGTH IN BC + LD DE,(VDU_POS) ; PUT DEST IN DE + JP VDU_BLKCPY ; DO A BLOCK COPY + + RET VDU_VDASCR: LD A,E ; LOAD E INTO A @@ -240,6 +252,20 @@ VDU_CRTINIT1: RET ; ;---------------------------------------------------------------------- +; CONVERT XY COORDINATES IN DE INTO LINEAR INDEX IN HL +; D=ROW, E=COL +;---------------------------------------------------------------------- +; +VDU_XY2IDX: + LD A,E ; SAVE COLUMN NUMBER IN A + LD H,D ; SET H TO ROW NUMBER + LD E,80 ; SET E TO ROW LENGTH + CALL MULT8 ; MULTIPLY TO GET ROW OFFSET + LD E,A ; GET COLUMN BACK + ADD HL,DE ; ADD IT IN + RET ; RETURN +; +;---------------------------------------------------------------------- ; SET CURSOR POSITION TO ROW IN D AND COLUMN IN E ;---------------------------------------------------------------------- ; @@ -316,6 +342,64 @@ VDU_FILL1: JR VDU_FILL1 ; LOOP ; ;---------------------------------------------------------------------- +; COPY A BLOCK (UP TO 255 BYTES) FROM HL TO FRAME BUFFER POSITION +; BC: NUMBER OF BYTES TO COPY +; HL: SOURCE POSITION +; DE: DESTINATION POSITION +;---------------------------------------------------------------------- +; +VDU_BLKCPY: + ; SETUP TO COPY FROM VDU SOURCE TO WORK BUFFER + PUSH DE ; SAVE VDU DESTINATION ADR + PUSH HL ; SAVE VDU SOURCE ADDRESS + LD HL,(VDU_OFFSET) ; GET THE CURRENT OFFSET + POP DE ; RECOVER SOURCE ADDRESS + ADD HL,DE ; HL HAS TRUE SOURCE ADR OF VIDEO BUF W/ OFFSET + LD DE,VDU_BUF ; POINT DE TO WORK BUFFER + PUSH BC ; SAVE COPY LENGTH FOR LATER + LD B,C ; NOW USE B FOR LENGTH (MAX COPY IS 255) + LD C,18 ; SET SOURCE ADDRESS IN VDU (HL) + CALL VDU_WRREGX ; DO IT + LD A,31 ; PREP VDU FOR DATA R/W + OUT (VDU_REG),A ; DO IT + LD HL,VDU_BUF ; HL POINTS TO WORK BUFFER +; LD C,VDU_RAMWR ; LOAD C WITH VDU WRITE REGISTER + +VDU_BLKCPY1: ; VIDEO RAM -> BUFFER COPY LOOP + CALL VDU_WAITRDY ; WAIT FOR VDU +;;;;;;;;;;;;;;;;; +; INI IS NOT WORKING FOR ME, GARBAGE DATA READS, NO IDEA WHY +; INI ; READ BYTE, DEC B, INC HL +; IN A,(VDU_DATA) ; BOGUS READ TO INCREMENT VDU RAM ADDRESS!!! +; JR NZ,VDU_BLKCPY1 ; LOOP TILL DONE +;;;;;;;;;;;;;;;;; + IN A,(VDU_RAMRD) ; READ DATA BYTE + LD (HL),A ; SAVE IN BUFFER + INC HL ; BUMP SOURCE ADDRESS + IN A,(VDU_DATA) ; BOGUS READ TO INCREMENT VDU RAM ADDRESS!!! + DJNZ VDU_BLKCPY1 ; LOOP TILL DONE + + ; SETUP TO COPY FROM WORK BUFFER TO VDU DEST + POP BC ; RECOVER THE COPY LENGTH + LD HL,(VDU_OFFSET) ; GET THE CURRENT VDU OFFSET + POP DE ; RECOVER THE DEST ADDRESS + ADD HL,DE ; HL HAS TRUE DEST ADR OF VIDEO BUF W/ OFFSET + LD B,C ; NOW USE B FOR LENGTH (MAX COPY IS 255) + LD C,18 ; SET DEST ADDRESS IN VDU (HL) + CALL VDU_WRREGX ; DO IT + LD A,31 ; PREP VDU FOR DATA R/W + OUT (VDU_REG),A ; DO IT + LD HL,VDU_BUF ; HL POINTS TO WORK BUFFER + LD C,VDU_RAMWR ; LOAD C WITH VDU WRITE REGISTER + +VDU_BLKCPY2: ; BUFFER -> VIDEO RAM COPY LOOP + CALL VDU_WAITRDY ; WAIT FOR VDU + OUTI ; WRITE BYTE, DEC B, INC HL + JR NZ,VDU_BLKCPY2 ; LOOP TILL DONE +; + RET ; RETURN +; +;---------------------------------------------------------------------- ; SCROLL ENTIRE SCREEN FORWARD BY ONE LINE (CURSOR POSITION UNCHANGED) ;---------------------------------------------------------------------- ; @@ -339,7 +423,7 @@ VDU_SCROLL: POP HL LD (VDU_POS),HL - ; ADJUST CURSOR POSITION + ; ADJUST CURSOR POSITION AND RETURN LD HL,(VDU_OFFSET) LD DE,(VDU_POS) ADD HL,DE @@ -351,7 +435,31 @@ VDU_SCROLL: ;---------------------------------------------------------------------- ; VDU_RSCROLL: - RET + ; SCROLL BACKWARD BY SUBTRACTING ONE ROW FROM DISPLAY START ADDRESS + LD HL,(VDU_OFFSET) + LD DE,-80 + ADD HL,DE + LD (VDU_OFFSET),HL + LD C,12 + CALL VDU_WRREGX + + ; FILL EXPOSED LINE + LD HL,(VDU_POS) + PUSH HL + LD HL,0 + LD (VDU_POS),HL + LD DE,80 + LD A,' ' + CALL VDU_FILL + POP HL + LD (VDU_POS),HL + + ; ADJUST CURSOR POSITION AND RETURN + LD HL,(VDU_OFFSET) + LD DE,(VDU_POS) + ADD HL,DE + LD C,14 + JP VDU_WRREGX ; ;================================================================================================== ; VDU DRIVER - DATA @@ -359,6 +467,7 @@ VDU_RSCROLL: ; VDU_POS .DW 0 ; CURRENT DISPLAY POSITION VDU_OFFSET .DW 0 ; CURRENT DISPLAY POSITION +VDU_BUF .FILL 256,0 ; COPY BUFFER ; ;================================================================================================== ; VDU DRIVER - SY6845 REGISTER INITIALIZATION diff --git a/branches/dwg/Source/ver.inc b/branches/dwg/Source/ver.inc index 62fbadcb..0d281b7e 100644 --- a/branches/dwg/Source/ver.inc +++ b/branches/dwg/Source/ver.inc @@ -1,6 +1,6 @@ #DEFINE RMJ 2 -#DEFINE RMN 3 +#DEFINE RMN 5 #DEFINE RUP 0 -#DEFINE RTP 0 -#DEFINE BIOSVER "2.3(int)" +#DEFINE RTP 1 +#DEFINE BIOSVER "2.5 - Prerelease" #DEFINE REVISION 248