|
DataMuseum.dkPresents historical artifacts from the history of: CR80 Hard and Floppy Disks |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about CR80 Hard and Floppy Disks Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - download
Length: 70656 (0x11400)
Types: TextFile
Names: »AMUMRG«
└─⟦381395839⟧ Bits:30005538 8" CR80 Floppy CR80FD_0045 ( AMOS MASTER CLEAR UTILITIES CSS/1395/09 Login under HBA AMUEX FIKS BACKUP )
└─⟦848aae195⟧
└─ ⟦this⟧ »HBA.AMUMRG«
└─⟦4e8fa1c0f⟧ Bits:30005163 8" CR80 Floppy CR80FD_0156 ( AMOS MASTERCLEAR UTILITY E.C [MASTER] BACKUP )
└─⟦9a394c66e⟧
└─ ⟦this⟧ »AMU.AMUMRG«
LIST; A M O S M A S T E R C L E A R U T I L I T I E S FR/791101
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; IDENTIFICATION: CSS/395/PGM
; VERSION: 02
; DATED: 791101/FR
;
; THE AMOS_MASTERCLEAR_UTILITIES PROGRAM (AMU) RESIDING IN THE UPPER
;2K_WORDS PROM OF MEMORY SECTION 0 WILL SERVE THE USER OF THE CR80 WITH
;A RANGE OF UTILITIES. THIS AIM NOT ONLY AT PROGRAMMERS BUT ALSO AT
;MAINTENANCE PERSONNEL.
; ONLY MEMORY LOCATIONS:
; #200-#221 INCL
;WILL BE DESTROYED UPON EITHER MASTER CLEAR OR EMERGENCY ACTION, THOUGH
;ONLY AS LONG AS THE USER RESTRICT HIMSELF TO THE FOLLOWING UTILITIES:
; COPY, DUMP, IO_UTILITIES, MEMORY_CHECK, PATCH, SEARCH
; XECUTE, SET_PARITY (,AND OPTIONS).
; HOWEVER THE AMU_PROGRAM WILL NEVER CLAIM BUT THE LOWER #247 WORDS OF
;MEMORY EXCEPT FOR THE CPU_TEST WHICH REQUIRES AN ADDITIONAL 4K_RAM
;STARTING AT #1000.
;THIS IMPLIES THAT FD_BOOT_FILES CAN HAVE THEIR LOADING ADDRESS (START)
;FROM #0248 AND UPWARDS. (CROSSING PAGE_BOUNDARIES DURING FD_LOAD WILL
;RESULT IN A PAGE SHIFT AND CONTINUATION FROM #0000 THAT PAGE).
;
; U S E R ' S M A N U A L
; -------------------------
;
;UTILITIES
;---------
;
; BOOT_LOAD:
; B F/X <DRIVE_NO> (F= FD, X= DMA)
; COPY_MEMORY:
; C* <SOURCE>[.<REL_OFFSET>][+<COUNT>] <OBJECT>[/<PAGE>]
; DUMP:
; D* <START_ADDRESS>[.<REL_OFFSET>] <END_ADDRESS>
; D* <START_ADDRESS>[.<REL_OFFSET>][+<NO_OF_WORDS>]
; DOWNLOAD LTU-PROGRAM:
; F <LTU_PGM_CTL_BLOCK_ADDRESS>.<PGM_NUMBER> <LTU_ADDRESSES>
; IO:
; I S (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>]
; I R (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>]
; I C (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>] <OUTPUT_WORD>
; I K (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>] <OUTPUT_WORD>,....
; I W (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>] <OUTPUT_WORD>
; I V (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>] <OUTPUT_WORD>,....
; LOAD_FILE:
; L F/X <DRIVE_NO> (F= FD, X= DMA)
; MEMORY_CHECK:
; M* <START_ADDRESS>[.<REL_OFFSET>][+<NO_OF_WORDS>] [<PATTERN>]
; PATCH:
; P* <START_ADDRESS>[.<REL_OFFSET>] [<PATCH_DATA>]
; MULTI_PATCH:
; P* <START_ADDRESS>[.<REL_OFFSET>][+<NO_OF_WORDS>] <PATTERN>
; SWITCH_CPU:
; Q <CPU_NO>
; RETURN_CALLING_PROCESS:
; R
; SEARCH:
; S* <START_ADDRESS>[.<REL_OFFSET>][+<NO_OF_WORDS>] <PATTERN>
; TEST_CPU:
; T* <CPU_PROM_ADDRESS>
; UNIT_MAPPER:
; U
; WAIT_INTERRUPT:
; W [<DEVICE_ADDRESS>]
; XECUTE:
; X* <PROCESS_BASE_ADDRESS>
; SET_PARITY:
; Z
;
; OPTIONS:
; O
; PRINT_CONTROL
; LOOP_CONTROL (CPU TEST)
;
;
;
;LEGEND:
;-------
; BREAK
; BREAK FROM THE OPERATOR'S CONSOLE WILL IMMEDIATELY STOP ANY
; PRINT-OUT ON THE OC AND RETURN TO THE MAIN_LINE SELECTION MODE.
;
; MEMORY_SECTION
; IF A PAGE OTHER THAN PAGE 0 IS DESIRED, IT MUST FOLLOW IMMEDI-
; ATELY AFTER THE COMMAND, I.E.
; <COMMAND><PAGE> <....
; ONLY COMMANDS MARKED WITH '*' CAN HAVE PAGE SELECTION.
;
; <---> HEXADECIMAL DATA_WORD:
; AN ENTERED HEXADECIMAL DATA WORD CAN BE ANY COMBINATION OF
; HEXA-DECIMAL CHARACTERS. THOUGH ONLY THE LAST ENTERED FOUR ARE
; ACCEPTED. ZEROES WILL AUTOMATICALLY BE FILLED IN IF LESS THAN
; FOUR HEX CHARACTERS HAVE BEEN ENTERED.
; HEX DATA_WORDS ARE SEPARATED BY ANYTHING BUT '0123456789ABCDEF'
; AND CARRIAGE RETURN <CR>.
; <CR> FLAGS END_OF_DATA.
; <---><DEL> IMPLIES THAT THE ENTERED HEXADECIMAL (WORD (ONE) IS
; REJECTED.
; NOTE THAT +0 ALWAYS IS INTERPRETED AS 64K (ONE PAGE).
;
; [----] OPTIONAL FIELD.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CPU TEST ;
; INSTRUCTION SET KERNEL
; ----------------------
; 0 - UNTIL TEXT TO BE WRITTEN ON OC
; 1 - DURING WRITE-OUT
; 2 - REST OF INITIALIZATION BEFORE '>'
; 3 ESSENTIAL TO CPU_TEST PROGRAMS
;
;MOV
; 0 MOVC [M] C[N]8 R3
; 1 MOV R3 R3
; 2 MOV B8 R3
; 0 MOV R3 B8
; 3 MOV B6.X2 R3
; 3 MOV R2 B6.X2
; 0 MOVL B6.X2 R22
; 0 MOVL R22 B6.X2
; 0 MOV P8 R3
; 1 MVP P6.X2 R2
;JUMP
; 1 JMP S2 L[N]8
; 0 JMP L[N]10
; 1 JMP B6.X2
; 1 JMPI B6
; 0 JMPI [S2] P6
; 0 SOB R3 LN8
;ARIT/LOG
; 0 ADDC C[N]8 R3
; 3 ADD R3 R3
; 3 SUB R3 R3
; 1 SBN/Z R3 C4
; 1 SBZP R3 C4
; 3 SLC R3 C4
; 1 XTR R3 C4
; 1 SWP R3
; 3 INE R3 R3
; 3 INE X3 X3
; 1 IEQ/INE R3 [M] C4
; 3 SHS/SLO R2 C4
;I/O
; 3 CIO R3 R3
; 1 SIO R3 R3
; 3 RIO R3 R3
; 1 WIO R3 R3
;SPECIAL
; 0 SVP L4
; 0 RESS X3 C4
; 2 SVS R3
; 3 LDS R3
;
;NOTE THIS PROGRAM INTERFACE THE CPU_TEST_PROGRAM CSM/100. IT ASSUMES:
; - THE CPU_TEST_PROGRAM STARTS WITH '#0158'='JMP LOC'
; - IT REPLACES THE FIRST LOCATION OF THE CPU_TEST
; 'JMP S4 OUTSTRING'
; WHEREUPON CONTROL IS LEFT OVER TO THE CPU_TEST,
; - THE KEY TO RE-INITIALIZATION IS MEM[B5555, BAAAA], WHICH ARE
; TO BE INITIALIZED PROPERLY BY THE CPU_TEST_PROGRAM,
; - NOTE THAT THE NAMES FILES BEING GENERATED BY THIS PROGRAM
; IS USED BY THE CPU_TEST_PROGRAM. THUS THESE ENTRIES MUST NOT
; BE CHANGED IN ORDER TO HAVE THE CPU_TEST WOTK PROPERLY.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
BEGIN MODULE CPUPROM
AREASWITCH= 1
FDSUPPORT= TRUE
SCMMODE= TRUE
SCMMODE= FALSE
CPUPROM= #F800
USE BASE
BIT0=0, BIT1=1, BIT2=2, BIT3=3, BIT4=4, BIT5=5, BIT6=6
BIT7=7, BIT8=8, BIT9=9, BIT10=10, BIT11=11, BIT12=12,
BIT13=13, BIT14=14, BIT15=15
;FF\f
; MEMORY LAY-OUT (ABS)
LOC= 0 ; --------------------
CPUMEM:
CPUIVT: LOC= LOC+4 ; INTERRUPT VECTOR TABLE INDEX - PRIORITY
CPUIVR: LOC= LOC+1 ; RESET BASE, INTERRUPT SERVE PROCESS
LOC= LOC+2 ;
CPUMSG: LOC= LOC+1 ; USED FOR "OTHER'S" MESSAGE (ADDREESS DUMMY)
CPUCPU: LOC= LOC+8 ; CPU MESSAGE AREA
LOC= LOC+#10 ;
CPUDUMMY: LOC= LOC+#1F ; BASE LOOSER'S DUMMY PROCESS.
; USED FOR SVP FROM OTHER CPUS UPON FIRST
; CPU_INTERRUPT;
LOC= LOC+1 ; SPECIAL MON_CALL CASE (0-63)
CPUMON: LOC= LOC+192 ; MONITOR TABLE (ABS PROGRAM ADDRESS
LOC= LOC+128 ; RESERVED PROGRAM AREA (MON 0-63)
CPUIVB: LOC= LOC+64 ; INTERRUPT VECTOR TABLE (PROCESS BASE)
LOC= LOC+32 ; BASE DUMMY INTERRUPT PROCESS
LOC= LOC+32 ;
CPUBASE: LOC= LOC+256 ; PROCESS AREA CPU TEST PROGRAM
CPUWORK: ; WORK AREA
MASTERCLEARBASE:=#FFE0 ;
; ASCII CHARACTERS
; ----------------
NIL= 0 ; NIL CHARACTER
LF= <:<10>:> ; LINE_FEED
CR= <:<13>:> ; CARRIAGE_RETURN
YES= <:Y:> ;
DEL= #7F ; DELETE
EOT= #FF ; END_OF_TEXT (PROCEDURE OUT_STRING)
;FF\f
; PROCESS DESCRIPTOR
LOC= 0 ; ------------------
XR0: ABSMCE50 ;
XR1: CPUDUMMY ;
XR2: 0-0 ;
XR3: CPUBASE ;
XR4: 0-0 ;
XR5: RELPROMBASE ;
XR6: 0-0
XR7: 0-0
XBASE: CPUBASE ; PROCESS BASE CPU TEST PROGRAM
XMOD: CPUBASE ; MODIFY REGISTER NORMAL STATE
XPROG: PROGRAMSTART ;
XPRPC: PROGRAMGO ;
XTIMER: #7FFF ; TIMER REGISTER
XPSW: #E000 ; PROGRAM STATUS WORD (PSW)
;******************* END OF PROCESS DESCRIPTOR *************************
XOLDPRC:MASTERCLEARBASE ; PROCESS LINK ADDRESS (ABS)
XLOCACT:LOCALACT ; LOCAL INTERRUPT ACTION PROCEDURE ADDRESS
XLOCRET:0-0 ; LOCAL INTER'T RETURN ADDRESS
XCAUSE: #FFFF ; CAUSE:
; 0 - LOCAL TIMER
; 1 - TRAP
; 2 - PARITY ERROR
; 3 - TIME OUT
XDEVICE:0-0 ; IF INTERRUPT THEN DEV_ADDR ELSE #FFFF
XTIMRS: #8000 ; FAST TIMER PRESET VALUE
XMONRET:0-0 ;
;NOTE THAT THE FD_UTILITIES USES 256 WORDS BELOW OWN BASE AS DEDICATED
; MEMORY BUFFER;
; WORK AREA
; ---------
PGMEVALUATE: ; TRUE => EVALUATE TEST RESULTS AND PRINT
; MISMATCHES ON THE OC.
PRINTOUT: TRUE ;
PGMLOOP: 0, 0 ; NO_OF_LOOPS_LEFT-1 (LONG_INTEGER);
;
TCBASE: #1000 ; START CPU_TEST PROGRAM (RAM_COPY)
;NOTE HAS TO BE WITHIN 32 K FROM "OWN" BASE.
XABS= (LOC+1-XR0)/2
ENDOFDATA:
;FF\f
SB12SV: LOC= LOC+1 ; DEDICATED SB1200 (WRITE_NEWLINE)
SB14SV: LOC= LOC+1 ; DEDICATED SB1400 (IN_HEXA)
SB15SV: LOC= LOC+1 ; DEDICATED SB1500 (WRITE_HEXA)
SB16SV: LOC= LOC+1 ; DEDICATED SB1600 (GET_ADDRESS)
SB17SV: LOC= LOC+2 ; DEDICATED SB1700 (SET_PARITY)
UT50SV: LOC= LOC+1 ;
UT13PATTERN: ; 2 (MEMORY_CHECK)
UT17SV: ; 1 (SEARCH)
UT20SV: ; 2 ((IO_UTILITIES)
UT60SV: ; 1 (DOWNLOAD LOU'S)
LOC= LOC+2
;************** END OF DUMP/PATCH/SEARCH UTILITIES *******************
;
;CPU_TEST PROGRAMS
;-----------------
LOC= LOC+(#24-LOC)
TCREFWORK:
REFWORK: LOC= LOC+1 ; REFERENCE CPU_TEST PROGRAM WORK_AREA.
MAISV: LOC= LOC+2 ; DEDICATED MAIN LINE
B5555: LOC= LOC+1 ;
BAAAA: LOC= LOC+1 ;
CP06:
CP20INS:
CPWORK: LOC= LOC+4 ; WORK AREA FOR CPU_TEST PROGRAMS
CP46P: LOC= LOC+1 ;
CP46: LOC= LOC+1 ;
PGMNEXT:LOC= LOC+1 ; REF TABLE PGMPOOL - CURRENT TEST PGM REF
;
TCPOOL: ; REF(TEST_PROGRAM), REF(DATA_AREA)
LOC=0
TCPPROG: LOC= LOC+1 ;
TCPDATA: LOC= LOC+1 ;
LOC= LOC+TCPOOL
;
;FF\f
LOC=TCREFWORK
;FD_UTILITIES WORK
;-----------------
FDMEMBUF:= XR0-256 ; I/O BUFFER 256 POSITIONS BELOW OWN BASE
;
FDMODE: LOC= LOC+1 ; MODE_OF_OPERATION:
FD10SV: LOC= LOC+1 ; DEDICATED FD1000 (FD_BOOT)
; 'F'-'O' - FD
; 'X'-'O' REMOTE FD VIA DMA
FD10DRV: LOC= LOC+1 ; FD DRIVE_NO (0-3)
FDZERO: ;
FDTRACK: LOC= LOC+1 ; CURRENT TRACK POSITION OF FD_HEAD
FD20SV: LOC= LOC+1 ; DEDICATED FD2000 (FD_READ_BLOCK)
FD20CTL: LOC= LOC+1 ;
FD30SV: LOC= LOC+1 ; DEDICATED FD3000 (FD_TRANSFER)
FDRECOUNT: LOC= LOC+1 ; NO OF RESTORE_ATTEMPTS ON FD (<16).
;
FDCLOAD: LOC= LOC+1 ; CURRENT LOAD ADDRESS (OUTPUT_AREA)
FDCPAGE: LOC= LOC+1 ; CURRENT MEMORY SECTION
;
FDBLOCKNO: LOC= LOC+1 ; CURRENT BLOCK NO
;
FDAREAS=10 ; MAX AREAS PER FILE
FDBENTRY: ; FD BOOT_FILE DIR ENTRY
LOC= 0
FDAREASIZE: LOC= LOC+1 ; AREA_SIZE
FDSECTORS: LOC= LOC+1 ; SECTORS PER BLOCK
FDHIBLOCK: LOC= LOC+1 ; HIGHEST BLOCK ALLOCATED
FDBLOCKS: LOC= LOC+1 ; BLOCKING_FACTOR: BLOCKS PER AREA
FDAREA: LOC= LOC+FDAREAS; 1ST AREA ADDRESS (-1 IF NON-ALLOCATED)
FDLOAD: LOC= LOC+1 ; FIRST ADDRESS (LOAD ADDRESS)
FDPAGE: LOC= LOC+1 ; MEMORY SECTION (PAGE)
FDBASE: LOC= LOC+1 ; BASE ADDRESS
FDCOUNT: LOC= LOC+1 ; WORD COUNT OF FILE
FDCHECKSUM: LOC= LOC+1 ; CHECKSUM OF BOOT FILE
FDCHECK: LOC= LOC+1 ; CHECK_SUM OF DIRECTORY ENTRY
FDENTRYLENGTH: ;
LOC= FDBENTRY+FDAREA+1
FDDIRBUF: LOC= LOC+FDENTRYLENGTH
FDEND: ;
;******************* END OF DESTROYED AREA *****************************
;FF\f
USE PROG
PROGSTART:
;CPU_TEST PROGRAM CONSTANTS
MODC -1
P5555: #5555 ;
PAAAA: #AAAA ;
;
MAINLINE: MAINLOOP ; RETURN LINK FROM CPU_TEST SEQUENCES.
OC= 1 ;
SCM= OC
SCMADR:
OCADR: OC ; ADDRESS OF OPERATOR'S CONSOLE (OC)
;
FD= 2
FDADR: FD ; DISKETTE (DEFAULT) IO ADDRESS
DMAADR: 7 ; DMA IO ADDRESS
DISKADR: 0-0 ;
SB16PAGE: #E000, #E004, #E008, #E00C
MSEC: 500 ;
;FF\f
;SUBROUTINES:
BREAKCHECK: SB1350 ; BREAK_CHECK R:(LINK/LINK+1);
COPY: SB1900 ; COPY I:(SOURCE, OBJECT);
GETADDRESS: SB1600 ; GET_ADDRESS O:(REF(LOWER, UPPER));
GETHEXA: SB1400 ; GET_HEXADECIMAL O:(DELIMITER, BINARY);
INCHAR: SB1100 ; READ_SINGLE_CHAR O:(CHAR);
OUTCHAR: SB1250 ; WRITE_SINGLE_CHAR I:(CHAR);
OUTHEXA: SB1500 ; WRITE_HEXADECIMAL U:(BINARY);
OUTNL: SB1200 ; WRITE_NEWLINE;
OUTSTRING: SB1300 ; OUT_STRING I:(REF(STRING));
SETPARITY: SB1700 ;
;
UTILITIES: UT5000 ;UTILITIES:
BOOTLOAD: UT3000 ;
COPYMEMORY: UT1900 ;
DUMP: UT1500 ;
DOWNLOADLTU:UT6000 ; F
IO: UT2000 ;
LOADFILE: UT3100 ;
MEMCHECK: UT1300 ;
OPTIONS: OPT00 ;
PATCH: UT1600 ;
SWITCHCPU: UT2800 ; Q
RETURNCALLER:MCE90 ;
SEARCH: UT1700 ;
TESTCPU: TEC00 ;
UNITS: UT2900 ;
WAITINTERRUPT:UT2500 ;
XECUTE: UT1800 ;
;
ERROR: UT5090 ;
NOLIST IF FDSUPPORT THEN LIST
FDBLOAD: FD1000 ;
FDREADBLOCK:FD2000 ; FD_READ_BLOCK I:(REF(DIR_ENTRY));
FDWAITCMDCOMPLETE:
FDTRANSFER: FD3000 ; FD_TRANSFER I:(REF(BUFFER));
FDCOPY: FD3100 ; FD_MEM_COPY
FDCONTROL: FD3500 ; FD_CONTROL_IO I:(COMMAND);
NOLIST ELSE LIST
FDBLOAD:= ERROR ;
NOLIST FI LIST
0, REPEAT (#30-LOC)
;FF\f
; C O M M O N L O C A L A C T I O N
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE SERVE_LOCAL_INTERRUPT;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
LOCALACT: ;NORMAL_LOCAL_ACTION:
SVP ;
MOV XLOCRET R0 ; GET CAUSING POSITION;
MOVC #FFFF R2 ; PRESET CAUSE_VALUE;
MOVC XCAUSE R7 ;
XCH X7 R2 ; GET CAUSE AND RESET FIELD;
MOVC XPSW R7 ; POINT PROCESS_PSW;
RELS X7 BIT11 ; RESET LOCAL_INTERRUPT FLAG;
;
JMP LOC10 ;***BY-PASS LOCAL TIMER_INTERRUPT***
SNE R2 0 ; IT .NOT. TIMER_INTERRUPT
JMP LOC40 ; THEN
LOC10: MOV XPSW R7 ;
SETS R7 BIT15 ; DISABLE TIMER_INTERRUPTS;
LDS R7 ; RE-ESTABLISH PSW;
JMPI S4 OUTSTRING, <:<13>LOCAL INTERRUPT, CAUSE=:>, EOT
JMPI S6 OUTHEXA ;
JMPI S6 UTILITIES ;
;RETURN:
JMPI S6 GETHEXA ; GET REUTNR_OFFSET;
MOV XLOCRET R0 ;
ADD R2 R0 ; COMPUTE NEW START LOCATION
LOC40: ;RETURN_CAUSING_LOCATION:
MOVC XBASE R4 ; POINT "OWN" BASE;
ADD XPROG-XBASE.X4 R0 ; ADJUST WAKE-UP LOCATION;
MOV R0 XPRPC ;
LDN X4 ; RETURN INTERRUPTED LOCATION;
;///////////////////////////////////;
;FF\f
; E M E R G E N C Y A C T I O N E N T R Y P O I N T
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
EMERGENCY:
SVP ;
MODN XBASE
MOVC MASTERCLEARBASE R4 ; POINT PROMMED AMU_BASE;
MOV XBASE R0 ;
MOVC #E000 R7 ; FORCE
LDS R7 ; MEMORY SECTION 0;
MOV XBASE. X4 R6 ; GET BASE THAT PROCESS;
SUB R0 R6 ; SET-UP POINTER TO RAM_BASE;
MOVM X4 X6 ; CREATE
MOVM X4 X6 ; AMU_PROCESS;
ADDC -2*16 R6 ; POINT START PROCESS_DESCRIPTOR;
MOVC LOC50 R0 ;
ADD XPROG. X6 R0 ; COMPUTE START_ADDRESS;
MOV R0 XPRPC. X6 ;
MOV XBASE. X6 R7 ; GET BASE RAM_RESIDENT AMU_PROC;
LDP R7 ; LEAVE CAUSING PROCESS
;*** BY ACTIVATING AMU_PROCESS;
;************** ENTRY POINT UPON EMERGENCY WAKE UP *********************
LOC50: ;ENTRY_POINT FROM EMERGENCY:
JMPI S4 OUTSTRING, <:<13>EMERGENCY ACTION BY :>, EOT
MOV XOLDPRC R2 ; GET CAUSING PROCESS_BASE;
JMPI S6 OUTHEXA ;
LOC90: JMPI S6 UTILITIES ; ACTIVATE UTILITIES;
JMP LOC90 ; ENSURE NO RETURN;
;FF\f
NOLIST IF SCMMODE THEN LIST
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; OC SCM CHARACTERISTICS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;COMMAND_REGISTERS:
SCMMR1= 2#010<BIT8 ;MODE_REG_1:
SCMASYNC= %;
2#11<BIT0 OR %; ASYNCHRONEOUS
2#10<BIT2 OR %; 7 BITS
1<BIT4 OR %; PARITY ENABLED
1<BIT5 OR %; EVEN PARITY
2#01<BIT6 ; 1 STOP BIT
SCMMR2= 2#110<BIT8 ;MODE_REG_2:
SCMBAUD= %;
#0<BIT0 OR %; BAUD RATE (ASYNC)
2#11<BIT4 OR %; INTERNAL CLOCK
1<BIT6 ; SLOT 2
SCMCMD= 2#011<BIT8 ;COMMANDS:
SCMENB= %;
1<BIT0 OR %; ENABLE TX CONTROL
1<BIT1 OR %; FORCE DTR LOW
1<BIT2 OR %; ENABLE RX
0<BIT3 OR %; NORMAL
0<BIT4 OR %; KEEP ERROR FLAGS
1<BIT5 OR %; FORCE RTS LOW
2#00<BIT6 ; NORMAL OPERATION
SCMRESET= %;
1<BIT0 OR %; ENABLE TX CONTROL
1<BIT1 OR %; FORCE DTR LOW
1<BIT2 OR %; ENABLE RX
0<BIT3 OR %; NORMAL
1<BIT4 OR %; RESET ERROR FLAGS IN STATUS
1<BIT5 OR %; FORCE RTS LOW
2#00<BIT6 ; NORMAL OPERATION
SCMSTATUS= 2#001<BIT8 ;STATUS_BITS:
SCMORDY= BIT0 ; TRANSMIT HOLDING REG EMPTY (HIGH)
SCMIRDY= BIT1 ; RECEIVE HOLDING REG HAS DATA (INPUT READY)
SCMPARITY= BIT3 ; PARITY ERROR (HIGH)
SCMOVERRUN= BIT4 ; OVERRUN ERROR (HIGH)
SCMFRAME= BIT5 ; FRAMING ERROR (HIGH)
SCMDSR= BIT7 ; DATA_SET_READY (HIGH - RECEIVER READY)
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE READ_CHAR O:(CHAR);
; R0 - CHAR (LEAST SIGN 7 BITS)
; R6 LINK DESTROYED
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;IN_CHAR:
SB1100: ; REPEAT
MOV SCMADR R7 ; GET DEVICE ADDRESS;
MOVC SCMENB R0 ;
MODC SCMCMD
CIO R0 R7 ; ENABLE OC;
MODC SCMSTATUS
SIO R0 R7 ; SENSE(STATUS, DEVICE);
SBN R0 SCMIRDY ; UNTIL INPUT_READY HIGH;
JMP SB1100 ;
RIO R0 R7 ; GET CHAR FROM OC;
XTR R0 7 ; STRIP OFF PARITY;
JMP SB1250 ; ECHOE CHARACTER;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE NEW_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;WRITE_NEWLINE:
SB1200: ;
MOVC CR R0 ;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE WRITE_SINGLE_CHAR I:(CHAR);
; R0 CHAR KEPT
; R6 LINK DESTROYED
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;OUT_CHAR:
SB1250: ; REPEAT
MOV SCMADR R7 ; GET DEVICE ADDRESS;
MODC SCMSTATUS
SIO R7 R7 ; SENSE(STATUS, DEVICE);
IBNP R7 SCMFRAME ; IF FRAMING ERROR
IBN & R7 SCMIRDY ; .AND. INPUT_READY
JMP & SB1290 ;*** THEN BREAK-POINT;
SBN R7 SCMORDY ; UNTIL OUTPUT_READY HIGH;
JMP SB1250 ;
;
MOV SCMADR R7 ; RE-ESTABLISH DEVICE ADDRESS;
WIO R0 R7 ; WRITE TO OC;
MOV R0 R7 ;
XTR R7 8 ; ISOLATE CHAR;
INE R0 CR ; IF .NOT. CARRIAGE_RETURN
JMP X6 ; RETURN
; ELSE
MOV R6 SB12SV ; ESTABLISH RETURN LINKAGE;
ADDC LF-CR R0 ;
JMP S6 SB1250 ; OUTCHAR (<LF>);
ADDC NIL-LF R0 ;
JMP S6 SB1250 ; OUTCHAR (<NIL>);
JMP S6 SB1250 ; OUTCHAR (<NIL>);
JMP S6 SB1250 ; OUTCHAR (<NIL>);
JMP S6 SB1250 ; OUTCHAR (<NIL>);
JMP S6 SB1250 ; OUTCHAR (<NIL>);
ADDC CR-NIL R0 ;
JMPI SB12SV ; RETURN CALLER;
SB1290: ;BREAK_POINT:
MOV SCMADR R7 ; GET DEVICE ADDRESS;
MOVC SCMRESET R0 ;
MODC SCMCMD
CIO R0 R7 ; RESET ERROR FLAGS;
RIO R0 R7 ;
JMP UT5010 ;
NOLIST ELSE LIST
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; OC AV24 CHARACTERISTICS
;;;;;;;;;;;;;;;;;;;;;;;;;;
OCIRDY:= 10 ; OC INPUT READY
OCORDY:= 11 ; OC OUTPUT READY
OCBREAK:= 13 ;
OCPARITY:= 14 ;
OCENB:= 3 ; ENABLE (USED BY CIO)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE READ_CHAR O:(CHAR);
; R0 - CHAR (LEAST SIGN 7 BITS)
; R6 LINK DESTROYED
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;IN_CHAR:
SB1100: ; REPEAT
MOV OCADR R7 ; GET DEVICE ADDRESS
MOVC OCENB R0 ;
CIO R0 R7 ; ENABLE OC;
SIO R0 R7 ; GET STATUS OF OC-DEVICE;
SBN R0 OCIRDY ; UNTIL INPUT_FLAG HIGH;
JMP SB1100 ;
RIO R0 R7 ; GET CHAR FROM OC;
XTR R0 7 ; ISOLATE CHAR, REMOVE PARITY;
;
JMP SB1250 ; ECHOE CHARACTER;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE NEW_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1200: ;WRITE_NEWLINE:
MOVC CR R0 ;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE WRITE_SINGLE_CHAR I:(CHAR);
; R0 CHAR KEPT
; R6 LINK KEPT
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;OUT_CHAR:
SB1250: ; REPEAT
MOV OCADR R7 ; GET DEVICE ADDRESS;
SIO R7 R7 ; SENSE(STATUS, DEVICE);
IBNP R7 OCBREAK ; IF FRAMING ERROR
IBN & R7 OCIRDY ; .AND. INPUT_READY
JMP & UT5010 ;*** THEN BREAK-POINT;
SBN R7 OCORDY ; UNTIL OUTPUT_FLAG=READY
JMP SB1250 ;
;
MOV OCADR R7 ; RE-ESTABLISH DEVICE ADDRESS
WIO R0 R7 ; WRITE ON OC;
MOV R0 R7 ;
XTR R7 8 ; ISOLATE CHAR;
INE R7 CR ; IF NOT CARRIAGE_RETURN
; THEN
JMP X6 ; RETURN
; ELSE
MOV R6 SB12SV ; ESTABLISH RETURN LINK;
ADDC LF-CR R0 ;
JMP S6 SB1250 ; OUT_CHAR (<LF>);
ADDC NIL-LF R0 ;
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
ADDC CR-NIL R0 ;
JMPI SB12SV ; RETURN CALLER;
NOLIST FI LIST
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE WRITE_STRING I:(REF(STRING));
; R1-3,5 - KEPT
; R4 LINK DESTROYED
; R0,6,7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;OUT_STRING:
SB1300: ; REPEAT
MVP 0. X4 R0 ; GET NEXT SET OF CHARS
IEQ R0 EOT ; IF END_OF_TEXT
JMP 1. X4 ; THEN RETURN CALLER;
JMPI S6 OUTCHAR ; WRITE_CHAR (CHAR);
SWP R0 ; POSITION 2ND CHAR;
JMPI S6 OUTCHAR ; WRITE_CHAR (CHAR);
ADDC 1 R4 ; ADJUST POINTER;
JMP SB1300 ; UNTIL END_OF_TEXT;
NOLIST IF SCMMODE THEN LIST
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE BREAK_POINT R:(LINK/LINK+1);
; R0 - DESTROYED (IF BREAK ACTIVE)
; R1-5 - KEPT
; R6 LINK KEPT
; R7 - DESTROYED
; RETURN:
; LINK BREAK DETECTED
; LINK+1 NO BREAK DETECTED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1350: ;BREAK_POINT:
MOV SCMADR R7 ; GET DEVICE_ADDRESS;
MODC SCMSTATUS
SIO R7 R7 ; SENSE(STATUS, DEVICE);
SBZ R7 SCMFRAME ; IF FRAMING ERROR
SBN R7 SCMIRDY ; .AND. INPUT_READY HIGH
JMP 1. X6 ; THEN
MOV SCMADR R7 ; RE-ESTABLISH DEVICE ADDRESS;
MOVC SCMRESET R0 ;
MODC SCMCMD
CIO R0 R7 ; RESET ERROR FLAGS;
RIO R0 R7 ; EMPTY RECEIVE BUUFER;
JMP 0. X6 ; RETURN CELLER (ERROR);
NOLIST ELSE LIST
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE BREAK_CHECK R:(LINK/LINK+1);
;
; R0 - DESTROYED IF BREAK
; R1-5 - KEPT
; R6 LINK KEPT
; R7 - STATUS OF OC
; RETURN:
; LINK BREAK DETECTED
; LINK+1 NO BREAK DETECTED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1350: ;BREAK_CHECK:
MOV OCADR R7 ; GET DEVICE ADDRESS;
SIO R7 R7 ; SENSE(STATUS, DEVICE);
SBZ R7 OCBREAK ; IF FRAMING ERROR
SBN R7 OCIRDY ; .AND. INPUT READY
JMP 1. X6 ; THEN
MOV OCADR R7 ; GET DEVICE ADDRESS
RIO R7 R7 ; READ ERRONEOUS CHAR;
JMP 0. X6 ; END;
NOLIST FI LIST
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MEMORY_CHECK UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT1300: ;MEMORY:
MOV P5555 R0 ; INITIALIZE TEST PATTERN
MOV R0 UT13PATTERN ;
MOV PAAAA R0 ;
MOV R0 UT13PATTERN+1
JMPI S6 GETADDRESS ; GET START_ADDRESS;
SNE R0 CR ; IF PATTERN
JMP UT1310 ; THEN
JMPI S6 GETHEXA ; GET PATTERN
MOV R2 UT13PATTERN
INE R0 CR ; IF 2ND PATTERN_PARAM
JMPI S6 GETHEXA ; GET 2ND PATTERN;
MOV R2 UT13PATTERN+1
UT1310: ; END GETTING PARAMETERS;
MOV R3 R6 ;
MOVC UT1350 R0 ;*
MOV R0 XLOCACT ; REPLACE TO LOCAL ACTION PROCESS;
UT1320: ; REPEAT
MOV UT13PATTERN R0 ; GET TEST PATTERN;
MOV UT13PATTERN+1 R1 ;
MOV XPROG R2 ; GET OWN PROG_ADDRESS;
MODN XBASE
ADDC UT1330 R2 ;* COMPUTE BASE_REL OFFSET;
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITCH TO OTHER PAGE
SHS R5 R2 ; IF UPPER PART OF MEMORY
JMP UT1335 ; THEN
MOVL 0. X5 R23 ; SAVE CONTENT DURING TEST;
MOVL R01 0. X5 ; INSERT TEST PATTERN;
MOVC 4096/2 R0 ; REPEAT
SOB R0 LOC ; UNTIL 2-4 MSEC ELAPSED;
MOVL 0. X5 R01 ; GET PATTERN FROM RAM;
MOVL R23 0. X5 ; RE-ESTABLISH CONTENT;
JMP UT1340 ; ELSE
UT1330: NOP ;
UT1335: MOVL 0. X5 R23 ; SAVE CONTENT DURING TEST;
MOVL R01 0. X5 ; INSERT TEST PATTERN;
MOVC 4096/2 R0 ; REPEAT
SOB R0 LOC ; UNTIL 2-4 MSEC ELAPSED;
MOVL 0. X5 R01 ; GET PATTERN FROM RAM;
MOVL R23 0. X5 ; RE-ESTABLISH CONTENT;
UT1340: ; END PERFORMING TEST;
LDS R7 ; RETURN OWN PAGE;
MOV UT13PATTERN R2 ;
MOV UT13PATTERN+1 R3 ;
SNEP R0 R2 ; IF MISMATCH IN 1ST
SNE R1 R3 ; .OR. 2ND WORD
JMP UT1390 ;
UT1350: ; .OR. LOCAL_INTERRUPT
; THEN
LDS R7 ; RESET LOCAL_INT'PT FLAG;
MOV PRINTOUT R2 ;
SEQ R2 TRUE ; IF PRINT_OUT
JMP UT1390 ; THEN
SVP ; SAVE REGISTERS DURING PRINT;
MOVC XCAUSE R2 ;
IEQ X2 -1 ; IF LOCAL INTERRUPT
JMP UT1370 ; THEN
SEQP X2 2 ; IF PARITY_ERROR
SEQ X2 3 ; .OR. TIME-OUT
JMP LOCALACT ; THEN
MOVC -1 R0 ;
XCH R0 X2 ;
SEQ R0 2 ;
JMP UT1360 ;
JMPI S4 OUTSTRING, <:PARITY ERROR:>, EOT
JMP UT1380 ;
UT1360: ;
JMPI S4 OUTSTRING, <:TIME-OUT:>, EOT
JMP UT1380 ;
UT1370: ; ELSE
JMPI S4 OUTSTRING, <:MISMATCH:>, EOT
UT1380: ;
JMPI S4 OUTSTRING, <: AT :>, EOT
MOV XBASE R2 ;
ADD R5 R2 ;
JMPI S6 OUTHEXA ;
JMPI S6 OUTNL ;
MOVC XR0 R7 ; POINT TOP SAVED REG_STACK;
UNS 6 ; RE-ESTABLISH REGS CONTENT;
UT1390: ; END SERVING MISMATCH;
ADDC 2 R5 ; ADJUST POINTER NEXT SEQUENCE;
ADDC -1 R6 ;
INE R6 0 ;
SOB R6 UT1320 ; UNTIL WHOLE MEMORY AREA CHECKED;
JMP UT5020 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE GET_HEXADECIMAL O:(DELIMITER, BINARY_NUMBER);
;
; R0 - LAST ENTERED CHARACTER (DELIMITER)
; R1 - TRUE IF DATA ENTERED ELSE FALSE
; R2 - ENTERED BINARY_NUMBER (DEFAULT 0)
; R3-5 - KEPT
; R6 LINK DESTROYED
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1400: ;GET_HEXA:
MOV R6 SB14SV ; SAVE LINK;
MOVC FALSE R1 ; RISE NO_HEXA_YET FLAG;
MOVC 0 R2 ; RESET VALUE;
SB1410: ; REPEAT
JMPI S6 INCHAR ; GET NEXT CHARACTER;
SEQ R0 DEL ; IF CHAR = 'DELETE'
JMP SB1450 ; THEN
MOVC <:*:> R0 ;
JMPI S6 OUTCHAR ; FLAG DELETED;
JMP SB1400+1 ; ALLOWE RE-ENTERING DATA;
SB1450: ; ELSE
MOV R0 R6 ;
ADDC -(1+<:9:>) R6 ;
SHS R6 <:A:>-(1+<:9:>); IF .NOT. '9' < CHAR < 'A'
JMP SB1490 ; THEN
ADDC (1+<:9:>)+10-<:A:> R6 ; ADJUST AS IF 'A'-'F';
ILT R6 10 ; IF CHAR < <:A:>
ADDC -(10-<:A:>)-<:0:> R6 ; ADJUST AS IF '0'-'9';
IHS R6 16 ; ENSURE '0' <= CHAR <= 'F';
JMP SB1490 ; END GETTING VALID HEXA;
SLL R2 4 ; INSERT
ADD R6 R2 ; NEWLY HEXA;
MOVC TRUE R1 ; FLAG HEX CHAR ENTERED;
JMP SB1410 ;
SB1490: ; UNTIL SEPARATOR MET;
INEP R0 CR ;
INE R1 TRUE ;
JMP SB1410 ;
JMPI SB14SV ; RETURN CALLER;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE WRITE_HEXADECIMAL I:(BINARY );
;
; R0-1,7 - DESTROYED
; R2 BINARY KEPT
; R3-5 - KEPT
; R6 LINK DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1500: ;WRITE_HEXA:
MOV R6 SB15SV ; ESTABLISH RETURN LINK;
MOVC 4 R1 ; FOR I:=1 UNTIL 4
SB1510: ; DO
SLC R2 4 ; POSITION LEFT-MOST 4-BIT;
MOV R2 R0 ;
XTR R0 4 ; ISOLATE PATTERN;
IGE R0 10 ; IF ABOVE 10
ADDC <:A:>-<:0:>-10 R0 ; THEN ADJUST;
ADDC <:0:> R0 ; MAKE HEXADECIMAL
JMPI S6 OUTCHAR ; WRITE_SINGLE_CHAR (CHAR);
SOB R1 SB1510 ; END FOR_UNTIL;
MOVC <: :> R0 ; FORCE SPACE BETWEEN WORDS;
JMPI S6 OUTCHAR ;
JMPI SB15SV ; RETURN CALLER;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE GET_ADDRESS
;
; R0-2,7 - DESTROYED
; R3 - '+'-FIELD (DEFAULT 1)
; R4 - PSW FOR SPECIFIED PAGE (DEFAULT 0)
; R5 - REF(FIRST_ADDRESS)
; R6 LINK DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1600: ;GET_ADDRESS:
MOV R6 SB16SV ;
JMPI S6 INCHAR ; GET PAGE (IF ANY)
ADDC 0-<:0:> R0 ; MAKE DECIMAL
SHS R0 4 ; IF -1 < PAGE < 4
MOD R0 ; THEN ADJUST FOR PAGE:
MOV SB16PAGE R4 ; GET MASKED PSW WITH PAGE BITS;
;
JMPI S6 GETHEXA ; GET START ADDRESS;
MOV R2 R5 ;
SUB XBASE R5 ; COMPENSATE OWN BASE;
MOVC 0 R2 ;
IEQ R0 <:.:> ; IF OFF_SET DESIRED
JMPI S6 GETHEXA ; THEN
ADD R2 R5 ; ADJUST START_ADDRESS;
MOVC 1 R2 ; PRESET OPTIONAL '+'-FIELD;
IEQ R0 <:+:> ; IF '+'-FIELD
JMPI S6 GETHEXA ; THEN GET VALUE;
MOV R2 R3 ; SET UP LOOP_CONTROL;
JMPI SB16SV ; RETURN CALLER
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE SET_PARITY
;
; R0-5,7 - DESTROYED
; R6 LINK DESTROYED
;
; NOTE - OWN BASE HAS TO BE MULTIPLA 512.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1700: ;SET_PARITY:
MOV R6 SB17SV ;
MOV R6 SB17SV+1 ; RESET PARITY ERROR FLAG;
JMP S4 SB1710 ; BY-PASS LOCAL INTERRUPT ROUTINE;
;-----------------------------------;LOCAL_INTERRUPT:
LDS R7 ; RESET BIT_11 (LOCAL INTERRUPT)
MOV XCAUSE R1 ; GET INTERRUPTING CAUSE;
SEQ R1 2 ; IF PARITY ERROR
JMP SB1705 ; THEN
MOV R1 SB17SV+1 ;
LDS R6 ;
JMP SB1750 ; RETURN MAIN LINE FROM INTER'T;
SB1705: ; END SERVING PARITY_ERROR;
IEQ R1 3 ; IF TIME_OUT
JMP SB1760 ; THEN CONTINUE NEXT SECTION;
JMP LOCALACT ; CAUSE NEITHER 2/3
;
;-----------------------------------;
SB1710: ;
MOV R4 XLOCACT ; SET-UP OWN LOCAL_ACTION;
;
MOVC 4 R2 ; FOR I:=0 UNTIL PAGE 3
SB1720: ; DO
MOD R2
MOV SB16PAGE-1 R6 ; GET CURRENT PSW;
MOVC 128 R3 ; FOR I:=1 UNTIL 128 BLOCKS
SVS R7 ; DO
SB1730: MOV R3 R5 ;
SLL R5 9 ; ESTABLISH CORRECT START;
MOVC 512 R4 ; FOR I:=1 UNTIL 512 WORDS
LDS R6 ; DO
SB1740: MOV 0. X5 R0 ; RE-ESTABLISH
SB1750: MOV R0 0. X5 ; PARITY;
ADDC 1 R5 ; ADJUST POINTER;
SOB R4 SB1740 ; UNTIL ALL 1024 WORDS DONE;
SB1760: SOB R3 SB1730 ; UNTIL ALL 64 MODULES DONE;
LDS R7 ; RETURN "OWN" PAGE;
SOB R2 SB1720 ; UNTIL ALL PAGES DONE;
MOVC LOCALACT R0 ;
MOV R0 XLOCACT ; RE-ESTABLISH;
MOV SB17SV+1 R0 ;
SEQ R0 2 ; IF PARITY ERROR
JMPI SB17SV ; THEN
JMPI S4 OUTSTRING, <:, MEM PARITY ERROR:>, EOT;
JMPI SB17SV ; RETURN CALLER;
;
;FF\f
; U T I L I T I E S
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DUMP_UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1500: ;DUMP:
JMPI S6 GETADDRESS ; GET START_ADDRESS, NO_OF WORDS;
ADD R5 R3 ; COMPUTE ENDING ADDRESS;
IEQ R0 CR ; IF END_ADDRESS
JMP UT1520 ; THEN
JMPI S6 GETHEXA ; GET ENDING ADDRESS
MOV R2 R3 ;
MODN XBASE
ADDC 1 R3 ; MAKE REL "OWN" BASE;
UT1520: ; END SERVING END_ADDRESS;
SRL R5 4 ;
SLL R5 4 ; ROUND START ADDRESS;
SUB R5 R3 ; FOR I:=1 UNTIL NO_OF_WORDS
UT1540: ; DO
MOV R5 R0 ;
XTR R0 3 ; COMPUTE MODULO 8;
IEQP R0 8 ; IF (ADDRESS MOD 8) .EQ. 8
MOVC <: :> R0 ; THEN
JMPI S6 OUTCHAR ; INSERT XTRA SPACE;
JON R0 UT1580 ; IF (ADDRESS MOD 16) .EQ. 0
JMPI S6 OUTNL ; WRITE_NEWLINE;
MOV XBASE R2 ;
ADD R5 R2 ; COMPUTE ADDRESS NEXT DUMP;
JMPI S6 OUTHEXA ; WRITE_HEXADECIMAL (ADDRESS)
UT1580: ; END IF NEW LINE;
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITH TO RELEVANT PAGE;
MOV 0. X5 R2 ; GET NEXT WORD
LDS R7 ; RE-ESTABLISH OWN PSW;
JMPI S6 OUTHEXA ; WRITEN
ADDC 1 R5 ; ADJUST POINTER;
SOB R3 UT1540 ; END FOR_UNTIL;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PATCH_UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1600: ;PATCH:
JMPI S6 GETADDRESS ; GET START_ADDRESS, NO_OF WORDS;
IEQ R3 1 ; IF MULTIPATCH
JMP UT1660 ; THEN
JMPI S6 GETHEXA ; GET_HEXA (PATCH_PATTERN);
UT1620: ; FOR I:=1 UNTIL COUNT
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITH TO RELEVANT PAGE;
IEQ R1 TRUE ; IF VALID PATCH DATA
MOV R2 0. X5 ; PATCH;
LDS R7 ; RE-ESTABLISH OWN PSW;
ADDC 1 R5 ; ADJUST POINTER;
SOB R3 UT1620 ; END MULTI-PATCH LOOP;
JMP UT1690 ; ELSE
UT1650: ; REPEAT
JMPI S6 GETHEXA ; GET NEXT PATCH VALUE
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITH TO RELEVANT PAGE;
IEQ R1 TRUE ; IF PATCH DATA
MOV R2 0. X5 ; REPLACE OLD VALUE;
LDS R7 ; RE-ESTABLISH OWN PSW;
ADDC 1 R5 ; ADJUST POINTER;
UT1660: INE R0 CR ;
JMP UT1650 ; UNTIL LAST_CHAR .EQ. CR/NL;
UT1690: JMP UT5020 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SEARCH_UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1700: ;
JMPI S6 GETADDRESS ; GET START_ADDRESS, NO_OF WORDS;
JMPI S6 GETHEXA ; GET SEARCH PARAMETER;
UT1720: ; REPEAT
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITH TO RELEVANT PAGE;
SEQP X5 R2 ; IF MATCH
LDS R7 ; RE-ESTABLISH OWN PAGE;
JMP UT1740 ; THEN
LDS R7 ; RE-ESTABLISH OWN PSW;
SVP ; SAVE REGISTERS DURING PRINT-OUT;
JMPI S4 OUTSTRING, <:MATCH AT :>, EOT
MOV XBASE R2 ;
ADD R5 R2 ; COMPUTE PATTERN_ADDRESS;
JMPI S6 OUTHEXA ;
JMPI S6 OUTNL ;
MOVC XR0 R7 ; POINT TOP REG_STACK (PROC_DESC);
UNS 6 ;
UT1740: ; END SERVING MATCH;
ADDC 1 R5 ; ADJUST POINTER
SOB R3 UT1720 ; UNTIL FILE END
JMP UT5020 ; RETURN UTILITIES_MAIN_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; XECUTE_UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1800: ;
JMPI S6 GETADDRESS ; GET PAGE/BASE OF PROCESS
ADD XBASE R5 ; COMPUTE BASE_ADDRESS;
LDS R4 ; SWITCH TO RELEVANT PAGE;
LDN R5 ; ACTIVETE PROCESS
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; COPY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1900: ;COPY_MOMORY
JMPI S6 GETADDRESS ; GET PAGE/SOURCE_ADDRESS/COUNT
JMPI S6 GETHEXA ; GET OBJECT_ADDRESS
SUB XBASE R2 ; ADJUST FOR OWN BASE
IEQ R0 <:/:> ; IF PAGE TO BE SPECIFIED
JMPI S6 INCHAR ; GET SPECIFIED PAGE;
ADDC -<:0:> R0 ;
JMP S6 SB1900 ; COPY SOURCE TO OBJECT_AREA;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE COPY I:(REF(SOURCE), REF(OBJECT), PAGE);
; R0 OBJECT MEMORY_SECTION DESTR
; R1 - DESTR
; R2 REF(START OBJECT_AREA) DESTR
; R3 WORDS TO COPY DESTR
; R4 PSW FOR SOURCE_AREA KEPT
; R5 REF(START SOURCE_AREA) DESTR
; R6 LINK KEPT
; R7 - DESTR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1900: ; COPY
SHS R0 4 ; IF VALID SPECIFIED PAGE
MOD R0 ; USE IT
MOV SB16PAGE R0 ; SET-UP RELEVANT PSW_PATTERN;
SVS R7 ; SAVE OWN PSW;
UT1950: ; REPEAT
LDS R4 ; SWITCH TO SOURCE SECTION;
MOV 0. X5 R1 ; GET WORD;
LDS R0 ; SWITCH TO ALTERNATIVE PAGE;
MOV R1 X2 ;
INCD R5 R2 ; ADJUST ADDRESSES;
SOB R3 UT1950 ; UNTIL SOURCE_AREA COPIED;
LDS R7 ; RE-ESTABLISH "OWN" MEM_SECTION;
JMP X6 ; RETURN CALLER;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; IO_UTILITIES
;
; USING: UT20SV, PGMLOOP[0:1]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT2000: ;IO:
MOVC 0 R3 ;
MOV R3 UT20SV+1 ; DEFAULT NO MODIFICATION;
MOV R3 PGMLOOP+1 ; RESET LOOP_COUNT (LONG_INTEGER);
JMPI S4 OUTSTRING
<:O::>, EOT
JMPI S6 INCHAR ; GET IO_TYPE;
ADDC -<:O:> R0 ;
MOV R0 UT20SV ;
;
JMPI S6 GETADDRESS ;
SEQ R0 <:):> ; IF MODIFICATION ACTIVE
JMP UT2010 ; THEN
ADD XBASE R5 ; RE-ESTABLISH ENTERED DATA;
MOV R5 UT20SV+1 ;
JMPI S6 GETADDRESS ; GET DEVICE_ADDRESS, REPEATS;
UT2010: ; END GETTING MODIFICATION;
ADD XBASE R5 ; BEWARE WAS BASE_REL;
SEQ R0 <:_:> ; IF LONG_INTEGER
JMP UT2020 ; THEN
JMPI S6 GETHEXA ;
IEQ R2 0 ; IF LEAST SIGNIFICANT PART 0
ADDC -1 R3 ; THEN ADJUST MOST SIGN;
MOV R3 PGMLOOP+1 ; PREPARE MOST SIGNIFICANT PART;
MOV R2 R3 ; SET UP LEAST SIGNIFICANT PART;
UT2020: ; END GETTING LONG INTEGER;
MOV UT20SV R4 ;
; CASE IO_TYPE OF
IEQ R4 <:S:>-<:O:>, JMP UT2050
IEQ R4 <:R:>-<:O:>, JMP UT2060
JMPI S6 GETHEXA ; GET ADDITIONAL PARAMETER;
IEQ R4 <:C:>-<:O:>, JMP UT2070
IEQ R4 <:K:>-<:O:>, JMP UT2075
IEQ R4 <:W:>-<:O:>, JMP UT2080
IEQ R4 <:V:>-<:O:>, JMP UT2085
JMPI ERROR ;
;
UT2050: ;SIO:
JMP S6 UT2090 ;
MOD R7 ;
SIO R2 R5 ;
JMP UT2140 ;
UT2060: ;RIO:
JMP S6 UT2090 ;
MOD R7 ;
RIO R2 R5 ;
JMP UT2140 ;
UT2070: ;CIO:
MOD R7 ;
CIO R2 R5 ;
JMP UT2180 ;
UT2075: ;CIO: SINGLE_STEP
JMP S6 UT2090 ;
MOD R7 ;
CIO R2 R5 ;
JMP UT2160 ;
UT2080: ;WIO:
JMP S6 UT2090 ;
MOD R7 ;
WIO R2 R5 ;
JMP UT2180 ;
UT2085: ;WIO: SINGLE_STEP
JMP S6 UT2090 ;
MOD R7 ;
WIO R2 R5 ;
JMP UT2160 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2090: ;COMMON_INITIALIZATION:
MOVC 0 R4 ;
MOV UT20SV+1 R7 ;
SNE R7 0 ; IF NO MODIFICATION
ADDC 1 R6 ; THEN ADJUST POINTER;
MOV R6 UT20SV ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2100: ; REPEAT
MOV UT20SV+1 R7 ; GET MODIFICATION REGISTER;
JMPI UT20SV ; EXECUTE RELEVANT IO_INSTR;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2140: ;WRITE_IO_RESULTS:
MOV PRINTOUT R7 ;
SEQ R7 TRUE ; IF PRINT_OUT
JMP UT2180 ; THEN
JMPI S6 OUTHEXA ; DUMP STATUS
ADDC 1 R4 ; MAINTAIN DATA COUNT
MOV R4 R0 ;
XTR R0 3 ; ISOLATE BUT LOWER 3;
IEQ R0 0 ; IF (COUNT MOD 8) EQ 0
JMPI S6 OUTNL ; THEN TIME FOR NEW LINE;
JMP UT2180 ;
UT2160: ;GET_NEXT_PARAMETER:
JMPI S6 GETHEXA ;
UT2180: ;
SOB R3 UT2100 ; PERFORM LEAST_SIGN LOOP_CONTROL;
JMPI S6 BREAKCHECK ; BREAK_CHECK
JMP UT2190 ; R:(BREAK OCCURED);
MOV PGMLOOP+1 R6 ; GET MOST SIGNIFICANT PART
ADDC -1 R6 ; MAINTAIN COUNTER;
INEP R6 #FFFF ;
MOV R6 PGMLOOP+1 ;
JMP UT2100 ; UNTIL LONG_INTER ZEROED; (-1);
UT2190: ;END_OF_IO_UTILITY:
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; WAIT_INTERRUPT
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT2500: ;WAIT_INTERRUPT:
JMPI S6 GETHEXA ; GET_HEXA) DEVICE);
XTR R2 6 ; ISOLATE DEVICE_NO;
MOV XBASE R5 ; "OWN" PROCESS BASE;
SVP UT2520 ;
JMP UT2540 ; CONTINU PROCESSING;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; WAIT DUMMY INTERRUPT ;
; EXECUTED BY DUMMY PROCESS ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
NOLIST IF SCMMODE THEN LIST
;WAIT_DUMMY_INTERRUPTS:
UT2520: ; REPEAT
LDM 2#110 ; OPEN FOR I/O UNTERRUPTS;
MOV SCMADR R7 ; GET DEVICE ADDRESS;
MODC SCMSTATUS
SIO R0 R7 ; SENSE(STATUS, DEVICE);
SBZ R0 SCMIRDY ; CHECK IF BREAK OCCURED
IBZ R0 SCMFRAME ; SINCE LAST CHECK
JMP UT2520 ; UNTIL BREAK OCCURED;
LDM 2#111 ; CLOSE I/O WINDOW;
JMPI S4 OUTSTRING, <:MISSING INTERRUPT<13>:>, EOT
LDN R5 ; ACTIVATE MASTER PROCESS;
NOLIST ELSE LIST
UT2520: ;WAIT_DUMMY_INTERRUPT:
; REPEAT
LDM 2#110 ; OPEN FOR I/O INTERRUPTS;
MOV OCADR R7 ;
SIO R0 R7 ; SENSE(STATUS, DEVICE);
SBZ R0 OCIRDY ; CHECK IF FRAMING ERROR
IBZ R0 OCBREAK ; SINCE LAST CHECK
JMP UT2520 ; UNTIL BREAK OCCURED;
LDM 2#111 ; CLOSE WINDOW AGAIN;
JMPI S4 OUTSTRING, <:MISSING INTERRUPT<13>:>, EOT
LDN R5 ; ACTIVATE MASTER PROCESS
NOLIST FI LIST
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; INITIALIZE INTERRUPT TABLES ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2540: ;CONTINUATION:
IEQP R1 TRUE ; IF DATA ENTERED THEN
MODC & CPUIVB+64
MODN & XBASE ; COMPENSATE FOR DEFAULT ALL;
MOD XBASE
MOVC 0 R0 ; SET UP PROCESS EXPECTING INT'PT;
NEG R5 ; POINT TOP OF MEMORY SECTION 0;
MOVC CPUIVB R4 ; POINT INTERUPT_VECTOR_TABLE;
ADD R5 R4 ;
MOVC 64 R7 ; FOR I:=1 UNTIL MAX_DEVICES
UT2550: ; DO
MOV R0 0. X4 ; INSERT BASE IN INTER_RUPT_TAB;
ADDC 1 R4 ; ADJUST POINTER;
SOB R7 UT2550 ; UNTIL TABLE PREPARED;
;
MOVC CPUIVB R3 ; PREPARE ALL PRIORITY LEVEL2
MOV R3 CPUIVT+0.X5; WITH
MOV R3 CPUIVT+1.X5; ADDRESS OF SAME
MOV R3 CPUIVT+2.X5; INTERRUPT
MOV R3 CPUIVT+3.X5; VECTOR TABLE;
ADDC 64 R3 ; BASE DUMMY PROCESS;
MOV R3 CPUIVR.X5 ; PREPARE SYSTEM BASE WITH "OWN";
;
;MOVC XR0 R7 ; POINT TOP OWN PROCESS;
MOVM X7 X4 ; CREATE
MOVM X7 X4 ; DUMMY PROCESS;
ADDC -2*16 R4 ; DUMMY PROCESS;
MOV R3 XBASE. X4 ; PREPARE BASE
MOV R3 XMOD. X4 ; AND MOD REGISTER;
;
UT2560: ;
;REARM_INTERRUPT_TABLE:
MODN XBASE
MOVC CPUIVB R5 ; POINT START INTERRUPT TABLE;
MOV XBASE R1 ;
MOV R1 0. X5 ; PREPARE FOR TIMER;
MOD OCADR
MOV R1 0. X5 ; OPERATOR'S CONSOLE
MOD R2 ; SELECTED DEVICE;
MOV R1 0. X5 ;
;
SVP UT2580 ;
LDN R3 ; ACTIVATE DUMMY INTERRUPT_PROC;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; INTERRUPT OCCURED ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2580: ;WAKE_UP:
NOLIST IF SCMMODE THEN LIST
JMPI S6 BREAKCHECK ; PERFORM BREAK-CHECK;
JMP UT5020 ;*** RETURN(BREAK ACTIVATED);
NOLIST ELSE LIST
MOV OCADR R7 ;
SIO R0 R7 ; SENSE(STATUS, DEVICE);
IBNP R0 OCBREAK ; TEST WAS INTERRUPTED BY BREAK
RIO & R0 R7 ; EMPTY OC_RX_BUFFER;
JMP & UT5020 ; TERMINATE TEST;
; ELSE
NOLIST FI LIST
;
MOV XDEVICE R2 ;
IEQ R2 #FFFF ; IF CPU_INTERRUPT OR LDP
JMPI ERROR ; THEN ERROR
; ELSE
MOV PRINTOUT R0 ;
SNE R0 TRUE ; IF PRINT-OUT
IEQ R2 0 ; .AND.NOT. TIMER_INTERRUPT
JMP UT2590 ; THEN
MOV OCADR R7 ;
SRL R2 2 ; ISOLATE DEVICE_NO;
SNE R2 R7 ; IF .NOT. OC_INTERRUPT
JMP UT2590 ; THEN
JMPI S4 OUTSTRING, <:IO INTERRUPT, DEV=:>, EOT
JMPI S6 OUTHEXA ;
JMPI S4 OUTSTRING, <:, PRIO=:>, EOT
MOV XDEVICE R0 ;
XTR R0 2 ; ISOLATE PRIORITY;
ADDC <:0:> R0 ; CONVERT TO ASCII
JMPI S6 OUTCHAR ;
JMPI S6 OUTNL ;
UT2590: ; END PRINTING;
JMP UT2560 ; UNTIL BREAK OCCURED;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SWITCH_CPU
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT2800: ;SWITCH_CPU:
JMPI S6 INCHAR ; GET NEW MASTER CPU_NO;
ADDC -<:0:> R0 ;
IHS R0 8 ; IF INVALID
JMPI ERROR ; THEN FLAG SO;
JMP S6 SB2800 ; SEND_CPU_MESSAGE;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE SEND_CPU_MESSAGE I:(CPU_NO);
; THE PROCEDURE WILL PREPARE THE CPU_MESSAGE_AREA SUCH THAT THE
; SPECIFIED CPU WILL CONTINUE WHILE CURRENT ONE GOES ASLEEP.
; THE SPECIFIED CPU IS AWAKENED BY A CPU_INTERRUPT.
; N O T E NO CHECK IS PERPORMED TO VERIFY THE EXISTANCE OF THE OTHER.
;
; R0 CPU TO BE ACTIVATED DESTROYED
; R2,3,7 - DESTROYED
; R4 - POINTER TO TOP OF PAGE 0
; R6 LINK KEPT
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB2800: ;SEND_CPU_MESSAGE:
MODN XBASE
MOVC #0000 R4 ; POINT TOP OF MEMORY "OWN" PAGE;
MOVC CPUDUMMY R7 ;
MOVC CPUMSG R2 ; OTHER'S CPU'S MESSAGE;
MOD R2
MOV R7 0. X4 ; INSERT DUMMY_BASE IN MESSAGE;
SETS R2 BIT15 ; FORCE MESSAGE RESERVED;
MOVC 8 R3 ; FOR U:=1 UNTIL 8 CPU'S
SB2810: ; DO
MOV R2 CPUCPU.X4 ; INSERT POINTER;
ADDC 1 R4 ; ADJUST ADDRESS;
SOB R3 SB2810 ; UNTIL CPU MESSAGE_AREA DONE;
ADDC -8 R4 ; RE-ESTABLISH POINTER
;
MOV XBASE R2 ; USE "OWN" BASE_REGISTER
ADDC XBASE R2 ; AS POINTER;
MOD R0
MOV R2 CPUCPU.X4 ;
;
SVP SB2820 ; PREPARE OTHER CPU'S PROCESS;
JMP SB2825 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; OTHER CPU'S FAITH ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SB2820: ;OTHER'S_FAITH:
LDM 2#101
JMP LOC ; WAIT FOR CPU_&NTERRUPT;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CREATE LOOSER'S SLEEPING PROCESS ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SB2825: ;MASTER_PROCESS_CONTINUATION:
ADD R7 R4 ; POINT DUMMY CPU_PROCESS;
;MOVC XR0 R3 ;
MOVM X3 X4 ; CREATE DUMMY
MOVM X3 X4 ; CPU_INTERRUPT SERVICE PROCES;
ADDC -32 R4 ;
MOV R7 XBASE. X4 ; PREPARE BASE
MOV R7 XMOD. X4 ; AND MOD_REGISTERS;
SUB R7 R4 ;
;
SVS R2 ;
LDM 2#101 ;
CPU ; ACTIVATE ALL CPU'S
MOV MSEC R7 ;
SOB R7 LOC ; WAIT 1 MSEC;
LDS R2 ; RE-ESTABLISH OLD PSW;
JMP X6 ; RETURN CALLER;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; UNIT_MAPPER
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT2900: ;MAP_CPU'S:
JMPI S4 OUTSTRING, <:<13>CPU: :>, EOT
SVS R5 ;
MOV R5 R0 ;
SWP R0 ;
XTR R0 3 ; ISOLATE "OWN" CPU_NO;
JMP S6 SB2800 ; SEND_CPU_MESSAGE("OWN"_CPU);
;
MOVC 8 R3 ; FOR I:=1 UNTIL 8 CPU'S
UT2930: ; DO
MOVC <:1:> R0 ; CPU EXIST BY DEFAULT;
SOZ CPUCPU.X4 ; IF NO_MESSAGE ACCEPTED
MOVC <:.:> R0 ; THEN FLAG SO;
JMPI S6 OUTCHAR ;
ADDC 1 R4 ;
SOB R3 UT2930 ; END MAPPING CPU'S;
JMP S4 UT2950 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SERVE MISSING MODULE/TIME_OUT ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;TIME_OUT:
MOV XCAUSE R6 ;
IEQ R6 2 ; IF PARITY_ERROR
JMP UT2940 ; THEN OK;
INE R6 3 ; IF TIME_OUT
JMP LOCALINT ;*** THEN IT DESERVES SPECIAL CARE;
MOVC <:.:> R0 ; FLAG MISSING 4K_RAM/IO_MODULE;
UT2940: ;PRINT_RESULT:
LDS R5 ; RE-ESTAB "OWN" PSW, LOWER BIT11;
MOV R3 R6 ;
XTR R6 4 ; IF (COUNT MOD 16) .EQ. 0
IEQ R6 7 ; IF (COUNT MOD 16) .EQ. 7
ADDC <: :><8 R0 ; THEN INSERT EXTRA SPACE;
IEQ R6 15 ; IF (COUNT MOF 16) .EQ. 15
ADDC <:/:><8 R0 ; THEN ADJUST;
JMPI S6 OUTCHAR ; PRINT CURRENT CHAR;
SRL R0 8 ; POSITION EVENTUAL SECOND CHAR;
INE R0 0 ; IF ANY 2ND CHAR
JMPI S6 OUTCHAR ; THEN PRINT AS WELL;
ADDC 1 R3 ; MAINTAIN CURRENT MODULE_NO;
SHS R3 64 ; IF STILL MODULES LEFT
JMP 1. X4 ; THEN RETURN SERVE
JMP 0. X4 ; ELSE DONE WITH THIS SECTION;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MAP RAM'S ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2950: ;MAP_RAM'>:
MOV R4 XLOCACT ; SET_UP OWN LOCAL_ACTION;
JMPI S4 OUTSTRING, <:<13>RAM: :>, EOT
MOVC 0 R3 ; FOR I:=1 UNTIL 4*16 4K_RAM'S
JMP S4 UT2960 ; DO
JMP UT2970 ; **EXIT WHEN RAM'S TESTED;
UT2960: MOVC <:1:> R0 ; SET-UP UNIT_EXIST;
MOV R3 R6 ;
SRL R6 4 ; POSITION MEMORY_SECTION;
MOD R6
MOV SB16PAGE R6 ; SET-UP PAGE;
MOV R3 R7 ;
SLL R7 12 ; COMPUTE CORRECT ADDRESS;
SUB XBASE R7 ;
LDS R6 ; SWITCH TO RELEVANT PAGE;
MOV 0. X7 R6 ; TEST RELEVANT 4K_RAM;
JMP UT2940 ; UNTIL ALL MODULES SERVED;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MAP IO_MODULES ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2970: ;MAP IO_MODULES:
JMPI S4 OUTSTRING, <:<13>IO: :>, EOT
MOVC 0 R3 ; FOR I:=0 UNTIL 63 IO_MODULES
JMP S4 UT2980 ; DO
JMP UT2990 ; **EXIT WHEN ALL IO_MODULES DONE;
UT2980: MOVC <:1:> R0 ; DEFAULT EXESTING MODULE;
SIO R6 R3 ; SENSE(STATUS, DEVICE);
JMP UT2940 ; UNTIL ALL MODULES SERVED;
;
UT2990: ;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
; E X E R C I Z E O P T I O N S
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
OPT00: ;OPTIONS:
JMPI S6 OUTNL ;
JMPI S4 OUTSTRING, <:PRINT-OUT ?<62>:>, EOT
JMPI S6 INCHAR ;
ADDC TRUE-YES R0 ;
MOV R0 PRINTOUT ;
;
MOVC 0 R0 ;
MOV R0 PGMNEXT ; RESET TEST_PGM_CONTROL;
;
JMPI S6 OUTNL ;
JMPI S4 OUTSTRING, <:NO OF TESTS <62>:>, EOT
JMPI S6 GETHEXA ; GET FIRST PART OF COUNT
MOV R2 R3 ;
MOVC 0 R2 ; PRESET MOST SIGNIFICANT
INEP R0 CR ; IF LEAST SIGNIFICANT TOO
JMPI & S6 GETHEXA ;
XCH & R3 R2 ; POSITION;
ADDC -1 R3 ; ADJUST LEAST SIGNIFICANT PART;
IEQ R3 -1 ; IF LOWER PART OVERFLOW
ADDC -1 R2 ; THEN ADJUST MOST SIGNIFICANT;
MOV R2 PGMLOOP+1 ; SAVE MOST SIGNIFICANT PART
MOV R3 PGMLOOP ; LEAST SIGNIFICANT AS WELL;
JMP UT5020 ; RETURN UTILITIES MAIN LINE;
;FF\f
; B O O T U T I L I T I E S
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; BOOT_UTILITIES
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT3000: ;BOOT_LOAD:
JMPI S4 OUTSTRING, <:OOT :>, EOT
JMPI S6 INCHAR ; GET TRANSFER TYPE
MOV R0 R2 ;
JMPI S4 OUTSTRING, <:D: :>, EOT
JMPI S6 INCHAR ; GET FD DRIVE_NO;
JMPI S6 FDBLOAD ; LOAD_FILE FROM FD
JMP & UT5010 ;*** FAILED: RETURN_MAIN_LINE;
; R:(FILE OK);
JMPI S6 OUTNL ;
LDS R2 ; CHANGE TO RELEVANT PAGE;
LDN R3 ; ACTIVATE BOOT FILE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; LOAD_UTILITIES
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT3100: ;LOAD_FILE:
JMPI S4 OUTSTRING, <:OAD :>, EOT
JMPI S6 INCHAR ; GET DEVICE IDENTIFICATION
MOV R0 R2 ;
JMPI S4 OUTSTRING, <:D: :>, EOT
JMPI S6 INCHAR ; GET FD DRIVE_NO;
JMPI S6 FDBLOAD ; LOAD_FILE FROM FD;
JMP & UT5010 ;*** FAILED: RETURN_MAIN_LINE;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT5000: ;UTILITIES:
MOV R6 UT50SV ; SAVE RETURN ADDRESS;
UT5010: ;
JMPI S6 OUTNL ;
UT5020: ;
MOVC LOCALACT R0 ;
MOV R0 XLOCACT ; RE-ESTABLISH TO COMMON LOCAL
;
MOVC <:<62>:> R0 ;
JMPI S6 OUTCHAR ; WRITE '>'
JMPI S6 INCHAR
ADDC -<:O:> R0 ;
JMP S6 UT5050 ; ESTABLISH LINK
JMP UT5010 ;
UT5050: ;
; CASE CHAR OF
IEQ R0 <:B:>-<:O:>, JMPI BOOTLOAD
IEQ R0 <:C:>-<:O:>, JMPI COPYMEMORY
IEQ R0 <:D:>-<:O:>, JMPI DUMP
IEQ R0 <:F:>-<:O:>, JMPI DOWNLOADLTU
IEQ R0 <:I:>-<:O:>, JMPI IO
IEQ R0 <:L:>-<:O:>, JMPI LOADFILE
IEQ R0 <:M:>-<:O:>, JMPI MEMCHECK
IEQ R0 <:O:>-<:O:>, JMPI OPTIONS
IEQ R0 <:P:>-<:O:>, JMPI PATCH
IEQ R0 <:Q:>-<:O:>, JMPI SWITCHCPU
IEQ R0 <:R:>-<:O:>, JMPI RETURNCALLER
IEQ R0 <:S:>-<:O:>, JMPI SEARCH
IEQ R0 <:T:>-<:O:>, JMPI TESTCPU
IEQ R0 <:U:>-<:O:>, JMPI UNITS
IEQ R0 <:W:>-<:O:>, JMPI WAITINTERRUPT
IEQ R0 <:U:>-<:O:>, JMPI UNITS
IEQ R0 <:X:>-<:O:>, JMPI XECUTE
IEQ R0 <:Z:>-<:O:>, JMPI SETPARITY
IEQ R0 <:<:>-<:O:>, JMPI UT50SV
UT5090: ;ERROR:
MOVC <:?:> R0 ;
JMPI S6 OUTCHAR ;
JMP UT5010 ;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DOWN_LOAD LTU UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
USE BASE ;
;LTU DOWN-LOAD CONTROL BLOCK
LOC= 0 ;---------------------------
LTUID: LOC= LOC+3 ; LTU DOWNLOAD PROGRAM IDENTIFICATION
; HAS TO START WITH 'LTU<0>'
LTUPGMS:LOC= LOC+1 ; NUMBER OF DLTU_DOWN-LOAD PROGRAMS
LTUPGM: LOC= LOC+1 ; ADDRESS LTU DOWNLOAD PROGRAM(S)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
USE PROG ;
;
UT6000: ;DOWN-LOAD_LTU:
JMPI S6 GETHEXA ; GET LTU_PGM_CONTROL_BLOACK ADDR;
MOV R2 R5 ;
MOV XBASE R3 ;
SUB R3 R5 ;
MOVL LTUID. X5 R12 ; GET MODULE IDENTIFICATION;
ADDC -<:LT:> R1 ;
ADDC -<:U<0>:> R2 ;
IEQ R1 0 ; IF IDENTIFICATION .EQ.
SEQ R2 0 ; 'LTU<0>'
JMPI ERROR ; THEN
MOVC 0 R2 ; DEFAULT PGM_NO 0;
IEQ R0 <:.:> ;
JMPI S6 GETHEXA ; GET LTU_PGM_NUMBER;
IHS R2 LTUPGMS.X5 ; IF WITHIN VALID RANGE
JMPI ERROR ; THEN
MOD R2
MOV LTUPGM.X5 R5 ; GET ADDRESS LTU_PROGRAM
SUB R3 R5 ; ADJUST FOR OWN BASE;
UT6020: ; REPEAT
JMPI S6 GETHEXA ; GET DEVICE ADDRESS;
MOV R0 UT60SV ; SAVE LAST ENTERED CHAR;
SNE R1 TRUE ;
JMP UT6080 ;
XTR R2 6 ; ISOLATE DEVICE ADDRESS
; ///////////////////
;R2 - DEVICE ADDRESS
;R5 - POINTER LTU PROGRAM KEPT
; YOUR CODE ;
; ///////////////////
UT6080: ;
MOV UT60SV R0 ;
INE R0 CR ; UNTIL END_OF_COMMAND;
JMP UT6020 ; END DOWN_LOADING LTO'S;
JMP UT5020 ; RETURN UTILITIES MAIN_LINE;
UT6090: ;LTU_ERROR:
JMPI S4 OUTSTRING, <:, LTU ERROR=:>, EOT
JMPI S6 OUTHEXA ;
JMP UT5010 ; RETURN UTILITIES_NEW_LINE;
;FF\f
NOLIST IF FDSUPPORT THEN LIST
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE LOAD_BOOT_FILE I:(MODE_OF_OPERATION)
; R(LINK: FAILED, LINK+1 SUCCES);
; LOAD OK
; R0 DRIVE_NUMBER DESTROYED
; R2 TYPE_OF_XFER (-/'X') PSW CORRESPONDING TO BOOT_FILE
; DEVICE STATUS IF FAILED LOAD;
; R3 - BASE OF LOADED FILE
; R6 LINK DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FDREAD= 2#00010<11
FDRESTORE= 2#01000<11
FDSEEK= 2#00100<11
FDSELECT= 2#00000<11
FDWRITE= 2#00001<11
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
FD1000: ;LOAD_BOOT_FILE:
MOV R6 FD10SV ;
XTR R0 2 ; ISOLATE DRIVE NUMBER (0_3);
MOV R0 FD10DRV ;
;
ADDC -<:O:> R2 ; NORMALIZE;
MOV R2 FDMODE ; SAVE MODE_OF_OPERATION (FD/DMA);
MOV DMAADR R7 ; GET DMA DEVICE_ADR;
IEQP R2 <:X:>-<:O:>; IF INDIRECT TRANSFER
MODC & DMRESET ; THEN
WIO & R7 R7 ; MASTER_CLEAR DMA_DEVICE;
;
JMPI S6 SETPARITY ;
;
MOVC FDZERO R5 ; POINT TOP OF AREA TO BE INIT'D;
MOVC 0 R7 ;
MOVC FDEND-FDZERO R3 ; FOR I:=1 UNTIL END_FD_AREA
FD1010: ; DO
MOV R7 0. X5 ; CLEAR OFF AREA;
ADDC 1 R5 ;
SOB R3 FD1010 ;
MOVC FDBENTRY R5 ; POINT BOOT_ENTRY DESCRIPTOR;
INC FDAREASIZE.X5 ; AREASIZE:= 1 SECTOR
INC FDSECTORS. X5 ; SECTOR_PER_BLOCK:= 1
INC FDBLOCKS. X5 ; BLOCKS_PER_AREA:= 1
INC FDAREA. X5 ; 1ST_AREA ADDRESS:= 0<8+1
MOD XBASE
MOVC FDDIRBUF R4 ; POINT FD_DIRECTORY BUFFER;
MOV R4 FDCLOAD ;
;
; NOTE R3:=0 (BLOCK 0)
MOVC FDSEEK R2 ; SET-UP TRACK 0 OF LOAD DRIVE;
JMPI S6 FDCONTROL ; SEEK_TRACK OF LOAD DRIVE;
JMPI S6 FDREADBLOCK;
JMPI S6 FDTRANSFER ; TRANSFER LAST SECTOR (ONLY ONE);
JMPI S6 FDCOPY ;
FDENTRYLENGTH
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; LOAD BOOT_FILE ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVC 0 R6 ;
MOV R6 FD20CTL ; RISE 1ST TIME FLAG;
MOVC FDDIRBUF R5 ; POINT DIRECTORY_ENTRY;
MOVL FDLOAD.X5 R01 ; GET LOAD_ADDRESS, PAGE
MOVL R01 FDCLOAD.X6 ; INITIALIZE
MOVC FDENTRYLENGTH-1 R3 ; FOR I:=1 UNTIL ENTRY_LENGTH
FD1020: ; DO
ADD 0. X5 R6 ; COMPUTE DIR_ENTRY CHECKSUM;
ADDC 1 R5 ;
SOB R3 FD1020 ; END SUMMING UP;
INE R6 0. X5 ; IF DISCREPANCY
JMP FDENTRYERROR
;
MOVC FDDIRBUF R5 ; POINT BOOT DIRECTORY BUFFER;
FD1040: ; REPEAT
MOV R3 FDBLOCKNO ; SAVE BLOCKNO
JMPI S6 FDREADBLOCK; GET NEXT BLOCK TO MEM_BUFFER;
MOV FDBLOCKNO R3 ;
INEP R3 FDHIBLK.X5 ; TEST IF LAST AREA (BLOCK)
ADDC 1 R3 ;
JMP FD1040 ; UNTIL ALL BLOCKS DONE;
;
JMPI S6 FDTRANSFER ; LAST_TRANSFER;
JMPI S6 FDCOPY ; REMEMBER COPYING LAST SECTOR;
64 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FILE LOADED, VALIDATE CHECKSUM ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOV XBASE R1 ;
SVS R4 ; "OWN" PSW;
MOV FDLOAD.X5 R6 ; GET FILE LOAD ADDRESS (START)
MOV FDPAGE.X5 R7 ; GET CORRESPONDING PAGE;
IOR R4 R7 ; COMPUTE RELEVANT PSW;
MOV FDCOUNT.X5 R3 ; FOR I:=1 UNTIL FILE_LENGTH
IEQ R3 0 ;
JMP FD1060 ;
MOVC 0 R0 ;
LDS R7 ;
FD1050: ; DO
MODN R1
ADD 0. X6 R0 ; COMPUTE CHECKSUM;
ADDC 1 R6 ;
IEQP R6 0 ; IF PAGE BOUNDARY
ADDC & 1<2 R7 ; THEN ADJUST (NEGLECT CARRY)
LDS & R7 ; TO NEXT MEMORY SECTION;
SOB R3 FD1050 ; END COMPUTING CHECK-SUM;
;
LDS R4 ; RETURN "OWN" MEMORY SECTION;
INE R0 FDCHECKSUM.X5; BEWARE CHECKSUM_ERROR;
JMP FDCHECKSUMERROR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FILE CHECKED: OK - GET BASE, PAGE ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FD1060:
JMPI S4 OUTSTRING, <:, START=:>, EOT
MOV FDLOAD.X5 R2 ;
JMPI S6 OUTHEXA ;
JMPI S4 OUTSTRING, <:, BASE= :>, EOT
MOV FDBASE.X5 R2 ;
JMPI S6 OUTHEXA ;
MOVL FDPAGE.X5 R23 ; GET PAGE, BASE
SVS R7 ;
IOR R7 R2 ; COMPUTE RELEVANT PSW;
MOV FD10SV R6 ; GET LINK;
JMP 1. X6 ; SUCCESSFULL RETURN;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FDENTRYERROR:
JMPI S4 OUTSTRING, <:, ENTRY:>, EOT
JMP FD1080 ;
FDCHECKSUMERROR:
JMPI S4 OUTSTRING, <:, CHECKSUM:>, EOT
FD1080: ;
JMPI S4 OUTSTRING, <: ERROR:>, EOT
JMP FD1099
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DEVICE ERROR
; R2 DEVICE_STATUS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
DMAERROR: ;DMA_ERROR:
JMPI S4 OUTSTRING, <:, DMA:>, EOT
JMP FD1090 ;
FDDISKERROR:
JMPI S4 OUTSTRING, <:, DISK:>, EOT
FD1090: ;ERROR_RETURN
JMPI S4 OUTSTRING, <: ERROR=:>, EOT
JMPI S6 OUTHEXA ;
FD1099: JMPI FD10SV ; RETURN CALLER (FAILED LOAD);
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE FD_READ_BLOCK I:(REF(DIR_ENTRY));
;
; THIS PROCEDURE SUPPORTS THE CR8062 FD CONTROLLER. THE CONTROLLER
; WORKS WITH A 64 WORD BUFFER.
; THE PROCEDURE COPIES ALL BUT THE LAST SECTOR OF A BLOCK TO THE
; DEDICATED OUTPUT AREA VIA ITS MEMORY_BUFFER.
;
; HIERARCHY:
; FILE/AREA[1:10]/BLOCK[1:-]/SECTOR[1:64]/WORD[1:16]/BIT
; THE RELETION BETWEEN PHYSICAL AND LOGICAL SECTORS ARE:
; TRACK 0: 2, 4,..., 26, 1, 3,..., 25
; TRACK 1: 14, 16,..,12,13,15,...,11
; TRACK 2: 26, 1, 3, ...
; TRACK3: 11,13,15,...
; .
; ... UNTIL TRACK 76
;
; R3 BLOCK_NO DESTROYED
; R5 REF(DIR_ENTRY) KEPT
; R6 LINK DESTROYED
; R0-2,4,7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
FD2000: ;FD_READ_BLOCK:
MOV R6 FD20SV ;
MOV R5 R6 ;
MOV FDBLOCKS.X5 R1 ; GET BLOCKS_PER_AREA;
IEQ R1 0 ;
JMP S6 FDENTRYERROR;
;
MOVC FDAREAS R2 ;
FD2010: ; COMPUTE
ILT R3 R1 ; OFF_SET:=
JMP FD2020 ;
SUB R1 R3 ; BLOCK_NO MOD BLOCKS_PER_AREA;
ADDC 1 R6 ; ADJUST AREA_REFERENCE;
SOB R2 FD2010 ;
JMP S6 FDENTRYERROR; TOO HIGH BLOCK_NO: ENTRY)ERR;
FD2020:
MOV FDSECTORS.X5 R1 ; GET SECTORS_PER_BLOCK;
MOV FDAREA.X6 R0 ; GET AREA'S START LOG_SECTOR_NO;
IEQ R0 -1 ; IF NOT USED
JMP S6 FDENTRYERROR; THEN ENTRY_ERROR;
JOZ R3 FD2060 ; IF .NOT. 1ST BLOCK IN AREA
MOV R0 R2 ;
XTR R2 8 ; ISOLATE LOGICAL_SECTOR_NO;
SWP R0 ; POSITION TRACK_NO;
FD2030: ; COMPUTE
ADD R1 R2 ; 1ST_SEC+BLOCK*SEC'S_PER_BL'K
SOB R3 FD2030 ;
FD2040: ; COMPUTE
ILT R2 27 ;
JMP FD2050 ;
ADDC 1 R0 ; ADJUST TRACK_NUMBER;
ADDC -26 R2 ; ADJUST SECTOR_NO
JMP FD2040 ; END ADJUSTING TRACK/SECTOR;
FD2050: ;
SLL R0 8 ; POSITION TRACK, ZERO SECTOR;
IOR R2 R0 ; INSERT LOGICAL_SECTOR_NO;
FD2060: ;FD_SEEK_TRACK:
; R0 - TRACK,/LOGICAL_SECTOR_NO
; R1 - SECTORS PER BLOCK
; REPEAT
MOV R0 R2 ; TRACK_OFFSET:=
SRL R2 7 ; (TRACK_NO*2
MOV R2 R3 ;
ADD R2 R3 ;
ADD R2 R3 ; *3)
FD2070: IGEP R3 26 ;
ADDC -26 R3 ; MOD 26;
JMP FD2070 ;
;
SRL R2 1 ; ISOLATE TRACK_NO;
MOV FDTRACK R6 ;
IEQ R2 R6 ; IF NEW TRACK .NOT. CURRENT
JMP FD2080 ; THEN
MOV R2 FDTRACK ; ESTABLISH AS CURRENT TRACK;
JMPI S6 FDWAITCMDCOMPLETE; COMPLETE PREVIOUS COMMAND;
MOV FDTRACK R2 ;
ADDC FDSEEK R2 ; ESTABLISH SEEK;
JMPI S6 FDCONTROL ;
; END ESTABLISHING NEW TRACK;
FD2080: ; REPEAT
JMPI S6 FDTRANSFER ; GET DATA INTO MOMORY_BUFFER;
MOV R0 R2 ;
XTR R2 8 ; ISOLATE LOGICAL_SECTOR_NO;
ADD R3 R2 ; ADJUST FOR TRACK_OFFSET;
; PHYSICAL_SECTOR_NO:=
ADD R2 R2 ; ((2*(TRACK_OFFSET_LOG_SECT))
IGE R2 53 ;
ADDC -52 R2 ; MOD 53;
IGE R2 27 ;
ADDC -27 R2 ; MOD 27;
ADDC FDREAD R2 ; SET-UP PROPER READ_COMMAND;
JMPI S6 FDCONTROL ; CONTROL(READ, SECTOR);
MOV FD20CTL R4 ; GET 1ST TIME FLAG;
INEP R4 0 ; IF COPY DATA FROM LAST READ
JMPI & S6 FDCOPY ; THEN DO SO;
64 ;
MOV R6 FD20CTL ;
;NEXT_SEGMENT:
ADDC -1 R1 ;
SGE R1 1 ; * PERFORM OUTHER LOOP_CONTROL
JMPI FD20SV ; * IF DONE RETURN CALLER;
;
ADDC 256 -26 R0 ; ADJUST TRACK/SECTOR_NO;
IBNP R0 BIT7 ; CHECK IF NEXT TRACK ;
ADDC -256 +27 R0 ;
JMP FD2080 ; UNTIL SEC'S THIS TRACK DONE;
ADDC 1 R0 ; NOTE: START SECTOR 1, NOT 0;
JMP FD2060 ; UNTIL AREA DONE (ALL BLOCKS);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE FD_TRANSFER I:(REF(BUFFER));
; WAIT FOR I/F TO GO READY;
; TRANSFER DATA FROM I/F BUFFER TO MEMORY;
; R2,4,7 - DESTROYED
; R6 LINK KEPT
; USING: XR0(X4), XR2(R2)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;FD_WAIT_COMMAND_COMPLETE:
FD3000: ;FD_TRANSFER:
MOV R6 FD30SV ;
MOVC 60 R4 ;
SOB R4 LOC ; WAIT 60-120 USEC;
;
MOV FDMODE R7 ; GET MODE_OF_OPERATION
IEQ R7 <:X:>-<:O:>; IF DIRECT TRANSFER
JMP FD3050 ; THEN
MOV FDADR R7 ; GET FD DEVICE_ADDRESS;
FD3010: ; REPEAT
MODC 1<15
SIO R2 R7 ; SENSE(ADDITIONAL_STATUS,DEV)
IBN R2 BIT6 ; TEST DEVICE STILL BUSY;
JMP FD3010 ; UNTIL FORMATTER READY;
;
MOVC FDMEMBUF R2 ; POINT DEDICATED MEMORY BUFFER;
MOVC 64 R4 ; FOR I:=1 UNTIL BLOCK_SIZE
FD3020: ; DO
RIO X2 R7 ; READ(BUFFER_WORD, DEVICE);
ADDC 1 R2 ;
SOB R4 FD3020 ; END_FOR_UNTIL;
;
SIO R2 R7 ; SENSE(STATUS, DEVICE);
JMP FD3060 ; ELSE
FD3050: ; REPEAT
JMP S6 DMA ; DMA: SENSE REMOTE FD
2,#8000+FD,DMSMODE,XR0,DMMEMMODE,DMINPUT
IBN X4 BIT6 ; TEST REMOTE FORMATTER BUSY;
JMP FD3050 ; UNTIL FORMATTER READY
JMP S6 DMA ; DMA: READ 64 WORDS FROM REM.FD
128,FD,DMRMODE,FDMEMBUF,DMMEMMODE,DMINPUT
JMP S6 DMA ; DMA: SENSE REMOTE FD
2,FD,DMSMODE,XR2,DMMEMMODE,DMINPUT
MOV XR2 R2 ; GET PRESENT STATUS;
FD3060: ; END TRANSFERING SECTOR;
IBN R2 BIT0 ; RESET
ADDC #FFFF R2 ; BIT0 ONLY;
IEQ R2 0 ; IF TRANSFER COMPLETE
JMPI FD30SV ; RETURN CALLER AS DONE;
; ELSE
IBZ R2 BIT7 ; IF .NOT. DISK_CHANGE.OR.OVERRUN
JMP FDDISKERROR; THEN
MOVC FDRESTORE R2 ; SET-UP FD_RESTORE:
JMPI S6 FDCONTROL ; STEP DRIVE OUT 79 TIMES TO
; USE TRACK_00 FOR RESYNC;
MOV R6 FDTRACK ;* FORCE NEW SEEK;
MOVC FDRECOUNT R6 ;
INC 0. X6 ; MAINTAIN RESTORE_COUNT;
IBZ X6 BIT4 ; CONTINUATION ALLOWED
JMP FD2060 ; AS LONG AS BELOW 16;
MOVC #FFFF R2 ; SET-UP ERROR FLAG
JMP FDDISKERROR; END DISK_ERROR HANDLING;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE FD_MEM_COPY
; R6 LINK KEPT
; R7 - DESTROYED
;
; USING: PROCESS_DESCRIPTOR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
FD3100: ;FD_COPY:
SVP ;
SVS R2 ; GET OWN PSW;
;NOTE HAS TO BE MEM_SECTION 0;
MOV XBASE R4 ; AND BASE;
MOVC FDMEMBUF R5 ; POINT FD MEM_BUFFER;
MOV FDCPAGE R3 ; GET CURRENT OUTPUT PAGE;
IOR R2 R3 ; ESTABLISH NEW PSW THAT SECTION;
MOV FDCLOAD R7 ; POINT OUTPUT_AREA;
MVP 0. X6 R1 ; FOR I:=1 UNTIL BUFFER_SIZE
FD3120: ; DO
MOV 0. X5 R0 ; GET NEXT WORD
LDS R3 ; SWITCH TO RELEVANT SECTION;
MODN R4
MOV R0 0. X7 ; INSERT WORD IN OUTPUT_AREA;
LDS R2 ; RETURN OWN PAGE;
INCD R5 R7 ; ADJUST POINTERS;
IEQ R7 0 ; IF PAGE BOUNDARY
ADDC 1<2 R3 ; THEN SWITCH PAGE
; (NEGLECTING CARRY BIT);
SOB R1 FD3120 ; UNTIL WHOLE BUFFER COPIED;
MOV R7 FDCLOAD ;
MOV R3 FDCPAGE ;
MOVC XR0 R7 ; RE-ESTABLISH
UNS 7 ; ALL REGISTERS;
JMP 1. X6 ; RETURN CALLER;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE FD_CONTROL I:(COMMAND);
; R2 COMMAND<11+TRACK/SECTOR DESTROYED
; R6 LINK KEPT
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FD3500: ;FD_CONTROL:
MOV FD10DRV R7 ; GET DRIVE NUMBER;
SWP R7 ; POSITION IN LEFTMOST BYTE;
ADD R7 R2 ; INSERT DRIVE_NO IN COMMAND;
MOV FDMODE R7 ;
SNE R7 <:X:>-<:O:>; IF DIRECT FD_LOAD
JMP FD3580 ; THEN
MOV FDADR R7 ; GET DEVICE ADDRESS;
CIO R2 R7 ; CONTROL(DATA, DEVICE);
JMP X6 ; RETURN CALLER;
FD3580: ; ELSE
MOV R6 FD30SV ;
MOV R2 XR2 ;
JMP S6 DMA ; DMA: CONTROL REMOTE DEVICE
2,FD,DMCMODE,XR2,DMMEMMODE,DMOUTPUT
JMPI FD30SV ; RETURN CALLER;
; END CONTROLLING FD;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE DO_DMA (CNT, REM_ADR,REM_PAGE,LOC_ADR,LOC_PAGE,REQUEST);
; R2 - DESTROYED
; RL LINK DESTROYED
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DMA IF CHARACTERISTICS
;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;DMA_STATUS:
DMRQSNT= BIT3 ; REQUEST SENT
DMNTEOB= BIT5 ; NOT_EOB
DMERRM1= 1<BIT6 OR %; STOPPED
1<BIT7 OR %; REMOTE TIME-OUT
1<BIT8 OR %; LOCAL TIME-OUT
1<BIT9 ; PARITY ERROR
;DMA_COM'DS:
DMLDBC= 0<8 ; LOAD BYTE COUNT
DMLDAD= 1<8 ; LOAD ADDRESS
DMLDPG= 2<8 ; LOAD PAGE
DMSNRQ= 3<8 ; SEND REQUEST
DMSTART= 5<8 ; START DMA
DMSTOP= 6<8 ; STOP DMA
DMRESET= 7<8 ; RESET DMA IF
DMRMBC= 8<8 ; LOAD REMOTE BYTE COUNT
DMRMAD= 9<8 ; LOAD REMOTE ADDRESS
DMRMPG= 10<8 ; LOAD REMOTE PAGE
;
DMINPUT= 2#01 ; INPUT REQUEST, TYPE 0
DMOUTPUT= 2#00 ; OUTPUT REQUEST, TYPE 0
DMMEMMODE= #302 ; MEMORY MODE: LOWER BYTE, PAGE 0
DMSMODE= #2 ; SENSE IO MODE
DMCMODE= #2 ; CONTROL IO MODE
DMRMODE= #6 ; READ IO MODE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
DMA: ;DMA:
DMA00: ; REPEAT
MOV DMAADR R7 ; GET DEVICE ADDRESS;
MOVC DMOUTPUT R2 ; SET-UP CONTROL
MODC DMSNRQ
WIO R2 R7 ; OUTPUT(CMD, CTL, DEVICE);
MOVC 0 R2 ; WAIT
MOVC 0 R2 ; 2 USEC;
RIO R2 R7 ; INPUT(STATUS, DEVICE);
IBZ R2 DMRQSNT ; UNTIL REQUEST
JMP DMA00 ; ACCEPTED;
MVP 0. X6 R2 ; GET COUNT_FIELD;
MODC DMRMBC
WIO R2 R7 ; OUTPUT(CMD, COUNT, DEVICE);
MVP 1. X6 R2 ; GET REMOTE_ADR;
MODC DMRMAD
WIO R2 R7 ; OUTPUT(CMD, REM_ADR, DEVICE);
MVP 2. X6 R2 ; GET REMOTE_PAGE (MODE);
MODC DMRMPG
WIO R2 R7 ; OUTPUT(CMD, REM_PAGE, DEVICE);
MVP 5. X6 R2 ; GET REQUEST_TYPE;
MODC DMSNRQ
WIO R2 R7 ; OUTPUT(CMD, SEND_REQUEST, DEVICE);
MVP 0. X6 R2 ; GET COUNT
MODC DMLDBC
WIO R2 R7 ; OUTPUT(CMD% COUNT% DEVICE);
MVP 3. X6 R2 ; GET POINTER TO OUTPUT_AREA;
ADD XBASE R2 ;
MODC DMLDAD
WIO R2 R7 ; OUTPUT(CMD, LOAD_ADDR, DEVICE);
MVP 4. X6 R2 ; GET LOAD_PAGE;
MODC DMLDPG
WIO R2 R7 ; OUTPUT(CMD, LOAD_PAGE, DEVICE);
MODC DMSTART
WIO R2 R7 ; OUTPUT(CMD, -, DEVICE);
DMA10: ; REPEAT
RIO R2 R7 ; INPUT(STATUS, DEVICE);
MOVC DMERRM1 R7 ; SET-UP ERROR MASK;
AND R2 R7 ; IF RESULT.>0 THEN
INE R7 0 ; IF RESULT<>0 THEN
JMP DMAERR ;* DMA_ERROR;
MOV DMAADR R7 ;
IBN R2 DMNTEOB ; UNTIL STATUS.NOT_EOB
JMP DMA10 ; GOES LOW (EOB);
MODC DMSTOP
WIO R2 R7 ; OUTPUT(CMD, -, DEVICE);
JMP 6. X6 ; RETURN CALLER;
NOLIST FI LIST
;FF\f
; I N I T I A L I Z E C P U T E S T P R O G R A M
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Q;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
TEC00: ;TEST_CPU:
MOVC B5555 R5 ;
MOVL 0. X5 R23 ;
MOV P5555 R0 ;
MOV PAAAA R1 ;
INE R0 R2 ; IF B5555_FIELD NOT CORRECT
JMP TEC10 ; .OR.
SNE R1 R3 ; BAAAA_FIELD NOT CORRECT
JMP TEC90 ; THEN
TEC10: ;
;
JMPI S6 GETADDRESS ; GET POSITION OF (PROMMED)
; CPU_TEST SEQUENCES;
MOVC #1000 R3 ; SET-UP COUNT (4K PROM);
MOVC 0 R0 ; OBJECT_SECTION 0;
MOV TCBASE R2 ; GET "BASE" CPU_TEST PROGRAMS;
MOV XBASE R7 ;
SUB R7 R2 ; MAKE REL "OWN" BASE;
JMPI S6 COPY ; COPY CPU_TEST PROGRAMS
; TO MEMORY #1000 UPWARDS;
MOV XBASE R3 ;
MOV TCBASE R1 ; GET START OF CPU_TEST_PROGRAMS;
SUB R3 R1 ; SET-UP CPU-TEST-"OWN=_BASE;
MOV TCBASE R2 ;
MOV XPROG R7 ;
SUB R7 R2 ; SET-UP CPU_TEST-"OWN"_PROG;
MOV R1 R7 ;
MOV 0. X7 R0 ; GET FIRST STATEMENT;
INE R0 #0158 ; IF NOT 'JMP LOC'
JMPI ERROR ; THEN ERRORONEOUS MODULE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; RAM RESIDENT VERSION ACCEPTED ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
JMP S4 LOC+2 ; BY-PASS INSTRUCTION;
JMPI S4 OUTSTRING
MVP 0. X4 R0 ; GET INSTRUCTION
MOV R0 0. X7 ; INSERTED AS FIRST OF AREA;
MOV R2 R6 ;
JMP S5 LOC+1 ; ESTABLISH LINK BACK;
JMP X6 ; ACTIVATE RAM_RESIDING PART;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;RETURN_FROM_CUP_TEST:
; R0,4,6,7 DESTROYED
; R4 REF CPU_TEST PROGRAM_TABLE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SET-UP CPU_TEST CONTROL ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ADD R1 R4 ; ADJUST REF(CPU_TEST_PGMS);
MOV R1 R7 ;
MOVC TCPOOL R6 ;
TEC20: ; REPEAT
MOVL 0. X4 R01 ;
IEQ R0 #BE ; IF TEST UNDEFINED (TRAP)
SUB R0 R0 ; THEN FORCE DUMMY TEST;
IEQ R0 0 ; IF DUMMY TEST
JMP TEC30 ; THEN
INE R0 #8000 ; IF NOT END_OF_TEST_FILE
ADD R2 R0 ; ADJUST TO REL "ACTUAL" PROG;
TEC30: ; END ADJUSTING PROG_REL;
ADD R7 R1 ; ADJUST TO REL "ACTUAL" BASE;
MOVL R01 0. X6 ; MAKE
ADDC 2 R4 ; REFERENCES
ADDC 2 R6 ; RELATIVE;
IBZ R0 BIT15 ;
JMP TEC20 ; UNTIL CPU_TEST AREA INITIALIZED;
;
MOVC 0 R7 ;
MOV R7 PGMLOOP ; INITIALIZE COUNTERS
MOV R7 PGMLOOP+1 ;
MOV R7 PGMNEXT ; AND CURRENT TEST PGM POINTER;
TEC90: JMPI S6 OUTNL ;
;CONTINUE WITH CPU_TEST MAIN_LINE:
;FF\f
; C P U T E S T P R O G R A M - M A I N L I N E
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
USE BASE ;
; CPU_TEST_CONTROL_BLOCK LAY-OUT
LOC= 0 ; ------------------------------
CTCBID: LOC= LOC+1 ; IDENTIFICATION OF TEST
CTCBCNT:LOC= LOC+1 ; NUMBER OF DATA IN TEST RUN
CTCBRST:LOC= LOC+1 ; RESET VALUE (IF 0 THEN FIRST AREA COPIED)
CTCBDATA:LOC=LOC+1 ; DATA AREA:
; 1ST AREA (CNT) WORDS, EXPECTED DATA
; 2ND AREA, INPUT DATA AREA
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
USE PROG ; FOR I:=1 UNTIL TEST_LOOP_COUNT
; DO
; REPEAT UNTIL TABLE SCANNED
MAINLOOP:
MOV PGMEVALUATE R0 ; GET CHECK/PRINT-OUT FLAG
MOV PGMNEXT R6 ; GET REF(CUR'T TEST_PGM_NDX);
MOV TCPOOL+TCPPROG.X6 R4 ; GET REF(CUR'T TEST_PGM_ADR);
SNE R0 TRUE ; IF EVALUATION
IEQ R4 0 ; .AND. VALID TEST_PROGRAM
JMP MAI50 ; THEN
;-----------------------------------;
; EVALUATE TEST RESULTS ;
;-----------------------------------;
MOV TCPOOL+TCPDATA.X6 R4 ; GET REF(ASSOCIATED DATA_AREA)
MOVC CTCBDATA R5 ; OFF-SET TO EXPECTED DATA;
ADD R4 R5 ; REF (EXPECTED_DATA_AREA);
MOV REFWORK R7 ; POINT WORK AREA;
MOV CTCBCNT.X4 R3 ; FORI:=1 UNTIL NO_WORDS
MAI10: ; DO
IEQ X5 X7 ; IF DISCREPANCY
JMP MAI20 ; THEN
MOV R7 MAISV ;
MOV R4 MAISV+1 ;
JMPI S4 OUTSTRING, <:TEST :>, EOT
MOV MAISV+1 R4 ;
MOV CTCBID.X4 R2 ; GET TEST IDENTIFICATION
JMPI S6 OUTHEXA ;
JMPI S4 OUTSTRING, <: WORD :>, EOT
MOV MAISV+1 R4 ;
MOV CTCBCNT.X4 R2 ; COMPUTE WORD
SUB R3 R2 ; NUMBER;
JMPI S6 OUTHEXA ;
JMPI S4 OUTSTRING, <: TO BE :>, EOT
MOV X5 R2 ; GET ACTUAL RESULT
JMPI S6 OUTHEXA
JMPI S4 OUTSTRING, <:- WAS :>, EOT
MOV MAISV R7 ;
MOV X7 R2 ; GET EXPECTED
JMPI S6 OUTHEXA ; GET EXPECTED
JMPI S6 OUTNL ; WRITE_NEWLINE;
MOV MAISV+1 R4 ;
MOV MAISV R7 ; RE-ESTABLISH POINTER;
MAI20: ; END DISCREPANCY;
ADDC 1 R5, ADDC 1 R7 ;
SOB R3 MAI10 ; END FOR_UNTIL;
;-----------------------------------;
; CHECK IF BREAK OCCURED ;
;-----------------------------------;
MAI50:
JMPI S6 BREAKCHECK ; BREAK_CHECK
JMPI & S6 UTILITIES ;*** R:(BREAK OCCURED);
;-----------------------------------;
; SEARCH NEXT TEST SEQUENCE ;
;-----------------------------------;
MOV PGMNEXT R6 ; GET REF(TEST_PGM TABLE INDEX);
MAI55: ; REPEAT
ADDC 2 R6 ; POINT NEXT TEST_RECORD;
MOV TCPOOL+TCPPROG.X6 R7 ; GET REF(TEST_PROGRAM);
IEQ R7 0 ; IF VALID TEST
JMP MAI55 ; THEN
MOV R6 PGMNEXT ; SAVE REFERENCE;
SNE R7 #8000 ; IF STILL TEST PROGRAMS LEFT
JMP MAI80 ; THEN
MOV TCPOOL+TCPDATA.X6 R4 ; GET REF(ASSOCIATED DATA);
MOVL CTCBCNT.X4 R01 ; GET NO_WORDS, RESET VALUE;
ADD R0 R4 ; ADJUST FOR EXPECTED_AREA;
MOV R4 R5 ;
MOV REFWORK R6 ; POINT WORK AREA;
IEQ R1 0 ; IF WHOLE AREA EQUAL 'R1'
JMP MAI65 ; THEN
MAI60: ; REPEAT
MOV R1 X6 ; INITIALIZE AREA;
ADDC 1 R6 ; ADJUST POINTER;
SOB R0 MAI60 ; UNTIL AREA COVERED;
JMP MAI70 ; ELSE
MAI65: ; REPEAT
MOV CTCBDATA.X4 R2 ; GET NEXT WORD
MOV R2 X6 ; COPIED;
ADDC 1 R4, ADDC 1 R6 ; ADJUST POINTERS;
SOB R0 MAI65 ; END COPYING AREA;
MAI70: ;
ADDC CTCBDATA R5 ; ADJUST POINTER TO INPUT;
MOVL 0. X5 R01 ;
MOVL 2. X5 R23 ;
MOV 4. X5 R4 ;
MOV REFWORK R6 ; POINT WORK AREA;
JMP X7 ; EXECUTE TEST PROGRAM;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; EXECUTE TEST SEQUENCE ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;TEST_PROGRAM_ENTRY:
; R0-4:FIRST 5 WORK_WORDS
; R5 - REF(WORK_AREA)
; R6 - REF(OUTPUT_AREA)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MAINTAIN LONG_INTEGER ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MAI80: ; END TABLE_SCAN;
MOVC 0 R6 ; RE-ADJUST TO TOP
MOV R6 PGMNEXT ; PROGRAM_INDEX;
MOVC PGMLOOP R6 ; REF(TEST_LOOP_COUNT);
MOVL 0. X6 R01 ; GET NO_TEST LEFT (LONG INT);
ADDC -1 R0 ; ADJUST LEAST SIGNIFICANT;
IEQ R0 -1 ; IF LEAST_SIGN'T BELOW
ADDC -1 R1 ; THEN ADJUST MOST_SIGNIFI'T;
SNEP R0 -1 ;
IEQ R1 -1 ; CPU_LOOP_TEST
JMP TESTEND ;
;
MOVL R01 0. X6 ; SAVE;
JMPI MAINLINE ; END CPU_TEST_LOOP;
; E N D P R O G R A M
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
TESTEND:
MOVC <:*:> R0 ;
MOVC 44 R3 ; FOR I:=1 UNTIL 44
END10: ; DO
JMPI S6 OUTCHAR ; WRITE_CHAR;
SOB R3 END10 ; END FOR_UNTIL;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;-----------------------------------------------------------------------
;FF\f
; M A S T E R C L E A R E N T R Y P O I N T
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ENTRY POINT UPON MASTER CLEAR
;
; R2 POINTER PROMMED PROGRAM
; R4 PROG_REL ADDRESS OF AUTOMATIC SERVICE PROGRAM
; R5 POINTER PROMMED PROCESS_DESCRIPTOR
; R7 DEVICE ADDRESS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
MCENTRYPOINT: ;ENTRY_POINT UPON MASTER CLEAR:
SVP MCWAITCPU ;
MOVC 0 R6 ;
MOV R6 XR0 ; RESET MEMORY CLAIM SEMAPHORE;
MOVC 100 R6 ;
SOB R6 LOC ; WAIT 100-200 USEC;
RESS X6 BIT0 ; RESERVE MEMORY
JMP MCE10 ; (LOST: WAIT FOR CPU_INTERRUPT,
; WON: CONTINUE);
MOV MSEC R6 ;
SOB R6 LOC ; WAIT 1 MSEC;
JMP MCE20 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; WAIT FOR WINNER'S CPU INTERRUPT ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MCE10: ;LOOSER'S_FAITH:
MOV R1 XBASE ;
MOV R1 XMOD ;
LDN R3 ;***ACTIVATE CPU WITH DUMMY PROCESS;
MCWAITCPU:
LDM 2#101 ; OPEN FOR CPU_INTERRUPTS ONLY;
JMP LOC ; WAIT FOR INTERRUPT;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; INITIALIZE WINNING PROCESS ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MCE20: ;INITIALIZE:
MOVC XABS R7 ; FOR I:=1 UNTIL COUNT
MCE30: ; DO
MOVL 0. X5 R01 ;
MOVL R01 0. X6 ; COPY
ADDC 2 R5 ; PROCESS
ADDC 2 R6 ; DESCRIPTOR;
SOB R7 MCE30 ; END FOR_UNTIL;
NOLIST IF SCMMODE THEN LIST
MCE40: ;RETRY_AUTO_BOOT:
MOV SCMADR R7 ; GET OC'S DEVICE ADDRESS;
MODC SCMSTATUS
SIO R0 R7 ; SENSE(STATUS, DEVICE);
MOVC SCMASYNC R1 ;
MODC SCMMR1
CIO R1 R7 ; LOAD MODE REGISTER 1;
MOV R0 R2 ;
SRL R2 BIT11 ; POSITION FRONT-PANEL SWITCH
IBN R2 BIT15-BIT11; IF AUTOMATIC_MODE
MOVC 2#0101 R2 ;... THEN FORCE 300 BAUD;
XTR R2 4 ; ISOLATE SWITCH SETTING (BAUD);
ADDC SCMBAUD R2 ; SET-UP PROPER MODE REG 2;
MODC SCMMR2
CIO R2 R7 ; LOAD MODE_REGISTER 2;
;
SBZ R0 BIT15 ; IF MANUAL MODE
JMP MCE70 ; THEN
NOLIST ELSE LIST
MOV OCADR R7 ; GET OC DEVICE ADDRESS
MOVC OCENB R0 ;
CIO R0 R7 ; ENABLE AV24;
RIO R0 R7 ; STATUS FLAGS;
SIO R0 R7 ; RESET
NOLIST FI LIST
;
JMPI S4 OUTSTRING, <:<13>CSS/395/02 791101:>, EOT
JMPI S4 OUTSTRING, <:<13>CPU :>, EOT
SVS R0 ; GET CURRENT PSW
SWP R0 ; POSITION CPU-NO AS RIGHTMOST;
XTR R0 3 ; ISOLATE CPU NO;
ADDC <:0:> R0 ; CONVERT TO ASCII;
JMPI S6 OUTCHAR ; WRITE_CHAR;
MCE50: JMPI S6 UTILITIES ;
JMP MCE50 ;
NOLIST IF SCMMODE THEN LIST
;FF\f
; A U T O M A T I C M O D E
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; AUTO MODE
; R0 SCM STATUS WORD
; BIT12,11 DRIVE IDENTIFICATION
; BIT13 TYPE OF DEVICE: 0=FD, 1=CDC-DISK
; BIT14 BOOT INDIRECT VIA DMA-CHANNEL
; BIT15 AUTO MODE FLAG (HIGH)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
MCE70: ;AUTO_MODE:
SBZ R0 BIT13 ; IF AUTO LOAD FROM FLOPPY
JMP MCE80 ; THEN
MOV R0 R2 ; FORCE DIRECT LOAD AS DEFAULT;
IBN R2 BIT14 ; IF REQUEST FOR VIA DMA
MOVC <:X:> R2 ; THEN PREPARE INDIRECT LOAD;
SRL R0 BIT11 ; POSITION DRIVE NUMBER;
JMPI S6 FDBLOAD ; LOAD_FILE FROM FD
JMP & MCE40 ; FAILED:(RETRY),
LDN R3 ;*** ACTIVATE LOADED PROCESS;
MCE80: ; ELSE
TRP 0 ; INVALID SETTING
NOLIST FI LIST
;///////////////////////////////////; END BASIC_INTITIALIZATION;
MCE90: ;RETURN_CALLER:
MOV XOLDPRC R7 ; GET BASE CALLING PROCESS
LDN R7 ; RE-ACTIVATE CALLING PROCESS;
ENDOFPGM:
;FF\f
PROGRAMSTART:= CPUPROM+PROGSTART
PROGRAMGO:= PROGRAMSTART+MCENTRYPOINT
ABSMCE50:= PROGRAMSTART+MCE50
IF LOC LT #0FE0
THEN #0000, REPEAT (#FE0-LOC) AN #7FF
ELSE MESSAGE LOC FI
RELPROMBASE= PROGRAMSTART+LOC-CPUBASE
USE BASE
LOC= ENDOFDATA
IF LOC LT #1E
#0000
IF LOC LT #1E
REPEAT (#1E-LOC)
FI
FI
PROGRAMSTART+EMERGENCY ; EMERGENCY ACTION SERVICE PROGRAM
#0000 ; PROM CHECK-SUM
BEGIN
EXTERNAL EOT
EXTERNAL BIT0, BIT1, BIT2, BIT3, BIT4, BIT5, BIT6, BIT7,
EXTERNAL BIT8, BIT9, BIT10, BIT11, BIT12, BIT13, BIT14, BIT15
USE BASE
EXTERNAL CPUMON
EXTERNAL XBASE, XPROG
EXTERNAL TCBASE, TCREFWORK
EXTERNAL B5555, BAAAA, CP06, CP20INS, CPWORK
EXTERNAL CP46P, CP46
USE PROG
EXTERNAL MAINLINE, P5555, PAAAA
NAMES
END
;FF\f
END
«eof»