diff --git a/firmware/MON16/p.test.s b/firmware/MON16/p.test.s new file mode 100644 index 0000000..1e17435 --- /dev/null +++ b/firmware/MON16/p.test.s @@ -0,0 +1,3584 @@ +!****************************************************************************** +******************************************************************************* + + P8000-Firmware (C) ZFT/KEAW Abt. Basissoftware - 1988 + U8000-Softwaremonitor (MON16) Modul: p_test + + Bearbeiter: J. Zabel + Datum: 02.01.1989 + Version: 3.1 + +******************************************************************************* +******************************************************************************! + +!============================================================================== +Inhaltsuebersicht Modul p_test +------------------------------ +Dieser Modul umfasst das Monitorkommando TEST (T). + +Prozeduren +---------- +TEST_ +RAM_TEST_SEG0 +MMU_TEST +RAM_TEST_SEG +PRIVINSTR_TRAP +SEGMENT_TRAP +CODE_TRAP +CLR_CTL_REG +LD_SDR +RD_SDR +LD_3SDR +SEGMENT_TRAP_TEST +BY_WO_CMP +FAT_ERR +WR_TESTNR +WR_2SP +WR_2BS +MSG_ERROR +MSG_MAXSEG +CRC_TEST +PIO_TEST1 +PIO_ISR +CTC_TEST1 +CTC_TEST2 +CTC_TEST3 +CTC_INIT +CTC_ISR +SIO_TEST1 +SIO0_A_TEST2 +SIO0_B_TEST2 +SIO1_A_TEST2 +SIO1_B_TEST2 +SIO_INIT +SIO_ISR +==============================================================================! + + +p_test module + +$SECTION PROM + +!anfang mon16.include! +!****************************************************************************** +allgemeine Vereinbarungen (Stand: 16.11.1987) +******************************************************************************! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +externe Prozeduren und Marken +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + EXTERNAL +!INIT_CTC0_0 procedure Modul p_init! +INIT_CTC0_1 procedure !Modul p_init! +!INIT_SIO0_A procedure Modul p_init! +INIT_SIO0_B procedure !Modul p_init! +CMDLOP procedure !Modul p_init! +ERROR procedure !Modul p_init! +NMI_INT procedure !Modul p_init! + +PTY_INT procedure !Modul p_term! +PTY_ERR procedure !Modul p_term! +KOPPEL_INT procedure !Modul p_term! +INCPTR procedure !Modul p_term! +TYRD procedure !Modul p_term! +TYWR procedure !Modul p_term! +TYRD_UDOS_INT procedure !Modul p_term! +TYRD_UDOS_POL procedure !Modul p_term! +TYWR_UDOS_INT procedure !Modul p_term! +TYWR_UDOS_POL procedure !Modul p_term! +TYWR_KOPPEL_INT procedure !Modul p_term! +TYWR_KOPPEL_POL procedure !Modul p_term! +KP_OUTB procedure !Modul p_term! +KP_INB procedure !Modul p_term! +RD_LINE_BFF procedure !Modul p_term! +RD_LINE_INBFF procedure !Modul p_term! +WR_CRLF procedure !Modul p_term! +WR_MSG procedure !Modul p_term! +WR_OUTBFF_CR procedure !Modul p_term! +WR_OUTBFF procedure !Modul p_term! +HTOB procedure !Modul p_term! +BTOH16 procedure !Modul p_term! +BTOH8 procedure !Modul p_term! +GET_CHR procedure !Modul p_term! +GET_SIGN procedure !Modul p_term! +GET_SIGNW procedure !Modul p_term! +GET_SGNR procedure !Modul p_term! +GET_HEXZ procedure !Modul p_term! +GET_ADR procedure !Modul p_term! +GET_PAR procedure !Modul p_term! +RD_DATA procedure !Modul p_term! +GET_DATA procedure !Modul p_term! +WR_R5_RDDATA procedure !Modul p_term! +WR_OBF_RDDATA procedure !Modul p_term! +PUT_CHR procedure !Modul p_term! +PUT_3C procedure !Modul p_term! +PUT_2CHR procedure !Modul p_term! +PUT_SEGNR procedure !Modul p_term! +PUT_SGNR procedure !Modul p_term! + +DISPLAY procedure !Modul p_comm! +COMPARE procedure !Modul p_comm! +FILL procedure !Modul p_comm! +MOVE procedure !Modul p_comm! +PORT_READ procedure !Modul p_comm! +PORT_WRITE procedure !Modul p_comm! +PORT_READ_SPECIAL procedure !Modul p_comm! +PORT_WRITE_SPECIAL procedure !Modul p_comm! +HARD_DISK_READ procedure !Modul p_comm! +HARD_DISK_WRITE procedure !Modul p_comm! +FLOPPY_FORMAT procedure !Modul p_comm! +FLOPPY_READ procedure !Modul p_comm! +FLOPPY_WRITE procedure !Modul p_comm! + +REGISTER procedure !Modul p_brk! +SAVREG procedure !Modul p_brk! +BREAK procedure !Modul p_brk! +GO procedure !Modul p_brk! +GO_NXT procedure !Modul p_brk! +NEXT procedure !Modul p_brk! +RETI_CTC0_3 procedure !Modul p_brk! + +TEST_ procedure !Modul p_test! + +GET procedure !Modul p_gesa! +SAVE procedure !Modul p_gesa! +QUIT8 procedure !Modul p_gesa! +QUIT8_RESET procedure !Modul p_gesa! +FLOPPY procedure !Modul p.gesa! +RM_GET procedure !Modul p_gesa! +RM_SAVE procedure !Modul p_gesa! +RM_QUIT procedure !Modul p_gesa! + +OS_BOOT procedure !Modul p_boot! +AUTOBOOT procedure !Modul p_boot! + +DISK procedure !Modul p_disk! + +! +QUIT procedure Modul p_ldsd +LOAD procedure Modul p_ldsd +MCZ_INT procedure Modul p_ldsd +MCZ_ERR procedure Modul p_ldsd +TYWR_MCZ procedure Modul p_ldsd +WOCF_MCZ procedure Modul p_ldsd +SEND procedure Modul p_ldsd +! + +MON16_1H word !Modul p.crc! +N_MON16_1H word !Modul p.crc! +MON16_1L word !Modul p.crc! +N_MON16_1L word !Modul p.crc! +MON16_2H word !Modul p.crc! +N_MON16_2H word !Modul p.crc! +MON16_2L word !Modul p.crc! +N_MON16_2L word !Modul p.crc! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +Werte aus dem Arbeitsspeicher (Modul p_ram) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + EXTERNAL +RAM_ANF ARRAY [%10 WORD] +NSP_OFF WORD + ARRAY [%3F WORD] !Stackbereich! +STACK WORD + ARRAY [4 WORD] +_numterm WORD !Anzahl der Terminals! +PTYPORT BYTE !Terminalkanal: + 00 - SIO0_B (16-Bit-Teil) + 01 - SIO0_B (8-Bit-Teil) ueber + Koppelschnittstelle! +XEMPTY BYTE !fuer interruptgesyeuerten Terminal- + betrieb ueber Koppelschnittstelle: + 00 - Sendepuffer SIO0_B (8-Bit-Teil) + leer + FF - Sendepuffer SIO0_B (8-Bit-Teil) + nicht leer! + BYTE +KONV BYTE !Hilfsbyte zur Konvertierung! +INBFF ARRAY [%80 BYTE] !Eingabepuffer! +OUTBFF ARRAY [%80 BYTE] !Ausgabepuffer! +PTYBFF ARRAY [%100 BYTE] !Eingabepuffer fuer interrupt- + gesteuerte Eingabe vom Terminal- + kanal! +MCZBFF ARRAY [%0EA BYTE] !Ein-/Ausgabepuffer fuer LOAD/SEND! +MAXLEN WORD !maximale Zeilenlaenge! +INPTR WORD !Zeiger fuer Eingabepuffer INBFF! +OUTPTR WORD !Zeiger fuer Ausgabepuffer OUTBFF + (Pufferlaenge)! +COUNT_PTY WORD !aktuelle Anzahl der Zeichen in PTYBFF! +INPTR_PTY WORD !Eingabezeiger fuer PTYBFF + (naechster freier Platz)! +OUTPTR_PTY WORD !Ausgabezeiger fuer PTYBFF + (naechstes auszulesende Zeichen)! +INPTR_MCZ WORD !Eingabezeiger fuer MCZBFF! +OUTPTR_MCZ WORD !Ausgabezeiger fuer MCZBFF! +B_WORD WORD !Speicherinhalt auf der BREAK-Adresse! +B_ADR_S WORD !Segmentnummer der BREAK-Adresse! +B_ADR_O WORD !Offset der BREAK-Adresse! +RR14_V LONG !VARIABLER STACK, FUER NEXT UND BREAK! +W23B4 WORD +FCW_V WORD !VARIABLES FCW FUER NEXT UND BREAK! +PORT_BF WORD !Puffer fuer gelesenen bzw. zu + schreibenden PORT-Datenwert! +PORT_IO WORD !Adresse des PORT-I/O-Programms! + WORD !unbenutzt! +SV_R ARRAY [14 WORD] !Registerrettungsbereich! +SVSTK LONG +PC_SEG WORD !Programmcounter (Segmentnummer)! +PC_OFF WORD !Programmcounter (Offsetadresse)! +FCW_ WORD !FCW im Registerrettungsbereich! +RF_CTR WORD !Merker: Refresh Control Register! +N4_ WORD !Normalstack R14! +N5_ WORD !Normalstack R15! +PS_ WORD !Program-Status-Area Segment! +PO_ WORD !Program-Status-Area Offset! + WORD !unbenutzt! +!Flags! +FLAG0 BYTE +FLAG1 BYTE +!Variablen (initialisiert bei Systemstart)! +CHRDEL BYTE !Zeichen loeschen (Backspace %08)! +LINDEL BYTE !Zeile loeschen (Line delete %7F)! +XONCHR BYTE !Terminalausgabe fortsetzen (^Q %11)! +XOFCHR BYTE !Terminalausgabe anhalten (^S %13)! +NULLCT WORD !Anzahl der Nullen nach CR bei Terminalausgabe (%0000)! +B_CODE WORD !Unterbrechungscode Z8000 (7F00)! +STKCTR WORD !Zaehler der Stackoperationen fuer NEXT (%0004)! +NXTCTR WORD !SCHRITTZAEHLER FUER NEXT (%0001)! +PROMT WORD !Promt-Zeichen (%2000)! +!---------------------------------------------------! +!Program Status Area (initialisiert bei Systemstart)! +PSAREA +! ID FCW PCSEG PCOFF! + ARRAY [4 WORD] !:= [%0000 %0000 %0000 %0000] + RESERVED! + ARRAY [4 WORD] !:= [%0000 %4000 %8000 VI_ERR] + UNIMLEMENTED INSTRUCTIONS! + ARRAY [4 WORD] !:= [%0000 %4000 %8000 VI_ERR] + PRIVILEGED INSTRUCTIONS! +PSA_SC ARRAY [4 WORD] !:= [%0000 %C000 %8000 SC_ENTRY] + SYSTEM_CALL INSTRUCTIONS! + ARRAY [4 WORD] !:= [%0000 %4000 %8000 MMU_ERR] + SEGMENT TRAP! +PSA_NMI ARRAY [4 WORD] !:= [%0000 %4000 %8000 AUTOBOOT bzw. NMI_INT] + NONMASKABLE INTERRUPT + (AUTOBOOT vor erster Terminaleingabe; + NMI_INT nach erster Terminaleingabe)! + ARRAY [4 WORD] !:= [%0000 %4000 %8000 VI_ERR] + NONVECTORED INTERRUPT! +! VECTORED INTERRUPT! + ARRAY [2 WORD] !:= [%0000 %4000] + VECTORED INTERRUPT (ID, FCW)! +! VI - Sprung-Tabelle (128 Eintraege) ! +! SEG OFFSET! +!CTC0! +VI_CTC0_0 ARRAY [2 WORD] !:= [%8000 VI_ERR] ! +VI_CTC0_1 ARRAY [2 WORD] !:= [%8000 VI_ERR] ! +VI_CTC0_2 ARRAY [2 WORD] !:= [%8000 VI_ERR] ! +VI_CTC0_3 ARRAY [2 WORD] !:= [%8000 VI_ERR bzw. GO_INT bzw. NXT_INT] + fuer GO bzw. NEXT! +!PIO1! +VI_PIO1_B ARRAY [2 WORD] !:= [%8000 KOPPEL_INT] + VI Zeichen empfangen (von Koppelschnittstelle)! + ARRAY [2 WORD] !:= [%8000 VI_ERR] ! + ARRAY [2 WORD] !:= [%8000 VI_ERR] ! + ARRAY [2 WORD] !:= [%8000 VI_ERR] ! +!SIO0! +VI_SIO0_B ARRAY [2 WORD] !:= [%8000 VI_ERR] ! + ARRAY [2 WORD] !:= [%8000 VI_ERR] ! + ARRAY [2 WORD] !:= [%8000 PTY_INT] + VI Zeichen empfangen (fuer Terminaleingabe)! + ARRAY [2 WORD] !:= [%8000 PTY_ERR] + VI Empfangssonderfall (fuer Empfangsfehler)! +VI_SIO0_A ARRAY [2 WORD] !:= [%8000 VI_ERR] ! + ARRAY [2 WORD] !:= [%8000 VI_ERR] ! + ARRAY [2 WORD] !:= [%8000 VI_ERR] (vorher MCZ_INT) + VI Zeichen empfangen (fuer MCZ-Eingabe)! + ARRAY [2 WORD] !:= [%8000 VI_ERR] (vorher MCZ_ERR) + VI Empfangssonderfall (fuer Empfangsfehler)! +! Rest der 128 Eintraege der VI-Sprung-Tabelle! +VI_TAB_REST ARRAY [224 WORD] !:= [%8000 VI_ERR] ! +!---------------------------------------------------! + +!Arbeitsspeicher fuer Kommando "T" (Hardwareeigentest)! +RG_FELD ARRAY [%1A WORD] !Feld zur Registerrettung! +REM_MMU_BCSR BYTE !Merker: Inhalt BUS CYCLE STATUS REGISTER! +REM_MMU_VTR BYTE !Merker: Inhalt VIOLATION TYPE REGISTER! +REM_MMU_ID WORD !Merker: MMU-Identifikation! +REM_ERR_CNT WORD !Merker: Stand Fehlerzaehler! +REM_SEGMENT_TRAP WORD !Merker: urspruengliche Offsetadresse fuer Segmenttrap! +REM_PRIVINSTR_TRAP WORD !Merker: urspruengl. Offsetadr. fuer Priv.-Instr.-Trap! +REM_MMU_SINOUT WORD !Merker: MMU-Ein-/Ausgabewerte! +ERR_CNT WORD !Fehlerzaehler! +ERR_WDC WORD !Fehlerzaehler fuer WDC-Test! +MAX_SEGNR WORD !Merker: hoechste vorhandene Segmentnummer! +REM_PARNMI WORD !Merker: Paritaets-NMI aufgetreten + (%0000-->nein / %FFFF-->ja)! +ERRPAR_ID WORD !Spezifizierung der 4 Parameter der auszugebenden + Fehlerzeile (Prozedur MSG_ERROR)! +REM_MMU1 WORD +REM_MMU2 WORD +REM_INT WORD !Merker: Interrupt aufgetreten (0-->nein)! +REM_WDC1 WORD !Speicherplatz fuer Testdatenwert! +REM_WDC2 WORD !Speicherplatz fuer rueckgelesenen datenwert! + +!Arbeitsspeicher fuer Kommandos "GE"/"S"/"O U" und Floppytreiber! +FILENAME_PTR WORD !Anfangsadresse Dateiname! +COUNT_UDOS WORD !akt. Anzahl der Zeichen in UDOSBFF! +INPTR_UDOS WORD !Eingabezeiger fuer UDOSBFF + (naechster freier Platz)! +OUTPTR_UDOS WORD !Ausgabezeiger fuer UDOSBFF + naechstes auszulesende Zeichen)! +UDOSBFF ARRAY [%100 BYTE] !Eingabepuffer fuer interrupt- + gesteuerte Eingabe bei Dateitransfer + von/zu UDOS bzw. Blocktransfer! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +System Calls +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + CONSTANT +SC_SEGV := %01 !Modul p.term! +SC_NSEGV := %02 !Modul p.term! +SC_TYRD := %04 !Modul p.term! +SC_TYWR := %06 !Modul p.term! +SC_RD_LINE_BFF := %08 !Modul p.term! +SC_WR_CRLF := %0A !Modul p.term! +SC_WR_MSG := %0C !Modul p.term! +SC_BTOH16 := %0E !Modul p.term! +SC_WR_OUTBFF_CR := %10 !Modul p.term! +SC_BTOH8 := %12 !Modul p.term! +SC_PUT_SEGNR := %14 !Modul p.term! +SC_PUT_CHR := %16 !Modul p.term! +! +SC_WOCF_MCZ := %18 Modul p.ldsd +SC_TYWR_MCZ := %1A Modul p.ldsd +! +SC_CMDLOP := %1C !Modul p.init! +SC_DISK := %1E !Modul p.disk! +SC_TYRD_UDOS_INT := %20 !Modul p.term! +SC_TYWR_UDOS_INT := %22 !Modul p.term! +SC_FLOPPY := %24 !Modul p.gesa! +SC_WR_OUTBFF := %26 !Modul p.term! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +spezielle ASCII-Zeichen +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + CONSTANT +SOH := %01 +STX := %02 +ETX := %03 +EOT := %04 +ACK := %06 +BEL := %07 +BS := %08 +LF := %0A +CR := %0D +NAK := %15 +CAN := %18 +ESC := %1B + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +Hardwareadressen +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + CONSTANT + +!8-Bit-Teil! + +SIO0D_B_8 := %26 !SIO fuer Terminal! +SIO0C_B_8 := %27 + +!16-Bit-Teil! + +SIO0 := %FF81 !Kanal A (XB1/TTY4): unbenutzt (vorher LOAD/SEND/QUIT); + Kanal B (XB2/TTY5): Terminal, wenn 8-Bit-Teil inaktiv! +SIO0D_A := SIO0 + 0 +SIO0D_B := SIO0 + 2 +SIO0C_A := SIO0 + 4 +SIO0C_B := SIO0 + 6 + +SIO1 := %FF89 !Kanal A (XB3/TTY6): unbenutzt + Kanal B (XB4/TTY7): unbenutzt! +SIO1D_A := SIO1 + 0 +SIO1D_B := SIO1 + 2 +SIO1C_A := SIO1 + 4 +SIO1C_B := SIO1 + 6 + +PIO0 := %FF91 !Koppel-PIO zum 8-Bit-Teil + fuer Terminal und Kommandos "GE", "S", + "Q", "QRES", "O U" und Floppytreiber + Kanal A: Datenausgabe + Kanal B: Statusausgabe/Steuerport! +PIO0D_A := PIO0 + 0 +PIO0D_B := PIO0 + 2 +PIO0C_A := PIO0 + 4 +PIO0C_B := PIO0 + 6 + +PIO1 := %FF99 !Koppel-PIO zum 8-Bit-Teil + fuer Terminal und Kommandos "GE", "S", + "Q", "QRES", "O U" und Floppytreiber + Kanal A: Dateneingabe + Kanal B: Statuseingabe/Steuerport! +PIO1D_A := PIO1 + 0 +PIO1D_B := PIO1 + 2 +PIO1C_A := PIO1 + 4 +PIO1C_B := PIO1 + 6 + +PIO2 := %FFA1 !(XB5): Winchester + Kanal A: Datenein-/-ausgabe; Kanal B: Steuerport! +PIO2D_A := PIO2 + 0 +PIO2D_B := PIO2 + 2 +PIO2C_A := PIO2 + 4 +PIO2C_B := PIO2 + 6 + +CTC0 := %FFA9 +CTC0_0 := CTC0 + 0 ! Baud 0 - SIO0, Kanal A! +CTC0_1 := CTC0 + 2 ! Baud 1 - SIO0, Kanal B! +CTC0_2 := CTC0 + 4 ! Baud 2 - SIO1, Kanal A! +CTC0_3 := CTC0 + 6 ! Next ! + +CTC1 := %FFB1 +CTC1_0 := CTC1 + 0 ! Baud 3 - SIO1, Kanal B! +CTC1_1 := CTC1 + 2 +CTC1_2 := CTC1 + 4 +CTC1_3 := CTC1 + 6 + +S_BNK := %FFC1 !SWITCH-BANK: + Bit0-3 Ausgabebits; Bit4-7 Eingabebits (DIL-Schalter): + Bit 0: =0 - Monitor PROM+RAM einschalten + =1 - Monitor PROM+RAM ausschalten + Bit 1: =0 - MMU's ausschalten; =1 - MMU's einschalten + Bit 2: Seg. Usr. + Bit 3: =0 - Paritaetspruefung ausgeschaltet bzw. + Paritaetsfehler loeschen + =1 - Paritaetspruefung eingeschaltet + Bit 5,4: Baudrate Terminal (unbenutzt) + Bit 7,6: Autoboot Device (unbenutzt)! + +SBREAK := %FFC9 !System Break Register! +NBREAK := %FFD1 !Normal Break Register! +RETI_P := %FFE1 !RETI-Port fuer Schaltkreise des U880-Systems! + +ALL_MMU := %F0 +STACK_MMU := %F6 +DATA_MMU := %FA +CODE_MMU := %FC + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +Moegliche Statusausgaben an 8-Bit-Teil von 16-Bit-Teil +fuer 8-Bit-/16-Bit-Koppelschnittstelle (PIO0_B) +(INT8-Bit jeweils = 0) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + CONSTANT +STAT8_ENDE := %00 !Ende eines Write-Requests! +STAT8_READ := %02 !Read-Request an einen Peripheriebaustein 8-Bit-Teil! +STAT8_WRITE := %04 !Write-Request an einen Peripheriebaustein 8-Bit-Teil! + +STAT8_UDOS := %10 !Datenbyte ist Bestandteil eines Dateitransfers + bzw. eines Blocktransfers von/zu UDOS! +STAT8_QUIT := %1E !Rueckkehr zum 8-Bit-Teil (Datenbyte "Q" oder "R")! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +Moegliche Statuseingaben von 8-Bit-Teil an 16-Bit-Teil +fuer 8-Bit-/16-Bit-Koppelschnittstelle (PIO1_B) +(INT16-Bit jeweils = 0) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + CONSTANT +STAT16_ENDE := %00 !Beantwortung eines Read-Requests! + +STAT16_SIO0_B_R := %04 !REC INT (SIO0_B-Empfaengerinterrupt)! +STAT16_SIO0_B_X := %24 !TRANS INT (SIO0_B-Interrupt Sendepuffer leer)! +STAT16_SIO0_B_E := %44 !EXT STAT INT (SIO0_B-Externer-Statusinterrupt)! +STAT16_SIO0_B_S := %64 !SPEC REC INT (SIO0_B-Interrupt Empfangssonderfall)! + +STAT16_UDOS := %10 !Datenbyte ist Bestandteil eines Dateitransfers + bzw. eines Blocktransfers von/zu UDOS! +!ende mon16.include! + +!****************************************************************************** +modulspezifische Vereinbarungen +******************************************************************************! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +SIO-Kommandos +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + +!Command Identifiers and Values +Includes all control bytes for asynchronous and synchronous I/O ! + + CONSTANT +!WR0 Commands! +SIO_R0 := %00 !SIO register pointers! +SIO_R1 := %01 +SIO_R2 := %02 +SIO_R3 := %03 +SIO_R4 := %04 +SIO_R5 := %05 +!SIO_R6 := %06! +!SIO_R7 := %07! + +!COMM0 := %00! !Null Code! +!COMM1 := %08! !Send Abort (SDLC)! +COMM2 := %10 !Reset Ext/Stat Int! +COMM3 := %18 !Channel Reset! +!COMM4 := %20! !Enable Int On Next Rx Char! +!COMM5 := %28! !Reset Tx Int Pending! +!COMM6 := %30! !Error Reset! + +RFI := %38 !Return from Int! +!RRCC := %40! !Reset Rx CRC Checker! +!RTCG := %80! !Reset Tx CRC Generator! +!RTUEL := %C0! !Reset Tx Under/EOM Latch! + +!WR1 Commands! +!WAIT := %00! !Wait function! +DRCVRI := %00 !Disable Receive Interrupts! +!EXTIE := %01! !External interrupt enable! +XMTRIE := %02 !Transmit Int Enable! +SAVECT := %04 !Status affects vector! +!FIRSTC := %08! !Rx interrupt on first character! +!PAVECT := %10! !Rx interrupt on all characters! + !(parity affects vector)! +PDAVCT := %18 !Rx interrupt on all characters! + !(parity doesn't affect vector)! +!WRONRT := %20! !Wait/ready on receive! +!RDY := %40! !Ready function! +!WRDYEN := %80! !Wait/Ready enable! + +!WR2 Commands! +!IV := %00! + +!WR3 Commands! +!B5 := %00! !Receive 5 bits/character! +!RENABLE := %01! !Receiver enable! +!SCLINH := %02! !Sync character load inhibit! +!ADSRCH := %04! !Address search mode! +!RCRCEN := %08! !Receive CRC enable! +!HUNT := %10! !Enter hunt mode! +!AUTOEN := %20! !Auto enable! +!B7 := %40! !Receive 7 bits/character! +!B6 := %80! !Receive 6 bits/character! +!B8 := %C0! !Receive 8 bits/character! + +!WR4 Commands! +!SYNC := %00! !Sync modes enable! +NOPRTY := %00 !Disable partity! +!ODD := %00! !Odd parity! +!MONO := %00! !8 bit sync character! +!C1 := %00! !x1 clock mode! +!PARITY := %01! !Enable Parity! +!EVEN := %02! !Even parity! +!S1 := %04! !1 stop bit/character! +!S1HALF := %08! !1+1/2 stop bit/character! +S2 := %0C !2 stop bits/character! +!BISYNC := %10! !16 bit sync character! +!SDLC := %20! !SDLC mode! +!ESYNC := %30! !External sync mode! +!C16 := %40! !x16 clock mode! +C32 := %80 !x32 clock mode! +!C64 := %C0! !x64 clock mode! + +!WR5 Commands! +!T5 := %00! !Transmit 5 bits/character! +!XCRCEN := %01! !Transmit CRC enable! +!RTS := %02! !Request to send! +!SELCRC := %04! !Select CRC-16 polynomial! +XENABLE := %08 !Transmitter enable! +!XBREAK := %10! !Send break! +!T7 := %20! !Transmit 7 bits/character! +!T6 := %40! !Transmit 6 bits/character! +T8 := %60 !Transmit 8 bits/character! +!DTR := %80! !Data terminal ready! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +Texte +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL +T_TEST WORD := %26 + ARRAY [* BYTE] := 'P8000 Hardwaretest U8001 - Version 3.1' +T_ERR WORD := %000A + ARRAY [* BYTE] :='*** ERROR ' +T_FERR WORD := %0010 + BYTE := BEL + ARRAY [* BYTE] := '*** FATAL ERROR' +! +T_SEG WORD := %0009 + ARRAY [* BYTE] := 'SEGMENTED' +T_NSEG WORD := %000D + ARRAY [* BYTE] := 'NON-SEGMENTED' +T_JUM WORD := %0008 + ARRAY [* BYTE] := ' JUMPERS' +! +T_MAXS WORD := %0007 + ARRAY [* BYTE] := 'MAXSEG=' + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +MMU-Listen +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL +MMU_LISTE1: !MMU-Adressen! + WORD := CODE_MMU + WORD := DATA_MMU + WORD := STACK_MMU + WORD := CODE_MMU + WORD := DATA_MMU +MMU_LISTE2: !Adressen der SDR-Tabellen! + WORD := %A000 + WORD := %A100 + WORD := %A100 +MMU_LISTE3: !1. Byte: Ausgabewert fuer SAR; + 2. Byte: Ausgabewert fuer DSCR; + 3. Byte: Datenwert, der rueckgelesen werden + muesste ! + ARRAY [3 BYTE] := [%00 %00 %00] + ARRAY [3 BYTE] := [%00 %01 %01] + ARRAY [3 BYTE] := [%00 %02 %02] + ARRAY [3 BYTE] := [%00 %03 %03] + ARRAY [3 BYTE] := [%01 %00 %04] + ARRAY [3 BYTE] := [%02 %00 %08] + ARRAY [3 BYTE] := [%04 %00 %10] + ARRAY [3 BYTE] := [%08 %00 %20] + ARRAY [3 BYTE] := [%10 %00 %40] + ARRAY [3 BYTE] := [%20 %00 %80] +MMU_LISTE4: !SDR-Feld! + WORD := %0000 + WORD := %FF00 +MMU_LISTE5: + WORD := %0000 + WORD := %0000 +MMU_LISTE6: !SDR-Feld! + WORD := %0000 + WORD := %FF20 +MMU_LISTE7: + WORD := %0000 + WORD := %FF01 +MMU_LISTE8: + WORD := %0100 + WORD := %0000 +MMU_LISTE9: + WORD := %0101 + WORD := %0000 +MMU_LISTE10: + WORD := %0000 + WORD := %0020 + + +!****************************************************************************** +Prozeduren +******************************************************************************! + +!------------------------------------------------------------------------------ +In diesem Modul wird das Register rh1 als Flagbyte verwendet. Die einzelnen +Bits haben dabei folgende Bedeutung: +Bit 0 = 0 RAM-Test nicht in Segment 0 + = 1 RAM-Test in Segment 0 + (gesetzt in RAM_TEST_SEG0; + getestet in BY_WO_CMP, WR_TESTNR) +Bit 1 = 0 Byte-Vergleich + = 1 Word-Vergleich + (gesetzt in RAM_TEST_SEG, MMU_TEST; + getestet in BY_WO_CMP) +Bit 2 = 0 ERR_CNT wird in MSG_ERROR inkrementiert + = 1 ERR_CNT wird in MSG_ERROR nicht inkrementiert + (getestet und rueckgesetzt in MSG_ERROR) +Bit 6 = 0 MSG_ERROR wurde seit dem letzten Loeschen des Bits nicht + schon einmal durchlaufen + = 1 MSG_ERROR wurde bereits vorher einmal durchlaufen + (gesetzt und getestet in MSG_ERROR) +Bit 7 = 0 MSG_ERROR wurde seit dem letzten Loeschen des Bits nicht + zweimal durchlaufen + = 1 MSG_ERROR wurde zweimal durchlaufen + (gesetzt in MSG_ERR; + getestet in RAM_TEST_SEG, MMU_TEST, SEGMENT_TRAP_TEST) +------------------------------------------------------------------------------! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE TEST_ +TEST-Routine (Monitorkommando) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + GLOBAL + TEST_ procedure + entry + xorb rl0, rl0 + outb S_BNK, rl0 !MONITOR PROM & RAM EINSCHALTEN! + + sc #SC_WR_CRLF + ld r2, #T_TEST + sc #SC_WR_MSG !Ausgabe Meldung! + sc #SC_WR_OUTBFF_CR !Ausgabe CR! + + calr WR_2SP !2 Space ausgeben, da Testschrittausgabe + mit 2x Backspace beginnt! + ld ERR_CNT, #%0000 !Fehlerzaehler loeschen! + +!------------------------- +Testschritt 40 (EPROM) +Test der EPROM-Pruefsummen +-------------------------! + +!Fuer jeden EPROM wird zuerst getestet, ob die im Modul p_crc abgelegte +Pruefsumme fehlerfrei ist (durch Vergleich mit ihrem ebenfalls in p_crc +abgelegten negierten Wert) - danach wird die Pruefsumme des EPROM's berechnet +und mit dem in p_crc abgelegten Wert verglichen +--- Fehler 40 bei fehlerhafter Pruefsumme ---! + + ld r8, #%40 !Fehler 40: falsche EPROM-Pruefsumme! + ld ERRPAR_ID, #%0000 !Fehlerparameter fuer Fehler 40: + keine Parameter! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r2, #%0000 !Anfangsadresse fuer Pruefsummenbildung! + ld r3, #%1000 !Bytezahl! + ld r4, MON16_1H !erwartete Pruefsumme (aus Modul p_crc)! + ld r5, N_MON16_1H !erwartete negierte Pruefsumme (aus p_crc)! + calr CRC_TEST !Pruefsummentest fuer EPROM MON16_1H; + bei Fehler Abbruch des Testes (FATAL ERROR)! + + ld r2, #%0001 !Anfangsadresse fuer Pruefsummenbildung! + ld r3, #%1000 !Bytezahl! + ld r4, MON16_1L !erwartete Pruefsumme (aus Modul p_crc)! + ld r5, N_MON16_1L !erwartete negierte Pruefsumme (aus p_crc)! + calr CRC_TEST !Pruefsummentest fuer EPROM MON16_1L; + bei Fehler Abbruch des Testes (FATAL ERROR)! + + ld r2, #%2000 !Anfangsadresse fuer Pruefsummenbildung! + ld r3, #%1000-8 !Bytezahl (letzten 8 Byte nicht in CRC-Bildung + einbeziehen, da dort die geraden Werte der + EPROM-Pruefsummen abgespeichert sind)! + ld r4, MON16_2H !erwartete Pruefsumme (aus Modul p_crc)! + ld r5, N_MON16_2H !erwartete negierte Pruefsumme (aus p_crc)! + calr CRC_TEST !Pruefsummentest fuer EPROM MON16_2H; + bei Fehler Abbruch des Testes (FATAL ERROR)! + + ld r2, #%2001 !Anfangsadresse fuer Pruefsummenbildung! + ld r3, #%1000-8 !Bytezahl (letzten 8 Byte nicht in CRC-Bildung + einbeziehen, da dort die ungeraden Werte der + EPROM-Pruefsummen abgespeichert sind)! + ld r4, MON16_2L !erwartete Pruefsumme (aus Modul p_crc)! + ld r5, N_MON16_2L !erwartete negierte Pruefsumme (aus p_crc)! + calr CRC_TEST !Pruefsummentest fuer EPROM MON16_2L; + bei Fehler Abbruch des Testes (FATAL ERROR)! + +!--------------------------------------------------- +Testschritt 46 (SRAM) +Test des statischen RAM auf fehlerhafte Datenleitung +---------------------------------------------------! + +!Die Adresse %4000 (1. Adr. des statischen RAM) wird nacheinander mit den Werten +0001,0002,0004,0008,0010,0020,0040,0080,0100,0200,0400,0800,1000,2000,4000, +8000,0001 (jeweils ein Bit gesetzt) beschrieben und wieder rueckgelesen. +--- Fehler 46, wenn ein Wert fehlerhaft rueckgelesen wurde ---! + + ld r8, #%46 !Fehler 46: fehlerhafte Datenleitung! + ld ERRPAR_ID, #%0029 !Fehlerparameter fuer Fehler 46,47,48: + r7, r5, r4! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + setb rh1, #%01 !Word-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r7, #%4000 !r7=Fehlerpar. (Testadresse)! + ld r5, #%0001 !r5=Fehlerpar. (Testdatenwert)! + ldb rl0, #%11 !rl0:=Anzahl der Testdatenwerte! +TSRAM1: ld r6, @r7 !urspruengl. Wert auf Testadresse retten! + ld @r7, r5 !Testdatenwert auf Testadr. eintragen! + ld r4, @r7 !r4=Fehlerpar. (rueckgel. Datenwert)! + ld @r7, r6 !urspruengl. Wert wieder eintragen! + calr BY_WO_CMP !Vergleich r4/r5; ggf. Fehler 46! + bitb rh1, #7 !Fehler aufgetreten?! + jr nz, TSRAM2 !ja --> naechster Testschritt! + rl r5, #1 !nein --> neuer Testdatenwert! + dbjnz rl0, TSRAM1 + +!----------------------------------------------- +Testschritt 47/48 (SRAM) +Test auf fehlerhafte '%AAAA'- bzw. '%5555'-Daten +-----------------------------------------------! + +!Der statische RAM wird mit dem Datenwert %AAAA bzw. %5555 +beschrieben und wieder rueckgelesen. +--- Fehler 47, wenn ein %AAAA-Wert fehlerhaft rueckgelesen wurde --- +--- Fehler 48, wenn ein %5555-Wert fehlerhaft rueckgelesen wurde ---! + +TSRAM2: + ld r8, #%47 !Fehler 47: fehlerhafte '%AAAA'-Daten! + ld r5, #%AAAA !r5=Fehlerpar. (Testdatenwert)! +TSRAM3: + xorb rh1, rh1 !Flagbyte rh1 loeschen! + setb rh1, #%01 !Word-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + ld r7, #%4000 !r7=Fehlerpar. (Testadresse)! + ld r0, #%400 !r0:=Word-Anzahl statischer RAM! +TSRAM4: ld r6, @r7 !urspruengl. Wert auf Testadresse retten! + ld @r7, r5 !Testdatenwert auf Testadr. eintragen! + ld r4, @r7 !r4=Fehlerpar. (rueckgel. Datenwert)! + ld @r7, r6 !urspruengl. Wert wieder eintragen! + calr BY_WO_CMP !Vergleich r4/r5; ggf. Fehler 47 bzw. 48! + bitb rh1, #7 !Fehler aufgetreten?! + jr nz, TSRAM5 !ja --> naechster Testschritt! + inc r7, #2 !nein --> naechste Testadresse! + djnz r0, TSRAM4 +TSRAM5: + cp r5, #%5555 !Testschritt 48 abgearbeitet?! + jr z, TPIO !ja --> naechster Testschritt! + + ld r8, #%48 !Fehler 48: fehlerhafte '%5555'-Daten! + ld r5, #%5555 !r5=Fehlerpar. (Testdatenwert)! + jr TSRAM3 + +!---------------------------------------- +Testschritt 50 (PIO2) +Test auf fehlerhafte Daten 'AA' oder '55' +----------------------------------------! + +!An die Datenkanaele A und B des PIO2 werden die Daten 'AA' bzw. '55' +ausgegeben und rueckgelesen +--- Fehler 50, wenn ein Wert fehlerhaft rueckgelesen wurde ---! + +!An diesem PIO ist der Winchestercontroller angeschlossen. Deshalb sind +beim PIO-Test bestimmete Restriktionen einzuhalten, die sonst nicht +noetig waeren! + +TPIO: + ld r8, #%50 !Fehler 50: fehlerhafte '%AA' bzw. '%55'-Daten! + ld ERRPAR_ID, #%0085 !Fehlerparameter fuer Fehler 50: + r6, rl5, rl4! + xorb rh1, rh1 !Flagbyte rh1 loeschen, + Byte-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + !Restriktion! + ldb rl0, #%20 !Bit5=1; BIT6=0! + outb PIO2D_B, rl0 + ldb rl0, #%0F !Ausgabemode fuer Kanal B! + outb PIO2C_B, rl0 + + ld r6, #PIO2D_A !r6=Fehlerpar. (PIO-Adresse)! + ld r7, #PIO2C_A + calr PIO_TEST1 + ld r6, #PIO2D_B !r6=Fehlerpar. (PIO-Adresse)! + ld r7, #PIO2C_B + calr PIO_TEST1 + +!--------------------------------------------------------- +Testschritt 52/53 (WDC) +Test auf fehlerhafte Daten 'AAAA' oder '5555' fuer WDC-RAM +---------------------------------------------------------! + +!Der WDC-RAM wird auf der Adresse %2E00 mit den Datenwerten %AAAA bzw. +%5555 beschrieben und wieder rueckgelesen +--- Fehler 52, wenn beim Schreiben ein Fehler vom WDC gemeldet wurde --- +--- Fehler 53, wenn beim Ruecklesen ein Fehler vom WDC gemeldet wurde bzw. + wenn der rueckgesene Wert nicht mit dem geschriebenen Wert + uebereinstimmt ---! + + ld ERR_WDC, #0 !Fehlerzaehler fuer WDC-Test loeschen! + ld r5, #%AAAA !r5=Fehlerpar. (Testdatenwert)! +TWDC0: + ld r0, #2 !bei Fehler 52 Test 2x ausfuehren! +TWDC1: + push @r15, r0 + ld r8, #%52 !Fehler 52: Schreiben in WDC-RAM fehlerhaft! + ld ERRPAR_ID, #%48 !Fehlerpar. fuer Fehler 52: rl6, r5! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + push @r15, r5 + push @r15, r8 + push @r15, r1 + ld REM_WDC1, r5 !Testdatenwert abspeichern! + ld r7, #4 !Requestcode fuer WDC: Write WDC-RAM! + ldb rl6, #%00 !Low-Teil WDC-RAM-Adresse (%2E00)! + ldb rl5, #%2E !High-Teil WDC-RAM-Adresse (%2E00)! + ld r8, #%00 !Pufferadresse (Segment)! + ld r9, #REM_WDC1 !Pufferadresse (Offset)! + ld r10, #2 !Laenge (2 Byte)! + sc #SC_DISK + pop r1, @r15 + pop r8, @r15 + pop r5, @r15 + pop r0, @r15 + test r2 !Returncode! + jr z, TWDC2 !kein Fehler aufgetreten! + + ldb rl6, rl2 !rl6=Fehlerpar. := Returncode! + push @r15, r0 + push @r15, r5 + calr MSG_ERROR !Fehler 52! + inc ERR_WDC !Fehlerzaehler WDC-Test erhoehen! + pop r5, @r15 + pop r0, @r15 + djnz r0, TWDC1 + +TWDC2: + ld r8, #%53 !Fehler 53: Lesen aus WDC-RAM fehlerhaft! + ld ERRPAR_ID, #%4A !Fehlerpar. fuer Fehler 53: rl6, r5, r4! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + setb rh1, #01 !Word-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + push @r15, r5 + push @r15, r8 + push @r15, r1 + ld REM_WDC2, #0 !Platz fuer rueckgelesenen Datenwert loeschen! + ld r7, #3 !Requestcode fuer WDC: Read WDC-RAM! + ldb rl6, #%00 !Low-Teil WDC-RAM-Adresse (%2E00)! + ldb rl5, #%2E !High-Teil WDC-RAM-Adresse (%2E00)! + ld r8, #%00 !Pufferadresse (Segment)! + ld r9, #REM_WDC2 !Pufferadresse (Offset)! + ld r10, #2 !Laenge (2 Byte)! + sc #SC_DISK + pop r1, @r15 + pop r8, @r15 + pop r5, @r15 + ldb rl6, rl2 !rl6=Fehlerpar. := Returncode! + ld r4, REM_WDC2 !r4=Fehlerpar. := rueckgelesener Datenwert! + test r2 !Returncode! + jr z, TWDC3 !kein Fehler aufgetreten! + + push @r15, r5 + calr MSG_ERROR !Fehler 53! + inc ERR_WDC !Fehlerzaehler WDC-Test erhoehen! + pop r5, @r15 + jr TWDC4 +TWDC3: + push @r15, r5 + calr BY_WO_CMP !Vergleich r4/r5, ggf. Fehler 53! + pop r5, @r15 + bitb rh1, #6 !Fehler aufgetreten?! + jr z, TWDC4 !nein! + inc ERR_WDC !Fehlerzaehler WDC-Test erhoehen! + +TWDC4: + cp r5, #%5555 + jr z, TWDC5 !naechster Testschritt! + ld r5, #%5555 !Test mit Datenwert %5555! + jr TWDC0 + +!------------------------------------------- +Testschritt 54 (WDC) +Test auf richtige Kommandoauswertung des WDC +-------------------------------------------! + +!An den WDC wird ein ungueltiger Kommandokode ausgegeben; als Returnkode +muesste daruafhin %01 zurueckgegeben werden +--- Fehler 54, wenn der Returncode ungleich %01 ist ---! + +TWDC5: + ld r8, #%54 !Fehler 54: falsche Kommandoauswertung des WDC! + ld ERRPAR_ID, #%40 !Fehlerpar. fuer Fehler 54: rl6! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + push @r15, r8 + push @r15, r1 + ld r7, #5 !Requestcode fuer WDC: ungueltiger Code! + sc #SC_DISK + pop r1, @r15 + pop r8, @r15 + cp r2, #%01 !Returncode = %01?! + jr z, TWDC6 !ja, d.h. kein Fehler! + + ldb rl6, #%C1 !WDC-Fehlerkode %C1 ausgeben! + calr MSG_ERROR !Fehler 54! + inc ERR_WDC !Fehlerzaehler WDC-Test erhoehen! + +TWDC6: + +!-------------------------------------------------------------------- +Testschritt 55 (CTC0/CTC1) +Test auf fehlerhafte Daten 'AA' oder '55' fuer Zeitkonstantenregister +--------------------------------------------------------------------! + +!An die Zeitkonstantenregister der einzelnen CTC-Kanaele die Daten +'AA' bzw. '55' ausgegeben und rueckgelesen +--- Fehler 55, wenn ein Wert fehlerhaft rueckgelesen wurde ---! + + ld r8, #%55 !Fehler 55: fehlerhafte '%AA' bzw. '%55'-Daten! + ld ERRPAR_ID, #%0085 !Fehlerparameter fuer Fehler 55: + r6, rl5, rl4! + xorb rh1, rh1 !Flagbyte rh1 loeschen, + Byte-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r0, #%FFFF !Wartezeit, um Ausgabe der Testschritt- + nummer zu garantieren im Falle, dass die + Ausgabe ueber Terminalkanal SIO0_B / CTC0_1 + erfolgt und nicht ueber Koppelschnittstelle! +WARTE1: djnz r0, WARTE1 + + ld r6, #CTC0_0 !r6=Fehlerpar. (CTC-Kanal-Adresse)! + calr CTC_TEST1 + ld r6, #CTC0_1 !r6=Fehlerpar. (CTC-Kanal-Adresse)! + calr CTC_TEST1 + ld r6, #CTC0_2 !r6=Fehlerpar. (CTC-Kanal-Adresse)! + calr CTC_TEST1 + ld r6, #CTC0_3 !r6=Fehlerpar. (CTC-Kanal-Adresse)! + calr CTC_TEST1 + ld r6, #CTC1_0 !r6=Fehlerpar. (CTC-Kanal-Adresse)! + calr CTC_TEST1 + ld r6, #CTC1_1 !r6=Fehlerpar. (CTC-Kanal-Adresse)! + calr CTC_TEST1 + ld r6, #CTC1_2 !r6=Fehlerpar. (CTC-Kanal-Adresse)! + calr CTC_TEST1 + ld r6, #CTC1_3 !r6=Fehlerpar. (CTC-Kanal-Adresse)! + calr CTC_TEST1 + +!-------------------------- +Testschritt 56 (CTC0/CTC1) +Test, ob CTC-Kanaele zaehlen +---------------------------! + +!Die CTC-Kanaele werden im Zeitgebermode programmiert, es wird eine +Zeitkonstante ausgegeben und diese nach einer bestimmten Wartezeit rueckgelesen +--- Fehler 56, wenn sich die Zeitkonstante nicht gaendert hat, d.h. wenn + der Kanal nicht zaehlt ---! + + ld r8, #%56 !Fehler 56: CTC-Kanal zaehlt nicht! + ld ERRPAR_ID, #%0080 !Fehlerparameter fuer Fehler 56: r6! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r0, #%FFFF !Wartezeit, um Ausgabe der Testschritt- + nummer zu garantieren im Falle, dass die + Ausgabe ueber Terminalkanal SIO0_B / CTC0_1 + erfolgt und nicht ueber Koppelschnittstelle! +WARTE2: djnz r0, WARTE2 + + ld r6, #CTC0_0 !r6=Fehlerpar. (CTC-Kanaladresse)! + calr CTC_TEST2 + ld r6, #CTC0_1 !r6=Fehlerpar. (CTC-Kanaladresse)! + calr CTC_TEST2 + ld r6, #CTC0_2 !r6=Fehlerpar. (CTC-Kanaladresse)! + calr CTC_TEST2 + ld r6, #CTC0_3 !r6=Fehlerpar. (CTC-Kanaladresse)! + calr CTC_TEST2 + ld r6, #CTC1_0 !r6=Fehlerpar. (CTC-Kanaladresse)! + calr CTC_TEST2 + ld r6, #CTC1_1 !r6=Fehlerpar. (CTC-Kanaladresse)! + calr CTC_TEST2 + ld r6, #CTC1_2 !r6=Fehlerpar. (CTC-Kanaladresse)! + calr CTC_TEST2 + ld r6, #CTC1_3 !r6=Fehlerpar. (CTC-Kanaladresse)! + calr CTC_TEST2 + +!-------------------------- +Testschritt 57 (CTC0/CTC1) +Test des Interruptsystems +--------------------------! + +!Die CTC-Kanaele werden auf ihre Interruptfaehigkeit getestet, indem sie +als Zeitgeber programmiert werden (mit Interrupt) und eine Zeitkonstante +ausgegeben wird +--- Fehler 57, wenn kein Interrupt erfolgt ---! + + ld r8, #%57 !Fehler 57: CTC-Kanal interruptet nicht! + ld ERRPAR_ID, #%0080 !Fehlerparameter fuer Fehler 57: r6! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r0, #%FFFF !Wartezeit, um Ausgabe der Testschritt- + nummer zu garantieren im Falle, dass die + Ausgabe ueber Terminalkanal SIO0_B / CTC0_1 + erfolgt und nicht ueber Koppelschnittstelle! +WARTE3: djnz r0, WARTE3 + + push @r15, VI_TAB_REST+2 !urspruengl. Wert retten! + push @r15, VI_TAB_REST+6 !urspruengl. Wert retten! + push @r15, VI_TAB_REST+10 !urspruengl. Wert retten! + push @r15, VI_TAB_REST+14 !urspruengl. Wert retten! + + ld VI_TAB_REST+2, #CTC_ISR !Adresse ISR in PSAREA eintr.! + ld VI_TAB_REST+6, #CTC_ISR !Adresse ISR in PSAREA eintr.! + ld VI_TAB_REST+10, #CTC_ISR !Adresse ISR in PSAREA eintr.! + ld VI_TAB_REST+14, #CTC_ISR !Adresse ISR in PSAREA eintr.! + + ldb rl0, #%20 !Interruptvektor (VI_TAB_REST)! + outb CTC0_0, rl0 + outb CTC1_0, rl0 + + ld r6, #CTC0_0 + calr CTC_TEST3 + ld r6, #CTC0_1 + calr CTC_TEST3 + ld r6, #CTC0_2 + calr CTC_TEST3 + ld r6, #CTC0_3 + calr CTC_TEST3 + ld r6, #CTC1_0 + calr CTC_TEST3 + ld r6, #CTC1_1 + calr CTC_TEST3 + ld r6, #CTC1_2 + calr CTC_TEST3 + ld r6, #CTC1_3 + calr CTC_TEST3 + + pop VI_TAB_REST+14, @r15 !urspruengl. Wert zurueckspeichern! + pop VI_TAB_REST+10, @r15 !urspruengl. Wert zurueckspeichern! + pop VI_TAB_REST+6, @r15 !urspruengl. Wert zurueckspeichern! + pop VI_TAB_REST+2, @r15 !urspruengl. Wert zurueckspeichern! + +!--------------------------------------------------------------- +Testschritt 60 (SIO0/SIO1) +Test auf fehlerhafte Daten 'AA' oder '55' fuer Interruptregister +---------------------------------------------------------------! + +!An die Interruptregister der SIO's werden die Daten 'AA' bzw. '55' +ausgegeben und rueckgelesen +--- Fehler 60, wenn ein Wert fehlerhaft rueckgelesen wurde ---! + + ld r8, #%60 !Fehler 60: fehlerhafte '%AA' bzw. '%55'-Daten! + ld ERRPAR_ID, #%0085 !Fehlerparameter fuer Fehler 60: + r6, rl5, rl4! + xorb rh1, rh1 !Flagbyte rh1 loeschen, + Byte-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r0, #%FFFF !Wartezeit, um Ausgabe der Testschritt- + nummer zu garantieren im Falle, dass die + Ausgabe ueber Terminalkanal SIO0_B / CTC0_1 + erfolgt und nicht ueber Koppelschnittstelle! +WARTE4: djnz r0, WARTE4 + + ld r6, #SIO0D_B !r6=Fehlerpar. (SIO-Adresse)! + ld r7, #SIO0C_B + calr SIO_TEST1 + ld r6, #SIO1D_B !r6=Fehlerpar. (SIO-Adresse)! + ld r7, #SIO1C_B + calr SIO_TEST1 + +!-------------------------- +Testschritt 61 (SIO0/SIO1) +Test des Interruptsystems +--------------------------! + +!Die SIO-Ports werden auf ihre Interruptfaehigkeit getestet, indem sie +auf Senderinterrupt programmiert werden und ein Byte ausgegeben wird +--- Fehler 61, wenn kein Interrupt erfolgt ---! + + ld r8, #%61 !Fehler 61: SIO-Port interruptet nicht! + ld ERRPAR_ID, #%0080 !Fehlerparameter fuer Fehler 61: r6! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r0, #%FFFF !Wartezeit, um Ausgabe der Testschritt- + nummer zu garantieren im Falle, dass die + Ausgabe ueber Terminalkanal SIO0_B / CTC0_1 + erfolgt und nicht ueber Koppelschnittstelle! +WARTE5: djnz r0, WARTE5 + + push @r15, VI_TAB_REST+2 !urspruengl. Wert retten! + push @r15, VI_TAB_REST+18 !urspruengl. Wert retten! + + ld VI_TAB_REST+2, #SIO_ISR !Adresse ISR in PSAREA eintr.! + ld VI_TAB_REST+18, #SIO_ISR !Adresse ISR in PSAREA eintr.! + + calr SIO0_A_TEST2 + calr SIO0_B_TEST2 + calr SIO1_A_TEST2 + calr SIO1_B_TEST2 + + pop VI_TAB_REST+18 @r15 !urspruengl. Wert zurueckspeichern! + pop VI_TAB_REST+2, @r15 !urspruengl. Wert zurueckspeichern! + +!--------------------------------------------- +Testschritt 70 (0000 'P') +Test auf externen Speicher (hoechstes Segment) +---------------------------------------------! + +!Beginnend bei Segment 0 wird jeweils bei den Offsetadressen %8000 und %FFFE +getestet, ob RAM vorhanden ist (auf der Adresse wird die Segmentnummer des +betrachteten Segments eingetragen und rueckgelesen). Wenn auf beiden Adressen +kein RAM vorhanden ist, ist die vorherige Segmentadresse die hoechste. +--- Fehler 70, wenn kein Segment vorhanden ist ---! + + ld r8, #%70 !Fehler 70: NO EXTERNAL MEMORY! + ld ERRPAR_ID, #%0000 !Fehlerparameter fuer Fehler 70: + keine Parameter! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + xor r6, r6 !r6 (rh6) := Segmentnummer (=0)! + ld MAX_SEGNR, r6 !hoechste Segmentnummer initialisieren (:=0)! + + ldb rl5, #%A5 +C_SEG: + ldb rl0, #%02 !Schleifenzaehler (2 Adressen testen)! + ldb rh5, rh6 !rh5:=Segmentnummer des zu testenden Segments! + ld r7, #%8000 !1. betrachtete Offsetadresse des Segments! +C_SEGL: + sc #SC_SEGV + ld @r6, r5 !r5 (rh5=akt.Segnr./rl5=%A5) in RAM eintragen! + ld r4, @r6 !ruecklesen! + sc #SC_NSEGV + cp r5, r4 !ruecklesbar! + jr z, INC_SEG !Sprung wenn Segment vorhanden! + ld r7, #%FFFE !2. betrachtete Offsetadresse des Segments! + dbjnz rl0, C_SEGL + + decb rh6, #%01 !betrachtetes Segment nicht vorhanden; + rh6:=hoechstes vorhandenes Segment! + cpb rh6, #0 + jr ge, _SEG_IO !mindestens Segment 0 vorhanden! + jp FAT_ERR !Fehler: kein Segment vorhanden! + +INC_SEG: + ld MAX_SEGNR, r6 !hoechste Segmentnummer retten! + incb rh6, #1 !Segmentadresse erhoehen! + jr C_SEG !naechstes Segment testen! + +!------------------------ +Testschritt 71 (0001 'O') +Test Segmentadressen +------------------------! + +!Beginnend beim hoechsten Segment wird bis zum Segment 0 auf den Offset- +adressen %8000 und %FFFE die im vorherigen Testschritt auf diesen Adressen +eingetragenen Segmentnummern rueckgelesen und mit der Segmentnummer des +betrachteten Segments verglichen. +--- Fehler 71, wenn der Vergleich auf beiden Adressen eines Segments + negativ ausfaellt ---! + +_SEG_IO: + ld r8, #%71 !Fehler 71: SEG. ADDR. FAULT! + ld ERRPAR_ID, #%00E1 !Fehlerparameter fuer Fehler 71: + , r7, rl4 ! + calr WR_TESTNR !Ausgabe der Testschrittnummer! +T_SEGR: + ldb rl0, #%02 !Schleifenzaehler (2 Adressen testen)! + ld r7, #%8000 !1. betrachtete Offsetadresse des Segments! +SEGR_LOOP: + sc #SC_SEGV + ldb rl4, @r6 !ruecklesen der im vorherigen Testschritt in + RAM eingetragene Segmentnummer! + sc #SC_NSEGV + cpb rh6, rl4 !ruecklesbar ? ! + jr z, DEC_SEG !Segment i.O.! + ld r7, #%FFFE !2. betrachtete Offsetadresse des Segments! + dbjnz rl0, SEGR_LOOP + jp FAT_ERR !Fehler: falsche Segmentadresse! + +DEC_SEG: + decb rh6, #%01 !Segmentnummer decrementieren! + cpb rh6, #%00 + jr ge, T_SEGR !naechstes Segment testen! + +!------------------------------------------------------------------ +Testschritte 72, 73, 74, 75, 79 (0100, 0101, 0102, 0103, 0104 'W') +RAM-Test (ausser Segment 0) +------------------------------------------------------------------! + +! +--- Fehler 72, 73, 74, 75 - siehe RAM_TEST_SEG --- +--- Fehler 79 wenn kein fehlerfreies Segment groesser 0 vorhanden ist --- +! + + ld ERR_CNT, #%0000 !Fehlerzaehler loeschen! + ld REM_ERR_CNT, #0 !Merker: Stand Fehlerzaehler loeschen! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + ld r6, MAX_SEGNR !r6:=hoechste Segmentnummer! + ldctl r9, FCW !r9:=Stand FCW! + +RAM_CHK: + calr RAM_TEST_SEG !RAM-Test im Segment r6! + + ld r2, ERR_CNT !r2:=Stand Fehlerzaehler nach Aufruf von + RAM_TEST_SEG! + cp r2, REM_ERR_CNT !Vergleich mit Stand Fehlerzaehler vor + Aufruf von RAM_TEST_SEG! + jr z, T_LOOP !kein Fehler aufgetreten --> Segment r6 i.O.! + + !Segment r6 nicht i.O.! + ld REM_ERR_CNT, r2 !neuen Stand Fehlerzaehler merken! + cp r6, MAX_SEGNR !war fehlerhaftes Segment das hoechste?! + jr nz, T_LOOP !nein --> naechstes Segment testen! + + !ja! + ld r8, #%79 !Fehler 79: No Good Segments Above Zero! + ld ERRPAR_ID, #%0000 !Fehlerparameter fuer Fehler 79: + keine Parameter! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + decb rh6, #%01 !hoechste SEGMENTNR. DEKREMENTIEREN! + testb rh6 + jp z, FAT_ERR !hoechste Segmentnummer war 1 und Segment 1 ist + fehlerhaft --> Fehler 79! + ld MAX_SEGNR, r6 !hoechste Segmentnummer neu laden, da + bisheriges hoechstes Segment fehlerhaft ist! + incb rh6, #%01 + +T_LOOP: !naechtes Segment testen! + decb rh6, #%01 !SEGMENTNR. DEKREMENTIEREN! + cpb rh6, #%00 + jr gt, RAM_CHK !alle Segmente > 0 testen! + +!------------------------------------------------------ +Testschritt 72, 73, 74, 76 (0100, 0101, 0102, 0103 'E') +RAM-Test Segment 0 +------------------------------------------------------! + +! +--- Fehler 72,73,74,76 - siehe RAM_TEST_SEG --- +! + xor r6, r6 !Segmentnummer 0! + ld r3, #S_BNK !Adresse S_BNK fuer Monitor PROM+RAM + ein- und ausschalten! + + ld r10, r6 !Quell-Segment=0! + ld r12, MAX_SEGNR !Ziel-Segment=hoechstes Segment! + ld r11, r6 !Quell-Offset=0! + ld r13, r6 !Ziel-Offset=0! + ld r9, #%8000 !Transferlaenge=ganzes Segment! + sc #SC_SEGV + ldir @r12, @r10, r9 !Transfer des Monitors in hoechstes Segment! + + ld r13, #RAM_TEST_SEG0 !Adresse fuer Programmfortsetzung laden + (RAM_TEST_SEG0 im hoechsten Segment)! + ld r11, #MMU_TEST !Folgeadresse nach RAM_TEST_SEG0 laden + (MMU_TEST im Segment 0)! + jp @r12 !Sprung in hoechstes Segment zu RAM_TEST_SEG0! + end TEST_ + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE RAM_TEST_SEG0 +RAM-Test im Segment 0 ausfuehren +Input: r6 - Segmentnummer des zu testenden Segments (= %0000) +Output: r3 - Stand Fehlerzaehler (ERR_CNT) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + RAM_TEST_SEG0 procedure + entry + ldctl r9, FCW !r9:=Stand FCW! + res r9, #%0F + ldctl FCW, r9 !nichtsegmentierten Mode einstellen! + +!Terminalinterrupts sperren! + testb PTYPORT !8-Bit-Teil aktiv?! + jr z, RATE01 !nein! + + !Terminal 8-Bit-Teil: + Empfaenger- und Senderinterrupts sperren! + ldb rl0, #SIO0C_B_8 !Adresse SIO0C_B auf 8-Bit-Teil! + ldb rh0, #SIO_R1 + call KP_OUTB !Datenbyte rh0 an SIO-Adr. rl0 ausgeben! + ldb rh0, #DRCVRI !Empfaengerinterrupt aus! + call KP_OUTB !Datenbyte rh0 an SIO-Adr. rl0 ausgeben! + jr RATE02 +RATE01: !Terminal 16-Bit-Teil: + Empfaengerinterrupts sperren! + ld r2, #SIO0C_B + ldb rh4, #SIO_R1 + outb @r2, rh4 + ldb rl4, #DRCVRI !Empfaengerinterrupt aus! + outb @r2, rl4 + +RATE02: + inb rh2, S_BNK + setb rh2, #%00 + outb S_BNK, rh2 !Monitor PROM+RAM ausschalten! + + ld ERR_CNT, #0 !Fehlerzaehler loeschen + (ERR_CNT liegt hier im hoechsten Segment)! + setb rh1, #%00 !Test in Segment 0! + calr RAM_TEST_SEG !Ramtest des Segment 0! + + inb rh2, S_BNK + resb rh2, #%00 + outb S_BNK, rh2 !Monitor PROM+RAM einschalten! + +!Terminalinterrupts wieder zulassen! + testb PTYPORT !8-Bit-Teil aktiv?! + jr z, RATE03 !nein! + + !Terminal 8-Bit-Teil: + Empfaenger- und Senderinterrupts zulassen! + ldb rl0, #SIO0C_B_8 !Adresse SIO0C_B auf 8-Bit-Teil! + ldb rh0, #SIO_R1 + call KP_OUTB !Datenbyte rh0 an SIO-Adr. rl0 ausgeben! + ldb rh0, #PDAVCT+SAVECT + call KP_OUTB !Datenbyte rh0 an SIO-Adr. rl0 ausgeben! + jr RATE04 +RATE03: !Terminal 16-Bit-Teil: + Empfaengerinterrupts zulassen! + ld r2, #SIO0C_B + ldb rh4, #SIO_R1 + outb @r2, rh4 + ldb rl4, #PDAVCT+SAVECT + outb @r2, rl4 + +RATE04: + ld r3, ERR_CNT !r3:=Anzahl der Fehler bei RAM_TEST_SEG0 + (RAM-Zelle ERR_CNT liegt hier im hoechsten + Segment)! + + set r9, #%0F + ldctl FCW, r9 !segmentierten Mode einstellen! + jp @r10 !RUECKSPRUNG INS SEGMENT 0 ZU MMU_TEST! + end RAM_TEST_SEG0 + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE MMU_TEST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + MMU_TEST procedure + entry + sc #SC_NSEGV + add r3, ERR_CNT !waehrend RAM_TEST_SEG0 aufgetretene Fehler + zu Stand ERR_CNT addieren! + ld ERR_CNT, r3 !Fehlerzaehler aktualisieren! + test r3 !Fehler bei RAM-Test aufgetreten?! + jp nz, FAT_ERR1 !ja --> Ausgabe T_FERR; Abbruch! + + xorb rh1, rh1 !Flagbyte rh1 loeschen! + +!MMU-ID in Mode-Register eintragen! + xorb rl2, rl2 + soutb CODE_MMU, rl2 !CODE-MMU: ID=0! + incb rl2, #%01 + soutb DATA_MMU, rl2 !DATA-MMU: ID=1! + incb rl2, #%01 + soutb STACK_MMU, rl2 !STACK-MMU: ID=2! + + soutb ALL_MMU, rl2 + SOUTB ALL_MMU + %1100, RL2 !Reset Violation-Type-Register! + +!Adresse fuer Segment-Trap und Priv.-Instr.-Trap aus PSAREA retten! + ldctl r9, PSAP + ld r4, %26(r9) !Offsetadresse fuer Segment-Trap! + ld REM_SEGMENT_TRAP, r4 + ld r4, %16(r9) !Offsetadresse fuer Priv.-Instr.-Trap! + ld REM_PRIVINSTR_TRAP, r4 +!Adresse fuer Segment-Trap und Priv. Instr. Trap in PSAREA neu setzen! + ld %22(r9), #%4000 !FCW=nonsegmented! + ld %24(r9), #%0000 !Segmentadresse=0! + ld %26(r9), #SEGMENT_TRAP !Offsetadresse! + ld %12(r9), #%4000 !FCW=nonsegmented! + ld %14(r9), #%0000 !Segmentadresse=0! + ld %16(r9), #PRIVINSTR_TRAP !Offsetadresse! + +!SDR-Tabellen fuer Test laden! + ld r10, #%A100 !%A100-%A1FF mit %00 laden! + ld r11, #%A101 + xor r5, r5 + ld r0, #%00FF + ldb @r10, rl5 + ldirb @r11, @r10, r0 + + ld r10, #%A000 !%A000-%A0FF mit %00 BIS %FF laden! +LD_INC: + ldb @r10, rl5 + inc r10, #%01 + inc r5, #%01 + bitb rh5, #%00 + jr z, LD_INC + + ld r10, #%A200 !%A200-%A2FF mit %AA laden! + ld r11, #%A201 + ld r5, #%AAAA + ld r0, #%00FF + ldb @r10, rl5 + ldirb @r11, @r10, r0 + + ld r10, #%A300 !%A300-%A3FF mit %55 laden! + ld r11, #%A301 + ld r5, #%5555 + ld r0, #%00FF + ldb @r10, rl5 + ldirb @r11, @r10, r0 + +!Schleife L14E2 (Testschritt 80, 81, 82, 83) wird 3x durchlaufen mit +r2=0,2,4 (r2-Zeiger auf 1. MMU-Adresse in MMU_LISTE1 fuer den entsprechenden +Durchlaufes! + xor r2, r2 !r2=0 (1. Schleifendurchlauf) + Reihenfolge der MMU's: + 1. CODE-, 2. DATA-, 3. STACK-MMU! + !r2=2 (2. Schleifendurchlauf) + Reihenfolge der MMU's: + 1. DATA-, 2. STACK-, 3. CODE-MMU! + !r2=4 (3. Schleifendurchlauf) + Reihenfolge der MMU's: + 1. STACK-, 2. CODE-, 3. DATA-MMU! +L14E2: + +!--------------------------------------------------------- +Testschritt 80 (0300) +Test auf individuelle Adressierbarkeit der einzelnen MMU's +---------------------------------------------------------! +! +--- Fehler 80, wenn MMU's nicht einzeln addressierbar --- +! + + ld r8, #%80 !Fehler 80: MMU's Not Individually Adressable! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + xor r3, r3 + +!64 SDR der 3 MMU's fuellen! + ld r6, MMU_LISTE1(r2) !Adresse der 1. MMU des entsprechenden + Durchlaufes: CODE-MMU (1. Durchlauf) + bzw. DATA-MMU (2. Durchlauf) + bzw. STACK-MMU (3. Durchlauf) ! + ld r11, #%A000 !Anfangsadresse der SDR-Tabelle im Speicher! + calr LD_SDR !64 SDR der 1. MMU des Durchlaufes fuellen mit + Inhalt des Speicherbereiches %A000-%A0FF! + + incb rl2, #%02 + ld r6, MMU_LISTE1(r2) !Adresse der 2. MMU des entsprechenden + Durchlaufes: DATA-MMU (1. Durchlauf) + bzw. STACK-MMU (2. Durchlauf) + bzw. CODE-MMU (3. Durchlauf) ! + ld r11, #%A100 !Anfangsadresse der SDR-Tabelle im Speicher! + calr LD_SDR !64 SDR der 2. MMU des Durchlaufes fuellen mit + Inhalt des Speicherbereiches %A100-%A1FF! + + incb rl2, #%02 + ld r6, MMU_LISTE1(r2) !Adresse der 3. MMU des entsprechenden + Durchlaufes: STACK-MMU (1.Durchlauf) + bzw. CODE-MMU (2. Durchlauf) + bzw. DATA-MMU (3. Durchlauf)! + calr LD_SDR !64 SDR der 3. MMU des Durchlaufes fuellen mit + Inhalt des Speicherbereiches %A100-%A1FF! + + decb rl2, #%04 !Zeiger in MMU_LISTE1 wieder auf 1. MMU des + entsprechenden Durchlaufes stellen! + +!Vergleich: geschriebener mit rueckgelesener SDR-Tabelle fuer die +3 MMU's des entsprechenden Durchlaufes +(r3=0: 1. MMU / r3=2: 2. MMU / r3=4: 3. MMU des Durchlaufes)! +L150E: + ld r9, r3 + add r9, r2 + ld r6, MMU_LISTE1(r9) !Adresse der 1. bzw. 2. bzw. 3. MMU + entsprechend r3! + ld r11, MMU_LISTE2(R3) !Anfangsadresse der zugehoerigen SDR- + Tabelle im Speicher! + calr RD_SDR !Vergleich: geschriebene und rueckgelesene + SDR-Tabelle; ggf. Fehler 80! + incb rl3, #%02 + cpb rl3, #%06 + jr nz, L150E !naechste MMU! + +!---------------------------------- +Testschritt 81 (0301) +Test der SAR- bzw. DSCR-Indizierung +----------------------------------! +! +--- Fehler 81, wenn die SAR- oder DSCR-Indizierung fehlerhaft ist --- +! + + ld r8, #%81 !Fehler 81: SAR Or DSCR Indexing Fault! + andb rh1, #%01 !Flagbyte Bit 1-7 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r0, #%001E !Anzahl der Bytes der MMU_LISTE3! + !(10 x 3 Bytes)! + ld r6, MMU_LISTE1(R2) !Adresse der 1. MMU des entsprechenden + Durchlaufes: CODE-MMU (1. Durchlauf) + bzw. DATA-MMU (2. Durchlauf) + bzw. STACK-MMU (3. Durchlauf) ! + ld r3, #MMU_LISTE3 +!Schleife L1538 wird 10 mal durchlaufen, wobei bei jedem Durchlauf 3 Bytes + der MMU_LISTE3 benutzt werden (1.Byte: write SAR; 2.Byte: write DSCR; + 3.Byte: Datenwert, der rueckgelesen werden muesste)! +L1538: + ld r10, r6 !Adresse der 1. MMU des Durchlaufes! + add r10, #%0100 !Write Segment-Adress-Register (SAR)! + ldb rl7, @r3 + sllb rl7, #%02 + soutib @r10, @r3, r0 !Beschreiben SAR mit akt. Byte der MMU_LISTE3! + !incr r3 / decr r0! + + ld r10, r6 !Adresse der 1. MMU des Durchlaufes! + add r10, #%2000 !Write Descriptor-Selector-Counter-Reg. (DSCR)! + addb rl7, @r3 !rl7=Fehlerpar. (SDR FELD#)! + soutib @r10, @r3, r0 !Beschreiben DSCR mit akt. Byte der MMU_LISTE3! + !incr r3 / decr r0! + + ld r10, r6 !Adresse der 1. MMU des Durchlaufes! + add r10, #%0F00 !Read Descriptor and increment SAR! + ldb rl5, @r3 !rl5=Fehlerpar. (Testdatenwert (Datenwert, der + rueckgelesen werden muesste))! + ld r9, #REM_MMU_SINOUT !Speicherplatz fuer rueckgelesenen Wert! + sinib @r9, @r10, r0 !Ruecklesen! + !incr r9 / decr r0! + dec r9, #%01 + ldb rl4, @r9 !rl4=Fehlerpar. (rueckgelesener Datenwert)! + calr BY_WO_CMP !Vergleich rl4/rl5; ggf. Fehler 81! + bitb rh1, #%07 + jr nz, L1578 !Fehler aufgetreten, naechster Testschritt! + inc r3, #%01 !r3 auf naechstes Byte in MMU_LISTE3 stellen! + testb rl0 !MMU_LISTE3 abgearbeitet?! + jr nz, L1538 !nein! + +!-------------------- +Testschritt 82 (0302) +Test der SDR-Daten +--------------------! +! +--- Fehler 82, wenn SDR-Daten 'AA' oder '55' fehlerhaft sind --- +! + + ld r8, #%82 !Fehler 82: SDR 'As' Or '5s' Data Fault! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + +L1578: + ld r11, #%A200 !Anfangsadresse der SDR-Tabelle im Speicher! + calr LD_SDR !64 SDR der 1. MMU des Durchlaufes fuellen + mit 'AA' (Inhalt Speicherbereich %A200-%A2FF)! + calr RD_SDR !Vergleich geschriebene mit rueckgelesene + SDR-Tabelle; ggf. Fehler 82! + ld r11, #%A300 !Anfangsadresse der SDR-Tabelle im Speicher! + calr LD_SDR !64 SDR der 1. MMU des Durchlaufes fuellen + mit '55' (Inhalt Speicherbereich %A300-%A3FF)! + calr RD_SDR !Vergleich geschriebene mit rueckgelesene + SDR-Tabelle; ggf. Fehler 82! + +!---------------------------------- +Testschritt 83 (0303) +Test der MMU-Control-Register-Daten +----------------------------------! +! +--- Fehler 83, wenn MMU-Control-Register-Daten 'AA' oder '55' + fehlerhaft sind --- +! + + ld r8, #%83 !Fehler 83: MMU Control Register 'As' Or '5s' + Fault! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + ld ERRPAR_ID, #%0025 !Fehlerparameter fuer Fehler 83: + r7, rl5, rl4! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r9, #REM_MMU_SINOUT !Speicherplatz fuer Testdaten! + ld @r9, #%AAAA !Test mit Daten 'AA'! + ldb rl0, #%02 !2 Durchlaeufe fuer Schleife L15A4 + (fuer Daten 'AA' bzw. '55')! +L15A4: +!Beschreiben der Control-Register aller MMU's! + ldb rl5, @r9 !rl5=Fehlerpar. (Testdatenwert)! + soutb ALL_MMU + %0000, rl5 !Write Mode-Register! + soutb ALL_MMU + %0100, rl5 !Write Segment-Adress-Register (SAR)! + soutb ALL_MMU + %2000, rl5 !Write Descriptor-Selector-Counter- + Register (DSCR)! +!Ruecklesen der Control-Register der 1. MMU des Durchlaufes und Vergleich! + ld r10, r6 !Adresse der 1. MMU des Durchlaufes! + add r10, #%0000 !Read Mode-Register! + sinib @r9, @r10, r11 !Ruecklesen Mode-Register! + dec r9, #%01 + ldb rl4, @r9 !rl4=Fehlerpar. (rueckgelesener Datenwert)! + ld r7, r6 !r7=Fehlerpar. (MMU CMD#) + rl7 - MMU-Adresse + rh7 - Kommando %00: R/W Mode-Register! + calr BY_WO_CMP !Vergleich rl5/rl4; ggf. Fehler 83! + + ld r10, r6 + add r10, #%0100 !Read Segment-Adress-Register (SAR)! + sinib @r9, @r10, r11 !Ruecklesen SAR! + dec r9, #%01 + ldb rl4, @r9 !rl4=Fehlerpar. (rueckgelesener Datenwert)! + andb rl5, #%3F !rl5=Fehlerpar. (Testdatenwert (Datenwert, der + rueckgelesen werden muesste))! + incb rh7, #%01 !r7=Fehlerpar. (MMU CMD#) + rl7 - MMU-Adresse + rh7 - Kommando %01: R/W SAR! + calr BY_WO_CMP !Vergleich rl5/rl4; ggf. Fehler 83! + + ld r10, r6 + add r10, #%2000 !Read Descriptor-Selector-Counter-Register! + sinib @r9, @r10, r11 !Ruecklesen DSCR! + dec r9, #%01 + ldb rl4, @r9 !rl4=Fehlerpar. (rueckgelesener Datenwert)! + andb rl5, #%03 !rl5=Fehlerpar. (Testdatenwert (Datenwert, der + rueckgelesen werden muesste))! + ldb rh7, #%20 !r7=Fehlerpar. (MMU CMD#) + rl7 - MMU-Adresse + rh7 - Kommando %20: R/W DSCR! + calr BY_WO_CMP !Vergleich rl5/rl4; ggf. Fehler 83! + + ld @r9, #%5555 !Test mit Daten '55'! + dbjnz rl0, L15A4 + + incb rl2, #%02 + cpb rl2, #%06 + jp nz, L14E2 !r2=2 (2. Schleifendurchlauf)! + !bzw.! + !r2=4 (3. Schleifendurchlauf)! + +!------------------------------------------- +Testschritt 84 (0304) +Test der System-/Normal-Break-Register-Daten +-------------------------------------------! +! +--- Fehler 84, wenn System-/Normal-Break-Register-Daten 'AA' oder '55' + fehlerhaft sind --- +! + + ld r8, #%84 !Fehler 84: System/Normal Break Register + 'As' Or '5s' Fault! + ld ERRPAR_ID, #%0085 !korrigiert (original %0094)! + !Fehlerparameter fuer Fehler 84: + r6, rl5, rl4 ! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r10, #%0100 + xor r11, r11 + sc #SC_SEGV + ld @r10, #%0001 + ld r11, r10 + ld @r10, #%0000 + sc #SC_NSEGV + lda r3, MMU_LISTE4 + ld r4, r3 + lda r5, MMU_LISTE10 + xor r7, r7 + call CLR_CTL_REG + ldb rl0, #%02 + ld r6, #CODE_MMU+%0F00 + ld r7, #DATA_MMU+%0F00 + ld r9, #STACK_MMU+%0F00 +LB_1826: + ld r2, #%0004 + sotirb @r6, @r3, r2 + ld r2, #%0004 + sotirb @r7, @r4, r2 + ld r2, #%0004 + sotirb @r9, @r5, r2 + lda r3, MMU_LISTE8 + lda r4, MMU_LISTE9 + ld r5, r4 + dbjnz rl0, LB_1826 + ldb rl0, #%D0 + soutb ALL_MMU, rl0 + ldb rl0, #%02 + outb S_BNK, rl0 + xor r11, r11 + sc #SC_SEGV + ld r12, @r10 + sc #SC_NSEGV + xor r0, r0 + outb S_BNK, rl0 + soutb ALL_MMU, rl0 + ld REM_MMU2, r0 + ld REM_MMU1, r12 + test r12 + jr z, LB_187C + set REM_MMU2, #%00 + jp LB_18A8 +LB_187C: + + ldb rl0, #%02 !2 Durchlauefe der Schleife L1616 fuer + System- und Normal-Break-Register! + ld r6, #SBREAK !Test System-Break-Register! +L1616: + ld r5, #%AAAA !rl5=Fehlerpar. (Testdatenwert)! + outb @r6, rl5 !Break-Reg. beschreiben! + inb rl4, @r6 !rl4=Fehlerpar. (rueckgelesener Datenwert)! + calr BY_WO_CMP !Vergleich rl5/rl4; ggf. Fehler 84! + + ld r5, #%5555 !rl5=Fehlerpar. (Testdatenwert)! + outb @r6, rl5 !Break-Reg. beschreiben! + inb rl4, @r6 !rl4=Fehlerpar. (rueckgelesener Datenwert)! + calr BY_WO_CMP !Vergleich rl5/rl4; ggf. Fehler 84! + + ld r6, #NBREAK !Test Normal-Break-Register! + dbjnz rl0, L1616 + +!---------------------------------------------- +Testschritt 85 (0305 'I') +Test, ob STACK-MMU beim Limit-Test Trap erzeugt +----------------------------------------------! +! +--- Fehler 85, wenn STACK-MMU beim Limit-Test keinen Trap erzeugt --- +! + +LB_18A8: + ld r8, #%85 !Fehler 85: Stack MMU Did Not Trap On + Limit Test! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r2, #%9000 + outb SBREAK, rh2 !System-Break-Register mit %90 laden! + outb NBREAK, rh2 !Normal-Break-Register mit %90 laden! + + ld r3, #MMU_LISTE4 !r3 - Zeiger auf SDR-Feld fuer CODE-MMU! + ld r4, r3 !r4 - Zeiger auf SDR-Feld fuer DATA-MMU! + ld r5, #MMU_LISTE6 !r5 - Zeiger auf SDR-Feld fuer STACK-MMU! + test REM_MMU1 + jr z, LB_18CE + ld r5, #MMU_LISTE5 +LB_18CE: + calr LD_3SDR !SDR der 3 MMU's programmieren! + + ld r3, #%A000 !Offsetadresse fuer Trap-Test! + ldb rh0, #%04 !MMU_ID: Stack-MMU muss Trap ausloesen! + ldb rl4, #%D2 + calr SEGMENT_TRAP_TEST !Trap-Test; ggf. Fehler 0305! + +!------------------------- +Testschritt 86 (0305 'A') +Test auf unerwarteten Trap +-------------------------! +! +--- Fehler 86, wenn ein Trap ausgeloest wird --- +! + + ld r8, #%86 !Fehler 86: Unexpected Trap! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r3, #%8000 !Offsetadresse fuer Trap-Test! + xorb rh0, rh0 !kein Trap darf ausgeloest werden! + ldb rl4, #%D1 + calr SEGMENT_TRAP_TEST !Trap-Test; ggf. Fehler 86! + +!------------------------- +Testschritt 87 (0305 'G') +Test auf unerwarteten Trap +-------------------------! +! +--- Fehler 87, wenn ein Trap ausgeloest wird --- +! + + ld r3, #MMU_LISTE4 !r3 - Zeiger auf SDR-Feld fuer CODE-MMU! + ld r4, #MMU_LISTE6 !r4 - Zeiger auf SDR-Feld fuer DATA-MMU! + ld r5, r3 !r5 - Zeiger auf SDR-Feld fuer STACK-MMU! + test REM_MMU1 + jr z, LB_18FE +LB_18FE: + calr LD_3SDR !SDR der 3 MMU's programmieren! + + ld r8, #%87 !Fehler 87: Unexpected Trap! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r3, #%A000 !Offsetadresse fuer Trap-Test! + xorb rh0, rh0 !kein Trap darf ausgeloest werden! + ldb rl4, #%D2 + calr SEGMENT_TRAP_TEST !Trap-Test; ggf. Fehler 0305! + +!---------------------------------------------- +Testschritt 88 (0305 'N') +Test, ob DATA-MMU beim Limit-Test Trap erzeugt +----------------------------------------------! +! +--- Fehler 88, wenn DATA-MMU beim Limit-Test keinen Trap erzeugt --- +! + + ld r8, #%88 !Fehler 88: Data MMU Did Not Trap On + Limit Test! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r3, #%8000 !Offsetadresse fuer Trap-Test! + ldb rh0, #%02 !MMU_ID: DATA-MMU muss Trap ausloesen! + ldb rl4, #%D1 + calr SEGMENT_TRAP_TEST !Trap-Test; ggf. Fehler 88! + +!-------------------------------------------------- +Testschritt 89 (0305 'O') +Test, ob STACK-MMU beim Read-Only-Test Trap erzeugt +--------------------------------------------------! +! +--- Fehler 89, wenn STACK-MMU beim Read-Only-Test keinen Trap erzeugt --- +! + + ld r3, #MMU_LISTE4 !r3 - Zeiger auf SDR-Feld fuer CODE-MMU! + ld r4, #MMU_LISTE7 !r4 - Zeiger auf SDR-Feld fuer DATA-MMU! + ld r5, r4 !r5 - Zeiger auf SDR-Feld fuer STACK-MMU! + calr LD_3SDR !SDR der 3 MMU's programmieren! + + ld r8, #%89 !Fehler 89: Stack MMU Did Not Trap On + Read-Only Test! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r3, #%A000 !Offsetadresse fuer Trap-Test! + ldb rh0, #%04 !MMU_ID: STACK-MMU muss Trap ausloesen! + ldb rl4, #%D2 + calr SEGMENT_TRAP_TEST !Trap-Test; ggf. Fehler 89! + +!-------------------------------------------------- +Testschritt 90 (0305 'S') +Test, ob DATA-MMU beim Read-Only-Test Trap erzeugt +--------------------------------------------------! +! +--- Fehler 90, wenn DATA-MMU beim Read-Only-Test keinen Trap erzeugt --- +! + + ld r8, #%90 !Fehler 90: Data MMU Did Not Trap On + Read-Only Test! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r3, #%8000 !Offsetadresse fuer Trap-Test! + ldb rh0, #%02 !MMU_ID: DATA-MMU muss Trap ausloesen! + ldb rl4, #%D1 + calr SEGMENT_TRAP_TEST !Trap-Test; ggf. Fehler 90! + +!------------------------------------------------ +Testschritt 91/92 (0306/0307 'T') +Test, ob Uebersetzung der DATA-MMU fehlerfrei ist +------------------------------------------------! +! +--- Fehler 91, wenn Uebersetzung der DATA-MMU fehlerhaft ist --- +--- Fehler 92, wenn ein Trap ausgeloest wurde --- +! + + ld r8, #%91 !Fehler 91: Translation Fault On Data MMU! + + ld ERRPAR_ID, #%009A !Fehlerparameter fuer Fehler 91: + r6, rl7, r5, r4 ! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + setb rh1, #%01 !WORD-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r2, #%FFFF + outb SBREAK, rl2 !System-Break-Register mit %FF laden! + outb NBREAK, rl2 !Normal-Break-Register mit %FF laden! + + ld r3, #MMU_LISTE4 !r3 - Zeiger auf SDR-Feld fuer CODE-MMU! + ld r4, r3 !r4 - Zeiger auf SDR-Feld fuer DATA-MMU! + ld r5, r3 !r5 - Zeiger auf SDR-Feld fuer STACK-MMU! + calr LD_3SDR !SDR der 3 MMU's programmieren! + + xor r2, r2 !rh2=logische Segmentnummer (0-63)! + ld r3, #%9000 !Offsetadresse fuer Test! + ld r5, #%AAAA !r5=Fehlerpar. (Testdatenwert (auf Offset- + adresse r3 zu schreiben))! + ld r6, #DATA_MMU !r6=Fehlerpar. (MMU PORT#)! + ld r0, #%00D1 + +!Schleife fuer die Segmente 0-63 (r2)! +TST_DATA_MMU: + ld @r3, #%0000 !Speicheradresse %9000 loeschen! + ld REM_MMU_ID, #%0000 !Merker: MMU-ID loeschen - + wird bei Segment-Trap gesetzt! + ldb rl4, #%02 + test REM_MMU1 + jr z, LB_199E + ldb rl4, #%06 +LB_199E: + outb S_BNK, rl4 !MMU's einschalten! + + soutb DATA_MMU, rl0 !Mode-Register mit %D1 laden (ID=1), d.h. + DATA-MMU aktivieren! + + ldctl r9, FCW + set r9, #%0F + test REM_MMU2 + jr z, LB_19B2 + res r9, #%0E +LB_19B2: + ldctl FCW, r9 + ld @r2, r5 !Speicheradresse rr2 (Segment rh2/Offset %9000) + mit Datenwert %AAAA beschreiben! + mbit + sc #SC_NSEGV + + soutb DATA_MMU, rh0 !Mode-Register mit %00 laden, d.h. + DATA-MMU deaktivieren! + outb S_BNK, rh0 !MMU's ausschalten! + + ldb rl7, rh2 !rl7=Fehlerpar. (SDR#) =log. Segmentnummer! + test REM_MMU_ID !Segment-Trap (Routine SEGMENT_TRAP) + aufgetreten?! + jr nz, L1738 !ja, d.h. Fehler 92! + + ld r4, @r3 !r4=Fehlerpar. (rueckgelesener Datenwert! + calr BY_WO_CMP !Vergleich r5/r4; ggf. Fehler 91! + + bitb rh1, #%07 !Fehler aufgetreten?! + jr nz, L1748 !ja, d.h. naechster Testschritt! + + incb rh2, #%01 + cpb rh2, #%40 + jr nz, TST_DATA_MMU !naechste logische Segmentnummer! + jr L1748 !alle Segmentnummern abgearbeitet, d.h. + naechster Testschritt! + +!Fehler 92! +L1738: + ld r8, #%92 !Fehler 92: Unexpected Trap! + ld ERRPAR_ID, #%0098 !Fehlerparameter fuer Fehler 92: + r6, rl7, r5 ! + + ld r5, REM_MMU_BCSR !r5=Fehlerpar. (VDAT) - Werte der Status- + Register BCSR und VTR nach Segment-Trap: + rh5= Bus Cycle Status Register (BCSR) / + rl5= Violation Type Register (VTR) ! + calr MSG_ERROR !Fehlerausgabe! + +!------------------------------------------------- +Testschritt 93/94 (0308/0309 'I') +Test, ob Uebersetzung der STACK-MMU fehlerfrei ist +-------------------------------------------------! +! +--- Fehler 93, wenn Uebersetzung der STACK-MMU fehlerhaft ist --- +--- Fehler 94, wenn ein Trap ausgeloest wurde --- +! + +L1748: + ld r8, #%93 !Fehler 93: Translation Fault On Stack MMU! + ld ERRPAR_ID, #%009A !Fehlerparameter fuer Fehler 93: + r6, rl7, r5, r4! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + setb rh1, #%01 !WORD-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r0, #%00D2 + outb SBREAK, rh0 !System-Break-Register mit %00 laden! + outb NBREAK, rh0 !Normal-Break-Register mit %00 laden! + + xor r2, r2 !rh2=logische Segmentnummer (0-63)! + test REM_MMU1 + jr z, LB_1A16 + ld r2, #%4000 !rh2=logische Segmentnummer (64-127)! +LB_1A16: + ld r6, #STACK_MMU !r6=Fehlerpar. (MMU PORT#)! + +!Schleife fuer die Segmente 64-127 (r2)! +TST_STACK_MMU: + ld @r3, #%0000 !Speicheradresse %9000 loeschen! + ld REM_MMU_ID, #%0000 !Merker: MMU-ID loeschen - + wird bei Segment-Trap gesetzt! + ldb rl4, #%02 + test REM_MMU1 + jr z, LB_1A2E + ldb rl4, #%06 +LB_1A2E: + outb S_BNK, rl4 !MMU's einschalten! + + soutb STACK_MMU, rl0 !Mode-Register mit %D2 laden (ID=2), d.h. + STACK-MMU aktivieren! + + ldctl r9, FCW + set r9, #%0F + test REM_MMU2 + jr z, LB_1A42 + res r9, #%0E +LB_1A42: + ldctl FCW, r9 + ld @r2, r5 !Speicheradresse rr2 (Segment rh2/Offset %9000) + mit Datenwert %AAAA beschreiben! + mbit + sc #SC_NSEGV + + soutb STACK_MMU, rh0 !Mode-Register mit %00 laden, d.h. + STACK-MMU deaktivieren! + outb S_BNK, rh0 !MMU's ausschalten! + + ldb rl7, rh2 !rl7=Fehlerpar. (SDR#) =log. Segmentnummer! + test REM_MMU_ID !Segment-Trap (Routine SEGMENT_TRAP) + aufgetreten?! + jr nz, L17AA !ja, d.h. Fehler 94! + + ld r4, @r3 !r4=Fehlerpar. (rueckgelesener Datenwert! + calr BY_WO_CMP !Vergleich r5/r4; ggf. Fehler 93! + + bitb rh1, #%07 !Fehler aufgetreten?! + jr nz, L17BA !ja, d.h. naechster Testschritt! + + incb rh2, #%01 + test REM_MMU1 + jr z, LB_1A72 + cpb rh2, #%80 + jr nz, TST_STACK_MMU + jr L17BA +LB_1A72: + cpb rh2, #%40 + jr nz, TST_STACK_MMU !naechste logische Segmentnummer! + jr L17BA !alle Segmentnummern abgearbeitet, d.h. + naechster Testschritt! + +!Fehler 94! +L17AA: + ld r8, #%94 !Fehler 0309: Unexpected Trap! + ld ERRPAR_ID, #%0098 !Fehlerparameter fuer Fehler 94: + r6, rl7, r5 ! + + ld r5, REM_MMU_BCSR !r5=Fehlerpar. (VDAT) - Werte der Status- + Register BCSR und VTR nach Segment-Trap: + rh5= Bus Cycle Status Register (BCSR) / + rl5= Violation Type Register (VTR) ! + calr MSG_ERROR !Fehlerausgabe! + +!------------------------------------------------ +Testschritt 95/96 (0310/0311 'C') +Test, ob Uebersetzung der CODE-MMU fehlerfrei ist +------------------------------------------------! +! +--- Fehler 95, wenn Uebersetzung der CODE-MMU fehlerhaft ist --- +--- Fehler 96, wenn ein Trap ausgeloest wurde --- +! + +L17BA: + ld r8, #%95 !Fehler 95: Translation Fault On Code MMU! + ld ERRPAR_ID, #%009A !Fehlerparameter fuer Fehler 95: + r6, rl7, r5, r4 ! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + setb rh1, #%01 !WORD-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + clr REM_MMU2 + + ldctl r9, PSAP + ld %26(r9), #CODE_TRAP !neue Trap-Routine fuer Segment-Trap + in PSAREA eintragen! + ld r4, #CODE_FELD + ld r5, #%9000 + ld r3, #%0004 + ldirb @r5, @r4, r3 !CODE_FELD NACH %9000 MOVEN! + + ld r0, #%00D0 + ld r6, #CODE_MMU !r6=Fehlerpar. (MMU PORT#)! + + ldb rl3, #%02 !Kennzeichnung Testschritt 95 (rl3=2)! + ldb rh3, #%02 + test REM_MMU1 + jr z, LB_1ACC + ldb rh3, #%06 +LB_1ACC: + xor r2, r2 !rh2=logische Segmentnummer (0-63)! + ld r5, r2 !r5=Fehlerpar. (Testdatenwert) = %0000 + (r4 soll durch Abarbeitung von CODE_FELD + auf diesen Wert gesetzt werden)! + + ld r10, r2 !r10/r11 - Ansprungadresse Marke FKT_TST! + ld r11, #FKT_TST !(Segment 0, Offset #FKT_TST)! + + ld r13, #%9000 !Ansprungadresse (Offset) fuer CODE_FELD! + +!fuer Testschritt 95 und 97! +!Schleife fuer die Segmente 0-63 (r2)! +TST_CODE_MMU: + ld r12, r2 !Ansprungadresse (Segment) fuer CODE_FELD + (Segment 0-63)! + ld REM_MMU_ID, #%0000 !Merker: MMU-ID loeschen - + wird bei Segment-Trap gesetzt! + ld r4, #%AAAA !r4=Fehlerpar. (zurueckgegebener Datenwert) + setzen (wird bei Abarbeitung von + CODE_FELD auf %0000 gesetzt)! + + outb S_BNK, rh3 !MMU's einschalten! + soutb CODE_MMU, rl0 !Mode-Register mit %D0 laden (ID=0), d.h. + CODE-MMU aktivieren! + sc #SC_SEGV + jp @r12 !Sprung zu CODE_FELD auf Offsetadresse %9000 + im aktuellen Segment (r2) - r4 wird in + CODE_FELD auf den Wert %0000 gesetzt; + dann Fortsetzung bei FKT_TST! + !oder! + !Segment-Trap (Routine CODE_TRAP) - + r4 wird nicht veraendert; + dann Fortsetzung bei FKT_TST! +FKT_TST: + sc #SC_NSEGV + + soutb CODE_MMU, rh0 !Mode-Register mit %00 laden, d.h. + CODE-MMU deaktivieren! + outb S_BNK, rh0 !MMU's ausschalten! + + ldb rl7, rh2 !rl7=Fehlerpar. (SDR#) =log. Segmentnummer! + + bitb rl3, #%00 !rl3=2 bei Testschritt 95; + rl3=1 bei Testschritt 97! + jr nz, L1866 !Programmfortsetzung fuer Testschritt 0312! + +!fuer Testschritt 95! + test REM_MMU_ID !Segment-Trap (Routine CODE_TRAP) aufgetreten?! + jr nz, L1874 !ja, d.h. Fehler 96! + + calr BY_WO_CMP !Vergleich r5/r4, d.h. ob CODE_FELD abge- + arbeitet wurde und dabei r4 auf 0 gesetzt + wurde; ggf. Fehler 95! + + bitb rh1, #%07 !Fehler aufgetreten?! + jr nz, L183C !ja, d.h. naechster Testschritt! + !(korrigiert: im Original L1842)! + +!fuer Testschritt 95 und 97! +L1834: + incb rh2, #%01 + cpb rh2, #%40 + jr nz, TST_CODE_MMU !naechste logische Segmentnummer! + + !alle Segmentnummern abgearbeitet, d.h. + naechster Testschritt! + +!--------------------------------------------- +Testschritt 97 (0312 'S') +Test, ob CODE-MMU beim Limit-Test Trap erzeugt +---------------------------------------------! +! +--- Fehler 97, wenn CODE-MMU beim Limit-Test keinen Trap erzeugt --- +! + +L183C: + decb rl3, #%01 !rl3=1, d.h. Kennzeichnung Testschritt 97; + rl3=0, d.h. Testschritt 97 beendet! + testb rl3 + jr z, MMU_TEST_END !Ende des Testes! + +L1842: + ld r8, #%97 !Fehler 97: No Trap On Code MMU Limit Test! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + push @r15, r3 + ld r3, #MMU_LISTE5 !r3 - Zeiger auf SDR-Feld fuer CODE-MMU! + ld r4, #MMU_LISTE4 !r4 - Zeiger auf SDR-Feld fuer DATA-MMU! + ld r5, r4 !r5 - Zeiger auf SDR-Feld fuer STACK-MMU! + calr LD_3SDR !SDR der 3 MMU's programmieren! + pop r3, @r15 + + xor r2, r2 !rh2=logische Segmentnummer (0-63)! + ld r5, #%AAAA !ueberfluessig ???! + jr TST_CODE_MMU + +L1866: + test REM_MMU_ID !Segment-Trap (Routine CODE_TRAP) aufgetreten?! + jr nz, L1834 !ja, d.h. kein Fehler; + naechste Segmentnummer! + + ld ERRPAR_ID, #%0090 !Fehlerparameter fuer Fehler 97: r6, rl7 ! + + jr L1880 !Fehlerausgabe! + +!Fehler 96! +L1874: + ld r8, #%96 !Fehler 96: Unexpected Trap! + ld ERRPAR_ID, #%0098 !Fehlerparameter fuer Fehler 96: + r6, rl7, r5 ! + ld r5, REM_MMU_BCSR !r5=Fehlerpar. (VDAT) - Werte der Status- + Register BCSR und VTR nach Segment-Trap: + rh5= Bus Cycle Status Register (BCSR) / + rl5= Violation Type Register (VTR) ! + +L1880: + calr MSG_ERROR !Fehlerausgabe! + +MMU_TEST_END: + ldctl r9, PSAP + ld r4, REM_SEGMENT_TRAP + ld %26(r9), r4 !Adresse der urspruenglichen Segment-Trap- + Routine wieder in PSAREA abspeichern! + ld r4, REM_PRIVINSTR_TRAP + ld %16(r9), r4 !Adresse der urspruenglichen Priv.-Instr.-Trap- + Routine wieder in PSAREA abspeichern! + xorb rl0, rl0 + outb S_BNK, rl0 + soutb ALL_MMU, rl0 + + jp MSG_MAXSEG !Ausgabe "MAXSEG="! + + +CODE_FELD: + xor r4,r4 !r4=Fehlerpar. (zurueckgegebener Datenwert)= + %0000 (Kennzeichnung, dass CODE_FELD + abgearbeitet wurde)! + jp @r10 !Sprung zu FKT_TST! + + end MMU_TEST + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE RAM_TEST_SEG +RAM-Test eines Segmentes +Input: r6 - Segmentnummer des zu testenden Segments + rh1 Bit0=0 - Test nicht in Segment 0 + =1 - Test in Segment 0 + r9 - Stand FCW +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + RAM_TEST_SEG procedure + entry + +!----------------------------------- +Testschritt 72 (0100) +Test auf fehlerhafte Speicheradresse +-----------------------------------! + +!Die 15 Adressen (0003,0006,000C,0018,0030,0060,00C0,0180,0300,0600,0C00,1800, +3000,6000,C000) des betrachteten Segments werden beschrieben und wieder +rueckgelesen. +--- Fehler 72, wenn eine Speicherzelle fehlerhaft rueckgelesen wurde ---! + + ld r8, #%72 !Fehler 72: MEM. ADDR. FAULT! + + ld ERRPAR_ID, #%00E5 !Fehlerparameter fuer Fehler 72: + , r7, rl5, rl4 ! + andb rh1, #%01 !Loeschen Bit1-7(rh1); + Bit1(rh1):=0, d.h. Bytevergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + +!15 Adresse des Segments beschreiben! + + ld r7, #%0003 !Anfangs-Offset-Adresse! + ldb rl5, #%0F !Adressenzaehler: 15 Adresse testen! +RATE1: + set r9, #%0F + ldctl FCW, r9 !segmentierten Mode einstellen! + ldb @r6, rl5 !Speicherzelle beschreiben + (mit akt. Stand des Adressenzaehlers rl5)! + res r9, #%0F + ldctl FCW, r9 !nichtsegmentierten Mode einstellen! + rl r7, #%01 !Offsetadresse um 1 Bit nach links verschieben! + dbjnz rl5, RATE1 !naechste Adresse! + +!Ruecklesen der beschriebenen Adressen! + + rl r7, #%01 !Anfangs-Offset-Adressse := %0003! + ldb rl5, #%0F !Adressenzaehler! +RATE2: + set r9, #%0F + ldctl FCW, r9 !segmentierten Mode einstellen! + ldb rl4, @r6 !Speicherzelle ruecklesen! + res r9, #%0F + ldctl FCW, r9 !nichtsegmentierten Mode einstellen! + calr BY_WO_CMP !Vergleich eingetragener Wert (rl5) mit + rueckgelesenen Wert (rl4); + ggf. Fehler 72: Mem Addr Fault! + bitb rh1, #%07 !Fehler aufgetreten?! + jr nz, RATE3 !ja --> naechster Testschritt! + + rl r7, #%01 !Offsetadresse um 1 Bit nach links verschieben! + dbjnz rl5, RATE2 !naechste Adresse testen! + +!-------------------------------- +Testschritt 73 (0101) +Test auf fehlerhafte Datenleitung +--------------------------------! + +!Die Adresse %8000 des betrachteten Segments wird nacheinander mit den Werten +0001,0002,0004,0008,0010,0020,0040,0080,0100,0200,0400,0800,1000,2000,4000, +8000,0001 (jeweils ein Bit gesetzt) beschrieben und wieder rueckgelesen. +--- Fehler 73, wenn ein Wert fehlerhaft rueckgelesen wurde ---! + +RATE3: + ld r8, #%73 !Fehler 73: Data Line Fault! + ld ERRPAR_ID, #%00EA !Fehlerparameter fuer Fehler 73, 74 + , r7, r5, r4 ! + andb rh1, #%01 !Loeschen Bit1-7(rh1)! + setb rh1, #%01 !Bit1(rh1):=1,d.h. WORD-Vergleich in BY_WO_CMP! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r7, #%8000 !r7:=Offsetadresse! + ld r5, #1 !r5:=in RAM einzutragender Datenwert + (Anfangswert - Bit0 gesetzt)! + ldb rl0, #%11 !rl0:=Anzahl der Schritte! +RATE4: + set r9, #%0F + ldctl FCW, r9 !segmentierten Mode einstellen! + ld @r6, r5 !r5 in RAM eintragen! + ld r4, @r6 !r4:=rueckgelesenen Wert! + res r9, #%0F + ldctl FCW, r9 !nichtsegmentierten Mode einstellen! + + calr BY_WO_CMP !Vergleich r4/r5; ggf. Fehler 73! + bitb rh1, #%07 !Fehler aufgetreten?! + jr nz, RATE5 !ja! + + rl r5, #%01 !nein --> naechstes Bit testen! + dbjnz rl0, RATE4 + +!----------------------------------------------- +Testschritt 74 (0102, 0103) +Test auf fehlerhafte '%AAAA'- bzw. '%5555'-Daten +-----------------------------------------------! + +!Das ganze betrachtete Segment wird mit dem Datenwert %AAAA bzw. %5555 +beschrieben und wieder rueckgelesen. +--- Fehler 74, wenn ein %AAAA- bzw. %5555-Wert fehlerhaft + rueckgelesen wurde ---! + +RATE5: + ld r8, #%74 !Fehler 74: 'A' or '5' Data Fault! + andb rh1, #%03 !Loeschen Bit2-7(rh1)! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + ld r5, #%AAAA !zuerst %AAAA in RAM eintragen! +RATE6: + ld r12, r6 !r12=Segnr. Zieladresse:=Segnr. Quelladresse! + ld r13, #%0002 !r13=Offset Zieladresse:= %0002! + xor r7, r7 !r7=Offset Quelladresse:= %0000! + ld r0, #%7FFF !r0=WORD-Anzahl fuer ldir! + set r9, #%0F + ldctl FCW, r9 !segmentierten Mode einstellen! + ld @r6, r5 + ldir @r12, @r6, r0 !ganzes Segment mit r5 beschreiben! + + xor r7, r7 !r7=Anfangs-Offset-Adresse fuer Vergleich:=%0! + ld r0, #%8000 !r0=Anzahl der Worte fuer Vergleich! + cpir r5, @r6, r0, nz !Test ab Adr. 0 (max. bis Segmentende), bis + zu einer Stelle, wo r5 nicht im RAM steht! + dec r7, #2 !r7 zeigt auf fehlerhafte RAM-Adresse! + ld r4, @r6 !fehlerhafte Adresse lesen! + res r9, #%0F + ldctl FCW, r9 !nichtsegmentierten Mode einstellen! + calr BY_WO_CMP !Vergleich r4/r5; ggf. Fehler 74! + cpb rl5, #%55 + jr z, RATE7 !naechster Testschritt! + ld r5, #%5555 !Test mit Datenwort %5555! + jr RATE6 + +!-------------------------------------------------------------- +Testschritt 75: Test auf RAM-Paritaetsfehler (ausser Segment 0) +Testschritt 76: Test auf RAM-Paritaetsfehler (Segment 0) +--------------------------------------------------------------! + +!Das ganze betrachtete Segment wird mit dem Monitormaschinenkode +(0-%1FFF, 8x) beschrieben und wieder rueckgelesen. +--- Fehler 75, wenn waehrend des Ruecklesens ein Paritaetsfehler auftrat --- +--- Bei Testschritt 76 erfolgt keine Fehlerausgabe. Stattdessen stuerzt + das System bei Auftreten eines Paritaets-NMI ab, da das Programm + nicht im Segment 0, sondern im hoechsten Segment laeuft ---! + +RATE7: + ld r8, #%75 !Fehler 75: RAM-Paritaetsfehler! + ld ERRPAR_ID, #%00E8 !Fehlerparameter fuer Fehler 75: + , r7, r5! + bitb rh1, #0 !Test in Segment 0?! + jr z, RATE8 !nein! + ld r8, #%76 !Testschritt 76! +RATE8: + andb rh1, #%03 !Loeschen Bit2-7(rh1)! + calr WR_TESTNR !Ausgabe der Testschrittnummer! + + !zu testendes Segment mit Monitormaschinencode %0000-%1FFF (8x) + fuellen! + ld r4, #8 !8*%2000=%10000 (1 Segment, 64k)! + xor r7, r7 !r7=Offset Zieladresse:= %0000 + r6 enthaelt Segnr. Zieladresse! +RATE9: + ld r12, #0 !r12=Segnr. Quelladresse := Segnr., wo Monitor! + cp r6, #0 !laueft ((MAX_SEGNR) bei Test im Segment 0,! + jr nz, RATE13 !sonst Segment 0)! + ld r12, MAX_SEGNR +RATE13: ld r13, #0 !r13=Offset Quelladresse := %0000! + ld r0, #%1000 !r0=WORD-Anzahl fuer ldir! + set r9, #%0F + ldctl FCW, r9 !segmentierten Mode einstellen! + ldir @r6, @r12, r0 + res r9, #%0F + ldctl FCW, r9 !nichtsegmentierten Mode einstellen! + djnz r4, RATE9 + + xor r7, r7 !r7=Anfangs-Offset-Adresse fuer Vergleich:=%0! + ld REM_PARNMI, #0 !Merkerzelle 'Paritaets-NMI aufgetreten' + loeschen! + inb rl0, S_BNK + setb rl0, #3 !Paritaetskontrolle einschalten! + outb S_BNK, rl0 +RATE10: set r9, #%0F + ldctl FCW, r9 !segmentierten Mode einstellen! + ld r5, @r6 !Wert ruecklesen! + res r9, #%0F + ldctl FCW, r9 !nichtsegmentierten Mode einstellen! + test REM_PARNMI !Paritaets-NMI aufgetreten?! + jr nz, RATE12 !ja, d.h. Paritaetsfehler! + inc r7, #2 !naechste Offsetadresse fuer Vergleich! + test r7 !ganzes Segment geprueft?! + jr nz, RATE10 !nein! +RATE11: + inb rl0, S_BNK + resb rl0, #3 !Paritaetskontrolle ausschalten! + outb S_BNK, rl0 + ret + +RATE12: !Paritaetsfehler! + ld r4, r5 !r4 auf Wert ungleich r5 setzen,! + inc r4 !damit in BY_WO_CMP Fehler ausgegeben wird! + calr BY_WO_CMP !Vergleich r4/r5; Fehler 75! + ld REM_PARNMI, #0 !Merkerzelle 'Paritaets-NMI aufgetreten' + zuruecksetzen! + jr RATE11 + + end RAM_TEST_SEG + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE PRIVINSTR_TRAP +Trap-Routine bei Priv.-Instr.-Trap +Umschaltung auf Systemmode +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + PRIVINSTR_TRAP procedure + entry + set %02(r15), #%0E + sc #SC_SEGV + iret + end PRIVINSTR_TRAP + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE SEGMENT_TRAP +Trap-Routine bei Segment-Trap +Output: REM_MMU_BCSR - Inhalt Bus-Cycle-Status-Register (BCSR) der MMU bzw. + 0 bei Fehler + REM_MMU_VTR - Inhalt Violation-Type-Register (VTR) der MMU bzw. + 0 bei Fehler + REM_MMU_ID - MMU_ID (1:CODE-MMU; 2:DATA-MMU; 3:STACK-MMU) bzw. + High-Teil=%FF bei Fehler +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + SEGMENT_TRAP procedure + entry + pushl @r15, rr2 + ld r2, 4(r15) + exb rl2, rh2 + and r2, #%0007 !rl2=MMU_ID! + + cpb rl2, #%01 + jr z, TRAP_CODE !Trap durch CODE-MMU ausgeloest! + cpb rl2, #%02 + jr z, TRAP_DATA !Trap durch DATA-MMU ausgeloest! + cpb rl2, #%04 + jr z, TRAP_STACK !Trap durch STACK-MMU ausgeloest! +!Fehler: falscher MMU_ID! + ldb rh2, #%FF !High-Teil von REM_MMU_ID auf %FF setzen! + xor r3, r3 !REM_MMU_BCSR/REM_MMU_VTR auf %00 setzen! + jr TRAP_OUT + +TRAP_CODE: + sinb rl3, CODE_MMU + %0200 !Read VTR! + sinb rh3, CODE_MMU + %0500 !Read BCSR! + jr TRAP_OUT + +TRAP_DATA: + sinb rl3, DATA_MMU + %0200 !Read VTR! + sinb rh3, DATA_MMU + %0500 !Read BCSR! + jr TRAP_OUT + +TRAP_STACK: + sinb rl3, STACK_MMU + %0200 !Read VTR! + sinb rh3, STACK_MMU + %0500 !Read BCSR! + +TRAP_OUT: + ld REM_MMU_ID, r2 !Trap-Werte abspeichern! + ld REM_MMU_BCSR, r3 + + soutb ALL_MMU + %1100, rl2 !Reset VTR! + + popl rr2, @r15 + ldctl r9, FCW + set r9, #%0F !Segment-Bit im FCW setzen! + ldctl FCW, r9 + iret + end SEGMENT_TRAP + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE CODE_TRAP +Trap-Routine fuer Segment-Trap fuer Test der CODE-MMU +Input: rh0 - %00 + r11 - Ruecksprungadresse (FKT_TST) +Output: REM_MMU_BCSR - Inhalt Bus-Cycle-Status-Register (BCSR) der CODE-MMU + REM_MMU_VTR - Inhalt Violation-Type-Register (VTR) der CODE-MMU + REM_MMU_ID - %FFFF +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + CODE_TRAP procedure + entry + soutb CODE_MMU, rh0 !Mode-Register der CODE-MMU mit %00 laden + (CODE-MMU deaktivieren)! + outb S_BNK, rh0 !MMU's ausschalten! + add r15, #%0008 !(im Original %0009)! + push @r15, r2 + + sinb rl2, CODE_MMU + %0200 !Read VTR! + sinb rh2, CODE_MMU + %0500 !Read BSCR! + ld REM_MMU_BCSR, r2 + ld REM_MMU_ID, #%FFFF + soutb CODE_MMU + %1100, rl2 !Reset VTR! + + ld r2, #%5000 + ldctl FCW, r2 !FCW setzen (nonseg./Systemmode/VI=EI/NVI=DI)! + pop r2, @r15 + jp @r11 !Sprung zu FKT_TST! + end CODE_TRAP + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE CLR_CTL_REG +Beschreiben der 2 Control-Register SAR (Segment-Adress-Register) und +DSCR (Descriptor-Selector-Counter-Register) +Input: rl7 - Wert fuer SAR + rh7 - Wert fuer DSCR +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + CLR_CTL_REG procedure + entry + soutb ALL_MMU + %0100, rl7 !Write SAR! + soutb ALL_MMU + %2000, rh7 !Write DSCR! + ret + end CLR_CTL_REG + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE LD_SDR +Fuellen der 64 SDR einer MMU +Input: r6 - MMU-Adresse + r11 - Zeiger auf Anfang des Speicherbereiches (%100 Byte lang) mit + dessen Inhalt die 64 SDR gefuellt werden sollen + (64 SDR * 4 Byte je SDR = %100 Byte) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + LD_SDR procedure + entry + ldm RG_FELD, r0, #%0F + xor r7, r7 + calr CLR_CTL_REG !Loeschen der Control-Register SAR und DSCR! + + add r6, #%0F00 !Write Descriptor and increment SAR! + ld r0, #%0100 + sotirb @r6, @r11, r0 !alle 64 SDR (zu je 4 Byte) laden! + + xor r7, r7 + calr CLR_CTL_REG !Loeschen der Control-Register SAR und DSCR! + ldm r0, RG_FELD, #%0F + ret + end LD_SDR + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE RD_SDR +Ruecklesen der 64 SDR einer MMU und Vergleich mit urspruenglich geladener SDR +ggf. Fehler 80 bzw. 82 +Input: r6 - MMU-Adresse + r11 - Zeiger auf Anfang des Speicherbereiches, mit dessen Inhalt die + 64 SDR gefuellt wurden +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + RD_SDR procedure + entry + pushl @r15, rr2 + push @r15, r11 + ld ERRPAR_ID, #%0095 !Fehlerparameter fuer Fehler 80,81,82: + r6, rl7, rl5, rl4! + xorb rh1, rh1 !Flagbyte rh1 loeschen! + + add r6, #%0F00 !Read Descriptor and increment SAR! + ld r10, #%A400 !Anfangsadresse Puffer fuer rueckgelesene SDR! + ld r0, #%0100 + sinirb @r10, @r6, r0 !64 SDR der MMU zuruecklesen! + + ld r10, #%A400 + ld r0, #%0100 + cpsirb @r11, @r10, r0, nz !Vergleich! + !Befehl cpsirb wird beendet, bei Ungleich- + heit von @r11/@10 bzw. wenn Bytezahl r0 + abgearbeitet ist! + dec r10, #%01 + dec r11, #%01 + ldb rl4, @r10 !rl4=Fehlerpar. (zurueckgelesener Datenwert)! + ldb rl5, @r11 !rl5=Fehlerpar. (Testdatenwert)! + sub r10, #%A400 + ld r7, r10 !rl7=Fehlerpar. (SDR FELD#)! + sub r6, #%0F00 !r6=Fehlerpar. (MMU PORT#)! + calr BY_WO_CMP !Vergleich rl5/rl4; ggf. Fehler 80 bzw. 82! + pop r11, @r15 + popl rr2, @r15 + ret + end RD_SDR + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE LD_3SDR +Fuellen der 64 SDR (zu je 4 Byte) der CODE-, DATA- und STACK-MMU +Input: r3 - Zeiger auf Anfangsadresse des Speicherbereiches (4 Byte), mit + dessen Inhalt die 64 SDR der CODE-MMU gefuellt werden sollen + r4 - Zeiger auf Anfangsadresse des Speicherbereiches (4 Byte), mit + dessen Inhalt die 64 SDR der DATA-MMU gefuellt werden sollen + r5 - Zeiger auf Anfangsadresse des Speicherbereiches (4 Byte), mit + dessen Inhalt die 64 SDR der STACK-MMU gefuellt werden sollen +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + LD_3SDR procedure + entry + ldm RG_FELD, r0, #%0F + xor r7, r7 + calr CLR_CTL_REG !Loeschen der Control-Register SAR und DSCR! + + ldb rl0, #%40 !Anzahl der SDR (64)! + ld r9, #CODE_MMU + %0F00 !Write Descriptor and increment SAR! + ld r10, #DATA_MMU + %0F00 !Write Descriptor and increment SAR! + ld r11, #STACK_MMU + %0F00 !Write Descriptor and increment SAR! +LD_3LOOP: + ld r2, #4 !Descriptorlaenge (4 Byte je SDR)! + sotirb @r9, @r3, r2 !SDR CODE_MMU programmieren! + dec r3, #%04 !Zeiger auf Anfangsadr. zurueckstellen! + + ld r2, #4 !Descriptorlaenge (4 Byte je SDR)! + sotirb @r10, @r4, r2 !SDR DATA_MMU programmieren! + dec r4, #%04 !Zeiger auf Anfangsadr. zurueckstellen! + + ld r2, #4 !Descriptorlaenge (4 Byte je SDR)! + sotirb @r11, @r5, r2 !SDR STACK_MMU programmieren! + dec r5, #%04 !Zeiger auf Anfangsadr. zurueckstellen! + dbjnz rl0, LD_3LOOP !naechstes SDR! + + calr CLR_CTL_REG !Loeschen der Control-Register SAR und DSCR! + ldm r0, RG_FELD, #%0F + ret + end LD_3SDR + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE SEGMENT_TRAP_TEST +Test, ob beim Beschreiben der Offsetadresse (r3) in jedem Segment ein Trap +ausgeloest wird +Input: r3 - Offsetadresse fuer Trap-Test (Adresse, die in jedem Segment + beschrieben werden soll) + rh0 - MMU_ID fuer MMU, die Trap ausloesen muss (2:DATA-MMU;4:STACK-MMU) + bzw. rh0=0, wenn kein Segment-Trap erwartet wird + rl4 - ??? +Fehler 85, wenn +- Segment-Trap nicht von der erwarteten MMU ausgeloest wurde (bei rh0=2,4) +- Segment-Trap ausgeloest wurde, obwohl nicht erwartet (bei rh0=0) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + SEGMENT_TRAP_TEST procedure + entry + pushl @r15, rr2 + push @r15, r9 + xorb rh1, rh1 !Flagbyte rh1 loeschen! + xor r2, r2 !rh2=logische Segmentnummer (0-63)! + test REM_MMU1 + jr z, L1ABE + ldb rh2, #%02 + bitb rl4, #%01 + jr z, L1ABE + ldb rh2, #%42 +L1ABE: + ld ERRPAR_ID, #%0050 !Fehlerparameter fuer Fehler 85: rl6, rl7! + ld REM_MMU_ID, #%0000 !Merker: MMU-ID loeschen - + wird bei Segment-Trap gesetzt! + ldb rl0, #%02 + test REM_MMU1 + jr z, LB_24F8 + ldb rl0, #%06 + outb S_BNK, rl0 + xorb rh4, rh4 + bitb rl4, #%01 + jr z, LB_24D0 + soutb STACK_MMU, rl4 + ldb rh4, #%80 + soutb CODE_MMU, rh4 + ldb rh4, #%81 + soutb DATA_MMU, rh4 + jr LB_250E +LB_24D0: + bitb rl4, #%00 + jr z, LB_24E6 + soutb DATA_MMU, rl4 + ldb rh4, #%80 + soutb CODE_MMU, rh4 + ldb rh4, #%82 + soutb STACK_MMU, rh4 + jr LB_250E +LB_24E6: + soutb CODE_MMU, rl4 + ldb rh4, #%81 + soutb DATA_MMU, rh4 + ldb rh4, #%82 + soutb STACK_MMU, rh4 + jr LB_250E +LB_24F8: + outb S_BNK, rl0 !MMU's einschalten! + + ldb rl0, #%D0 + soutb CODE_MMU, rl0 !Mode-Register mit %D0 laden (ID=0), d.h. + CODE-MMU aktivieren! + incb rl0, #%01 + soutb DATA_MMU, rl0 !Mode-Register mit %D1 laden (ID=1), d.h. + DATA-MMU aktivieren! + incb rl0, #%01 + soutb STACK_MMU, rl0 !Mode-Register mit %D2 laden (ID=2), d.h. + STACK-MMU aktivieren! + +LB_250E: + ldctl r9, FCW + set r9, #%0F + test REM_MMU2 + jr z, LB_251A + res r9, #%0E +LB_251A: + ldctl FCW, r9 + ld @r2, r5 !Speicherzelle (Segment r2 / Offset r3) + beschreiben! + mbit + sc #SC_NSEGV + + + soutb ALL_MMU, rl0 !MMU's deaktivieren! + outb S_BNK, rl0 !MMU's ausschalten! + + ld r6, REM_MMU_ID !rl6=Fehlerpar. (MMU ID#)! + testb rh6 + jr nz, L1B12 !Fehler 85 mit Fehlerpar. rl6, rl7: + Segment-Trap mit falschem MMU_ID aufgetreten + (nicht 1,2,4 - siehe SEGMENT_TRAP)! + cpb rh0, rl6 !Vergleich MMU_ID des Segment-Traps mit dem + erwarteten MMU_ID! + jr nz, L1B08 !Fehler 85 mit Fehlerpar. rl6, rl7, r5: + Segment-Trap erfolgte nicht mit erwarteten + MMU_ID (bei rh0=2,4) + bzw. + Segment-Trap aufgetreten, obwohl keiner + auftreten durfte (bei rh0=0)! +L1AFE: + incb rh2, #%01 + test REM_MMU1 + jr z, LB_254C + bitb rl4, #%01 + jr z, LB_254C + cpb rh2, #%80 + jr nz, L1ABE + jr L1B1C +LB_254C: + cpb rh2, #%40 + jr nz, L1ABE !naechste logische Segmentnummer! + jr L1B1C !alle Segmentnummern abgearbeitet,d.h. Ende! + +!Fehlereinsprung! +L1B08: + ld ERRPAR_ID, #%0058 !Fehlerparameter fuer Fehler 85: + rl6, rl7, r5 ! + ld r5, REM_MMU_BCSR !r5=Fehlerpar. (VDAT) - Werte der Status- + Register BCSR und VTR nach Segment-Trap: + rh5= Bus Cycle Status Register (BCSR) / + rl5= Violation Type Register (VTR) ! +!Fehlereinsprung! +L1B12: + ldb rl7, rh2 !rl7=Fehlerpar. (SDR#)! + calr MSG_ERROR !Fehlerausgabe! + bitb rh1, #%07 !MSG_ERROR seit dem letzen Loeschen von rh1 + (am Anfang dieser Prozedur) bereits zweimal + durchlaufen? ! + jr z, L1AFE !nein, d.h. naechste logische Segmentnummer! + +L1B1C: + pop r9, @r15 + popl rr2, @r15 + ret + end SEGMENT_TRAP_TEST + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE BY_WO_CMP +Vergleich zweier Byte-Register (rl4, rl5) bzw. zweier Word-Register (r4, r5); +bei Ungleichheit Fehlermeldung (MSG_ERROR) +Input: rl4/rl5 bzw. r4/r5 - zu vergleichende Register + rh1 Bit0=0 - Test nicht in Segment 0 + =1 - Test in Segment 0 + Bit1=0 - Byte-Vergleich (rl4,rl5) + =1 - Word-Vergleich (r4,r5) + r8,r7,r6,ERRPAR_ID - siehe Prozedur MSG_ERROR +OUTPUT: siehe Prozedur MSG_ERROR (nur bei Abarbeitung von MSG_ERROR) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + BY_WO_CMP procedure + entry + bitb rh1, #%01 + jr z, BYWO_BY !Byte-Vergleich! + cp r5, r4 !Word-Vergleich! + ret z !kein Fehler! + jr BYWO_ERR !Fehler! +BYWO_BY: + cpb rl5, rl4 !Byte-Vergleich! + ret z !kein Fehler! + +BYWO_ERR: + bitb rh1, #%00 !Test in Segment 0?! + jr z, MSG_ERROR !nein! + + inb rh2, S_BNK !ja! + resb rh2, #%00 + outb S_BNK, rh2 !Monitor PROM+RAM einschalten! + calr MSG_ERROR !Fehlerausgabe! + inb rh2, S_BNK + setb rh2, #%00 + outb S_BNK, rh2 !Monitor PROM+RAM ausschalten! + ret + end BY_WO_CMP + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE FAT_ERR +Ausgabe von T_ERR, Fehlerzeile und T_FERR auf Terminal +Input: siehe Prozedur MSG_ERROR +Output: r2 - Stand Fehlerzaehler (ERR_CNT) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + FAT_ERR procedure + entry + calr MSG_ERROR !Ausgabe T_ERR und Fehlerzeile auf Terminal! + +FAT_ERR1: + calr WR_2BS !2x Backspace ausgeben, um letzte Testschritt- + nummer zu ueberschreiben! + ld r2, #T_FERR + sc #SC_WR_MSG !Ausgabe T_FERR auf Terminal! + sc #SC_WR_OUTBFF_CR !Ausgabe CR auf Terminal! + ld r2, ERR_CNT + ret + end FAT_ERR + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE WR_TESTNR +Ausgabe der Testschrittnummer auf Terminal +Input: r8 - Testschrittnummer + rh1 Bit0=0 - Test nicht in Segment 0 + =1 - Test in Segment 0 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + WR_TESTNR procedure + entry + ldm RG_FELD, r0, #%0F + bitb rh1, #%00 !Test in Segment 0?! + jr z, WRTST1 !nein! + + inb rh2, S_BNK !ja! + resb rh2, #%00 + outb S_BNK, rh2 !Monitor PROM+RAM einschalten! + +WRTST1: + calr WR_2BS !2x Backspace ausgeben, um letzte Testschritt- + nummer zu ueberschreiben! + ld r5, r8 + sc #SC_BTOH8 !Testschrittnummer (aus rl5) in Ausgabepuffer + OUTBFF eintragen! + sc #SC_WR_OUTBFF !Inhalt von OUTBFF auf Terminal ausgeben! + + bitb rh1, #%00 !Test in Segment 0?! + jr z, WRTST2 !nein! + + inb rh2, S_BNK + setb rh2, #%00 + outb S_BNK, rh2 !Monitor PROM+RAM ausschalten! + +WRTST2: + ldm r0, RG_FELD, #%0F + ret + end WR_TESTNR + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE WR_2SP +Ausgabe von 2 Space auf Terminal +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + WR_2SP procedure + entry + pushl @r15, rr0 + pushl @r15, rr2 + + ldb rl0, #' ' + sc #SC_TYWR + ldb rl0, #' ' + sc #SC_TYWR + + popl rr2, @r15 + popl rr0, @r15 + ret + end WR_2SP + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE WR_2BS +Ausgabe von 2 Backspace auf Terminal +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + WR_2BS procedure + entry + pushl @r15, rr0 + pushl @r15, rr2 + + ldb rl0, #BS + sc #SC_TYWR + ldb rl0, #BS + sc #SC_TYWR + + popl rr2, @r15 + popl rr0, @r15 + ret + end WR_2BS + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE MSG_ERROR +Ausgabe T_ERR und Fehlerzeile (Fehlernummer und max. 4 Parameter) auf Terminal +Input: r8 - Fehlernummer + r6 - 1. Parameter der Fehlerzeile + r7 - 2. Parameter der Fehlerzeile + r5 - 3. Parameter der Fehlerzeile + r4 - 4. Parameter der Fehlerzeile + ERRPAR_ID - Spezifizierung, als was die 4 Fehlerparameter auszugeben + sind: + Bit 7,6 (ERRPAR_ID) fuer Parameter 1 (r6) + Bit 5,4 (ERRPAR_ID) fuer Parameter 2 (r7) + Bit 3,2 (ERRPAR_ID) fuer Parameter 3 (r5) + Bit 1,0 (ERRPAR_ID) fuer Parameter 4 (r4) + mit + Bit x,x = 00 --> Parameter ist nicht auszugeben + Bit x,x = 01 --> Ausgabe des rl-Reg. des Parameters + Bit x,x = 10 --> Ausgabe des r-Reg. des Parameters + Bit x,x = 11 --> Ausgabe des rh-Reg. des Parameters als + Segmentnummer ('') +Output: ERR_CNT - Fehlerzaehler wurde incr., wenn Bit2(rh1)=0 war + Bit2(rh1) := 0 + Bit6(rh1) := 1 + Bit7(rh1) := 1 , wenn Bit6(rh1) vorher =1 war +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + MSG_ERROR procedure + entry + ldm RG_FELD, r0, #%0F !Registerinhalte r0-r14 retten! + + push @r15, r4 !4. Parameter! + push @r15, r5 !3. Parameter! + push @r15, r7 !2. Parameter! + push @r15, r6 !1. Parameter! + push @r15, r8 !Fehlernummer! + + calr WR_2BS !2x Backspace ausgeben, um letzte Testschritt- + nummer zu ueberschreiben! + + ld r2, #T_ERR + call WR_MSG !Ausgabe Text T_ERR auf Terminal! +!Aufbau der Fehlerzeile im Ausgabepuffer OUTBFF und Ausgabe auf Terminal! + pop r5, @r15 + sc #SC_BTOH8 !Fehlernummer in Ausgabepuffer OUTBFF eintr.! + ldb rl1, #' ' + sc #SC_PUT_CHR !Space in OUTBFF eintragen! + ldb rl1, #' ' + sc #SC_PUT_CHR !Space in OUTBFF eintragen! + ldb rl1, #' ' + sc #SC_PUT_CHR !Space in OUTBFF eintragen! + + ld r7, ERRPAR_ID !rl7 := Parameter-Identifier fuer Fehlerzeile! + ld r6, #%0004 !r6 := Anzahl der Parameter (=4)! +MSER2: + xorb rh7, rh7 !rh7 loeschen! + rl r7, #%02 !Parameter-Identifier fuer betrachteten + Parameter in rh7 schieben (Bit 0,1)! + pop r5, @r15 !r5 := betrachteter Parameter! + cpb rh7, #%01 !Parameter-Identifier = 1 ?! + jr nz, MSER3 !nein! + + sc #SC_BTOH8 !ja --> rl-Reg. des Par. in OUTBFF eintr.! + jr MSER5 !naechster Parameter! + +MSER3: + cpb rh7, #%02 !Parameter-Identifier = 2 ?! + jr nz, MSER4 !nein! + + sc #SC_BTOH16 !ja --> r-Reg. des Par. in OUTBFF eintr.! + jr MSER5 !naechster Parameter! + +MSER4: + cpb rh7, #%03 !Parameter-Identifier = 3 ?! + jr nz, MSER5 !nein --> Parameter nicht ausgeben! + + ldb rl5, rh5 !ja --> rh-Reg. des Parameters als! + sc #SC_PUT_SEGNR !Segmentnummer in OUTBFF eintragen! + +MSER5: + ldb rl1, #' ' + sc #SC_PUT_CHR !Space in OUTBFF eintragen! + djnz r6, MSER2 !naechster Parameter! + + sc #SC_WR_OUTBFF_CR !Ausgabe Inhalt OUTBFF mit CR auf Terminal! + calr WR_2SP !2 Space ausgeben, da Testschrittausgabe + mit 2x Backspace beginnt! + + ldm r0, RG_FELD, #%0F !gerettete Registerinhalte r0-r14 + zurueckspeichern! + + bitb rh1, #%02 + jr nz, LB_2286 + inc ERR_CNT, #%01 !Fehlerzaehler incr! +LB_2286: + resb rh1, #%02 + + bitb rh1, #%06 + jr z, MSER6 + setb rh1, #%07 !SET Bit7(rh1), wenn Bit6(rh1)=1! +MSER6: + setb rh1, #%06 !SET Bit6(rh1)! + ret + end MSG_ERROR + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE MSG_MAXSEG +Ausgabe T_SEG/NSEG, TJUM, T_MAXS und hoechste Segmentnummer auf Terminal +Output: r2 - Stand Fehlerzaehler (ERR_CNT) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + MSG_MAXSEG procedure + entry + calr WR_2BS !2x Backspace ausgeben, um letzte Testschritt- + nummer zu ueberschreiben! + +! + ld r2, #T_NSEG Textausgabe 'NON-SEGMENTED' + test REM_MMU1 + jr z, LB_2324 + ld r2, #T_SEG Textausgabe 'SEGMENTED' +LB_2324: + sc #SC_WR_MSG + + ld r2, #T_JUM + sc #SC_WR_MSG Textausgabe ' JUMPERS' + sc #SC_WR_OUTBFF_CR +! + + ld r2, #T_MAXS + sc #SC_WR_MSG !Ausgabe Text T_MAXS auf Terminal! + ldb rl5, MAX_SEGNR + sc #SC_PUT_SEGNR !hoechste Segmentnr. in OUTBFF eintragen! + sc #SC_WR_OUTBFF_CR !Ausgabe der hoechsten Segmentnummer auf + Terminal (mit CR)! + + ld r2, ERR_CNT !r2 := Stand Fehlerzaehler! + add r2, ERR_WDC !Fehler von WDC-Test addieren! + ret + end MSG_MAXSEG + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE CRC_TEST +CRC-Berechnung und Vergleich mit vorgegebenen Sollwert +--- bei Fehler Sprung zu FAT_ERR und Ruecksprung zu Monitor --- + +(bei der CRC-Berechnung wird beginnend bei der angeg. Anfangsadresse nur +jedes zweite Byte in die CRC-Berechnung einbezogen, da der Maschinenkode +auf den EPROM's separiert ist (even/odd)) + +Input: r2 - Speicheranfangsadresse + r3 - Anzahl der in die CRC-Bildung einzubeziehenden Bytes + r4 - erwartete Pruefsumme + r5 - negierte erwartete Pruefsumme +Output: r6 - Pruefsumme +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + CRC_TEST procedure + entry +!Vergleich erwartete Pruefsumme mit negierter erwarteter Pruefsumme! + xor r5, r4 + cp r5, #%FFFF + jr nz, CRCERR !Fehler! + +!Berechnung der Pruefsumme! + ld r6, #-1 +CRC: ldb rl0, @r2 + xorb rl0, rh6 + ldb rh6, rl0 + rrb rl0 + rrb rl0 + rrb rl0 + rrb rl0 + andb rl0, #%0F + xorb rl0, rh6 + ldb rh6, rl0 + rrb rl0 + rrb rl0 + rrb rl0 + ldb rh0, rl0 + andb rl0, #%1F + xorb rl0, rl6 + ldb rl6, rl0 + ldb rl0, rh0 + rrb rl0 + andb rl0, #%F0 + xorb rl0, rl6 + ldb rl6, rl0 + ldb rl0, rh0 + andb rl0, #%E0 + xorb rl0, rh6 + ldb rh6, rl6 + ldb rl6, rl0 + + inc r2, #2 !naechstes Byte! + djnz r3, CRC + +!Vergleich der berechneten mit der erwarteten Pruefsumme! + cp r6, r4 + ret z !kein Fehler! +CRCERR: + pop r5, @r15 !UP-RET aufheben! + jp FAT_ERR !Fehlerabsprung! + end CRC_TEST + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE PIO_TEST1 + +Input: r6 - PIO-Datenadresse + r7 - PIO-Controladresse +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + PIO_TEST1 procedure + entry + ldb rl5, #%55 !rl5=Fehlerpar. (Testdatenwert)! + !Restriktion! + cp r6, #PIO2D_B + jr nz, PIOTST11 + ldb rl5, #%75 !BIT5=1! + +PIOTST11: !Restriktion: fuer Kanal kein Ausgabemode! + ldb rl0, #%CF !PIO-Bitmode! + outb @r7, rl0 + ldb rl0, #%00 !alle Bits auf Ausgabe! + outb @r7, rl0 + ldb rl0, #%07 !kein Interrupt! + outb @r7, rl0 + + outb @r6, rl5 !Ausgabe des Testdatenwertes! + inb rl4, @r6 !rl4=Fehlerpar. (rueckgel. Datenwert)! + calr BY_WO_CMP !Vergleich rl4/rl5; ggf. Fehler 50! + + !Restriktion! + ldb rl0, #%4F !PIO-Eingabemode! + outb @r7, rl0 + + cpb rl5, #%AA + ret z + ldb rl5, #%AA !rl5=Fehlerpar. (naechster Testdatenwert)! + jr PIOTST11 + end PIO_TEST1 + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE CTC_TEST1 + +Input: r6 - CTC-Kanaladresse +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + CTC_TEST1 procedure + entry + ldb rl5, #%AA !rl5=Fehlerpar. (Testdatenwert)! +CTCTST11: + di vi + ldb rl0, #%27 !Zeitgeber, Vorteiler 256! + outb @r6, rl0 + outb @r6, rl5 !Ausgabe des Testdatenwertes (Zeitkonstante)! + inb rl4, @r6 !rl4=Fehlerpar. (rueckgel. Datenwert)! + ei vi + calr CTC_INIT !CTC-Kanal ruecksetzen,ggf. neu initialisieren! + calr BY_WO_CMP !Vergleich rl4/rl5; ggf. Fehler 55! + cpb rl5, #%55 + ret z + ldb rl5, #%55 !rl5=Fehlerpar. (naechster Testdatenwert)! + jr CTCTST11 + end CTC_TEST1 + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE CTC_TEST2 + +Input: r6 - CTC-Kanaladresse +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + CTC_TEST2 procedure + entry + ldb rl0, #%07 !Zeitgeber, Vorteiler 16! + outb @r6, rl0 + ldb rl5, #%FF !Zeitkonstante! + outb @r6, rl5 + + ldb rl0, #2 !bestimmte Zeit warten! +CTCTST21: + dbjnz rl0, CTCTST21 + + inb rl4, @r6 !Zeitkonstante ruecklesen! + calr CTC_INIT !CTC-Kanal ruecksetzen,ggf. neu initialisieren! + + cpb rl4, rl5 + jp z, MSG_ERROR !Fehler 56: Kanal zaehlt nicht! + ret + end CTC_TEST2 + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE CTC_TEST3 + +Input: r6 - CTC-Kanaladresse +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + CTC_TEST3 procedure + entry + ldb rl0, #%87 !Zeitgeber, Vorteiler 16, Int! + outb @r6, rl0 + + ld REM_INT, #0 !Interruptmerkerzelle loeschen! + + ldb rl0, #%20 !Zeitkonstante! + outb @r6, rl0 + + ldb rl0, #%FF !bestimmte Zeit auf Interrupt warten! +CTCTST31: + test REM_INT !Interrupt aufgetreten?! + jr nz, CTC_INIT !ja --> CTC-Kanal rueckssetzen, + ggf. neu initialisieren! + dbjnz rl0, CTCTST31 + + calr CTC_INIT !CTC-Kanal ruecksetzen,ggf. neu initialisieren! + jp MSG_ERROR !Fehler 57! + end CTC_TEST3 + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE CTC_INIT +CTC-Kanal ruecksetzen; +ggf. Neuprogrammierung von bereits programmierten Kanaelen (CTC0_0/CTC0_1) + +Input: r6 - CTC-Kanaladresse +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + CTC_INIT procedure + entry + ldb rl0, #%03 !CTC-Reset! + outb @r6, rl0 + +! + cp r6, #CTC0_0 + jp z, INIT_CTC0_0 CTC0_0 fuer LOAD/SEND wieder initialisieren +! + + cp r6, #CTC0_1 + ret nz + testb PTYPORT !8-Bit-Teil aktiv?! + ret nz !ja! + jp INIT_CTC0_1 !CTC0_1 fuer Terminalkanal SIO0_B wieder init.! + end CTC_INIT + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +ISR CTC_ISR + +Input: r6 - CTC-Kanaladresse +Output: REM_INT := %FFFF +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + CTC_ISR procedure + entry + di vi + push @r15, r0 + ld REM_INT, #%FFFF + ldb rl0, #%03 !CTC-Reset! + outb @r6, rl0 + ld r0, #%ED4D !U880-RETI ausgeben! + outb RETI_P, rh0 + outb RETI_P, rl0 + pop r0, @r15 + ei vi + sc #SC_SEGV + nop + iret + end CTC_ISR + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE SIO_TEST1 + +Input: r6 - SIO-Datenadresse (nur Kanal B des entsprechenden SIO's) + r7 - SIO-Controladresse (nur Kanal B des entsprechenden SIO's) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + SIO_TEST1 procedure + entry + ldb rl5, #%AA !rl5=Fehlerpar. (Testdatenwert)! +SIOTST11: + ldb rl0, #SIO_R0+COMM3 !SIO-Kanal ruecksetzen! + outb @r7, rl0 + + ldb rl0, #SIO_R1+COMM2 + ldb rh0, #%00 !Status veraendert Vektor nicht! + outb @r7, rl0 + outb @r7, rh0 + + ldb rl0, #SIO_R2+COMM2 + outb @r7, rl0 !Schreibregister 2 adressieren! + outb @r7, rl5 !Ausgabe des Testdatenwertes an Int.-Reg.! + + outb @r7, rl0 !Leseregister 2 adressieren! + inb rl4, @r7 !rl4=Fehlerpar. (rueckgel. Datenwert)! + + calr SIO_INIT !SIO-Port ggf. neu initialisieren! + calr BY_WO_CMP !Vergleich rl4/rl5; ggf. Fehler 55! + cpb rl5, #%55 + ret z + ldb rl5, #%55 !rl5=Fehlerpar. (naechster Testdatenwert)! + jr SIOTST11 + end SIO_TEST1 + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE SIO0_A_TEST2 + SIO0_B_TEST2 + SIO1_A_TEST2 + SIO1_B_TEST2 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + SIO0_A_TEST2 procedure + entry + ld r6, #SIO0D_A !SIO-Datenadresse! + ld r7, #SIO0C_A !SIO-Controladresse! + ld r5, #CTC0_0 !zugehoeriger CTC-Kanal fuer Baudrate! + ld r4, #SIO0C_B !SIO-Controladresse f. Ausgabe des INT-Vektors + (Ausgabe nur an Kanal B des SIO's)! + ld r3, #SIO0C_A !SIO-Controladresse fuer RETI-Ausgabe + (Ausgabe nur an Kanal A des SIO's)! + jr SIO_TEST2 + +SIO0_B_TEST2: + ld r6, #SIO0D_B !SIO-Datenadresse! + ld r7, #SIO0C_B !SIO-Controladresse! + ld r5, #CTC0_1 !zugehoeriger CTC-Kanal fuer Baudrate! + ld r4, #SIO0C_B !SIO-Controladresse f. Ausgabe des INT-Vektors + (Ausgabe nur an Kanal B des SIO's)! + ld r3, #SIO0C_A !SIO-Controladresse fuer RETI-Ausgabe + (Ausgabe nur an Kanal A des SIO's)! + jr SIO_TEST2 + +SIO1_A_TEST2: + ld r6, #SIO1D_A !SIO-Datenadresse! + ld r7, #SIO1C_A !SIO-Controladresse! + ld r5, #CTC0_2 !zugehoeriger CTC-Kanal fuer Baudrate! + ld r4, #SIO1C_B !SIO-Controladresse f. Ausgabe des INT-Vektors + (Ausgabe nur an Kanal B des SIO's)! + ld r3, #SIO1C_A !SIO-Controladresse fuer RETI-Ausgabe + (Ausgabe nur an Kanal A des SIO's)! + jr SIO_TEST2 + +SIO1_B_TEST2: + ld r6, #SIO1D_B !SIO-Datenadresse! + ld r7, #SIO1C_B !SIO-Controladresse! + ld r5, #CTC1_0 !zugehoeriger CTC-Kanal fuer Baudrate! + ld r4, #SIO1C_B !SIO-Controladresse f. Ausgabe des INT-Vektors + (Ausgabe nur an Kanal B des SIO's)! + ld r3, #SIO1C_A !SIO-Controladresse fuer RETI-Ausgabe + (Ausgabe nur an Kanal A des SIO's)! + jr SIO_TEST2 + +SIO_TEST2: + ldb rh0, #%57 !zugehoerigen CTC-Kanal fuer Baudrate progr.! + ldb rl0, #%02 !9600 Baud! + outb @r5, rh0 + outb @r5, rl0 + + ld r2, #ITAB_SIO !SIO-Kanal programmieren! + ld r0, #9 + otirb @r7, @r2, r0 + ld r2, #ITAB_SIO_INTVEK + ld r0, #2 + otirb @r4, @r2, r0 + + ld REM_INT, #0 !Interruptmerkerzelle loeschen! + + ldb rl0, #%00 + outb @r6, rl0 !Datenausgabe! + + ld r0, #%1000 !bestimmte Zeit auf Interrupt warten! +SIOTST21: + test REM_INT !Interrupt aufgetreten?! + jr nz, SIO_INIT !ja! + djnz r0, SIOTST21 + + calr SIO_INIT !ggf. SIO-Port neu initialisieren! + jp MSG_ERROR !Fehler 61! + end SIO0_A_TEST2 + + INTERNAL +ITAB_SIO ARRAY [* BYTE] := [SIO_R0+COMM3 + SIO_R4 + COMM2 + S2 + C32 + NOPRTY + SIO_R3 + 0 !Empfaenger aus! + SIO_R5 + XENABLE + T8 !Sender ein! + SIO_R1 + COMM2 + XMTRIE] !Senderinterrupt ein! + +ITAB_SIO_INTVEK ARRAY [* BYTE] := [SIO_R2 + %20] !VI_TAB_REST in PSAREA! + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PROCEDURE SIO_INIT +Ruecksetzen des SIO- und CTC-Kanals; +ggf. Neuprogrammierung von bereits programmierten Kanaelen +(SIO0_B und CTC0_1 (vorher SIO0_A/SIO0_B und CTC0_0/CTC0_1)) + +Input: r7 - SIO-Controladresse + r5 - zugeh. CTC-Kanaladresse fuer Baudrate +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + SIO_INIT procedure + entry + ldb rl0, #SIO_R0+COMM3 !SIO-Kanal ruecksetzen! + outb @r7, rl0 + ldb rl0, #%03 !CTC-Kanal ruecksetzen! + outb @r5, rl0 + +! + cp r7, #SIO0C_A SIO0_A? + jr nz, SIOINIT1 nein + + call INIT_CTC0_0 CTC0_0 fuer SIO0_A initialisieren + jp INIT_SIO0_A SIO0_A fuer LOAD/SEND wieder initialisieren + +SIOINIT1: +! + cp r7, #SIO0C_B !SIO0_B! + ret nz !nein! + + testb PTYPORT !8-Bit-Teil aktiv?! + ret nz !ja --> SIO0B nicht initialisieren! +! + jp nz, INIT_SIO0_A ja --> SIO0_B nicht initialisieren, aber + Interruptvektor fuer SIO0_A wieder init., da + er bei Test von SIO0_B zerstoert wurde +! + + call INIT_CTC0_1 !nein --> Terminalkanal SIO0_B wieder init.! + jp INIT_SIO0_B + end SIO_INIT + +!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +ISR SIO_ISR + +Input: r7 - SIO-Controladresse + r3 - zugeh. SIO-Controladresse fuer RETI-Ausgabe (Kanal A des SIO's) +Output: REM_INT := %FFFF +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! + + INTERNAL + SIO_ISR procedure + entry + push @r15, r0 + ld REM_INT, #%FFFF + + ldb rl0, #SIO_R0+COMM3 + outb @r7, rl0 !SIO-Kanal zuruecksetzen! + + ldb rl0, #SIO_R0+RFI + outb @r3, rl0 !RETI an SIO ausgeben! + + pop r0, @r15 + sc #SC_SEGV + nop + iret + end SIO_ISR +end p_test