diff --git a/UDOS/WEGA/K.ACT.S b/UDOS/WEGA/K.ACT.S new file mode 100644 index 0000000..ca4316d --- /dev/null +++ b/UDOS/WEGA/K.ACT.S @@ -0,0 +1,1018 @@ +;************************************************************* +; +; P8000 KOPPELSOFTWARE +; MODUL: UDOS-DATEI E/A +; (angepasste REMOTE-Software) +; VERSION: 2.0 +; +;************************************************************* + + EXTERNAL BUF + EXTERNAL WAIT LODNET SNDNET + EXTERNAL SNDACK UEB16 + GLOBAL LOAD SEND + GLOBAL ACTFLG + +XFERSZ: EQU 64 +BFRLEN: EQU 1000H +RL: EQU 200H ;RL=0 = DEFAULT RL + +BINARY: EQU 0 +QUERY: EQU 1 +FILDES: EQU 2 +EXEC: EQU 4 + +MAGIC: EQU 0D607H +S0BC EQU 27H +S0BD EQU 26H +SYSTEM: EQU 1003H +DATE: EQU 0FA2H + +BTOHEX EQU 0BDFH ;AUS PROM-TEIL + +SOH: EQU 01H +STX: EQU 02H +ETX: EQU 03H +EOT: EQU 04H +ACK: EQU 06H +NAK: EQU 15H ;CTRL-U +CAN: EQU 18H +ESC: EQU 1BH + + +;ZEITGETEILTER FLOPPY-ZUGRIFF + +DISK: CALL SYSTEM +DLOOP: CALL UEB16 + LD A,(IY+10) + BIT 7,A + JR Z,DLOOP + BIT 6,A +DEND: RET + +;AUSGABE AUF CONSOLE + +OUTAS: + LD A,(HL) + LD B,A + INC HL +SFREE IN A,(S0BC) + BIT 2,A ;SENDEPUFFER LEER + JR Z,SFREE ;NEIN + LD A,(HL) ;ZEICHEN + OUT (S0BD),A ;AUSGEBEN + INC HL + DJNZ SFREE + RET + +ERROR: + LD HL,ERMSG1 + CALL OUTAS + LD HL,NAMLEN + CALL OUTAS + LD A,(IY+10) + LD HL,ERNR + CALL BTOHEX + LD HL,ERMSG2 + CALL OUTAS + RET + +ERMSG1 DEFB 5 + DEFM 'File ' + +ERMSG2 DEFB 11 + DEFM ' Error ' +ERNR: DEFW 2020H + DEFB 0DH + DEFB 0AH + +NETSND: LD A,(HL) + CP 80H + RET Z + INC HL + PUSH HL + CALL SNDNET + POP HL + JR NETSND + +WLODNET CALL LODNET + JR Z,WLODNET + RET + +TRNBYT: + CALL LODNET + JR Z,TRNBYT + RET + + +MSKTRN: + CALL WLODNET + AND 7FH + RET + + +WAITAK: + CALL WLODNET + AND 7FH + CP ACK + RET ;ZERO IF ACK,NONZERO IF NOT + + +;START REQUEST + +STRTRQ: + CALL SNDACK + CALL WLODNET + LD (FLGBYT),A ;WAIT FOR THE FLAGBYTE + CALL SNDACK ;ACKNOWLEDGE IF GOT + CALL FILNAM + LD IX,FLP + LD (IX),0 + LD A,(FLGBYT) + BIT BINARY,A + JR Z,ASCTYP + BIT EXEC,A + JR Z,BINTYP + SET 7,(IX) ;SET PROCEDURE TYPE-FILE + RET +BINTYP: + SET 4,(IX) + RET +ASCTYP: + SET 5,(IX) + RET + +;****************************************************** +;LOAD REQUEST + +LOAD: + RES 2,(HL) + CALL STRTRQ + + BIT FILDES,A + JR Z,LOAD1 + + CALL CLRBUF ;DESCRIPTOR EINLESEN + LD HL,80H + LD (ABFRLEN),HL ;NEW LENGTH + LD HL,ACTFLG + SET 7,(HL) + LD DE,DARRAY + LD HL,DATE + LD BC,8 + LDIR + + CALL SNDACK + JR WAISTX + +LOAD1: + LD (IX+01),01 ;OPEN FOR OUTPUT + LD HL,RL ;RECORD LENGTH + CALL OPNFIL + JR Z,REDTRN ;WITH NO ERROR READY FOR TRANSFER + CALL ERROR ;THERE OCCURED ANOTHER ERROR + JP CANCEL ;SEND THE CANCEL-REQUEST + +REDTRN: + CALL CLRBUF + CALL SNDACK ;ACKNOWLEDGE FOR A GOOD FILE +WAISTX: + CALL MSKTRN + CP STX + JR Z,STXFON + CP CAN + JP Z,CANCIN + CP ESC + JP Z,CANCIN + JR WAISTX + + +STXFON: + LD HL,CHKSUM + LD (HL),0 + CALL TRNBYT ;BLOCK LENGTH + LD D,A + PUSH DE + CALL TRNBYT + POP DE + LD E,A + PUSH DE ;COUNT + LD HL,CHKBFR +MORCHR: + PUSH DE + PUSH HL + CALL TRNBYT + POP HL + POP DE + LD C,A + LD A,(CHKSUM) + XOR C + LD (CHKSUM),A + LD (HL),C + INC HL + DEC DE + LD A,D + OR E + JR NZ,MORCHR + +LOKETX: + CALL MSKTRN + CP ETX + JR NZ,LOKETX + CALL WLODNET + LD C,A + LD A,(CHKSUM) + CP C + LD HL,CHKBFR + POP DE ;COUNT + JR Z,PUTBUF + LD A,NAK + CALL SNDNET + JR WAISTX + +PUTBUF: + LD A,(HL) + CALL PUTBFR + JP NZ,CANCEL + DEC DE + INC HL + LD A,D + OR E + JR NZ,PUTBUF + +GIVACK: + CALL SNDACK + JR WAISTX + +;++++++++++ +;CANCEL LOAD + +CANCEL: + LD A,CAN + CALL SNDNET + CALL WAITAK ;WAIT FOR THE BACK-CANCEL + JP CLOSE + +CANCIN: + JP CLOSEW ;WAIT FOR THE NEXT ACTIONS + + +;++++++++++ +;WRITE DATA BYTES TO BUFFER +;WRITE TO DISK WHEN BUFFER FULL + +PUTBFR: + PUSH HL + PUSH BC + PUSH DE + LD HL,(ABUF) + LD BC,(ABFRLEN) + LD (HL),A + INC HL + DEC BC ;INCREMENT POINTER,REDUCE COUNT + LD (ABUF),HL + LD (ABFRLEN),BC + LD A,B + OR C + JR Z,PUTBFW ;IF BUFFER FULL WRITE IT TO THE FILE + XOR A +PUTB1: POP DE + POP BC + POP HL + RET +PUTBFW: + LD A,(ACTFLG) + BIT 7,A + RES 7,A + LD (ACTFLG),A + JR NZ,WRTDES + + CALL WRTFIL + PUSH AF + CALL CLRBUF +; LD HL,PUNKT +; CALL OUTAS + POP AF + JR PUTB1 + +;++++++++++ +;WRITE DESCRIPTOR RECORD + +WRTDES: + LD HL,(BUF) + LD A,L + LD L,H + LD H,A + LD DE,MAGIC + OR A + SBC HL,DE + JR Z,WRTD1 + + LD HL,NODES ;ERROR NO DESCRIPTOR +WRTD0: CALL OUTAS + XOR A + INC A + JR PUTB1 + +WRTD1: LD DE,(BUF+15) ;RL + LD HL,BFRLEN + OR A + SBC HL,DE + LD HL,NORL + JR C,WRTD0 ;RL TO LARGE + + LD DE,FILPRM ;MOVE + LD HL,BUF+12 + LD BC,74H + LDIR + + LD DE,DATE + LD HL,BUF+18H + LD BC,8 + LDIR + LD A,(BUF+13H) + LD (PROP),A + + POP DE + POP BC + POP HL + POP HL ;RET FROM PUTBFR + JP LOAD1 + +;+++++++++ +;WRITE A BUFFER TO DISK + +WRTFIL: + LD HL,BFRLEN + LD BC,(ABFRLEN) + AND A + SBC HL,BC + RET Z ; IF THERE IS NOTHING TO WRITE DO NOTHING + + LD (FILDL),HL + + LD A,(FLGBYT) + BIT FILDES,A + JR NZ,WF0 + + EX DE,HL + LD HL,(FILSMT+2) + ADD HL,DE + LD (FILSMT+2),HL + DEC HL + LD (HIGADR),HL + EX DE,HL + +WF0: LD DE,(FILRL) +WF1: OR A + SBC HL,DE + JR Z,WF2 + JR NC,WF1 +WF2: ADD HL,DE + LD A,(FLP) + BIT 5,A + JR Z,WF3 + DEC HL ;ASCII FILE, EOF NOT COUNT +WF3: LD (FILST1),HL ;NUMBER OF BYTES IN LAST RECORD + + LD IY,FILVEC + CALL DISK + RET Z ;IF NO ERRORS RETURN + CALL ERROR ;IF THERE WAS ONE DISPLAY IT + XOR A + INC A + RET ;NONZERO RETURN SHOWS ERROR + + +;++++++++++ +;CLEAR BUFFER + +CLRBUF: LD HL,BUF + LD (ABUF),HL + LD DE,BUF+1 + LD BC,BFRLEN + LD (ABFRLEN),BC + DEC BC + LD (HL),-1 + LDIR + RET + + +;****************************************************** +;CLOSE FILE + + +CLOSEW: + LD A,(FLP) + BIT 5,A ;ASCII ? + JR Z,CLOSE1 + LD A,-1 ;EOF - MARK + CALL PUTBFR +CLOSE1: CALL WRTFIL + LD A,(FLGBYT) + BIT FILDES,A + JR Z,CLOSE + LD DE,DATE + LD HL,DARRAY + LD BC,8 + LDIR + LD A,(PROP) + LD (FILPRP),A + +CLOSE: +; LD HL,NEWLN +; CALL OUTAS + + LD IY,FILCLS + LD (IY+4),74H + CALL SYSTEM + + CALL SNDACK ;SEND THE ACKNOWLEDGE FOR READY + JP WAIT + + +;****************************************************** +;SEND REQUEST + +SEND: + RES 1,(HL) + + CALL STRTRQ + LD (IX+01),0 ;OPEN FOR INPUT + LD HL,0 ;DEFAULT RL + CALL OPNFIL + PUSH AF + CALL NZ,ERROR ;NZ IST ERROR-RETURN + POP AF + JP NZ,CANCL ;CANCEL THIS FILEREQUEST + + ;READY FOR TRANSFER + CALL SNDACK ;FOR FILENAME IS OPEN OK + LD IY,FILRDV + LD (IY+0AH),0 + LD HL,0 + LD (BFCNT),HL + + LD A,(FLGBYT) + BIT FILDES,A + JR Z,REDLOP + +SNDDESC: ;SEND DESCRIPTOR RECORD + LD HL,BUF + LD (BUFPOI),HL + LD B,6 + LD DE,MAGIC +SNDD1: LD (HL),D + INC HL + LD (HL),E + INC HL + DJNZ SNDD1 + EX DE,HL + LD HL,FILPRM + LD BC,74H + LDIR + LD HL,80H + LD (BFCNT),HL + +REDLOP: + LD HL,ACTFLG + BIT 5,(HL) + RES 5,(HL) + JP NZ,DONRED + LD HL,(BFCNT) + LD DE,(BUFPOI) + LD IX,CHKBFR + LD BC,XFERSZ + LD (CCOUNT),BC +LDLOP: + LD A,H + OR L + JR Z,NEWRED + PUSH HL + AND A ;RESET CARRY + SBC HL,BC ;BUFCNT-XFERSZ > 0 ? + POP HL + CALL C,CHKS ;SET ACTUAL COUNT INSTEAD OF XFERSZ + LD A,(FLP) + BIT 5,A + JR Z,OVCHK1 + LD A,(DE) + CP 0FFH ;IS THERE ASCII-EOF ? + JR Z,ASCEOF +OVCHK1: + LD A,(DE) + INC DE + DEC HL + LD (BFCNT),HL + LD (BUFPOI),DE + LD (IX),A + DEC BC + INC IX + LD A,B + OR C + JP Z,SNDREC + JR LDLOP + +ASCEOF: + LD HL,(CCOUNT) + AND A + SBC HL,BC ;ACTUAL COUNT FOR RECORD + LD (CCOUNT),HL + LD HL,ACTFLG + SET 5,(HL) + JP SNDREC + +;++++++++++ +;READ FROM DISK TO BUFFER + +NEWRED: + LD A,(ACTFLG) + RES 6,A + LD (ACTFLG),A + LD IY,FILRDV + LD A,(IY+0AH) + CP 0C9H + JR Z,DONRED + + LD HL,BFRLEN + LD (RDVLEN),HL + CALL DISK + LD A,(IY+0AH) + CP 0C9H + JR Z,NEWEND + BIT 6,A + PUSH AF + CALL NZ,ERROR + POP AF + JP NZ,CANCL + + CALL SUBREC + JR Z,NEWEND + +; LD HL,PUNKT +; CALL OUTAS +NEWR0: LD HL,(RDVLEN) +NEWR1: LD (BFCNT),HL + LD DE,BUF + LD (BUFPOI),DE + JP REDLOP + +NEWEND: LD (IY+0AH),0C9H + LD HL,(FILST1) + LD A,L + OR H + JR Z,NEWR0 ;NUMBER OF BYTES IN LAST + ;RECORD NOT USED + PUSH DE + LD DE,(FILRL) + LD HL,(RDVLEN) + LD A,L + AND 7FH + JR NZ,NEWR0 + SBC HL,DE + LD DE,(FILST1) + ADD HL,DE + POP DE + JR NEWR1 + +;++++++++++ +;END FILE TRANSFER + +DONRED: + LD A,EOT + CALL SNDNET + JP CLOSE + +;++++++++++ +;SET ACTUELL TRANSFER BLOCK LENGTH TO NUMBER OF LAST CHARACTERS + +CHKS: + LD A,(ACTFLG) + BIT 6,A + RET NZ + LD B,H + LD C,L + LD (CCOUNT),BC + SET 6,A + LD (ACTFLG),A + RET + +;++++++++++ +;DECREMENT RECORD COUNT + +SUBREC: LD DE,(FILRL) + LD HL,BFRLEN + LD BC,0 +SUBR1: INC BC + OR A + SBC HL,DE + JR NZ,SUBR1 + LD HL,(FILPRM+1) + OR A + SBC HL,BC + LD (FILPRM+1),HL + RET + +;++++++++++ +;SEND A BLOCK TO NET + +SNDREC: + LD HL,(CCOUNT) + LD A,H + OR L + JP Z,REDLOP + + LD A,STX + CALL SNDNET + LD BC,(CCOUNT) + LD A,B + PUSH BC + CALL SNDNET + POP BC + LD A,C + CALL SNDNET + LD DE,CHKBFR + LD HL,CHKSUM + LD (HL),0 + LD BC,(CCOUNT) +TRALOP: + LD A,(DE) + INC DE + DEC BC + PUSH AF + XOR (HL) + LD (HL),A + POP AF + PUSH BC + PUSH DE + PUSH HL + CALL SNDNET + POP HL + POP DE + POP BC + LD A,B + OR C + JR NZ,TRALOP + LD A,ETX + CALL SNDNET + LD A,(CHKSUM) + CALL SNDNET + CALL WAITAK + JP Z,REDLOP + CP NAK ;WAS IT A NAK + JR Z,SNDREC ;TRY IT AGAIN + JP CLOSE + +;++++++++++ +;CANCEL SEND + +CANCL: + LD A,CAN + CALL SNDNET + CALL WAITAK +CANIN: + LD IY,FILCLS + LD (IY+4),74H + CALL DISK + CALL SNDACK + JP WAIT + + +;****************************************************** +;GET FILENAME + +FILNAM: + CALL MSKTRN + CP STX + JR NZ,FRAMER + XOR A + LD (CHKSUM),A ;INITIALIZE CHECKSUM + LD C,A ;INITIALIZE NAME-LENGTH COUNTER + LD HL,NAMBUF +MORNAM: + PUSH BC + PUSH HL + CALL MSKTRN ;ONLY ASCII-CHARACTERS FOR FILENAME + POP HL + POP BC + LD B,A + CP ETX ;HAVE WE REACHED THE END ? + JR Z,ENDNAM + INC C + LD A,32 + CP C + JR C,MORN1 ;ONLY 32 CHARACTERS FOR FILENAME ALLOWED + LD (HL),B + INC HL +MORN1: + LD A,(CHKSUM) + XOR B + LD (CHKSUM),A + JR MORNAM + +ENDNAM: + LD (HL),0DH + CALL WLODNET + LD B,A + LD A,(CHKSUM) + CP B + JR NZ,SUMERR ;CHECKSUMERROR IN FILENAME ! + RET + + +;++++++++++ +;FILENAME ERROR + +SUMERR: +; LD HL,SUMEMS +; CALL OUTAS + LD A,NAK + CALL SNDNET ;GIVE A NONACKNOWLEDGE FOR THE WRONG FILENAME + JR FILNAM + ;TRY IT AGAIN TO GET THE NAME CORRECT + +SUMEMS: + DEFB 28 + DEFM 'CHECKSUM ERROR IN FILENAME ' + DEFB 0DH + +FRAMER: + POP HL ;FROM ROUTINE FILNAM + POP HL ;FROM ROUNTINE STRTRQ + CP CAN + JP Z,CANIN +; LD HL,FRAMSG +; CALL OUTAS + JP CANCL + +FRAMSG: + DEFB 36 ;LENGTH OF MSG + DEFM 'RECORD - FRAMING ERROR IN FILENAME' + DEFB 0DH + DEFB 0AH + + +;***************************** +;OPEN FILE + +OPNFIL: + LD A,(FLGBYT) + BIT FILDES,A + JR NZ,OPNF + + LD (FILRL),HL + LD (FILST1),HL + LD HL,0 + LD (LOWADR),HL + LD (HIGADR),HL + LD (STKSIZ),HL + LD (FILSMT),HL + LD (FILSMT+2),HL + LD (FILSMT+4),HL + LD (FILSMT+6),HL + +OPNF: XOR A + LD (FILSPV),A + LD (FILPRP),A + CALL ISNAME + RET NZ + + LD A,(IX+1) + OR A + JR Z,OPN0 + PUSH IX + LD IY,FILINI ;I REQUEST BEI WRITE + CALL SYSTEM + POP IX + +OPN0: PUSH IX + LD IY,FILASV ;ASSIGN REQUEST + CALL SYSTEM + POP IX + RET NZ + + LD A,'*' + LD (FILSPV+1),A + LD IY,FILOPN ;OPEN REQUEST + LD A,(IX+1) + LD (FILSPV),A + + LD A,(FLGBYT) + BIT FILDES,A + JR Z,OPN1 + + BIT BINARY,A ;DESCRIPTOR TRANSFER ONLY + JR Z,OPN3 ;TYPE BINARY + JR OPN2 + +OPN1: LD A,(IX) + LD (FILPRM),A +OPN2: LD (IY+4),74H + CALL SYSTEM + + LD A,(FLGBYT) + BIT FILDES,A + JR NZ,OPN4 + + LD A,(FLP) + AND 20H + LD B,A + LD A,(FILPRM) + LD (FLP),A + AND 20H + CP B + JR Z,OPN4 +OPN3: LD (IY+0AH),48H ;INVALID FILE TYPE +OPN4: LD A,(IY+0AH) + BIT 6,A + JR Z,FILOKM + CP 0D0H ;DUPLICATE FILE ERROR ? + RET + +;++++++++++ +;FILE OK + +FILOKM: + XOR A + RET + +;++++++++++ +;FILE NAME OK ? +ISNAME: + LD HL,NAMBUF + LD C,0 ;COUNT + LD A,(HL) + CP 0DH + JR Z,NAMERR + +NAMLOP: + LD A,(HL) + CP 0DH ;CR ERREICHT + JR Z,ENDLEN + CP ';' + JR Z,NAMERR + CP ' ' + JR Z,NAMERR + CP 09H + JR Z,NAMERR + INC HL + INC C + LD A,C + CP 33 + JR NZ,NAMLOP + LD (HL),0DH +ENDLEN: + LD HL,NAMLEN + LD (HL),C + INC HL ;NAMBUF + XOR A + RET + +NAMERR: LD A,46H ;INVALID FILE NAME + OR A + RET + +FILVEC: ;FILE WRITE BIN + DEFB 05 + DEFB 0FH + DEFW BUF +FILDL: DEFS 2 + DEFW DEND + DEFW DEND + DEFB 0 + DEFW 0 + +FILRDV: ;FILE READ BIN + DEFB 05 + DEFB 0BH + DEFW BUF +RDVLEN: DEFS 2 + DEFW DEND + DEFW DEND + DEFB 0 + DEFW 0 + +FILCLS: ;FILE CLOSE + DEFB 05 + DEFB 06 + DEFW FILPRM + DEFW 74H + DEFW 0 + DEFW 0 + DEFB 0 + DEFW 0 + +FILINI: ;DOS INIT + DEFB 05 + DEFB 00 + DEFW 0 + DEFW 0 + DEFW 0 + DEFW 0 + DEFB 0 + DEFW 0 + +FILASV: ;FILE ASSIGN + DEFB 05 + DEFB 02 + DEFW NAMBUF + DEFW 0 + DEFW 0 + DEFW 0 + DEFB 0 + DEFW FILSPV + +FILOPN: ;FILE OPEN + DEFB 05 + DEFB 04 + DEFW FILPRM + DEFW 74H + DEFW 0 + DEFW 0 + DEFB 0 + DEFW FILSPV + + +FILOK1: + DEFB 7 + DEFB 0DH + DEFB 0AH + DEFM 'FILE ' +FILOK2: + DEFB 9 + DEFM ' OF TYPE ' +PROTYP: + DEFB 9 + DEFM 'PROCEDURE' +ASTYP: + DEFB 5 + DEFM 'ASCII' +BNTYP: + DEFB 6 + DEFM 'BINARY' +OPENED: + DEFB 24 + DEFM ' IS OPEN FOR TRANSFER ' + DEFB 0DH + DEFB 0AH +PUNKT: + DEFB 1 + DEFM '.' +NEWLN: + DEFB 2 + DEFB 0DH + DEFB 0AH +LOGOUT: + DEFM 'logout' + DEFB 0AH + DEFB 80H + +NODES: DEFB NODESL + DEFM 'INVALID DESCRIPTOR' + DEFB 0DH + DEFB 0AH +NODESL: EQU $-NODES-1 + +NORL: DEFB NORLL + DEFM 'RECORD LENGTH TO LARGE' + DEFB 0DH + DEFB 0AH +NORLL: EQU $-NORL-1 + + +;****************************************************** +;FILE DESCRIPTOR + +FILPRM: DEFB 0 + DEFW 0 +FILRL: DEFW 0 +FILSTO: DEFS 2 +FILPRP: DEFS 1 +FILSA: DEFW 0 +FILST1: DEFS 18 +FILSMT: DEFS 82 +LOWADR: DEFS 2 +HIGADR: DEFS 2 +STKSIZ: DEFS 2 + +PROP: DEFS 1 +DARRAY: DEFS 8 + +;****************************************************** + +ACTFLG: DEFS 1 +CHKSUM: DEFS 1 +FLGBYT: DEFS 1 +FLP: DEFS 2 + +BUFPOI: DEFS 2 +BFCNT: DEFS 2 +CCOUNT: DEFS 2 + +NAMLEN: DEFS 1 +NAMBUF: DEFS 33 +FILSPV: DEFS 35 + +ABUF DEFS 2 +ABFRLEN DEFS 2 +CHKBFR: DEFS XFERSZ+1 diff --git a/UDOS/WEGA/K.BLK.S b/UDOS/WEGA/K.BLK.S new file mode 100644 index 0000000..7eb921e --- /dev/null +++ b/UDOS/WEGA/K.BLK.S @@ -0,0 +1,484 @@ +;************************************************************* +; +; P8000 KOPPELSOFTWARE +; MODUL: BLOCK-FLOPPY E/A +; VERSION: 3.0 +; +;************************************************************* + + GLOBAL BLKRD BLKWT BLKFO + GLOBAL RBLOCK WBLOCK + GLOBAL BLKINIT + EXTERNAL SNDNET SNDACK LODNET + EXTERNAL SNDDAT LODDAT + EXTERNAL WAIT UEB16 + EXTERNAL BUF + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Initialisierung der Floppy-Formate 2 und 4 + +BLKINIT: + ld de,TYP2 ;Typ 2 wird 48ds16 + ld hl,TYP5 + ld bc,11 + ldir + ld de,TYP4 ;Typ 4 wird 48ds5 + ld hl,TYP7 + ld bc,11 + ldir + ld l,40 ;Anzahl der Spuren + ld h,0c1h ;MT=1, MFM=1, SK=0, 8"=0, DSTEP=1 + ld (TYP2+9),hl + ld (TYP4+9),hl + ld hl,(TYP5) ;Typ 3 fuer MF 1.6 optimieren + ld (TYP3),hl ;LW-Zeiten + ld hl,-1 ;PR1/PR2 + ld (TYP3+6),hl + ret + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;ZEITGETEILTER FLOPPY ZUGRIFF + +DISK: LD IY,RQVEC + CALL FLOPPY +DLOOP: CALL UEB16 + LD A,(IY+10) + BIT 7,A ;FERTIG ? + JR Z,DLOOP + BIT 6,A +DEND: RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;mehrere Bloecke lesen / schreiben mit Spurwechsel + +DISKRQ: ld hl,(RESID) + ld a,h + or l + ret z ;Fertig + call BCOUNT + ex de,hl ;DE Laenge bis Ende der Spur + ld hl,(RESID) + or a + sbc hl,de + jr nc,DB1 + ld hl,(RESID) ;RESID < BCOUNT + ld (RQLEN),hl + ld hl,0 +DB1: ld (RESID),hl + call DISK + ret nz ;Fehler + ld hl,RQDA ;naechste Spur + ld a,(hl) + and 0e0h ;Sektor auf 0 + ld (hl),a + inc hl + inc (hl) ;Track increment + ld hl,(RQADR) + ld de,(RQLEN) + add hl,de + ld (RQADR),hl + jr DISKRQ + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;BLOCK LESEN: + +RBLOCK: LD A,0BH ;READ BINARY + JP KOPF ;KOPFINFORMATIONEN UEBERNEHMEN + +BLKRD: RES 0,(HL) ;RESET READ BIT IM STATUS + CALL DISKRQ + JR NZ,ERROR + CALL SNDACK + LD DE,(LEN) ;DATEN UEBERMITTELN + LD HL,BUF +BLKRLP: LD A,(HL) + CALL SNDDAT + INC HL + DEC DE + LD A,D + OR E + JR NZ,BLKRLP +WATACK: CALL LODDAT + JR Z,WATACK ;WARTEN AUF ACK + JR BRWEND + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;BLOCK SCHREIBEN: + +WBLOCK: LD A,0FH ;WRITE BINARY + CALL KOPF ;KOPFINFORMATIONEN UEBERNEHMEN + LD DE,(LEN) ;DATEN EINLESEN + LD HL,BUF +BLKWLP: CALL LODDAT + JR Z,BLKWLP + LD (HL),A + INC HL + DEC DE + LD A,D + OR E + JR NZ,BLKWLP + RET + +BLKWT: RES 1,(HL) ;RESET WRITE-BIT IM STATUS + CALL DISKRQ + JR NZ,ERROR + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; BLOCK READ/WRITE Ende + +FEND: LD A,ACK +ERROR: CALL SNDNET +BRWEND LD HL,(SAVEFD) ;ALTE WERTE RUECKSCHREIBEN + LD (FDCONF),HL + LD HL,0C050H ;ALTE WERTE FUER TABELLE NR.6 + LD (TYP6+9),HL ;WIEDER EINTRAGEN (STANDARD-NR.6) + JP WAIT + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;UEBERNAHME KOPFINFORMATIONEN + +KOPF: LD (RQCOD),A ;REQUEST-CODE +WAFI: CALL LODDAT + JR Z,WAFI ;1.BYTE ENTHAELT IM OBEREN NIBBLE FLOPPY-TYP + ;UND IM UNTEREN NIBBLE DRIVE-NR. + ld hl,(FDCONF) ;Retten FDCONF + ld (SAVEFD),hl + CALL TYP +WABN1: CALL LODDAT + JR Z,WABN1 + LD D,A ;BLOCK-NR. HIGH-BYTE +WABN2: CALL LODDAT + JR Z,WABN2 + LD E,A ;BLOCK-NR. LOW-BYTE + CALL BLOCK ;KONVERTIERUNG IN SPUR/SEKTOR +WAL1: CALL LODDAT + JR Z,WAL1 + LD H,A ;LENGTH HIGH-BYTE +WAL2: CALL LODDAT + JR Z,WAL2 + LD L,A ;LENGTH LOW-BYTE + LD (LEN),HL + LD (RESID),HL + RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +TYP: ;Setzen FDCONF und Drive + ld hl,BUF + ld (RQADR),hl ;Pufferadr setzen + push af + and 0f0h ;Typ + ld e,a + pop af + rrca + rrca + rrca + push af + and 0e0h + ld (RQDA),a ;DRIVE-NR. + pop af + rrca + and 0fh ;Typ + ld b,a + or e + ld e,a + ld d,a + + ld hl,OLDTYP ;hat sich Typ geaendert ? + cp (hl) + jr z,T0 ;nein + ld (hl),a + ld hl,PFDTYP ;Floppy-Treiber muss neuen + ld (hl),0 ;Typ initialisieren + +T0: cp 88h ;Standardtypen + jr c,T1 + ld de,6666H ;andere Typen auf Tabelle 6 abbilden + ld b,6 + jr z,FD48DS ;Typ 8 + cp 99h + jr z,FD48SS ;Typ 9 + cp 0aah + jr z,FD96SS ;Typ10 + ;alle restlichen werden auf 6 gesetzt + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;ADRESSE DER TABELLE DER FDTYP-DEFINITIONEN ERMITTELN + +T1: ld (FDCONF),de + push ix + ld ix,TYPTAB-11 + ld de,11 ;LAENGE EINES TYPTAB-EINTRAGS +T2: add ix,de + djnz T2 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Diskparameter ermitteln + + ld a,(ix+3) ;Anzahl Sektoren pro Spur und Seite + ld (NSECT1),a + ld l,0 + bit 7,(ix+10) ;SS / DS + jr z,T3 + add a,a ;DS + inc l +T3: ld (NSECT),a ;Anzahl der Sektoren + ld a,l + ld (DOUBLE),a ;0=SS 1=DS + ld a,(ix+2) ;Sektorlaenge + ld (SECLEN),a + ld a,(ix+9) ;Anzahl der Spuren + ld (NTRACK),a + pop ix + ret + +FD96SS: LD HL,4050H ;AUSFUEHREN DER ENTSPR. AENDERUNGEN + LD (TYP6+9),HL ;IN DER FLOPPY-TYP TABELLE NR.6 + JR T1 + +FD48DS: LD HL,0C128H + LD (TYP6+9),HL + JR T1 + +FD48SS: LD HL,4128H + LD (TYP6+9),HL + JR T1 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;UMWANDLUNG BLOCK-NR. IN SPUR- UND SEKTOR-NR. UND SETZEN IM REQUEST-VEKTOR +;DIVIDEND IN AE, DIVISOR IN C + +BLOCK: ex de,hl ;de Blocknummer + ld a,(SECLEN) + or a + jr z,BLOCK1 ;1 Block = 4 Sektoren + dec a + jr z,BLOCK2 ;1 Block = 2 Sektoren + dec a + jr z,BLOCK3 ;1 Block = 1 Sektor + dec a + jr nz,BLOCK3 ;unzulaessige Laenge + srl h ;/2 1 Block = 1/2 Sektor + rr l + jr BLOCK3 + +BLOCK1: add hl,hl +BLOCK2: add hl,hl +BLOCK3: ld a,(NSECT) ;Anzahl der Sektoren + ld c,a + ld a,h ;hl (n. Sektor) -> ae + ld e,l + call DV168 ;QUOTIENT IN E (SPUR-NR.) + ;Rest in A = Sektornummer + ld hl,RQDA + or (hl) ;+ DRIVE + ld (hl),a + inc hl + ld (hl),e ;SPUR-NR. + ret + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Integer Division +;Divident in AE, Divisor in C, Quotient in E, Rest in A + +DV168: CP C + CCF + RET C + LD B,8 + JR DV163 +DV161: SUB C +DV162: SCF + DEC B + JR Z,DV165 +DV163: RL E + RLA + JR C,DV161 + SUB C + JR NC,DV162 + ADD A,C + AND A + DJNZ DV163 +DV165: RL E + RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;BLOCK FORMAT / VERIFY / COPY DISK + +BLKFO: ld a,(hl) + ld (BLKREQ),a + ld (hl),0 + ld hl,(FDCONF) ;Retten FDCONF + ld (SAVEFD),hl + bit 4,a ;COPY DISK ? + jr z,BLKF1 +BLKF0: call LODNET + jr z,BLKF0 + ld (STYP),a ;SOURCE-Typ +BLKF1: CALL LODNET + JR Z,BLKF1 ;STATUS-BYTE (FD-TYP + DRIVE) + ld (DTYP),a ;SOURCE-Typ + CALL TYP ;SETZEN FDCONF UND DRIVE-NR. + LD HL,-1 ;POSITIONIERUNG AUF SPUR 0 + LD (CURT0),HL + LD (CURT0+2),HL + XOR A + LD (RQDA+1),A ;TRACK + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Diskette formatieren + +FORMAT: ld a,(BLKREQ) + bit 3,a + jr nz,VERIFY ;nur Verify + LD A,51H ;Requestcode fuer Format + LD (RQCOD),A + LD E,0 ;Seite 1 + CALL FBUILD + CALL DISK ;1 SPUR FORMATIEREN + JP NZ,ERROR + LD A,(DOUBLE) + OR A + JR Z,COPYDISK ;SS + + LD E,1 ;Seite 2 + CALL FBUILD + LD HL,RQDA + LD A,(HL) + OR C ;& SEKTOR NR FUER 2.SEITE + LD (HL),A ;AB SEKTOR 0 2. SEITE + CALL DISK ;1 SPUR FORMATIEREN + JP NZ,ERROR + LD HL,RQDA ;Sektor wieder auf 0 + LD A,(HL) + AND 0E0H ;Sektor auf 0 + LD (HL),A + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;COPY DISK + +COPYDISK: + ld a,(BLKREQ) + bit 4,a + jr z,VERIFY ;kein COPY DISK + ld a,(STYP) ;Quelldiskette Lesen + call TYP + ld a,0bh + ld (RQCOD),a ;Requstcode + call BCOUNT + call DISK + set 5,a ;in Fehlercode Source markieren + jp nz,ERROR + ld a,(DTYP) ;Zieldiskette Schreiben + call TYP + ld a,0fh + ld (RQCOD),a ;Requstcode + call DISK + jp nz,ERROR + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;DISKETTE VERIFY + +VERIFY: LD A,0BH + LD (RQCOD),A ;Requstcode + CALL BCOUNT + CALL DISK + JP NZ,ERROR + + LD HL,RQDA+1 ;TRACK + INC (HL) ;NAECHSTE SPUR + LD A,(NTRACK) + CP (HL) + JP NZ,FORMAT + JP FEND + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Format Daten aufbauen + +FBUILD: LD HL,(NSECT1) ;ANZAHL DER SEKTOREN 1 SEITE + LD B,L + LD C,L + LD H,0 + ADD HL,HL ;*2 + ADD HL,HL ;*4 (4 BYTE JE SEKTOR AN FDC) + LD (RQLEN),HL + LD HL,BUF ;FORMAT DATEN AUFBAUEN + LD D,1 ;1. SEKTOR +FLOOP1: LD A,(RQDA+1) ;TRACK + LD (HL),A ;SPUR + INC HL + LD (HL),E ;KOPF + INC HL + LD (HL),D ;SEKTOR + INC D + INC HL + LD A,(SECLEN) + LD (HL),A ;BYTE/SEKTOR + INC HL + DJNZ FLOOP1 + RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Berechnung der Bytes von Sektornummer bis Ende der Spur + +BCOUNT: LD A,(RQDA) + AND 1FH + LD B,A ;START Sektor + LD HL,128 + LD A,(SECLEN) ;SEKTORLAENGE (0 = 128 BYTE) + OR A + JR Z,BC2 +BC1: ADD HL,HL ;*2 + DEC A + JR NZ,BC1 +BC2: LD A,(NSECT) ;ANZAHL DER SEKTOREN + SUB B + LD B,A + EX DE,HL + LD HL,0 +BC3: ADD HL,DE + DJNZ BC3 + LD (RQLEN),HL ;IN HL: LAENGE EINER SPUR + RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +RQVEC DEFB 0 +RQCOD DEFS 1 +RQADR DEFW BUF ;DATEN ADR. +RQLEN DEFS 2 ;LAENGE + DEFW DEND + DEFW DEND + DEFS 1 +RQDA DEFS 2 ;DISK ADRESSE + +LEN DEFS 2 +RESID DEFS 2 +SAVEFD DEFS 2 +OLDTYP defb 0 +STYP defs 1 +DTYP defs 1 +NSECT1 defs 1 +NSECT defs 1 +NTRACK defs 1 +DOUBLE defs 1 +SECLEN defs 1 +BLKREQ defs 1 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +FLOPPY EQU 0BFDH +PFDTYP EQU 0E88H +FDCONF EQU 0EEBH +TYPTAB EQU 0B24H +TYP2 EQU TYPTAB+1*11 +TYP3 EQU TYPTAB+2*11 +TYP4 EQU TYPTAB+3*11 +TYP5 EQU TYPTAB+4*11 +TYP6 EQU TYPTAB+5*11 +TYP7 EQU TYPTAB+6*11 +CURT0 EQU 0FCEH + +POAD EQU 0CH +POBD EQU 0EH +P16A EQU 10H +P16B EQU 14H + +ACK EQU 06H +NAK EQU 15H diff --git a/UDOS/WEGA/K.BUF.S b/UDOS/WEGA/K.BUF.S new file mode 100644 index 0000000..ebaf5aa --- /dev/null +++ b/UDOS/WEGA/K.BUF.S @@ -0,0 +1,3 @@ + GLOBAL BUF + +BUF DEFS 4000H diff --git a/UDOS/WEGA/K.LINK b/UDOS/WEGA/K.LINK new file mode 100644 index 0000000..5b38cc9 --- /dev/null +++ b/UDOS/WEGA/K.LINK @@ -0,0 +1,2 @@ +V;PLINK $=4000 K.NEU K.BLK K.ACT K.PROM K.P8000 PLZ.MATH K.BUF (N=WEGA1 NOM RL=400) +B; diff --git a/UDOS/WEGA/K.NEU.S b/UDOS/WEGA/K.NEU.S new file mode 100644 index 0000000..a1956e5 --- /dev/null +++ b/UDOS/WEGA/K.NEU.S @@ -0,0 +1,832 @@ +;************************************************************** +; +; P8000 KOPPELSOFTWARE +; GRUNDMODUL +; VERSION: 3.1 +; +;************************************************************** + + GLOBAL SAVE S0BT + GLOBAL ERROR UEB16 + GLOBAL LODNET SNDNET WAIT STATUS WAITACK + GLOBAL LODDAT SNDDAT SNDACK + EXTERNAL LOAD SEND PROM + EXTERNAL ACTFLG + EXTERNAL BLKINIT + EXTERNAL BLKRD BLKWT BLKFO + EXTERNAL RBLOCK WBLOCK + + LD B,5 +ESTART: + LD HL,0FFFFH ;ZEITSCHLEIFE FUER FLOPPY +ENTRY: + DEC HL + LD A,H + OR L + JR NZ,ENTRY + DJNZ ESTART + + DI + LD HL,ISRPIO + LD (IP0KB),HL ;ISR-ADR IN TABELLE FUER PIO + + LD HL,ITABS0 ;RETTEN SIO 0 KANAL B ISR-ADR. + LD DE,SAVE + LD BC,32 + LDIR + + LD HL,IP1KA ;RETTEN PIO1 ISR-ADR + LD DE,SAVEPIO + LD BC,4 + LDIR + + IN A,(P0BD) ;STAND U8000-BIT RETTEN + PUSH AF + + LD HL,BUFFER ;INITIALISIEREN RINGPUFFER + LD (HL),0 + LD DE,BUFFER+1 + LD BC,BUFEND-BUFFER-1 + LDIR + + IN A,(P0AD) ;SCHEINEINGABE DAMIT PORT FREI ! + + XOR A + LD (ACTFLG),A + POP AF + BIT 7,A + JR Z,MMT ;U8000 BEREITS AKTIV + + XOR A ;RESET-U8000 AUF LOW + OUT (P0BD),A ;D.H. 16 BIT-TEIL START + LD B,80H + DJNZ $ + LD A,80H ;DOPPELRESET FUER + OUT (P0BD),A ;MP600-ERWEITERUNGSKARTEN + LD B,80H + DJNZ $ + XOR A ;NOTWENDIG + OUT (P0BD),A + + IN A,(P0BD) + BIT 6,A + JR Z,HWTEST ;PORT NICHT FREI (ALLES I.O.) + ;WENN PORT FREI ,WAS AN DIESER STELLE + ;NICHT SEIN DARF, DANN GEWISSE ZEIT WARTEN + LD HL,8000H +ZEIT: DEC HL + LD A,H + OR L + JR NZ,ZEIT + +;HARDWARETEST-KOPPELSCHNITTSTELLE + +HWTEST: + LD HL,0FFFFH ;MAX. ZEIT +W8000 IN A,(P0BD) + BIT 6,A + JR NZ,TEST + DEC HL + LD A,H + OR L + JR NZ,W8000 + LD HL,MERR ;U8000 ARBEITET NICHT + JR TERR1 + +TEST: LD C,2AH ;STATUS FUER + LD A,0AAH + CALL OUTP16 ;1.DATENMUSTER + JR Z,TERR + LD C,0AH + CALL WAITACK + JR NZ,TERR + IN A,(P0AD) + CP 0AAH + JR NZ,TERR + + LD A,55H + LD C,A ;STATUS FUER + CALL OUTP16 ;2.DATENMUSTER + JR Z,TERR + LD C,15H + CALL WAITACK + JR NZ,TERR + IN A,(P0AD) + CP 55H + JR NZ,TERR + + LD HL,KBC0R ;ENDGUELTIGE PROGRAMMIERUNG KOPPELPIO + LD C,P0BC ;MIT INTERRUPT + LD B,4 + OTIR + + LD A,2 ;KENNZEICHEN DAS VON UDOS-PROGRAMM + ;WEGA GESTARTET WURDE !!! + LD C,0 ;STATUS + CALL OUTP16 ;DATENMUSTER + JR NZ,WREQ ;OK + +TERR: LD HL,MTERR ;FEHLER BEI HARDWARETEST +TERR1: EI + CALL OUTAS + JR QUITRST + +MMT: + LD A,83H + OUT (P0BC),A ;PIO-INTERRUPT ERLAUBEN + EI + LD HL,MMLDG + CALL OUTAS + DI + +WREQ: LD HL,SNEUTAB ;SIO ISR-ADR. NEU INITIALISIEREN + LD DE,ITABS0 + LD BC,32 + LDIR + + LD HL,ISP1KA + LD (IP1KA),HL + LD HL,ISP1KB ;PIO1-ISR-ADR NEU SETZEN + LD (IP1KB),HL + + call BLKINIT ;Block-Floppy Init + EI + +WAIT: XOR A + LD (RSTART),A + LD A,8FH ;FD-LAUFWERKE READY SETZEN + LD (DSEL),A +LOOP: CALL UEB16 ;TEST OB INT-WERTE VON SIO'S ANLIEGEN + LD HL,STATUS + LD A,(HL) + OR A + JR Z,NEXT + BIT 0,A + JR NZ,QUIT + BIT 7,A + JR NZ,QUITRST + BIT 1,A + JP NZ,SEND + BIT 2,A + JP NZ,LOAD + BIT 3,A + JP NZ,PROM +NEXT: inc hl + ld a,(hl) + or a + jr z,LOOP + BIT 0,A + JP NZ,BLKRD + BIT 1,A + JP NZ,BLKWT + BIT 2,A + JP NZ,BLKFO + BIT 3,A + JP NZ,BLKFO + BIT 4,A + JP NZ,BLKFO + JR LOOP + +QUITRST: + LD A,80H ;U8000-RESET + OUT (P0BD),A + JR REEX + +QUIT: + CALL SNDACK + LD B,80H ;WARTEZEIT FUER U8000 KINB !!! + DJNZ $ + LD HL,BASP + CALL OUTAS + LD B,10 + DJNZ $ +REEX: + DI + LD A,11H ;SIO0 KANAL B AUF + OUT (S0BC),A ;STANDARDINITIALISIERUNG + LD A,1CH ;DES 8-BIT-PROM + OUT (S0BC),A + LD HL,SAVE ;ALTE ISR-WERTE SIO 0 KANAL B + LD DE,ITABS0 ;ZURUECKSPEICHERN + LD BC,32 + LDIR + + LD HL,SAVEPIO + LD DE,IP1KA ;ALTE WERTE PIO1 ISR-ADR SETZEN + LD BC,4 + LDIR + + LD A,3 + OUT (P0BC),A ;PIO-INT AUS + EI + RET ;EXIT ZU UDOS + +;;;;;;;;;;;;;;;;;;;;;;;;;; + +UEB16: + LD IX,RB_S0A + LD C,83H ;STATUS + STB + INT8000 + CALL UEBSIO + LD IX,RB_S0B + LD C,85H + CALL UEBSIO + LD IX,RB_S1A + LD C,87H + CALL UEBSIO + LD IX,RB_S1B + LD C,89H + +UEBSIO: DI + BIT 1,(IX+73H) ;WAR E_INT + RES 1,(IX+73H) + JR Z,OUTBUF ;NEIN + SET 6,C ;E_INT SETZEN + JR INT1 + +OUTBUF LD A,(IX+71H) + CP (IX+72H) ;POINTER GLEICH + JR Z,S_INT + CALL INCPOI ;NEIN + LD (IX+71H),A ;LESEPOINTER+1 UND SPEICHERN + LD A,(HL) ;ZEICHEN HOLEN + JR INT2 + +S_INT: + BIT 2,(IX+73H) ;WAR S_INT + RES 2,(IX+73H) + JR Z,T_INT + LD A,C + OR 60H ;S_INT SETZEN + LD C,A + LD A,(IX+75H) ;RR1 UEBERGEBEN + JR INT2 + +T_INT: + BIT 0,(IX+73H) ;WAR T_INT + RES 0,(IX+73H) + JR Z,P1KA ;NEIN + SET 5,C ;T_INT SETZEN +INT1: LD A,(IX+74H) ;RR0 UEBERGEBEN +INT2: DI + LD B,A ;DATEN RETTEN + OUT (P16A),A ;DATENBYTE + XOR A + OUT (P16B),A + LD A,C +INT3: OUT (P16B),A + +WAT16: EI + NOP + DI + IN A,(P0BD) + BIT 6,A ;WARTEN BIS DATEN PER INT8000 + JR Z,WAT16 ;ABGEHOLT WURDEN + LD A,(FLAG) ;WURDEN AUSGABEDATEN DURCH + OR A ;KINB UEBERSCHRIEBEN ? + JR NZ,NEUAUS ;JA: DATEN NEU ANLEGEN OHNE INT8000 +EXIT: EI + RET + +P1KA: LD HL,STAT2 ;WAR PIO1 KANAL A INTERRUPT ? + BIT 0,(HL) + JR Z,P1KB ;NEIN + RES 0,(HL) ;JA + LD A,0 + LD C,8BH ;STATUS 0AH or 81H + JR INT2 +P1KB: BIT 1,(HL) ;KANAL B INTERRUPT ? + JR Z,EXIT ;NEIN + RES 1,(HL) + LD A,0 + LD C,0ABH ;STATUS 2AH or 81H + JR INT2 + +NEUAUS: XOR A + LD (FLAG),A ;FLAG RUECKSETZEN + RES 0,C ;INT8000 AUSSCHALTEN + LD A,B + JR INT2 ;DATEN UND STATUS NEU ANLEGEN + +;;;;;;;;;;;;;;;;;;;;;;;;; + +LODNET: + CALL UEB16 + DI + LD IX,RECBUF + LD A,(IX+71H) + CP (IX+72H) ;POINTER GLEICH --> KEIN ZEICHEN + JR Z,ZERE ;ZERO-RETURN + CALL INCPOI ;LESEPOINTER + 1 + LD (IX+71H),A ;UND SPEICHERN + INC A ;NZ SETZEN + LD A,(HL) ;ZEICHEN HOLEN +ZERE EI + RET + +;;;;;;;;;;;;;;;;;;;;;;;;; +SNDNET: PUSH AF + CALL UEB16 + POP AF + LD C,91H ;STATUS + STB + INT8000 + JR INT2 + +;;;;;;;;;;;;;;;;;;;;;;;;; +SNDACK: LD A,ACK + LD C,91H + JR INT2 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +SNDDAT: LD C,90H ;STATUS OHNE INT. + JR INT2 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +LODDAT: + IN A,(P0BD) + BIT 5,A ;DATEN DA? + RET Z ;NEIN ZERO RETURN + IN A,(P0AD) ;JA --> NZ-RETURN + RET ;IN REG. A DATENBYTE + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +OUTP16: ;AUSGABE AN 16-BIT PORT + ;ZEICHEN IN A + ;STATUS IN REG. C + ;OHNE INTERRUPT + + LD HL,0FFFFH ;MAX. ZEIT + LD B,A +WTKP IN A,(P0BD) ;PORT FREI? + BIT 6,A + JR Z,DETI ;NEIN + LD A,B ;JA + OUT (P16A),A ;DATENBYTE-AUSGABE + XOR A + OUT (P16B),A + LD A,C ;STATUS UND + OR 80H ;STB-FLANKE OHNE INTERRUPT + OUT (P16B),A ;BEACHTE IM DI + RET ;OKAY --> NZ-RETURN + +DETI DEC HL + LD A,H + OR L + JR NZ,WTKP + RET ;FEHLER --> Z-RETURN + +;;;;;;; + +WAITACK: ;WARTEN AUF ACK (FUER TEST - HARDWARE) + ;ACK-CODE IN REG. C + LD HL,0FFFFH ;MAX. WARTEZEIT +WTL IN A,(P0BD) + BIT 5,A + JR Z,NXTIT ;KEIN ZEICHEN + AND 1FH ;STATUS FILTERN + CP C ;ACK VOM U8000 + RET Z ;OKAY --> ZERO-RET +NZRET OR 0FFH + RET ;SONST --> NZ-RET +NXTIT DEC HL + LD A,H + OR L + JR NZ,WTL + JR NZRET + +;;;;;;;;;;;;;;;;;;;;;;;;; + +ISRPIO: PUSH AF + PUSH BC + PUSH DE + PUSH HL + PUSH IX + IN A,(P0BD) ;STATUS + BIT 5,A ;DATEN DA + JR Z,ISREND ;NEIN --> FEHLER + + AND 16H ;STATUS HERAUSFILTERN + BIT 4,A + JR NZ,REQUEST ;REQUESTANFORDERUNG + +RWQ LD B,A + IN A,(P0AD) ;PERIPHERIE-ADRESSE IN + LD C,A ;REG. C LADEN + LD A,B + CP 02H ;READ-STATUS ? + JR Z,READ ;JA + CP 04H ;WRITE-STATUS ? + JR NZ,ISREND ;NEIN --> INVALID STATUS + +WRITE: IN A,(P0BD) + BIT 5,A ;DATEN DA ? + JR Z,WRITE ;NEIN --> WARTEN + LD B,A + IN A,(P0AD) ;DATENBYTE + OUT (C),A ;AUSGABE AN PERIPHERIE-ADR. + LD A,B + AND 16H + JR Z,ISREND ;ENDESTATUS + CP 04H ;WRITE-STATUS + JR Z,WRITE ;NAECHSTE DATENBYTE IST WIEDER FUER WRITE + ;BEI JEDEM ANDEREN STATUS WIRD +WADA: IN A,(P0BD) ;AUF DATEN GEWARTET + BIT 5,A + JR Z,WADA + AND 16H ;STATUS FILTERN + JR RWQ ;READ ODER WRITE-REQUEST + +READ: IN A,(C) ;EINGABE VON PERIPHERIE-ADR. + LD B,A + IN A,(P0BD) ;PORT-AUSGABE FREI ? + BIT 6,A + JR NZ,RQEND ;JA KEIN FLAG SETZEN + LD A,0FFH + LD (FLAG),A ;FLAG SETZEN, D.H. WERT WURDE UEBERSCHRIEBEN +RQEND: LD A,B + OUT (P16A),A ;DATENUEBERGABE + XOR A + OUT (P16B),A ;MIT STATUS 0 + OR 80H + OUT (P16B),A ;STB-FLANKE OHNE INTERRUPT + +WABH IN A,(P0BD) + BIT 6,A ;WARTEN BIS WERT ABGEHOLT WURDE + JR Z,WABH + +ISREND: POP IX + POP HL + POP DE + POP BC + POP AF + EI + RETI + +;------- + +REQUEST: + LD HL,STATUS + CP 16H ;QUIT-STATUS + JR Z,RQT + CP 10H ;REMOTE-STATUS + JR Z,RRT + IN A,(P0AD) + JR ISREND + +;QUIT-REQUEST + +RQT: IN A,(P0AD) + CP 'R' + JR NZ,RQT1 + SET 7,(HL) +RQT1: CP 'Q' + JR NZ,ISREND + SET 0,(HL) + JR ISREND + +;REMOTE-STATUS + +RRT: LD A,(RSTART) + OR A + JR NZ,RRTD + LD A,0FFH + LD (RSTART),A + IN A,(P0AD) + CP 'S' + JR NZ,LST + SET 1,(HL) ;SEND + JR REMST +LST CP 'L' + JR NZ,PST + SET 2,(HL) ;LOAD + JR REMST +PST CP 'P' + JR NZ,BRD + SET 3,(HL) ;PROM-PROGRAMMER + JR REMST +BRD INC HL ;BLOCK-REQUEST + CP 'R' + JR NZ,BWT + SET 0,(HL) ;READ + CALL RBLOCK + JR REMST +BWT CP 'W' + JR NZ,BFO + SET 1,(HL) ;WRITE + CALL WBLOCK + JR REMST +BFO: CP 'F' + JR NZ,BVY + SET 2,(HL) ;FORMAT + JR REMST +BVY: CP 'V' + JR NZ,BCP + SET 3,(HL) ;VERIFY + JR REMST +BCP: CP 'C' + JR NZ,NOREMST + SET 4,(HL) ;COPY DISK + JR REMST +NOREMST: + XOR A + LD (RSTART),A +REMST: JP ISREND + +;REMOTE-DATEN + +RRTD: LD IX,RECBUF + LD A,(IX+72H) + CALL INCPOI ;NEUEN POINTERWERT BERECHNEN + LD (IX+72H),A ;UND SPEICHERN + IN A,(P0AD) + LD (HL),A ;HL ZEIGT AUF PLATZ ZUM EINSCHREIBEN + JP ISREND + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; PIO1 INTERRUPTS (EPROM-PROGR.) +; +ISP1KA: + PUSH HL ;KANAL A INT + LD HL,STAT2 + SET 0,(HL) + POP HL + EI + RETI + +ISP1KB: + PUSH HL ;KANAL B INT + LD HL,STAT2 + SET 1,(HL) + POP HL + EI + RETI + +;;;;;;;;;;;;;;;;;;;;;;;;; + +; SIO RECEIVE - INTERRUPTS +; ABLEGEN DER WERTE IN ENTSPR. RINGPUFFER + + +S0AR: PUSH BC ;SIO 0 KANAL A RECEIVE-INT. + PUSH IX + LD C,S0AC ;DATEN-ADR + LD IX,RB_S0A ;RINGPUFFER + JR RINT + +S0BR: PUSH BC ;SIO 0 KANAL B RECEIVE-INT. + PUSH IX + LD C,S0BC ;DATEN-ADR. + LD IX,RB_S0B ;RINGPUFFER + JR RINT + +S1AR: PUSH BC ;SIO 1 KANAL A RECEIVE-INT. + PUSH IX + LD C,S1AC ;DATEN-ADR. + LD IX,RB_S1A ;RINGPUFFER + JR RINT + +S1BR: PUSH BC ;SIO 1 KANAL B RECEIVE-INT. + PUSH IX + LD C,S1BC ;DATEN-ADR. + LD IX,RB_S1B ;RINGPUFFER + +RINT: PUSH AF ;GEMEINSAMER TEIL FUER ALLE + PUSH HL ;RECEIVE-INTERRUPTS + PUSH DE +RINT1: DEC C + IN B,(C) ;WERT EINLESEN + LD A,(IX+72H) ;SCHREIBPOINTER + CALL INCPOI ;NEUEN WERT BERECHNEN + LD (IX+72H),A ;UND SPEICHERN + LD (HL),B ;DATENBYTE IN RINGPUFFER + INC C ;SIO CONTROL-ADR. + IN A,(C) ;EINGABE RR0 + BIT 0,A ;NOCH ZEICHEN DA + JR NZ,RINT1 ;JA + POP DE + POP HL + POP AF + POP IX + POP BC + EI + RETI + +INCPOI: + LD D,0 + LD E,A + PUSH IX + POP HL ;HL AUF WERT VON IX + INC A + CP 70H + JR NZ,INCP + XOR A +INCP ADD HL,DE + RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;RESTLICHE SIO-INTERRUPTS: T_INT, E_INT, S_INT FUER ALLE KANAELE: +; +S0BT: PUSH BC + PUSH IX + LD C,S0BC ;SIO CONTROL-ADR. + LD IX,RB_S0B + JR TINT + +S0AT: PUSH BC + PUSH IX + LD C,S0AC + LD IX,RB_S0A + JR TINT + +S1BT: PUSH BC + PUSH IX + LD C,S1BC + LD IX,RB_S1B + JR TINT + +S1AT: PUSH BC + PUSH IX + LD C,S1AC + LD IX,RB_S1A +TINT: PUSH AF + LD A,28H ;RESET T_INT + OUT (C),A + IN A,(C) ;EINGABE RR0 + LD (IX+74H),A ;SPEICHERN + SET 0,(IX+73H) ;SET T_INT BIT + JR SIOINT + +S0BE: PUSH BC + PUSH IX + LD C,S0BC + LD IX,RB_S0B + JR EINT + +S0AE: PUSH BC + PUSH IX + LD C,S0AC + LD IX,RB_S0A + JR EINT + +S1BE: PUSH BC + PUSH IX + LD C,S1BC + LD IX,RB_S1B + JR EINT + +S1AE: PUSH BC + PUSH IX + LD C,S1AC + LD IX,RB_S1A +EINT: PUSH AF + IN A,(C) ;EINGABE RR0 + LD (IX+74H),A ;SPEICHERN + LD A,10H + OUT (C),A ;RESET E_INT + SET 1,(IX+73H) ;SET E_INT BIT + JR SIOINT + +S0BS: PUSH BC + PUSH IX + LD C,S0BC + LD IX,RB_S0B + JR SINT + +S0AS: PUSH BC + PUSH IX + LD C,S0AC + LD IX,RB_S0A + JR SINT + +S1BS: PUSH BC + PUSH IX + LD C,S1BC + LD IX,RB_S1B + JR SINT + +S1AS: PUSH BC + PUSH IX + LD C,S1AC + LD IX,RB_S1A +SINT: PUSH AF + LD A,1 + OUT (C),A + IN A,(C) ;EINGABE RR1 + LD (IX+75H),A ;SPEICHERN + LD A,30H + OUT (C),A ;RESET S_INT + SET 2,(IX+73H) ;SET S_INT BIT + +SIOINT: POP AF + POP IX + POP BC + EI + RETI + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;TEXTE: + +MERR DEFB 23 + DEFM 'U8000-Unit does not work' + DEFB 0DH + +MTERR DEFB 29 ;LAENGE + DEFM 'Hardware Error in Connection' + DEFB 0DH + +BASP DEFB 1 + DEFB 08H + +MMLDG DEFB 22 + DEFM 'U8000-Softwaremonitor' + DEFB 0DH + +KBC0R DEFB 0CFH + DEFB 7FH + DEFB 0B7H + DEFB 0FEH + +;INT-TABELLEN-EINTRAEGE + +SNEUTAB DEFW S0BT + DEFW S0BE + DEFW S0BR + DEFW S0BS + + DEFW S0AT + DEFW S0AE + DEFW S0AR + DEFW S0AS + + DEFW S1BT + DEFW S1BE + DEFW S1BR + DEFW S1BS + + DEFW S1AT + DEFW S1AE + DEFW S1AR + DEFW S1AS + +;BUFFER UND VARIABLEN + +SAVE DEFS 32 +SAVEPIO DEFS 4 + +;RINGPUFFER FUER ALLE SIO-INTERRUPTS + +BUFFER: +RB_S0A DEFS 70H + DEFS 3 ;BUFLEN / BUFPOI / RECPOI + DEFS 1 ;FLAG FUER TES_INT'S + DEFS 2 ;RR0 / RR1 SPEICHER +RB_S0B DEFS 76H +RB_S1A DEFS 76H +RB_S1B DEFS 76H + +FLAG DEFS 1 ;FUER KINB BEIM UEBERSCHREIBEN + +;RINGPUFFER FUER UD + +RECBUF DEFS 073H + +STATUS DEFS 2 +STAT2 DEFS 1 +ERROR DEFS 1 +RSTART DEFS 1 +BUFEND: DEFS 0 + + +;;;;;;;;;;;;;;;;;;;; +;KONSTANTEN: + +ACK: EQU 06H + +P16A EQU 10H ;AUSGABEPORT 1 (DATEN) AN U8000 +P16B EQU 14H ;AUSGABEPORT 2 (RDY/STATUS/INT8000) + +PIO0 EQU 0CH +P0AD EQU PIO0 +P0AC EQU PIO0+1 +P0BD EQU PIO0+2 +P0BC EQU PIO0+3 + +S0AD EQU 24H +S0AC EQU S0AD+1 +S0BD EQU S0AD+2 +S0BC EQU S0AD+3 +S1AD EQU 28H +S1AC EQU S1AD+1 +S1BD EQU S1AD+2 +S1BC EQU S1AD+3 + +;AUS PROM SATZ: + +DSEL EQU 0EDDH +OUTAS EQU 0BF1H ;AUSGABE ZEICHENKETTE + +IP0KB: EQU 0F12H +IP1KA: EQU 0F14H +IP1KB: EQU 0F16H +ITABS0 EQU 0F20H +IS1B1 EQU 0F20H diff --git a/UDOS/WEGA/K.P8000.S b/UDOS/WEGA/K.P8000.S new file mode 100644 index 0000000..5ca0926 --- /dev/null +++ b/UDOS/WEGA/K.P8000.S @@ -0,0 +1,946 @@ +;****************************************************************************** +;****************************************************************************** +; +; U D O S - Quelle (C) ZFT/KEAW Abt. Baisisoftware - 1987 +; +; burn Modul: K.P8000.S +; +; +; Bearbeiter: P. Hoge +; Change: R. Kuehle +; +; Datum: 27.03.1988 +; Version: 1.1 +; +;****************************************************************************** +;****************************************************************************** + + +;P8000 EPROM-Programmer (alter und neuer Programmer) + + EXTERNAL WAIT ;label + EXTERNAL LODNET ;procedure + EXTERNAL SNDNET ;procedure + EXTERNAL prom ;procedure + EXTERNAL errflg ;byte + EXTERNAL UEB16 ;procedure + EXTERNAL Vpp ;byte programmierspannung + EXTERNAL PM ;byte program mode + EXTERNAL BUF ;array [%4000 byte] + + GLOBAL PROM ;procedure(entry burn - prom programmer wega) + GLOBAL intppb ;procedure(req byte, type byte) + GLOBAL rbyte ;procedure(promadr word) + ;returns(data byte) + GLOBAL wbyte ;procedure(promadr word,data byte) + GLOBAL p2708 ;procedure(nbytes word) + GLOBAL bcoff ;procedure + GLOBAL schar ;procedure(byte) + GLOBAL lchar ;procedure returns(byte) + GLOBAL ueb16 ;procedure + GLOBAL sdlc ;procedure + GLOBAL old ;byte prom programmer board + + +;INTERNAL + +l2val: defb -1 ;Steuerbits von Latch 2 +l3prog: defb -1 ;latch 3 beim Programmieren +l3chg: defb -1 ;latch 3 Umschalten Prog auf Verify +l3ver: defb -1 ;latch 3 bei Verify +old: defb -1 +nmax: defb 1 +time: defb 0 +count: defw 100 ;loop counter 2708 + +;CONSTANT + +ctc: equ 08h +pio1ad: equ 18h +pio1ac: equ 19h +pio1bd: equ 1ah +pio1bc: equ 1bh + + +;PROM - entry burn - prom programmer (wega) + +PROM: res 3,(hl) + call prom + jp WAIT + + +;intppb - Initialiesieren Programmer fuer +; req=0 Anfangsinitialisierung +; req=1 read +; req=2 write + +ireq equ 6 +ityp equ 4 + +intppb: push ix ;save callers ix + ld ix,0 + add ix,sp ;point to in parameters + ld a,(ix+ireq) ;get request type + and a + jr nz,rinit ;not initial request + + ld hl,isrctc ;isr adr ctc 0 kanal 3 + ld (0f04h),hl + ld b,inilen + ld hl,initab +iloop1: ld c,(hl) ;io address + inc hl + outi ;data byte + jr nz,iloop1 + in a,(pio1ad) ;alter Programmer = FF + ;neuer Programmer = 00 + ld (old),a + or a + ld b,ninilen ;Initialisierung neuer Programmer + jr z,iloop2 + ld b,oinilen ;Initialisierung alter Programmer +iloop2: ld c,(hl) ;io address + inc hl + outi ;data byte + jr nz,iloop2 + jp initret ;return to caller + +;Anfangsinitialisierung Programmer + +initab: defb pio1ac ;port a input + defb 0cfh + defb pio1ac + defb 0ffh + defb pio1bc ;port b + defb 0 + defb pio1bd + defb 0fch ;daten + defb pio1bc ;port b bit mode + defb 0cfh + defb pio1bc + defb 40h ;bit 6 input +inilen: equ ($-initab)/2 + +itab1: + defb pio1bd + defb 0ffh + defb pio1ac ;port a output + defb 0fh +ninilen: equ ($-itab1)/2 + defb pio1bd + defb 11h + defb pio1bd + defb 9dh ;strobe latch 1; reset kurzschluss + defb pio1bd + defb 11h +oinilen: equ ($-itab1)/2 + +;Initialiesierung Read/Write fuer alten Programmer + +rinit: cp 1 ;initialize for read? + jr nz,winit ;no + + ld e,(ix+ityp) ;prom typ + call typ + jr nz,initret ;invalid prom typ + ld a,(old) + or a + jr z,ri1 ;neue Programmer-Karte + ld hl,ritab + jr rwinit + +ri1: call nrinit + jr initret + +winit: cp 2 ;initialize for write? + jr nz,initret ;no just return + + ld e,(ix+ityp) + call typ + jr nz,initret ;invalid prom typ + ld a,(old) + or a + jr nz,wi1 + call nwinit ;neuer Programmer + jr initret + +wi1: ld hl,witab +rwinit: ld e,(ix+ityp) + ld d,0 + add hl,de ;entry in table + add hl,de + add hl,de ;* 3 + ex de,hl + ld a,(de) ;latch 2 + ld (l2val),a ;control bits latch 2 + ld h,a + call latch2 ;latch 2 init + inc de + ld a,0ffh + call latch3 ;latch 3 inaktiv + ld a,(de) ;prg inaktiv + inc de + or 81h ;+5V eprom + out (pio1bd),a + call wait50 + and 7fh + out (pio1bd),a ;reset Kurzschluss + ld a,(de) ;latch 3 init + or 10h ;prog spannung aus + call latch3 + call wait1 + ld a,(de) ;prog spannung 1 ms spaeter anlegen + call latch3 ;latch 3 init + call nz,ks ;Kurzschluss + +initret: + pop ix ;restore callers ix + pop hl ;return address + pop de + pop de ;deallocate in parameters + jp (hl) + +ritab: defb 0ch ;2708 (typ 0) latch 2 + defb 00h ;prg bit 5 + defb 57h ;latch 3 + defb 0d8h ;2716 (typ 1) + defb 00h + defb 5eh + defs 5*3 ;(typ 2-6) + defb 0d0h ;2732 (typ 7) + defb 00h + defb 5fh + defb 0d0h ;2732A (typ 8) + defb 00h + defb 5fh + defb 80h ;2764 (typ 9) + defb 20h + defb 5fh + +witab: defb 0fch ;2708 latch 2 + defb 00h ;prg bit 5 + defb 07h ;latch 3 + defb 0d8h ;2716 + defb 00h + defb 8eh + defs 5*3 + defb 0d0h ;2732 + defb 20h + defb 8dh + defb 0d0h ;2732A + defb 20h + defb 2dh + defb 80h ;2764 + defb 20h + defb 2fh + + +;Kurzschluss EPROM + +ks: ld a,2 + ld (errflg),a + +;Grundzustand alter Programmer + +bcoff: ld a,(old) + or a + jr z,nbcoff ;neue Programmer-Karte + ld a,0ffh ;latch 3 inaktiv + call latch3 + call wait4 + ld a,11h ;+5V off + out (pio1bd),a + ret + +;Grundzustand neuer Programmer + +nbcoff: ld a,0ffh + out (pio1bd),a + ret + +;Initialiesierung Read/Write fuer neuen Programmer + +nrinit: ld hl,nritab + ld a,4 + jr nrwinit + +nwinit: ld hl,nwitab + ld a,7 +nrwinit: + ld e,(ix+ityp) + ld d,0 +nrw1: add hl,de ;entry in table + dec a + jr nz,nrw1 + ex de,hl + ld l,0 ;low adressen low + call nlch1 + ld a,(de) ;latch 2 + inc de + ld (l2val),a + ld h,a + call nlch2 + ld a,(de) + inc de + ld (l3prog),a + set 2,a ;Programierspannung abgeschaltet lassen + call nlch3 + ld a,(de) + inc de + bit 5,a + jr z,nrw4 ;read bei 5V + and 11100011B ;Vpp 25V, UB 6V + ld c,a + ld a,(PM) + or a + jr z, nrw2 ;intelligent Programmieren + set 7,c + res 5,c ;5V +nrw2: ld a,(Vpp) ;Programmierspannung einstellen + cp 1 + jr z,nrw3 ;25V + set 2,c + cp 2 + jr z,nrw3 ;21V + res 2,c ;sonst 12,5V + set 3,c + set 4,c + +nrw3: ld a,c +nrw4: call nlch4 + ld a,(de) + inc de + out (pio1bd),a ;latchs output enable + ld a,(de) + inc de + ld (l3chg),a + ld a,(de) + inc de + ld (l3ver),a + ld a,(PM) ;Programmier-Mode 0: intelligent + or a ; 1: normal + ld a,1 + jr nz,nrw5 + ld a,(de) +nrw5: ld (nmax),a + call wait200 + ld a,(l3prog) + call nlch3 ;Programmierspannung bei Write anlegen + in a,(pio1bd) + bit 6,a + call nz,nks ;Kurzschluss + ret ;ok + +nritab: defs 4 ;Typ 0 nicht vorhanden + defb 11111000B ;2716 (typ 1) latch 2 + defb 00101110B ;latch 3 + defb 10000000B ;latch 4 + defb 11101101B ;pio b + defs 5*4 ;(typ 2-6) + defb 11110000B ;2732 (typ 7) + defb 00111110B + defb 10000000B + defb 11101101B + defb 11110000B ;2732A (typ 8) + defb 00111110B + defb 10000100B + defb 11101101B + defb 11100000B ;2764 (typ 9) + defb 00011110B + defb 11000100B + defb 01101101B + defb 11100000B ;2764A (typ 10) + defb 00011110B + defb 11011000B + defb 01101101B + defb 11000000B ;27128 (typ 11) + defb 00011110B + defb 11000100B + defb 01101101B + defb 11000000B ;27128A (typ 12) + defb 00011110B + defb 11011000B + defb 01101101B + defb 10000000B ;27256 (typ 13) + defb 00011110B + defb 11011000B + defb 11101101B + defs 4 ;(typ 14) + defb 00000000B ;27512 (typ 15) + defb 00111110B + defb 11011000B + defb 11101101B + +nwitab: defs 7 ;Typ 0 nicht vorhanden + defb 11111000B ;2716, 25V Upp (typ 1) latch 2 + defb 11101011B ;latch 3 + defb 00100000B ;latch 4 + defb 11101111B ;pio + defb 10101011B ;latch 3 change + defb 10101011B ;latch 3 verify + defb 15 ;max. Anzahl der 1ms Prog. Impulse, 1 = 50ms + defs 5*7 ;(typ 2-6) + defb 11110000B ;2732, 25V Upp (typ 7) + defb 11110011B + defb 00100000B + defb 01101111B + defb 11111011B + defb 00111010B + defb 15 + defb 11110000B ;2732A, 21V Upp (typ 8) + defb 11110011B + defb 00100100B + defb 01101111B + defb 11111011B + defb 00111010B + defb 15 + defb 11100000B ;2764, 21V Upp (typ 9) + defb 01011011B + defb 01100100B + defb 01101111B + defb 00011011B + defb 00011011B + defb 15 + defb 11100000B ;2764A, 12,5V Upp (typ 10) + defb 01011011B + defb 01111000B + defb 01101111B + defb 00011011B + defb 00011011B + defb 25 + defb 11000000B ;27128, 21V Upp (typ 11) + defb 01011011B + defb 01100100B + defb 01101111B + defb 00011010B + defb 00011010B + defb 15 + defb 11000000B ;27128A, 12,5V Upp (typ 12) + defb 01011011B + defb 01111000B + defb 01101111B + defb 00011010B + defb 00011010B + defb 25 + defb 10000000B ;27256, 12,5V Upp (typ 13) + defb 11011010B + defb 01111000B + defb 01101111B + defb 10011010B + defb 10011010B + defb 25 + defs 7 ;(typ 14) + defb 00000000B ;27512, 12,5V Upp (typ 15) + defb 11110010B + defb 01111000B + defb 01101111B + defb 11111010B + defb 00111110B + defb 25 + + +;rbyte procedure - Read 1 Byte (alter Programmer) + +radr equ 4 +rdata equ 6 + +rbyte: push ix ;save callers ix + ld ix,0 + add ix,sp ;point to in parameters + ld l,(ix+radr) ;prom address + ld h,(ix+radr+1) + ld a,(old) + or a + jr z,rd2 ;neue Programmer-Karte + call latch1 ;output low address + call latch2 ;output high address + jr z,rd1 + call ks ;Kurzschluss + jr rdret +rd1: ld a,0cfh ;port a input + out (pio1ac),a + ld a,0ffh + out (pio1ac),a + in a,(pio1bd) + and 0f0h ;OE aktiv + out (pio1bd),a + ld c,pio1ad + in l,(c) ;read data byte from prom + ld (ix+rdata),l ;store in out parameters + or 01h ;oe inaktiv + out (pio1bd),a + ld a,0fh ;port a output + out (pio1ac),a + jr rdret + +rd2: call nrbyte +rdret: pop ix ;restore callers ix + pop hl ;return address + pop de ;deallocate in parameter + jp (hl) + + +;wbyte procedure - write 1 Byte (alter Programmer) + +wadr equ 6 +wdata equ 4 + +wbyte: push ix ;save callers ix + ld ix,0 + add ix,sp ;point to in parameters + ld l,(ix+wadr) ;prom address + ld h,(ix+wadr+1) + ld a,(old) + or a + jr z,wr2 ;neuer Programmer + call latch1 + call latch2 + jr z,wr1 + call ks ;Kurzschluss + jr wrret + +wr1: ld a,(ix+wdata) ;get data byte + cp 0ffh ;is data = FF ? + jr z,wrret + + out (pio1ad),a + in a,(pio1bd) + and 0f0h + or 02h ;OE aktiv, PRG inaktiv + out (pio1bd),a + ld b,50 ;50 ms + call prog + or 03h ;OE inaktiv + out (pio1bd),a + jr wrret + +wr2: call nwbyte +wrret: pop ix ;restore callers ix + pop hl ;return address + pop de ;deallocate in parameters + pop de + jp (hl) + + +;Programmierung 2708 (nur alter Programmer) + +nbyt equ 4 + +p2708: call wait50 + push ix ;save callers ix + ld ix,0 + add ix,sp ;point to in parameters + ld iy,count + ld (iy),100 ;loop thru prom 100 times + +p2708a: ld c,(ix+nbyt) + ld b,(ix+nbyt+1) + ld hl,0000h ;prom address + ld de,BUF ;buffer - external + +p2708b: push bc + call latch1 ;output low address + call latch2 ;output high address + pop bc + jr nz,pks + + ld a,(de) ;data byte + out (pio1ad),a + ld a,02h ;OE aktiv, PRG inaktiv + out (pio1bd),a + push hl + push bc + ld b,1 ;1ms + call prog + or 03h ;OE inaktiv + out (pio1bd),a + pop bc + pop hl + + inc hl ;inc prom address + inc de ;inc buffer address + dec bc ;dec byte count + ld a,b + or c + jr nz,p2708b ;next byte + dec (iy) + jr nz,p2708a ;next loop + +pret pop ix ;restore callers ix + pop hl ;return address + pop de ;deallocate parameter + jp (hl) ;return + +pks: call ks ;Kurzschluss + jr pret + +;Read 1 Byte (neuer Programmer) + +nrbyte: call nlch1 ;Anlegen der Adresse + call nlch2 + ld a,0cfh ;port a input + out (pio1ac),a + ld a,0ffh + out (pio1ac),a + call nz,nks ;Kurzschluss + in a,(pio1bd) + and 0feh ;OE bidirekt. Treiber aktiv + out (pio1bd),a + ld c,pio1ad + in l,(c) ;read data byte from prom + ld (ix+rdata),l ;store in out parameters + or 01h ;OE inaktiv + out (pio1bd),a + ld a,0fh ;port a output + out (pio1ac),a + ret + +;Write 1 Byte (neuer Programmer) + +nwbyte: call nlch1 + call nlch2 + call nz,nks ;Kurzschluss + ld a,(ix+wdata) ;get data byte + cp 0ffh ;is data = FF ? + ret z + + out (pio1ad),a + ld d,a + ld a,(nmax) + cp 1 + jr nz,nwr1 ;intelligente Programmierung + +;unintelligente Programmierung + + in a,(pio1bd) + and 0feh ;OE bidirekt. Treiber aktiv, PRG inaktiv + out (pio1bd),a + ld b,50 ;50ms + call nprog + or 01h ;OE inaktiv + out (pio1bd),a + ret + +;intelligente Programmierung + +nwr1: ld e,0 +nwr2: in a,(pio1bd) + and 0feh ;OE bidirekt. Treiber aktiv, PRG inaktiv + out (pio1bd),a + ld b,1 ;1ms + call nprog + or 01h ;OE inaktiv + out (pio1bd),a + + ld a,(l3chg) + ld hl,l3ver + cp (hl) + jr z,t1 + call nlch3 +t1: ld a,(l3ver) ;Byte verify + call nlch3 ;verify einstellen + call nz,nks ;Kurzschluss + ld a,0cfh ;port a input + out (pio1ac),a + ld a,0ffh + out (pio1ac),a + in a,(pio1bd) + and 0fdh ;Richtung lesen, OE bid. Treiber aktiv + out (pio1bd),a + and 0fch + out (pio1bd),a + ld c,pio1ad + in l,(c) ;read data byte from prom + or 01h ;Richtung schreiben, OE inaktiv + out (pio1bd),a + or 03h + out (pio1bd),a + ld a,0fh ;port a output + out (pio1ac),a + push hl + ld a,(l3chg) + ld hl,l3ver + cp (hl) + jr z,t2 + call nlch3 +t2: pop hl + ld a,(l3prog) ;wieder auf Programmieren einstellen + call nlch3 + ld a,d + out (pio1ad),a ;Daten wieder anlegen + call nz,nks ;Kurzschluss + + inc e + ld a,l ;rueckgelesenes Byte vergleichen + cp d + jr z,nwr3 ;Ueberprogrammieren + ld a,(nmax) ;max Anzahl Impulse erreicht ? + dec a + cp e + jr nc,nwr2 ;naechster Prog. impuls + ld a,3 + ld (errflg),a + ret ;Fehler + +nwr3: ld b,4 ;4n Ueberprogrammieren + ld a,(nmax) + cp 16 + jr c,nwr4 + ld b,3 ;3n Ueberprogrammieren +nwr4: xor a +nwr5: add a,e + djnz nwr5 + ld b,a + in a,(pio1bd) + and 0feh ;OE bidirekt. Treiber aktiv, PRG inaktiv + out (pio1bd),a + call nprog ;in b Anzahl der ms + or 01h ;OE inaktiv + out (pio1bd),a + ret + +;Kurzschluss neue Programmer-Karte + +nks: call ks ;Kurzschluss + pop hl ;Ausgleich fuer call nks + ret + + +;Ueberpruefung EPROM-Typ alte Programmer-Karte + +typ: ld a,(old) + or a + ld a,e ;prom typ + jr z,ntyp + cp 0 ;2708 ? + ret z + cp 1 ;2716 ? + ret z + cp 7 ;2732, 32A, 64 ? + jr c,typerr + cp 10 + jr nc,typerr + xor a ;ok + ret + +;Ueberpruefung EPROM-Typ neue Programmer-Karte + +ntyp: cp 1 ;2716 + ret z + cp 7 ;2732, 32A, 64, 64, 128, 128, 256, 512 ? + jr c,typerr + cp 14 + jr z,typerr + cp 16 + jr nc,typerr + xor a ;ok + ret + +typerr: xor a + inc a + ld (errflg),a + ret + +;Output to latch's (alte Programmer-Karte) + +latch1: ld c,0dh ;l = low address + ld a,l + jr l0 + +latch2: ld a,(l2val) ;control bits PRG + or h ;high address + ld c,09h + jr l0 + +latch3: ld c,05h ;l = control bits +l0: out (pio1ad),a + in a,(pio1bd) + and 0f0h + or c + out (pio1bd),a ;strobe + and 0f0h + or 01h + out (pio1bd),a + bit 6,a ;Kurzschluss ? + ret + +;Output to latch's (neue Programmer-Karte) + +L1STROBE: equ 00h +L2STROBE: equ 04h +L3STROBE: equ 08h +L4STROBE: equ 0ch +LNOSTROBE: equ 20h +LMASK: equ 0d3h + +nlch1: + ld a,l ;l = low address + ld c,L1STROBE + jr nl0 + +nlch2: + ld a,(l2val) ;control bits + or h ;high address + ld c,L2STROBE + jr nl0 + +nlch3: + ld c,L3STROBE + jr nl0 + +nlch4: + ld c,L4STROBE +nl0: out (pio1ad),a + in a,(pio1bd) + and LMASK + or c + out (pio1bd),a ;strobe + or LNOSTROBE + out (pio1bd),a + bit 6,a ;Kurzschluss ? + ret + + +;wait routines + +wait200: + ld b,200 + jr wait + +wait50: + ld b,50 + jr wait + +wait4: ld b,4 + jr wait + +wait1: ld b,1 +wait: ld c,0 + jr w1 + +prog: + ld c,20h ;prog bit alter Programmer + jr w1 + +nprog: + ld c,80h ;prog bit neuer Programmer +w1: push af + ld a,b + ld (time),a + ld a,0a5h + out (ctc+2),a + ld a,15 + out (ctc+2),a + in a,(pio1bd) + xor c ;Prog. impuls ein, wenn progbit gesetzt + out (pio1bd),a + xor c + push af +wloop: call ueb16 + ld a,(time) + or a + jr nz,wloop + pop af + out (pio1bd),a ;Prog. impuls aus, falls vorher ein + pop af + ret + +isrctc: push af + ld a,(time) + dec a + ld (time),a + jr nz,isrc1 + ld a,03h ;ctc aus + out (ctc+2),a +isrc1: pop af + ei + reti + + +; lchar - procedure +; lesen von "dev/ud" (16-bit/8-bit p8000) + +zchar equ 4 + +lchar: push ix + ld ix,0 + add ix,sp + + push ix +kzei: + call LODNET + jr z,kzei + + pop ix + ld (ix+zchar),a + pop ix + pop hl + jp (hl) + + +; schar - procedure +; schreiben nach "dev/ud" (8-bit/16-bit p8000) + +schar: push ix + ld ix,0 + add ix,sp + ld a,(ix+zchar) + + call SNDNET + pop ix + pop hl + pop de + jp (hl) + +ueb16: push ix + call UEB16 + pop ix + ret + + +; BERECHNUNG DES CRC VOM PROM NACH DEM SDLC POLYNOM + + GLOBAL sdlc + +sdlc: push ix ; plz ix retten + ld ix,0 ; parameter uebernahme + add ix,sp + ld a,(ix+8) ;char + ld d,(ix+6) ;crc + ld e,(ix+4) + xor d + ld d,a + rrca + rrca + rrca + rrca + and 0fh + xor d + ld d,a + rrca + rrca + rrca + push af + and 1fh + xor e + ld e,a + pop af + push af + rrca + and 0f0h + xor e + ld e,a + pop af + and 0e0h + xor d + ld d,e + ld e,a + + ld (ix+12),e ; out parameter uebergeben + ld (ix+10),d + pop ix ; restore plz ix + pop hl ; ret adr + pop de ; dealocate inparameter + pop de + pop de + jp (hl) ; ret to plz diff --git a/UDOS/WEGA/K.PROM.S b/UDOS/WEGA/K.PROM.S new file mode 100644 index 0000000..f28c588 --- /dev/null +++ b/UDOS/WEGA/K.PROM.S @@ -0,0 +1,275 @@ +!****************************************************************************** +******************************************************************************* + + U D O S - Quelle (C) ZFT/KEAW Abt. Basissoftware - 1989 + + pburn Modul: K.PROM.S + + + Bearbeiter: P. Hoge, R. Kuehle + + Datum: 18.4.1989 + Version: 2.1 + +******************************************************************************* +******************************************************************************! + + +PROM module + +constant + rd := 1 + wt := 2 + false := 0 + +external + intppb procedure (byte byte) + bcoff procedure !turns off programmer! + rbyte procedure (word) returns (byte) + wbyte procedure (word byte) + p2708 procedure (word) + + lchar procedure returns (byte) + schar procedure (byte) + ueb16 procedure + sdlc procedure (byte byte byte) returns (byte byte) + BUF array [%4000 byte] + old byte !0 - board 2 + ungleich 0 - board 1! + +global + + errflg byte + Vpp byte !programmierspannung 1 - 25 V + 2 - 21 V + 3 - 12.5 V + 4 - free V! + PM byte !program mode 0 - high speed + 1 - normal speed! + +internal + ptype byte + begadr word + nbytes word + promadr word + char, read_write byte + k byte + i, len word + d, e byte + + +internal + +readprom procedure + entry + intppb(rd ptype) + if errflg<>false then return fi + i := 0 + do + ueb16 + BUF[i] := rbyte(promadr) + if errflg<>false then exit fi + len := len-1 + if len=0 then exit fi + promadr := promadr+1 + i := i+1 + od + bcoff +end readprom + +writeprom procedure + entry + intppb(wt ptype) + if errflg<>false then return fi + promadr:=begadr + len:=nbytes + if ptype=0 then p2708(nbytes) + else + i := 0 + do + wbyte(promadr,BUF[i]) + + if errflg=3 then schar (3) + char:=lchar + if char='n' then exit + else errflg:=0 + fi + fi + if errflg<>false then exit fi + len := len-1 + if len=0 then exit fi + promadr := promadr+1 + i := i+1 + od + fi + bcoff +end writeprom + + +! anpassung schnittstelle 16-bit/8-bit p8000 fuer burn (wega) + *********************************************************** ! + +global +prom procedure + entry + errflg:=false + + ! read, write, erase, crc ! + read_write:=lchar + + ! type prom ! + ptype:=lchar + + ! beginn adresse prom ! + char:=lchar + begadr:=word char !high! + begadr:=begadr * 256 + char:=lchar + begadr:=begadr or word char !low! + promadr:=begadr + + ! laenge prom ! + char:=lchar + nbytes:=word char !high! + nbytes:=nbytes * 256 + char:=lchar + nbytes:=nbytes or word char !low! + len:=nbytes + + !programmierspannung Vpp! + Vpp:=lchar + + !program mode! + PM:=lchar + + schar('q') !acknowledge! + + ! initialisierung EPROM-Programmer Board Abfrage ! + if read_write=5 then intppb (0 0) fi + + i:=0 + + ! write prom + ********* ! + + if read_write=2 then + do + k:=64 + do + BUF[i]:=lchar + i:=i+1 + k:=k-1 + len:=len-1 + if len=0 then exit fi + if k=0 then exit fi + od + schar('q') + if len=0 then exit fi + od + writeprom + if errflg<>3 then schar (errflg) fi + + ! ruecklesen prom; feststellen programmierfehler; + uebergabe an wega bei Standard Speed Program Mode ! + + if errflg=false then if PM=1 then + promadr:=begadr + len:=nbytes + i:=0 + intppb(rd ptype) + do + ueb16 + char:=rbyte(promadr) + if errflg<>false then exit fi + if char<>BUF[i] then errflg:=3 exit fi + len := len-1 + if len=0 then exit fi + promadr:=promadr+1 + i:=i+1 + od + bcoff + schar(errflg) + fi + fi + fi + + ! read prom + ********* ! + + if read_write=1 then + readprom + schar(errflg) + if errflg=false then + i := 0 + len:=nbytes + do + k:=64 + do + schar(BUF[i]) + i:=i+1 + k:=k-1 + len:=len-1 + if len=0 then exit fi + if k=0 then exit fi + od + char:=lchar + if len=0 then exit fi + od + fi + fi + + ! erase prom + ********** ! + + if read_write=3 then + intppb(rd ptype) + do + ueb16 + char:=rbyte(promadr) + if errflg<>false then exit fi + if char<>%FF then errflg:=3 exit fi + len:=len-1 + if len=0 then exit fi + promadr:=promadr+1 + od + bcoff + schar(errflg) + fi + + ! crc prom + ******** ! + if read_write=4 then + d:=%ff + e:=%ff + k:=0 + intppb(rd ptype) + do + ueb16 + char:=rbyte(promadr) + if errflg<>false then k:=errflg exit fi + if char<>%FF then k:=3 fi + d,e:=sdlc(char,d,e) + len:=len-1 + if len=0 then exit fi + promadr:=promadr+1 + od + bcoff + schar(k) + if errflg=false then + schar(d) + schar(e) + fi + fi + + !prom programmer board + *********************! + + if read_write=5 then + if old=0 then schar('2') + else schar('1') + fi + fi + +end prom + +end PROM diff --git a/UDOS/WEGA/koppeldoc b/UDOS/WEGA/koppeldoc new file mode 100644 index 0000000..90c086e --- /dev/null +++ b/UDOS/WEGA/koppeldoc @@ -0,0 +1,351 @@ +******************************************************************************* +******************************************************************************* + + P8000 - Softwaredokumentation (C) ZFT/KEAW Abt. Basissoftware - 1989 + Koppelsoftware (8-Bit-Teil) + + Bearbeiter: U. Oefler / P. Hoge / R. Kuehle + Datum: 31.1.89 + Version: 3.1 + +******************************************************************************* +******************************************************************************* + +1. Grundlagen +============= + +1.1. Hardware +------------- + +Zur Kopplung der beiden Rechnerkarten des P8000 dienen zwei 16-Bit-Ports. +Auf der 16-Bit-Seite werden diese durch zwei PIO's realisiert. Auf der +8-Bit-Seite dienen dazu ein PIO (PIO-0) und zwei Ausgabeports (jeweils +8-Bit breit, P16A und P16B). Die Verbindung zwischen beiden Teilen ist +im Band: "Einfuehrung in die Software des P8000" (Bild A.1) ausfuehrlich +dargestellt. +Zum Verstaendnis der nachfolgend beschriebenen Programmteile der Koppel- +software (8-Bit-Teil) ist die Belegung auf der 8-Bit-Seite wichtig. + +PIO0 Port-A 8-Bit Dateneingabe vom 16-Bit-Teil + Daten: 0CH + Control: 0DH + + Port-B Bit 7 Reset-U8000 (1=steht, 0=laeuft) + Daten: 0EH Bit 6 Enable-Output (1=frei, 0=gesperrt) + Control: 0FH Bit 5 Daten-Da (1=ja, 0=nein) + Bit 4-1 Status (4 Bit) vom 16-Bit-Teil + Bit 0 Interrupt-Bit + +Ausgabeport-A 8-Bit Daten an 16-Bit-Teil +(P16A, Adr.: 10H) + +Ausgabeport-B Bit 7 STB fuer PIO auf 16-Bit-Seite +(P16B, Adr.: 14H) (Flanke 0->1 fuer Datenuebernahme!) + Bit 6-1 Status (6 Bit) an 16-Bit-Teil + Bit 0 INT-16 + (Flanke 0->1 erzeugt Int. auf 16-Bit-Seite) + + +1.2. Arbeitsweise +----------------- + +Die Koppelsoftware hat die Aufgabe die Peripherieschaltkreise des 8-Bit- +Teils (2 x SIO und 1 x PIO) dem 16-Bit-Teil zur Verfuegung zu stellen, +d.h. Ein- und Ausgaben vom 16-Bit-Teil aus zu ermoeglichen. +Weiterhin beiinhaltet die Koppelsoftware Programmteile zur Ausfuehrung +von Requests, die vom 16-Bit-Teil angefordert werden (z.B.: Lesen und +Schreiben von UDOS-Dateien und Diskettensektoren, Formatieren von Disketten). +Auf der 16-Bit-Seite arbeiten sowohl der U8000-Softwaremonitor als der +WEGA-Kern mit der Koppelsoftware zusammen. + +Ueber die zwei SIO's des 8-Bit-Teils sind 4 V.24-Kanaele des P8000 +durch die Koppelsoftware mit dem 16-Bit-Teil verbunden. + +Organisation der Ankopplung: + +Fuer jeden SIO-Kanal (4 Stueck) wird auf der 8-Bit-Seite ein Ringpuffer +organisiert, der die einlaufenden Daten aufnimmt, ein Flag-Byte, in dem +das Auftreten von T_INT's, E_INT's oder S_INT's gemerkt wird, sowie 2 Byte +fuer das Retten der Werte der Leseregister 0 und 1. Diese Ringpuffer haben +die symbolischen Bezeichnungen + + RB_S0A (tty-0) + RB_S0B (Console) + RB_S1A (tty-2) + RB_S1B (tty-3) + +Die Interrupt-Service-Routine realisieren folgende Funktionen + + R_INT (Receive-Int.) SIO-Empfangspuffer leer lesen + Ablegen im Ringpuffer + T_INT (Transmit-Int.) Reset T_INT, RR0 einlesen + E_INT (Ext.-Status-Int.) RR0 einlesen, Reset E_INT + S_INT (Special-Rec.- RR1 einlesen, Reset S_INT + Condition) + +Innerhalb der Koppelsoftware testet das Programm UEB16 staendig, ob +Interrupts eingelaufen sind, wenn ja erfolgt Uebergabe an den 16-Bit- +Teil. Dabei erfolgt ueber die 6-Bit Status die Kennzeichnung der Art +des Interrupts und der Adresse der Quelle. + +Ausgaben an die Peripherieschaltkreise werden von der ISR-Koppelpio direkt +an die entsprechende Adresse durchgereicht. + +Das Interruptsystem fuer den PIO1 (Anschluss des EPROM-Programmers) +ist ab der Version 3.1. in der Koppelsoftware integriert. + + +1.3. Statusfestlegungen +----------------------- + +Der 8-Bit-Teil uebergibt Informationen an den 16-Bit-Teil, indem er +den 16-Bit-Teil ueber INT-16 unterbricht. Dabei sind in den 6-Bit +Status folgende Kennzeichnungen verschluesselt: + + 00H Ende-Status + + 02H SIO-0 Kanal-A R_INT + 22H T_INT + 42H E_INT + 62H S_INT + + 04H SIO-0 Kanal-B R_INT + 24H (console) T_INT + 44H E_INT + 64H S_INT + + 06H SIO-1 Kanal-A R_INT + 26H T_INT + 46H E_INT + 66H S_INT + + 08H SIO-1 Kanal-B R_INT + 28H T_INT + 48H E_INT + 68H S_INT + + 0AH PIO1-Port A INTERRUPT + 2AH PIO1-Port B INTERRUPT + + 10H Daten (UDOS-Dateien) + + +Der 16-Bit-Teil uebergibt Informationen an den 8-Bit-Teil, indem er +den 8-Bit-Teil ueber INT-8 (Bit0 PIO0-PortB) unterbricht. Dabei sind +in den 4 Bit Status sind folgende Anforderungen verschluesselt: + +(a) Hardware-E/A: + + 00H Ende-Status + + 02H READ von Peripherie + 04H WRITE an Peripherie + Erlaeuterung: + am Datenport liegt die Peripherieadresse an, + bei WRITE folgen am Datenport die auszugebenden + Datenbytes (beim letzten Datenbyte Status 0H) + +(b) Request: + + 10H Request-Status + Erlaeuterung: + beim ersten Interrupt mit Status 10H entscheidet + das am Datenport anliegende Zeichen + ueber die Art des Requests + 'L' (LOAD: Empfangen UDOS-Datei) + 'S' (SEND: Senden UDOS-Datei) + 'P' (PROM: EPROM-Programmierung) + 'R' (READ: Lesen Block-Floppy) + 'W' (WRITE: Schreiben Block-Floppy) + 'F' (FORMAT: Formatieren Block-Floppy (physisch)) + 'V' (VERIFY: Ueberpruefen Disk) + 'C' (COPYDISK: Kopieren von Disketten) + weitere Requests sind z.Z. nicht implementiert + die nachfolgenden Datenbytes mit Status 10H + werden bis zum Abschluss der Requestaktivitaet + in den 16-Bit-Empfangsringpuffer (RECBUF) + uebernommen + +(c) U8000-Monitorende: + + 16H Quit-Status + Erlaeuterung: + Uebergang vom 16-Bit-Monitor in 8-Bit-Monitor + oder UDOS (entsprechend Start) + das am Datenport anliegende Zeichen entscheidet + ob mit oder ohne Reset-U8000 + 'R' Reset-U8000 + 'Q' ohne Reset-U8000 + +Hardware E/A-Aktivitaeten werden in der ISR-Koppelpio sofort +ausgefuehrt. Bei Requestanforderungen wird in der ISR-Koppelpio +entsprechend des Requests ein Bit gesetzt. + +1.Status-Byte: Bit + 0 Monitor-QUIT (ohne Reset U8000) + 1 LOAD (Empfangen UDOS-Datei) + 2 SEND (Senden UDOS-Datei) + 3 PROM (EPROM-Programmierung) + 7 Monitor-QUIT (mit Reset U8000) + +2.Status-Byte: Bit + 0 READ (Block-Floppy) + 1 WRITE (Block-Floppy) + 2 FORMAT (Block-Floppy) + 3 VERIFY (Block-Floppy) + 4 COPYDISK (Block-Floppy) + +Innerhalb der Grundwarteschleife der Koppelsoftware (Marke WAIT) +wird neben dem Test auf eingelaufene Interrupts (CALL UEB16) auch +staendig in den zwei Status-Bytes nachgesehen, ob zu einem +Requestprogrammteil verzweigt werden muss. + + + +2. Module der Koppelsoftware +============================ + +2.1. Startprogramm WEGA +----------------------- + +Die Koppelsoftware besteht aus sechs Modulen: + + K.NEU.S Grundprogramm zur Koppelschnittstelle + (Initialisierung, Eigentest, Interruptsystem, + Grundwarteschleife) + K.BLK.S Programme zur Arbeit mit Floppy-Disk + (Read, Write und Format Block-Floppy-Formate) + K.ACT.S Programme zum Ein-/Auslagern von UDOS-Dateien + (Load/Send entsprechend Remote-Telegramm) + K.PROM.S PLZ/SYS-Programmodul zur EPROM-Programmierung + (Basismodul mit Anpassung an Koppelschnittstelle) + K.P8000.S Assemblerprogramm zur EPROM-Programmierung + (P8000-Programmer, und Schnittstelle /dev/ud) + K.BUF.S Puffervereinbarung + +Nach dem Compilieren von K.PROM.S (mit PLZ/SYS Vers. 3.0) und dem +Assemblieren der restlichen Module wird durch folgende Linkanweisung + + PLINK $=4000 K.NEU K.BLK K.ACT K.PROM K.P8000 PLZ.MATH K.BUF (N=WEGA) + +das Startprogramm WEGA erzeugt. Der Aufruf dieses Programms unter +UDOS bewirkt die Initialisierung und Aktivierung der Koppelschnitt- +stelle fuer WEGA und den Uebergang in den 16-Bit-Monitor. + + +2.2. Koppelsoftwareteile fuer U880-Monitor +------------------------------------------ + +Die in den U880-Softwaremonitor zu integrierenden Teile der Koppelsoftware +fuer die Ausfuehrung des Kommandos 'X' sind im Modul K.MON.S zusammengefasst. +Da bei dieser Arbeitsweise keine Floppy-Disk-Arbeit moeglich ist, +wird in diesem Fall im Anschluss an den Eigentest das Datenmuster 01H mit +Status 00H an den 16-Bit-Softwaremonitor uebergeben (beim Programm WEGA +wird das Datenmuster 02H uebergeben). Dadurch wird erreicht, dass sowohl +der U8000-Monitor als auch der WEGA-Kern beim Start ueber das Kommando 'X' +die Floppyarbeit sperrt und damit sich das System nicht verklemmen kann. + + +2.3. Beschreibung der Prozeduren +-------------------------------- + +Modul K.NEU.S: + +bis Zeile 218 Koppelschnittstelle Grundprogramm + (Initialisierung, Hardwaretest - in Zusammenarbeit + mit 16-Bit-Monitor, Fehlerausgaben, Grundwarteschleife + Programmteile zum QUIT-Status) + +UEB16 Tests ob Interrupts eingelaufen sind, wenn ja Uebergabe + der entsprechenden Daten an 16-Bit-Teil + +LODNET Eingabe 1 Zeichen aus 16-Bit-Empfangsringpuffer + +SNDNET Ausgabe 1 Zeichen an 16-Bit-Teil mit Status 10H + ueber Interrupt + +SNDACK Ausgabe ACK (06H) an 16-Bit-Teil mit Status 10H + ueber Interrupt + +SNDDAT Ausgabe 1 Zeichen an 16-Bit-Teil mit Status 10H + ueber Polling + +LODDAT Eingabe 1 Zeichen vom 16-Bit-Teil ueber Polling + +OUTP16 Ausgabe 1 Zeichen an 16-Bit-Teil ohne Interrupt + mit Zeitueberwachung + +WAITACK Warten auf 1 Zeichen vom 16-Bit-Teil und Test ob + ACK (06H) mit Zeitueberwachung + +ISRPIO Interrupt-Service-Routine Koppelpio: + Auswertung des Status und Realisierung der + entsprechenden Aktivitaet. E/A-Aktionen werden direkt + ausgefuehrt. Requestanforderungen bewirken das Setzen + des entsprechenden Statusbits. Daten mit Status 10H + (UD-Daten) werden im Ringpuffer abgelegt. Bei Block- + Floppy-Read bzw. -Write erfolgt auch die Uebernahme + der notwendigen Kopfinformationen ueber Polling + (Marken RBLOCK und WBLOCK (bei Write auch Uebernahme + des zu schreibenden Blocks)) + +SxxR Eintrittspunkte fuer SIO-Kanaele Receive-Interrupts +SxxT ... Transmit-Interrupts +SxxE ... External-Status-Interrupts +SxxS ... Special-Receive-Cond.-Interrupts + + +Modul K.BLK.S: + +DISK zeitgeteilter Floppy-Zugriff + +RBLOCK Uebernahme Kopfinformationen (von ISR-Koppelpio aus) + +BLKRD Eintrittspunkt fuer Block-Read + +WBLOCK Uebernahme Kopfinformationen und Blockdaten + (von ISR-Koppelpio aus) + +BLKWT Eintrittspunkt fuer Block-Write + +KOPF Uebernahme Kopfinformationen (durch Polling) + +BLOCK Umwandlung Blocknummer in Spur- und Sektornummer + (entsprechend angefordetem Diskettenformat) und + eintragen in Requestvektor fuer Floppyzugriff + +BLKFO Eintrittspunkt fuer Format, Verify und Copydisk + + +Modul K.ACT.S: + +Die Programmteile dieses Moduls stellen eine Anpassung des Remote- +Softwarepakets an die Koppelschnittstelle des P8000 dar. +Das Ein-/Auslagern von UDOS-Dateien unter WEGA (Programme getud und +putud) erfolgt entsprechend dem Remote-Telegramm. +Der Floppyzugriff wurde auf zeitgeteilten Verkehr umgestellt. + + +Modul K.PROM.S: + +Dieser PLZ/SYS-Programmodul enthaelt die zur EPROM-Programmierung +notwendigen Teile (Basismodul mit Anpassung an Koppelschnittstelle). + + +Modul K.P8000.S: + +Dieses Assemblerprogramm umfasst die speziellen Teile zur +EPROM-Programmierung mit der Anpassung an den P8000-Programmer +und die Schnittstelle /dev/ud. + +Modul K.BUF.S: + +Dieser Modul enthaelt nur die Vereinbarung des globalen Puffers +mit dem Namen BUF. + +3. Listings der Module +====================== + +Im Anschluss an diese Beschreibung folgen die kommentierten +Programmlistings aller sechs Module der Koppelsoftware +(K.NEU, K.BLK, K.ACT, K.P8000, K.PROM und K.BUF). diff --git a/WEGA/contrib/eigentest/makefile b/WEGA/contrib/eigentest/makefile new file mode 100644 index 0000000..922dc02 --- /dev/null +++ b/WEGA/contrib/eigentest/makefile @@ -0,0 +1,14 @@ +# Makefile zur Bildung des Programms: eigentest + +# muss anschliessend unter UDOS mit UDOSCNVT eigentest EIGENTEST in eine +# lauffaehige UDOS-Procedure konvertiert werden + +GFLAGS=-t +CC=u80cc +AS=u80as +LD=u80ld +CFLAGS=-O +OBJECTS=udosprom.o menu.o u880tr.o + +eigentest : $(OBJECTS) + u80ld -bt 0x4000 -e start $(OBJECTS) -o eigentest -lu80c diff --git a/WEGA/contrib/eigentest/readme b/WEGA/contrib/eigentest/readme new file mode 100644 index 0000000..9ef13a2 --- /dev/null +++ b/WEGA/contrib/eigentest/readme @@ -0,0 +1,360 @@ + README - 1 - EIGENTEST + + + + + P 8 0 0 0 8-Bit + + H a r d w a r e - E I G E N T E S T + + Beschreibung der Testschritte + + + + Mit dem Stand-alone-Programm EIGENTEST wird dem Anwender die + Moeglichkeit gegeben, individuelle Hardware-Tests fuer den + 8-Bit-Mikrorechnerteil beliebig oft abzuarbeiten. Empfohlen + wird die Verwendung dieses Programms besonders fuer das + Auffinden von Fehlern, die nur zeitweilig auftreten. In + solch einem Fall sollte man das Eigentestprogramm, bzw. den + entsprechenden Einzeltest, laengere Zeit laufen lassen. Das + Programm wird als Dienstprogramm auf der UDOS-Systemdiskette + bereitgestellt. + Das Programm laeuft ohne das OS zu booten im sogenannten + stand-alone-Betrieb und wird mit Hilfe des PROM-MONITOR von + der Systemdiskette geladen und gestartet. + + Start des Programms 'EIGENTEST': + + 1. P8000 einschalten, oder 'RESET'-Taste betaetigen + 2. Systemdiskette UDOS 3.1 in Laufwerk 0 einlegen + 3. Eingabe: "GE EIGENTEST " (Programm laden) + 4. Eingabe: "G " (Programm starten) + + Das Programm meldet sich mit der Ausschrift: + + UDOS 3.1 + H a r d w a r e - E i g e n t e s t Vx.x + + Die Programmsteuerung erfolgt ueber einen Menuebaum. + Menuebestandteile sind entweder Untermenuenamen oder + Funktionen, die ausgefuehrt werden. Das Programm kommentiert + sich selbst. Dem Anwender werden jeweils alle + Eingabemoeglichkeiten angezeigt. Durch Eingabe eines + Kommandos wird eine Auswahl getroffen und man gelangt in das + naechste Menue. Es besteht die Moeglichkeit Einzeltests + aufzurufen, fuer diese einen Wiederholungszaehler + einzustellen (1...9999 mal) und sie dann abzuarbeiten. + Weiterhin ist es moeglich, die interne Testliste anzuzeigen, + in der alle Einzeltests enthalten sind. Diese Liste kann + vollstaendig, oder beginnend bei einer als "aktuell" + gekennzeichneten Zeile, abgearbeitet werden. Dabei kann fuer + jeden der Tests die Anzahl der Wiederholungen individuell + (bis zu 9999 mal) festgelegt werden. + + Werden bei der Abarbeitung der Tests Hardware-Fehler + festgestellt, so erfolgt die Fehlerausgabe auf die + Systemkonsole und in eine Fehlerliste. Der Eintrag in diese + Liste erfolgt unter einer laufenden Nummer die bei 1 beginnt + und bei 32767 ueberlaeuft. Die Fehlerliste kann die jeweils + letzten 200 Fehler speichern und laeuft nicht ueber. Sie ist + organisiert nach dem LIFO-Prinzip und rollendem Eintrag. Die + Fehlerliste kann vom Hauptmenue aufgerufen werden. + + + + + + + + + + + README - 2 - EIGENTEST + + + Das Diagnoseprogramm ist entsprechend den Funktionsgruppen + des 8-Bit-Teils gegliedert und enthaelt gegenwaertig + folgende Tests: + + EPROM-CRC-Test + SRAM-Speichertest + UA855-PIO-Test + UA857-CTC-Test + UA856-SIO-Test + U8272-FDC-Test + UA858-DMA-Test + DRAM-Speichertest + + + Beschreibung der Tests + ---------------------- + + 1. EPROM-CRC-Test + ~~~~~~~~~~~~~~~~~ + Es wird die CRC-Summe des EPROM-Satzes ermittelt und mit den + Sollwerten (EPROM-Adr.: 1FF8...1FFF) verglichen. Treten + Differenzen auf, wird die Nummer des EPROM's (0 oder 1) + sowie Soll-CRC und Ist-CRC angezeigt. + + Test-Nr.0 1.EPROM + + Test-Nr.1 2.EPROM + + + 2. SRAM-Speichertest + ~~~~~~~~~~~~~~~~~~~~ + Es wird ein Test der Datenleitungen, der Adressleitungen, + der Datenhaltigkeit durch das Durchschieben von 0 oder 1 + durchgefuehrt. + + Test-Nr.5 Test der Adressleitungen + Es wird ein besonderes Bitmuster in den SRAM geschrieben und + danach kontrolliert. Der Speicher wird dazu in 8 Seiten + (Seiten-Nr.:20...27) zu je 256 Byte aufgeteilt. Die Bytes + einer Seite werden fortlaufend nummeriert. Das erste Byte + einer Seite ist gleich der Seiten-Nr. d.h. gleich dem High- + Teil der Speicheradresse dieses Bytes. Anschliessend werden + die Seiten nacheinander auf richtigen Dateninhalt getestet. + + Test-Nr.6 Test der Datenleitungen + Beschreiben des SRAM (Adr.:2000...27FF) mit 00 bzw. FF und + anschliessendem Test. + + Test-Nr.7 Test des Datenbusses + Durchschieben eines 0-Bit bzw. 1-Bit auf dem DBUS und im + Speicher. + + + 3. PIO-TEST + ~~~~~~~~~~~ + Test-Nr.10 + Es werden die PIO0, PIO1 und PIO2 in MODE0 (Ausgabe) ohne + INT programmiert und danach ein Test-Byte ausgegeben und + zurueckgelesen. + + + + + + + + + + + README - 3 - EIGENTEST + + + Testbytes: + + 55h an PIO0A + D5h an PIO0B + 55h an PIO1A + F3h an PIO1B + 9Fh an PIO2A + 6Fh an PIO2B + + Nach Testende liegen die Testbytes an den Portausgaengen an. + + + 4. CTC-Test + ~~~~~~~~~~~ + Test-Nr.15 Zaehltest ohne INT + Die CTC-Kanaele werden als Zeitgeber ohne INT programmiert + (SW=07h), eine Zeitkonstante geladen, 0.025 ms gewartet, das + Zaehlregister gelesen und der Kanal gestopt. + + Test-Nr.16 Zeitkonstanten Ueberpruefung + + CTC Kanal TC + --------------------- + 0 0 40h + 0 1 50h + 0 2 60h + 0 3 70h + 1 0 80h + 1 1 02h + 1 2 90h + 1 3 A0h + + Test-Nr.17 Test mit INT + Die CTC-Kanaele (nicht CTC1-Kanal1) werden als Zeitgeber mit + INT programmiert (SW=87h), eine Zeitkonstante geladen + (TC=10h), und max. 1ms gewartet in dieser der Kanal einen + INT nach ca. 0.04ms generieren muss. Danach wird + kontrolliert ob in dieser Zeit eine INT-Service-Routine + angesprungen wurde. + + + 5. SIO-Test + ~~~~~~~~~~~ + Test-Nr.20 + Ueberpruefung der Adressierbarkeit und des Datenaustauschs + zwischen der CPU und der SIO durch Ruecklesen des INT- + Vektors aus dem SIO-KanalB. + + INT-Vektoren: SIO0 = 20h + SIO1 = 50h dann 30h + + Test-Nr.21 + Ueberpruefung der Sende- und INT-Faehigkeit der SIO0 und + SIO1. Die Kanaele senden 00h und die CPU wartet auf INT- + 'SENDEPUFFER LEER'. Erfolgt die INT-Anmeldung nicht + innerhalb von 0.5s kommt es zu einer Fehlermeldung. SIO0- + KanalB (Consolenausgabe-Kanal) wird nicht auf diese Weise + getestet. + SIO-programmierung: 9600,8,N,2 + INT-MODE 3 + SAVECT + + + + + + + + + README - 4 - EIGENTEST + + + + 6. FDC-Test + ~~~~~~~~~~~ + Test-Nr.23 + Der FDC-PIO (PIO2B) wird auf MODE 3 (Bitmode Bit4=E) + programmiert und danach wird ein Hardware-Reset fuer den FDC + ausgeloest (Impulsbreite ca. 0.025ms). Nach einer Pause von + weiteren 0.025ms wird der Test fortgesetzt. + + Test-Nr.24 + An den FDC wird das Kommando 'SPECIFY' gegeben und deren + Ausfuehrung abgewartet. + + Parameter: SRT=1 HUT=0FH HLT=2AH ND=1. + + Test-Nr.25 + An den FDC wird jetzt das Kommando 'SENSE DRIVE STATUS' + gegeben und das Statusregister ST3 in der Ergebnisphase des + FDC gelesen und auf 05H ueberprueft. + Parameter: HDS=1 DS1=0 DS0=1. + + Nach Abschluss der Tests wird ein Reset an den FDC gegeben. + + + 7. DMA-Test + ~~~~~~~~~~~ + Test-Nr.26 Test ohne INT + Der DMA wird programmiert und transferiert 100 Byte von + Adresse 0000 zur Adresse 3000h. Danach wird das + Statusregister und das Zaehlerregister auf Sollwerte + getestet. Der DMA uebernimmt vollstaendig die Bussteuerung + und gibt sie nach der Speicheruebertragung wieder an die CPU + zurueck. + + Test-Nr.27 Test mit INT + Der DMA wird auf INT programmiert und uebertraegt 100 Byte + von Adresse 0000 zur Adresse 3000 (wurde vorher geloescht). + Danach wird ueberprueft ob ein INT generiert und durch die + CPU bedient wurde. + Nach erfolgreicher INT-Behandlung wird das Statusbyte + kontrolliert. + + Test-Nr.28 movecheck + Es wird der DMA-Transfer durch die CPU ueberprueft. Sie + testet, ob die 100 Bytes vollstaendig uebertragen wurden. + + + 8. DRAM-Speichertest + ~~~~~~~~~~~~~~~~~~~~ + Es werden ein Test der Adressleitungen, der Datenleitungen, + der Datenhaltigkeit des Speichers durch das Durchschieben + von 0 und 1 durchgefuehrt. Bei auftretenden Fehlern wird der + entsprechende Fehlercode (Test-Nr.) an das Terminal + ausgegeben. Am Terminal werden ausserdem die + Speicheradresse, der geschriebene und der rueckgelesene Wert + angezeigt. + Der Test erfolgt in zwei Teilen. + + Teil 1: + Einschalten des DRAM auf den Adressen 0000...FFFF und + testen des Bereiches 8000...FFFF. + + + + + + + + + README - 5 - EIGENTEST + + + + Teil 2: (nur wenn 1.Teil fehlerfrei!) + MOVE des Bereiches 0000...7FFF nach 8000...FFFF und + testen des Bereiches 0000...7FFF. + + Danach remove der Programme SMON und EIGENTEST und verlassen + des DRAM-Tests. + + Test-Nr.30 (35) + Test der Adressleitungen im Bereich 8000...FFFF + (0000...7FFF). + Der Speicher wird in Seiten zu je 256 Byte aufgeteilt. Die + Bytes einer Seite werden fortlaufend nummeriert. Das erste + Byte in einer Seite ist gleich dem High-Teil der + Speicheradresse dieses Bytes. Anschliessend werden die + Seiten nacheinander getestet. War der Test der + Datenleitungen fehlerfrei und stimmen die Werte einer Seite + nicht mit den eingegebenen Werten ueberein, dann ist die + Ansteuerung fuer ein oder mehrere Adressbits dieser Seite + fehlerhaft. + + Test-Nr.31 (36) + Test der Datenleitungen im Bereich 8000...FFFF + (0000...7FFF). Der Speicherbereich wird zuerst mit 00 und + danach mit FF gefuellt und ueberprueft. + + Test-Nr.32 (37) + Durchschieben von 0-Bits in einer Umgebung von 1-Bits im + Bereich von 8000...FFFF (0000...7FFF). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/WEGA/contrib/eigentest/s.menu.c b/WEGA/contrib/eigentest/s.menu.c new file mode 100644 index 0000000..1c088be --- /dev/null +++ b/WEGA/contrib/eigentest/s.menu.c @@ -0,0 +1,738 @@ +h05673 +s 00005/00005/00619 +d D 3.1.1.4 89/11/08 10:14:50 wega 5 4 +c tolower +e +s 00005/00005/00619 +d D 3.1.1.3 89/11/08 09:59:06 wega 4 3 +c _tolower +e +s 00002/00000/00622 +d D 3.1.1.2 89/11/08 08:16:00 klatte 3 2 +c include +e +s 00008/00006/00614 +d D 3.1.1.1 89/11/08 07:51:10 klatte 2 1 +c Ueberschrift;tolower +e +s 00620/00000/00000 +d D 3.1 89/11/07 14:57:48 klatte 1 0 +c date and time created 89/11/07 14:57:48 by klatte +e +u +U +f b +t +T +I 1 +/************************************************************************** +*************************************************************************** + + UDOS - Quelle (c) ZFT/KEAW Abt. Basissoftware 1988 + P8000-UDOS + Programm: EIGENTEST + Modul: %M% + Bearbeiter: J.Kubisch, M.Klatte + Datum der letzten Release: %G% + UDOS-Release: %R%.%L% + Zweignummer: %B%.%S% + +*************************************************************************** +**************************************************************************/ + +char ident[] = "%W%"; + +I 3 +D 5 +#include +E 5 +I 5 +#define tolower(c) (('A'<=c && c<='Z')?c-'A'+'a':c) +E 5 + +E 3 +#define JA 1 +#define NEIN 0 + +extern unsigned int errcnt; /* Fehlerzaehler */ + +unsigned char ertab[1000]; /* Fehlerliste */ +unsigned int z,errct,adress,sollcrc,istcrc; +unsigned int sollwert,istwert; +char fehnr; +char eink[5]; /* Kommandoeingabe*/ +char eint[2]; /*Testeingabe*/ +char komm; /*Letztes Kommando der Kommando-Ebene*/ +int einzelt; /*aktueller Einzeltest*/ +int rep; /*Wiederholungszaehler fuer akt. Test*/ +int noend; /*Merker fuer Endlostest*/ +int testl; /*Ungleich Null, wenn Liste abgearbeitet wird.*/ +int aktze; /*aktuelle Zeile fuer vollstaendige Listenabarbeitung*/ +int i,j,n; +char *gets(); /*Zeichenketteneingabe von Konsole*/ + +struct testz +{ char name [11]; + int wdhlg; +} tz[8] = {{"EPROM ",1}, + {"SRAM ",1}, + {"PIO ",1}, + {"CTC ",1}, + {"SIO ",1}, + {"FDC ",1}, + {"DMA ",1}, + {"DRAM ",1}}; + +struct testz *pt; /*Strukturpointer*/ + + +main() +{ + einzelt = 0; /*1.Test (EPROM) voreingestellt*/ + aktze = 1; /*1 = aktuelle Zeile,voreingestellt*/ + rep = 1; + noend = 0; + testl = 0; + komm = ' '; /*Kommandotaste*/ + + printf("\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0"); + printf("\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0"); + printf("\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0\n\0\0\0"); + printf("\n\0\0\0\n\0\0\0\n\0\0\0\n"); + printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\n"); + printf("***************************************************\n"); +I 2 +D 4 + printf("* UDOS %R%.%L% *\n"); +E 4 +I 4 + printf("* UDOS %R%.%L% *\n"); +E 4 +E 2 + printf("* *\n"); +D 2 + printf("* Stand alone Hardware-Eigentest *\n"); +E 2 +I 2 + printf("* H a r d w a r e - E i g e n t e s t V%B%.%S% *\n"); +E 2 + printf("* *\n"); +I 2 + printf("* *\n"); +E 2 + printf("***************************************************\n"); + + INI_ERR_LST (); /*UP zur Initialisierung der Fehlerliste*/ + + do ; while (tke()); + printf("\nEnde Eigentest - Resettaste betaetigen!\n"); + do ; while (1); +} +tke() /*Testkommando-Eingabe*/ +{ + printf("\n\n\n\t*** TESTKOMMANDO-EBENE ***"); + printf("\n\nt Auswaehlen und Abarbeiten von Einzeltests"); + printf("\nr Wiederholen des aktuellen Einzeltests"); + printf("\nl Abarbeiten der vollstaendigen Testliste"); + printf("\nf Anzeige der Fehlerliste"); + printf("\nq Quitt"); + printf("\n\n\tGeben Sie Ihre Auswahl ein ]=> "); + + gets(eink,sizeof eink); /*Kommando-Eingabe)*/ +D 2 + komm = eink[0]; +E 2 +I 2 +D 4 + komm = tolower(eink[0]); +E 4 +I 4 +D 5 + komm = _tolower(eink[0]); +E 5 +I 5 + komm = tolower(eink[0]); +E 5 +E 4 +E 2 + +D 2 + switch(eink[0]) { +E 2 +I 2 + switch(komm) { +E 2 + case 't': + do ; while (aae()); /*Auswaehlen und /Abarbeiten von + Einzeltests*/ + return(1); + case 'r': + do ; while (vtz()); /*Veraendere Testzeile*/ + return(1); + case 'l': + testl=1; + do ; while (avt()); /*Abarbeiten der vollst. Testliste*/ + return(1); + case 'f': + printf("\n\n\t*** Ausgabe der Fehlerliste ***\n\n"); + MEM_MSG_OUT (); /*UP zur Fehlerlistenausgabe*/ + return(1); + case 'q': + return(0); /* Ende des Tests*/ + default: + return(1); + } +} + +aae() /*Auswaehlen und Abarbeiten von Einzeltests*/ +{ + printf("\n\n *** WAEHLE TESTZEILE ***"); + printf("\n\n1 Test EPROM"); + printf("\n2 Test SRAM"); + printf("\n3 Test PIO"); + printf("\n4 Test CTC"); + printf("\n5 Test SIO"); + printf("\n6 Test FDC"); + printf("\n7 Test DMA"); + printf("\n8 Test DRAM"); + printf("\n\n# Auswahl des Tests mit der Nr. #"); + printf("\n^ Rueckkehr zur \"Testkommando-Ebene\""); + printf("\n\n Geben Sie Ihre Auswahl ein ]=> "); + + gets(eint,sizeof eint); + + switch (eint[0]){ + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + einzelt=eint[0]-0x30; /*Testzeilennr.: Ascii zu int konv.*/ + aktze = einzelt; /*Aktuelle Zeile*/ + + do ; while (vtz()); /*Veraendere Testzeile*/ + return(1); /*aae bleibt, bis ^ gegeben wird*/ + case '^': + return(0); /*Ende aae*/ + default: + return(1); /*aae soll wiederholt werden*/ + } +} +vtz() /*Veraendere Testzeile*/ +{ + printf("\n\n *** Veraendere Testzeile (optional) ***"); + printf("\n\nDie Testzeile hat folgenden aktuellen Stand:"); + printf("\n\nName Anzahl der Wiederholungen"); + + pt = tz + aktze - 1; /*Strukturzeiger setzen*/ + + printf("\n%s %d",pt->name,pt->wdhlg); + printf("\n\n w Wiederholungszaehler veraendern"); + printf ("\n p Testparameter veraendern"); + printf("\n Testzeile ist korrekt, Test abarbeiten!"); + if (komm == 'r') /*Wdhlg. des aktuellen Einzeltests*/ + printf("\n ^ Rueckkehr zur \"Testkommando-Ebene\""); + else + printf("\n ^ Rueckkehr zu \"Waehle Testzeile\""); + printf("\n\n Geben Sie Ihre Auswahl ein ]=>"); + gets (eink,sizeof eink); /*Eingabe fuer "veraendere Testzeile"*/ + +D 2 + switch (eink[0]){ +E 2 +I 2 +D 4 + switch (tolower(eink[0])){ +E 4 +I 4 +D 5 + switch (_tolower(eink[0])){ +E 5 +I 5 + switch (tolower(eink[0])){ +E 5 +E 4 +E 2 + + case 'w': + vw(); /*Progr. \"Wiederholungszaehler setzen\""*/ + return (1); + + case 'p': + vp(); /*Progr. \"Testparameter veraendern\""*/ + return(1); + + case '^': + return(0); /*Rueckkehr zu "Waehle Testzeile"*/ + + case '\0': /*CR, Testzeile o.k., Test abarbeiten*/ + + tl(); /*Testabarbeitung*/ + + return(1); + default: + return(1); + } +} +vw() /*Setze Wiederholungszaehler*/ +{ + printf("\n\n *** Veraendere Wiederholungszaehler ***"); + printf("\nAktueller Wiederholungszaehler = %d",pt->wdhlg); + printf("\n\n 0 Test laeuft, bis Reset-Taste betaetigt wird"); + printf("\n # Test laeuft # mal (# positiv <= 9999)"); + printf("\n ^ Rueckkehr zu \"Veraendere Testzeile\""); + printf("\n Wiederholungszaehler bleibt unveraendert"); + printf("\n\n Geben Sie Ihre Auswahl ein ]=>"); + + gets(eink,sizeof eink); + switch (eink[0]){ + case '\0': /*CR:Wiederholungszaehler bleibt unveraendert*/ + case '^': + return(0); /*Rueckkehr zu "Veraendere Testzeile"*/ + } + + rep=katoi(eink); /*Konvertierung Wiederholungszaehler*/ + if (rep>=0 && rep<=9999) + pt->wdhlg=rep; + return(0); +} + +katoi(s) /*Zeichenkette s in int umwandeln*/ + char s[]; +{ + int n; + for (i=0;s[i]==' '||s[i]=='\n'||s[i]=='\t'||s[i]=='+'||s[i]=='-';i++) + ; /*Zwischenraeume ueberlesen*/ + + for(n=0;s[i]>='0'&&s[i]<='9';i++) + n=10*n+s[i]-'0'; + return(n); +} + +vp() /*Veraendere Testparameter*/ +{ + printf("\n\n *** Veraendere Testparameter ***"); + printf("\nFuer diesen Test gibt es keine Parameter "); + printf("\n ^ Rueckkehr zu \"Veraendere Testzeile\""); + printf("\n\n Geben Sie Ihre Auswahl ein ]=>"); + do + gets(eink,sizeof eink); + while (eink[0]!='\0' && eink[0]!='^'); + return(0); +} + +tl() /*Testlistenabarbeitung*/ +{ + printf("\n\nDer folgende Test wird jetzt abgearbeitet:"); + printf("\n\nName Anzahl der Wiederholungen\n"); + + if (komm == 'l') /*vollstaendige Liste abarbeiten*/ + j=8; + else + j=aktze; /*nur fuer akt. Zeile abarbeiten*/ + + for (i = aktze; i <= j; i++) + { pt = tz+i-1; + printf("\n%s %d\n",pt->name,pt->wdhlg); + rep = pt->wdhlg; /*Wiederholungszaehler fuer aktuellen Test*/ + + if (rep == 0) + noend = 1; + else + noend = 0; + +/* Aufruf der Assembler-UPs fuer die entspr. Tests */ +/* Geben Fehlermeldungen aus, die im Abarbeitungstempo weiterrollen */ + + while (rep > 0 || noend == 1) + { switch (i) + { case 1: + printf("EPROM_ \n"); /*Aufruf des Assembl.-UPs*/ + EPROM_ (); + break; + + case 2: + printf ("SRAM_ \n"); + SRAM_ (); + break; + + case 3: + printf ("PIO_ \n"); + PIO_ (); + break; + + case 4: + printf ("CTC_ \n"); + CTC_ (); + break; + + case 5: + printf ("SIO_ \n"); + SIO_ (); + break; + + case 6: + printf ("FDC_ \n"); + FDC_ (); + break; + + case 7: + printf ("DMA_ \n"); + DMA_ (); + break; + + case 8: + printf ("DRAM_ \n"); + DRAM_ (); + break; + + default: + printf ("\nFehlerh. Eingabe"); + } + rep --; + } + } + if (komm == 'l') /*Testlistenabarbeitung*/ + printf ("\n\nRueckkehr zur \"Testkommando-Ebene\" durch CR-Eingabe :"); + else + printf ("\n\nRueckkehr zu \"Veraendere Testzeile\" durch CR-Eingabe :"); + + do + gets (eink,sizeof eink); + while (eink[0] != '\0' && eink[0] !='^'); + return (0); +} + + +avt() /*Abarbeiten der volsstaendigen Testliste*/ +{ + printf("\n\n *** Testliste abarbeiten ***\n\n"); + for (i=1; i<=8; i++) /*Vollst.Testliste abarbeiten*/ + {if (i == aktze) + printf("*"); + else printf(" "); + pt = tz+i-1; + printf(" %d %s\n",i,pt->name); + } + printf("\n Testlistenabarbeitung beginnt bei aktueller Zeile (*)"); + printf("\n s Testlistenabarbeitung beginnt bei Zeile 1"); + printf("\n # # wird zur aktuellen Zeile"); + printf("\n ^ Rueckkehr zur \"Testkommando-Ebene\""); + + printf("\n\n Geben Sie Ihre Auswahl ein ]=> "); + + gets(eink, sizeof eink); + +D 2 + switch (eink[0]){ +E 2 +I 2 +D 4 + switch (tolower(eink[0])){ +E 4 +I 4 +D 5 + switch (_tolower(eink[0])){ +E 5 +I 5 + switch (tolower(eink[0])){ +E 5 +E 4 +E 2 + + case'\0': /*CR-Testabarbeitung beginnt bei akt. Zeile*/ + tl(); + return(0); + case's': + aktze=1; /*Testabarb. ab Zeile 1*/ + tl(); + return(0); + case'1': + case'2': + case'3': + case'4': + case'5': + case'6': + case'7': + case'8': + aktze = katoi(eink); + return(1); + case'^': + return(0); + default: + return(1); /*Wiederholung avt*/ + } +} /*Ende avt*/ + + + + +/*---------------------------------------------------------------------------*/ +/* + *gets + * Eingabe einer Zeichenkette von der Console + * + * in einen vorgegebenen Puffer bis CR oder LF + * oder bis der Eingabepuffer gefuellt ist + * Das letzte Zeichen im Puffer ist 0x00. CR und LF werden + * nicht in den Puffer geschrieben + */ +/*---------------------------------------------------------------------------*/ +char *gets(buf, buflen) +char *buf; +unsigned buflen; +{ + char *lp; + int c; + + lp = buf; + for (;;) { + c = getchar() & 0177; + putchar (c); /* Ausgabe an Terminal */ + switch(c) { + case '\n': /* lf */ + case '\r': /* cr */ + *lp = '\0'; + return(buf); + case '\b': /* back space */ + putchar(' '); + putchar('\b'); + lp--; + if (lp < buf) + lp = buf; + continue; + case 0x18: + case 0x7f: + lp = buf; + putchar('\n'); + continue; + default: + if (lp>=buf+buflen-1) { + *lp = '\0'; + return(buf); + } + *lp++ = c; + } + } +} + +/* Initialisierung der Fehlerliste */ + +INI_ERR_LST () +{ + for(n = 0; n<1000; n++) ertab[n] = 0; + errcnt = 0; +} + +/* Fehlerliste ausgeben */ + +MEM_MSG_OUT () +{ +errct = errcnt; + +if (errct==0) + printf("\n Es sind keine Fehler gespeichert !\n"); +else { + printf("\nLfd.-Nr. Fehler-Nr. Adresse Sollwert Istwert\n"); + for(n = 0; (errct>0)&&(n<1000); errct--, n+=5) { + fehnr = ertab[n]; + if (fehnr<5) { + sollcrc = ertab[n+1]*256+ertab[n+2]; + istcrc = ertab[n+3]*256+ertab[n+4]; + printc(" %5d %x %0x %0x\n",errct,fehnr,sollcrc,istcrc,n); + } + else { + adress = ertab[n+1]*256+ertab[n+2]; + sollwert = ertab[n+3]; + istwert = ertab[n+4]; + printc(" %5d %x %0x %x %x\n",errct,fehnr,adress,sollwert,istwert); + } + if (((errcnt-errct+1)%22)==0) { + printf(" weiter ---> (ENTER) beenden ---> (q)"); + gets(eink,sizeof eink); +D 2 + if (eink[0]=='q') return; +E 2 +I 2 +D 4 + if (tolower(eink[0])=='q') return; +E 4 +I 4 +D 5 + if (_tolower(eink[0])=='q') return; +E 5 +I 5 + if (tolower(eink[0])=='q') return; +E 5 +E 4 +E 2 + printf("\n"); + } /* end if */ + } /* next errct */ + printf("\ndruecke (ENTER) :\n"); + gets(eink,sizeof eink); + } /* end else */ +} /* end MEM_MSG_OUT () */ + + + +/*****************************************/ +/* */ +/* simulation der Druckausgabe 'printf' */ +/* */ +/*****************************************/ + +/* conventions: */ +/* Variable duerfen nur vom Typ int, char oder pointer sein. */ +/* Die Anzahl der aktuellen Parameter muss mit der Anzahl der*/ +/* formalen Parameter uebereinstimmen (bei printc sind es 5) */ + +int links; /* Zeichen linksbuendig */ +int stellen; /* Anzahl der Stellen */ +int vnull; /* vornullen ausgeben */ +int pnull; /* Null ausgabe */ +int k,c; + +printc(tp,a,b,c,d,e) +unsigned char *tp; +int a,b,c,d,e; +{ +int *pp; + +pp = &a; + +while (*tp) { + + if ( *tp == '%' ) { + + tp++; + if (*tp=='-') {links = JA;tp++;} else links = NEIN; + if (*tp=='0') {vnull = JA;tp++;} else vnull = NEIN; + if ('0'<*tp && *tp<'6') {stellen = *tp-'0'; tp++;} + else stellen = 5; + pnull = NEIN; + switch (*tp) { + case'd': putdec(*pp--); break; + case'u': putudec(*pp--); break; + case'x': puthex(*pp--); break; + case'o': putoct(*pp--); break; + case'c': putchar(*pp--); break; + case's': putstring(*pp--); break; + case'%': putchar(*tp);break; + default: break; + } + } + else putchar(*tp); + + tp++; +} +} + + + +/* Ausgabeconvertierung DEZIMAL mit Vorzeichen */ +/*---------------------------------------------*/ +putdec(zahl) +int zahl; +{ +int z; +int za; + +if ( zahl < 0 ) { + za = -zahl; + putchar('-'); + } +else za = zahl; + +for ( k = z = 1; z0; k--) { + c = (((za&0xf000)>>12)&0x000f)+'0'; + za <<= 4; + if(c > '9') c += 7; + putform(c); + +} +} /* end of funktion */ + +/* Ausgabe eines strings */ + +putstring(s) +char *s; +{ +while (*s) { putchar(*s); s++; } +} + + +/* formatierte Ausgabe eines Zeichens */ + +putform(c) +int c; +{ + + if (links) { + if ((c>'0') || pnull || k==1) { putchar(c); pnull = JA; } + } + else { + if (c=='0') { + if (vnull || pnull || k==1) putchar('0'); + else putchar(' '); + } + else { putchar(c); pnull = JA;} + } +} +E 1 diff --git a/WEGA/contrib/eigentest/s.u880tr.s b/WEGA/contrib/eigentest/s.u880tr.s new file mode 100644 index 0000000..fb39135 --- /dev/null +++ b/WEGA/contrib/eigentest/s.u880tr.s @@ -0,0 +1,2134 @@ +h65362 +s 00002/00001/02109 +d D 3.1.1.1 89/11/07 15:18:30 klatte 2 1 +c error25 +e +s 02110/00000/00000 +d D 3.1 89/11/07 14:40:48 klatte 1 0 +c date and time created 89/11/07 14:40:48 by klatte +e +u +U +f b +t +T +I 1 +;************************************************************************** +;************************************************************************** + +; UDOS - Quelle (c) ZFT/KEAW Abt. Basissoftware 1988 +; P8000-UDOS +; Programm: EIGENTEST +; Modul: %M% +; Bearbeiter: J.Kubisch, M.Klatte +; Datum der letzten Release: %G% +; UDOS-Release: %R%.%L% +; Zweignummer: %B%.%S% + +;************************************************************************** +;*************************************************************************/ + + +; Verbindungen zum C-Modul menu.c: + + public EPROM_,SRAM_,PIO_,CTC_,SIO_,FDC_,DMA_,DRAM_ + public errcnt ;Fehlerzaehler (0...32767) + extrn ertab ;Fehlerliste 1000 Byte + + begin 0 + +D 2 + text '%W%' +E 2 +I 2 + text '%W%\' +E 2 + + +; PROM-Test +; Fuer den PROM wird ausser den letzten zwei Bytes die Pruefsumme +; gebildet und mit dem in den letzten zwei Bytes stehenden Wert +; verglichen. Bei Fehler wird der Fehlerkode 00 o. 01 an das Terminal +; ausgegeben. + +EPROM_: + di + + push af + push bc + push de + push hl + push ix + push iy + + EXX + ld a,3 + ld (MAWE),a ;Anzahl auszugebener Werte + LD E,0 ;TEST-NUMMER SETZEN + EXX + +; PROM select 0000H...1FFFH + + ld c,WEADP ;adress bank-select + ld d,1 ;PROM-select + ld b,0 ;adress:0000 + out (c),d + ld b,10H ;adress:1000H + out (c),d + +; Berechnung des CRC der PROM's nach dem SDLC Polynom + +; Berechnung des CRC fuer EPROM0 + + LD HL,0 ;1. Byte-Adr. + LD BC,1000H ;Byte-Anzahl + ld de,-1 +crc1: ld a,(hl) + xor d + ld d,a + rrca + rrca + rrca + rrca + and 0fh + xor d + ld d,a + rrca + rrca + rrca + LD I,A + and 1fh + xor e + ld e,a + LD A,I + LD I,A + rrca + and 0f0h + xor e + ld e,a + LD A,I + and 0e0h + xor d + ld d,e + ld e,a + inc hl + dec bc + ld a,b + or c + jr nz,crc1 + LD HL,(CRCEP0) + LD A,D + CP H + JR NZ,CRCFE0 + LD A,E + CP L + JR NZ,CRCFE0 + LD HL,(NCEP0) + ADD HL,DE + LD A,0FFH + CP H + JR NZ,CRCFE0 + CP L + JR Z,CRCE1 + +CRCFE0 ld b,d + ld a,e ;CRC-Istwert umladen ( ba:=de ) + call FAHLR ;Fehlerausgabe ( Feh.Nr. CRC-Soll CRC-Ist ) + +; Berechnung und Test des CRC fuer EPROM1 + +CRCE1 exx + ld e,1 ;Fehler-Nr. naechsten Test laden + exx + + LD HL,1000H ;STARTADRESSE PROM + LD BC,0FF8H ;BYTE-ZAHL + ld de,-1 +crc10: ld a,(hl) + xor d + ld d,a + rrca + rrca + rrca + rrca + and 0fh + xor d + ld d,a + rrca + rrca + rrca + LD I,A + and 1fh + xor e + ld e,a + LD A,I + LD I,A + rrca + and 0f0h + xor e + ld e,a + LD A,I + and 0e0h + xor d + ld d,e + ld e,a + inc hl + dec bc + ld a,b + or c + jr nz,crc10 + LD HL,(CRCEP1) ;CRC-Sollwert holen + LD A,D + CP H ;Soll-Ist Vergleich High-Teil + JR NZ,CRCFE1 + LD A,E + CP L + JR NZ,CRCFE1 + LD HL,(NCEP1) + ADD HL,DE + LD A,0FFH + CP H + JR NZ,CRCFE1 + CP L + JR Z,EPROME + +CRCFE1 ld b,d + ld a,e ;CRC-Istwert umladen ( ba:=de ) + call FAHLR ;Fehlerausgabe (Feh.-Nr. CRC-Soll CRC-Ist ) + + +; DRAM select 0000H...1FFFH + +EPROME: ld c,WEADP ;adress bank-select + ld d,4 ;DRAM-select + ld b,0 ;adress:0000 + out (c),d + ld b,10H ;adress:1000H + out (c),d + + ld a,IVRSYS + ld i,a ;I-Reg. auf UDOS-System stellen + + pop iy + pop ix + pop hl + pop de + pop bc + pop af + + ei + + RET ;END OF PROCEDURE + +;----------------------------------------------------------------------- + +; SRAM-Test +; Es werden ein Test der Adressleitungen,der Datenleitungen,der Daten- +; haltigkeit des Speichers durch das Durchschieben von 0 oder 1 und ein +; Programmtest des Speichers durchgefuehrt. Bei auftretenden Fehlern +; wird der entsprechende Fehlerkode an das Terminal ausgegeben. Am +; Terminal werden ausserdem die Speicheradresse, der ausgegebene und der +; rueckgelesene Wert angezeigt. + +SRAM_: + di + push af + push bc + push de + push hl + push ix + push iy + + EXX ;holen Zweitregistersatz + LD E,6 ;TEST-NUMMER LADEN + ld a,3 + ld (MAWE),a + EXX + +; Initialisierung Speicherbank, SRAM auf die Adresse 2000H + + LD D,2 ;SRAM_SEL aktiv + LD B,20H ;Adresse ist 2000H + LD C,WEADP + OUT (C),D ;Einschalten des SRAM auf die Adresse 2000H + +; Test der Datenleitungen des SRAM + + XOR A ;alle Bits auf 0 setzen +TAUFD LD HL,2000H ;Anfangsadresse ist 2000H + LD DE,2001H + LD BC,7FFH ;Datenlaenge ist 2k-1 + LD (HL),A ;0 oder 0FFH auf den ersten Speicherplatz + LDIR ;Wert wird in alle Speicherzellen des SRAM + ; eingetragen + CP (HL) ;Letztes Byte gleich dem Akkumulator? + JR Z,DTSR1 + LD B,A ;Testwert eintragen + LD A,(HL) + call FAHLR ;Fehlerausgabe + jr WT2SR + +DTSR1 XOR 0FFH ;Ja. + JR NZ,TAUFD ;Test mit 0FFH + +WT2SR EXX + LD E,5 + EXX + +; Test der Adressleitungen des statischen RAM im Bereich 2000...27ffh + +; Der Speicher wird in Seiten zu je 256 Byte aufgeteilt. Die Bytes +; einer Seite werden fortlaufend nummeriert. Das erste Byte in einer +; Seite ist Gleich dem High-Teil der Speicheradresse dieses Bytes +; (Seiten-Nr.). Anschliessend werden die Seiten nacheinander getestet. +; War der Test der Datenleitungen fehlerfrei und stimmen die Werte +; einer Seite mit dem eingegebenen Wert nicht ueberein,dann ist +; die Ansteuerung fuer ein Adressbit dieses Bytes fehlerhaft. + +; Laden des Musters + + ld hl,2000h ;Startadresse SRAM-Teil + ld d,8 ;Seitenzahl laden (1 Seite = 256 Byte) +sr210 ld b,0 ;b:=256 + ld a,h ;Seiten-Nr. holen (1.Byte in Seite=Seiten-Nr.) + +sr220 ld (hl),a ;SRAM auf einer Seite (256 Byte) fortlaufend + inc a ;nummerieren + inc hl + djnz sr220 + + dec d ;DEC Seitenzaehler + jr nz,sr210 ;wenn nicht die letzte, JP + +; Test ob Muster richtig geladen wurde + + ld hl,2000h ;Startadresse SRAM-Teil + ld de,0800h ;Seitenzahl*Seitenlaenge laden +sr230 ld b,h ;Seiten-Nr. holen (Sollwert) + +sr240 ld a,(hl) ;Istwert holen + cp b ;Soll=Ist? + call nz,FAHLR + inc b ;neue Sollwert-Byte-Nr. + inc hl ;neue Adresse + dec e ;Bytezaehler + jr nz,sr240 ;wenn Seitenende nicht erreicht, jp + + dec d ;DEC Seitenzaehler + jr nz,sr230 ;wenn noch nicht alle Seiten getestet, jp + + EXX + LD E,7 + EXX + +; Durchschieben von 0 und 1 + +; Durchschieben einer Null + + LD HL,2000H + LD (HL),0FFH + LD DE,7FFH + LD B,E + LD A,(424) ;nur wegen Aenderung auf dem Bus + LD A,(HL) + CP B ;Testen des ersten Wertes + call nz,FAHLR + INC HL + AND A +NZNL RLA + LD (HL),A ;Laden des Speichers mit den Werten + EX AF,AF' + INC HL + DEC DE + LD A,D + OR E + JR Z,T2ZSR + EX AF,AF' + JR NZNL +T2ZSR + LD HL,2001H + LD DE,7FEH + SCF + LD B,E ;Register mit 0FEH laden + EX AF,AF' +TNZSR2 + LD A,(HL) + CP B ;Vergleich der Werte + call NZ,FAHLR + INC HL + DEC DE + LD A,D + OR E + JR Z,SRAME + EX AF,AF' + LD A,B + RLA + LD B,A + EX AF,AF' + JR TNZSR2 + +; Initialisierung Speicherbank, DRAM auf die Adresse 2000H zurueckschalten + +SRAME: LD D,4 ;DRAM_SEL aktiv + LD B,20H ;Adresse ist 2000H + LD C,WEADP + OUT (C),D ;Einschalten des DRAM auf die Adresse 2000H + + ld a,IVRSYS + ld i,a ;I-Reg. auf UDOS-System stellen + + pop iy + pop ix + pop hl + pop de + pop bc + pop af + + ei + + RET ;END OF PROCEDURE + +;----------------------------------------------------------------------------- + +; PIO-Test +; Es werden alle PIO's im Ausgabemode getestet (ohne Interrupt). +; Im Fehlerfall werden Port-Adresse, eingetragener und rueckgelesener +; Wert an das Terminal ausgegeben. + +PIO_: + di + + push af + push bc + push de + push hl + push ix + push iy + + EXX + LD E,10H + LD A,3 + LD (MAWE),A ;Initialisierung fuer den Merker + EXX + +; Test PIO0, Kanal A im Ausgabemode (ohne Interrupt) + + LD A,3 + LD C,P0AC + OUT (C),A + LD A,55H + CALL PTAUS + CALL NZ,FA3RET + + +; Test PIO0, Kanal B im Ausgabemode + + LD C,P0BC + LD A,0D5H + CALL PTAUS + CALL NZ,FA3RET + +; Test PIO1, Kanal A im Ausgabemode + + ld a,3 + ld c,P1AC + out (c),a ;DI PIO1A + ld a,55h ;Testmuster + call PTAUS + call nz,FA3RET + + +; Test PIO1, Kanal B im Ausgabemode + + LD A,3 + LD C,P1BC + OUT (C),A + LD A,0F3H + CALL PTAUS + CALL NZ,FA3RET + +; Test PIO2, Kanal A im Ausgabemode + + + LD A,3 + LD C,P2AC + OUT (C),A + LD A,9FH + CALL PTAUS + CALL NZ,FA3RET + +; Test PIO2, Kanal B im Ausgabemode + + + LD A,3 + LD C,P2BC + OUT (C),A + LD A,6FH + CALL PTAUS + CALL NZ,FA3RET + +PIOE: + pop iy + pop ix + pop hl + pop de + pop bc + pop af + + ei + + RET ;END OF PROCEDURE + +;---------------------------------------------------------------------------- + +; CTC-Test + +CTC_: + push af + push bc + push de + push hl + push ix + push iy + +; Test der CTC-Kanaele als Zaehler (ohne Interrupt) + + EXX + LD A,3 + LD (MAWE),A + LD E,15H ;Test-Nr. ausgeben + EXX + +; Zaehltest von CTC0, Kanal 0-3 und CTC1, Kanal 0,2,3 + + LD C,C0K0 + LD B,40H + CALL CZPR + CALL NC,FA3RET + + LD C,C0K1 + LD B,50H + CALL CZPR + CALL NC,FA3RET + + LD C,C0K2 + LD B,60H + CALL CZPR + CALL NC,FA3RET + + LD C,C0K3 + LD B,70H + CALL CZPR + CALL NC,FA3RET + + LD C,C1K0 + LD B,80H + CALL CZPR + CALL NC,FA3RET + + LD C,C1K2 + LD B,090H + CALL CZPR + CALL NC,FA3RET + + LD C,C1K3 + LD B,0A0H + CALL CZPR + CALL NC,FA3RET + + EXX + LD E,16H + EXX + +; Test des CTC, ob die Zeitkonstanten richtig ruecklesbar sind + + LD B,40H + LD C,C0K0 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,50H + LD C,C0K1 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,60H + LD C,C0K2 + IN A,(C) + CP B + CALL NZ,FA3RET + + + LD B,70H + LD C,C0K3 + IN A,(C) + CP B + CALL NZ,FA3RET + + + LD B,80H + LD C,C1K0 + IN A,(C) + CP B + CALL NZ,FA3RET + + ld c,C1K1 ;Kanaladresse + ld d,57h ;DI / Zaehler / CLK / TC folgt / Kanal-RESET + ld b,2 ;Zeitkonstante Sollwert TC=2 + ld a,53h ;Kanal STOP + out (c),a + in a,(c) ;Zeitkonstante Istwert holen + out (c),d ;Kanalsteuerwort laden + out (c),b ;Zeitkonstante laden Kanal START + cp b ;Zeitkonstante: Soll=Ist ? + call nz,FA3RET ;wenn nicht, call + + LD B,90H + LD C,C1K2 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,0A0H + LD C,C1K3 + IN A,(C) + CP B + CALL NZ,FA3RET + + EXX + LD A,1 + LD (MAWE),A + LD E,17H + EXX + +; Test der CTC-Kanaele mit Interrupt + + call INTINI ; INT-Initialisierung + +; CTC0, Kanal0 auf INT programmieren + + XOR A ;INT.VEC. fuer CTC0 = 00H + LD C,C0K0 + OUT (C),A ;INT-VEKTOR WIRD NUR EINMAL PROGRAMMIERT + CALL CIPR ;Interruptprogrammierung CTC + CALL Z,FA3RET ;bei Fehler Ausgabe + + LD C,C0K1 + CALL CIPR + CALL Z,FA3RET + + LD C,C0K2 + CALL CIPR + CALL Z,FA3RET + + LD C,C0K3 + CALL CIPR + CALL Z,FA3RET + + LD A,8 ;INT.VEC. fuer CTC1 = 08H + LD C,C1K0 + OUT (C),A ;Interruptvektor wird einmal ausgegeben + CALL CIPR + CALL Z,FA3RET + + LD C,C1K2 + CALL CIPR + CALL Z,FA3RET + + LD C,C1K3 + CALL CIPR + CALL Z,FA3RET + +CTCE ld a,IVRSYS + ld i,a ;Systemzustand regenerieren + + pop iy + pop ix + pop hl + pop de + pop bc + pop af + + RET ;END OF PROCEDURE + +;----------------------------------------------------------------------------- + +; SIO-Test +; Test des SIO durch Lesen des Interruptvektors (ohne Interrupt) +; Eingabe des Interruptvektors und anschliessendes Ruecklesen +; Test ist auch nur im Kanal B moeglich +; Ueberpruefen des Sende-INT + +SIO_: + push af + push bc + push de + push hl + push ix + push iy + + EXX + LD E,20H ;TEST-NR. LADEN + LD A,3 + LD (MAWE),A ;3 Werte ausgeben + EXX + + di ;weil INT.VEC. der SIO's manipuliert werden + +; Test SIO 0 Kanal B, durch lesen des INT.VEC (Sollwert IV=20H) + + ld c,S0BC + ld a,12h + out (c),a ;RR2 adressieren (INT.VEC.REG.) + ld b,20h ;INT.VEC. sollwert laden + in a,(c) ;INT.VEC. istwert holen + and 0f0h ;festen Vektorteil selektieren + cp b + call nz,FA3RET + +; Test SIO 1 + + LD A,11H + OUT (S1BC),A + XOR A + OUT (S1BC),A + LD A,12H ;Schreibregister 2 ansprechen + OUT (S1BC),A + LD A,50H ;Wert 50H eintragen + OUT (S1BC),A + IN A,(S1BC) ;Lesen des Leseregisters 0, damit aendern der + ; Daten + ;auf dem Datenbus + LD A,12H ;Leseregister 2 ansprechen + OUT (S1BC),A + LD C,S1AD ;erste SIO-Adresse fuer evt. Fehlerausgabe + ; eintragen + LD B,50H + IN A,(S1BC) + CP B ;Ist der Wert gleich dem ausgegebenen Wert? + CALL NZ,FA3RET ;Nein, Fehler bei Aufruf + +; Wiederholung gleicher Test, nur mit anderem Wert + + LD A,12H ;Schreibregister 2 adressieren + OUT (S1BC),A + LD A,30H + OUT (S1BC),A ;INT.VEC. SIO1 = 30H laden + IN A,(S1BC) ;Veraenderung auf dem Datenbus + LD A,12H ;Leseregister 2 adressieren + OUT (S1BC),A + LD C,S1AD + LD B,30H + IN A,(S1BC) ;Einlesen des Interruptvektors + CP B + CALL NZ,FA3RET + + EXX + LD A,1 + LD (MAWE),A + LD E,21H + EXX + +; Programmierung SIO0 und SIO1 als Sender (mit Interrupt) + + call INTINI ; INT-System-Initialisierung + +; SIO0 Kanal B und Interruptvektoren sind bereits programmiert + + LD B,CTC1 + LD E,S0AC + CALL SINIT ;SIO 0 Kanal A programmieren + + LD A,R1+COMM2 + OUT (S0BC),A + ld a,4 ;Kanal B-DI, status affects vector + OUT (S0BC),A + + LD A,R1+COMM2 + OUT (S0AC),A + LD A,2 ;nur EI fuer Sender Kanal A + OUT (S0AC),A + +; SIO0 Kanal A sendet 00 und warten auf INT 'Sendepuffer leer' + + LD C,S0AD + CALL SI0APR ;Zeichen senden und auf INT warten + CALL Z,FA3RET ;kein Interrupt in ausreichender Zeit + +; SIO0 Kanal B sendet 00 und warten auf INT 'Sendepuffer leer' + +; LD C,S0BD +; CALL SI0BPR +; CALL Z,FA3RET ;kein Interrupt in ausreichender Zeit + +; SIO 1 programmieren + + LD B,C1K2 + LD E,S1AC + CALL SINIT ;SIO 1 Kanal A progr. + + LD B,C0K0 + LD E,S1BC + CALL SINIT ;SIO 1 Kanal B progr. + + LD A,R1+COMM2 + OUT (S1BC),A + ld a,6 ;nur EI fuer Sender, status affects vector + OUT (S1BC),A + + LD A,R1+COMM2 + OUT (S1AC),A + LD A,2 ;nur EI fuer Sender + OUT (S1AC),A + +; SIO1 Kanal A sendet 00 und warten auf INT 'Sendepuffer leer' + + LD C,S1AD + CALL SI1APR + CALL Z,FA3RET ;kein Interrupt in ausreichender Zeit + +; SIO1 Kanal B sendet 00 und warten auf INT 'Sendepuffer leer' + + LD C,S1BD + CALL SI1BPR + CALL Z,FA3RET ;kein Interrupt in ausreichender Zeit + +SIOE: di ;System-status regenerieren + ld c,C1K1 ;CTC1 Kanal 1 programm. + ld a,57h + out (c),a + ld a,2 + out (c),a + + ld hl,INITAB ;Initialis. Tabelle SIO0B + ld c,S0BC + ld b,12 ;anzahl CW + otir + + ld a,IVRSYS + ld i,a ;I-Reg. regenerieren + + pop iy + pop ix + pop hl + pop de + pop bc + pop af + + ei + + RET ;END OF PROCEDURE + +;----------------------------------------------------------------------------- + +; FDC-Test + +FDC_: + push af + push bc + push de + push hl + push ix + push iy + + EXX + LD A,3 + LD (MAWE),A + LD E,23H ;Test-Nr. laden + EXX + +; Test des FDC +; Programmierung SPECIFY-Kommando und Ruecklesen + + DI + +; FDC-PIO programmieren ( PIO2B ) + + LD A,0CFH ;MODE 3 (Bitmode) + OUT (P2BC),A + LD A,10H ;Nur Bit4 Eingang + OUT (P2BC),A + LD A,3 ;DI + OUT (P2BC),A + + call FDCRES ; RESET-Impuls an FDC + + CALL FDCREA ;FDC bereit zur Datenuebernahme ? + JR NZ,FDCE ;FDC meldet keine Freigabe, damit keine weitere + ;Initialisierung moeglich + +; 1.Test mit FDC-Kommando 'SPECIFY' + + exx + ld e,24h + exx + + LD A,3 ;Kommando-Code 'SPECIFY' + OUT (DFDC),A + + CALL FDCREA ;FDC bereit zur Befehlsuebernahme? + JR NZ,FDCE + LD A,1FH ;SRT=1 (Step Rate Time = (16-1)ms = 15ms ) + OUT (DFDC),A ;HUT=0FH (Head Unload Time = 15*16ms=240ms ) + + CALL FDCREA + JR NZ,FDCE + LD A,55H ;HLT=2AH (Head Load Time = 2AH*2ms =84ms=54H ) + ;ND =1 (Non DMA-Mode) + OUT (DFDC),A + + call FDCREA ;FDC ready ? + jr nz,FDCE + +; 2. Test mit FDC-Kommando 'SENSE DRIVE STATUS' + + exx + ld e,25h + exx + + ld a,4 ;Kommando-Code + out (DFDC),a ;ins Datenregister des FDC schreiben + + call FDCREA ;FDC bereit zur Befehlsuebernahme? + jr nz,FDCE + ld a,05 ; Select-Byte=05 : HDS=1 , DS1=0 , DS0=1 + out (DFDC),a + + call FDCREE ;warten auf FDC bereit,lesen moeglich + jr nz,FDCE + + ; Statusregister ST3 lesen + + ld b,05 ;ST3 Sollwert + ld c,DFDC + in a,(c) ;ST3 lesen +I 2 + and 7 ;andere ausblenden +E 2 + cp b ;Soll=Ist? + call nz,FA3RET ;nein, dann call + +FDCE: call FDCRES ;FDC-Reset + + pop iy + pop ix + pop hl + pop de + pop bc + pop af + + EI + + RET ;END OF PROCEDURE + +;----------------------------------------------------------------------------- + +; DMA-Test +; Test des DMA durch Programmieren und Ruecklesen Statusbyte und +; Blocklaenge (ohne Interrupt) +; Test ohne INT: +; Der DMA transferiert 100 Byte von Adresse 0000 zur Adresse 3000h. +; Danach wird das Statusregister und das Zaehlerregister auf Sollwerte +; ueberprueft. +; Test mit INT: +; Wie vorher RAM-MOVE, danach Test ob ISR angesprungen wurde und +; Statusregister den Sollwert besitzt. +; Am Ende ueberprueft die CPU dem RAM-Transfer auf Richtigkeit. + +DMA_: + push af + push bc + push de + push hl + push ix + push iy + + EXX + LD E,26H ;Fehler-Nr. laden + ld a,3 + ld (MAWE),a ;bei Fehler, 3 Werte ausgeben + EXX + +; Zielpuffer loeschen + + ld hl,3000h + ld de,3001h + ld bc,7FFh + ld (hl),0 + ldir + +; DMA programmieren + + LD HL,DMAT +Z: def DMATE-DMAT + LD B,Z + LD C,DMAADR + OTIR + +; DMA-START move S=0000 D=3000 L=100 + + LD B,19H ;STATUS-Byte Sollwert + IN A,(C) ;Status-Byte lesen + AND 3BH ;Status-Byte maskieren + cp b ;Soll=Ist? + CALL NZ,FA3RET ;Wenn Statusbyte fehlerhaft, call + + LD C,DMAADR + LD B,0ffh ;zweiter Testwert wird eingetragen + IN A,(C) ;Zaehler low-Teil lesen + CP B ; =-1 ? + CALL NZ,FA3RET ; Fehler, wenn nicht + + LD C,DMAADR + LD B,0 ;dritter Testwert wird eingetragen + IN A,(C) ;Zaehler high-Teil lesen + CP B + CALL NZ,FA3RET + + EXX + LD A,1 + LD (MAWE),A + LD E,27H + EXX + +; Test des DMA mit Interrupt +; Programmieren eines Speichertransfers und warten auf den Interrupt + +; Zielpuffer loeschen + + ld hl,3000h + ld de,3001h + ld bc,7FFh + ld (hl),0 + ldir + + call INTINI ; INT-System-Initialisierung + + LD HL,DMATI +Z: def DMATIE-DMATI + LD B,Z + LD C,DMAADR + OTIR + +; DMA START : move S=0 D=3000H L=100H + + call ZEIT1 ;auf INT warten + ld a,(MISDMA) ;MERKER.INT.SERVICE holen + and a ; + call z,FA3RET ;if a=0 then call + + ld a,3 + ld (MAWE),a + + ld b,19h ;Statusbyte Sollwert + IN A,(C) ;Statusbyte lesen + AND 3BH ;Maskieren + cp b + CALL NZ,FA3RET + + LD A,0C3H + OUT (DMAADR),A ;partielles RESET an den DMA + +; Ueberpruefen ob DMA-Transfer o.k. + + EXX + LD A,3 + LD (MAWE),A + LD E,28H + EXX + + ld hl,0 ;Quell-Adr. + ld de,3000h ;Vergleichs-Adr. + ld bc,100h ;Daten-laenge + +dmalop ld a,(de) ;istwert holen + cpi ;vergleichen + inc de + push bc + dec hl ;hl auf aktuelle Solladr. stellen + ld b,(hl) ;Sollwert holen + call nz,FAHLR ;Transfererror + inc hl ;hl auf neue Adr. stellen + pop bc + jp pe,dmalop ;wenn BC>0 dann P/V-Flag=1 und Sprung + + +DMAE ld a,IVRSYS + ld i,a + + pop iy + pop ix + pop hl + pop de + pop bc + pop af + + RET ;END OF PROCEDURE + +;---------------------------------------------------------------------------- + +; DRAM-Test +; Es werden ein Test der Adressleitungen, der Datenleitungen, und der +; Datenhaltigkeit des Speichers durch das Durchschieben von 0 oder 1 +; durchgefuehrt. Bei auftretenden Fehlern wird der entsprechende Fehler- +; kode an das Terminal ausgegeben. Am Terminal werden ausserdem die +; Speicheradresse,der geschriebene und der rueckgelesene Wert angezeigt. +; Der Test erfolgt in zwei Teilen. Erster Teil: Einschalten des DRAM auf +; den Adressen 0000H-FFFFH und Test des Bereichs 8000h...ffffh. +; Zweiter Teil: move des bereiches 0000...7fffh nach 'oben' und Test des +; 'unteren' DRAM-Bereiches (0000...7fffh). Danach remove des Programms +; SMON und SA.DIAGS und verlassen des DRAM-Tests. + +DRAM_: + push af + push bc + push de + push hl + push ix + push iy + + EXX + LD A,3 + LD (MAWE),A + LD E,31H ;TEST-NR. LADEN + EXX + +; Initialisierung des DRAM auf den Adressen 0000H-FFFFH + + LD D,04H ;DRAM_SEL aktiv + LD B,00h ;1. Adresse ist 0000H + LD C,WEADP +W1EDR LD A,10H + OUT (C),D ;Einschalten des DRAM 0000-ffff + ADD A,B + LD B,A + JR NZ,W1EDR + +; Test der Datenleitungen des DRAM + + XOR A ;alle Bits auf 0 setzen + LD HL,RAMANF ;Anfangsadresse + LD DE,RAMANF+1 + LD BC,RAMLEN-1 + LD (HL),A ;0 oder 0FFH auf den ersten Speicherplatz + LDIR ;Wert wird in die Speicherzellen des DRAM + ; eingetragen + LD A,(HL) + CP B ;Testwert ist 0 + JP NZ,DRAMFE ;Fehlerausgabe wenn nicht 00 + LD A,0FFH ;Test mit 0FFH + LD HL,RAMANF + LD DE,RAMANF+1 + LD BC,RAMLEN-1 + LD (HL),A + LDIR + LD B,A ;Testwert eintragen + LD A,(HL) + CP B + JP NZ,DRAMFE ;Fehlerausgabe wenn nicht FFH + + EXX + LD E,30H + EXX + +; Test der Adressleitungen des dynamischen RAM + +; Der Speicher wird in Seiten zu je 256 Byte aufgeteilt. Die Bytes +; einer Seite werden fortlaufend nummeriert. Das erste Byte in +; einer Seite ist Gleich dem High-Teil der Speicheradresse dieses +; Bytes. Anschliessend werden die Seiten nacheinander getestet. +; War der Test der Datenleitungen fehlerfrei und stimmen die Werte +; einer Seite mit dem eingegebenen Wert nicht ueberein,dann ist +; die Ansteuerung fuer ein Adressbit dieser Seite fehlerhaft. + +; Laden des Musters + + ld hl,RAMANF + ld de,RAMLEN +ramta2 ld b,0 ;b:=256 + ld a,h ;Start-Nr. holen + +ramta3 ld (hl),a + inc a + inc hl + djnz ramta3 + + dec d + jr nz,ramta2 + +; Test ob Muster richtig geladen wurde + + ld hl,RAMANF + ld de,RAMLEN +ramta4 ld b,h ;Start-Nr. holen (Sollwert) + +ramta5 ld a,(hl) ;Istwert holen + cp b ;Soll=Ist? + jp nz,DRAMFE ;Fehlerausgabe wenn ungleich + inc b ;neue Sollwert-Byte-Nr. + inc hl ;neue Adresse + dec e + jr nz,ramta5 ;wenn Blockende nicht erreicht, jp + + dec d + jr nz,ramta4 ;wenn noch nicht alle Bloecke getestet, jp + + EXX + LD E,32H + EXX + +; Durchschieben von 0 und 1 + +; Durchschieben einer Null + + LD HL,RAMANF + ld de,RAMLEN + LD B,0FEH ;Start-Sollwert laden + +NZNLDR LD (HL),B + RLC B + + INC HL + DEC DE + LD A,D + OR E + JR NZ,NZNLDR + +; Test ob Muster o.k + + LD HL,RAMANF + LD DE,RAMLEN + LD B,0FEH ;Start-Sollwert laden + +TNZDR2 LD A,(HL) ;Istwert holen + CP B ;Soll-Istvergleich + JP NZ,DRAMFE ;Fehlerausgabe wenn ungleich + RLC B + + INC HL + DEC DE + LD A,D + OR E + JR NZ,TNZDR2 + + di + + ld hl,0 ;Quelladresse + ld de,8000h ;Zieladresse + ld bc,8000h ;laenge + ldir ;SMON u. SA.DIAGS move in 8000...ffff + +adr: def DRAM2+8000h + jp adr ;Ansprung der Testroutiene im oberen RAM + + +; DRAM-Test 2.Teil, Programm laeuft im Bereich ab 8000h +; und testet den Bereich 0000...7fffh. +;------------------------------------------------------ + +DRAM2: + exx + ld e,36h ;Fehlernummer laden + exx + +; Test der Datenleitungen des DRAM + + XOR A ;alle Bits auf 0 setzen + LD HL,0 ;Anfangsadresse + LD DE,1 + LD BC,7fffh ;laenge + LD (HL),A ;0 auf den ersten Speicherplatz + LDIR ;Wert wird in die Speicherzellen des DRAM + ; eingetragen + LD A,(HL) + CP B ;Testwert ist 0 + jr nz,dr2end + + LD A,0FFH ;Test mit 0FFH + LD HL,0 ;Startadresse RAM-Test + LD DE,1 ;Startadresse+1 + LD BC,7fffh ;laenge + LD (HL),A + LDIR + LD B,A ; B:= FFH + LD A,(HL) + CP B + jr nz,dr2end + + EXX + LD E,35H + EXX + +; Test der Adressleitungen des dynamischen RAM im Bereich 0000...7fffh + +; Der Speicher wird in Seiten zu je 256 Byte aufgeteilt. Die Bytes +; einer Seite werden fortlaufend nummeriert. Das erste Byte in +; einer Seite ist Gleich dem High-Teil der Speicheradresse dieses +; Bytes [ (hh00)=hh ]. Anschliessend werden die Seiten nacheinander +; getestet. War der Test der Datenleitungen fehlerfrei und stimmen die +; Werte einer Seite mit dem eingegebenen Wert nicht ueberein,dann ist +; die Ansteuerung fuer ein Adressbit dieses Bytes fehlerhaft. + +; Laden des Musters + + ld hl,0 ;Startadresse DRAM-Teil + ld d,80h ;Seitenzahl laden (1 Seite = 256 Byte) +dr210 ld b,0 ;b:=256 + ld a,h ;Seiten-Nr. holen (1.Byte in Seite=Seiten-Nr.) + +dr220 ld (hl),a ;DRAM auf einer Seite (256 Byte) fortlaufend + inc a ;nummerieren + inc hl + djnz dr220 + + dec d ;neue Seiten-Nr. + jr nz,dr210 ;wenn nicht die letzte, JP + +; Test ob Muster richtig geladen wurde + + ld hl,0 ;Startadresse DRAM-Teil + ld de,8000h ;Seitenzahl*Seitenlaenge laden +dr230 ld b,h ;Seiten-Nr. holen (Sollwert) + +dr240 ld a,(hl) ;Istwert holen + cp b ;Soll=Ist? + jr nz,dr2end + inc b ;neue Sollwert-Byte-Nr. + inc hl ;neue Adresse + dec e ;Bytezaehler + jr nz,dr240 ;wenn Seitenende nicht erreicht, jp + + dec d ;DEC Seitenzaehler + jr nz,dr230 ;wenn noch nicht alle Seiten getestet, jp + + EXX + LD E,37H + EXX + +; Durchschieben von 0 und 1 + +; Durchschieben einer Null + + LD HL,0 ;Anfang DRAM-Test + ld de,8000h + LD B,0FEH ;Start-Sollwert laden + +dr250 LD (HL),B + RLC B + + INC HL + DEC DE + LD A,D + OR E + JR nz,dr250 + +; Test ob Muster o.k + + LD HL,0 + LD DE,8000h ;DRAM-laenge + LD B,0FEH ;Start-Sollwert laden + +dr260 LD A,(HL) ;Istwert holen + CP B ;Soll-Istvergleich + jr nz,dr2end + RLC B + + INC HL + DEC DE + LD A,D + OR E + JR NZ,dr260 + + exx + ld e,0 ;Fehler-Nr.0, d.h. kein Fehler + exx + jr dr2end + +;Fehlerbehandlung + ;A = Istwert + ;B = Sollwert + ;E'= Fehlernummer + ;HL= Adresse + +dr2end: ex af,af' + exx ;Fehlerstatus in rr' speichern + ld a,e ;Fehler-Nr. in a retten + + ld hl,8000h ;Quelladresse + ld de,0000 ;Zieladresse + ld bc,8000h ;laenge + ldir ;SMON u. SA.DIAGS remove to 0000...7fff + + jp DRAMW + ;DRAM-Bereich 8000...ffffh +;----------------------------------------------------------------------------- + ;DRAM-Bereich 0000...7fffh +DRAMW: + or a ;wenn Fehler-Nr.=0, dann kein Fehler + jr z,DRAME ;wenn kein Fehler, JP + + ld e,a + exx ;Fehlerstatus remove + ex af,af' + ei +DRAMFE: call FAHLR ;Fehlerausgabe + +DRAME: ei + pop iy + pop ix + pop hl + pop de + pop bc + pop af + + RET ;END OF PROCEDURE + + eject + +; Unterprogramme fuer die Testroutinen +;-------------------------------------- + +; Programmierung PIO im Ausgabemode (ohne Interrupt) +; Testwert in B, rueckgelesener Wert in A, Portadresse in C + +PTAUS LD B,A ;Testwert in B retten + LD A,0FH ;Ausgabemode + OUT (C),A + LD A,3 ;Interrupt sperren + OUT (C),A + DEC C ;Adresse Datenport einstellen + LD A,B ;Testwert fuer die Ausgabe holen + OUT (C),A + IN A,(S0BD) ;Datenbus veraendern + IN A,(C) + CP B ;Vergleich mit dem Testwert + RET + +; Programmierung CTC-Kanal als Zeitgeber ohne Interrupt +; INPUT's: +; C - Kanaladresse +; B - Zeitkonstante +; Die Zeitkonstante sollte groesser als 7 +; gewaehlt werden, damit das Zaehlerregister +; nicht ueberlaeuft. +; OUTPUT's: +; A - gelesener Wert des Zaehlerregisters +; CF- CF=1:Kanal zaehlt, Test o.k. +; CF=0:Kanal zaehlt nicht, ERROR + +CZPR: LD A,7 ;DI, Timer, 1/16, no CLK, TC folgt, Kanal-Reset + OUT (C),A + LD A,B ;Zeitkonstante laden + OUT (C),A + CALL ZEIT2 ;0.025 ms warten + IN A,(C) ;Zaehlerregister lesen + CP B ;wenn Kanal zaehlt, dann CF=1 sonst CF=0 + PUSH AF ;CF retten + LD A,3 + OUT (C),A ;Kanal stop + POP AF + RET + + +; Programmierung CTC-Kanal als Zeitgeber mit Interrupt. +; Nach 0.04ms ist INT zu erwarten. +; Maximal wird 1ms auf den Interrupt gewartet. +; In der ISR wird HL entsprechend des ausgewaehlten Kanals veraendert. +; INPUT's: +; C - Kanaladresse + +; OUTPUT's: +; ZF- ZF=1: ISR wurde nicht angesprungen, ERROR +; ZF=0: ISR wurde angesprungen, Test o.k. + +CIPR: LD A,87H ;EI, Timer, 1/16, no CLK, TC folgt, Kanal-Reset + OUT (C),A + LD B,10 ;Zeitkonstante TC=10 (ti=10*16*250ns= 40960 ns) + LD HL,NULBYT ;Inhalt von HL ist 0 + LD A,0FFH ;fuer ISR mit Wert ungleich 0 laden + OUT (C),B ;TC laden, Kanal START (INT nach ca. 0.04ms) + CALL ZEIT1 ;ca. 1 ms warten + LD A,(HL) ;in der ISR wird HL veraendert + AND A + RET + +; Programmierung des SIO fuer Zeichen senden (mit Interrupt). +; Portadresse steht in C, Warten auf den Interrupt, nach bestimmter +; Zeit wird abgebrochen. +; In der ISR wird HL entsprechend ausgewaehltem SIO-Kanal veraendert. + +SI0APR + XOR A + OUT (C),A + CALL ZEIT + CALL ZEIT + CALL SIORES + LD A,3 + OUT (CTC1),A + LD A,(MIS0KA) + AND A + RET + +SI0BPR + XOR A + OUT (C),A ;Datenbyte 00 senden + CALL ZEIT ;auf INT warten + CALL ZEIT + INC C ;Out-Adr. auf control-port stellen + LD A,R1+COMM2 ;WR1 adressieren + OUT (C),A + XOR A ;Kanal DI + OUT (C),A + LD A,38H ;RETI an SIO 0 + OUT (S0AC),A + DEC C ;Datenadr. einstellen + LD A,(MIS0KB) ;Flagbyte fuer INT holen + AND A ;if A=0 then ZF=1 else ZF=0 + RET + +SI1APR + XOR A + OUT (C),A + CALL ZEIT + CALL ZEIT + CALL SIORES + LD A,3 + OUT (CTC1+2),A + LD A,(MIS1KA) + AND A + RET + +SI1BPR + XOR A + OUT (C),A + CALL ZEIT + CALL ZEIT + CALL SIORES + LD A,3 + OUT (CTC0),A + LD A,(MIS1KA) + AND A + RET + + +SIORES + INC C + LD A,11H + OUT (C),A + XOR A + OUT (C),A + LD A,30H + OUT (C),A + LD A,38H + OUT (C),A + LD A,18H + OUT (C),A + DEC C + RET + + +; INT-System-Initialisierung +; - I-Register laden +; - INT-Vektor-Tabelle bereitstellen +; - INT-Merker initialisieren + +INTINI DI + IM 2 + + LD HL,IVTAB ;INT.VEC.TAB. Quell-Adresse + LD DE,_end ;HIGH-ADRESS SA.DIAGS laden + INC D ;INT.VEC.TAB. Ziel-Adresse berechnen + LD E,0 ;modulo 256 + LD A,D + LD I,A ;I-Reg. laden + LD BC,42H ;Anzahl der Werte + LDIR ;INT-Vektor-Tabelle umladen + + XOR A + LD HL,M1CISR ;Merker fuer ISR loeschen +Z: def MAWE-M1CISR + LD B,Z ;Anzahl der Merkzellen +INTIN1 LD (HL),A + INC HL + DJNZ INTIN1 + + EI + + RET + +; Interruptserviceroutinen der CTC-Kanaele + +ISC0K0 LD HL,MIC0K0 +ICRET LD (HL),A ;INT-Flag setzen (A>0) + LD A,3 ;CTC-Kanal DI, STOP + OUT (C),A + EI + RETI + +ISC0K1 LD HL,MIC0K1 + JR ICRET + +ISC0K2 LD HL,MIC0K2 + JR ICRET + +ISC0K3 LD HL,MIC0K3 + JR ICRET + +ISC1K0 LD HL,MIC1K0 + JR ICRET + +ISC1K2 LD HL,MIC1K2 + JR ICRET + +ISC1K3 LD HL,MIC1K3 + JR ICRET + + +; Interruptserviceroutinen der SIO-Kanaele + +ISS0KA + PUSH AF + LD A,0FFH + LD (MIS0KA),A +ISRET + INC C + LD A,28H + OUT (C),A + DEC C + POP AF + EI + RETI + +ISS0KB + PUSH AF + LD A,0FFH + LD (MIS0KB),A + JR ISRET + +ISS1KA + PUSH AF + LD A,0FFH + LD (MIS1KA),A + JR ISRET + +ISS1KB + PUSH AF + LD A,0FFH + LD (MIS1KB),A + JR ISRET + + +; Interruptserviceroutine DMA + +ISDMA push af + LD A,0A3H + OUT (DMAADR),A ;alle INT reset + ld a,0ffh + ld (MISDMA),a ;INT-MERKER setzen + pop af + EI + RETI + +; Zeitschleifen + +ZEIT LD HL,0FFFFH ;Zeitkonstante fuer ca. 250ms +DECZL DEC L + JR NZ,DECZL + DEC H + JR NZ,DECZL + RET + +ZEIT1 LD D,0FFH ;Zeitkonstante fuer ca. 1ms +DECDL DEC D + JR NZ,DECDL + RET + +ZEIT2 LD D,6 ;Zeitkonstante fuer ca. 0.025ms +DECD1 DEC D + JR NZ,DECD1 + RET + +; Unterprogramm SIO-Programmierung + +SINIT + LD C,B + LD A,57H + OUT (C),A + LD A,2 + OUT (C),A + LD HL,INITAB + LD B,8 + LD C,E + OTIR + RET + +; Unterprogramm fuer die Fehlerausgabe an das Terminal fuer drei, zwei +; oder einen Wert entsprechend in MAWE eingetragener Anzahl +; Uebergabewerte sind: Register B enthaelt den Testwert +; Register C enthaelt die Portadresse +; Akkumulator enthaelt den gelesenen Wert + +FA3RET PUSH AF + PUSH BC + PUSH DE + PUSH HL + call ETROLL ;errortable roll down + LD D,A ;rueckgelesenen Wert in speichern + CALL AUSERR ;Ausschrift Error, Nummer entsprechend E + ld (iy+1),0 ;Eintrag in Fehlertabelle: Adr.-High + ld (iy+2),c ;Eintrag in fehlertabelle: Adr.-Low + LD A,C ;Portadresse ist erste Ausgabe +AUS2WE CALL HEXCON ;Umwandlung in Hexadezimalzahl + OUT (S0BD),A ;Ausgabe an das Terminal + CALL SIOREA ;Ist SIO fertig? + LD A,C + OUT (S0BD),A + CALL SIOREA + LD A,(MAWE) ;Anzahl der auszugebenden Werte dekrementieren + DEC A + JR Z,FEAEND ;bei 0, Sprung an das Ende der Fehlerausgabe + ld (iy+3),b ;Eintrag in Fehlertabelle: Sollwert + LD C,B ;zu lesenden Wert in speichern + CALL AUSSP ;Ausgabe von Space + LD A,C + CALL HEXCON + OUT (S0BD),A ;Ausgabe zu lesender Wert + CALL SIOREA + LD A,C + OUT (S0BD),A + CALL SIOREA + CALL AUSSP + LD A,D ;Ruecklesen gelesener Wert + ld (iy+4),a ;Eintrag in Fehlertabelle: Istwert + CALL HEXCON + OUT (S0BD),A ;Ausgabe gelesener Wert + CALL SIOREA + LD A,C + OUT (S0BD),A + CALL SIOREA +FEAEND LD HL,ENDZEI + LD B,ANZEZ +NAEZEI LD A,(HL) + OUT (S0BD),A ;Ausgaben am Ende einer Zeile +WEZEI IN A,(S0BC) + BIT 2,A + JR Z,WEZEI + INC HL + CALL ZEIT1 + DJNZ NAEZEI + POP HL + POP DE + POP BC + POP AF + RET + +; Unterprogramm fuer die Ausgabe ERROR und der Fehlernummer + +AUSERR EXX + LD HL,ADRERR + LD C,S0BD + LD B,ANAUSE ;Anzahl der Werte + +WAUSE LD A,(HL) + OUT (C),A + CALL SIOREA + INC HL + DJNZ WAUSE + + ld (iy+0),e ;Eintrag in Felertabelle: Fehl.-Nr. + LD A,E + CALL HEXCON + OUT (S0BD),A + CALL SIOREA + LD A,C + OUT (S0BD),A + CALL SIOREA + CALL AUSSP + CALL AUSSP + CALL AUSSP + LD H,0FFH + EXX + RET + +; Unterprogramm fuer die Ausgabe von HL + +FAHLR PUSH AF + PUSH BC + PUSH DE + PUSH HL + call ETROLL ;error-code-table roll down + LD D,A ;rueckgelesenen Wert retten + CALL AUSERR + ld (iy+1),h ;Eintrag in Fehlertabelle: Adr.-High + LD A,H + CALL HEXCON + OUT (S0BD),A + CALL SIOREA + LD A,C + OUT (S0BD),A + CALL SIOREA + ld (iy+2),l ;Eintrag in Fehlertabelle: Adr.-Low + LD A,L + JP AUS2WE + +; UP zur Forbereitung eines Eintrags in die Fehlercodetabelle +; Es koennen von den aufgetretenden Fehlern die letzten 200 Fehler +; gespeichert werden. Ein Fehlereintrag belegt 5 Byte. + +ETROLL: push bc + push de + push hl + + ld hl,ertab+994 + ld de,ertab+999 + ld bc,995 + lddr ;Fehlertabelle 5Byte weiter rollen + ;der aelteste Eintrag wird ueberrollt + ld hl,ertab + ld de,ertab+1 + ld bc,4 + ld (hl),0 + ldir ;letzten Eintrag loeschen + + ld hl,(errcnt) + inc hl ;Fehlerzaehler inc + ld (errcnt),hl + + ld iy,ertab + + pop hl + pop de + pop bc + + ret + +; Unterprogramm fuer die Abfrage der SIO-Fertigmeldung + +SIOREA IN A,(S0BC) + BIT 2,A + JR Z,SIOREA + RET + +; Unterprogramm fuer die Konvertierung eines Bytes in zwei ASCII-Zeichen + +HEXCON LD C,A + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,ORUP0 + ADD A,7 +ORUP0 ADD A,30H + PUSH AF + LD A,C + AND 0FH + CP 0AH + JR C,ORUP + ADD A,7 +ORUP ADD A,30H + LD C,A + POP AF + RET + +; Unterprogramm fuer die Ausgabe von SPACE + +AUSSP LD A,20H +AUSSP1 OUT (S0BD),A + CALL SIOREA + RET + +; Unterprogramm fuer die Abfrage der Fertigmeldung des FDC + +FDCREE: ld b,0c0h ;RQM=1 , DIO=1 FDC bereit zum lesezugriff + jr FDCRE + +FDCREA: LD B,80H ;RQM=1 , DIO=0 FDC bereit zum schreibzugr. +FDCRE ld c,MSRFDC + ld HL,0 ;Initialisierung einer Zeit +FDCR1 IN A,(C) ;Einlesen Hauptstatusregister + ld d,a ;Wert in D retten + AND 0C0H + CP B + JR Z,TW1FDC ;wenn FDC bereit, JP + dec hl + ld a,h + or l + jr nz,FDCR1 ;Wenn Zeit noch nicht um, JP + ld a,d ;zuletzt eingelesenen Wert holen (Istwert) + CALL FA3RET ;Fehlerausgabe FDC not ready + inc l ;ZF:= 0 + +TW1FDC RET + +; UP: RESET-Impuls an FDC + +FDCRES: LD A,8FH + OUT (P2BD),A ;RESET an den FDC + call ZEIT2 ;ca. 0.025 ms warten + ld a,0fh + out (P2BD),a ;RESET inactiv + call ZEIT2 ;ca. 0.025 ms warten + ret + + eject + +; Vereinbarungen + +; Portadressen + +CTC0 equ 8 +C0K0 equ CTC0 +C0K1 equ CTC0+1 +C0K2 equ CTC0+2 +C0K3 equ CTC0+3 + +CTC1 equ 02CH +C1K0 equ CTC1 +C1K1 equ CTC1+1 +C1K2 equ CTC1+2 +C1K3 equ CTC1+3 + +SIO0 equ 024H +S0AD equ SIO0 +S0AC equ SIO0+1 +S0BD equ SIO0+2 +S0BC equ SIO0+3 + +SIO1 equ 028H +S1AD equ SIO1 +S1AC equ SIO1+1 +S1BD equ SIO1+2 +S1BC equ SIO1+3 + +PIO0 equ 0CH +P0AD equ PIO0 +P0AC equ PIO0+1 +P0BD equ PIO0+2 +P0BC equ PIO0+3 + +PIO1 equ 018H +P1AD equ PIO1 +P1AC equ PIO1+1 +P1BD equ PIO1+2 +P1BC equ PIO1+3 + +PIO2 equ 1CH +P2AD equ PIO2 +P2AC equ PIO2+1 +P2BD equ PIO2+2 +P2BC equ PIO2+3 + +DMAADR equ 3CH + +FDC equ 20H +MSRFDC equ FDC +DFDC equ FDC+1 + + begin 1 + +; Vereinbarungen fuer die SIO-Programmierung + +R0 equ 0 +R1 equ 1 +R2 equ 2 +R3 equ 3 +R4 equ 4 +R5 equ 5 +R6 equ 6 +R7 equ 7 +; +COMM6 equ 30H ; FEHLER RUECKSETZEN +COMM3 equ 18H ; KANAL RUECKSETZEN +COMM2 equ 10H ; RUECKSETZEN EXT./STAT. INTERRUPT +NOPRTY equ 0 ; PARITAETSPRUEFUNG AUSSCHALTEN +S2 equ 0CH ; 2 STOP/BITS JE ZEICHEN +C16 equ 40H ; *16 +RENABLE equ 1 +B8 equ 0C0H +XENABLE equ 8 +T8 equ 60H +PDAVCT equ 18H +SAVECT equ 04H +XMTRIE equ 02H +C32 equ 80H + +; Initialisierungstabelle fuer den SIO + +INITAB db COMM6 ;Fehler ruecksetzen + db COMM3 ;Kanal-Reset + db R4+COMM2 + db NOPRTY+S2+C32 + db R3+COMM2 + db RENABLE+B8 + db R5+COMM2 + db XENABLE+T8 + + db R2+COMM2 + db 20h ;INT.VEC. + db R1+COMM2 + db 1CH ;INT.MOD 3 / STATUS AFFECTS VECTOR / TR-DI + + +; DMA - programmierung + +; Definition der Schreibregister WR0...WR6 + +WR0 equ 0 +WR1 equ 4 ;DMA-Port A +WR2 equ 0 ;DMA-Port B +WR3 equ 80h +WR4 equ 81h +WR5 equ 82h +WR6 equ 83h + +; Initialisierungstabelle fuer den DMA ohne INT + +DMAT db 0C3H ;DMA-reset + + db WR0+7DH ;Transfer A--->B / A-Adr. u. Laenge folgen + dw 0000H ;Anfangsadresse DMA-Port A + dw 00FFH ;Datenlaenge-1 + db 0CFH ;LOAD Adresse A + db WR1+10H ;Port A: MEMRQ / INC + + db WR4+2CH ;Blocktransfer / B-Adr. folgt + dw 3000H ;Anfangsadresse DMA-Port B + db 0CFH ;LOAD Adresse B + db WR2+10H ;Port B: MEMRQ / INC + + db WR5+00H ;Stop bei Blockende / nur/CE / RDY low activ + db 0BBH ;Lesemaske folgt + db 7 ;Lesemaske fuer STATUSBYTE / Bytezaehler l/h + db 87H ;DMA-START +DMATE + +; Initialisierungstabelle fuer den DMA mit INT. + +DMATI db 0C3H ;DMA-reset + + db WR0+7DH ;Transfer A--->B / A-Adr. u. Laenge folgen + dw 0000H ;Anfangsadresse DMA-Port A + dw 00FFH ;Datenlaenge-1 + db 0CFH ;LOAD Adresse A + db WR1+10H ;Port A: MEMRQ / INC + + db WR4+3CH ;Blocktransfer / B-Adr. folgt / INTCW folgt + dw 3000H ;Anfangsadresse DMA-Port B + db 12H ;INTCW: INT.VEC. folgt / INT nach Blockende + db 1CH ;INT.VEC. DMA (NO STATUS AFFECTS VECTOR) + db 0CFH ;LOAD Adresse B + db WR2+10H ;Port B: MEMRQ / INC + + db WR5+00H ;Stop bei Blockende / nur/CE / RDY low activ + db 0ABH ;DMA-EI + db 0BFH ;READ STATUSBYTE + db 87H ;DMA-START +DMATIE + + +; Initialisierungswerte fuer die ISR-Tabelle + +IVRSYS equ 0FH ;I-Register UDOS-SYSTEM + +IVTAB dw ISC0K0 ;IVTAB+00h + dw ISC0K1 + dw ISC0K2 + dw ISC0K3 + + dw ISC1K0 ;IVTAB+08h + dw 0 + dw ISC1K2 + dw ISC1K3 + + dw 0 ;IVTAB+10h + dw 0 + + dw 0 + dw 0 + + dw 0 ;IVTAB+18h + dw 0 + + dw ISDMA ;IVTAB+1Ch + dw 0 + + dw ISS0KB ;IVTAB+20h + dw 0 + dw 0 + dw 0 + + dw ISS0KA ;IVTAB+28h + dw 0 + dw 0 + dw 0 + + dw ISS1KB ;IVTAB+30h + dw 0 + dw 0 + dw 0 + + dw ISS1KA ;IVTAB+38h + dw 0 + dw 0 + dw 0 + + dw ISDMA ;IVTAB+40h + +; Vereinbarungen fuer die Merkzellen + +NULBYT db 0 +M1CISR: +MIC0K0 db 0 +MIC0K1 db 0 +MIC0K2 db 0 +MIC0K3 db 0 +MIC1K0 db 0 +MIC1K2 db 0 +MIC1K3 db 0 +MIP0KA db 0 +MIP0KB db 0 +MIP1KB db 0 +MIP2KA db 0 +MIP2KB db 0 +MIS0KA db 0 +MIS0KB db 0 +MIS1KA db 0 +MIS1KB db 0 +MISDMA db 0 + +MAWE db 0 ;Merker fuer Anzahl der Auszugebenen Werte +errcnt dw 0 ;Fehlerzaehler + +; Ausschrift bei Fehler + +ADRERR text '*** ERROR ' +ANAUSE equ 10 + +; Ausgaben am Ende der Zeile + +ENDZEI db 0AH + db 0DH +ANZEZ equ 2 + +; Adressen fuer MEMORY-BANK-SELECT-LOGIK + +WEADP equ 0 ;out-adress +RFF equ 4 ;Speicherbank aktivieren + + +; PROM-CRC Kontrollspeicheradressen + +CRCEP0 equ 1FF8H +NCEP0 equ 1FFAH +CRCEP1 equ 1FFCH +NCEP1 equ 1FFEH + +RAMANF equ 8000h ;ANFANG DRAM-TEST +RAMLEN equ 8000h ;laenge des zu testenden DRAM-Bereichs + + end +E 1 diff --git a/WEGA/contrib/eigentest/udosprom.o b/WEGA/contrib/eigentest/udosprom.o new file mode 100644 index 0000000..e027644 Binary files /dev/null and b/WEGA/contrib/eigentest/udosprom.o differ diff --git a/firmware/MON8/FDINIT.S b/firmware/MON8/FDINIT.S new file mode 100644 index 0000000..6341fea --- /dev/null +++ b/firmware/MON8/FDINIT.S @@ -0,0 +1,87 @@ +; ------------------------------------------ +; ! INITIALISIERUNG FDC-CONTROLLER P8000 ! +; ------------------------------------------ +; +; +U880M EQU 1 ; =0 --> Verwendung im RAM + ; =1 --> Verwendung im U880-Softwaremonitor +; +; Initialisierung des PIO2 und FDC auf der U880-Karte P8000 +; Belegung von Port A und B des PIO2: +; A0 -- Ausgang -- Motor LW 0 an -- /LCK0 +; A1 -- Ausgang -- Motor LW 1 an -- /LCK1 +; A2 -- Ausgang -- Motor LW 2 an -- /LCK2 +; A3 -- Ausgang -- Motor LW 3 an -- /LCK3 +; A4 -- Ausgang -- Takt -- T +; A5 -- Ausgang -- Head Load -- HL +; A6 -- Ausgang -- Terminal Count -- TC +; A7 -- Eingang -- Spann.- oder Bedienerreset -- RES +; +; B0 -- Ausgang -- Select LW0 -- /DS0 +; B1 -- Ausgang -- Select LW1 -- /DS1 +; B2 -- Ausgang -- Select LW2 -- /DS2 +; B3 -- Ausgang -- Select LW3 -- /DS3 +; B4 -- Eingang -- Interrupt vom FDC -- INT +; B5 -- Ausgang -- Praecompensation 1 -- PR1 +; B6 -- Ausgang -- Praecompensation 2 -- PR2 +; B7 -- Ausgang -- Reset FDC -- RFDC +; +; + COND U880M +; Adressen der Interruptserviceroutinen + LD HL,ISRPB ;Adresse PIO2(FDC)-Interruptserviceroutine + LD (IP2KB),HL +; + LD HL,ISRCT1 ;Adresse CTC-Interruptserviceroutine + LD (INTAB+2),HL +; + LD HL,ISRDMA ;Adresse DMA-Interruptserviceroutine + LD (INTABD),HL + ENDC +; + COND 1-U880M +; Initialisierung DSEL + LD A,80H + LD (DSEL),A + ENDC + LD A,5 + LD (FDCONF),A +; Initialisierung DMA + + LD BC,10 + LD HL,DMAT + LD DE,DMALSW + LDIR + COND 1-U880M + RET + ENDC +; + JR FL1END +; +; +;DMA-Tabelle fuer die Uebernahme/Uebergabe der Daten vom/zum FDC +DMAT DEFB 79H ;Datenlaenge und Datenadresse ist einzutragen + DEFB 0 ;Daten-Adresse Low-Teil + DEFB 0 ;Daten-Adresse High-Teil + DEFB 0 ;Datenlaenge Low-Teil + DEFB 0 ;Datenlaenge High-Teil + DEFB 0CFH ;Laden der Adresse und Laenge + DEFB 5 ;Richtungsumkehr programmieren + DEFB 0CFH ;Laden Richtungsumkehr + DEFB 0ABH ;Interruptfreigabe fuer DMA + DEFB 87H ;DMA aktivieren +; +FL1END +;Adressen der benutzten peripheren Schaltkreise +PIO2AD EQU 01CH +PIO2AC EQU 01DH +PIO2BD EQU 01EH +PIO2BC EQU 01FH +MSR EQU 020H +DATREG EQU 021H +CTC EQU 08H +; +;Adressen der Interruptserviceroutinen +INTABP EQU 0F1AH +INTAB EQU 0F00H +INTABD EQU 0F1CH diff --git a/firmware/MON8/FLOPPY.S b/firmware/MON8/FLOPPY.S new file mode 100644 index 0000000..aeb08a8 --- /dev/null +++ b/firmware/MON8/FLOPPY.S @@ -0,0 +1,893 @@ +*P 84 +;****************************************************************************** +; +; Floppydisk Treiber fuer P8000 +; +;****************************************************************************** + +DMA EQU 1 +UDOS EQU 1 +U880SM EQU 1 + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;ENTRY FLOPPY TREIBER + +DISK +FLOPPY LD HL,(DSKVSL) ;ist Parametervektor eingetragen ? + LD A,H + OR L + JR NZ,FLOPPY ;Treiber besetzt --> warten ! + LD (DSKVSL),IY ;Treiber ist frei --> Parametervektor + ;eintragen und damit als "besetzt" setzen + CALL FLP ;CALL-Aufruf des Treibers +WAIT BIT 0,(IY+1) ;zeitgeteilter Verkehr ? +WAIT1 RET NZ + BIT 7,(IY+10) ;Operation fertig ? + JR WAIT1 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;RETURN FUER WARTEN AUF INTERRUPT + +SFLPI POP HL ;IN HL ADR WO PROGRAMM NACH + LD (INTPNT),HL ;INTERRUPT WEITER LAEUFT + EI ;falls Programm als ISR des PIO2 laeuft + ;kann neuer INT vom PIO2 erst nach RETI + RET ;erfolgen + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Auswertung UDOS-Requestcode +FLP + COND 1-U880SM +; Adressen der Interruptserviceroutinen + LD HL,ISRPB ; Initialisierung der Interruptserviceroutinen + LD (INTABP),HL ; wenn FLOPPY-Teil als externer Treiber arbeitet. + LD HL,ISRCT1 + LD (INTAB+2),HL + LD HL,ISRDMA + LD (INTABD),HL + ENDC +; + LD A,(IY+1) ;Request Code + AND 0FEH ;Loeschen der Abarbeitungsart + CP 0AH ;Read Binary Request ? + JR Z,TYPTEST + CP 0EH ;Write Binary Request ? + JR Z,TYPTEST + CP 50H ;Format + JR Z,TYPTEST + LD A,0C1H ;'Invalid Request' +ERRRTN CALL OPFIN + LD H,(IY+9) + LD L,(IY+8) + LD A,H + OR L + JR Z,FEHL1 + JP (HL) ;Jump to Error Return Address + +FEHL1 BIT 0,(IY+1) + RET Z ;Ruecksprung, wenn einfacher Request + LD H,(IY+7) + LD L,(IY+6) + JP (HL) ;Jump to Completion Return Address + +ERRC2 LD A,0C2H + JR ERRRTN + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Floppy-Typ testen und FDC einstellen + +TYPTEST LD C,(IY+11) ;Drive/Sector + LD A,C + RLA + JR C,ERRC2 + LD HL,FDCONF + BIT 6,C ;0 = Drive 0,1 + JR Z,TYP1 + INC HL +TYP1 LD A,(HL) + BIT 5,C ;0 = Drive 0,2 + JR Z,TYP2 + RRCA ;Verschiebung fuer Drive 1 und 3 + RRCA + RRCA + RRCA +TYP2 AND 0FH + JR Z,ERRC2 ;Ist Laufwerktyp in FDCONF eingetragen? + CP 8 ;Ja, testen. + JR NC,ERRC2 + LD HL,FDTYP ;Nein, weiter testen. + CP (HL) ;altes = neues Format ? + JR Z,TYPOK + + LD (HL),A ;neuen Typ einstellen + LD HL,TYPTAB ;Treiber auf Typ einstellen + LD DE,11 + LD B,A + JR TYP4 +TYP3 ADD HL,DE +TYP4 DJNZ TYP3 ;solange addieren, bis :=0, dann ist die + ;richtige Tabelle eingestellt + LD C,2 + LD DE,FDCTAB+1 + LDIR + INC DE + INC DE ;veraenderliche Werte ueberspringen + LD C,8 + LDIR + + DI ;besser DI + IN A,(PIO2AD) ;Takt einstellen + SET 4,A ;5" = 4MHz Takt einstellen + BIT 1,(HL) + JR Z,TYP5 + RES 4,A ;8" = 8MHz Takt einstellen +TYP5 OUT (PIO2AD),A + LDI ;CMD Byte eintragen + COND 1-DMA + LD HL,FDCTAB+2 + SET 0,(HL) ;NON-DMA setzen + ENDC + LD BC,0303H ;Specify; Werte aus Tabelle eintragen + CALL FDCKMD + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Drive, Track und Sektor uebernehmen + +TYPOK LD HL,0202H ;Setzen der Fehlerzaehler + LD (WSCTR),HL ;WSCTR und WTCTR + LD A,10 + LD (CRCCTR),A ;fuer CRC (Data Transfer) Errors (C6) + XOR A + LD (IY+10),A ;Loeschen Completion Code + LD A,(IY+12) ;Ueberpruefen Spurnummer + LD (SPURNR),A ;Spurnummer in Speicherzelle eintragen + LD HL,TRK + CP (HL) + LD A,0C5H + JR NC,ERR + LD A,(IY+11) ;Uebernehmen Sektor/Laufwerk + LD C,A + AND 60H ;Drive Maske + RLCA + RLCA + RLCA + LD B,A + LD A,C + LD C,0 ;Head 0 + AND 1FH ;Sektor Maske + LD HL,FDCTAB+6 ;EOT + CP (HL) ;Sektor >= EOT --> Head 1 + JR C,HEADOK + SUB (HL) ;Sektornummer einmal subtrahieren, wegen Doppelkopflaufwerk + CP (HL) ;Sektornummer zu gross ? + JR NC,HERRC4 + LD HL,CMD + BIT 7,(HL) ;Head (Side) 1 zugelassen ? + JR NZ,HEAD1 +HERRC4 LD A,0C4H +ERR JP ERRRTN + +HEAD1 SET 2,B ;Head 1 setzen in Drivenummer + INC C +HEADOK INC A ;1. PHYSISCHER SEKTOR = 1 + LD (FDCTAB+4),A ;Sektornummer eintragen + LD A,C + LD (FDCTAB+3),A ;Head eintragen + LD A,B + LD (FDCTAB+1),A ;Drive und Head select + AND 03H ;Laufwerk-Nummer in + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;DRIVE SELEKT UND BEREITSCHAFT PRUEFEN + + CALL READY ;in A Drive + JP Z,ERRC2 ;Drive not ready" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Laufwerksanwahl ist ok. --> Pruefen der Kopfposition + + LD HL,CURT0 ;Tabelle der Kopfpositionen (nach RESET mit + ;0FFH beschrieben) + ;in DE noch Laufwerk von READY + ADD HL,DE ;zeigt auf die Kopfposition des angef. LW + LD A,(HL) + INC A ;war Kopf schon mal positioniert ? + LD (HL),D ;beim 8272 muss sich nicht die Kopfposition + ;gemerkt werden, nur Unterscheidung ob + ;schon mal positioniert + JR NZ,HDMOV ;JA + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Kopf des angewaehlten LW auf Spur 00 fahren + +TR00 LD BC,0207H ;Recalibrate Command + CALL FDCKMD + CALL SFLPI + +;*************** Warten auf Interrupt ******************* + + LD BC,0207H ;2.Recalibrate falls mehr als 77 Spuren + CALL FDCKMD + CALL SFLPI + +;*************** Warten auf Interrupt ******************* + + ;auf Fehlerauswertung wird hier verzichtet + ;sie werden spaeter auch noch gemerkt + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;In HDMOV wird der Kopf des angewaehlten LW auf die richtige +;Spur gefahren + +HDMOV LD A,(SPURNR) ;Track Nummer + LD HL,CMD + BIT 0,(HL) ;Doppelstep ? + JR Z,HDMOV1 + ADD A,A ;*2 +HDMOV1 LD (FDCTAB+2),A ;Spur in Kommandotabelle + + LD HL,(PR1) ;Praekompensation ein/aus + DI + LD C,PIO2BD + IN B,(C) + RES 5,B + RES 6,B + CP L ;1. Praekompensation + JR C,CHKP + SET 5,B + CP H ;2. Praekompensation + JR C,CHKP + SET 6,B +CHKP OUT (C),B + + LD BC,030FH ;Kommandotabelle fuer "SEEK" + CALL FDCKMD + CALL SFLPI + +;*************** Warten auf Interrupt ******************* + + ;auf Fehlerauswertung wird hier verzichtet + ;sie werden spaeter auch noch gemerkt + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;SEKTOR(EN) LESEN SCHREIBEN + + COND 1-DMA +DTRANS LD A,(SPURNR) ;Spur + LD (FDCTAB+2),A + LD H,(IY+5) + LD L,(IY+4) ;Datenlaenge + LD A,H + OR L + JP Z,OPCOMP + PUSH DE + EX DE,HL + LD L,(IY+2) ;Adresse + LD H,(IY+3) + LD A,3 ;Interrupt PIO2 aus, Lesen/Schreiben erfolgt + OUT (PIO2BC),A ;ohne Interrupt, Abfrage von INT + LD B,9 + LD A,(CMD) + AND 0F0H + OR 5 ;Write + LD C,A + BIT 2,(IY+1) ;Lesen oder Schreiben ? + JR NZ,WR + BIT 4,(IY+1) ;Format ? + JR NZ,FORMAT + +;DATEN EINLESEN + + INC C ;Read + CALL FDCKMD ;Ausfuehrung +LREAD IN A,(MSR) + RLCA + JR NC,LREAD ;warten auf Zeichen + RLCA + RLCA + JR NC,RWEND ;1= NON DMA MODE --> 0= Ende Uebertragung + INI ;REG C = DATREG in FDCKMD gesetzt + DEC DE + LD A,D + OR E + JR NZ,LREAD + JR RWEND + +;DATEN SCHREIBEN + +FORMAT PUSH HL ;Format + LD HL,(FDCTAB+5) + LD (FDCTAB+2),HL + LD HL,(GPL2) + LD H,0E5H + LD (FDCTAB+4),HL + LD A,H + LD (FDTYP),A ;NACH FORMAT IMMER TYP NEU EINSTELLEN + POP HL + LD B,6 + SET 3,C ;Format + RES 7,C ;MT nicht bei Format + +WR CALL FDCKMD +LWRITE IN A,(MSR) + RLCA + JR NC,LWRITE + RLCA + RLCA + JR NC,RWEND ;FDC bereits fertig + OUTI + DEC DE + LD A,D + OR E + JR NZ,LWRITE + +;ENDE LESEN / SCHREIBEN + +RWEND IN A,(PIO2AD) + SET 6,A ;TC auf 1;Abbruch R/W + OUT (PIO2AD),A + RES 6,A ;TC wieder auf 0 + OUT (PIO2AD),A + POP DE + LD A,83H ;Interrupt PIO2 erlauben + OUT (PIO2BC),A + CALL SFLPI + ENDC + + COND DMA +DTRANS LD A,(SPURNR) ;Spur eintragen + LD (FDCTAB+2),A + LD H,(IY+3) + LD L,(IY+2) ;Datenadresse + LD (DMALSW+1),HL ;in DMA-Tabelle + LD H,(IY+5) + LD L,(IY+4) ; Datenlaenge + LD A,H + OR L + JP Z,OPCOMP + DEC HL + LD (DMALSW+3),HL ;Datenlaenge-1 in DMA-Tabelle + LD B,9 ;Kommandokode fuer Schreiben + LD A,(CMD) + AND 0F0H + OR 05H + LD C,A + BIT 2,(IY+1) ;Abfrage Schreiben oder Lesen + JR NZ,AUSDMA + BIT 4,(IY+1) ;FORMAT ? + JR Z,DREAD + LD HL,(FDCTAB+5) + LD (FDCTAB+2),HL + LD HL,(GPL2) + LD H,0E5H + LD (FDCTAB+4),HL + LD A,H + LD (FDTYP),A ;NACH FORMAT IMMER TYP NEU EINSTELLEN + LD B,6 + SET 3,C ;Format + RES 7,C + JR AUSDMA + +DREAD INC C ;Read + LD A,1 ;Festlegung der Datenrichtung DMA <--- FDC + LD (DMALSW+6),A + LD A,7DH + LD (DMALSW),A + +AUSDMA PUSH BC + LD HL,DMALSW + LD BC,0A00H+DMAADR + OTIR + LD A,5 ;Festlegung der Datenrichtung DMA ---> FDC + LD (DMALSW+6),A ;Wert fuer Schreiben wieder eintragen + LD A,79H + LD (DMALSW),A ;Wert fuer Schreiben wieder eintragen + + POP BC + CALL FDCKMD + CALL SFLPI + + ENDC + +;********** Warten auf Interrupt ************ + + CALL RDRES ;Result einlesen + ;in A (RESUL) + AND 0C0H ;IC & SE + JR Z,OPCOMP ;kein Fehler + + ;Fehler bei der Datenuebertragung + LD A,(RESUL+1) ;Statusregister 1 + BIT 1,A ;Schreibschutz ? + JR NZ,WRPROT + AND 30H ;CRC-Fehler im ID-Feld oder Overrun ? + JR NZ,BADCRC + LD A,(RESUL+2) + BIT 5,A ;CRC Fehler im Datenfeld ? + JR NZ,BADCRC + AND 12H + JR NZ,WRNGTR + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;DISK FEHLER + +;Sector Address Errors (C4) + +WRNGSEC LD HL,(SECERR) + INC HL + LD (SECERR),HL + LD HL,WSCTR + LD A,0C4H ;Sektor Address Error + JR WRNG1 + +;CRC-Fehler (C6) + +BADCRC LD HL,(CRCERR) + INC HL + LD (CRCERR),HL + LD HL,CRCCTR + LD A,0C6H ;CRC-Fehler +WRNG1 DEC (HL) + JP NZ,DTRANS ;neuer Versuch + JR OPFIN + +;Seek-Errors (C5) + +WRNGTR LD HL,(TRKERR) + INC HL + LD (TRKERR),HL + LD HL,WTCTR + DEC (HL) + JP NZ,TR00 ;neuer Versuch + LD A,0C5H ;Seek Error + JR OPFIN + +;Schreibschutz (C3) + +WRPROT LD A,0C3H + JR OPFIN + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Abschluss-Routine + +OPCOMP LD A,80H ;Completion Code = 80H (Transfer ok.) +OPFIN LD (IY+10),A + AND 40H ;Error wenn bit 6 = 1 + JR Z,OPFIN1 + XOR A + LD (IY+4),A ;0 Bytes uebertragen + LD (IY+5),A +OPFIN1 LD H,A ;A = 0 + LD L,A + LD (DSKVSL),HL ;Treiber frei + LD (DMASK),A ;LW Maske loeschen + RET ;ab hier beginnt die Zeit fuer Motor aus + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;KOMMANDOAUSFUEHRUNG DES FDC +;Vor dem Einschreiben von Bytes in den FDC muss im Main Status Register +;RQM=1 und DIO=0 sein. +;Vor dem Auslesen von Bytes aus dem FDC muss im Main Status Register +;RQM=1 und DIO=1 sein. +;Programmierung des FDC + +FDCKMD DI + PUSH HL + LD HL,FDCTAB + LD (HL),C ;Kommando eintragen +FDCKM1 LD C,DATREG +RQMDIO IN A,(MSR) ;Lesen des Main Status Register + AND 0C0H ;nur RQM & DIO + CP 080H ;RQM=1 & DIO=0 ? + JR NZ,RQMDIO ;Warten + OUTI ;Ausgabe + PUSH HL ;mindestens 12 Mikrosek. zwischen Zugriff + POP HL ;Daten- und Hauptstatusregister einhalten + PUSH HL + POP HL + JR NZ,FDCKM1 + POP HL + RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;RESULT VOM FDC LESEN + +RDRES LD HL,RESUL ;Resultatstabelle + LD C,DATREG +RDRES1 IN A,(MSR) ;Lesen Main Status Register + CPL + AND 0C0H + JR NZ,RDRES1 ;warten auf READ-Bereitschaft des FDC + INI ;FDC --> CPU + LD B,6 ;Zeit von 12 Mikrosek. einhalten + DJNZ $ + IN A,(MSR) + BIT 4,A ;FDC noch in einer Kommandodurchfuehrung + JR NZ,RDRES1 ;ja (noch Resultatsbytes zu lesen) + LD A,(RESUL) ;Statusregister 0 + RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;INTERRUPTSERVICE-ROUTINE FUER PIO2/B-INTERRUPTS +;zeigt den Beginn der "Result Phase" an + +ISRPB PUSH HL + PUSH AF + PUSH BC + PUSH IY + LD IY,(DSKVSL) + IN A,(MSR) + BIT 4,A ;FDC besetzt ? + JR NZ,RUECK ;Ja -> Transfer Kommando + + ;ermitteln, ob Recalibrate oder Seek Int + LD BC,0108H ;FDC-Kommando "Sense Interrupt Status" + CALL FDCKMD ;Ausfuehrung des Kommandos + CALL RDRES ;Lesen des Resultats + ;in A (RESUL) = Statusregister 0 + AND 0E0H ;IC & SE (Interrupt und Seek End) + CP 0C0H ;Ready Line Changed ? + JR Z,SOFORT ;Ja -> keine Reaktion +RUECK LD HL,RTNPTR + PUSH HL ;Eintragen der Rueckkehradresse + LD HL,(INTPNT) + JP (HL) ;weiter bei eingetragener Adresse + +RTNPTR BIT 7,(IY+10) ;Operation fertig + JR NZ,CCOK ;ja +SOFORT POP IY + JR INTEND + +CCOK BIT 6,(IY+10) + JR Z,KEINF ;Durchfuehrung fehlerfrei + LD H,(IY+9) + LD L,(IY+8) ;Error Return Address + LD A,H + OR L ;=0 ? + JR NZ,ERRRET +KEINF BIT 0,(IY+1) ;zeitgeteilt ? + JR Z,SOFORT ;nein + LD H,(IY+7) + LD L,(IY+6) ;Completion Return Address +ERRRET POP IY + POP BC + POP AF + EX (SP),HL + JR IRET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;ISR CTC fuer Motor aus + +ISRCT1 PUSH HL + PUSH AF + PUSH BC + LD C,01H ;Maske fuer LW 0 + LD HL,TTAB ;Motorzeitentabelle +CLOOP LD A,(DMASK) + AND C + JR NZ,CLOOPE ;fuer aktuelles LW Motorzeit nicht decrement + IN A,(PIO2AD) ;PIO-Port fuer Motorsteuerung + LD B,A + AND C ;Motor LW n an ? + JR NZ,CLOOPE ;nein + DEC (HL) ;Zeit herunterzaehlen + JR NZ,CLOOPE ;noch nicht Null + LD A,B + OR C ;MOTORBIT = 1 SETZEN + LD B,A + CPL + AND 0FH + JR NZ,CLOOP1 + LD A,03H ;kein Motor an, CTC Reset + OUT (CTC0+1),A + RES 5,B ;Kopf ab +CLOOP1 LD A,B + OUT (PIO2AD),A + IN A,(PIO2BD) + OR C + OUT (PIO2BD),A ;Select mit dem Motor abschalten +CLOOPE INC HL ;naechste Motorzeit + SLA C ;Maske auf naechstes LW + BIT 4,C ;alle LW abgearbeitet ? + JR Z,CLOOP +INTEND POP BC + POP AF + POP HL + COND 1-DMA +ISRDMA + ENDC +IRET EI ;EI fuer ISR PIO2 + RETI + + COND DMA +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Interruptserviceroutine fuer den DMA +;enthaelt nur DMA ruecksetzen +; +ISRDMA PUSH AF + LD A,0A3H ;DMA Interrupt ruecksetzen + OUT (DMAADR),A + POP AF + JR IRET + ENDC + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;READY +;READY prueft die Bereitschaft des angeforderten LW mit Hilfe des +;FDC-Kommandos "Sense Drive Status" und schaltet gegebenenfalls +;den Motor ein. +;A enthaelt Laufwerksnummer + +READY LD E,A + LD D,0 + INC A ;LW Maske aus LW Nr. bilden + LD B,7FH +RDY0 RLC B + DEC A + JR NZ,RDY0 + LD A,B + CPL + LD (DMASK),A ;LW Maske speichen + COND UDOS + LD HL,DSEL + AND (HL) + JR NZ,RDY1 + BIT 7,(HL) ;INITIALISIERUNG ? + RES 7,(HL) + RET Z ;nein +RDY1 XOR (HL) ;Drive in DSEL erst einmal not ready setzen + LD (HL),A + ENDC + + PUSH HL + LD HL,TTAB + ADD HL,DE + LD (HL),100 ;2 Sekunden bis Motor aus (ab OPFIN) + + DI ;besser DI + IN A,(PIO2BD) + OR 0FH ;Select altes Laufwerk ruecksetzen + AND B + OUT (PIO2BD),A ;Ausgabe des "Drive select" an PIO/B + IN A,(PIO2AD) + AND B ;Motor LW an + SET 5,A ;Kopf an + OUT (PIO2AD),A + LD A,0A5H ;CTCINT fuer Motor aus programmieren + OUT (CTC0+1),A + LD A,255 ;16,3ms + OUT (CTC0+1),A + LD HL,01500H ;Warteschleife +RDY2 LD BC,0204H ;Kommando "Sense Drive Status" + CALL FDCKMD + PUSH HL + CALL RDRES + POP HL + EI + BIT 5,A + JR NZ,RDY3 + DEC HL + LD A,H + OR L + JR NZ,RDY2 ;not ready +RDY3 POP HL + COND UDOS + RET Z ;LW nicht bereit + LD A,(DMASK) + OR (HL) ;bereites LW in DSEL eintragen + LD (HL),A + ENDC + RET ;mit NZ + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;Floppy-Typ und Format Tabellen + + COND U880SM + + ORG 0B24H + + ENDC + +TYPTAB +;Standard FM 77 Spuren 26 Sektoren a 128 Byte (Typ 1) + + DEFB 6FH ;10ms, 240ms + DEFB 28H ;40ms (8MHz) + DEFB 0 + DEFB 26 + DEFB 07H + DEFB 128 + DEFB -1 + DEFB -1 + DEFB 1BH + DEFB 77 + DEFB 02H ;MT=0, MFM=0, SK=0, 8"=1, DSTEP=0 + +;Mini MFM 40 Spuren 16 Sektoren a 256 Byte (Typ 2) + + DEFB 9FH ;14ms, 480ms + DEFB 14H ;40ms (4MHz) + DEFB 01H + DEFB 16 + DEFB 22H + DEFB -1 + DEFB 20 + DEFB 29 + DEFB 32H + DEFB 40 + DEFB 40H ;MT=0, MFM=1, SK=0, 8"=0, DSTEP=0 + +;Mini MFM 40 Spuren auf 80 Spur Drive 16 Sektoren a 256 Byte (Typ 3) + + DEFB 0BFH ;10ms (bei NEC nur 3ms erforderlich), 480ms + DEFB 12H ;36ms (fuer NEC Laufwerk) + ;fuer K5600.20 nur 12ms (Kopfberuhigungzeit) + ;erforderlich (DEFB 06H) + DEFB 01H + DEFB 16 + DEFB 22H + DEFB -1 + DEFB 35 + DEFB 0FFH + DEFB 32H + DEFB 40 + DEFB 41H ;MT=0, MFM=1, SK=0, 8"=0, DSTEP=1 + +;Mini MFM 80 Spuren 16 Sektoren a 256 Byte (Typ 4) + + DEFB 0BFH ;SRT=10ms, HUT=480ms + DEFB 12H ;HLT=36ms + DEFB 01H ;N + DEFB 16 ;EOT + DEFB 22H ;GPL + DEFB -1 ;DTL + DEFB 35 ;PR 1 + DEFB 0FFH ;PR 2 + DEFB 32H + DEFB 80 ;Anzahl der Spuren + DEFB 40H ;MT=0, MFM=1, SK=0, 8"=0, DSTEP=0 + +;Mini MFM Doppelkopf 80 Spuren 2*16 Sektoren a 256 Byte (Typ 5) + + DEFB 0BFH ;10ms, 480ms + DEFB 12H ;36ms + DEFB 01H + DEFB 16 + DEFB 22H + DEFB -1 + DEFB 0FFH + DEFB 0FFH + DEFB 32H + DEFB 80 + DEFB 0C0H ;MT=1, MFM=1, SK=0, 8"=0, DSTEP=0 + +;Mini MFM Doppelkopf 80 Spuren 2*9 Sektoren a 512 Byte (Typ 6) + + DEFB 0EFH ;4ms, 480ms + DEFB 08H ;16ms + DEFB 02H + DEFB 9 + DEFB 1BH + DEFB -1 + DEFB -1 + DEFB -1 + DEFB 54H + DEFB 80 + DEFB 0C0H ;MT=1, MFM=1, SK=0, 8"=0, DSTEP=0 + +;Mini MFM Doppelkopf 80 Spuren 2*5 Sektoren a 1024 bYTE (Typ 7) + + DEFB 0EFH ;4ms, 480ms + DEFB 08H ;16ms + DEFB 03H + DEFB 5 + DEFB 35H + DEFB -1 + DEFB -1 + DEFB -1 + DEFB 74H + DEFB 80 + DEFB 0C0H ;MT=1, MFM=1, SK=0, 8"=0, DSTEP=0 + +;Mini MFM Doppelkopf 80 Spuren 2*15 Sektoren a 512 bYTE (Typ 8) + +;DEFB 0DFH ;3ms, 240ms +;DEFB 10H ;16ms (8MHz) +;DEFB 02H +;DEFB 15 +;DEFB 1BH +;DEFB -1 +;DEFB -1 +;DEFB -1 +;DEFB 54H +;DEFB 80 +;DEFB 0C1H ;MT=1, MFM=1, SK=0, 8"=1, DSTEP=0 + +;Mini MFM Doppelkopf 80 Spuren 2*8 Sektoren a 1024 Byte (Typ 9) + +;DEFB 0DFH ;3ms, 240ms +;DEFB 10H ;16ms (8MHz) +;DEFB 03H +;DEFB 8 +;DEFB 35H +;DEFB -1 +;DEFB -1 +;DEFB -1 +;DEFB 74H +;DEFB 80 +;DEFB 0C1H ;MT=1, MFM=1, SK=0, 8"=1, DSTEP=0 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;VEREINBARUNGEN +;Kommandotabelle fuer den FDC + + COND 1-U880SM + +FDCTAB DEFB 00H ;Command Codes (MT,MFM,SK & Read/Write) + DEFB 00H ;Bit 2,1,0: HDS,DS1,DS0 + DEFB 0 ;Spur + DEFB 00H ;Kopf + DEFB 00H ;Record + DEFB 01H ;256 Byte/Sector + DEFB 16 ;EOT (last sector on track) + DEFB 0EH ;GPL (Length of gap 3) + DEFB 0FFH ;DTL (N=0 --> Data length) + +PR1 DEFB 35 +PR2 DEFB 45 +GPL2 DEFB 32H +TRK DEFB 80 +CMD DEFB 40H + +;DMA-Tabelle fuer die Uebernahme/Uebergabe der Daten vom/zum FDC +DMALSW DEFB 79H ;Datenlaenge und Datenadresse ist einzutragen + DEFB 0 ;Daten-Adresse Low-Teil + DEFB 0 ;Daten-Adresse High-Teil + DEFB 0 ;Datenlaenge Low-Teil + DEFB 0 ;Datenlaenge High-Teil + DEFB 0CFH ;Laden der Adresse und Laenge + DEFB 5 ;Richtungsumkehr programmieren + DEFB 0CFH ;Laden Richtungsumkehr + DEFB 0ABH ;Interruptfreigabe fuer DMA + DEFB 87H ;DMA aktivieren + +;Resultats-Tabelle der FDC-Kommandos + +RESUL DEFS 7 + +;Motorzeittabelle + +TTAB DEFB 0 ;Motor 0 aus + DEFB 0 ;Motor 1 aus + DEFB 0 ;Motor 2 aus + DEFB 0 ;Motor 3 aus + +;Fehlerzaehler +WSCTR DEFB 0 ;Fehlerzaehler Sektor +WTCTR DEFB 0 ;Fehlerzaehler Spur +CRCCTR DEFB 0 ;CRC-Fehlerzaehler + +DSKVSL DEFW 0 ;Disk Semaphor +INTPNT DEFW 0 ;Adresse fuer Programmfortsetzung +DMASK DEFB 0 ;LW Maske fuer Motor aus und ... +FDTYP DEFB 0 +CURT0 DEFB -1 ;Tabelle der Kopfpositionen der Laufwerke + DEFB -1 + DEFB -1 +SPURNR DEFB 0 + DEFB -1 +FDCONF DEFW 0 +SECERR DEFW 0 +CRCERR DEFW 0 +TRKERR DEFW 0 +PIO2AD EQU 1CH +PIO2AC EQU 1DH +PIO2BD EQU 1EH +PIO2BC EQU 1FH +MSR EQU 20H +DATREG EQU 21H +DMAADR EQU 3CH +CTC0 EQU 08 + ENDC + diff --git a/firmware/MON8/FW8ASMLINK b/firmware/MON8/FW8ASMLINK new file mode 100644 index 0000000..06419d3 --- /dev/null +++ b/firmware/MON8/FW8ASMLINK @@ -0,0 +1,6 @@ +V +ASM U880SM (A +ASM U880EIG (A +ASM K.MON8 (A +PLINK U880EIG U880SM K.MON8 (N=U880FIRMWARE) +B diff --git a/firmware/MON8/INA.S b/firmware/MON8/INA.S new file mode 100644 index 0000000..feae5fc --- /dev/null +++ b/firmware/MON8/INA.S @@ -0,0 +1,91 @@ +; +GETA +; +; EINGABE-ROUTINE UEBER SIO-KANAL B +; ZEICHEN STEHT NACH EINGABE IM AKKUMULATOR +; MIT INTERRUPT +; + CALL PRESS +;JR Z,GETA + RET Z + CALL GETAZ + RET +; +PRESS PUSH HL + PUSH BC + LD HL,APEIN + LD B,A + LD A,(APAUS) + CP (HL) + LD A,B + POP BC + POP HL + RET + +GETAZ PUSH HL + LD A,(APAUS) + CALL PUFADR + AND A + LD (APAUS),A + LD A,(HL) + POP HL + RET +; +PUFADR PUSH DE + LD D,0 + LD E,A + LD HL,0F00H ; ANFANGSADRESSE DES PUFFERS IST FESTGELEGT + INC A + JR NZ,PUFA1 ; NIEDERWERTIGER TEIL NUR VON E0H BIS FFH + LD A,0E0H +PUFA1 ADD HL,DE + POP DE + RET +; + +ISRZET PUSH AF + PUSH HL + IN A,(S0BD) + LD HL,MCSQ + BIT 0,(HL) + JR NZ,OHNCSQ + CP 13H + JR Z,CTS + CP 11H + JR Z,CTQ + CP 1BH + JR Z,ESCEIN +OHNCSQ PUSH AF + LD A,(APEIN) + CALL PUFADR + LD (APEIN),A + POP AF + LD (HL),A ; ZEICHEN WIRD IN DEN RINGPUFFER EINGETRAGEN +ENDIZ LD A,20H + OUT (S0BC),A ; FREIGABE FUER DEN SIO (INTERRUPT NAECHSTES ZEICHEN) + POP HL +IBRT1 POP AF + EI + RETI +; +CTS SET 6,(HL) + JR ENDIZ +; +CTQ RES 6,(HL) + JR ENDIZ +; +ESCEIN RES 4,(HL) + JR ENDIZ +; +; ISR SONDERFALL DES EMPFANGS +; +ISRSET PUSH AF + LD A,1 + OUT (S0BC),A + IN A,(S0BC) + LD A,30H ; RUECKSETZEN VON FEHLERN + OUT (S0BC),A + IN A,(S0BD) + JR IBRT1 +; +; diff --git a/firmware/MON8/K.MON8.S b/firmware/MON8/K.MON8.S new file mode 100644 index 0000000..bc10447 --- /dev/null +++ b/firmware/MON8/K.MON8.S @@ -0,0 +1,763 @@ +*H P8000 U880-FIRMWARE 3.0 +;****************************************************************************** +;* * +;* * +;* P8000 - SOFTWARE * +;* * +;* Entwicklerdokumentation * +;* * +;* Betriebssystem UDOS * +;* * +;* Programm: K.MON8 * +;* * +;* Version: 3.1 * +;* * +;* Bearbeiter: U. Oefler, M. Weber * +;* * +;* Datum: 05.07.1989 * +;* * +;* * +;****************************************************************************** +; +;************************************************************** +; +; P8000 KOPPELSOFTWARE +; GRUNDMODUL +; VERSION: 3.0 +; +;************************************************************** + +;GLOBAL SAVE S0BT +;GLOBAL ERROR UEB16 +;GLOBAL LODNET SNDNET WAIT STATUS WAITACK +;GLOBAL LODDAT SNDDAT SNDACK +;EXTERNAL LOAD SEND +;EXTERNAL ACTFLG +;EXTERNAL BLKRD BLKWT BLKFO +;EXTERNAL RBLOCK WBLOCK + + + ORG 0F000H +; + +KOPSO + + LD BC,LETZT-KOPSO + LD DE,0F000H + LD HL,0DB00H + LDIR + + JP ENTRY +ENTRY: + +; Ausschalten von EPROM und Einschalten von RAM + + LD BC,0D000H + LD A,4 + OUT (C),A + + POP AF ; ZERO-Flag zurueck von der Abfrage + JR NZ,NURX + + XOR A + OUT (P0BD),A ;START U8000 + LD B,80H + DJNZ $ + LD A,80H + OUT (P0BD),A ;RESET-U8000 HIGH (FUER ZUSATZ) + LD B,80H + DJNZ $ + XOR A + OUT (P0BD),A ;START U8000 (ENDGUELTIG) + JP DEBUG + +NURX + DI + + +ANF1 + LD HL,ISRPIO + LD (IP0KB),HL ;ISR-ADR IN TABELLE FUER PIO + + LD HL,ITABS0 ;RETTEN SIO 0 KANAL B ISR-ADR. + LD DE,SAVE + LD BC,32 + LDIR + + LD HL,IP1KA + LD DE,SAVEPIO + LD BC,4 + LDIR + + IN A,(P0BD) ;STAND U8000-BIT RETTEN + PUSH AF + + LD HL,BUFFER ;INITIALISIEREN RINGPUFFER + LD (HL),0 + LD DE,BUFFER+1 + LD BC,BUFEND-BUFFER-1 + LDIR + + IN A,(P0AD) ;SCHEINEINGABE DAMIT PORT FREI ! + + POP AF + BIT 7,A + JR Z,MMT ;U8000 BEREITS AKTIV + + XOR A ;RESET-U8000 AUF LOW + OUT (P0BD),A ;D.H. 16 BIT-TEIL START + LD B,80H + DJNZ $ + LD A,80H + OUT (P0BD),A;RESET U8000 (FUER ZUSATZ) + LD B,80H + DJNZ $ + XOR A + OUT (P0BD),A;START U8000 (ENDGUELTIG) + +; Die folgenden acht Programmzeilen sind am 13.12.1988 +; zusaetzlich aufgenommen worden, damit keine Fehler +; im Eigentest entstehen. + + IN A,(P0BD) + BIT 6,A + JR Z,HWTEST + + LD HL,8000H +ZEIT DEC HL + LD A,H + OR L + JR NZ,ZEIT + +;HARDWARETEST-KOPPELSCHNITTSTELLE + +HWTEST + LD HL,0FFFFH ;MAX. ZEIT +W8000 IN A,(P0BD) + BIT 6,A + JR NZ,TEST + DEC HL + LD A,H + OR L + JR NZ,W8000 + LD HL,MERR ;U8000 ARBEITET NICHT + JR TERR1 + +TEST: LD C,2AH ;STATUS FUER + LD A,0AAH + CALL OUTP16 ;1.DATENMUSTER + JR Z,TERR + LD C,0AH + CALL WAITACK + JR NZ,TERR + IN A,(P0AD) + CP 0AAH + JR NZ,TERR + + LD A,55H + LD C,A ;STATUS FUER + CALL OUTP16 ;2.DATENMUSTER + JR Z,TERR + LD C,15H + CALL WAITACK + JR NZ,TERR + IN A,(P0AD) + CP 55H + JR NZ,TERR + +; engueltige Programmierung des Koppel-PIO's mit Interrupt + + LD HL,KBC0R + LD C,P0BC + LD B,4 + OTIR + + LD A,1 ;KENNZEICHEN DAS VON PROM GESTARTET WURDE !!! + LD C,0 ;STATUS + CALL OUTP16 ;DATENMUSTER + JR NZ,WREQ ;OK + +TERR: LD HL,MTERR ;FEHLER BEI HARDWARETEST +TERR1: EI + CALL OUTAS + JR QUITRST + +MMT + LD A,83H + OUT (P0BC),A ; PIO-Interrupt erlauben + + EI + LD HL,MMLDG + CALL OUTAS + DI + +WREQ: LD HL,SNEUTAB ;SIO ISR-ADR. NEU INITIALISIEREN + LD DE,ITABS0 + LD BC,32 + LDIR + + LD HL,ISP1KA + LD (IP1KA),HL + LD HL,ISP1KB + LD (IP1KB),HL + + + EI + +LOOP: CALL UEB16 ;TEST OB INT-WERTE VON SIO'S ANLIEGEN + LD HL,STATUS + LD A,(HL) + OR A + JR Z,LOOP + BIT 0,A + JR NZ,QUIT + BIT 7,A + JR Z,LOOP + +QUITRST: + LD A,80H ;U8000-RESET + OUT (P0BD),A + JR REEX + +QUIT: + CALL SNDACK + LD B,80H ;WARTEZEIT FUER U8000 KINB !!! + DJNZ $ + LD HL,BASP + CALL OUTAS + LD B,10 + DJNZ $ +REEX: + DI + LD A,11H + OUT (S0BC),A + LD A,1CH + OUT (S0BC),A + LD HL,SAVE ;ALTE ISR-WERTE SIO 0 KANAL B + LD DE,ITABS0 ;ZURUECKSPEICHERN + LD BC,32 + LDIR + LD A,3 + OUT (P0BC),A ;PIO-INT AUS + EI + JP DEBUG ;EXIT ZU UDOS + +;;;;;;;;;;;;;;;;;;;;;;;;;; + +UEB16: + LD IX,RB_S0A + LD C,83H ;STATUS + STB + INT8000 + CALL UEBSIO + LD IX,RB_S0B + LD C,85H + CALL UEBSIO + LD IX,RB_S1A + LD C,87H + CALL UEBSIO + LD IX,RB_S1B + LD C,89H + +UEBSIO: DI + BIT 1,(IX+73H) ;WAR E_INT + RES 1,(IX+73H) + JR Z,OUTBUF ;NEIN + SET 6,C ;E_INT SETZEN + JR INT1 + +OUTBUF LD A,(IX+71H) + CP (IX+72H) ;POINTER GLEICH + JR Z,S_INT + CALL INCPOI ;NEIN + LD (IX+71H),A ;LESEPOINTER+1 UND SPEICHERN + LD A,(HL) ;ZEICHEN HOLEN + JR INT2 + +S_INT: + BIT 2,(IX+73H) ;WAR S_INT + RES 2,(IX+73H) + JR Z,T_INT + LD A,C + OR 60H ;S_INT SETZEN + LD C,A + LD A,(IX+75H) ;RR1 UEBERGEBEN + JR INT2 + +T_INT: + BIT 0,(IX+73H) ;WAR T_INT + RES 0,(IX+73H) + JR Z,P1KA ;NEIN + SET 5,C ;T_INT SETZEN +INT1: LD A,(IX+74H) ;RR0 UEBERGEBEN +INT2: DI + LD B,A ;DATEN RETTEN + OUT (P16A),A ;DATENBYTE + XOR A + OUT (P16B),A + LD A,C +INT3: OUT (P16B),A + +WAT16: EI + NOP + DI + IN A,(P0BD) + BIT 6,A ;WARTEN BIS DATEN PER INT8000 + JR Z,WAT16 ;ABGEHOLT WURDEN + LD A,(FLAG) ;WURDEN AUSGABEDATEN DURCH + OR A ;KINB UEBERSCHRIEBEN ? + JR NZ,NEUAUS ;JA: DATEN NEU ANLEGEN OHNE INT8000 +EXIT: EI + RET + +P1KA LD HL,STAT2 + BIT 0,(HL) + JR Z,P1KB + RES 0,(HL) + LD A,0 + LD C,8BH + JR INT2 + +P1KB BIT 1,(HL) + JR Z,EXIT + RES 1,(HL) + LD A,0 + LD C,0ABH + JR INT2 + +NEUAUS: XOR A + LD (FLAG),A ;FLAG RUECKSETZEN + RES 0,C ;INT8000 AUSSCHALTEN + LD A,B + JR INT2 ;DATEN UND STATUS NEU ANLEGEN + +;;;;;;;;;;;;;;;;;;;;;;;;; +SNDACK: LD A,ACK + LD C,91H + JR INT2 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + +OUTP16: ;AUSGABE AN 16-BIT PORT + ;ZEICHEN IN A + ;STATUS IN REG. C + ;OHNE INTERRUPT + + LD HL,0FFFFH ;MAX. ZEIT + LD B,A +WTKP IN A,(P0BD) ;PORT FREI? + BIT 6,A + JR Z,DETI ;NEIN + LD A,B ;JA + OUT (P16A),A ;DATENBYTE-AUSGABE + XOR A + OUT (P16B),A + LD A,C ;STATUS UND + OR 80H ;STB-FLANKE OHNE INTERRUPT + OUT (P16B),A ;BEACHTE IM DI + RET ;OKAY --> NZ-RETURN + +DETI DEC HL + LD A,H + OR L + JR NZ,WTKP + RET ;FEHLER --> Z-RETURN + +;;;;;;; + +WAITACK: ;WARTEN AUF ACK (FUER TEST - HARDWARE) + ;ACK-CODE IN REG. C + LD HL,0FFFFH ;MAX. WARTEZEIT +WTL IN A,(P0BD) + BIT 5,A + JR Z,NXTIT ;KEIN ZEICHEN + AND 1FH ;STATUS FILTERN + CP C ;ACK VOM U8000 + RET Z ;OKAY --> ZERO-RET +NZRET OR 0FFH + RET ;SONST --> NZ-RET +NXTIT DEC HL + LD A,H + OR L + JR NZ,WTL + JR NZRET + +;;;;;;;;;;;;;;;;;;;;;;;;; + +ISRPIO: PUSH AF + PUSH BC + PUSH DE + PUSH HL + PUSH IX + IN A,(P0BD) ;STATUS + BIT 5,A ;DATEN DA + JR Z,ISREND ;NEIN --> FEHLER + + AND 16H ;STATUS HERAUSFILTERN + BIT 4,A + JR NZ,REQUEST ;REQUESTANFORDERUNG + +RWQ LD B,A + IN A,(P0AD) ;PERIPHERIE-ADRESSE IN + LD C,A ;REG. C LADEN + LD A,B + CP 02H ;READ-STATUS ? + JR Z,READ ;JA + CP 04H ;WRITE-STATUS ? + JR NZ,ISREND ;NEIN --> INVALID STATUS + +WRITE: IN A,(P0BD) + BIT 5,A ;DATEN DA ? + JR Z,WRITE ;NEIN --> WARTEN + LD B,A + IN A,(P0AD) ;DATENBYTE + OUT (C),A ;AUSGABE AN PERIPHERIE-ADR. + LD A,B + AND 16H + JR Z,ISREND ;ENDESTATUS + CP 04H ;WRITE-STATUS + JR Z,WRITE ;NAECHSTE DATENBYTE IST WIEDER FUER WRITE + ;BEI JEDEM ANDEREN STATUS WIRD +WADA: IN A,(P0BD) ;AUF DATEN GEWARTET + BIT 5,A + JR Z,WADA + AND 16H ;STATUS FILTERN + JR RWQ ;READ ODER WRITE-REQUEST + +READ: IN A,(C) ;EINGABE VON PERIPHERIE-ADR. + LD B,A + IN A,(P0BD) ;PORT-AUSGABE FREI ? + BIT 6,A + JR NZ,RQEND ;JA KEIN FLAG SETZEN + LD A,0FFH + LD (FLAG),A ;FLAG SETZEN, D.H. WERT WURDE UEBERSCHRIEBEN +RQEND: LD A,B + OUT (P16A),A ;DATENUEBERGABE + XOR A + OUT (P16B),A ;MIT STATUS 0 + OR 80H + OUT (P16B),A ;STB-FLANKE OHNE INTERRUPT + +WABH IN A,(P0BD) + BIT 6,A ;WARTEN BIS WERT ABGEHOLT WURDE + JR Z,WABH + +ISREND: POP IX + POP HL + POP DE + POP BC + POP AF + EI + RETI + +;------- + +REQUEST: + LD HL,STATUS + CP 16H ;QUIT-STATUS + JR Z,RQT + IN A,(P0AD) + JR ISREND + +;QUIT-REQUEST + +RQT: IN A,(P0AD) + CP 'R' + JR NZ,RQT1 + SET 7,(HL) + JR ISREND +RQT1: CP 'Q' + JR NZ,ISREND + SET 0,(HL) + JR ISREND + +;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; PIO1 INTERRUPTS (EPROM-PROGRAMMER) +; +ISP1KA + PUSH HL + LD HL,STAT2 + SET 0,(HL) + POP HL + EI + RETI + +ISP1KB + PUSH HL + LD HL,STAT2 + SET 1,(HL) + POP HL + EI + RETI + + +;;;;;;;;;;;;;;;;;;;;;;;;; + +; SIO RECEIVE - INTERRUPTS +; ABLEGEN DER WERTE IN ENTSPR. RINGPUFFER + + +S0AR: PUSH BC ;SIO 0 KANAL A RECEIVE-INT. + PUSH IX + LD C,S0AC ;DATEN-ADR + LD IX,RB_S0A ;RINGPUFFER + JR RINT + +S0BR: PUSH BC ;SIO 0 KANAL B RECEIVE-INT. + PUSH IX + LD C,S0BC ;DATEN-ADR. + LD IX,RB_S0B ;RINGPUFFER + JR RINT + +S1AR: PUSH BC ;SIO 1 KANAL A RECEIVE-INT. + PUSH IX + LD C,S1AC ;DATEN-ADR. + LD IX,RB_S1A ;RINGPUFFER + JR RINT + +S1BR: PUSH BC ;SIO 1 KANAL B RECEIVE-INT. + PUSH IX + LD C,S1BC ;DATEN-ADR. + LD IX,RB_S1B ;RINGPUFFER + +RINT: PUSH AF ;GEMEINSAMER TEIL FUER ALLE + PUSH HL ;RECEIVE-INTERRUPTS + PUSH DE +RINT1: DEC C + IN B,(C) ;WERT EINLESEN + LD A,(IX+72H) ;SCHREIBPOINTER + CALL INCPOI ;NEUEN WERT BERECHNEN + LD (IX+72H),A ;UND SPEICHERN + LD (HL),B ;DATENBYTE IN RINGPUFFER + INC C ;SIO CONTROL-ADR. + IN A,(C) ;EINGABE RR0 + BIT 0,A ;NOCH ZEICHEN DA + JR NZ,RINT1 ;JA + POP DE + POP HL + POP AF + POP IX + POP BC + EI + RETI + +INCPOI: + LD D,0 + LD E,A + PUSH IX + POP HL ;HL AUF WERT VON IX + INC A + CP 70H + JR NZ,INCP + XOR A +INCP ADD HL,DE + RET + +;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;RESTLICHE SIO-INTERRUPTS: T_INT, E_INT, S_INT FUER ALLE KANAELE: +; +S0BT: PUSH BC + PUSH IX + LD C,S0BC ;SIO CONTROL-ADR. + LD IX,RB_S0B + JR TINT + +S0AT: PUSH BC + PUSH IX + LD C,S0AC + LD IX,RB_S0A + JR TINT + +S1BT: PUSH BC + PUSH IX + LD C,S1BC + LD IX,RB_S1B + JR TINT + +S1AT: PUSH BC + PUSH IX + LD C,S1AC + LD IX,RB_S1A +TINT: PUSH AF + LD A,28H ;RESET T_INT + OUT (C),A + IN A,(C) ;EINGABE RR0 + LD (IX+74H),A ;SPEICHERN + SET 0,(IX+73H) ;SET T_INT BIT + JR SIOINT + +S0BE: PUSH BC + PUSH IX + LD C,S0BC + LD IX,RB_S0B + JR EINT + +S0AE: PUSH BC + PUSH IX + LD C,S0AC + LD IX,RB_S0A + JR EINT + +S1BE: PUSH BC + PUSH IX + LD C,S1BC + LD IX,RB_S1B + JR EINT + +S1AE: PUSH BC + PUSH IX + LD C,S1AC + LD IX,RB_S1A +EINT: PUSH AF + IN A,(C) ;EINGABE RR0 + LD (IX+74H),A ;SPEICHERN + LD A,10H + OUT (C),A ;RESET E_INT + SET 1,(IX+73H) ;SET E_INT BIT + JR SIOINT + +S0BS: PUSH BC + PUSH IX + LD C,S0BC + LD IX,RB_S0B + JR SINT + +S0AS: PUSH BC + PUSH IX + LD C,S0AC + LD IX,RB_S0A + JR SINT + +S1BS: PUSH BC + PUSH IX + LD C,S1BC + LD IX,RB_S1B + JR SINT + +S1AS: PUSH BC + PUSH IX + LD C,S1AC + LD IX,RB_S1A +SINT: PUSH AF + LD A,1 + OUT (C),A + IN A,(C) ;EINGABE RR1 + LD (IX+75H),A ;SPEICHERN + LD A,30H + OUT (C),A ;RESET S_INT + SET 2,(IX+73H) ;SET S_INT BIT + +SIOINT: POP AF + POP IX + POP BC + EI + RETI + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;TEXTE: + +MERR DEFB 25 + DEFM 'U8000-Unit does not work' + DEFB 0DH + +MTERR DEFB 29 ;LAENGE + DEFM 'Hardware Error in Connection' + DEFB 0DH + +BASP DEFB 1 + DEFB 08H + +MMLDG DEFB 22 + DEFM 'U8000-Softwaremonitor' + DEFB 0DH + +KBC0R + DEFB 0CFH + DEFB 7FH + DEFB 0B7H + DEFB 0FEH + +;INT-TABELLEN-EINTRAEGE + +SNEUTAB DEFW S0BT + DEFW S0BE + DEFW S0BR + DEFW S0BS + + DEFW S0AT + DEFW S0AE + DEFW S0AR + DEFW S0AS + + DEFW S1BT + DEFW S1BE + DEFW S1BR + DEFW S1BS + + DEFW S1AT + DEFW S1AE + DEFW S1AR + DEFW S1AS + +LETZT + +;BUFFER UND VARIABLEN + +SAVE DEFS 32 +SAVEPIO DEFS 4 + +;RINGPUFFER FUER ALLE SIO-INTERRUPTS + +BUFFER: +RB_S0A DEFS 70H + DEFS 3 ;BUFLEN / BUFPOI / RECPOI + DEFS 1 ;FLAG FUER TES_INT'S + DEFS 2 ;RR0 / RR1 SPEICHER +RB_S0B DEFS 76H +RB_S1A DEFS 76H +RB_S1B DEFS 76H + +FLAG DEFS 1 ;FUER KINB BEIM UEBERSCHREIBEN + + +STATUS DEFS 2 +STAT2 DEFS 1 +ERROR DEFS 1 +BUFEND: DEFS 0 + + +;;;;;;;;;;;;;;;;;;;; +;KONSTANTEN: + +ACK: EQU 06H + +P16A EQU 10H ;AUSGABEPORT 1 (DATEN) AN U8000 +P16B EQU 14H ;AUSGABEPORT 2 (RDY/STATUS/INT8000) + +PIO0 EQU 0CH +P0AD EQU PIO0 +P0AC EQU PIO0+1 +P0BD EQU PIO0+2 +P0BC EQU PIO0+3 + +S0AD EQU 24H +S0AC EQU S0AD+1 +S0BD EQU S0AD+2 +S0BC EQU S0AD+3 +S1AD EQU 28H +S1AC EQU S1AD+1 +S1BD EQU S1AD+2 +S1BC EQU S1AD+3 + +;AUS PROM SATZ: + +DSEL EQU 0EDDH +OUTAS EQU 0BF1H ;AUSGABE ZEICHENKETTE +DEBUG EQU 0BFAH + +IP0KB: EQU 0F12H +IP1KA EQU 0F14H +IP1KB EQU 0F16H +ITABS0 EQU 0F20H +IS1B1 EQU 0F20H diff --git a/firmware/MON8/OUTA.S b/firmware/MON8/OUTA.S new file mode 100644 index 0000000..0850a08 --- /dev/null +++ b/firmware/MON8/OUTA.S @@ -0,0 +1,18 @@ +; +PUTA +; +; AUSGABE-ROUTINE UEBER SIO-KANAL B +; ZEICHEN FUER DIE AUSGABE STEHT IM AKKUMULATOR +; SENDEPUFFER IST LEER WIRD IM POLLING ERMITTELT +; + PUSH AF +PUTW1 LD A,(MCSQ) ; MERKER CTRL S, Q UND ESC ABFRAGEN + BIT 6,A ; CTRL S GESETZT ? + JR NZ,PUTW1 +PUTW2 IN A,(S0BC) + BIT 2,A ; IST DER SENDEPUFFER LEER ? + JR Z,PUTW2 + POP AF + OUT (S0BD),A + RET + diff --git a/firmware/MON8/U880EIG.S b/firmware/MON8/U880EIG.S new file mode 100644 index 0000000..82a8835 --- /dev/null +++ b/firmware/MON8/U880EIG.S @@ -0,0 +1,2628 @@ +*H P8000 U880-FIRMWARE 3.0 +*P 84 +;****************************************************************************** +;* * +;* * +;* P8000 - SOFTWARE * +;* * +;* Entwicklerdokumentation * +;* * +;* Betriebssystem UDOS * +;* * +;* Programm: U880EIG * +;* * +;* Version: 3.1 * +;* * +;* Bearbeiter: M. Weber * +;* * +;* Datum: 18.01.1989 * +;* * +;* * +;****************************************************************************** +; +;P8000 U880-Eigentest +; +; + + JR START + DEFM '(C)KEAW_01/89' +; +; Es wird die Funktionsfaehigkeit von PIO2, Kanal A vorausgesetzt. +; Es gilt: Bit 7 = 1 ---> Spannungs-Reset +; Bit 7 = 0 ---> Bediener-Reset, es wird kein Eigentest +; durchgefuehrt +; +START + + LD B,0 +DECB1 LD C,0 +DECB2 DEC C + JR NZ,DECB2 + DEC B + JR NZ,DECB1 + + + LD A,0CFH ;Bit-Mode PIO2, Kanal A + OUT (P2AC),A + LD A,80H ;nur Bit 7 ist Eingabebit + OUT (P2AC),A + LD A,3 + OUT (P2AC),A + IN A,(P2AD) + BIT 7,A + JP Z,INSM1 ;kein Spannungs-Reset + +; Initialisierung der Speicherbanksteuerung + +ISPBST + XOR A + LD I,A + LD C,WEADP + LD DE,10H + XOR A ;Anfangsadresse +AUSA LD B,A ;Adressbildung + OUT (C),D + ADD A,10H ;naechste Adresse wird berechnet + DEC E + JR NZ,AUSA + LD D,1 ;PROM_SEL aktiv + LD B,0 ;Adresse gleich 0 + OUT (C),D + IN A,(RFF) ;Aktivierung des Adressports + LD D,1 + LD B,10H + OUT (C),D + JR START1 + +ENSMON + LD H,0 + LD C,0 + EXX + LD A,0FH + OUT (P1AC),A + LD A,3 + OUT (P1AC),A + + LD C,S0BD + LD B,43 + LD HL,AHWT1 + JP ATEST + + +; Beginn des Eigentest des P8000 8-Bit-Teils + + +; Test des PIO1, Kanal A durch Ausgabe und Ruecklesen. +; Bei Fehler werden Fehlerkode 10H, Adresse 18H, ausgegebener und +; rueckgelesener Wert gemerkt. +; Benutzte Register: A, B, C, H, L +; +START1 JR WENMI + +; Hier Einsprung fuer NMI fuer Hardwaretestung ! + + JP 4000H +WENMI + LD A,0FH + OUT (P1AC),A ;Ausgabemode PIO1, Kanal A + LD A,3 + OUT (P1AC),A + LD A,0AAH + OUT (P1AD),A + LD C,0 ;Initialisierung fuer Register C + IN A,(P2AD) ;Veraenderung auf dem Datenbus + IN A,(P1AD) + CP 0AAH ;Ist der Wert gleich dem ausgegebenen Wert? + JR Z,WTP1A ;Ja, kein Fehler. +; + LD H,A ;rueckgelesenen Wert merken + LD C,1 ;Fehler beim ersten Test +WTP1A + LD A,55H + OUT (P1AD),A + IN A,(P2AD) ;Veraenderung auf dem Datenbus + IN A,(P1AD) + CP 055H ;Ist der Wert gleich dem ausgegebenen Wert? + JR Z,WTC11 ;Ja, kein Fehler. +; + LD L,A ;rueckgelesenen Wert merken + SET 1,C ;Fehler beim zweiten Test +; +; Es wird der CTC1, Kanal 1 getestet. +; Bei Fehler werden Fehlerkode 15H oder 16H, Portadresse 2DH sowie +; ausgegebener und rueckgelesener Wert gemerkt. +; Benutzte Register: A, C, D, E +; +WTC11 + LD A,0FFH + OUT (P1AD),A ;Start: Ausgabe von 0FFH +; + LD A,7 + OUT (CTC1+1),A + LD A,0AAH ;Zeitkonstante ist 0AAH + OUT (CTC1+1),A + LD D,5 +ZC1 DEC D + JR NZ,ZC1 + IN A,(CTC1+1) + CP 0AAH ;Ist der Wert gleich dem ausgegebenen Wert? + JR C,NTC11 ;Nein, kleiner. +; + LD D,A ;rueckgelesenen Wert merken + SET 2,C ;Fehler beim dritten Test +; +NTC11 + LD A,3 + OUT (CTC1+1),A ;CTC anhalten + IN A,(CTC1+1) + CP 0AAH ;Ist der Wert gleich dem ausgegebenen Wert? + JR Z,WTS0B ;Ja, kein Fehler. +; + LD E,A ;rueckgelesenen Wert merken + SET 3,C ;Fehler beim vierten Test +; +; Test des SIO0 durch Programmierung und Ruecklesen des Interruptvektors (nur +; in Kanal B moeglich). +; Bei Fehler werden Fehlerkode 20H, Adresse 26H, ausgegebener und rueckgelese- +; ner Wert gemerkt. +; Benutzte Register: AF', BC', DE', HL' +; +WTS0B + LD A,38H + OUT (S0BC),A + LD A,10H + OUT (S0BC),A + LD A,11H + OUT (S0BC),A + XOR A + OUT (S0BC),A + + + LD A,12H ;Schreibregister 2 ansprechen + OUT (S0BC),A + LD A,50H ;Wert 50H eintragen + OUT (S0BC),A +Daten + ;auf dem Datenbus + LD A,12H ;Leseregister 2 ansprechen + OUT (S0BC),A + IN A,(S0BC),A + CP 50H ;Ist der Wert gleich dem ausgegebenen Wert? + JR Z,NTS0B ;Ja, kein Fehler. +; + LD I,A + SET 4,C ;Fehler beim fuenften Test +NTS0B + LD A,12H ;Leseregister 2 ansprechen + OUT (S0BC),A + LD A,20H + OUT (S0BC),A + LD A,12H + OUT (S0BC),A + IN A,(S0BC) ;Einlesen des Interruptvektors + CP 20H ;Ist der Wert gleich dem ausgegebenen Wert? + JR Z,SPF ;Ja, kein Fehler, restliche Fehler speichern. +; + LD B,A ;rueckgelesenen Wert merken + SET 5,C ;Fehler beim sechsten Test +SPF + EXX ;Werte in den Zweitregistersatz +; +; Initialisierung von CTC1 Kanal 1 und SIO0 Kanal B fuer die Ausgabe der +; Eigentestmeldungen. +; PIO1 Kanal A ist bereits initialisiert. +; + LD A,57H ;Zeitgeber-Mode mit externem Takt + OUT (CTC1+1),A + LD A,2 ;Baudrate von 9600 Bd + OUT (CTC1+1),A + LD HL,INITAB ;Initialisierungstabelle fuer den SIO + LD B,8 + LD C,S0BC + OTIR ;acht Werte werden ausgegeben + LD C,S0BD + LD B,ANZHWT + LD HL,AUSHWT +ATEST OUTI ;Ausgabe der Anfangsaussschrift fuer den Hardwareeigentest + INC B +P1WAIT IN A,(S0BC) + BIT 2,A ;Ist der SIO fertig? + JR Z,P1WAIT ;Nein, warten. + LD C,2 +ZAUS11 LD D,0 +ZAUS1 DEC D + JR NZ,ZAUS1 ;Realisierung einer Wartezeit + DEC C + JR NZ,ZAUS11 + LD C,S0BD + DJNZ ATEST ;alle Zeichen, bis Anzahl gleich 0 +; +; Ausgabe eventuell beim Test von CTC1 Kanal 1, SIO0 Kanal B und PIO1 Kanal A +; entstandener und gemerkter Fehler. +; + EXX ;holen der Werte aus dem Zweitregistersatz + LD A,C + AND A ;Ist ueberhaupt ein Fehler aufgetreten? + JR NZ,AFKP ;Ja, Ausgabe der Fehler. +; +; Ausgabe der Eigentestnummern der durchgefuehrten Tests +; + LD HL,TENRAN + LD B,ANZANF +NZANF LD A,(HL) + OUT (S0BD),A +ANFWRS IN A,(S0BC) + BIT 2,A + JR Z,ANFWRS + INC HL + LD D,0 +TD1 DEC D + JR NZ,TD1 + DJNZ NZANF + EXX + LD H,0 ;Register H mit 0 laden, da kein Fehler + EXX + LD A,10H ;Fehlerkode PIO Test + OUT (P1AD),A + LD A,15H ;Fehlerkode CTC Test + OUT (P1AD),A + LD A,16H ;zweiter Fehlerkode CTC-Test + OUT (P1AD),A + LD A,20H ;Fehlerkode SIO Test + OUT (P1AD),A +; + JP W1EIG ;weiter im Eigentest +; +AFKP EXX + LD E,10H ;Fehlerkode laden + LD IX,$+7 + JP AUSTNR + EXX + BIT 0,C ;Fehler beim Test PIO1 Kanal A? + JR Z,NEAUS +; + EXX ;Ja! Speichern der Werte im Zweitregistersatz + LD C,S0BD ;Daten SIO0 Kanal B + LD B,ANAUS1 ;Anzahl erster Fehler + LD HL,AUSF1 ;Ausschrift erster Fehler +A1TE OUTI + INC B +P2W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P2W + LD D,0FFH ;Ja, Zeitschleife +ZAUS2 DEC D + JR NZ,ZAUS2 + DJNZ A1TE + EXX ;gespeicherte Werte holen + LD A,H + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,ADD2 + ADD A,7 +ADD2 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P3W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P3W + LD A,H ;Ja, naechstes Halbbyte + AND 0FH ;naechstes Halbbyte + CP 0AH + JR C,ADD3 + ADD A,7 +ADD3 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P4W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P4W + LD H,0FFH ;in Fehler merken + EXX +; +NEAUS BIT 1,C ;Fehler beim zweiten Test PIO1 Kanal A? + JR Z,NEAUS2 +; + EXX ;Ja! Speichern der Werte im Zweitregistersatz + LD C,S0BD ;Daten SIO0 Kanal B + LD B,ANAUS2 ;Anzahl zweiter Fehler + LD HL,AUSF2 ;Ausschrift zweiter Fehler +A2TE OUTI + INC B +P5W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P5W + LD D,0FFH ;Ja, Zeitschleife +ZAUS3 DEC D + JR NZ,ZAUS3 + DJNZ A2TE + EXX ;gespeicherte Werte holen + LD A,L + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,ADD4 + ADD A,7 +ADD4 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P6W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P6W + LD A,L ;Ja, naechstes Halbbyte + AND 0FH ;naechstes Halbbyte + CP 0AH + JR C,ADD5 + ADD A,7 +ADD5 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P7W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P7W + LD H,0FFH ;in Fehler merken + EXX + +NEAUS2 EXX + LD E,15H Nein, Fehlerkode CTC Test ausgeben. + LD IX,$+7 + JP AUSTNR + EXX + BIT 2,C ;Fehler beim Test CTC1 Kanal 1? + JR Z,NEAUS3 +; + EXX ;Ja! Speichern der Werte im Zweitregistersatz + LD C,S0BD ;Daten SIO0 Kanal B + LD B,ANAUS3 ;Anzahl dritter Fehler + LD HL,AUSF3 ;Ausschrift dritter Fehler +A3TE OUTI + INC B +P8W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P8W + LD D,0FFH ;Ja, Zeitschleife +ZAUS4 DEC D + JR NZ,ZAUS4 + DJNZ A3TE + EXX ;gespeicherte Werte holen + LD A,D + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,ADD6 + ADD A,7 +ADD6 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P9W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P9W + LD A,D ;Ja, naechstes Halbbyte + AND 0FH ;naechstes Halbbyte + CP 0AH + JR C,ADD7 + ADD A,7 +ADD7 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P10W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P10W + LD H,0FFH ;in Fehler merken + EXX +; +NEAUS3 EXX + LD E,16H + LD IX,$+7 + JP AUSTNR + EXX + BIT 3,C ;Fehler beim Test CTC1 Kanal 1? + JR Z,NEAUS4 +; + EXX ;Ja! Speichern der Werte im Zweitregistersatz + LD C,S0BD ;Daten SIO0 Kanal B + LD B,ANAUS4 ;Anzahl vierter Fehler + LD HL,AUSF4 ;Ausschrift vierter Fehler +A4TE OUTI + INC B +P11W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P11W + LD D,0FFH ;Ja, Zeitschleife +ZAUS5 DEC D + JR NZ,ZAUS5 + DJNZ A4TE + EXX ;gespeicherte Werte holen + LD A,E + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,ADD8 + ADD A,7 +ADD8 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P12W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P12W + LD A,E ;Ja, naechstes Halbbyte + AND 0FH ;naechstes Halbbyte + CP 0AH + JR C,ADD9 + ADD A,7 +ADD9 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P13W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P13W + LD H,0FFH ;in Fehler merken + EXX + +NEAUS4 EXX + LD E,20H ;Fehlerkode fuer SIO-Test ausgeben. + LD IX,$+7 + JP AUSTNR + EXX +NEA4 BIT 4,C ;Fehler beim Test SIO0 Kanal A? + JR Z,NEAUS5 +; + EXX ;Ja! Speichern der Werte im Zweitregistersatz + LD C,S0BD ;Daten SIO0 Kanal B + LD B,ANAUS5 ;Anzahl fuenfter Fehler + LD HL,AUSF5 ;Ausschrift fuenfter Fehler +A5TE OUTI + INC B +P14W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P14W + LD D,0FFH ;Ja, Zeitschleife +ZAUS6 DEC D + JR NZ,ZAUS6 + DJNZ A5TE + EXX ;gespeicherte Werte holen + LD A,I + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,ADD10 + ADD A,7 +ADD10 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P15W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P15W + LD A,I ;Ja, naechstes Halbbyte + AND 0FH ;naechstes Halbbyte + CP 0AH + JR C,ADD11 + ADD A,7 +ADD11 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P16W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P16W + LD H,0FFH ;in Fehler merken + EXX +; +NEAUS5 BIT 5,C ;Fehler beim Test SIO0 Kanal A? + JR Z,W1EIG +; + EXX ;Ja! Speichern der Werte im Zweitregistersatz + LD C,S0BD ;Daten SIO0 Kanal B + LD B,ANAUS6 ;Anzahl sechster Fehler + LD HL,AUSF6 ;Ausschrift sechster Fehler +A6TE OUTI + INC B +P17W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P17W + LD D,0FFH ;Ja, Zeitschleife +ZAUS7 DEC D + JR NZ,ZAUS7 + DJNZ A6TE + EXX ;gespeicherte Werte holen + LD A,B + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,ADD12 + ADD A,7 +ADD12 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P18W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P18W + LD A,B ;Ja, naechstes Halbbyte + AND 0FH ;naechstes Halbbyte + CP 0AH + JR C,ADD13 + ADD A,7 +ADD13 ADD A,30H ;ASCII-Zeichen fertig + OUT (S0BD),A +P19W IN A,(S0BC) + BIT 2,A ;Sendepuffer leer? + JR Z,P19W + LD H,0FFH ;in Fehler merken + EXX +; +; Nach den Ausgaben evtl. aufgetretener Fehler wird der Eigentest fortgesetzt. +; Das Register H wird in den Zweitregistersatz gerettet. +; +W1EIG EXX + LD E,0 + LD IX,TEPROM + JP AUSTNR +TEPROM EXX + + +; Programm Test EPROM +; Fuer den EPROM wird ausser den letzten zwei Bytes die Pruefsumme gebildet und +; mit dem in den letzten zwei Bytes stehenden Wert verglichen. +; Bei Fehler wird der Fehlerkode 00 an PIO und Terminal ausgegeben. +; Benutzte Register: +; + +; BERECHNUNG DES CRC VOM PROM NACH DEM SDLC POLYNOM + + +; Berechnung des CRC fuer EPROM0 + +CRCANF + LD IX,TENEP + LD HL,0 + LD BC,1000H + ld de,-1 +crc1: ld a,(hl) + xor d + ld d,a + rrca + rrca + rrca + rrca + and 0fh + xor d + ld d,a + rrca + rrca + rrca + LD I,A + and 1fh + xor e + ld e,a + LD A,I + LD I,A + rrca + and 0f0h + xor e + ld e,a + LD A,I + and 0e0h + xor d + ld d,e + ld e,a + inc hl + dec bc + ld a,b + or c + jr nz,crc1 + LD HL,(CRCEP0) + LD A,D + CP H + JP NZ,FAUSA3 + LD A,E + CP L + JP NZ,FAUSA3 + LD HL,(NCEP0) + ADD HL,DE + LD A,0FFH + CP H + JP NZ,FAUSA3 + CP L + JP NZ,FAUSA3 + +; Berechnung und Test des CRC fuer EPROM1 + +TENEP LD IX,TSRAM + LD HL,1000H + LD BC,0FF8H + ld de,-1 +crc10: ld a,(hl) + xor d + ld d,a + rrca + rrca + rrca + rrca + and 0fh + xor d + ld d,a + rrca + rrca + rrca + LD I,A + and 1fh + xor e + ld e,a + LD A,I + LD I,A + rrca + and 0f0h + xor e + ld e,a + LD A,I + and 0e0h + xor d + ld d,e + ld e,a + inc hl + dec bc + ld a,b + or c + jr nz,crc10 + LD HL,(CRCEP1) + LD A,D + CP H + JP NZ,FAUSA3 + LD A,E + CP L + JP NZ,FAUSA3 + LD HL,(NCEP1) + ADD HL,DE + LD A,0FFH + CP H + JP NZ,FAUSA3 + CP L + JP NZ,FAUSA3 + + + +; +; Programm Test SRAM +; Es werden ein Test der Adressleitungen, der Datenleitungen, der Datenhaltigkeit +; des Speichers durch das Durchschieben von 0 oder 1 und ein Programmtest des Speichers durchgefuehrt. +; Bei auftretenden Fehlern wird der entsprechende Fehlerkode an das Terminal und, wenn vorher kein +; Fehler aufgetreten war, an den PIO Port ausgegeben. Am Terminal werden ausserdem die Speicheradresse, +; der ausgegebene und der rueckgelesene Wert angezeigt. +; Benutzte Register: +; +TSRAM EXX ;holen Zweitregistersatz + LD E,5 + LD IX,WTSR1 + JP AUSTNR +WTSR1 EXX + +; Initialisierung des SRAM auf die Adresse 2000H +; + LD D,2 ;SRAM_SEL aktiv + LD B,20H ;Adresse ist 2000H + LD C,WEADP + OUT (C),D ;Einschalten des SRAM auf die Adresse 7000H +; +; Test der Datenleitungen des SRAM +; + XOR A ;alle Bits auf 0 setzen +TAUFD LD HL,2000H ;Anfangsadresse ist 2000H + LD DE,2001H + LD BC,7FFH ;Datenlaenge ist 2k-1 + LD (HL),A ;0 oder 0FFH auf den ersten Speicherplatz + LDIR ;Wert wird in alle Speicherzellen des SRAM eingetragen + CP (HL) ;Letztes Byte gleich dem Akkumulator? + JP Z,DTSR1 + LD B,A ;Testwert eintragen + LD A,(HL) + LD IX,WT2SR + JR FAUSA3 + +; Ausgabe der Testschrittnummer an den SIO0, Kanal B (Terminal) +; An den PIO erfolgt die Ausgabe nur, wenn vorher kein Fehler auftrat. +; Programm arbeitet mit dem Zweitregistersatz, im Register E steht die +; auszugebende Testschrittnummer. + +AUSTNR LD B,2 +BB0 LD A,8 ;Ausgabe von 2 Backspace + OUT (S0BD),A +WSBSR IN A,(S0BC) + BIT 2,A + JR Z,WSBSR + LD D,0 +Z1AUS DEC D + JR NZ,Z1AUS + DJNZ BB0 + LD A,E + LD IY,$+7 + JP HCAHL + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD D,0 +Z2AUS DEC D + JR NZ,Z2AUS + LD A,C + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,E + BIT 0,H + JR NZ,VORFE + OUT (P1AD),A +VORFE LD BC,0 +ZAUSN2 DEC C + JR NZ,ZAUSN2 + DEC B + JR NZ,ZAUSN2 + JP (IX) + + +; Ausgabe der Werte, wenn ein Fehler im SRAM-Test auftritt +; Speicheradresse in HL, Testwert in B, rueckgelesener Wert in D +; in IX ist die Rueckkehradresse eingetragen + +FAUSA3 EXX + LD HL,ADRERR + LD B,ANAUSE + LD C,S0BD +NZAERR OUTI + INC B +WSREA IN A,(S0BC) + BIT 2,A + JR Z,WSREA + LD D,0 +ZSAE DEC D + JR NZ,ZSAE + DJNZ NZAERR + LD A,E + LD IY,$+7 + JP HCAHL + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,C + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD H,0FFH + LD A,E + LD I,A + EXX + LD D,A + LD A,I + AND A + JP Z,AENDZ + LD A,' ' + OUT (S0BD),A +WSREA1 IN A,(S0BC) + BIT 2,A + JR Z,WSREA1 + LD C,B + LD B,2 +NASP LD A,20H + OUT (S0BD),A +WSREA2 IN A,(S0BC) + BIT 2,A + JR Z,WSREA2 + LD E,0 +ZSAE1 DEC E + JR NZ,ZSAE1 + DJNZ NASP + LD B,C + LD A,H ;Speicheradresse ist erste Ausgabe + LD IY,$+7 + JP HCAHL ;Umwandlung in Hexadezimalzahl + OUT (S0BD),A ;Ausgabe an das Terminal + LD IY,$+7 + JP SRAHL ;Ist SIO fertig? + LD A,C + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,L + LD IY,$+7 + JP HCAHL + OUT (S0BD),A ;Ausgabe zu lesender Wert + LD IY,$+7 + JP SRAHL + LD A,C + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,20H + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,B ;Ausgabe zu lesender Wert + LD IY,$+7 + JP HCAHL + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,C + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,20H + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,D ;Ruecklesen gelesener Wert + LD IY,$+7 + JP HCAHL + OUT (S0BD),A + LD IY,$+7 + JP SRAHL + LD A,C + OUT (S0BD),A + LD IY,$+7 + JP SRAHL +AENDZ LD HL,ENDZEI + LD B,ANZEZ +NZENDZ LD A,(HL) + OUT (S0BD),A +WSIOFR IN A,(S0BC) + BIT 2,A + JR Z,WSIOFR + INC HL + LD D,0 +ZSAEND DEC D + JR NZ,ZSAEND + DJNZ NZENDZ + JP (IX) + +SRAHL IN A,(S0BC) + BIT 2,A + JR Z,SRAHL + JP (IY) + +HCAHL LD C,A + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,OR0 + ADD A,7 +OR0 ADD A,30H + LD I,A ;in I wird der Wert zwischengespeichert + LD A,C + AND 0FH + CP 0AH + JR C,OR1 + ADD A,7 +OR1 ADD A,30H + LD C,A + LD A,I + JP (IY) + +ADRM1T NOP + ADC A,B + LD BC,07FH + ADC A,B + NOP + INC B + ADC A,B + NOP + EX AF,AF' + NOP + EX AF,AF' + NOP + DJNZ TST_P1 + LD C,8 +TST_P1 INC B + ADC A,B + DEC L + NOP + ADC A,B + NOP + EX AF,AF' + ADD A,B + NOP + NOP + JP (IX) + +DTSR1 XOR 0FFH ;Ja. + JP NZ,TAUFD ;Test mit 0FFH +; +WT2SR EXX + LD E,6 + LD IX,T2SR + JP AUSTNR +T2SR EXX +; +; Test der Adressleitungen des statischen RAM + +; Test der oberen Adressleitungen +; Der Speicher wird in Bloecke zu je 256 Byte aufgeteilt. Die Bloecke werden nacheinander +; mit jeweils einem Wert gefuellt (0-7). Anschliessend werden die Bloecke nacheinander +; getestet. War der Test der Datenleitungen fehlerfrei und stimmen die Werte eines +; Blockes mit dem eingegebenen Wert nicht ueberein, dann ist die Ansteuerung fuer +; das Adressbit dieses Blockes fehlerhaft. + + +; Test der unteren Adressleitungen + +TUALSR LD IX,NT2SR ;Rueckkehradresse bei Fehler eintragen + LD HL,2000H + LD DE,2000H + LD C,8 +SRT3 XOR A +SRT4 LD (DE),A + INC DE + INC A + JR NZ,SRT4 + LD B,A +SRT5 LD A,(HL) + CP B + JP NZ,FAUSA3 + INC HL + INC B + JR NZ,SRT5 + DEC C + JR NZ,SRT3 + +NT2SR EXX + LD E,7 + LD IX,T01SR + JP AUSTNR +T01SR EXX +; Durchschieben von 0 und 1 + + +; Durchschieben einer Null + +TE0SR + LD HL,2000H + LD (HL),0FFH + LD DE,7FFH + LD B,E + LD A,(424) ;nur wegen Aenderung auf dem Bus + LD A,(HL) + CP B ;Testen des ersten Wertes + JP NZ,FAUSA3 + INC HL + AND A +NZNL RLA + LD (HL),A ;Laden des Speichers mit den Werten + EX AF,AF' + INC HL + DEC DE + LD A,D + OR E + JR Z,T2ZSR + EX AF,AF' + JR NZNL +T2ZSR + LD HL,2001H + LD DE,7FEH + SCF + LD B,E ;Register mit 0FEH laden + EX AF,AF' +TNZSR2 + LD A,(HL) + CP B ;Vergleich der Werte + JP NZ,FAUSA3 + INC HL + DEC DE + LD A,D + OR E + JR Z,KAT3SR + EX AF,AF' + LD A,B + RLA + LD B,A + EX AF,AF' + JR TNZSR2 + +KAT3SR + EXX + LD E,8 + LD IX,T3SR + JP AUSTNR +T3SR EXX + +; M1-Test des statischen RAM + + LD DE,2000H +NT3SR LD HL,ADRM1T + LD BC,30 + LDIR + AND A + EX DE,HL + LD DE,30 + SBC HL,DE + LD IX,WTM1SR + JP (HL) +WTM1SR LD DE,100H + INC L + ADD HL,DE + EX DE,HL + LD A,D + CP 28H + JR NZ,NT3SR + +TALLP LD SP,2800H ;Stackpointer mit bestimmten Wert laden + LD A,0FFH + LD (MAWE),A ;Initialisierung fuer den Merker + EXX + LD E,10H + CALL ANRRET ;Ausgabe der Fehlernummer an PIO und Terminal + EXX + +; Es werden alle PIO's im Ausgabemode getestet (ohne Interrupt). +; Im Fehlerfall werden Port-Adresse, eingetragener und rueckgelesener +; Wert an das Terminal ausgegeben. + +; Test PIO0, Kanal A im Ausgabemode (ohne Interrupt) + + LD A,3 + LD C,P0AC + OUT (C),A + LD A,55H + CALL PTAUS + CALL NZ,FA3RET +; + +; Test PIO0, Kanal B im Ausgabemode + + +;LD C,P0BC +;LD A,0D5H +;CALL PTAUS +;CALL NZ,FA3RET + +; Test PIO1, Kanal B im Ausgabemode + + + LD A,3 + LD C,P1BC + OUT (C),A + LD A,0F3H + CALL PTAUS + CALL NZ,FA3RET + +; Test PIO2, Kanal A im Ausgabemode + + + LD A,3 + LD C,P2AC + OUT (C),A + LD A,9FH + CALL PTAUS + CALL NZ,FA3RET + +; Test PIO2, Kanal B im Ausgabemode + + + LD A,3 + LD C,P2BC + OUT (C),A + LD A,6FH + CALL PTAUS + CALL NZ,FA3RET + + + EI + IM 2 + + LD A,23H + LD I,A ;Interruptvektorregister mit 73H laden + LD HL,TABISR ;Tabelle fuer alle Interrupts + LD DE,ADISR ;Adresse fuer ISR-Adressen + LD BC,42H ;Anzahl der Werte + LDIR + XOR A + LD HL,M1CISR ;Merker fuer ISR initialisieren + LD B,20 ;Anzahl der Merkzellen +ALLMZ LD (HL),A + INC HL + DJNZ ALLMZ + + + EXX + LD A,0FFH + LD (MAWE),A ;vorher war Test mit Interrupt + LD E,15H + CALL ANRRET + EXX + +; Test der CTC-Kanaele als Zaehler (ohne Interrupt) +; Test von CTC0, Kanal 0-3 und CTC1, Kanal 0,2,3 + + LD C,C0K0 + LD B,40H + CALL CZPR + CALL NC,FA3RET + + LD C,C0K1 + LD B,50H + CALL CZPR + CALL NC,FA3RET + + LD C,C0K2 + LD B,60H + CALL CZPR + CALL NC,FA3RET + + LD C,C0K3 + LD B,70H + CALL CZPR + CALL NC,FA3RET + + LD C,C1K0 + LD B,80H + CALL CZPR + CALL NC,FA3RET + + LD C,C1K2 + LD B,90H + CALL CZPR + CALL NC,FA3RET + + LD C,C1K3 + LD B,0A0H + CALL CZPR + CALL NC,FA3RET + + EXX + LD E,16H + CALL ANRRET + EXX + +; Test des CTC, ob die Zeitkonstanten richtig ruecklesbar sind + + LD B,40H + LD C,C0K0 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,50H + LD C,C0K1 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,60H + LD C,C0K2 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,70H + LD C,C0K3 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,80H + LD C,C1K0 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,90H + LD C,C1K2 + IN A,(C) + CP B + CALL NZ,FA3RET + + LD B,0A0H + LD C,C1K3 + IN A,(C) + CP B + CALL NZ,FA3RET + + EXX + LD A,1 + LD (MAWE),A + LD E,17H + CALL ANRRET + EXX + +; Test der CTC-Kanaele mit Interrupt + +; CTC0, Kanal0 auf Interrupt programmieren + + XOR A + LD C,C0K0 + OUT (C0K0),A ;Interruptvektor wird nur einmal programmiert + CALL CIPR ;Interruptprogrammierung CTC + CALL Z,FA3RET ;bei Fehler Ausgabe + + LD C,C0K1 + CALL CIPR + CALL Z,FA3RET + + LD C,C0K2 + CALL CIPR + CALL Z,FA3RET + + LD C,C0K3 + CALL CIPR + CALL Z,FA3RET + + LD A,8 + LD C,C1K0 + OUT (C),A ;Interruptvektor wird einmal ausgegeben + CALL CIPR + CALL Z,FA3RET + + LD C,C1K2 + CALL CIPR + CALL Z,FA3RET + + LD C,C1K3 + CALL CIPR + CALL Z,FA3RET + + EXX + LD E,20H + LD A,0FFH + LD (MAWE),A + CALL ANRRET +TSLES EXX + +; Test des SIO durch Lesen des Interruptvektors (ohne Interrupt) +; Eingabe des Interruptvektors und anschliessendes Ruecklesen +; nur Test des SIO1, da SIO0 bereits getestet +; Test ist auch nur im Kanal B moeglich + + + LD A,11H + OUT (S1BC),A + XOR A + OUT (S1BC),A + LD A,12H ;Schreibregister 2 ansprechen + OUT (S1BC),A + LD A,50H ;Wert 50H eintragen + OUT (S1BC),A + IN A,(S1BC) ;Lesen des Leseregisters 0, damit aendern der Daten + ;auf dem Datenbus + LD A,12H ;Leseregister 2 ansprechen + OUT (S1BC),A + LD C,S1AD ;erste SIO-Adresse fuer evt. Fehlerausgabe eintragen + LD B,50H + IN A,(S1BC) + CP B ;Ist der Wert gleich dem ausgegebenen Wert? + CALL NZ,FA3RET ;Nein, Fehler bei Aufruf + +; Wiederholung gleicher Test, nur mit anderem Wert + + LD A,12H ;Leseregister 2 ansprechen + OUT (S1BC),A + LD A,30H + OUT (S1BC),A + IN A,(S1BC) ;Veraenderung auf dem Datenbus + LD A,12H + OUT (S1BC),A + LD C,S1AD + LD B,30H + IN A,(S1BC) ;Einlesen des Interruptvektors + CP B + CALL NZ,FA3RET + + EXX + LD A,1 + LD (MAWE),A + LD E,21H + CALL ANRRET +TSINT EXX + +; Programmierung SIO0 und SIO1 als Sender (mit Interrupt) +; Aussenden von 0 +; Interruptvektoren sind bereits programmiert + + LD B,CTC1 + LD E,S0AC + CALL SINIT + + LD A,11H + OUT (S0AC),A + OUT (S0BC),A + LD A,6 ;Sendeinterrupt einschalten, Status wird nicht modifiziert + OUT (S0AC),A + OUT (S0BC),A + +; Senden von SIO0, Kanal A + + LD C,S0AD + CALL SI0APR ;Interruptprogrammierung SIO aufrufen + CALL Z,FA3RET ;kein Interrupt in ausreichender Zeit + + ; Senden von SIO0, Kanal B + + LD C,S0BD + CALL SI0BPR + CALL Z,FA3RET ;kein Interrupt in ausreichender Zeit + + LD B,CTC1+2 + LD E,S1AC + CALL SINIT + + LD B,CTC0 + LD E,S1BC + CALL SINIT + + LD A,11H + OUT (S1AC),A + OUT (S1BC),A + LD A,6 ;Sendeinterrupt einschalten, Status wird nicht modifiziert + OUT (S1AC),A + OUT (S1BC),A + +; Senden von SIO1, Kanal A + + LD C,S1AD + CALL SI1APR + CALL Z,FA3RET ;kein Interrupt in ausreichender Zeit + +; Senden von SIO1, Kanal B + + LD C,S1BD + CALL SI1BPR + CALL Z,FA3RET ;kein Interrupt in ausreichender Zeit + +TEFDC1 + + EXX + LD A,0FFH + LD (MAWE),A + LD E,25H + CALL ANRRET + EXX + +; Test des FDC +; Programmierung SPECIFY-Kommando und Ruecklesen + + DI + + CALL FDCREA + JR NZ,VTDPA ;FDC meldet keine Freigabe, damit keine weitere + ;Initialisierung moeglich + LD A,3 + OUT (DFDC),A + CALL FDCREA + JR NZ,VTDPA + + + LD A,1FH + OUT (DFDC),A + CALL FDCREA + JR NZ,VTDPA + + LD A,0FFH + OUT (DFDC),A + CALL FDCREA + JR NZ,VTDPA + + LD B,0FFH + LD C,DFDC + IN A,(C) + CP B + CALL NZ,FA3RET + + LD A,0CFH ;Bitmode programmieren + OUT (P2BC),A + LD A,10H + OUT (P2BC),A + LD A,3 + + + OUT (P2BC),A + LD A,8FH ;Wert fuer RESET ermitteln + OUT (P2BD),A ;RESET an den FDC + + EI + +VTDPA EXX + LD E,26H + CALL ANRRET +TEDMA EXX + + +; Test des DMA durch Programmieren und Ruecklesen Statusbyte und +; Blocklaenge (ohne Interrupt) + + LD HL,DMATA + LD B,DMATE-DMATA + LD C,DMAADR + OTIR + LD B,3BH ;Maske fuer ersten Wert aus Leseregister + IN A,(C) + AND B + CALL Z,FA3RET ;Ergebnis Maske und eingelesener Wert nicht 0 + LD C,DMAADR + LD B,0 ;zweiter Testwert wird eingetragen + IN A,(C) + CP B + CALL NZ,FA3RET + LD C,DMAADR + LD B,1 ;dritter Testwert wird eingetragen + IN A,(C) + CP B + CALL NZ,FA3RET + + EXX + LD A,1 + LD (MAWE),A + LD E,27H + CALL ANRRET +DMAIT EXX + +; Test des DMA mit Interrupt +; Programmieren eines Speichertransfers und warten auf den Interrupt + + LD HL,DMATA + LD B,DMATE2-DMATA + LD C,DMAADR + OTIR + LD HL,DMATA1 + LD B,DMATE1-DMATA1 + LD C,DMAADR + OTIR ;Programmierung des DMA fuer Interrupt + CALL ZEIT + LD A,(MIDMA) + AND A + CALL Z,FA3RET +DIEND LD A,0C3H + OUT (DMAADR),A ;partielles RESET an den DMA + + + EXX + LD A,0FFH + LD (MAWE),A + LD E,30H + CALL ANRRET +TDRAM EXX + +; Programm Test DRAM +; Es werden ein Test der Adressleitungen, der Datenleitungen, der Datenhaltigkeit +; des Speichers durch das Durchschieben von 0 oder 1 und ein Programmtest des Speichers durchgefuehrt. +; Bei auftretenden Fehlern wird der entsprechende Fehlerkode an das Terminal und, wenn vorher kein +; Fehler aufgetreten war, an den PIO Port ausgegeben. Am Terminal werden ausserdem die Speicheradresse, +; der ausgegebene und der rueckgelesene Wert angezeigt. +; Benutzte Register: + +; Der Test erfolgt in zwei Teilen. Erster Teil: Einschalten des DRAM auf den +; Adressen 3000H-FFFFH und Test dieses Bereichs. + +; Initialisierung des DRAM auf den Adressen 3000H-0FFFFH + + LD DE,040DH ;DRAM_SEL aktiv + LD B,30H ;Adresse ist 3000H + LD C,WEADP +W1EDR LD A,10H + OUT (C),D ;Einschalten des DRAM bis E=0 + ADD A,B + LD B,A + DEC E + JR NZ,W1EDR + +; Test der Datenleitungen des DRAM + + XOR A ;alle Bits auf 0 setzen + LD HL,3000H ;Anfangsadresse ist 3000H + LD DE,3001H + LD BC,0CFFFH ;Datenlaenge ist 32k-1 + LD (HL),A ;0 oder 0FFH auf den ersten Speicherplatz + LDIR ;Wert wird in die Speicherzellen des DRAM eingetragen + LD A,(HL) + CP B ;Testwert ist 0 + CALL NZ,FAHLR + LD A,0FFH ;Test mit 0FFH + LD HL,3000H + LD DE,3001H + LD BC,0CFFFH + LD (HL),A + LDIR + LD B,A ;Testwert eintragen + LD A,(HL) + CP B + CALL NZ,FAHLR + + + + EXX + LD E,31H + CALL ANRRET +T2DR EXX + +; Test der Adressleitungen des dynamischen RAM + +; Test der oberen Adressleitungen +; Der Speicher wird in Bloecke zu je 256 Byte aufgeteilt. Die Bloecke werden nacheinander +; mit jeweils einem Wert gefuellt (0-7). Anschliessend werden die Bloecke nacheinander +; getestet. War der Test der Datenleitungen fehlerfrei und stimmen die Werte eines +; Blockes mit dem eingegebenen Wert nicht ueberein, dann ist die Ansteuerung fuer +; das Adressbit dieses Blockes fehlerhaft. + + LD HL,3000H + LD DE,3001H + XOR A +SLDRT LD BC,0FFH + LD (HL),A + LDIR + INC HL + INC DE + INC A + CP 0D0H + JR NZ,SLDRT + LD HL,3000H +DRT1 LD E,0 +DRT2 LD A,(HL) + CP B + CALL NZ,FAHLR ;Fehler? dann Aufruf + INC HL + DEC E + JR NZ,DRT2 + INC B ;Erhoehen von B fuer die naechsten 256 Byte + LD A,B + CP 0D0H + JR NZ,DRT1 + + + EXX + LD E,32H + CALL ANRRET +T01DR EXX +; Durchschieben von 0 und 1 + + +; Durchschieben einer Null +TE0DR LD HL,3000H + LD B,0FFH + LD (HL),0FFH + LD DE,0CFFEH + LD A,(HL) + CP B + CALL NZ,FAHLR + INC HL +NZNLDR RLA + LD (HL),A + INC HL + DEC DE + PUSH AF + LD A,D + OR E + JR Z,T2ZDR + POP AF + JR NZNLDR +T2ZDR LD HL,3001H + LD DE,0CFFEH + LD A,E + SCF +TNZDR2 PUSH AF + LD B,A + LD A,(HL) + CP B + CALL NZ,FAHLR + INC HL + DEC DE + LD A,D + OR E + JR Z,KAT3DR + POP AF + RLA + JR TNZDR2 + +KAT3DR POP AF + EXX + LD E,33H + CALL ANRRET +T3DR EXX + + +; M1-Test des dynamischen RAM + + LD DE,3000H +NT3DR LD HL,ADRM1T + LD BC,30 + LDIR + AND A + EX DE,HL + LD DE,30 + SBC HL,DE + LD IX,WTM1DR + JP (HL) +WTM1DR LD DE,100H + INC HL + ADD HL,DE + EX DE,HL + LD A,D + AND A + JR NZ,NT3DR + +; Der zweite Teil des DRAM-Test wird nach der Initialisierung und nach dem Umladen +; des EPROM's in den dynamischen RAM ausgefuehrt. + + LD A,0DH + CALL AUSSP1 + CALL AUSSP + CALL AUSSP + CALL AUSSP + + JP INITSM ;Sprung zum Initialisierungsteil + +; Unterprogramme fuer die Eigentestroutinen + +; Programmierung PIO im Ausgabemode (ohne Interrupt) +; Testwert in B, rueckgelesener Wert in A, Portadresse in C + +PTAUS LD B,A ;Testwert in B retten + LD A,0FH ;Ausgabemode + OUT (C),A + LD A,3 ;Interrupt sperren + OUT (C),A + DEC C ;Adresse Datenport einstellen + LD A,B ;Testwert fuer die Ausgabe holen + OUT (C),A + IN A,(P1AD) ;Eingabe fuer Aenderung auf dem Bus + IN A,(C) + CP B ;Vergleich mit dem Testwert + RET + +; Programmierung CTC als Zaehler (ohne Interrupt) +; Zeitkonstante in B, rueckgelesener Wert in A, Portadresse in C + +CZPR LD A,7 + OUT (C),A + LD A,B + OUT (C),A + CALL ZEIT2 + IN A,(C) + CP B + PUSH AF + LD A,3 + OUT (C),A ;CTC ausschalten + POP AF + RET + + +; Programmierung CTC-Kanal als Zaehler (mit Interrupt). +; Portadresse steht in C, Warten auf den Interrupt, nach bestimmter +; Zeit wird abgebrochen. +; In der ISR wird HL entsprechend des ausgewaehlten Kanals veraendert. + +CIPR LD A,87H + OUT (C),A + LD B,70H + LD HL,ADRM1T ;Inhalt von HL ist 0 + LD A,0FFH ;fuer ISR mit Wert ungleich 0 laden + OUT (C),B + CALL ZEIT1 + CALL ZEIT1 + LD A,(HL) ;in der ISR wird HL veraendert + AND A + RET + +; Programmierung des SIO fuer Zeichen senden (mit Interrupt). +; Portadresse steht in C, Warten auf den Interrupt, nach bestimmter +; Zeit wird abgebrochen. +; In der ISR wird HL entsprechend ausgewaehltem SIO-Kanal veraendert. + +SI0APR + XOR A + OUT (C),A + CALL ZEIT + CALL ZEIT + CALL SIORES + LD A,3 + OUT (CTC1),A + LD A,(MIS0KA) + AND A + RET + +SI0BPR + XOR A + OUT (C),A + CALL ZEIT + CALL ZEIT + INC C + LD A,11H + OUT (C),A + XOR A + OUT (C),A + LD A,38H + OUT (S0AC),A + DEC C + LD A,(MIS0KB) + AND A + RET + +SI1APR + XOR A + OUT (C),A + CALL ZEIT + CALL ZEIT + CALL SIORES + LD A,3 + OUT (CTC1+2),A + LD A,(MIS1KA) + AND A + RET + +SI1BPR + XOR A + OUT (C),A + CALL ZEIT + CALL ZEIT + CALL SIORES + LD A,3 + OUT (CTC0),A + LD A,(MIS1KA) + AND A + RET + + +SIORES + INC C + LD A,11H + OUT (C),A + XOR A + OUT (C),A + LD A,30H + OUT (C),A + LD A,38H + OUT (C),A + LD A,18H + OUT (C),A + DEC C + RET + + +; Interruptserviceroutinen der CTC-Kanaele + +ISC0K0 LD HL,MIC0K0 +ICRET LD (HL),A + LD A,3 + OUT (C),A + EI + RETI + +ISC0K1 LD HL,MIC0K1 + JR ICRET + +ISC0K2 LD HL,MIC0K2 + JR ICRET + +ISC0K3 LD HL,MIC0K3 + JR ICRET + +ISC1K0 LD HL,MIC1K0 + JR ICRET + +ISC1K2 LD HL,MIC1K2 + JR ICRET + +ISC1K3 LD HL,MIC1K3 + JR ICRET + + +; Interruptserviceroutinen der SIO-Kanaele + +ISS0KA + PUSH AF + LD A,0FFH + LD (MIS0KA),A +ISRET + INC C + LD A,28H + OUT (C),A + DEC C + POP AF + EI + RETI + +ISS0KB + PUSH AF + LD A,0FFH + LD (MIS0KB),A + JR ISRET + +ISS1KA + PUSH AF + LD A,0FFH + LD (MIS1KA),A + JR ISRET + +ISS1KB + PUSH AF + LD A,0FFH + LD (MIS1KB),A + JR ISRET + + +; Interruptserviceroutine DMA + +ISDMA LD A,0A3H + OUT (DMAADR),A + LD (MIDMA),A + EI + RETI + +; Zeitschleifen + +ZEIT LD HL,0FFFFH +DECZL DEC L + JR NZ,DECZL + DEC H + JR NZ,DECZL + RET + +ZEIT1 LD D,0FFH +DECDL DEC D + JR NZ,DECDL + RET + +ZEIT2 LD D,6 +DECD1 DEC D + JR NZ,DECD1 + RET + +; Unterprogramm SIO-Programmierung + +SINIT + LD C,B + LD A,57H + OUT (C),A + LD A,2 + OUT (C),A + LD HL,INITAB + LD B,8 + LD C,E + OTIR + RET + +; Unterprogramm fuer die Ausgabe der Testschrittnummer an den PIO1, Kanal A +; fuer die Ziffernanzeige und Ausgabe an das Terminal ueber den SIO0, Kanal B +; Die Testschrittnummer wird im Zweitregistersatz im Register E uebergeben. + +ANRRET LD B,2 ;Anzahl von Backspace +NBSP LD A,8 ;Backspace laden + OUT (S0BD),A +WSBSP IN A,(S0BC) + BIT 2,A + JR Z,WSBSP + CALL ZEIT1 + DJNZ NBSP + LD A,E + BIT 0,H ;Kennzeichnung fuer bereits aufgetretenen Fehler + JR NZ,OHNPA + OUT (P1AD),A ;bei Fehler keine weiteren Ausgaben an den PIO +OHNPA CALL HEXCON + OUT (S0BD),A + CALL SIOREA + CALL ZEIT1 + LD A,C + OUT (S0BD),A + CALL SIOREA + LD C,0 +ZAUSNR CALL ZEIT1 + DEC C + JR NZ,ZAUSNR + RET + +; Unterprogramm fuer die Fehlerausgabe an das Terminal fuer drei, zwei +; oder einen Wert entsprechend in MAWE eingetragener Anzahl +; Uebergabewerte sind: Register B enthaelt den Testwert +; Register C enthaelt die Portadresse +; Akkumulator enthaelt den gelesenen Wert + +FA3RET PUSH AF + PUSH BC + PUSH DE + PUSH HL + LD D,A ;rueckgelesenen Wert in speichern + CALL AUSERR ;Ausschrift Error, Nummer entsprechend E + LD A,C ;Portadresse ist erste Ausgabe +AUS2WE CALL HEXCON ;Umwandlung in Hexadezimalzahl + OUT (S0BD),A ;Ausgabe an das Terminal + CALL SIOREA ;Ist SIO fertig? + LD A,C + OUT (S0BD),A + CALL SIOREA + LD A,(MAWE) ;Anzahl der auszugebenden Werte dekrementieren + DEC A + JR Z,FEAEND ;bei 0, Sprung an das Ende der Fehlerausgabe + LD C,B ;zu lesenden Wert in speichern + CALL AUSSP ;Ausgabe von Space + LD A,C + CALL HEXCON + OUT (S0BD),A ;Ausgabe zu lesender Wert + CALL SIOREA + LD A,C + OUT (S0BD),A + CALL SIOREA + CALL AUSSP + LD A,D ;Ruecklesen gelesener Wert + CALL HEXCON + OUT (S0BD),A ;Ausgabe gelesener Wert + CALL SIOREA + LD A,C + OUT (S0BD),A + CALL SIOREA +FEAEND LD HL,ENDZEI + LD B,ANZEZ +NAEZEI LD A,(HL) + OUT (S0BD),A ;Ausgaben am Ende einer Zeile +WEZEI IN A,(S0BC) + BIT 2,A + JR Z,WEZEI + INC HL + CALL ZEIT1 + DJNZ NAEZEI + POP HL + POP DE + POP BC + POP AF + RET + +; Unterprogramm fuer die Ausgabe ERROR und der Fehlernummer + +AUSERR EXX + LD HL,ADRERR + LD C,S0BD + LD B,ANAUSE ;Anzahl der Werte +WAUSE LD A,(HL) + OUT (C),A + CALL SIOREA + INC HL + DJNZ WAUSE + LD A,E + CALL HEXCON + OUT (S0BD),A + CALL SIOREA + LD A,C + OUT (S0BD),A + CALL SIOREA + CALL AUSSP + CALL AUSSP + CALL AUSSP + LD H,0FFH + EXX + RET + +; Unterprogramm fuer die Ausgabe von HL + +FAHLR PUSH AF + PUSH BC + PUSH DE + PUSH HL + LD D,A ;rueckgelesenen Wert retten + CALL AUSERR + LD A,H + CALL HEXCON + OUT (S0BD),A + CALL SIOREA + LD A,C + OUT (S0BD),A + CALL SIOREA + LD A,L + JP AUS2WE + +; Unterprogramm fuer die Abfrage der SIO-Fertigmeldung + +SIOREA IN A,(S0BC) + BIT 2,A + JR Z,SIOREA + RET + +; Unterprogramm fuer die Konvertierung eines Bytes in zwei ASCII-Zeichen + +HEXCON LD C,A + AND 0F0H + RRCA + RRCA + RRCA + RRCA + CP 0AH + JR C,ORUP0 + ADD A,7 +ORUP0 ADD A,30H + PUSH AF + LD A,C + AND 0FH + CP 0AH + JR C,ORUP + ADD A,7 +ORUP ADD A,30H + LD C,A + POP AF + RET + +; Unterprogramm fuer die Ausgabe von SPACE + +AUSSP LD A,20H +AUSSP1 OUT (S0BD),A + CALL SIOREA + RET + +; Unterprogramm fuer die Abfrage der Fertigmeldung des FDC + +FDCREA LD C,MSRFDC + LD B,80H + PUSH HL + POP HL + PUSH HL + POP HL ;Initialisierung einer Zeit + IN A,(C) ;Einlesen Hauptstatusregister + AND 0C0H + CP B + JR Z,TW1FDC + CALL ZEIT + CALL ZEIT + CALL ZEIT + IN A,(C) + CP B + PUSH AF + CALL NZ,FA3RET + POP AF +TW1FDC RET + +; Vereinbarungen fuer den Eigentest + +; Portadressen + +CTC0 EQU 8 +C0K0 EQU CTC0 +C0K1 EQU CTC0+1 +C0K2 EQU CTC0+2 +C0K3 EQU CTC0+3 + +CTC1 EQU 02CH +C1K0 EQU CTC1 +C1K1 EQU CTC1+1 +C1K2 EQU CTC1+2 +C1K3 EQU CTC1+3 + +SIO0 EQU 024H +S0AD EQU SIO0 +S0AC EQU SIO0+1 +S0BD EQU SIO0+2 +S0BC EQU SIO0+3 + +SIO1 EQU 028H +S1AD EQU SIO1 +S1AC EQU SIO1+1 +S1BD EQU SIO1+2 +S1BC EQU SIO1+3 + +PIO0 EQU 0CH +P0AD EQU PIO0 +P0AC EQU PIO0+1 +P0BD EQU PIO0+2 +P0BC EQU PIO0+3 + +PIO1 EQU 018H +P1AD EQU PIO1 +P1AC EQU PIO1+1 +P1BD EQU PIO1+2 +P1BC EQU PIO1+3 + +PIO2 EQU 1CH +P2AD EQU PIO2 +P2AC EQU PIO2+1 +P2BD EQU PIO2+2 +P2BC EQU PIO2+3 + +DMAADR EQU 3CH + +FDC EQU 20H +MSRFDC EQU FDC +DFDC EQU FDC+1 + +; Vereinbarungen fuer die SIO-Programmierung + +R0 EQU 0 +R1 EQU 1 +R2 EQU 2 +R3 EQU 3 +R4 EQU 4 +R5 EQU 5 +R6 EQU 6 +R7 EQU 7 +; +COMM6 EQU 30H ; FEHLER RUECKSETZEN +COMM3 EQU 18H ; KANAL RUECKSETZEN +COMM2 EQU 10H ; RUECKSETZEN EXT./STAT. INTERRUPT +NOPRTY EQU 0 ; PARITAETSPRUEFUNG AUSSCHALTEN +S2 EQU 0CH ; 2 STOP/BITS JE ZEICHEN +C16 EQU 40H ; *16 +RENABLE EQU 1 +B8 EQU 0C0H +XENABLE EQU 8 +T8 EQU 60H +PDAVCT EQU 18H +SAVECT EQU 04H +XMTRIE EQU 02H +C32 EQU 80H + +; Initialisierungstabelle fuer den SIO + +INITAB + DEFB COMM6 + DEFB COMM3 + DEFB R4+COMM2 + DEFB NOPRTY+S2+C32 + DEFB R3+COMM2 + DEFB RENABLE+B8 + DEFB R5+COMM2 + DEFB XENABLE+T8 + +; Initialisierungstabelle fuer den DMA + +DMATA DEFB 0C3H + DEFB 7DH + DEFB 0 + DEFB 21H + DEFB 0 + DEFB 1 + DEFB 0CFH + DEFB 14H + DEFB 10H + DEFB 80H + DEFB 0BDH + DEFB 0 + DEFB 20H + DEFB 12H + DEFB 40H + DEFB 1 + DEFB 0CFH + DEFB 5 + DEFB 82H +DMATE2 DEFB 87H + DEFB 0BBH + DEFB 7 +DMATE +DMATA1 DEFB 0ABH + DEFB 87H + DEFB 0BFH +DMATE1 + +; Initialisierungswerte fuer die ISR-Tabelle + +TABISR DEFW ISC0K0 + DEFW ISC0K1 + DEFW ISC0K2 + DEFW ISC0K3 + DEFW ISC1K0 + DEFW 0 + DEFW ISC1K2 + DEFW ISC1K3 + DEFW 0 + DEFW 0 + DEFW 0 + DEFW 0 + DEFW 0 + DEFW 0 + DEFW 0 + DEFW 0 + DEFW ISS0KB + DEFW 0 + DEFW 0 + DEFW 0 + DEFW ISS0KA + DEFW 0 + DEFW 0 + DEFW 0 + DEFW ISS1KB + DEFW 0 + DEFW 0 + DEFW 0 + DEFW ISS1KA + DEFW 0 + DEFW 0 + DEFW 0 + DEFW ISDMA + +; Vereinbarungen fuer die Merkzellen + +ADISR EQU 2300H +M1CISR EQU 234FH +MIDMA EQU 234FH +MIC0K0 EQU 2350H +MIC0K1 EQU 2351H +MIC0K2 EQU 2352H +MIC0K3 EQU 2353H +MIC1K0 EQU 2354H +MIC1K2 EQU 2355H +MIC1K3 EQU 2356H +MIP0KA EQU 2357H +MIP0KB EQU 2358H +MIP1KB EQU 2359H +MIP2KA EQU 235AH +MIP2KB EQU 235BH +MIS0KA EQU 235CH +MIS0KB EQU 235DH +MIS1KA EQU 235EH +MIS1KB EQU 235FH +MAWE EQU 2360H + + +; Ausschrift fuer die Meldung des Eigentest + +AUSHWT + DEFW 0D0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFW 0A0AH + DEFB 07H +AHWT1 DEFB 0DH + DEFB 0AH + DEFM 'P8000 Hardwaretest U880 - Version 3.1' + DEFB 0AH + DEFB 0DH + DEFB 20H + DEFB 20H ;2* Space wegen Testschrittnummer +ANZHWT EQU 68 + +; Ausschrift bei Fehler + +ADRERR DEFW 0808H ;2* Backspace wegen Loeschen der Testschrittnummer + DEFM '*** ERROR ' +ANAUSE EQU 12 + +; Ausgaben am Ende der Zeile + +ENDZEI DEFB 0AH + DEFB 0DH + DEFB 20H + DEFB 20H +ANZEZ EQU 4 + +; Ausschrift bei Fehler PIO1, Kanal A, Testwert AA (Test ohne verfuegbaren RAM) + +AUSF1 DEFW 0808H + DEFM '*** ERROR 10 18 AA ' + DEFW 0D0DH +ANAUS1 EQU 25 + +; Ausschrift bei Fehler PIO1, Kanal A, Testwert 55 (Test ohne verfuegbaren RAM) + +AUSF2 DEFW 0808H + DEFM '*** ERROR 10 18 55 ' + DEFW 0D0DH +ANAUS2 EQU 25 + +; Ausschrift bei Fehler CTC1, Kanal 1 (Test ohne verfuegbaren RAM) + +AUSF3 DEFW 0808H + DEFM '*** ERROR 15 2D 80 ' + DEFW 0D0DH +ANAUS3 EQU 25 + +; Ausschrift bei Fehler CTC1, Kanal1 (Test ohne verfuegbaren RAM) + +AUSF4 DEFW 0808H + DEFM '*** ERROR 16 2D 80 ' + DEFW 0D0DH +ANAUS4 EQU 25 + +; Ausschrift bei Fehler SIO0, Kanal B (Test ohne verfuegbaren RAM) + +AUSF5 DEFW 0808H + DEFM '*** ERROR 20 26 A0 ' + DEFW 0D0DH +ANAUS5 EQU 25 + +; Ausschrift bei Fehler SIO0, Kanal B (Test ohne verfuegbaren RAM) + +AUSF6 DEFW 0808H + DEFM '*** ERROR 21 26 50 ' + DEFW 0D0DH +ANAUS6 EQU 25 + +; Ausgabe der Testnummern zu Beginn des Eigentest, wenn kein Fehler +; auftrat (bei Test ohne verfuegbaren RAM) + +TENRAN DEFW 0808H + DEFM '10' + DEFW 0808H + DEFM '15' + DEFW 0808H + DEFM '16' + DEFW 0808H + DEFM '20' +ANZANF EQU 16 + +WEADP EQU 0 +RFF EQU 4 + +INSM1 + +MEMINI LD C,WEADP + LD DE,10H + XOR A +AUSWE LD B,A + OUT (C),D + ADD A,10H + DEC E + JR NZ,AUSWE + + LD D,1 + LD B,0 + OUT (C),D + IN A,(RFF) + LD B,10H + OUT (C),D + +INITSM + + LD A,57H + OUT (CTC1+1),A + LD A,2 + OUT (CTC1+1),A + + LD HL,INITAB + LD C,S0BC + LD B,8 + OTIR + + LD A,12H + OUT (S0BC),A + OUT (S1BC),A + LD A,20H + OUT (S0BC),A + LD A,30H + OUT (S1BC),A + + LD C,WEADP + LD D,4 + LD E,0EH + LD A,20H +AUSDR LD B,A + OUT (C),D + ADD A,10H + DEC E + JR NZ,AUSDR + LD BC,2000H + LD DE,0C000H + LD HL,0 + LDIR + JP RAMADR+0C000H +RAMADR LD C,WEADP + LD D,4 + LD B,0 +EINDR OUT (C),D + LD B,10H + OUT (C),D + LD BC,0C00H + LD DE,0 + LD HL,0CF00H + LDIR + LD HL,ANFSM+0C000H + LD B,ANZASM +NZSM LD A,(HL) + OUT (S0BD),A +WSFER IN A,(S0BC) + BIT 2,A + JR Z,WSFER + INC HL + LD D,0 +SLDEE DEC D + JR NZ,SLDEE + DJNZ NZSM + +; Initialisierung des PIO2 auf der U880-Karte +; + LD B,11 + LD HL,IOWERT+0C000H +ILOOP LD C,(HL) ;Adresse + INC HL + OUTI ;Ausgabe + JR NZ,ILOOP + +; Initialisierung DMA + LD HL,DMAINI+0C000H + LD BC,0B00H+DMAADR + OTIR +; + + LD A,0FFH + OUT (P0BD),A ;RESET-U8000 HIGH + + LD A,4FH ;PROGRAMMIERUNG PIO0 (KOPPELPIO) + OUT (P0AC),A ;PORT A: INPUT + IN A,(P0AD) ;SCHEINEINGABE + + LD BC,0C00H + LD HL,0CF00H + LD DE,0 +NVERGL LD A,(DE) + CP (HL) + JR NZ,ERR35 + INC DE + INC HL + DEC BC + LD A,B + OR C + JR NZ,NVERGL + + LD HL,0D00H +NWZUDR LD A,(HL) + LD D,A + XOR A + LD (HL),A + LD A,(0C000H) + LD A,(HL) + AND A + JR NZ,ERR34 + LD A,D + LD (HL),A + LD A,(0C000H) + LD A,(HL) + CP D + JR NZ,ERR34 + INC HL + LD A,H + CP 30H + JR NZ,NWZUDR + + LD HL,0D00H +NWZDR1 LD A,(HL) + LD D,A + LD A,0FFH + LD (HL),A + LD A,(0C000H) + LD A,(HL) + CP 0FFH + JR NZ,ERR34 + LD A,D + LD (HL),A + LD A,(0C000H) + LD A,(HL) + CP D + JR NZ,ERR34 + INC HL + LD A,H + CP 30H + JR NZ,NWZDR1 + + + +MZU0 LD C,S0BC + LD A,11H + OUT (C),A + LD A,1CH + OUT (C),A + + XOR A + OUT (CTC0),A + + XOR A + LD (0E88H),A ;Floppy-Neuinitialisierung fuer Start aus SMON + + DI + + JP 0 + +ERR34 + LD HL,AUSE34+0C000H +A34 LD B,ANZ34 + LD C,S0BD +SLE34 OUTI + INC B +ABFE34 + IN A,(S0BC) + BIT 2,A + JR Z,ABFE34 + LD D,0 +ZSLA34 DEC D + JR NZ,ZSLA34 + DJNZ SLE34 + JP MZU0+0C000H + +ERR35 LD HL,AUSE35+0C000H + JR A34 +;;;;;;;;;;;;;;;;;;;;;;;;; + + + +; +DMAINI DEFB 0C3H ;DMA Reset + DEFB 5 ;Speicher ist Quelle, FDC ist Ziel, keine Adressen, Datentransfer + DEFB 54H ;Time Byte folgt, Port A-MREQ, Adresse inkrementiert + DEFB 0FCH ;Time-Byte (4 Takte) + DEFB 78H ;Time Byte folgt, Port B-IORQ, Adresse fest + DEFB 0FCH ;Time Byte (4 Takte) + DEFB 95H ;Byte-Mode, IC-Byte folgt, Adresse Port B folgt + DEFB 21H ;Adresse FDC + DEFB 12H ;Int.-Vektor folgt, Interrupt bei Blockende + DEFB INTABD.AND.0FFH ;Interruptvektor + DEFB 8AH ;Ready ist "high activ" +; +; +; Initialisierungswerte fuer PIO2 +IOWERT + DEFB PIO2AC + DEFB 0CFH ;Modeauswahl --> Bit-Mode + DEFB PIO2AC + DEFB 80H + DEFB PIO2AC + DEFB 3 + DEFB PIO2AD + DEFB 5FH ;Motoren aus, TC ein, Praekompensation aus + ;5,25"-Laufwerke + DEFB PIO2AD + DEFB 1FH ;TC aus + DEFB PIO2BC + DEFB INTABP.AND.0FFH ; LOW-TEIL DES INT.VEKT. + DEFB PIO2BC + DEFB 0CFH ;Modeauswahl --> Bitmode + DEFB PIO2BC + DEFB 010H ;Festlegung E/A-Bits fuer Bit-Mode + DEFB PIO2BC + DEFB 0B7H ;Interruptsteuerung Port B + ;EI/Maske folgt/jedes auf HIGH gehende + ;Bit loest Interrupt aus + DEFB PIO2BC + DEFB 0EFH ;nur Bit 4 kann Interrupts ausloesen (FDC) + DEFB PIO2BD + DEFB 0FH ;Index erlaubt, kein Laufwerk selektiert +; +;Adressen der benutzten peripheren Schaltkreise +PIO2AD EQU 01CH +PIO2AC EQU 01DH +PIO2BD EQU 01EH +PIO2BC EQU 01FH +MSR EQU 020H +DATREG EQU 021H +CTC EQU 08H +; +;Adressen der Interruptserviceroutinen +INTABP EQU 0F1AH +INTAB EQU 0F00H +INTABD EQU 0F1CH + +ANFSM DEFB 0AH + DEFB 0DH + DEFM 'U880-Softwaremonitor Version 3.1 - Press RETURN' + DEFB 0AH + DEFB 0DH +ANZASM EQU 51 + +AUSE34 DEFM 'ERROR 34' + DEFB 0AH + DEFB 0DH +ANZ34 EQU 10 +AUSE35 DEFM 'ERROR 35' + DEFB 0AH + DEFB 0DH + + + ORG 0EF0H + + DI + LD D,1 + LD B,0 + LD C,0 + OUT (C),D + LD B,10H + OUT (C),D + JP ENSMON + + +CRCEP0 EQU 1FF8H +NCEP0 EQU 1FFAH +CRCEP1 EQU 1FFCH +NCEP1 EQU 1FFEH + diff --git a/firmware/MON8/U880SM.S b/firmware/MON8/U880SM.S new file mode 100644 index 0000000..9951042 --- /dev/null +++ b/firmware/MON8/U880SM.S @@ -0,0 +1,1637 @@ +*H P8000 U880-FIRMWARE 3.0 +*P 84 +;****************************************************************************** +;* * +;* * +;* P8000 - SOFTWARE * +;* * +;* Entwicklerdokumentation * +;* * +;* Betriebssystem UDOS * +;* * +;* Programm: U880SM * +;* * +;* Version: 3.1 * +;* * +;* Bearbeiter: M. Weber * +;* * +;* Datum: 05.07.1989 * +;* * +;* * +;****************************************************************************** +; +; +;******************************************************** +;* * +;* P8000 U880-SOFTWAREMONITOR * +;* * +;******************************************************** +; +; +; +ENTRY +; + JR INIGO0 + DEFM '(C)EAW' +; +RST1 DEFS 3 +; + DEFM '8801 ' +; +RST2 DEFS 3 +INIGO0 + LD A,NRET + JR GO01 + DEFS 1 +; +; +RST3 DEFS 3 +GO01 + LD (DSEL),A + JR GO02 +; +; +RST4 DEFS 3 +GO02 + LD HL,DPAVEC + JR GO03 +; +; +RST5 DEFS 3 +GO03 + LD B,FDCONF-DPAVEC + JP GO04 +; +; +RST6 DEFS 8 +; +; +;EINTRITTSPUNKT FUER TESTROUTINEN +BRKENTRY: +; + LD (HL_),HL + EX (SP),HL ;HL:=PC+1 + DEC HL ;HL:=PC + INC SP ;RST AUSGLEICHEN + INC SP +NMIBRK + LD (SP_),SP + LD SP,SP_ + PUSH HL + PUSH IY + PUSH IX + EXX + EX AF,AF' + PUSH HL + PUSH DE + PUSH BC + PUSH AF + EXX + EX AF,AF' + PUSH DE + PUSH BC + PUSH AF +; + LD A,I + PUSH AF ;INT.-VEKTOR + INT.ENABLE FLIP-FLOP +; + XOR A ;ZERO --> 1 + LD SP,STACK + CALL BREAK ;BREAKPOINT LOESCHEN + LD HL,BRKLOP + PUSH HL + RETI +; +;EINTRITTSPUNKT FUER NMI +NMIENTRY + LD (HL_),HL + LD HL,NMIBRK + EX (SP),HL + RETN +; +GO04 +; +LOP01: LD (HL),0 ;RAM LOESCHEN DPAVEK - INVEK + INC HL + DJNZ LOP01 +; +; +; +; Initialisierung von Zellen fuer die Terminalarbeit +; + LD A,10H + LD (MCSQ),A + LD A,0E0H + LD (APEIN),A + LD (APAUS),A +; +; INITIALISIERUNG DER ISR-TABELLE FUER DEN SIO +; + LD HL,SIOTAB + LD DE,ITABS0+2 + LD BC,6 + LDIR + + +;INITIALISIERUNG DER KOPPELSCHNITTSTELLE + + + LD HL,KBC0 ;PORT B: BIT-MODE + LD C,P0BC + LD B,3 + OTIR + + LD A,80H + OUT (P0BD),A ;RESET U8000 HIGH + + + +;VARIABLEN BLOCKTRANSFER + + LD HL,BASVAR + LD DE,NULLCT + LD BC,CURT0-NULLCT + LDIR + +BRKLOP: + LD SP,STACK + LD A,ITABC0.SHR.8 ;A:= HIGH ADRESSE DES INT. VEKTORS +; +ENTRY1 + LD I,A + IM 2 + EI +; + JP PE,SYSST +; +;RESTLICHES VARIABLENFELD INITIALISIEREN +;HL ZEIGT BEI NEUSTART AUF CURT0 + EX DE,HL + LD B,10 ;FLOPPY-LISTE UND MZNEXT +ILOOP1 LD (HL),-1 + INC HL + DJNZ ILOOP1 +; + LD B,4 ;ADRFLG UND TASTATURMERKZELLEN +ILOOP2 LD (HL),0 + INC HL + DJNZ ILOOP2 + LD (HL),0FBH ;ENABLE INT + INC HL + LD (HL),0C3H ;JUMP EINTRAGEN +;STACKPOINTER FUER DEBUG INITIALISIEREN + LD HL,STACK + LD (SP_),HL +; +*I FDINIT.S +; +RASC LD HL,CONOBF ;OUTPTR INITIALISIEREN + LD (OUTPTR),HL + CALL INASC + CP CR + JP NZ,BDEC0 +; + LD A,(FDCONF) + LD (MFDC),A + +;BOOT EINLESEN +BOOT: LD IY,DPAVEC ;STANDARD PARAMETERVEKTOR AUFBAUEN + LD HL,KOMINT ;DATA TRANSFER ADRESS + LD (DPAVEC+2),HL + LD HL,138 ;DATA LENGTH LADEN + LD (DPAVEC+4),HL +; + LD A,80H + LD (DSEL),A + LD HL,0000 + LD (CRCERR),HL + LD (TRKERR),HL + LD (SECERR),HL + LD (DPAVEC+11),HL + LD (IY+1),RDBIN ;REQUEST CODE LADEN + CALL DISK ;DISKETTENZUGRIFF + LD A,(IY+10) + CP NRET ;NORMAL RETURN ? + JP Z,TESTSD ;TESTEN SYSTEMDISKETTE +; + CP 0C2H + JR Z,BOOTER ;DRIVE NOT READY +; + LD HL,FDCONF + INC (HL) + LD A,(HL) + CP 8 + JR C,BOOT +; +; +BOOTER + LD A,(MFDC) + LD (FDCONF),A ;ALTEN WERT ZURUECKHOLEN + LD SP,STACK + LD A,'>' + LD (PROMPT),A + LD HL,TDERR ;TEXT "DISK ERROR" + CALL OUTAS ;AUSGABE ASC-ZEICHEN UEBER PCON + JP RASC +; +; Test, ob wirklich eine Systemdiskette im Laufwerk 0 ist +; Pruefen der Kennzeichnung 'P8000SYS' +; +TESTSD + LD HL,KENNSD + LD DE,0C80H + LD BC,8 +NWSYS LD A,(DE) + CPI + JR NZ,AUSISD + INC DE + JP PE,NWSYS + + LD HL,(0C7EH) ;FDCONF von Diskette holen + LD (FDCONF),HL + JP KOMINT + +AUSISD LD SP,STACK + LD HL,SDERR + CALL OUTAS + JP RASC + +; +; +SYSST + LD A,0FBH ;EI ZURUECKSSCHREIBEN + LD (GOJMP),A + LD A,(INT) ;INT.ENABLE FLIP-FLOP RETTEN + AND 4 + CALL INSTA2 + LD A,(BRKFLG) + BIT 7,A + JR Z,SYSST1 + LD HL,(BRKRET) + JP (HL) +; +SYSST1: + LD A,(MZNEXT) + AND A + JR NZ,TBAUS + CALL OUTRW + LD A,(EIINS) + LD HL,(EIADR) + LD (HL),A +NEXTE: LD HL,N_ + DEC (HL) + JP NZ,NEXLOP + JP DEBUG +TBAUS: + LD HL,TBREA + CALL OUTAS + LD HL,(PC_) + CALL BTOHA + CALL OUTZL ;AUSG: 'BREAK XXXX' +; +;BEFEHLSDECODIERUNG EINGABEKOMMANDOS +BDEC: CALL INASC ;EINGABE ASC- ZEICHEN UEBER PCON +BDEC0: LD HL,DEBUG + PUSH HL + CP CR ;CARRIAGE RETURN + LD HL,MZNEXT + JR NZ,BDEC1 + AND (HL) + JR NZ,ERROR + JP NEXNL +; +BDEC1 + LD (HL),-1 ;RESET MZNEXT + LD HL,(INPTR) + RES 5,A + CP 'F' ;FILL ? + JP Z,FILL + CP 'G' ;GO ODER GET ? + JP Z,GOGET + CP 'M' ;MOVE ? + JP Z,MOVE +;CP 'I' +;JP Z,INSTAT ;INT-STATUS + CP 'D' ;DISPLAY ? + JP Z,DISPL + CP 'P' ;I/O-PORT + JP Z,IOPORT + CP 'O' ;OPERATING SYSTEM ? + JR NZ,BDEC2 + POP HL ;SP ZURUECKSTELLEN + JP BOOT +BDEC2: CP 'R' ;REGISTER ? + JP Z,REGIST + CP 'Q' ;QUIT ? + JR NZ,BDEC3 + CALL NSIGN + LD HL,BRKFLG + BIT 5,(HL) + JR Z,ERROR + LD HL,(EXTRET) + JP (HL) +; +BDEC3: CP 'S' ;SAVE ? + JP Z,BOOT + CP 'B' ;BREAK ? + JP Z,BREAK + CP 'N' ;NEXT + JR Z,NEXT + CP 'X' + JR Z,U8000SM + CP 'T' + JR Z,EIGT +ERROR: LD SP,STACK + LD HL,FRAGZ ;FRAGEZEICHEN AUSGEBEN + CALL OUTAS ;AUSGABE ASC-ZEICHEN UEBER PCON +;******************************************************** +;* * +;* DEBUG-EINTRITTSPUNKT * +;* * +;******************************************************** +DEBUG: LD A,'>' ;PROMPT MIT '>' LADEN + LD (PROMPT),A + LD HL,BRKFLG + BIT 6,(HL) + RES 6,(HL) + JP Z,BDEC + LD HL,(EXTRET) + JP (HL) +; +; +U8000SM + CALL NSIGN + RES 5,A + CP 'R' + PUSH AF + LD A,1 + LD C,0 + LD B,0D0H + OUT (C),A + JP 0DB00H + +EIGT + LD A,20H + CALL PUTA + CALL PUTA +EIGT1 IN A,(S0BC) + BIT 2,A + JR Z,EIGT1 + LD A,1 + LD C,0 + LD B,0C0H + OUT (C),A + JP 0CEF0H + + +;******************************************************** +;* * +;* NEXT * +;* * +;******************************************************** +; +NEXT: + CALL OUTRB + CALL INHZ + JR NZ,NEXT1 +NEXNL: LD A,1 ;KEINE ZAEHLEREINGABE +NEXT1: + LD (N_),A ;DURCHLAUFZAEHLER +NEXLOP + DI + SUB A + LD (MZNEXT),A + LD (GOJMP),A ;EI VOR "GO" ABSPRUNG LOESCHEN + LD DE,(PC_) + DEC DE ;PC:=N-1 WEGEN EI EINTRAG + LD HL,TRCINT + LD (ITABC0+4),HL ;STARTADRESSE IN DIE ISR TABELLE LADEN + LD A,ITABC0.SHR.8 ;A:= HIGH ADRESSE DES INT. VEKTORS + LD (I_),A + LD A,87H ;CTC ALS TIMER PROGRAMMIEREN + OUT (CTC0+2),A + LD A,1 ;ZEITKONSTANTE + OUT (CTC0+2),A + EX DE,HL + LD (EIADR),HL + LD A,(HL) + LD (EIINS),A + LD (HL),0FBH ;EI LADEN + LD (PC_),HL + JP REALT +; +; +;NEXT INTERRUPT SERVICE ROUTINE LADEN +TRCINT: + LD (HL_),HL + PUSH AF + LD A,3 + OUT (CTC0+2),A ;CTC STOPPEN + POP AF + LD HL,NMIBRK + EX (SP),HL + RETI +;******************************************************** +;* * +;* BREAK * +;* * +;******************************************************** +BREAK: + AND A + PUSH AF + LD HL,(BRKADR) ;BREAKPOINT N-1 LOESCHEN + XOR A + CP L + JR NZ,BREAK2 + CP H + JR Z,BREAK1 +BREAK2 LD A,(INS) + LD (HL),A +BREAK1 POP AF + LD A,(INS) + LD HL,0 + LD (BRKADR),HL + RET Z ;RUECKSPRUNG WENN AUFRUF AUS + ;DER REGISTERRETTUNGSROUTINE + CALL INHZAD ;NEUE BREAKPOINTADRESSE LESEN + RET Z ;KEINE ADRESSE--> NUR LOESCHEN + LD A,(HL) + LD (INS),A ;BYTE RETTEN + LD (HL),-1 ;NEUEN BREAKPOINT SETZEN + LD (BRKADR),HL + RET +; +;******************************************************** +;* * +;* INT-STATUS * +;* * +;******************************************************** +;INSTAT +;LD HL,GOJMP +;SUB A +;BIT 3,(HL) +;JR Z,INSTA1 +;INC A +;INSTA1 +;CALL BTOHD +;CALL OUTBYT +;CALL INBYT +;RET Z +INSTA2: + LD HL,GOJMP + RES 3,(HL) ;F3H-->DISABLE INT. + AND A + RET Z + SET 3,(HL) ;FBH-->ENABLE INT. + RET +;******************************************************** +;* * +;* I/O-PORT * +;* * +;******************************************************** +IOPORT + CALL NSIGN + CP 'R' + JR Z,IOREAD + CP 'W' + JP NZ,ERROR +; +IOWRITE + CALL INHZ ;ADRESSE +IOERR JP Z,ERROR + PUSH HL + CALL INHZ ;DATENBYTE + POP BC + JR Z,IOERR + OUT (C),A + RET +; +IOREAD + CALL INHZ ;ADRESSE + PUSH HL + POP BC + IN A,(C) + CALL BTOHD + CALL OUTZL + RET + +;******************************************************** +;* * +;* DISPLAY * +;* * +;******************************************************** +DISPL: CALL INHZAD + PUSH HL + CALL INHZ + JR Z,DISP6 + LD B,H + LD C,L + POP HL + EXX +; +;CONOBF LOESCHEN +DISP0: LD HL,CONOBF ;BLOCKTRANSFER + LD DE,CONOBF+1 + LD BC,49H + LD (HL),' ' + LDIR +; + LD B,10H + LD HL,CONOBF+53 + LD (HL),'*' + INC HL + EXX + CALL INHZS ;ADRESSE-XXXXH UEBER OUTPTR EINTRAGEN +DISP1: LD A,(HL) + EXX + LD (HL),A + CP ' ' ;SPACE + JR C,DISP2 + CP 127 ;128 ZEICHEN AUSGEGEBEN ? + JR C,DISP3 +DISP2: LD (HL),'.' ;PUNKT EINTRAGEN +DISP3: INC HL + LD (HL),'*' + EXX + CALL BTOHD ;DATEN EINTAGEN + CPI + JP PE,DISP4 ;SPRUNG WENN KEINE ANZAHL EINGEGEBEN + EXX + INC HL + LD (OUTPTR),HL + JP OUTZL ;AUSGABE DER ZEILE +; +; +DISP4: EXX + DJNZ DISP5 + INC HL + LD (OUTPTR),HL + CALL OUTZL + JR DISP0 ;NAECHSTE ZEILE AUSGEBEN +DISP5: EXX + JR DISP1 +DISP6: POP HL +DISP7: PUSH HL + CALL INHZS + LD A,(HL) + CALL BTOHD + CALL OUTBYT + LD A,':' + CALL PUTA + CALL INBYT + JR Z,DISP8 + POP HL + LD (HL),A + PUSH HL + CALL SSIGK +DISP8: POP HL + CP 'Q' ;QUIT + RET Z +;RUECKWAERTS EINTRAGEN ? + CP '^' + JR NZ,DISP9 + DEC HL + JR DISP7 +; +DISP9 + INC HL + JR DISP7 +;******************************************************** +;* * +;* FILL * +;* * +;******************************************************** +FILL: CALL INHZAD ;ANFANGS-ADRESSE EINLESEN + JR Z,FILERR + PUSH HL + CALL INHZAD ;END-ADRESSE EINLESEN +FILERR: JP Z,ERROR + PUSH HL + CALL INHZ ;KONSTANTE EINLESEN + LD A,L + AND A + POP HL + POP DE + LD (DE),A + SBC HL,DE + RET Z +; + LD B,H ;BLOCKTRANSFER + LD C,L + LD H,D + LD L,E + INC DE + LDIR + RET +; +GOGET: CALL NSIGN ;NAECHSTES ZEICHEN EINLESEN + CP 'E' + JP Z,BOOT ;JP WENN GET + CALL INHZ + JR Z,GO + LD (PC_),HL +; +;******************************************************** +;* * +;* GO * +;* * +;******************************************************** +GO +REALT + LD SP,AF_ + POP AF ;REGISTER RUECKSPEICHERN + POP BC + POP DE + EX AF,AF' + EXX + POP AF + POP BC + POP DE + POP HL + POP IX + POP IY + EXX + EX AF,AF' + POP HL ;PC RUECKSPEICHERN + LD (GOJMP+2),HL + LD HL,(HL_) ;HL RUECKSPEICHERN + LD SP,(SP_) ;SP RUECKSPEICHERN + JP GOJMP ;SPRUNG IN DEN RAM +; +;DANN FOLGT UEBER DIE BEFEHLE: EI ODER DI;A;JP (PC_) +;DER BEGINN DER ABARBEITUNG DES USER PROGRAMMS +; +; +;******************************************************** +;* * +;* MOVE * +;* * +;******************************************************** +; +MOVE: CALL INHZAD ;ZIELADRESSE EINLESEN + PUSH HL + CALL INHZAD ;QUELLADRESSE EINLESEN + PUSH HL + CALL INHZ ;BYTEZAHL EINLESEN + JP Z,ERROR ;ERROR ANSPRUNG + LD B,H + LD C,L + POP DE + POP HL + PUSH HL + AND A + SBC HL,DE + POP HL + JR C,MOVE1 + LDIR + RET +; +; +MOVE1: ADD HL,BC + DEC HL + EX DE,HL + ADD HL,BC + DEC HL + EX DE,HL + LDDR + RET +;******************************************************** +;* * +;* REGISTER * +;* * +;******************************************************** +; +REGIST CALL SSIGN + LD A,CR + LD D,(HL) ;REGISTERBEZEICHNUNG LADEN + CP D + JR Z,ALLREG + INC HL + LD E,(HL) + CP E + JR NZ,REG16 ;16 BIT REGISTER AUSGEBEN + LD E,' ' +REG16 CALL REGADR + DEC HL + DEC HL + JP NZ,ERROR +REGLOP LD DE,CONOBF + LDI + LDI + PUSH HL + EX DE,HL + LD (HL),' ' + INC HL + LD (OUTPTR),HL + LD E,(IX+0) + LD D,HL_.SHR.8 + LD A,HLS_+1.AND.0FFH + SUB E + JR C,REGOUT +; + LD A,(DE) + CALL BTOHD + CALL OUTBYT + LD A,':' + CALL PUTA + CALL INBYT + JR Z,REGEND + LD (DE),A + CALL SSIGK +REGEND: CP 'Q' ;QUIT ? + POP HL + RET Z +; + INC IX + LD A,LADRRB-1.AND.0FFH + SUB L + JR NC,REGLOP + RET +; +; +REGOUT: LD A,(DE) + LD L,A + INC DE + LD A,(DE) + LD H,A + PUSH DE + CALL BTOHA + CALL OUTBYT + LD A,':' + CALL PUTA + CALL INBYT + POP DE + JR Z,REGEND + EX DE,HL + LD (HL),D + DEC HL + LD (HL),E + CALL SSIGK + JR REGEND +; +;ALLE REGISTER AUSGEBEN +ALLREG: CALL OUTRB ;AUSGABE REGISTERBEZEICHNUNGEN + CALL OUTRW ;AUSGABE REGISTERWERTE + RET +; +; +; +;******************************************************** +;* * +;* UNTERPROGRAMME * +;* * +;******************************************************** +INHZS: PUSH HL ;ADRESSENUMSCHALTUNG MONITOR-->USER + LD DE,0 + AND A ;CARRY=0 + SBC HL,DE ;1000H ODER 0 SUBTRAHIEREN + CALL BTOHA ;KONVERTIERT EINE ADRESSE IN DAS + POP HL ;HEXA-SYSTEM + RET +; +; +;AUSGABE DER REGISTERBEZEICHNUNGEN AUF RAM-BEREICH +OUTRB: LD DE,CONOBF ;AUSGABE:A,B,C,D,E,F,H,L,I UND STRICHREG. + LD HL,REGBEZ + LD B,11H + LD A,' ' +OUTB1: LD C,0FFH + LDI ;REGISTERBEZ.-->(DE) + LDI ;SPACE-->(DE) + LD (DE),A ;SPACE--> (DE) + INC DE + DJNZ OUTB1 +; + LD B,4 ;AUSGABE:IX,IY,PC UND SP +OUTB2: LD C,0FFH + LD (DE),A + INC DE + LDI + LDI + LD (DE),A + INC DE + LD (DE),A + INC DE + DJNZ OUTB2 +; + LD (OUTPTR),DE ;LETZTE ADR DER ZEICHENKETTE RETTEN + JR OUTW3 +; +;********************************************************************* +;AUSGABE DER REGISTERWERTE AUF RAM-BEREICH +OUTRW: LD B,17 ;ZAEHLER HL_,I_,AF_,BC_ ... + LD IX,LADRRB + LD D,HL_.SHR.8 +OUTW1: LD E,(IX+0) ;DE ZEIGT AUF REGISTERRETTUNGSBEREICH + LD A,(DE) + CALL BTOHD + INC IX + DJNZ OUTW1 + LD B,4 ;ZAEHLER IX_,IY_,PC_,SP_ +OUTW2: LD E,(IX+0) + EX DE,HL + LD E,(HL) + INC HL + LD D,(HL) + EX DE,HL + CALL BTOHA + INC IX + DJNZ OUTW2 +; +OUTW3: JP OUTZL ;AUSGABE EINER ZEILE +; +;********************************************************************* +;STANDARD PARAMETERVEKTOR FUER PCON INITIALISIEREN +;ASC-ZEICHEN EINLESEN +INASC: LD IY,CONIV ;CONIVC-->CONSOLE INPUT VECTOR + LD HL,CONIBF ;DATA TRANSFERADRESS LADEN + LD (CONIV+2),HL + LD (INPTR),HL + LD HL,0FFH ;DATA LENGTH LADEN + LD (CONIV+4),HL + LD (IY+1),RDASC ;REQUEST CODE LADEN + CALL PCON ;AUGABE AUF TERMINAL + LD A,(CONIBF) ;A:=ASC-ZEICHEN + RET +;********************************************************************* +; +;SUCHT NAECHSTES ZEICHEN=/SPACE & KLEINBUCHSTABEN RUECKSETZEN +; +SSIGK: CALL SSIGN + RES 5,A + RET +; +; +;********************************************************************* +;NAECHSTES ZEICHEN EINLESEN +NSIGN: INC HL + LD A,(HL) + RES 5,A ;KLEINBUCHSTABEN RUECKSETZEN + RET +; +;SUCHT NAECHSTES ZEICHEN=/SPACE +; +SSIGN: LD HL,(INPTR) ;ADR.DER PARAMETERLISTE +SSIG1: LD A,(HL) ;ASCII-ZEICHEN EINLESEN + CP ' ' + JR NZ,SSIG4 +; +SSIG2: INC HL + LD A,(HL) + CP ' ' + JR Z,SSIG2 ;SPACE UEBERGEHEN +; +SSIG3: LD (INPTR),HL ;INPTR ZEIGT AUF 1.ZEICHEN=/SPACE + RET +; +SSIG4: CP CR ;CARRIAGE RETURN + JR Z,SSIG3 + INC HL + JR SSIG1 +; +;************************************************************************ +;EINLESEN VON HEXA-DEZIMALZAHLEN +;OUTPUT:BIN-ZAHL IN HL +; +INHZ: LD HL,0 + PUSH HL + ADD HL,SP ;HL:=SP + EX DE,HL ;DE:=SP + CALL SSIGN + CP CR ;CARRIAGE RETURN + EX DE,HL + JR NZ,INHZ1 +; + POP HL + LD A,L + RET +; +INHZ1: CP 30H ;0 +KERRO: JP C,ERROR ;SPRUNG WENN SONDERZEICHEN +INHZ3: CP 40H ;ZAHLEN ODER BUCHSTABEN + JR C,INHZ4 ;SPRUNG WENN ZAHLEN 0....9 + RES 5,A +INHZ4: CALL HTOB ;BIN-ZAHL IN L-TETRADE VON A + RLD + INC HL +JPGET1: RLD ;EINSPRUNG AUS GET AUF 2.BYTE + DEC HL + INC DE ;INPTR:=INPTR+1 + LD A,(DE) ;NAECHSTES ASCII-ZEICHEN EINLESEN + CP 30H ;SPRUNG WENN HEXA-ZEICHEN + JR NC,INHZ3 +; +; + POP HL ;SPACE GELESEN ! + LD A,L + RET +; +;************************************************************************ +;KONVERTIERT EINE HEXA-ZAHL INEINE 4 BIT-ZAHL +; +HTOB: CP 3AH ;TEST: ZAHLEN VON 0....9 + JR C,HTOB1 + CP 'A' ;TEST: BUCHSTABEN VON A....F + JR C,KERRO ;SPRUNG WENN FEHLER-->KEIN HEXA-ZEICHEN + CP 'G' ;TEST: ASCII-ZEICHEN > 'G' -->KEINE + JP NC,ERROR ;HEXA-ZEICHEN + SUB 7 +HTOB1: AND 0FH + RET +; +;********************************************************************* +;BTOHA:KONVERTIERT 2 DURCH(OUTPTR) ADRESSIERTE RAM-PLAETZE (ADRESSEN) +;IN DAS HEXADEZIMALSYSTEM +;INPUT:BIN-ZAHL IN HL +BTOHA: PUSH DE + LD A,H + CALL BTOHD + LD DE,(OUTPTR) ;OUTPTR LADEN + DEC DE ;SPACE EINTRAGUNG IN BTOHD RUECKSETZEN + LD (OUTPTR),DE + POP DE + LD A,L +; +BTOHD: PUSH HL + LD HL,(OUTPTR) + CALL BTOHE + INC HL + LD (HL),' ' + INC HL + LD (OUTPTR),HL + POP HL + RET +; +;********************************************************************* +;BTOHEX: KONVERTIERT EINE 8-BIT BIN-ZAHL IN EINE HEXA-ZAHL +BTOHE: PUSH AF + RRA + RRA + RRA + RRA + CALL HBTHE ;KONVERTIERT DIE 4 HOEHERWERTIGEN BITS + INC HL + POP AF + CALL HBTHE ;KONVERTIERT DIE 4 NIEDERWERTIGEN BITS + RET +; +;******************************************************************** +;HBTHEX: KONVERTIERT EINE 4-BIT BIN-ZAHL IN EIN HEXA-ASCII-ZEICHEN +HBTHE: AND 0FH + CP 10 ;DEZIMALZEICHEN ? + JR C,HB10 + ADD A,7 +HB10: ADD A,30H + LD (HL),A ;ZEICHEN IN RAM-BEREICH LADEN + RET +; +;********************************************************************* +REGADR: LD IX,LADRRB + LD A,D + LD BC,2AH + LD HL,REGBEZ ;REGISTERBEZEICHNUNGEN +REGAD0: CPI + JR Z,REGAD2 + CPI +;EINSPRUNG AUS GET AUF REGAD1 +JPGET2 +REGAD1: RET PO + INC IX + JR REGAD0 +; +REGAD2: LD A,E + CP 2FH + JR C,REGAD3 + RES 5,A +REGAD3: CPI + RET Z + LD A,D + JR REGAD1 +; +INBYT: LD A,' ' + LD (PROMPT),A + CALL INASC ;EINGABE ASC-ZEICHEN UEBER PCON + RES 5,A + CP 'Q' ;QUIT ? + RET Z + CP '^' + RET Z ;ADRESSE BEI DISP ZURUECKSTELLEN + LD HL,CONIBF-1 + LD (HL),' ' + LD (INPTR),HL + PUSH DE + CALL INHZ + POP DE + RET +; +; +;AUSGABE EINER ZEILE +OUTZL: LD A,85H ;ZEILENLAENGE LADEN +OUTZV: PUSH HL ;EINSPRUNG FUER AUSGABE MIT + ;VARIABLER ZEILENLAENGE + LD HL,(OUTPTR) + LD (HL),CR ;CARRIAGE RETURN AN ZEICHENKETTE ANFUEGEN + LD HL,CONOBF ;BEGINN DER ZEICHENKETTE IM RAM (CONOBV) + LD (OUTPTR),HL ;OUTPTR INITIALISIEREN + DEC HL +OUTZ: LD (HL),A + CALL OUTAS ;AUSGABE ASC-ZEICHEN UEBER PCON + POP HL + RET +; +;********************************************************************* +; +OUTBYT: PUSH HL + PUSH DE + LD HL,(OUTPTR) + LD DE,CONOBF ;BEGINN DER ZEICHENKETTE IM RAM + LD (OUTPTR),DE + AND A + SBC HL,DE ;ANZAHL DER AUSZUGEBENDEN ZEICHEN + EX DE,HL + DEC HL + LD (HL),E + CALL OUTAS + POP DE + POP HL + RET +; +;******************************************************************** +;MOEGLICHKEIT ZUR ADRESSVERSCHIEBUNG +;ADRESSE:=ADRESSE+(ADRFLG) +; +INHZAD: CALL INHZ + LD DE,0 + ADD HL,DE + RET +; +;********************************************************************* +;STANDARD PARAMETERVEKTOR FUER PCON INITIALISIEREN +;ASC-ZEICHEN AUSGEBEN +OUTAS: LD IY,CONOV ;IY:=CONOVC + LD A,(HL) ;A:=DATA LENGTH + INC HL + LD (CONOV+2),HL + LD (IY+4),A ;DATA LENGTH LADEN + LD (IY+5),0 + LD (IY+1),WRASC +;******************************************************** +;* * +;* PROM CONSOLTREIBER * +;* * +;******************************************************** +PCON: PUSH DE + PUSH BC + LD A,(IY+1) ;REQUEST CODE LADEN + RES 0,A + CP RDBIN + JR NC,PCO2 ;TEST UNTERE GRENZE REQUEST CODE +PCO0: LD (IY+10),NRET ;COMPLETION CODE LADEN +PCO4: POP BC + POP DE + BIT 6,(IY+10) + JR Z,PCO1 ;JMPIF VALID OPERATION REQUEST CODE +PCONOUT + LD H,(IY+9) ;ERROR RETURN ADRESS LADEN + LD L,(IY+8) + LD A,H + OR L + JR Z,PCO1 ;JMP IF ERROR RETURN ADRESS =0 + JP (HL) ;JMP TO ERROR DOKUMENTATION +; +PCONEND +PCO1 + BIT 0,(IY+1) ;REQUEST CODE INCREASED ? + RET Z ;RUECKSPRUNG + LD H,(IY+7) ;HL:= COMPLETION RETURN ADRESS + LD L,(IY+6) + JP (HL) +; +; +PCO2: CP 11H ;TEST OBERE GRENZE REQUEST CODE + JR C,PCO3 + LD (IY+10),0C1H ;INVALID OPERATION REQUEST + JR PCO4 +; +PCO3: LD H,A ;H:=REQUEST CODE + LD A,(IY+4) + OR (IY+5) ;DATA LENGTH=0 ? + JR Z,PCO0 + LD A,H ;A:=REQUEST CODE + LD H,(IY+3) ;HL:=DATA TRANSFER ADRESS + LD L,(IY+2) + LD B,(IY+5) ;BC:=DATA LENGTH + LD C,(IY+4) + CP WRBIN + JR C,PCO5 ;JMP IF RDASC OR RDBIN + JR Z,PCWBIN ;JMP IF WRBIN +;************************************************ +;* * +;* WRITE-ASCII * +;* * +;************************************************ +; +PCWASC: LD A,(HL) + CALL PUTA ;AUSGABE EINES ZEICHENS + INC HL + DEC BC ;DATA LENGTH -1 + CP CR + JR Z,PCNL ;NL AUSGEBEN +; + LD A,C + OR B + JR NZ,PCWASC +PCO10: LD H,(IY+5) ;HL:=DATA LENGTH + LD L,(IY+4) + SBC HL,BC + LD (IY+5),H + LD (IY+4),L + JR PCO0 +; +;CARRIAGE RETURN UND (NULLCT) X LINEFEED AUSGEBEN +PCNL: PUSH BC + LD A,LF + CALL PUTA ;LINEFEED AUSGEBEN + LD A,(NULLCT) + AND A + JR Z,PCO8 + LD B,A + SUB A +PCLF: CALL PUTA ;LINEFEED'S :=(NULLCT) AUSGEBEN + DJNZ PCLF +; +; +PCO8: POP BC + JR PCO10 +;************************************************ +;* * +;* WRITE-BINARY * +;* * +;************************************************ +PCWBIN: LD A,(HL) + CALL PUTA + CPI + JP PE,PCWBIN + JR PCO10 +PCO5: CP RDBIN + JR NZ,PCRASC +;************************************************ +;* * +;* READ-BINARY * +;* * +;************************************************ +PCRBIN: CALL GETA + JR Z,PCRBIN + LD (HL),A + CPI + JP PE,PCRBIN ;SPRUNG WENN BC =/= 0 + JR PCO10 +;************************************************ +;* * +;* READ-ASCII * +;* * +;************************************************ +PCRASC: LD A,(PROMPT) + CALL PUTA ;AUSGABE (PROMPT) + PUSH HL ;DATA TRANSFER ADRESS +PCRA1: CALL RPAR ;ZEICHEN EINLESEN&PARITAETSBIT RUECKSETZEN + LD (HL),A + PUSH HL + LD H,A + LD A,(CARDEL) ;CARDEL + CP H + JR NZ,PCRA2 +; +; +; +;CHARDEL ERKANNT ! +;**************** + POP HL + DEC HL ;DATA TRANSFER ADRESS -1 + INC BC ;DATA LENGTH +1 + POP DE + PUSH HL + SBC HL,DE + POP HL + PUSH DE + JR NC,PCRA1 + JR PCLD1 +; +PCRA2: LD A,(LINDEL) ;LINDEL + CP H + JR NZ,PCO16 +; +;LINDEL ERKANNT ! +;**************** +PCLDEL: POP HL +PCLD1: POP HL + PUSH HL + LD B,(IY+5) DATA LENGTH NEULADEN + LD C,(IY+4) + JR PCRA1 ;NEUE ZEILE EINGEBEN +; +PCO16: LD A,H + POP HL + INC HL ;DATA TRANSFER ADRESS + DEC BC ;DATA LENGTH + POP DE + CP CR ;ENDE DER ZEILE ? + JR Z,PCNL + LD A,C + OR B + JR Z,PCO10 + PUSH DE + JR PCRA1 +; +RPAR: CALL GETA + JR Z,RPAR + RES 7,A + CALL PUTA + RET +*E +;******************************************************* +;* +;* ZUSAETZLICHE VEREINBARUNGEN * +;* +;******************************************************* + + +SIOTAB + DEFW ISRSET + DEFW ISRZET + DEFW ISRSET +; +SDERR DEFB 18 + DEFM 'INSERT SYSTEMDISK' + DEFB 0DH + + +KBC0 DEFB 12H + DEFB 0CFH ;BIT CONTROL + DEFB 7FH ;NUR BIT 7 AUSGABE + DEFB 037H ;EI/HIGH-AKTIV/MASK FOLGT + DEFB 0FEH ;NUR BIT 0 AKT. INTERRUPT + +*E +;******************************************************** +;* * +;* TREIBERPROGRAMME ZUR HARDWAREANPASSUNG * +;* * +;******************************************************** +; +; !!! D I S P L A Y !!! +*INCLUDE OUTA.S +; !!! T A S T A T U R !!! +*INCLUDE INA.S +; +; !!! F L O P P Y - T R E I B E R !!! +*INCLUDE FLOPPY.S +; + +; + +; +;******************************************************** + ORG 0B71H +;* * +;* PROM-VEREINBARUNGEN * +;* * +;******************************************************** +TBREA: DEFT 'BREAK ' +; +TDERR: DEFB 11 + DEFM 'DISK ERROR' + DEFB CR ;CARRIAGE RETURN +; +FRAGZ: DEFT '?' +REGBEZ: DEFM 'A B C D E F H L I ' + DEFM 'A''B''C''D''E''F''H''L''' + DEFM 'IXIYPCSP' +;LOW-ADRESSEN DES REGISTERRETTUNGSBEREICHES +LADRRB: DEFB AF_+1.AND.0FFH + DEFB BC_+1.AND.0FFH + DEFB BC_.AND.0FFH + DEFB DE_+1.AND.0FFH + DEFB DE_.AND.0FFH + DEFB AF_.AND.0FFH + DEFB HL_+1.AND.0FFH + DEFB HL_.AND.0FFH + DEFB I_.AND.0FFH + DEFB AFS_+1.AND.0FFH + DEFB BCS_+1.AND.0FFH + DEFB BCS_.AND.0FFH + DEFB DES_+1.AND.0FFH + DEFB DES_.AND.0FFH + DEFB AFS_.AND.0FFH + DEFB HLS_+1.AND.0FFH + DEFB HLS_.AND.0FFH + DEFB IX_.AND.0FFH + DEFB IY_.AND.0FFH + DEFB PC_.AND.0FFH + DEFB SP_.AND.0FFH +;********************************************************************* +;BASISVARIABLE: IM RAM AB NULLCT ABGESPEICHERT +BASVAR: DEFB 00H ;NULLCT + DEFB 01H ;LFCNT + DEFB 3EH ;PROMPT (>) + DEFB 7FH ;LINDEL (RUBOUT) + DEFB 08H ;CARDEL (BACKSPACE) + DEFB 00H ;BRKFLG + DEFW 00H ;BRKRETN + DEFW 00H ;DSKVSL +WRNGINIT: + DEFB 10 ;CRC RETRY + DEFB 3 ;WRONG SECTOR RETRY + DEFB 3 ;WRONG TRACK RETRY +;ENDE DES BLOCKES DER BASISVARIABLEN +;*********************************** +; + +KENNSD DEFM 'P8000SYS' + ORG 0BDFH +; BFOS SPRUNGVERTEILER +; +; + JP BTOHE + JP READY ;LW-READY TEST + JP PRESS ;CONSOL-STATUS TEST + JP GETA ;SPRUNG ZU GETA + JP PUTA + JP PCON + JP OUTAS ;AUSGABE ASC-ZEICHEN UEBER PCON + JP SSIGN + JP BDEC + JP DEBUG + JP DISK +*E +;********************************************************************* +;* * +;* RAM-BEREICH * +;* * +;********************************************************************* + ORG 0C00H +KOMINT: DEFS 100H ;ANFANG SYSTEMSTACK +STACK: DEFS 1 ;ENDE SYSTEMSTACK +; +XINT: DEFS 2 +CONOBC: DEFS 1 +CONOBF: DEFS 133 +; + DEFS 1 +CONIBF: DEFS 255-37 +;KOMMANDOTABELLE FUER DEN FDC, MINI- UND STANDARDLAUFWERKE +FDCTAB DEFS 9 +PR1 DEFS 1 +PR2 DEFS 1 +GPL2 DEFS 1 +TRK DEFS 1 +CMD DEFS 1 +;KOMMANDOTABELLE FUER DEN DMA +DMALSW DEFS 10 +;RESULTATSTABELLE DER FDC-KOMMANDOS +RESUL DEFS 7 +;TABELLE DER MOTORLAUFZEITEN +TTAB DEFS 4 +; +;Merkzelle fuer Laufwerkmaske +DMASK DEFS 1 +FDTYP DEFS 1 +; +;DISK PARAMETER VEKTOR1-->IM DEBUGER GELADEN +DPAVEC: DEFS 1 ;IGNORED + DEFS 1 ;IY+1 -->REQUEST-CODE + DEFS 2 ;IY+2,3 -->DATA TRANSFERADRESS + DEFS 2 ;IY+4,5 -->DATA LENGTH + DEFS 2 ;IY+6,7 -->COMPLETION RETURN ADRESS + DEFS 2 ;IY+8,9 -->ERROR RETURN ADRESS + DEFS 1 ;IY+10 -->COMPLETION CODE + DEFS 2 ;IY+11,12 -->DISK ADRESS +; +;DISK PARAMETER VEKTOR2-->WIRD IN DISK GELADEN +BFFADD: DEFS 2 ;IY+2,3 -->DATA TRANSFER ADRESS +BFFLEN: DEFS 2 ;IY+4,5 -->DATA LENGTH +INTPNT: DEFS 2 +RQTRK: DEFS 1 ;REQUEST-TRACK & H-TEIL DISK ADRESSE +RQSECT: DEFS 1 ;IY+11 -->SECTOR ADRESS +V2TADR: DEFS 1 ;IY+12 -->TRACK ADRESS +; +BCKPTR: DEFS 2 ;ZEIGER ZUM VORHERGEHENDEN SECTOR +FORPTR: DEFS 2 ;ZEIGER ZUM NAECHSTEN SECTOR +CRC: DEFS 4 +; +HL_: DEFS 2 +INT: DEFS 1 ;INT.-ENABLE FLIP-FLOP +I_: DEFS 1 +AF_: DEFS 2 +BC_: DEFS 2 +DE_: DEFS 2 +AFS_: DEFS 2 +BCS_: DEFS 2 +DES_: DEFS 2 +HLS_: DEFS 2 +IX_: DEFS 2 +IY_: DEFS 2 +PC_: DEFS 2 +SP_: DEFS 2 +; + DEFS 2 ;FREI +; +CONOV: DEFS 11 ;CONSOLE OUTPUT-VECTOR +CONIV: DEFS 11 ;CONSOLE INPUT-VECTOR + DEFS 2 ;SEKTORLAENGE +PCONF: DEFS 1 ;FREI +N_ DEFS 1 ;NEXT MERKER +; +DSEL: DEFS 2 +INS: DEFS 1 +BRKADR: DEFS 2 +EIADR DEFS 2 +EIINS DEFS 1 +; +CRCERR DEFS 2 +SECERR DEFS 2 +TRKERR DEFS 2 +; +FDCONF DEFS 2 ; MERKZELLE FUER DISK-KONFIGURATION +SPURNR DEFS 1 ; MERKZELLE FUER DIE SPURNUMMER +; +APEIN DEFS 1 ; ADRESSE FUER AKTUELLEN STAND IM RINGPUFFER +APAUS DEFS 1 +MCSQ DEFS 1 +MFDC DEFS 1 + DEFS 14 ; FREI +; +; TABELLEN DER INTERRUPTSERVICEROUTINEN VON ALLEN AUF DEM 8-BIT-TEIL +; BEFINDLICHEN PERIPHERIESCHALTKREISEN: +; CTC0, CTC1, SIO1, SIO2, PIO1, PIO2, PIO3, FDC, DMA +; +; CTC0: +ITABC0 + DEFS 2 ; KANAL 0, NICHT BELEGT + DEFS 2 ; KANAL 1, NICHT BELEGT +ISNEXT DEFS 2 ; KANAL 2, BELEGT DURCH NEXT-INTERRUPT IN NEXT +RDYMIN DEFS 2 ; KANAL 3, BELEGT DURCH ZEIT-INTERRUPT FUER MINI-LAUFWERKE +; +; CTC1: +ITABC1 + DEFS 2 ; + DEFS 2 ; + DEFS 2 ; + DEFS 2 ; +; +; PIO0: +ITABP0 +IP0KA DEFS 2 ; +IP0KB DEFS 2 +; +; PIO1: +ITABP1 +IP1KA DEFS 2 +IP1KB DEFS 2 ; +; +; PIO2: +ITABP2 +IP2KA DEFS 2 ; INTERRUPTSERVICEROUTINE FUER INTERRUPT VOM FDC +IP2KB DEFS 2 ; HIER WIRD OHNE INTERRUPT GEARBEITET +; +; DMA: +ITABD + DEFS 2 ; INTERRUPTADRESSE FUER DMA, GENUTZT FUER FLOPPY-ARBEIT +; + DEFS 2 ; FREI +; +; SIO0: +ITABS0 +IS0B1 DEFS 2 ; +IS0B2 DEFS 2 ; ISRSET +IS0B3 DEFS 2 ; ISRZET +IS0B4 DEFS 2 ; ISRSET +IS0A1 DEFS 2 +IS0A2 DEFS 2 +IS0A3 DEFS 2 +IS0A4 DEFS 2 +; +; SIO1: +ITABS1 +IS1B1 DEFS 2 +IS1B2 DEFS 2 +IS1B3 DEFS 2 +IS1B4 DEFS 2 +IS1A1 DEFS 2 +IS1A2 DEFS 2 +IS1A3 DEFS 2 +IS1A4 DEFS 2 +; +INVEK: DEFS 96 +; +USRSTK: DEFS 2 ;USER-STACK +DATE: + DEFS 6 +TIMEZG: DEFS 12 +ERRCOD: DEFS 1 +EXTRET: DEFS 2 +MEMTOP: DEFS 2 +MEMBOT: DEFS 2 +INPTR: DEFS 2 ;ZEIGT AUF DIE AKTUELLE ADRESSE IN CONIBF +OUTPTR: DEFS 2 ;ZEIGT AUF DIE AKTUELLE ADRESSE IN CONOB +; +;BASIS-VARIABLENFELD ANFANG +NULLCT: DEFS 1 ;NULLCT +LFCNT: DEFS 1 ;LINE FEED COUNTER +PROMPT: DEFS 1 ;PROMPT > +LINDEL: DEFS 1 ;LINDEL ! +CARDEL: DEFS 1 ;CARDEL @ +BRKFLG: DEFS 1 ;BRKFLG +BRKRET: DEFS 2 ;BRKRET +; +DSKVSL: DEFS 2 ;DISK-SCHLUESSELZELLE + DEFS 2 ;FREI +CRCCTR: DEFS 1 +WSCTR: DEFS 1 +WTCTR: DEFS 1 +CURT0: DEFS 8 +CURTRK: DEFS 1 +MZNEXT DEFS 1 ;MERKZELLE NEXTROUTINE + DEFS 4 ;FREI +GOJMP: DEFS 1 ;INTERRUPT MODE FUER REALTIME START + DEFS 3 ;JP (SAVPC) -->IN GO GELADEN +; +RINGP DEFS 20H ;Ringpuffer fuer die Eingabe von der Tastatur +; +; +;********************************************************************* +;* * +;*VEREINBARUNGSTEIL * +;* * +;********************************************************************* +;DATEN +NRET: EQU 80H ;NORMAL RETURN +;STEUERWORTE +RDBIN: EQU 0AH ;REQUEST CODES +WRBIN: EQU 0EH +RDASC: EQU 0CH +WRASC: EQU 10H +;I/O-ADRESSEN +; VEREINBARUNGEN +CTC0: EQU 008H ; +CTC1 EQU 02CH +; +SIO0 EQU 024H +S0AD EQU SIO0 +S0AC EQU SIO0+1 +S0BD EQU SIO0+2 +S0BC EQU SIO0+3 +; +SIO1 EQU 028H +S1AD EQU SIO1 +S1AC EQU SIO1+1 +S1BD EQU SIO1+2 +S1BC EQU SIO1+3 +; +PIO0 EQU 0CH +P0AD EQU PIO0 +P0AC EQU PIO0+1 +P0BD EQU PIO0+2 +P0BC EQU PIO0+3 +; +PIO1 EQU 018H +P1AD EQU PIO1 +P1AC EQU PIO1+1 +P1BD EQU PIO1+2 +P1BC EQU PIO1+3 +; +PIO2 EQU 1CH +P2AD EQU PIO2 +P2AC EQU PIO2+1 +P2BD EQU PIO2+2 +P2BC EQU PIO2+3 +; +DMAADR EQU 3CH +; +; +R0 EQU 0 +R1 EQU 1 +R2 EQU 2 +R3 EQU 3 +R4 EQU 4 +R5 EQU 5 +R6 EQU 6 +R7 EQU 7 +; +COMM6 EQU 30H ; FEHLER RUECKSETZEN +COMM3 EQU 18H ; KANAL RUECKSETZEN +COMM2 EQU 10H ; RUECKSETZEN EXT./STAT. INTERRUPT +NOPRTY EQU 0 ; PARITAETSPRUEFUNG AUSSCHALTEN +S2 EQU 0CH ; 2 STOP/BITS JE ZEICHEN +C16 EQU 40H ; *16 +RENABLE EQU 1 +B8 EQU 0C0H +XENABLE EQU 8 +T8 EQU 60H +PDAVCT EQU 18H +SAVECT EQU 04H +XMTRIE EQU 02H +; +CR EQU 0DH +LF EQU 0AH +C32 EQU 80H