CP/M

home *** CD-ROM | disk | FTP | other *** search

/ CP/M / CPM_CDROM.iso / simtel / sigm / vols000 / vol016 / mnemon21.asm < prev next >

Wrap

Assembly Source File | 1984-04-29 | 27.4 KB | 1,129 lines

;******************************************************************* ; ; MNEMONIC - A MULTI-PASS MEMORY TESTER FOR CP/M ; ; COPYRIGHT 1978, BY ; WILLIAM T. PRECHT & ASSOCIATES ; 1102 S. EDSON ; LOMBARD, IL 60148 ; ;******************************************************************** ;MODIFIED 1/11/81 BY CHARLES H. STROM FOR OPERATION WITH MEMORY- ;MAPPED CONSOLE I/O AND WITHOUT A FRONT PANEL. SEE CONDITIONAL ;SWITCHES BELOW. ;******************************************************************** ; ORG 100H ; ORG FOR CP/M TPA ; ; USER MODIFIABLE EQUATES FOLLOW ; MEMMAP EQU 0 ;TRUE FOR MEMORY-MAPPED CONSOLE PANEL EQU 1 ;TRUE FOR FRONT PANEL ; EXITA EQU 0F800H ; COLD BOOT ADDR CONSD EQU 04H ; CONSOLE DATA PORT OR MEMORY LOCATION CONST EQU 05H ; CONSOLE STATUS PORT OR MEMORY LOCATION CONSI EQU 02H ; READY BIT FOR KYBD (ACTIVE HIGH) CONSO EQU 01H ; READY BIT FOR CONSOLE OUTPUT (ACTIVE HIGH) SSWD EQU 20H ; SENSE SW 5 = DETAIL ERROR LIST SSWS EQU 10H ; S.S. 4 = DO SLOW TEST ; ;END OF USER MODIFIABLE EQUATES ; STAK EQU 1000H ; STACK ADDR - PRESERVE THIS STAKH EQU 10H ; STACK H/O ADDR - USED TO COMPARE TO PARMS ; ;******************************************************************* ; JMP START ; BYPASS JUMP TABLE ; EXIT JMP EXITA ; EXIT JUMP - GO TO COLD BOOT ADDR KEYIN JMP ZKEYIN ; CUSTOM CONSOLE INPUT KSTAT JMP ZKSTAT ; " " READY TEST TYPE JMP ZTYPE ; " " OUTPUT ; ;******************************************************************** ; ; CONSOLE KEYBOARD INPUT ROUTINE ; ;******************************************************************** ; ZKEYIN EQU $ CALL KSTAT ; TEST CHAR READY JNC KEYIN ; NOT READY, LOOP IF MEMMAP LDA CONSD ENDIF IF NOT MEMMAP IN CONSD ; READ CONSOLE DATA ENDIF ANI 7FH ; STRIP PARITY CALL TYPE ; ECHO IT TO TERMINAL IF NOT PANEL CPI 'S' ;S FOR SLOW/FAST TOGGLE JNZ XCOMP LDA SLOWTOGL XRI 1 STA SLOWTOGL RET XCOMP CPI 'X' ;X FOR DETAILED/NORMAL LIST TOGGLE RNZ LDA XAMTOGL XRI 1 STA XAMTOGL RET ENDIF RET ; ZKSTAT EQU $ IF MEMMAP LDA CONST ENDIF IF NOT MEMMAP IN CONST ; READ CONSOLE STATUS PORT ENDIF ANI CONSI ; TEST INPUT READY BIT RZ ; NOPE, RET STC ; YUP, SET CARRY RET ; ;******************************************************************** ; ; CONSOLE OUTPUT ROUTINE ; ;******************************************************************** ; ZTYPE EQU $ CALL TYPEC ; TYPE CHAR CPI 0DH ; Q. CARR RTN? RNZ ; NO, RETURN MVI A,0AH ; GET LINE FEED CALL TYPEC ; SEND IT RET ; TYPEC EQU $ PUSH PSW ; SAVE CHAR 2B TYPED TYPEL IF MEMMAP LDA CONST ENDIF IF NOT MEMMAP IN CONST ; READ CONSOLE STATUS ENDIF ANI CONSO ; TEST OUTPUT READY BIT JZ TYPEL ; NOPE, LOOP POP PSW ; ELSE, GET CHAR IF MEMMAP STA CONSD ENDIF IF NOT MEMMAP OUT CONSD ; TYPE IT ENDIF RET ; ; ;******************************************************************* ; ; START - PROGRAM BEGINS; DO INIT ; ;******************************************************************* ; START EQU $ LXI SP,STAK ; GET STACK ADDR CALL PMSG1 ; TYPE VERSION MSG JMP SPARM ; BYPASS CONTINUOUS TEST 1ST TIME ; ;******************************************************************* ; ; MAIN PROGRAM LOOP ; ;******************************************************************** ; LOOP EQU $ CALL KSTAT ; TEST CONSOLE READY JNC CONTIN ; NO, LOOP TILL INTERRUPTED IF MEMMAP LDA CONSD ENDIF IF NOT MEMMAP IN CONSD ; CLEAR INTERRUPTING DATA ENDIF SPARM EQU $ CALL GPARM ; GET ADDRS TO TEST JC SPARM ; LET'S TRY GETTING THOSE PARMS AGAIN CALL QUICK ; DO QUICK TEST FOR MEM PRESENT CONTIN EQU $ CALL RANDS ; SAVE RANDOM SEED CALL GPATT ; GEN RANDOM PATTERNS IN EACH LOC CALL KSTAT ; TEST KYBD READY JC LOOPP ; YES, PRINT MATRIX AND EXIT CALL RANDR ; RESET RAND TO SEED CALL TPATT ; TEST PATTERNS CALL KSTAT ; TEST KYBD READY JC LOOPP ; YES, PRINT MATRIX AND EXIT CALL SLOW ; DO SUPER-SLOW MEM TEST CALL KSTAT ; TEST KYBD READY JC LOOPP ; YES, PRINT MATRIX AND EXIT LHLD PASSC ; GET 16-BIT PASS COUNTER INX H ; PLUS 1 SHLD PASSC ; AND STORE IT BACK CALL PRTPASS ; PRINT PASS COUNT JMP LOOPX ; ELSE, GO TO LOOP EXIT ; LOOPP EQU $ CALL PRMAT ; PRINT ERROR MATRIX ; LOOPX EQU $ JMP LOOP ; LOOP TILL INTERRUPTED ; ; ;******************************************************************** ; ; GPARM - GET ADDRESS PARAMETERS ; ;******************************************************************** ; GPARM EQU $ CALL INIT ; INIT ERROR MATRIX CALL GTSTA ; GET START ADDR RC ; CARRY=ERROR, SO RETURN CALL GTEND ; GET END ADDR RC ; CARRY, PROBLEM RET ; ;******************************************************************** ; ; GPATT - GET RANDOM PATTERN TO ADDRESS SPACE ; ;******************************************************************** ; GPATT EQU $ LHLD AEND ; GET END ADDR TO H-L XCHG ; SWAP IT TO D-E LHLD ASTRT ; GET STARTING ADDR TO H-L GPAT2 EQU $ CALL KSTAT ; TEST KYBD READY RC ; YUP, EXIT CALL RANDB ; GET RANDOM BYTE CALL STNDX ; STORE CHAR, BUMP INDEX JC GPAT2 ; LT MAX, LOOP RET ; ;******************************************************************** ; ; TPATT - TEST RANDOM PATTERN PREVIOUSLY GENERATED ; ;******************************************************************** ; TPATT EQU $ LHLD AEND ; GET END ADDR TO H-L XCHG ; SWAP IT TO D-E LHLD ASTRT ; GET STARTING ADDR TPAT2 EQU $ CALL RANDB ; GET RANDOM BYTE MOV B,M ; GET CHAR FROM MEM TO B CMP B ; TEST EXPECTED TO ACTUAL JZ TPAT3 ; EQ, ON CALL TYPEA ; RECORD ADDR AND FAILURE CALL STMAT ; AND STORE IN ERROR MATRIX ; TPAT3 EQU $ CALL KSTAT ; TEST KYBD STATUS RC ; YES, EARLY EXIT CALL INDEX ; BUMP MEM PTR JC TPAT2 ; LT MAX, LOOP RET ; ;******************************************************************** ; ; STNDX - STORE BYTE IN MEMORY, BUMP INDEX ; ;******************************************************************** ; STNDX EQU $ MOV M,A ; STORE CHAR IN MEM JMP INDEX ; BUMP MEM PTR AND EXIT ; ;******************************************************************** ; ; INDEX - BUMP H-L, COMPARE TO D-E (ENDING ADDR) ; ;******************************************************************** ; INDEX EQU $ MOV A,H ; GET H/O OF CURR ADDR CMP D ; TEST TO H/O OF END JC INXIT ; LT, ONWARD JNZ INXIT ; NOT ZERO, END MOV A,L ; TEST L/O CMP E ; TO L/O OF END JC INXIT ; LT, ON ; ; H-L = D-E ; RESET ZERO AND CARRY FLAGS ; MVI A,0 ; GET ZERO DCR A ; RESET ZERO FLAG ORA A ; AND CARRY RET ; INXIT EQU $ INX H ; BUMP MEM PTR RET ; ;******************************************************************** ; ; STMAT - STORE BIT DIFFERENCES IN ERROR MATRIX ; ;******************************************************************** ; STMAT EQU $ PUSH PSW ; SAVE CHAR PUSH H ; SAVE H-L PUSH D ; AND PUSH B ; REST MOV B,A ; MOVE BYTE READ TO B MOV C,M ; MOVE BYTE WRITTEN TO C MOV A,H ; GET H/O ERROR ADDR PUSH PSW ; SAVE H/O LHLD ASTRT ; STARTING TEST ADDR MOV A,H ; GET H/O TO ACC ANI 0FCH ; STRIP L/O 2 BITS MOV H,A ; REPLACE H/O POP PSW ; RESTORE H/O ERR ADDR SUB H ; 256-BYTE DIFF ANI 0FCH ; CLEAR L/O 2 BITS MVI H,0 ; SETUP H-L MOV L,A ; TO FORM DAD H ; K INDEX TO MATRIX DAD H ; AGAIN LXI D,MATRX ; MATRIX START DAD D ; FORM K INDEX SHLD MINDX ; STORE MATRIX INDEX LHLD ERRCT ; GET ERROR COUNT INX H ; PLUS 1 SHLD ERRCT ; AND STORE IT BACK LXI D,8 ; BIT COUNT TO D STMA2 EQU $ MOV A,B ; GET BYTE READ RRC ; SHIFT L/O INTO CARRY MOV B,A ; RETURN BYTE READ MOV A,C ; GET BYTE WRITTEN JC STMC1 ; BIT WAS SET IN READ - SEE IF WRITTEN RRC ; SHIFT BYTE WRITTEN L/O BIT INTO CARRY MOV C,A ; RETURN BYTE WRITTEN JNC STMCO ; NOT CARRY, BIT MATCHES JMP STMBT ; CARRY, FLAG ERR STMC1 EQU $ RRC ; SHIFT WRITTEN BIT INTO CARRY MOV C,A ; RETURN BYTE WRITTEN JC STMCO ; CARRY, BIT MATCHES STMBT EQU $ PUSH D ; SAVE ERR CTR MVI H,0 ; SETUP MOV L,E ; H-L DCR L ; TAKE BIT COUNT - 1 DAD H ; * 2 XCHG ; SWAP TO D-E LHLD MINDX ; MATRIX K INDEX DAD D ; DISPLACE BIT LOC MOV E,M ; GET L/O OF ERROR CTR INX H ; BUMP PTR MOV D,M ; GET H/O INX D ; INCR DBL CTR MOV M,D ; REPLACE H/O DCX H ; DECR MEM PTR MOV M,E ; REPLACE L/O POP D ; RESTORE D-E ; STMCO EQU $ DCR E ; MINUS BIT COUNTER JNZ STMA2 ; LOOP TILL ALL BITS TESTED POP B ; RESTORE POP D ; ALL POP H ; REGS POP PSW ; AND CHAR RET ; ;******************************************************************** ; ; PMSG1 - TYPE VERSION MESSAGE AND INSTRUCTIONS ; ;******************************************************************** ; PMSG1 EQU $ LXI H,MSG1 ; GET VERSION MESSAGE CALL LINE ; TYPE LINE RET ; MSG1 DB 0DH DB 'WTP&A MNEMONIC - VERSION 2.1',0DH DB 0DH DB 'ANY MEMORY FROM 1000H TO FFFFH CAN BE TESTED.',0DH DB 'TEST WILL RUN CONTINUOUSLY ' DB 'UNTIL A KEY IS STRUCK.',0DH IF PANEL DB 'TURN ON S.S. 5 TO GET DETAILED ERROR LIST;',0DH DB ' S.S. 4 TO DO SUPER-SLOW TEST.',0DH ENDIF IF NOT PANEL DB 'AT "START ADDRESS" PROMPT ENTER;',0DH DB 'S - To toggle test SPEED normal/super slow;',0DH DB 'X - To toggle normal/detailed EXAMINATION of errors' ENDIF DB 0DH,0DH DB 'WHEN A KEY IS STRUCK, ALL CUMULATIVE ERRORS',0DH DB ' WILL BE SUMMARIZED BY BIT POSITION',0DH DB ' WITHIN 1K BOUNDARIES.',0DH DB 0DH DB '(ALL INPUTS AND OUTPUTS ARE IN HEX.)',0DH DB 0DH DB 00 ; ;******************************************************************** ; ; PMSGS - PRINT STARTING ADDR REQ MSG ; ;******************************************************************** ; PMSGS EQU $ LXI H,MSGS ; GET START ADDR REQ MSG CALL LINE ; TYPE LINE RET ; MSGS DB 'START ADDR (HEX) ?',0DH,00 ; ;******************************************************************** ; ; PMSGE - TYPE ENDING ADDR REQ MSG ; ;******************************************************************** ; PMSGE EQU $ LXI H,MSGE ; GET ENDING ADDR REQ MSG CALL LINE ; TYPE LINE RET ; MSGE DB 'END ADDR (HEX) ?',0DH,00 ; ;******************************************************************** ; ; LINE - TYPE A LINE TERMINATED BY X'00' ; ;******************************************************************** ; LINE EQU $ MOV A,M ; GET CHAR FROM MSG CPI 00 ; Q. MSG END? JZ LINEX ; YUP, WRAP UP CALL TYPE ; ELSE, TYPE CHAR INX H ; BUMP PTR JMP LINE ; LOOP TILL MSG END ; LINEX EQU $ RET ; ;******************************************************************** ; ; GTSTA - GET MEMORY STARTING ADDRESS ; ;******************************************************************** ; GTSTA EQU $ CALL PMSGS ; SEND STARTING REQ MSG CALL RDADR ; READ ADDR FROM CONSOLE JC GTSTA ; CARRY=ERROR, SO REPROMPT CALL PACKA ; PACK ADDR INTO ADDRH LHLD ADDRH ; GET PACKED ADDR SHLD ASTRT ; SAVE IT IN STARTING ADDR MOV A,H ; GET H/O OF START ADDR CPI STAKH ; TEST TO STACK ADDR RET ; ;******************************************************************** ; ; GTEND - GET ENDING ADDRESS ; ;******************************************************************** ; GTEND EQU $ CALL PMSGE ; SEND ENDING REQ MSG CALL RDADR ; READ ADDR FROM CONSOLE JC GTEND ; CARRY=ERROR, SO REPROMPT CALL PACKA ; PACK ADDR INTO ADDRH LHLD ADDRH ; GET PACKED ADDR SHLD AEND ; SAVE IT IN ENDING ADDR XCHG ; SWAP TO D-E LHLD ASTRT ; GET STARTING ADDR TO H-L MOV A,D ; GET H/O OF ENDING ADDR CMP H ; TEST TO H/O OF START RC ; LT, ERROR RNZ ; NOT ZERO, GO ON MOV A,E ; GET L/O OF END CMP L ; TEST TO L/O OF START RC ; LT, ERROR ORA A ; CLEAR CARRY RET ; ;******************************************************************** ; ; RDADR - READ 4-BYTE ADDRESS FROM CONSOLE, ; CONVERT IT TO HEX AND STORE IT. ; ;******************************************************************** ; RDADR EQU $ LXI H,NRAND ; RANDOMLY CREATE NRAND LXI D,ADDRA ; ADDR TO FILL MVI B,4 ; CHAR COUNT ; RDSTA EQU $ CALL KSTAT ; TEST KYBD STATUS JC RDBYT ; CARRY= CHAR READY INR M ; ELSE, ADD TO NRAND DIGIT JMP RDSTA ; LOOP TILL CHAR ; RDBYT EQU $ CALL KEYIN ; READ CHAR CALL TESTK ; TEST VALIDITY JC RDERR ; NG, RESTART STAX D ; OK, STORE CHAR INX D ; BUMP ADDRA PTR INX H ; AND NRAND PTR DCR B ; MINUS LTH COUNTER JNZ RDSTA ; LOOP TILL DONE MVI A,0DH ; CARR RTN CALL TYPE ; TYPE IT RET ; RDERR EQU $ PUSH H ; SAVE H-L (NRAND DIGIT) LXI H,MSGKE ; GET ERR MSG ADDR CALL LINE ; TYPE LINE POP H ; RESTORE H-L STC ; SHOW ERROR RET ; MSGKE DB 0DH IF PANEL DB 'YOU WANTA TRY THAT AGAIN?',0DH ENDIF DB 00 ; ;******************************************************************** ; ; TESTK - TEST KEYIN CHARACTER. ; IF CTL-C, DO COLD BOOT ; ;******************************************************************** ; TESTK EQU $ CPI 03H ; CTL-C? JZ EXIT ; YUP, GET OUT CPI '0' ; NUMERIC JC TSKNG ; NOPE, ERR CPI '9'+1 ; REALLY NUMERIC? JNC TSKAF ; NO, TEST A-F SUI 30H ; ADJUST TO BINARY ORA A ; RESET CARRY RET ; TSKAF EQU $ CPI 'A' ; TEST "A" JC TSKNG ; LT, ERR CPI 'F'+1 ; TEST "F" JNC TSKNG ; GT F, ERR SUI 37H ; SUBTRACT 55 ORA A ; RESET CARRY RET ; TSKNG EQU $ STC RET ; ;******************************************************************** ; ; PACKA - PACK ADDRESS KEYED-IN ; ;******************************************************************** ; PACKA EQU $ LXI H,ADDRA ; GET PARTIALLY-CONVERTED ADDR CALL PACKB ; PACK A BYTE MOV D,A ; PUT IT OVER THERE FOR THE NONCE CALL PACKB ; PACK 2ND BYTE MOV E,A ; COMBINE XCHG ; THEM INTO H-L SHLD ADDRH ; SAVE THEM IN ADDRH RET ; PACKB EQU $ MOV A,M ; GET CHAR FROM INPUT RLC ; ROTATE RLC ; IT RLC ; TO RLC ; H/O ANI 0F0H ; CLEAR L/O MOV B,A ; SAVE IT IN B INX H ; BUMP MEM PTR MOV A,M ; GET NEXT CHAR ORA B ; OR ON H/O FROM B INX H ; BUMP MEM PTR AGAIN RET ; ;******************************************************************** ; ; RANDS - SAVE RANDOM NUMBER FOR LATER RESTORATION ; ;******************************************************************** ; RANDS EQU $ LXI H,NRAND+3 ; PT TO L/O OF 4-BYTE RANDOM NUMBER MVI A,01 ; ENSURE ORA M ; THAT L/O OF NRAND MOV M,A ; ENDS IN 1 LXI D,NRNDS+3 ; POINT D TO RAND SAVE JMP RNDS2 ; GO TO COMMON MOVE RTN ; RANDR EQU $ LXI H,NRNDS+3 ; FROM ADDR = RAND SAVE LXI D,NRAND+3 ; TO ADDR = RANDOM NUMBER ; RNDS2 EQU $ MVI B,4 ; COUNT = 4 ; RNDSL EQU $ MOV A,M ; GET CHAR FROM SOURCE STAX D ; COPY IT TO DEST DCX D ; DECR DCX H ; BOTH PTRS DCR B ; MINUS COUNT JNZ RNDSL ; LOOP TILL DONE RET ; ; ;******************************************************************** ; ; DATA AREAS ; ;******************************************************************** ; NRAND DS 4 ; PSEUDO-RANDOM NUMBER NRNDS DS 4 ; RAND SAVE AREA ; MLTPR DW 0A5A5H ; RANDOM MULTIPLIER ; PRDAD DW 0 ; PARTIAL PRODUCT A*D PRDBD DW 0 ; " " B*D PRDBC DW 0 ; " " B*C ; ADDRA DS 4 ; ADDR INPUT ADDRH DS 2 ; HEX EQUIV. OF ADDRA ; ASTRT DS 2 ; HEX STARTING ADDR AEND DS 2 ; HEX ENDING ADDR ATEST DS 2 ; HEX TEST ADDR FOR "SLOW" ; MINDX DW 0 ; K INDEX TO ERROR MATRIX ; PASSC DW 0 ; PASS COUNTER ERRCT DW 0 ; ERROR COUNTER ; DS 2 MATRX DS 1024 ; ERROR MATRIX (64K * 16) DS 2 SLOWTOGL DB 0 ;SLOW TEST TOGGLE XAMTOGL DB 0 ;DETAILED LIST TOGGLE ; ; ;******************************************************************** ; ; GENERATE RANDOM BYTE ; ;******************************************************************** ; RANDB EQU $ PUSH D ; SAVE PUSH H ; REGS LDA MLTPR+1 ; GET MULTIPLIER L/O MOV C,A ; SAVE IN C LDA NRAND+3 ; GET NRAND L/O MOV B,A ; SAVE IN B CALL MULT ; GET 16-BIT PRODUCT IN H-L SHLD PRDBD ; STORE 1ST PARTIAL PRODUCT LDA MLTPR+1 ; GET MULTIPLIER H/O MOV C,A ; SAVE IN C LDA NRAND+2 ; GET NRAND DIG MOV B,A ; SAVE IN B CALL MULT ; DO MULTIPLICATION SHLD PRDBC ; SAVE PARTIAL PRODUCT LDA MLTPR ; GET MULTIPLIER L/O MOV C,A ; SAVE IN C LDA NRAND+3 ; GET NRAND L/O MOV B,A ; SAVE IN B CALL MULT ; DO MULTIPLICATION SHLD PRDAD ; SAVE 3RD PARTIAL PROD LDA PRDBD ; GET NEW L/O DIGIT STA NRAND+3 ; UPDATE NRAND L/O LXI H,0 ; GET CLEAR SUM MVI B,0 ; CLEAR H/O OF ADDEND LDA PRDBD+1 ; GET H/O OF PROD BD MOV C,A ; TO L/O OF ADDEND DAD B ; ADD INTO SUM LDA PRDBC ; GET L/O OF PROD BC MOV C,A ; TO L/O OF ADDEND DAD B ; ADD INTO SUM LDA PRDAD ; GET L/O OF PROD AD MOV C,A ; TO L/O OF ADDEND DAD B ; ADD INTO SUM MOV A,L ; GET L/O OF SUM STA NRAND+2 ; UPDATE NRAND TO NEW VALUE POP H ; RESTORE POP D ; REGS RET ; ;******************************************************************** ; ; MULT B * C = PROD IN H-L ; ;******************************************************************** ; MULT EQU $ PUSH D ; SAVE D-E MOV A,B ; COPY MULTIPLICAND TO A MVI B,0 ; CLEAR UPPER ADDEND LXI H,0 ; INIT PRODUCT TO ZERO MVI D,8 ; MULTIPLIER BIT COUNT MULT2 EQU $ DAD H ; SHIFT PRODUCT LEFT RLC ; MULTIPLIER BIT TO CARRY JNC MULTC ; SKIP IF BIT ZERO DAD B ; ELSE, ADD MPCND TO PARTIAL PRODUCT MULTC EQU $ DCR D ; DECR BIT COUNT JNZ MULT2 ; LOOP TILL DONE POP D ; RESTORE D-E RET ; ;******************************************************************** ; ; PRMAT - PRINT ERROR BIT MATRIX ; ;******************************************************************** ; PRMAT EQU $ CALL PRTPASS ; PRINT PASS COUNT LHLD ERRCT ; GET ERROR COUNT MOV A,H ; GET H/O ORA A ; Q. 0? JNZ PRMAH ; NO, GO THRU MATRIX MOV A,L ; GET L/O ORA A ; Q. ZERO? JZ PRMAX ; YES, BYPASS MATRIX SEARCH PRMAH EQU $ LXI H,MSGBH ; GET BIT ERR MSG HEADER CALL LINE ; TYPE IT LHLD ASTRT ; GET STARTING ADDR MOV A,H ; GET H/O ANI 0FCH ; MASK OFF L/O 2 BITS MOV H,A ; AND MOVE IT BACK XCHG ; MOVE TO D-E LXI H,MATRX ; POINT TO ERROR MATRIX MVI B,64 ; COUNT OF K'S TO SEARCH PRMA3 EQU $ MVI C,8 ; # OF BIT COUNTERS PER K PUSH H ; SAVE CURRENT K INDEX TO MATRIX PRMA4 EQU $ MOV A,M ; GET BIT COUNTER ORA A ; Q. ZERO? JNZ PRMA5 ; NO, MUST PRINT THIS K INX H ; ELSE, BUMP TO NEXT BIT CTR MOV A,M ; GET H/O OF BIT CTR ORA A ; TEST ZERO JNZ PRMA5 ; NO, PRINT K INX H ; YES, BUMP MEM PTR DCR C ; MINUS BIT COUNTER JNZ PRMA4 ; NOT DONE TESTING THIS K, LOOP JMP PRMA7 ; ELSE, TRY NEXT K PRMA5 EQU $ POP H ; RESTORE STARTING K INDEX MVI C,8 ; RESTART BIT COUNTER XCHG ; GET CURR K ADDR PUSH H ; SAVE IT MVI L,0 ; PRINT K ADDR ON EVEN BOUNDARY MVI A,' ' ; BLANK FOR SPACING CALL TYPE ; TYPE IT CALL TYPEB ; TYPE IT LXI H,MSG2B ; 2 BLANKS CALL LINE ; TYPE THEM POP H ; RESTORE K ADDR XCHG ; THEN SWAP BACK PRMA6 EQU $ PUSH D ; SAVE TARGET ADDR MOV E,M ; GET 1ST BYTE TO E INX H ; BUMP MEM PTR MOV D,M ; GET 2ND BYTE XCHG ; SWAP TO H-L CALL TYPEB ; TYPE CTR AS THO ADDR XCHG ; SWAP BACK POP D ; RESTORE D-E INX H ; BUMP MEM PTR DCR C ; MINUS COUNT JNZ PRMA6 ; LOOP TILL DONE MVI A,0DH ; CARR RTN CALL TYPE ; TYPE IT JMP PRMA8 ; AND GO TEST NEXT MATRIX LVL ; PRMA7 EQU $ POP H ; RESTORE H-L PUSH B ; SAVE COUNTERS LXI B,16 ; GET OFFSET TO NEXT K DAD B ; BUMP H-L POP B ; RESTORE COUNTERS PRMA8 EQU $ DCR B ; MINUS K COUNTER JZ PRMAX ; ZERO, DONE XCHG ; GET START ADDR PUSH B ; SAVE BIT COUNTERS LXI B,400H ; GET K BOUNDARY DAD B ; ADJUST START ADDR XCHG ; SWAP BACK POP B ; RESTORE BIT COUNTERS JMP PRMA3 ; LOOP TILL DONE ; PRMAX EQU $ RET ; MSGBH DB 'K ADDR B7 B6 B5 B4' DB ' B3 B2 B1 B0' DB 0DH,00 ; ;******************************************************************** ; ; PRTPASS - PRINT PASS COUNTER AND TOTAL ERRORS ; ;******************************************************************** ; PRTPASS EQU $ LXI H,MSGPC ; GET PASS COUNT MSG ADDR CALL LINE ; TYPE IT LHLD PASSC ; GET PASS COUNTER CALL TYPEB ; TYPE IT LXI H,MSGER ; ERROR COUNT MESSAGE CALL LINE ; TYPE LINE LHLD ERRCT ; GET ERROR COUNTER CALL TYPEB ; TYPE COUNT OF ERRORS MVI A,0DH ; CARR RTN CALL TYPE ; END LINE RET ; MSGPC DB 'PASSES COMPLETED = ',00 MSGER DB '; COUNT OF ERROR BYTES = ',00 DB 00 ; ;******************************************************************** ; ; TYPEH - TYPE A BYTE IN 2-DIGIT HEX ; ;******************************************************************** ; TYPEH EQU $ PUSH B ; SAVE COUNT MOV B,A ; SAVE CHAR IN B ANI 0F0H ; STRIP L/O RRC ; SHIFT RRC ; TO RRC ; L/O RRC ; 4 BITS CALL TYPHH ; TYPE HEX MOV A,B ; GET CHAR BACK ANI 0FH ; NOW STRIP H/O CALL TYPHH ; TYPE HEX POP B ; RESTORE COUNT RET ; TYPHH EQU $ ADI 90H ; DO DAA ; HEX TO ASCII ACI 40H ; ADJUSTMENT DAA ; TRICK CALL TYPE ; TYPE ADJUSTED HEX CHAR RET ; ;******************************************************************** ; ; QUICK - DO QUICK TEST OF MEMORY RANGE ; USING X'FF' AND X'00' ; ;******************************************************************** ; QUICK EQU $ MVI C,0FFH ; USE FOXES FIRST CALL QTEST ; DO QUICK TEST CALL KSTAT ; TEST KYBD READY RC ; YES, EXIT MVI C,00H ; NOW USE ZEROS CALL QTEST ; DO QUICK TEST AGAIN RET ; QTEST EQU $ LHLD AEND ; GET END ADDR TO H-L XCHG ; SWAP IT TO D-E LHLD ASTRT ; GET STARTING ADDR QTES2 EQU $ CALL KSTAT ; TEST KYBD READY RC ; YES, EXIT MOV A,C ; GET STORING VALUE CALL STNDX ; STORE CHAR IN MEM, BUMP INDEX JC QTES2 ; LT, MORE LHLD ASTRT ; GET START ADDR AGAIN QTES3 EQU $ CALL KSTAT ; TEST KYBD READY RC ; YES, EXIT MOV A,C ; GET STORED VALUE MOV B,M ; GET CHAR FROM MEM CMP B ; TEST EACH DIGIT AGAINST EXPECTED JZ QTES4 ; EQ, ON CALL TYPEA ; ELSE, TYPE ERR VALS CALL STMAT ; STORE BIT ERRORS IN MATRIX QTES4 EQU $ CALL INDEX ; BUMP INDEX JC QTES3 ; LT, AGAIN RET ; ;******************************************************************** ; ; SLOW - DO SUPER-SLOW MEM TEST. ; FIRST, MARCH A 1 BIT THRU A FLD OF ZEROS, ; TESTING EACH OTHER BYTE IN THE RANGE FOR ; A CHANGE. ; THEN, MARCH A ZERO BIT THRU A FLD OF ONES, ; TESTING AS ABOVE. ; ;******************************************************************** ; SLOW EQU $ IF PANEL IN 255 ; READ SENSE SWS ANI SSWS ; TEST SLOW SELECTED ENDIF IF NOT PANEL LDA SLOWTOGL ANI 01 ;DO SLOW TEST IF SLOWTOGL=1 ENDIF RZ MVI B,00 ; ZEROS TO MEM FOR 1ST PHASE CALL SETMEM ; CLEAR ADDR SPACE MVI C,01 ; BIT REG SLOW2 EQU $ CALL SLOWT ; DO SLOW TEST CALL KSTAT ; TEST FOR INTERRUPTION RC ; YES, GO MOV A,C ; GET BIT REG RLC ; SHIFT BIT JC SLOW3 ; WHEN BIT REACHES CARRY, DONE MOV C,A ; REPLACE BIT JMP SLOW2 ; NOT DONE, CONTINUE SLOW3 EQU $ MVI B,0FFH ; ALL ONES CALL SETMEM ; TO ADDR SPACE MVI C,0FEH ; BIT REG TO A L/O ZERO SLOW4 EQU $ CALL SLOWT ; DO SLOW TEST CALL KSTAT ; TEST FOR INTERRUPTION RC ; YES, GO MOV A,C ; GET BIT REG RLC ; SHIFT 0 BIT LEFTWARDS JNC SLOW5 ; WHEN ZERO REACHES CARRY, DONE MOV C,A ; REPLACE BIT REG JMP SLOW4 ; NOT DONE, CONTINUE ; SLOW5 EQU $ MVI B,08 ; COUNT OF BELLS SLOWB EQU $ MVI A,07H ; BELL CHAR CALL TYPE ; SOUND IT CALL KSTAT ; TEST KYBD READY JC SLOWX ; YES, CLEANUP LXI H,0 ; LONG WAIT SLOW6 EQU $ DCR L ; JNZ SLOW6 ; DCR H ; JNZ SLOW6 ; DCR B ; MINUS BELL COUNT JNZ SLOWB ; NOT DONE, RING AGAIN SLOWX EQU $ MVI A,0DH ; CR CALL TYPE ; TYPE IT RET ; SLOWT EQU $ LHLD ASTRT ; GET STARTING ADDR FOR TEST SHLD ATEST ; STORE IT AT TEST ADDR SLOWT2 EQU $ LHLD ATEST ; GET TEST ADDR MOV M,C ; STORE BIT REG AT TEST BYTE LHLD AEND ; ENDING ADDR TO H-L XCHG ; SWAP IT TO D-E LHLD ASTRT ; GET STARTING ADDR SLOWS2 EQU $ MOV A,M ; GET BYTE FROM MEM CMP B ; TEST TO EXPECTED JZ SLOWS5 ; EQ, ON PUSH B ; SAVE B-C MOV C,A ; SAVE CHAR READ (ERROR) XCHG ; CURRENT ADDR TO D-E LHLD ATEST ; GET TEST ADDR TO H-L MOV A,H ; GET H/O ADDR OF TEST BYTE CMP D ; TEST TO D JNZ SLOWS3 ; NOT EQ, ON MOV A,L ; GET L/O CMP E ; TEST L/O OF TEST ADDR JNZ SLOWS3 ; NOT EQUAL, PRT ERROR JMP SLOWS4 ; AND BYPASS ERROR PRT SLOWS3 EQU $ MOV A,B ; SWAP EXPECTED TO ACC MOV B,C ; INSERT VALUE READ IN ERROR CALL TYPEA ; TYPE ADDR CALL STMAT ; STORE IN ERR MATRIX SLOWS4 EQU $ POP B ; RESTORE B-C LHLD AEND ; GET ENDING ADDR XCHG ; CURRENT ADDR BACK TO H-L SLOWS5 EQU $ INX H ; BUMP MEM PTR MOV A,H ; GET H/O OF CURR ADDR CMP D ; TEST TO H/O OF END ADDR JC SLOWS2 ; LT, CONTINUE MOV A,L ; GET L/O OF CURR ADDR CMP E ; TEST TO L/O OF END ADDR JC SLOWS2 ; LT, ON SLOWSX EQU $ CALL KSTAT ; TEST FOR INTERRUPTION RC ; YES, GO LHLD ATEST ; GET TEST ADDR MOV M,B ; REPLACE TEST BYTE INX H ; BUMP TEST ADDR SHLD ATEST ; AND RESAVE IT XCHG ; SWAP TEST ADDR TO D-E LHLD AEND ; GET END ADDR TO H-L MOV A,D ; GET H/O OF TEST ADDR CMP H ; TEST TO H/O OF END ADDR JC SLOWT2 ; LT, ON JNZ SLOWTX ; NOT EQ, DONE MOV A,E ; GET L/O OF TEST ADDR CMP L ; TEST TO L/O OF END ADDR JC SLOWT2 ; LT, ON JZ SLOWT2 ; EQ, 1 MORE TIME SLOWTX EQU $ RET ; ;******************************************************************** ; ; SETMEM - SET ADDR SPACE TO VALUE IN B ; ;******************************************************************** ; SETMEM EQU $ LHLD AEND ; GET ENDING ADDR XCHG ; TO D-E LHLD ASTRT ; GET STARTING ADDR SETM2 EQU $ MOV M,B ; FILL MEM BYTE CALL INDEX ; BUMP PTR JC SETM2 ; LT, LOOP RET ; ;******************************************************************** ; ; INIT - SETUP MATRIX ; ;******************************************************************** ; INIT EQU $ LXI H,MATRX ; GET ERROR MATRIX ADDR LXI B,1024 ; GET MATRIX LENGTH XRA A ; GET ZERO INIT2 EQU $ MOV M,A ; STORE ZERO IN ERROR MATRIX BYTE INX H ; BUMP MEM PTR DCR C ; MINUS L/O OF COUNT JNZ INIT2 ; INNER LOOP DCR B ; MINUS COUNT JNZ INIT2 ; LOOP TILL DONE LXI H,0 ; ZEROS TO SHLD PASSC ; PASS COUNTER SHLD ERRCT ; AND ERROR COUNTER RET ; ;******************************************************************** ; ; TYPEA - TYPE ERROR ADDR, WROTE, READ ; ;******************************************************************** ; TYPEA EQU $ PUSH PSW ; SAVE CHAR 2B TYPED IF PANEL IN 255 ; READ SENSE SWS ANI SSWD ; TEST DETAIL LIST SENSE SW ENDIF IF NOT PANEL LDA XAMTOGL ANI 01 ; DO DETAILED LIST IF XAMTOGL=1 ENDIF JZ TYPAX ; YES, DON'T DETAIL ERRS PUSH H ; SAVE ADDR OF ERROR LHLD ERRCT ; GET ERROR COUNTER MOV A,H ; GET H/O ORA A ; Q. ZERO? JNZ TYPA2 ; NO, ALREADY PRINTED HEADER MOV A,L ; GET L/O ORA A ; Q. ZERO? JNZ TYPA2 ; NO, BYPASS LXI H,MSGEH ; GET ERROR HEADER MSG CALL LINE ; TYPE IT TYPA2 EQU $ POP H ; RESTORE ERROR ADDR CALL TYPEB ; CONVERT AND TYPE H-L PUSH H ; SAVE H-L AGAIN LXI H,MSG2B ; 2 BLANKS CALL LINE ; TYPE IT POP H ; RESTORE H-L POP PSW ; GET CHAR PUSH PSW ; RESAVE IT CALL TYPEH ; TYPE IT PUSH H ; SAVE H-L AGAIN LXI H,MSG3B ; 3 BLANKS CALL LINE ; TYPE IT POP H ; RESTORE H-L MOV A,B ; GET CHAR READ CALL TYPEH ; TYPE IT MVI A,0DH ; CARR RTN CALL TYPE ; SEND IT TYPAX EQU $ POP PSW ; RESTORE CHAR RET ; MSGEH DB 'ADDR WROTE READ',0DH DB 00 MSG3B DB ' ' MSG2B DB ' ',00 ; ;******************************************************************** ; ; TYPEB - TYPE 2-BYTE ADDRESS IN H-L ; ;******************************************************************** ; TYPEB EQU $ MOV A,H ; GET H/O OF ADDR CALL TYPEH ; TYPE IT MOV A,L ; GET L/O CALL TYPEH ; TYPE IT MVI A,' ' ; BLANK CALL TYPE ; FOR SEPARATION RET ; END