|
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: 59528 (0xe888)
Types: TextFile
Notes: UNREAD_DATA_SECTOR
Names: »AMUSRC«
└─⟦af8db8df8⟧ Bits:30005566 8" CR80 Floppy CR80FD_0245 ( CR/D/1242 )
└─⟦ce5288cf7⟧
└─ ⟦this⟧ »AMUSRC«
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«ff»
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 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
$OC
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«ff»
; 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«ff»
; 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«ff»
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«ff»
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«ff»
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«ff»
;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«ff»
; 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«ff»
; 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«ff»
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«ff»
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 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«ff»
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 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«ff»
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 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«ff»
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 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«ff»
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 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«ff»
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 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«ff»
$UTILITIES
NOLIST IF FDSUPPORT THEN LIST
$FDLOAD
NOLIST FI LIST
;FF«ff»
; 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«ff»
; 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«ff»
; 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 _UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD__UNREAD_ 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«ff»
; 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«ff»
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«ff»
END