IDENT MTE,PRS PERIPH BASE MIXED SST PPR,LEP,DFM,EXR,.SMS,RA,FL,IA,MA,EPFW TITLE MTE - MONITOR EXTENDED MEMORY INTERFACE. *COMMENT MTE - MONITOR EXTENDED MEMORY INTERFACE. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. MTE SPACE 4,10 *** MTE - MONITOR EXTENDED MEMORY INTERFACE. * W. E. GOEBEL. 86/01/20. * R. C. SCHMITTER 94/03/21. SPACE 4,20 *** *MTE* IS LOADED INTO A PP AT DEAD START TIME IF THE SYSTEM * IS RUNNING IN MULTI-MAINFRAME MODE, AND THE LINK DEVICE HAS * NO CPU COUPLER ACCESS. * * *MTE* PERFORMS THE FOLLOWING FUNCTIONS. * * 1. PROCESS DEVICE INTERLOCK REQUESTS FOR *DTKM*, *DLKM*, * *RTCM*, *STBM*, AND *VMSM* MONITOR FUNCTIONS. * 2. PROCESS *AFAM*, *ECSM* AND *MTEM* MONITOR FUNCTIONS IN * THEIR ENTIRETY. * 3. WRITE DEVICE TABLES TO EXTENDED MEMORY AND CLEAR DEVICE * INTERLOCKS. * 4. SCAN EXTENDED MEMORY CLOCKS TO DETERMINE ACTIVE MACHINES. * 5. PROCESS BUFFER ACCESS TABLE (BAT) REQUESTS WHEN SHARED * DAS DEVICES ARE PRESENT. * * *MTE* DOES NOT USE *PPR* ROUTINES PAST *EFTN*. THUS, DISK * DRIVER USAGE, DAYFILE MESSAGES, AND RE-ENTERING *PPR* ARE * NOT ALLOWED. A SPECIAL VERSION OF *EXR* IS INCLUDED IN * *MTE* FOR LOADING CM RESIDENT OVERLAYS. THE *PPR* VERSION * OF *EXR* IS NOT USED. SPACE 4,10 *** CALL. * *T 18/ MTE,6/ CP,24/,12/ RM * * CP = SYSTEM CONTROL POINT NUMBER. * RM = RECOVERY MODE. SPACE 4,40 *** A MEMORY MAP OF *MTE* IS AS FOLLOWS. * * 0 ************************************************************* * * * * * DIRECT CELLS * * * * * ************************************************************* * 100 * * * * *PPR* ROUTINES (*FTN*, *.DLY*, *.EST*) * * * * * ************************************************************* * EFTN * * * * MST/TRT/BAT/BRT READ/WRITE BUFFERS * * * *MTE* PRESET (OVERLAYS BUFFERS) * * * DOWN MACHINE PROCESSING (OVERLAYS BUFFERS) * * * EXTENDED MEMORY ERROR RECOVERY (OVERLAYS BUFFERS) * * * * * ************************************************************* * * * * * *MTE* MAIN LOOP * * * * * * MONITOR FUNCTION PROCESSORS * * * * * * SUBROUTINES * * * * * * EXTENDED MEMORY INTERFACE ROUTINES * * * * * ************************************************************* * EPFW * * * * EXTENDED MEMORY ERROR PROCESSING AREA * * * * * ************************************************************* SPACE 4,10 *** *MTE* DEBUG CAPABILITY - UEM EMULATION OF EXTENDED MEMORY. * * *MTE* WILL INTERFACE WITH UEM AS A LINK DEVICE FOR THE * PURPOSE OF TESTING MMF CODE. NO ACTUAL SHARING OF DEVICES * IS POSSIBLE SINCE NO HARDWARE PROVISION EXISTS FOR MULTIPLE * MACHINE ACCESS TO UEM. TO UTILIZE THIS FEATURE, SIMPLY * DEFINE EQUIPMENT 5 AS UEM AND DECLARE IT AS SHARED. * *SET* WILL TREAT IT AS A 180 MMF LINK DEVICE AND *MTE* * WILL BE LOADED. UEM WILL LOOK EXACTLY AS AN EXTENDED MEMORY * DEVICE WITH THE FLAG REGISTER BEING SIMULATED AND ITS * CONTENTS STORED IN *EFRL*. SPACE 4,10 EPFW EQU 7540 SPACE 4,10 * COMMON DECKS. *CALL COMPMAC *CALL COMPCHI *CALL COMSCPS QUAL DSL *CALL COMSDSL QUAL * *CALL COMSLSD LIST X *CALL COMSMMF LIST * *CALL COMSMRT *CALL COMSMSC *CALL COMSMSP *CALL COMSPFM *CALL COMSPIM *CALL COMS1DS TITLE ASSEMBLY CONSTANTS. SPACE 4,10 **** DIRECT LOCATION ASSIGNMENTS. BEGIN BSSN 16 BEGINING OF DIRECT CELL DEFINITIONS T8 BSSN 1 SCRATCH T9 BSSN 1 SCRATCH EA BSSN 5 EXTENDED MEMORY ADDRESS (FIRST TWO BYTES) BR BSSN 1 BYTES NOT TRANSFERED ST BSSN 1 STATUS FROM LOW SPEED PORT/DDP WC BSSN 1 WORD COUNT FOR EXTENDED MEMORY TRANSFER RC BSSN 1 ESM ERROR RETRY COUNT FS BSSN 5 CM WORD BUFFER RQ BSSN 1 REQUEST PARAMETER (OR/MST ADDRESS) QE BSSN 1 NEXT PP REQUEST QUEUE ENTRY QH BSSN 1 HEAD OF PP RETRY QUEUE QT BSSN 1 TAIL OF PP RETRY QUEUE FN BSSN 5 CM WORD BUFFER OF BSSN 1 FIRST (*MTR*) OUTPUT REGISTER ADDRESS BSSN 50-* IR BSSN 5 INPUT REGISTER BSSN 1 SPARE (DESTROYED BY *FTN*) BSSN 1 SPARE (DESTROYED BY *FTN*) CV BSSN 1 LAST TIME CLOCK VALUE OR BSSN 5 PP OUTPUT REGISTER * THESE THREE CELLS CAN BE USED AS SCRATCH OUTSIDE OF * *MTET*/*MTBT* QUEUE PROCESSING FROM *CPUMTR*. SX BSSN 0 MX BSSN 1 MAXIMUM REQUESTS PER PASS IN BSSN 1 IN POINTER FOR *MTBT* BUFFER OT BSSN 1 OUT POINTER FOR *MTBT* BUFFER RM EQU IR+4 RECOVERY MODE BSSN 70-* ON BSSN 1 1 HN BSSN 1 100 TH BSSN 1 1000 TR BSSN 1 3 CP BSSN 1 CONTROL POINT MA BSSN 1 MESSAGE BUFFER ADDRESS - NON STANDARD OA BSSN 1 OUTPUT REGISTER ADDRESS ZR BSSN 5-1 ZERO WORD MI BSSN 2 MACHINE INDEX (OVERLAYS ZR+4) END BSSN SPACE 4,10 * ASSEMBLY CONSTANTS. CH EQU 0 LINK DEVICE CHANNEL SC EQU 5000 LOW SPEED PORT SELECT CODE RDFN EQU 1 READ FUNCTION CODE WTFN EQU 2 WRITE FUNCTION CODE STFN EQU 4 STATUS FUNCTION CODE MCFN EQU 10 MASTER CLEAR PORT FUNCTION CODE ESFN EQU 604 SET ECS MODE ADDRESSING FUNCTION CODE NPPU EQU 30D NUMBER OF PP-S TO PROCESS REQUESTS FOR SPACE 4,10 * BEGIN TABLES OVERLAYED BY *PRESET*. BEGIN BSSN EFTN MBUF BSSN SDGL*5+5 MST READ/WRITE BUFFER TBUF BSSN BRTL*5+5 TRT/BAT READ/WRITE BUFFER FATB EQU TBUF FAST ATTACH TABLE READ/WRITE BUFFER BRTB EQU TBUF+5 BRT READ/WRITE BUFFER GFAT EQU FATB+5 GLOBAL FAST ATTACH WORD EBUF BSSN 0 END OF BUFFERS END BSSN **** TITLE MACRO DEFINITIONS. CFLAG SPACE 4,10 ** CFLAG - CLEAR FLAG REGISTER BITS. * * CFLAG BIT,NW * * ENTRY *BIT* = NAME OF BIT TO CLEAR. * *NW* = NO WRITE OF FLAG OWNER. * * CALLS IFR, SLA. PURGMAC CFLAG CFLAG MACRO BIT,NW MACREF CFLAG .A IFC NE,*TRTI*BIT* .B IFC EQ,$NW$$ LDN FRET+BIT RJM SLA WRITEM 1,ZR .B ENDIF .A ENDIF LDC C_BIT RJM IFR CFLAG ENDM PPR SPACE 4,10 ** PPR - SET PP REQUEST PROCESSOR. * * PPR FNC,PRC * ENTRY *FNC* = FUNCTION NUMBER. * *PRC* = PROCESSOR ADDRESS. PURGMAC PPR PPR MACRO FNC,PRC LOCAL K MACREF PPR .A IFC EQ,$PRC$$ K MICRO 1,3, FNC K MICRO 1,4,*."K"* "K" CON FNC ORG *-1 .A ELSE K MICRO 1,, PRC .A ENDIF PPR RMT ORG TPPR+FNC CON "K" FNC PPR RMT IF -DEF,MXFNC,1 MXFNC SET FNC IFGT FNC,MXFNC,1 MXFNC SET FNC PPR ENDM READEM SPACE 4,10 ** READEM - READ EXTENDED MEMORY. * * READEM WCT,BUF,ERR * * ENTRY *WCT* = WORD COUNT TO READ. * = *, IF DIRECT CELL WC CONTAINS WORD COUNT. * *BUF* = PP BUFFER ADDRESS TO RECEIVE THE DATA READ. * *ERR* = EXTENDED MEMORY ERROR PROCESSOR ADDRESS. * * CALLS RDW. PURGMAC READEM READEM MACRO WCT,BUF,ERR LOCAL A MACREF READEM .A IFC NE,$WCT$*$ LDN WCT STD WC .A ENDIF LDK BUF RJM RDW .B IFC NE,$ERR$$ A EQU * .ERP MICRO 1,, ".ERP"A,ERR, .B ENDIF READEM ENDM SFLAG SPACE 4,10 ** SFLAG - SET FLAG REGISTER BITS. * * SFLAG BIT,REJ * * ENTRY *BIT* = NAME OF BIT(S) TO CLEAR. * *REJ* = REJECT ENTRY ADDRESS. * * CALLS IFR, SLA. PURGMAC SFLAG SFLAG MACRO BIT,REJ MACREF SFLAG LDC S_BIT RJM IFR .A IFC NE,*REJ** NJP REJ IF INTERLOCK PREVIOUSLY SET .A ENDIF IFC NE,*TRTI*BIT* IFC NE,*COMI*BIT* LDN FRET+BIT RJM SLA WRITEM 1,MI+1-4 ENDIF SFLAG ENDM SUBFUN SPACE 4,15 ** SUBFUN - SET SUBFUNCTION PROCESSOR. * *SFA SUBFUN FNC,SFN * * ENTRY *SFA* = SUBFUNCTION PROCESSOR ENTRY NAME. * *FNC* = FUNCTION NAME. * *SFN* = SUBFUNCTION NAME. * * THIS MACRO BUILDS A TABLE OF SUBFUNCTION PROCESSORS. * THE TABLE IS NAMED T*FNC*, AND EACH ENTRY IS THE * ADDRESS OF THE PROCESSOR FOR THE SUBFUNCTION. PURGMAC SUBFUN MACRO SUBFUN,SFA,FNC,SFN MACREF SUBFUN SFA BSS 0 IRP SFN T_FNC RMT ORG T_FNC+SFN CON SFA SFN T_FNC RMT IRP SUBFUN ENDM WRITEM SPACE 4,10 ** WRITEM - WRITE EXTENDED MEMORY. * * WRITEM WCT,BUF,ERR * * ENTRY *WCT* = WORD COUNT TO WRITE. * = *, IF DIRECT CELL WC CONTAINS WORD COUNT. * *BUF* = PP BUFFER ADDRESS TO WRITE DATA FROM. * *ERR* = EXTENDED MEMORY ERROR PROCESSOR ADDRESS. * * CALLS WTW. PURGMAC WRITEM WRITEM MACRO WCT,BUF,ERR MACREF WRITEM .A IFC NE,$WCT$*$ LDN WCT STD WC .A ENDIF LDK BUF RJM WTW .B IFC NE,$ERR$$ A EQU * .ERP MICRO 1,, ".ERP"A,ERR, .B ENDIF WRITEM ENDM .ERP MICRO 1,, INITIALIZE ERROR PROCESSOR MICRO TITLE MAIN PROGRAM. FWAP EQU 600 FWA OF *PRS* ERRNG FWAP-315 MAIN OVERLAY DESTROYS *PLL* RETURN ADDRESS ORG FWAP SPACE 4,10 USE MAIN SPARES EQU *-EBUF LOCATIONS AVAILABLE IN MAIN BLOCK FWA EQU *L PRQ SPACE 4,15 ** PRQ - PROCESS QUEUED REQUEST. * * SOME DEVICE INTERLOCK REQUESTS ARE UNABLE TO BE PROCESSED * WHEN PASSED FROM *CPUMTR*. THESE REQUESTS ARE QUEUED TO BE * RETRIED AFTER A DELAY TIME IS EXPIRED. THIS ROUTINE IS * ENTERED WHEN A QUEUED REQUEST IS TO BE PROCESSED. * * ENTRY (A) = OUTPUT REGISTER ADDRESS OF QUEUED REQUEST. * * EXIT (RQ) = PP REQUEST ADDRESS. * TO FUNCTION PROCESSOR. * ENTRY DELETED FROM QUEUE. * TO *CFR1* IF REQUEST HAS BEEN CLEARED. * * USES MX, QH, RQ, T8, OR - OR+4. PRQ STD RQ LDN 0 STM TPPQ,QH STD MX LDC MTE1 SET EXIT FOR FUNCTION COMPLETE STM CFR SOD QH PJN PRQ1 IF NO WRAP LDN NPPU-1 STD QH PRQ1 LDD RQ * ENTER HERE TO PROCESS REQUEST INITIALLY. PRQ2 CRD OR LDD OR ZJP CFR1 IF REQUEST WAS CLEARED LDM TPPR,OR SET FUNCTION PROCESSOR STD T8 LJM 0,T8 ENTER PROCESSOR MTE SPACE 4,25 ** MTE - MAIN PROGRAM. * * THE MAIN LOOP OF *MTE* PERFORMS THE FOLLOWING TASKS. * 1. CHECKS FOR REQUESTS PASSED FROM *CPUMTR* IN THE *MTET* * QUEUE. * 2. RETRIES ANY BUFFER ACCESS TABLE REQUESTS THAT HAVE * BEEN QUEUED IN THE BUFFER REQUEST TABLE (BRT). * 3. CHECKS FOR NEW BAT REQUESTS PASSED FROM *CPUMTR* IN * THE *MTBT* QUEUE. * 4 CHECKS THE BRT-S OF ANY OTHER MAINFRAMES FOR REQUESTS * UNABLE TO BE PROCESSED BECAUSE OF LOCKS HELD BY THIS * MAINFRAME. * 5. RELEASES THE LOW SPEED PORT CHANNEL WHEN IT IS * REQUESTED. * 6. WRITES MACHINE CLOCK TO EXTENDED MEMORY ONCE A * SECOND. * 7. CHECKS THE STATE OF OTHER MACHINES ONCE EVERY TWO * SECONDS. * 8. INITIATES EXTENDED MEMORY ERROR RECOVERY WHEN * REQUIRED. * 9. UPDATES *MTE* STATISTICS. MTE LDM TPPQ,QH NJN PRQ IF QUEUED REQUESTS MTE1 RJM CFR CHECK FOR REQUESTS PASSED FROM *CPUMTR* MTED UJN MTE1.1 CHECK FOR CHANNEL REQUESTED * PSN (SHARED BUFFERED DEVICES PRESENT) * PROCESS BAT/BRT REQUESTS. RJM RBR REPROCESS BRT REQUESTS RJM PBR PROCESS NEW BAT REQUESTS RJM CBM CHECK BRT-S FROM OTHER M/F-S * CHECK FOR CHANNEL REQUESTED. MTE1.1 SOM CRCC NJP MTE5 IF NOT TIME TO CHECK CHANNEL REQUEST LDN 10 STM CRCC MTEA LDC ** SET CHANNEL INTERLOCK TABLE ADDRESS MTEB ADN ** ADD WORD NUMBER CRD CM MTEC LDD ** CHECK APPROPRIATE BYTE SHN 0-13 ZJN MTE2 IF CHANNEL NOT REQUESTED LDN 0 RELEASE CHANNEL RJM DSW LDN 1 REQUEST CHANNEL RJM DSW * CHECK IF TIME TO WRITE MACHINE CLOCK. MTE2 LDC PDTL CHECK IF ONE SECOND ELAPSED CRD FS LDD FS+4 SBD CV ZJN MTE3 IF NOT TIME TO WRITE CLOCK RAD CV * WRITE PACKED DATE AND TIME TO EXTENDED MEMORY. TLDN SMET-1,MI RJM SLA SET LABEL TRACK ADDRESS WRITEM 1,FS IGNORE ERROR IN WRITING CLOCK LDD CV LPN 1 MTE3 ZJN MTE5 IF NOT TIME TO STATUS MACHINES * CHECK FOR CHANGE IN MACHINE STATE. RJM CAM CHECK MACHINE STATUS ZJN MTE4 IF NO CHANGE IN MACHINE STATE EXECUTE 2EA PROCESS MACHINE STATE CHANGE RJM CFR CHECK FOR REQUESTS PASSED FROM *CPUMTR* * CHECK IF EXTENDED MEMORY ERROR RECOVERY NEEDED. MTE4 LDC TCOMI CHECK ERROR RECOVERY REQUESTED RJM IFR ZJN MTE5 IF NO ERROR RECOVERY PROCESSING EXECUTE 2EB PROCESS EXTENDED MEMORY TABLE ERRORS MTE5 RJM UMS UPDATE *MTE* STATISTICS LJM MTE LOOP CRCC CON 10 CHANNEL REQUEST CYCLE COUNT CYTM CON 0 *MTE* CYCLE TIME BRTF CON 0 BRT FULL FLAG (=*NBRR* IF BRT IS FULL) BRTP CON 0 BRT TRACK NUMBER ** BAT/BRT STATISTICS (MUST BE CONTIGUOUS). BRTS BSS 0 BATT CON 0 TOTAL BAT REQUESTS BRTT CON 0 TOTAL BRT ENTRIES BREC CON 0 CURRENT BRT ENTRY COUNT BIAA CON 0 *BATI* INTERLOCK ATTEMPTS ABANDONED BRTR CON 0 BRT ENTRIES REJECTED TITLE PP REQUEST PROCESSING. HNG SPACE 4,10 ** HNG - HANG PPU. * * ENTRY (RQ) = OUTPUT REGISTER ADDRESS. HNG LDD RQ SET ADDRESS OF FUNCTION IN ERROR STD CM+1 MONITOR HNGM FNR SPACE 4,10 ** FNR - FUNCTION NOT READY. * * ENTRY (RQ) = OUTPUT REGISTER ADDRESS. FNR LDD RQ REJECT FUNCTION STM TPPQ,QT LINK TO TAIL OF QUEUE SOD QT PJN CFR1 IF NO WRAP LDN NPPU-1 STD QT UJN CFR1 PROCESS NEXT REQUEST CPF SPACE 4,10 ** CPF - PASS REQUEST TO *CPUMTR*. * * ENTRY (RQ) = OUTPUT REGISTER ADDRESS. * * USES OR. CPF LDC 5000 RAD OR UJN FNC1 WRITE OUTPUT REGISTER FNC SPACE 4,10 ** FNC - FUNCTION RETURN TO CLEAR UPPER BYTE OF *OR*. * * ENTRY (RQ) = OUTPUT REGISTER ADDRESS. * * USES OR - OR+4. FNC LDN 0 SET FUNCTION COMPLETE STD OR FNC1 LDD RQ CWD OR UJN CFR1 CHECK NEXT FUNCTION CFR SPACE 4,10 ** CFR - CHECK FOR REQUESTS PASSED FROM *CPUMTR*. * * EXIT TO FUNCTION PROCESSOR WITH (A) = (RQ). * * USES MX, QE, RQ, FN - FN+4. CFR SUBR ENTRY/EXIT LDN 10 SET MAXIMUM REQUESTS PER PASS STD MX CFR1 TLDC MTET,PQ PP QUEUE ADDRESS ADD QE CRD FN LDD FN+4 CHECK FUNCTION PRESENT ZJN CFRX IF NO REQUEST PRESENT SOD MX ZJN CFRX IF AT MAXIMUM TLDC MTET,PQ CLEAR REQUEST FROM LIST ADD QE CWD ZR SOD QE ADVANCE PAST CURRENT ENTRY PJN CFR2 IF NO WRAP ON QUEUE LDN MXQP-1 STD QE CFR2 LDD FN+3 ENTRY STD RQ LJM TCFR,FN+4 ENTER REQUEST PROCESSOR TCFR SPACE 4,10 ** TCFR - TABLE OF *CPUMTR* FUNCTION REQUESTS. * * ENTRY = ONE WORD. * 12/ ADDRESS OF FUNCTION PROCESSOR TCFR EQU *-1 LOC 1 PPRF LJM PRQ2 PROCESS PP REQUEST CDIF LJM CDI CLEAR DEVICE INTERLOCK LOC *O TPPQ SPACE 4,10 ** TPPQ - TABLE OF QUEUED PP REQUESTS. TPPQ BSS NPPU QUEUED PP REQUESTS EXR SPACE 4,10 ** EXR - EXECUTE CM RESIDENT ROUTINE. * * ENTRY (A) = ROUTINE NAME. * * EXIT TO CALLED ROUTINE VIA SIMULATED RETURN JUMP. * * USES CM+2, CM+3. * * MACROS MONITOR. EXR CON 0 ENTRY STD CM+3 SHN -14 STD CM+2 MONITOR SPLM LDD CM+4 SET LOAD ADDRESS STM EXRA LDD CM+1 READ IN PROGRAM LPN 77 SHN 14 ADD CM+2 CRM *,CM+3 EXRA EQU *-1 LDM EXR SET RETURN ADDRESS STM 6,CM+4 LJM 7,CM+4 ENTER ROUTINE TITLE *AFAM* MONITOR FUNCTION PROCESSING. AFAM SPACE 4,30 *** AFAM - ACCESS FAST ATTACH. * *AFAM* ATTACHES OR RELEASES FAST ATTACH FILES. * * ENTRY *T OR 12/ AFAM,12/ EQ,1/N,11/ MD,12/ SF,12/ FO * EQ EST ORDINAL OF DEVICE WHERE THE FAST * ATTACH FILE RESIDES, IF GLOBAL FAST ATTACH FILE. * 0, IF LOCAL FAST ATTACH FILE. * N NON-ROLLABLE OPTION (VALID ONLY ON WRITABLE MODES * FOR *AFAS* SUBFUNCTION). * MD MODE OF ATTACH. * SF SUBFUNCTION CODE AS DEFINED IN COMSCPS. * *AFAS* = 0 = ATTACH FAST ATTACH FILE. * *RFAS* = 1 = RETURN FAST ATTACH FILE. * FO FNT ORDINAL. * * EXIT *T, OR 12/ 0,12/ ST,24/ ,4/ WF,6/ ,1/N,1/ * ST = 0 IF FUNCTION COMPLETE. * ST = 1 IF FUNCTION CANNOT BE COMPLETED AT THIS TIME. * FILE IS ATTACHED IN A CONFLICTING MODE. * WF .NE. 0 IF FILE ALREADY ATTACHED IN A WRITABLE MODE (AFAS * REJECT ONLY). * N = NON-ROLLABLE FLAG (*AFAS* REJECT ONLY). * * NOTE - *CPUMTR* CHECKS FOR ALL HANG CONDITIONS BEFORE PASSING * THE REQUEST TO *MTE*. AFP SPACE 4,10 ** AFP - *AFAM* PRESET PROCESSING. * * *AFAM* PRESET MAY NOT BE EXECUTED UNTIL THE DAT/FAT TRACK * IS ALLOCATED BY *0MF*. FOR THIS REASON THE FIRST CALL TO * *AFAM* DOES THE PRESET OPERATION. AFP LDC ALGL READ DAT/FAT TRACK CRD CM LDD CM+4 LPC 3777 STD CM+4 SHN 6 ADD CM+4 101 * TRACK AFPA SHN 4 2020 * TRACK * SHN 4+EMSC 2020 * EMSC * TRACK RAM AFAA+1 SHN -14 RAM AFAA LDN AFA-AFP RAM TPPR+AFAM * UJN AFA ENTER PROCESSOR PPR AFAM,AFP AFA LDD OR+2 LPC 3777 SHN 1 ADD OR+3 STD T8 LDM TAFAM,T8 SET PROCESSOR ADDRESS STD T9 * READ FNT/FST. SFA FNT,OR+4 ADK FNTG CRD FN ADK FSTG-FNTG CRD FS SOD FN+4 CLEAR BUSY * READ FAT OF REQUESTED FILE. SFLAG FATI,FNR SET FAT INTERLOCK LDD FN+3 LPN 77 SHN FATS AFAA ADC FAST*100B (ADDRESS OF FAT) * ADC FAST*100B+(SECTORS PER TRACK) STD EA+1 SHN -14 STD EA READEM MXMF+2,FATB,AFA1 READ FAST ATTACH TABLE LDM GFAT+4 LJM 0,T9 ENTER PROCESSOR * FAT READ ERROR PROCESSOR. AFA1 SFLAG COMI RJM CFI CLEAR FAT INTERLOCK UJP FNR RETRY FUNCTION * ATTACH PROCESSOR RETURN WHEN ATTACH IS ALLOWED. AFAX WRITEM *,FATB WRITE UPDATED FAT RJM CFI CLEAR FAT INTERLOCK ADK FSTG WRITE FNT/FST CWD FS ADK FNTG-FSTG CWD FN LDN 0 AFA2 STD OR+1 LJM FNC COMPLETE FUNCTION * ATTACH PROCESSOR REJECT RETURN. AFAR RJM CFI CLEAR FAT INTERLOCK ADK FNTG WRITE FNT CWD FN LDM GFAT+4 RETURN PRESENT WRITE MODE BITS LPC 7402 STD OR+4 LDN 1 UJN AFA2 RETURN AFA SPACE 4,15 ** THE FOLLOWING ARE *AFAM* SUBFUNCTION PROCESSORS. * THE SUBFUNCTION NUMBER IS MADE UP OF THE ATTACHMENT MODE * 2 * FOR AN ATTACH, OR THE ATTACHMENT MODE * 2 + 1 FOR A RETURN. * THE FOLLOWING ARE THE ENTRY CONDITIONS TO THE ATTACH/RETURN * PROCESSORS. * * ENTRY (A) = (GFAT+4) = BYTE 4 OF GLOBAL FAT ENTRY. * (FATB) = FAT ENTRY FROM EXTENDED MEMORY. * (FS - FS+4) = LOCAL MACHINE FST ENTRY. * * EXIT (FATB) UPDATED FOR NEW ACCESS MODE. * (FS - FS+4) = UPDATED FST. * WRITE MODE ATTACH. AWT SUBFUN AFAM,PTWR*2 SCN 3 ADM GFAT+3 ADM GFAT+2 AWT1 NJN AFAR IF FILE BUSY LDN 7 AWT2 SHN 10 STD T2 LDD OR+2 SET NON-ROLLABLE BIT SHN 1-13 RAD T2 RAD FS+4 TSTM FATB+1*5+4,,MI5 LDD T2 AWT3 RAM GFAT+4 LJM AFAX RETURN * APPEND MODE ATTACH. AAP SUBFUN AFAM,PTAP*2 SCN 3 NJN AWT1 IF APPEND MODE NOT ALLOWED LDM GFAT+3 LPN 77 AAP1 NJN AWT1 IF APPEND MODE NOT ALLOWED LDN 1 UJN AWT2 SET APPEND MODE * MODIFY MODE ATTACH. AMD SUBFUN AFAM,PTMD*2 SCN 3 ADM GFAT+3 NJN AAP1 IF MODE CONFLICT LDN 3 UJN AWT2 SET MODIFY MODE * UPDATE MODE ATTACH. AUP SUBFUN AFAM,PTUP*2 SHN -10 ADM GFAT+3 NJN AAP1 IF MODE CONFLICT LDN 10 UJP AWT2 SET MODIFY MODE * WRITE MODE RETURN. RWT SUBFUN AFAM,PTWR*2+1 LDN 7 RWT1 SHN 10 LMD FS+4 SHN -10 NJP HNG IF NOT IN WRITE MODE LDD FS+4 LPC 7402 STD T2 LMD FS+4 UPDATE LOCAL MODE BITS STD FS+4 TSTM FATB+1*5+4,,MI5 LDN 0 SBD T2 UJP AWT3 RETURN * APPEND MODE RETURN. RAP SUBFUN AFAM,PTAP*2+1 LDN 1 UJN RWT1 COMPLETE PROCESSING * MODIFY MODE RETURN. RMD SUBFUN AFAM,PTMD*2+1 LDN 3 UJN RWT1 COMPLETE PROCESSING * UPDATE MODE RETURN. RUP SUBFUN AFAM,PTUP*2+1 LDN 10 UJN RWT1 COMPLETE PROCESSING * READ ALLOW MODIFY MODE RETURN. RRM SUBFUN AFAM,PTRM*2+1 LDD FS+2 ZJN RRA2 IF NO R/M COUNT SET SOM GFAT+2 SOD FS+2 RRM1 TSTM FATB+1*5+2,,MI5 UJN RRD2 RETURN * READ/EXECUTE MODE RETURN. RRD SUBFUN AFAM,(PTRD*2+1,PTEX*2+1) LDD FS+3 LPN 77 ZJN RRA2 IF NO READ COUNT SET SOM GFAT+3 SOD FS+3 RRD1 TSTM FATB+1*5+3,,MI5 RRD2 LJM AFAX RETURN * READ ALLOW APPEND MODE RETURN. RRA SUBFUN AFAM,PTRA*2+1 LDC -100 RAM GFAT+3 LDC -100 RRA1 RAD FS+3 PJN RRD1 IF R/A COUNT SET RRA2 LJM HNG HANG * READ ALLOW UPDATE MODE RETURN. RRU SUBFUN AFAM,PTRU*2+1 LDD FS+4 LPC 374 ZJN RRA2 IF NO R/U COUNT SET LCN 4 RAM GFAT+4 LCN 4 RRU1 RAD FS+4 TSTM FATB+1*5+4,,MI5 UJN RRD2 RETURN * READ/EXECUTE MODE ATTACH. ARD SUBFUN AFAM,(PTRD*2,PTEX*2) SHN -10 NJN ARA1 IF FILE IN WRITABLE MODE AOM GFAT+3 LPN 77 ZJN ARU1 IF READ COUNT EXCEEDED AOD FS+3 ADVANCE LOCAL READ COUNT UJP RRD1 RETURN * READ ALLOW MODIFY MODE ATTACH. AMR SUBFUN AFAM,PTRM*2 SHN 21-12 MJN ARA1 IF FILE IN WRITE MODE AOM GFAT+2 SHN -14 NJN ARA1 IF R/M COUNT EXCEEDED AOD FS+2 ADVANCE LOCAL R/M COUNT UJP RRM1 RETURN * READ ALLOW APPEND MODE ATTACH. ARA SUBFUN AFAM,PTRA*2 SHN -11 NJN ARU1 IF FILE IN WRITE OR MODIFY MODE LDD HN RAM GFAT+3 SHN -14 ARA1 NJN ARU1 IF R/M COUNT EXCEEDED LDD HN UJP RRA1 UPDATE LOCAL COUNTS * READ ALLOW UPDATE MODE ATTACH. ARU SUBFUN AFAM,PTRU*2 LPC 3774 ADC -374 MJN ARU2 IF NOT CONFLICTING MODE OR COUNT EXCEEDED ARU1 LJM AFAR REJECT ARU2 LDN 4 RAM GFAT+4 LDN 4 UJP RRU1 ADVANCE LOCAL R/U COUNT TAFAM SPACE 4,10 ** TAFAM - TABLE OF *AFAM* SUBFUNCTION PROCESSOR ADDRESSES. * * INDEXED BY ATTACH/RETURN MODE. * 12/ ATTACH PROCESSOR, 12/ RETURN PROCESSOR MXAFAM EQU 2*PTLM TAFAM BSS 0 DUP MXAFAM,1 CON HNG LIST G TAFAM HERE LIST * ORG TAFAM+MXAFAM TITLE *ECSM* MONITOR FUNCTION PROCESSING. ECSM SPACE 4,10 *** ECSM - EXTENDED MEMORY TRANSFER. * 1.) TRANSFER FROM 1 TO 100B WORDS TO/FROM RELATIVE * EXTENDED MEMORY USING A USER SPECIFIED CM BUFFER. * ILLEGAL FOR *MTE* REQUEST. * 2.) TRANSFER FROM 1 TO 100B WORDS TO/FROM EXTENDED * MEMORY USING A USER SPECIFIED CM BUFFER. * 3.) TRANSFER EXTENDED MEMORY ACCORDING TO A LIST OF * ADDRESSES. * 4.) PERFORM FLAG REGISTER OPERATIONS. PPR ECSM LDD OR+1 SET WORD COUNT SHN -6 ADN 1 STD WC LDD OR+3 SET SUBFUNCTION SHN -11 STD T8 LDM TECSM,T8 STD T9 LJM 0,T9 ENTER PROCESSOR MXECSM EQU 10 MAXIMUM NUMBER OF *ECSM* SUBFUNCTIONS SPACE 4,10 *** RRES-WRES - READ/WRITE RELATIVE USER EXTENDED MEMORY. * * THESE SUBFUNCTIONS ARE NOT LEGAL FOR A MULTI-MAINFRAME * LINK DEVICE WITH NO CPU PORT. *HNG SUBFUN ECSM,(RRES,WRES) INVALID FUNCTION WHEN NO CPU PATH SPACE 4,20 *** RECS-WECS - READ/WRITE ABSOLUTE SYSTEM EXTENDED MEMORY. * * ENTRY *T, OR 12/ ECSM,6/ WC,18/ CMA,3/ SF,21/ ECA * WC NUMBER OF WORDS TO TRANSFER - 1. * WC = 0 TRANSFER 1 WORD. * WC = 1 TRANSFER 2 WORDS. * . * . * WC = 77B TRANSFER 100B WORDS. * CMA RELATIVE+400000B OR ABSOLUTE CM ADDRESS OF BUFFER. * SF *RECS* OR *WECS* SUBFUNCTION CODE. * ECA ABSOLUTE SYSTEM EXTENDED MEMORY ADDRESS OF TRANSFER. * * EXIT *T, OR 12/ 0,12/ ST,12/,24/ ECD * ST 0 FOR TRANSFER COMPLETE. * 7777 FOR TRANSFER ABORTED. * ECD ABSOLUTE SYSTEM EXTENDED MEMORY ADDRESS WHERE ERROR * OCCURRED IF ABORTED. RWE SUBFUN ECSM,(RECS,WECS) LDD OR+3 LPC 777 SET EXTENDED MEMORY ADDRESS STD EA LDD OR+4 STD EA+1 LCN RECS ERRNZ WECS-RECS-1 CODE DEPENDS ON VALUE OF TAG RAD T8 (T8) = 0 IF READ, = 1 IF WRITE NJN RWE1 IF WRITE REQUEST READEM *,TBUF READ EXTENDED MEMORY WORDS STD T2 RWE1 LDD OR+1 GET ABSOLUTE CM ADDRESS LPN 77 SHN 14 PJN RWE2 IF ABSOLUTE CM ADDRESS LDD RQ READ CONTROL POINT SBD OF SHN PPXES-PPCES TADC ACPP,PPX CRD FS READ ASSIGNED CP ADDRESS LDD FS+4 RWEA ADN FLSW * ADN FLSW+1 (CME PRESENT) CRD CM LRD CM+1 LDD OR+1 SET ABSOLUTE ADDRESS LPN 37 SHN 6 ADD CM+3 SHN 6 RWE2 ADD OR+2 LJM TRWE,T8 ENTER PROCESSOR TRWE UJN RWE4 READ * UJN RWE3 WRITE RWE3 CRM TBUF,WC WRITEM *,TBUF WRITE DATA TO EXTENDED MEMORY UJN RWE5 STORE STATUS AND EXIT RWE4 CWM TBUF,WC LDD T2 RWE5 STD OR+1 LJM FNC COMPLETE FUNCTION SPACE 4,15 *** SFRS-CFRS - SET/CLEAR FLAG REGISTER BITS. * * *SFRS* IS THE TEST AND SET FLAG REGISTER FUNCTION. * *CFRS* IS THE UNCONDITIONAL CLEAR FLAG REGISTER FUNCTION. * * ENTRY *T, OR 12/ ECSM,6/ ECB,18/,3/ SF,21/ * ECB FLAG REGISTER BIT NUMBER TO SET/CLEAR. * SF *SFRS* OR *CFRS* SUBFUNCTION CODE. * * EXIT *T, OR 12/ 0,12/ ST,12/,12/,12/ * ST 0 IF FUNCTION COMPLETED. * ST 7777 IF *SFRS* FUNCTION PERFORMED ON A BIT WHICH WAS * ALREADY SET. SFR SUBFUN ECSM,(CFRS,SFRS) LDN FRET-1 SET FLAG BIT OWNER ADDRESS ADD WC RJM SLA SET ADDRESS IN LABEL TRACK LDN 1 SET WORD COUNT STD WC LDD T8 LMN SFRS ZJN SFR1 IF SET FUNCTION WRITEM *,ZR CLEAR FLAG BIT OWNER SFR1 LDD OR+1 SET FLAG BIT SHN -6 ADD TH STM SFRA LDN 1 SFRA SHN ** STD FN+1 SHN -14 ADM TSFR,T8 STD FN LDN FN RJM IFR ISSUE FLAG REGISTER REQUEST STD OR+1 NJN SFR2 IF INTERLOCK NOT GAINED LDD T8 LMN SFRS NJN SFR2 IF NOT SET FUNCTION WRITEM *,MI+1-4 SET FLAG BIT OWNER SFR2 LJM FNC COMPLETE FUNCTION TSFR EQU *-SFRS TABLE OF FLAG REGISTER FUNCTIONS LOC SFRS SFRS CON 4000 CFRS CON 7000 LOC *O SPACE 4,35 *** PELS - PROCESS EXTENDED MEMORY ACCORDING TO LIST. * * ENTRY *T, OR 12/ ECSM,6/ WC,18/ CML,3/ SF,1/W,1/U,19/ * WC NUMBER OF LIST ENTRIES TO PROCESS. * CML ABSOLUTE CM FWA OF LIST. * SF *PELS* SUBFUNCTION CODE. * W SET IF LIST OF WORDS TO BE WRITTEN. * CLEAR IF LIST OF WORDS TO BE READ. * U SET IF LIST CONTAINS ABSOLUTE USER EXTENDED MEMORY * ADDRESSES. * CLEAR IF LIST CONTAINS ABSOLUTE SYSTEM EXTENDED MEMORY * ADDRESSES. * *T,CML 12/0,6/ CT,18/0,24/ EM * CT WORD COUNT TO TRANSFER (MAXIMUM OF 60D). * EM ABSOLUTE SYSTEM OR USER EXTENDED MEMORY ADDRESS. * * THE LIST OF EXTENDED MEMORY DATA WORDS IMMEDIATELY FOLLOW THE * LIST OF EXTENDED MEMORY ADDRESSES. DATA IS WRITTEN FROM THIS * BUFFER OR READ TO THIS BUFFER. * * EXIT *T, OR 12/ 0,12/ ST,36/ 0 * ST 0 FOR TRANSFER COMPLETE. * 7777 FOR TRANSFER ABORTED. * *T, CML 60/ EF * EF ERROR FLAGS INDICATING WORDS ON WHICH * ERROR OCCURRED IF TRANSFER ABORTED. * BIT 0 SET = ERROR OCCURRED ON WORD * AT *EM* + 0. * ... * BIT *CT* - 1 SET = ERROR OCCURRED ON WORD * AT *EM* + *CT* - 1. PEL SUBFUN ECSM,PELS * TEST FLAG BITS TO UPDATE *EFRL* STATUS. LDK EFRL SET FLAG REGISTER STATUS CRD FN LDN 0 STD FN+3 STD FN+4 LDD TH ERRNZ SHNI-1000 CODE DEPENDS ON VALUE OF TAG STM PELA PEL1 LDN 1 TEST FLAG BIT PELA SHN ** STD EA+1 SHN -14 ADC 6000 STD EA AOM PELA LPN 77 LMN 23 ZJN PEL2 IF END OF BITS TO CHECK LDN EA RJM IFR ZJN PEL1 IF BIT NOT SET LDD EA LPN 77 RAD FN+3 LDD EA+1 RAD FN+4 UJN PEL1 CHECK NEXT BIT PEL2 LDK EFRL WRITE UPDATED FLAG REGISTER CWD FN LDN 0 STD T9 SET RELATIVE LIST ADDRESS SOD WC SET WORD COUNT OF LIST STD T8 STD T3 SET DATA ADDRESS IN LIST PEL3 LDD OR+1 READ LIST ENTRY LPN 77 SHN 14 ADD OR+2 ADD T9 CRD FN LDD FN+1 SET WORD COUNT SHN -6 STD WC LDD FN+3 SET EM ADDRESS STD EA LDD FN+4 STD EA+1 LDD OR+3 SHN 21-10 PJN PEL4 IF READ LDD OR+1 READ DATA TO WRITE LPN 77 SHN 14 ADD OR+2 ADD T3 CRM TBUF,WC WRITEM *,TBUF WRITE DATA UJN PEL5 CONTINUE PEL4 READEM *,TBUF READ DATA STD FN+4 LDD OR+1 WRITE DATA TO CM LPN 77 SHN 14 ADD OR+2 ADD T3 CWM TBUF,WC PEL5 LDD OR+1 RETURN STATUS LPN 77 SHN 14 ADD OR+2 ADD T9 CWD FN LDD WC ADVANCE TOTAL WORD COUNT RAD T3 AOD T9 LMD T8 NJP PEL3 IF NOT END OF LIST LJM FNC COMPLETE FUNCTION TECSM SPACE 4,10 ** TECSM - TABLE OF *ECSM* SUBFUNCTION PROCESSOR ADDRESSES. * * INDEXED BY SUBFUNCTION. * 12/ PROCESSOR ADDRESS TECSM BSS 0 DUP MXECSM,1 CON HNG LIST G TECSM HERE LIST * ORG TECSM+MXECSM TITLE *MTEM* MONITOR FUNCTION PROCESSING. MTEM SPACE 4,10 *** MTEM - *MTE* REQUESTS FOR SHARED BUFFERED DEVICES. PPR MTEM LDM TMTEM,OR+1 CHECK SUBFUNCTION STD T9 LJM 0,T9 ENTER PROCESSOR CBT SPACE 4,10 *** CBRS-CBWS - CLEAR BAT READ/WRITE ACCESS. * * ENTRY *T, OR 12/ MTEM,12/ SF,12/ MI,12/ 0,12/ EQ * SF *CBRS*/*CBWS* SUBFUNCTION. * MI MACHINE INDEX FOR THE MAINFRAME BEING RECOVERED. * EQ EST ORDINAL FOR THE DEVICE BEING RECOVERED. * * EXIT *T, OR 12/ 0,48/ UNCHANGED CBT SUBFUN MTEM,(CBRS,CBWS) LDM TMMK-1,OR+2 GET MACHINE MASK SHN 4 STM CBTB SET WRITE BIT MASK STD T3 SHN 4 STD T2 READ BIT LDD OR+1 ERRNZ CBRS ZJN CBT1 IF TO CLEAR READ ACCESS (*CBRS*) LDD T3 CBT1 ADD T2 LMC 7777 STM CBTA SET MASK TO CLEAR READ OR R/W BITS LDD TH SET BAT LENGTH STD T8 RJM GBI SET *BATI* INTERLOCK MJP FNR IF UNABLE TO SET LOCK LDD OR+4 RJM GBA GET BAT ADDRESS CBT2 LDK BRTL SET WORD COUNT FOR FULL BUFFER STD WC SHN 2 ADD WC STD T9 BYTES TO PROCESS READEM *,TBUF,CBT5 READ BAT CBT3 SOD T9 MJN CBT4 IF DONE PROCESSING THIS BUFFER LDM TBUF,T9 STD T2 SAVE ORIGINAL VALUE LPC ** CBTA EQU *-1 STM TBUF,T9 LDD OR+1 ZJN CBT3 IF TO CLEAR READ ACCESS LDD T2 CHECK ORIGINAL VALUE LPC ** (MASK IS ONLY THE WRITE BIT FOR THIS M/F) CBTB EQU *-1 ZJN CBT3 IF WRITE BIT FOR THIS M/F NOT SET LDM TBUF,T9 SCN 10 CLEAR *URW* BIT STM TBUF,T9 UJN CBT3 CHECK NEXT BYTE CBT4 WRITEM *,TBUF REWRITE BAT LDD T8 SBD WC ZJN CBT5 IF NO MORE TO PROCESS STD T8 LDD WC ADVANCE EM ADDRESS RAD EA+1 SHN -14 RAD EA UJP CBT2 PROCESS NEXT BUFFER OF BAT DATA CBT5 RJM CBI CLEAR *BATI* INTERLOCK CBT6 LJM FNC SET FUNCTION COMPLETE EBR SPACE 4,10 *** EBRS - ENABLE BRT PROCESSING. * * ENTRY *T, OR 12/ MTEM,12/ *EBRS*,12/ 0,12/ BD,12/ BT * BD TRACK NUMBER OF BDT IN EXTENDED MEMORY. * BT TRACK NUMBER OF BRT IN EXTENDED MEMORY. * * EXIT *T, OR 12/ 0,48/ UNCHANGED EBR SUBFUN MTEM,EBRS LDD OR+4 STM BRTP RJM SEA SET ESM ADDRESS OF BRT RAM CBAA+1 SHN -14 RAM CBAA LDD OR+3 RJM SEA SET ESM ADDRESS OF BDT RAM CBDA+1 SHN -14 RAM CBDA RJM CSZ CREATE SECTOR OF ZERO WORDS LDN 1 START AT FIRST BRT RJM CBA EBRA LDC 20 NUMBER OF SECTORS/TRACK RJM CET CLEAR BRT TRACK RJM CBD EBRB LDC 20 NUMBER OF SECTORS/TRACK RJM CET CLEAR BDT TRACK UJP CBT6 COMPLETE FUNCTION CEM SPACE 4,10 *** CEMS - CLEAR EXTENDED MEMORY TRACK. * * ENTRY *T, OR 12/ MTEM,12/ *CEMS*,12/ FS,12/ NS,12/ TK * FS FIRST SECTOR TO CLEAR. * NS NUMBER OF SECTORS TO CLEAR. * TK EXTENDED MEMORY TRACK TO CLEAR. * * EXIT *T, OR 12/ 0,48/ UNCHANGED CEM SUBFUN MTEM,CEMS RJM CSZ CREATE SECTOR OF ZERO WORDS LDD OR+4 RJM SEA SET ESM ADDRESS OF TRACK STD EA+1 SET ESM ADDRESS SHN -14 STD EA LDD OR+2 FIRST SECTOR TO CLEAR SHN 6 RAD EA+1 SHN -14 RAD EA LDD OR+3 NUMBER OF SECTORS TO CLEAR RJM CET CLEAR ESM TRACK LJM FNC COMPLETE FUNCTION SEP SPACE 4,15 *** SEPS-CEPS - SET/CLEAR *DAS* ERROR PROCESSING INTERLOCK. * * ENTRY *T, OR 12/ MTEM,12/ SF,24/ 0,12/ EQ * SF *SEPS*/*CEPS* SUBFUNCTION CODE. * EQ EST ORDINAL OF DEVICE TO BE PROCESSED. * * EXIT *T, OR 12/ 0,36/ UNCHANGED,12/ ST * ST STATUS = 0, IF SUCCESSFUL. * = 1, IF REJECT. SEP SUBFUN MTEM,(SEPS,CEPS) SFLAG BDTI,FNR SET *BDTI* INTERLOCK LDD OR+1 LMN CEPS ZJN SEP1 IF CLEAR INTERLOCK SUBFUNCTION LDC TBDRI CHECK *BDRI* INTERLOCK RJM IFR NJN SEP4 IF *BDRI* SET SEP1 RJM RBD READ *BDT* ENTRY LDD OR+1 LMN CEPS ZJN SEP3 IF CLEAR INTERLOCK SUBFUNCTION LDD FN CHECK ERROR PROCESSING INTERLOCK NJN SEP4 IF INTERLOCK CURRENTLY SET LDD FN+1 CHECK RESTORE INTERLOCK ZJN SEP2 IF INTERLOCK NOT SET TLMC 4000,MI NJN SEP4 IF RESTORE IN PROGRESS ON ANOTHER MF SEP2 TLDC 4000,MI SET ERROR PROCESSING INTERLOCK SEP3 STD FN WRITEM 1,FN UPDATE BDT ENTRY LDN 0 UJN SEP5 SET SUCCESSFUL REPLY SEP4 LDN 1 SET REJECT REPLY SEP5 STD OR+4 RJM CBJ CLEAR *BDTI* INTERLOCK LJM FNC COMPLETE FUNCTION SRI SPACE 4,15 *** SRIS - SET RECOVERY ERROR PROCESSING INTERLOCK. * * ENTRY *T, OR 12/ MTEM,12/ *SRIS*,36/ 0 * * EXIT *T, OR 12/ 0,36/ UNCHANGED,12/ ST * ST STATUS = 0, IF SUCCESSFUL. * = 1, IF INCOMPLETE (*BDRI* SET, BUT SOME * CONFLICTING *BDT* INTERLOCKS ARE SET). * = 2, IF REJECT. SRI SUBFUN MTEM,SRIS LDM BRTP ZJP SRI3 IF BRT PROCESSING NOT ENABLED SFLAG BDTI,FNR SET *BDTI* INTERLOCK SFLAG BDRI,SRI2 SET *BDRI* INTERLOCK RJM CBJ CLEAR *BDTI* INTERLOCK SRI1 RJM CCI CHECK FOR CONFLICTING INTERLOCKS ZJN SRI4 IF NO CONFLICTING INTERLOCKS SET LDN 1 SET *INCOMPLETE* STATUS UJN SRI4 COMPLETE FUNCTION SRI2 RJM CBJ CLEAR *BDTI* INTERLOCK SRI3 LDN 2 SET REJECT REPLY SRI4 STD OR+4 SRI5 LJM FNC COMPLETE FUNCTION CRI SPACE 4,10 *** CRIS - CLEAR RECOVERY ERROR PROCESSING INTERLOCK. * * ENTRY *T, OR 12/ MTEM,12/ *CRIS*,36/ 0 * * EXIT *T, OR 12/ 0,48/ UNCHANGED CRI SUBFUN MTEM,CRIS CFLAG BDRI CLEAR *BDRI* INTERLOCK UJP SRI5 COMPLETE FUNCTION GRI SPACE 4,10 *** GRIS - SET RECOVERY INTERLOCK STATUS. * * ENTRY *T, OR 12/ MTEM,12/ *GRIS*,36/ 0 * * EXIT *T, OR 12/ 0,36/ UNCHANGED,12/ ST * ST STATUS = 0, IF NO CONFLICTING INTERLOCKS ARE SET. * = 1, IF CONFLICTING INTERLOCKS ARE STILL SET. GRI SUBFUN MTEM,GRIS UJP SRI1 CHECK FOR CONFLICTING INTERLOCKS RBP SPACE 4,10 *** RBPS - RELEASE BAT ACCESS PERMISSIONS FOR DEVICE. * * ENTRY *T, OR 12/ MTEM,12/ *RBPS*,24/ 0,12/ EQ * EQ EST ORDINAL FOR THE DEVICE. * * EXIT *T, OR 12/ 0,36/ UNCHANGED,12/ ST * ST STATUS = 0, IF ALL PERMISSIONS RELEASED. * = ERROR COUNT, IF NOT ALL PERMISSIONS RELEASED. RBP SUBFUN MTEM,RBPS LDD OR+4 SET EST ORDINAL STD FN SFA EST CRD CM LDD CM+4 SHN 3 ADK TDGL GET NUMBER OF TRACKS CRD CM LDD CM STD FN+3 LDN 0 SET INITIAL TRACK NUMBER STD FN+1 STD T8 CLEAR ERROR FLAG LDC 4000 SET WRITE MODE REQUESTED FLAG STD FN+2 RBP1 RJM RBW READ BAT WORD (NO INTERLOCK) LDI T6 CHECK CURRENT ACCESS TLPC 0,RWM (MASK IS R/W BITS FOR THIS MACHINE) ZJN RBP3 IF THIS MACHINE HAS NO ACCESS LDN BMTR TERMINATE READ AND WRITE ACCESS SHN 6 RJM IBF ISSUE *BFMM* LDD CM+4 CHECK REPLY NJN RBP2 IF NOT SUCCESSFUL STM UBAA RJM UBA UPDATE BAT ACCESS PJN RBP3 IF BAT UPDATED SUCCESSFULLY RBP2 AOD T8 INCREMENT ERROR COUNT RBP3 AOD FN+1 INCREMENT TRACK NUMBER LMD FN+3 NJN RBP1 IF MORE TRACKS TO PROCESS LDD T8 RETURN ERROR COUNT STD OR+4 LJM FNC SET FUNCTION COMPLETE SRP SPACE 4,15 *** SRPS-CRPS - SET/CLEAR RESTORE PARITY INTERLOCK. * * ENTRY *T, OR 12/ MTEM,12/ SF,24/ 0,12/ EQ *T, MB 24/ ,36/ CID * SF *SRPS*/*CRPS* SUBFUNCTION CODE. * EQ EST ORDINAL OF DEVICE. * CID SERIAL NUMBER OF CONTROLLER DOING RESTORE (*SRPS*). * * EXIT *T, OR 12/ 0,36/ UNCHANGED,12/ ST * ST STATUS = 0, IF SUCCESSFUL (*SRPS*). * = 1, IF REJECT (*SRPS*). * * NOTE - THE CALLER MUST SET ERROR PROCESSING ON THE DEVICE * (VIA *MTEM*/*SEPS*) BEFORE CALLING *MTEM*/*SRPS*. SRP SUBFUN MTEM,(SRPS,CRPS) SFLAG BDTI,FNR SET *BDTI* INTERLOCK RJM RBD READ *BDT* ENTRY LDN ZERL CRD CM LDD OR+1 LMN CRPS ZJN SRP1 IF CLEAR RESTORE INTERLOCK SUBFUNCTION LDD FN+1 CHECK RESTORE INTERLOCK NJN SRP2 IF INTERLOCK ALREADY SET LDD RQ READ MESSAGE BUFFER ADN 1 CRD CM TLDC 4000,MI SET RESTORE INTERLOCK AND MID SRP1 STD FN+1 SET/CLEAR INTERLOCK LDD CM+2 SET/CLEAR CONTROLLER ID STD FN+2 LDD CM+3 STD FN+3 LDD CM+4 STD FN+4 WRITEM 1,FN UPDATE BDT ENTRY LDN 0 UJN SRP3 SET SUCCESSFUL REPLY SRP2 LDN 1 SET REJECT REPLY SRP3 STD OR+4 RJM CBJ CLEAR *BDTI* INTERLOCK LJM FNC COMPLETE FUNCTION GBD SPACE 4,15 *** GBDS - GET *BDT* ENTRY. * * ENTRY *T, OR 12/ MTEM,12/ GBDS,24/ 0,12/ EQ * EQ EST ORDINAL OF DEVICE. * * EXIT *T, OR 12/ 0,48/ UNCHANGED *T, MB 60/ BDT * BDT *BDT* ENTRY FOR SPECIFIED DEVICE. GBD SUBFUN MTEM,GBDS RJM RBD READ *BDT* ENTRY LDD RQ RETURN *BDT* ENTRY TO MESSAGE BUFFER ADN 1 CWD FN LJM FNC COMPLETE FUNCTION TMTEM SPACE 4,10 ** TMTEM - TABLE OF *MTEM* SUBFUNCTION PROCESSOR ADDRESSES. * * INDEXED BY SUBFUNCTION. * 12/ PROCESSOR ADDRESS TMTEM BSS 0 DUP MXMTEM,1 CON HNG LIST G TMTEM HERE LIST * ORG TMTEM+MXMTEM TITLE OTHER MONITOR FUNCTION PROCESSORS. DLKM SPACE 4,10 *** DLKM - DELINK TRACKS. * * ENTRY *T, OR 12/ DLKM,12/ EQ,36/ * EQ EST ORDINAL * * EXIT. *T, OR 60/ UNCHANGED * THE REQUEST IS PASSED TO *CPUMTR* AFTER THE MST/TRT * INTERLOCK IS GAINED. PPR DLKM,SDI DTKM SPACE 4,10 *** DTKM - DROP TRACKS. * * ENTRY *T, OR 12/ DTKM,12/ EQ,36/ * EQ EST ORDINAL * * EXIT *T, OR 60/ UNCHANGED * THE REQUEST IS PASSED TO *CPUMTR* AFTER THE MST/TRT * INTERLOCK IS GAINED. PPR DTKM,SDI RTCM SPACE 4,15 *** RTCM - REQUEST TRACK CHAIN. * * ENTRY *T, OR 12/ RTCM, 1/C, 2/, 9/ EQ, 12/ TK, 24/ * C SET CHECKPOINT UPON FUNCTION COMPLETION. * EQ EST ORDINAL. * IF EQ IS ZERO TK BYTE CONTAINS SELECTION PARAMETER. * * EXIT *T, OR 60/ UNCHANGED. * THE REQUEST IS PASSED TO *CPUMTR* AFTER THE MST/TRT * INTERLOCK IS GAINED. PPR RTCM,SDI STBM SPACE 4,15 *** STBM - SET TRACK BIT. * * ENTRY *T, OR 12/ STBM,1/C,1/,10/ EQ,12/ PM,12/ SF,12/ * * C IF C = 1 SET CHECKPOINT BIT. * EQ EQUIPMENT. * PM PARAMETER WHOSE USE DEPENDS ON THE SUBFUNCTION * BEING PERFORMED. * SF SUBFUNCTION CODE. * * EXIT *T, OR 60/ UNCHANGED. * THE REQUEST IS PASSED TO *CPUMTR* AFTER THE MST/TRT * INTERLOCK IS GAINED. PPR STBM,SDI VMSM SPACE 4,10 *** VMSM - VALIDATE MASS STORAGE. * * ENTRY *T, OR 12/ VMSM,12/ EQ,36/ * EQ EST ORDINAL TO PROCESS. * * REPLY *T, OR 60/ UNCHANGED. * THE REQUEST IS PASSED TO *CPUMTR* AFTER THE MST/TRT * INTERLOCK IS GAINED. PPR VMSM,SDI TITLE SUBROUTINES. TMMK SPACE 4,10 ** TMMK - TABLE OF MACHINE MASKS. * * INDEXED BY MACHINE INDEX. * 12/ MACHINE MASK TMMK BSS 0 .1 SET 1 DUP MXMF,2 CON .1 .1 SET .1+.1 TCLK SPACE 4,10 ** TCLK - TABLE OF MACHINE CLOCK VALUES. * * INDEXED BY MACHINE INDEX. * 12/ LAST CLOCK VALUE TCLK BSS 0 DUP MXMF,1 CON 0 TSTA SPACE 4,10 ** TSTA - TABLE OF MACHINE STATES. * * INDEXED BY MACHINE INDEX. * 12/ MACHINE STATE TSTA BSS 0 DUP MXMF,1 CON MFDN AEB SPACE 4,15 ** AEB - ADD ENTRY TO BRT. * * ENTRY (FN - FN+4) = *MTBT* ENTRY (BYTE 2 UPDATED TO INCLUDE * MASKS OF MACHINES WITH CONFLICTING ACCESS). * (BRTB - BRTB+400) = CURRENT BRT. * * EXIT BRT UPDATED IN PP MEMORY (NEW ENTRY AND HEADER). * (BRTT) INCREMENTED. * (BRTF) SET IF BRT BECOMES FULL. * * USES T1, T2, CM - CM+4, FN - FN+4. * * NOTE - ASSUMES THE BRT IS NOT FULL ON ENTRY. AEB SUBR ENTRY/EXIT AOM BRTB INCREMENT ENTRY COUNT IN HEADER WORD STD T2 LDD FN SET EM ADDRESS OF MST INTO BRT ENTRY SFA EST ADK EQDE CRD CM LDD CM+4 SHN 3 ADK SDGL CRD CM LDD CM STD FN+3 LDD CM+1 STD FN+4 LDN MXMF-1 UPDATE HEADER STD T1 AEB1 LDM TMMK,T1 CHECK FOR MACHINE MASK N STM AEBA LDD FN+2 LPC ** AEBA EQU *-1 ZJN AEB2 IF MACHINE MASK NOT SET LDD T2 STM BRTB+1,T1 SET LAST ENTRY TO LOOK AT FOR M/F N AEB2 SOD T1 PJN AEB1 IF MORE MACHINES TO CHECK LDD T2 FORM ADDRESS OF NEW ENTRY TO ADD SHN 2 ADD T2 ADC BRTB STM AEBB LDD MA ADD NEW ENTRY CWD FN CRM **,ON AEBB EQU *-1 AOM BRTT UPDATE COUNT OF BRT ENTRIES ADDED LDD T2 ADC -BRTL+1 MJN AEB3 IF BRT IS NOT FULL LDN NBRR SET BRT FULL INDICATOR STM BRTF AEB3 LJM AEBX RETURN CAM SPACE 4,15 ** CAM - CHECK FOR ACTIVE MACHINES. * * ENTRY (A) = 0. * * EXIT (A) = (T8) = MACHINES REQUIRING STATE PROCESSING. * (T9) = MACHINES ACTIVE. * * CALLS SLA. * * USES T1, T8, T9, WC. * * MACROS READEM. CAM3 LDD T8 CAM SUBR ENTRY/EXIT LDN 0 STD T8 PRESET MACHINES TO PROCESS STD T9 LDN SMET READ MACHINE CLOCKS RJM SLA SET LABEL TRACK ADDRESS READEM MXMF,TBUF,CAM3 NO STATUS OF CLOCK ON ERROR CAM1 SOD WC MJN CAM3 IF END OF MACHINES TO CHECK SHN 2 ADD WC STD T1 LDM TBUF+4,T1 SBM TCLK,WC ZJN CAM2 IF NO CHANGE IN MACHINE STATUS RAM TCLK,WC LDM TMMK,WC RAD T9 LDN MFAC CAM2 LMM TSTA,WC ZJN CAM1 IF NO STATE PROCESSING LDM TMMK,WC RAD T8 UJN CAM1 LOOP CAP SPACE 4,15 ** CAP - CHECK ACCESS PERMISSIONS. * * ENTRY SEE *RBW* EXIT CONDITIONS. * * EXIT BAT WORD REWRITTEN. * *BATI* INTERLOCK CLEARED. * (A) .LT. 0 IF REQUEST COULD NOT BE PROCESSED. * (FN+2) UPDATED TO INCLUDE MASKS OF MACHINES WITH * CONFLICTING ACCESS. * * CALLS CBI, IBF. * * USES T7, T9. * * MACROS WRITEM. CAP5 SHN -4 SAVE BAT ACCESS PERMISSIONS STD T9 RJM CBI CLEAR *BATI* INTERLOCK LDD T9 UPDATE FUNCTION REQUEST WITH MASKS LPN 17 STD T7 LDD T9 SHN -4 RAD T7 LDD FN+2 LPC 4000 PRESERVE READ/WRITE MODE BIT ADD T7 STD FN+2 LCN 0 INDICATE FUNCTION NOT PROCESSED CAP SUBR ENTRY/EXIT LDI T6 SHN 21-3 MJP CAP4 IF *URW* SET LDD FN+2 SHN -13 ZJN CAP1 IF READ ACCESS REQUESTED LDI T6 CHECK CURRENT ACCESS TLPC 0,RWMC (MASK IS ALL BITS EXCEPT R/W FOR THIS M/F) CAP0 NJN CAP5 IF ANOTHER M/F HAS READ OR WRITE ACCESS LDD T3 UJN CAP2 ADD WRITE ACCESS CAP1 LDI T6 CHECK CURRENT ACCESS LPC 360 ISOLATE WRITER TLPC 0,RWMC NJN CAP0 IF ANOTHER M/F HAS WRITE ACCESS LDI T6 CLEAR R/W BITS FOR THIS M/F TLPC 0,RWMC LMD T2 ADD READ ACCESS CAP2 STI T6 LDN 0 SET ERROR CODE CAP3 STD T9 WRITEM 1,TBUF UPDATE BAT RJM CBI CLEAR *BATI* INTERLOCK ERRNZ BMCW-BMCR-1 LDD FN+2 SET *BFMM* OPERATION CODE SHN -13 ADN BMCR SHN 6 ADD T9 ADD ERROR CODE RJM IBF ISSUE *BFMM* FUNCTION UJP CAPX RETURN CAP4 LDI T6 CLEAR *URW* BIT SCN 10 STI T6 LDN 2 SET ERROR CODE UJN CAP3 UPDATE BAT CBA SPACE 4,10 ** CBA - CALCULATE BRT ADDRESS. * * ENTRY (A) = MACHINE INDEX OF BRT TO READ. * * EXIT (WC) = WORD COUNT (LENGTH OF BRT). * (EA - EA+1) = EM ADDRESS OF BRT. CBA SUBR ENTRY/EXIT SBN 1 SHN 10 (BRT LENGTH IS 400B) CBAA ADC ** STD EA+1 SHN -14 STD EA LDC BRTL SET LENGTH OF EM TRANSFER STD WC UJN CBAX RETURN CBD SPACE 4,10 ** CBD - CALCULATE BDT ADDRESS. * * EXIT (EA - EA+1) = EM ADDRESS OF BDT. CBD SUBR ENTRY/EXIT CBDA LDC ** STD EA+1 SHN -14 STD EA UJN CBDX RETURN CBI SPACE 4,10 ** CBI - CLEAR *BATI* INTERLOCK. CBI SUBR ENTRY/EXIT CFLAG BATI UJN CBIX RETURN CBJ SPACE 4,10 ** CBJ - CLEAR *BDTI* INTERLOCK. CBJ SUBR ENTRY/EXIT CFLAG BDTI UJN CBJX RETURN CBM SPACE 4,10 ** CBM - CHECK BRT-S FROM OTHER MAINFRAMES. * * USES T8, WC, EA - EA+1, SX - SX+2, FS - FS+4. * * CALLS CBA, IBF, UBA. * * MACROS READEM. CBM SUBR ENTRY/EXIT LDM BRTP ZJN CBMX IF BRT PROCESSING NOT ENABLED TLDN 0,MI SAVE MACHINE INDEX OF THIS MAINFRAME STD T8 LDN MXMF+1 STD SX CBM1 SOD SX ZJN CBMX IF ALL BRT-S HAVE BEEN PROCESSED TLMN 0,MI ZJN CBM1 IF THIS M/F LDM TSTA-1,SX LMN MFAC NJN CBM1 IF M/F NOT CURRENTLY ACTIVE LDD SX READ BRT HEADER RJM CBA READEM 1,FS LDM FS,T8 ZJN CBM1 IF NO ENTRIES FOR THIS M/F STD SX+1 ENTRY COUNT STD WC LDC BRTB-5 STD SX+2 AOD EA+1 ADVANCE EM ADDRESS PAST HEADER SHN -14 RAD EA READEM *,BRTB,CBMX READ BRT CBM2 LDN 5 ADVANCE TO NEXT ENTRY RAD SX+2 LDM 2,SX+2 STD FN+2 TLPN 0,MM ZJP CBM3 IF MASK FOR THIS M/F NOT SET LDM 3,SX+2 EM ADDRESS OF MST SHN 14 ADM 4,SX+2 TADN DILL-LLLL,ML ADVANCE TO LOCAL WORD *DILL* STD EA+1 SHN -14 STD EA READEM 1,MBUF READ LOCAL *DILL* WORD LDM MBUF+1 SET EST ORDINAL STD FN LDM 1,SX+2 SET TRACK STD FN+1 * VERIFY THAT THIS MACHINE STILL HAS CONFLICTING ACCESS. RJM RBW READ BAT WORD (NO INTERLOCK) LDD FN+2 SHN -13 ZJN CBM2.1 IF READ ACCESS REQUESTED LDI T6 CHECK CURRENT ACCESS TLPC 0,RWM (MASK IS R/W BITS FOR THIS MACHINE) ZJN CBM3 IF THIS MACHINE HAS NO ACCESS LDN BMTR UJN CBM2.2 ISSUE *BFMM* TO RELEASE ACCESS CBM2.1 LDI T6 CHECK CURRENT ACCESS TLPC 0,WM ZJN CBM3 IF THIS MACHINE DOES NOT HAVE WRITE ACCESS LDN BMTW CBM2.2 SHN 6 SET *BFMM* OPERATION CODE RJM IBF ISSUE *BFMM* LDD CM+4 CHECK REPLY STM UBAA SHN 21-12 MJN CBM3 IF BUFFER BUSY RJM UBA UPDATE BAT ACCESS MJN CBM4 IF CANNOT GET *BATI* INTERLOCK CBM3 SOD SX+1 NJP CBM2 IF MORE ENTRIES CBM4 UJP CBM1 CHECK NEXT BRT CCI SPACE 4,10 ** CCI - CHECK FOR CONFLICTING *BDT* INTERLOCKS. * * EXIT (A) = 0, IF NO BDT INTERLOCKS ARE HELD BY OTHER MF-S. * * USES T8, FN - FN+4. * * CALLS CBD, SLA. * * MACROS READEM. CCI SUBR ENTRY/EXIT LDN DAET RJM SLA READEM 1,FN READ DAET POINTER LDD FN+4 NUMBER OF BDT ENTRIES STD WC RJM CBD SET ADDRESS OF BDT READEM *,TBUF READ BDT LDC TBUF-5 INITIALIZE SEARCH ADDRESS STD T8 CCI1 LDN 5 ADVANCE TO NEXT BDT ENTRY RAD T8 LDI T8 ZJN CCI3 IF ERROR PROCESSING INTERLOCK NOT SET TLMC 4000,MI CCI2 NJN CCIX IF INTERLOCKED BY ANOTHER M/F CCI3 LDM 1,T8 ZJN CCI4 IF *RESTORE IN PROGRESS* NOT SET TLMC 4000,MI NJN CCI2 IF RESTORE IN PROGRESS ON ANOTHER M/F CCI4 SOD FN+4 NJN CCI1 IF MORE ENTRIES TO CHECK UJP CCIX RETURN CDI SPACE 4,15 ** CDI - CLEAR DEVICE INTERLOCK. * * ENTRY (A) = (RQ) = EQUIPMENT MST ADDRESS. * (FN) = FIRST WORD OF TRT TO WRITE TO EXTENDED MEMORY. * (FN+1) = 1/F, 11/LWA + 1 TO WRITE TO EXTENDED MEMORY. * F = 1, IF TO WRITE MRT. * (FN+2) = OUTPUT REGISTER ADDRESS TO CLEAR UPPER BYTE. * * EXIT TO *CFR1*. * * USES T1, WC, EA - EA+4, OR - OR+4. * * MACROS WRITEM. CDI SHN 3 ADK TDGL READ TRT ADDRESS CRM MBUF,TR ADK SDGL-TDGL-3 CRD EA ADK TRLL-SDGL CRD OR * THE MST INTERLOCK IN CM SHOULD ALWAYS BE CLEAR WHEN * PROCESSING A CLEAR DEVICE INTERLOCK REQUEST. LDD EA+4 LPN 77 NJN * IF INTERLOCK NOT CLEAR * CHECK IF TRT WORDS UPDATED. LDD FN+1 SET WORD COUNT LPC 3777 SBD FN MJN CDI1 IF NO TRT WORDS UPDATED NJN CDI2 IF TRT WORDS TO WRITE TO EXTENDED MEMORY CDI1 LJM CDI5 SKIP TRT WRITE CDI2 STD T8 LDM MBUF+2 SBD FN SBD T8 PJN CDI3 IF NOT BEYOND MAXIMUM TRT LENGTH RAD T8 CDI3 LDD FN START OF TRT TO WRITE TO EXTENDED MEMORY ADD HN ERRNZ TRST-MSST-1 CODE DEPENDS ON VALUE OF CONSTANTS RAD EA+1 SHN -14 RAD EA LDD T8 SAVE TOTAL LENGTH TO WRITE STD T9 LDK BRTL SET DEFAULT WRITE COUNT STD WC CDI3.1 LDD T8 SBD WC PJN CDI3.2 IF FULL BUFFER RAD WC ZJN CDI3.3 IF DONE LDN 0 CDI3.2 STD T8 LDD OR+3 SET ADDRESS TO READ FROM CM SHN 14 ADD OR+4 ADD FN CRM TBUF,WC READ TRT TO PP BUFFER SBD FN STD OR+4 ADVANCE ADDRESS TO READ FROM SHN -14 STD OR+3 WRITEM *,TBUF LDD WC ADVANCE EM ADDRESS TO WRITE TO RAD EA+1 SHN -14 RAD EA UJN CDI3.1 CONTINUE WRITE LOOP * WRITE MRT TO EXTENDED MEMORY. CDI3.3 LDD FN+1 SHN 21-13 PJP CDI4 IF NO MRT UPDATE LDD RQ RESET CM/EM ADDRESSES SHN 3 ADK SDGL CRD EA ADK TRLL-SDGL CRD OR LDD FN SET FIRST MRT WORD TO WRITE SHN -3 STD T1 LDD FN SET WORD COUNT ADD T9 ADN 7 SHN -3 SBD T1 STD WC LDD OR+3 READ MRT TO BUFFER SHN 14 ADD OR+4 ADD T1 ADM MBUF+2 CRM TBUF,WC TLDC MRST*100-MSST*100-100,MIH SET MRT ADDRESS ADD T1 RAD EA+1 SHN -14 RAD EA WRITEM *,TBUF WRITE MRT CDI4 LDD RQ RESET ADDRESS OF MST SHN 3 ADK SDGL CRD EA * RELEASE MST/TRT INTERLOCK. CDI5 WRITEM SDGL+1,MBUF LDD FN+2 CLEAR OUTPUT REGISTER CRD OR LDN 0 STD OR LDD FN+2 CWD OR TLDN GLGL-LLLL,ML SET ADDRESS OF LOCAL AREA TO WRITE TO RAD EA+1 SHN -14 RAD EA LDK LLLL SET LOCAL MST LENGTH STD T1 LDD RQ READ LOCAL MST SHN 3 ADK GLGL CRM TBUF,T1 WRITEM LLLL,TBUF LJM CFR1 RETURN CET SPACE 4,10 ** CET - CLEAR EXTENDED MEMORY TRACK. * * ENTRY (A) = NUMBER OF SECTORS TO CLEAR. * (EA - EA+1) = ESM ADDRESS TO START CLEARING. * (TBUF - TBUF+505) = ZERO SECTOR BUFFER. CET SUBR ENTRY/EXIT STD T8 SAVE SECTOR COUNT LDD HN SET WORD COUNT STD WC CET1 WRITEM *,TBUF LDD WC ADVANCE TO NEXT SECTOR RAD EA+1 SHN -14 RAD EA SOD T8 NJN CET1 IF MORE SECTORS UJN CETX RETURN CFI SPACE 4,10 ** CFI - CLEAR *FATI* FLAG INTERLOCK. * * ENTRY *FATI* INTERLOCK SET. * * EXIT *FATI* INTERLOCK CLEARED. * * MACROS CFLAG, SFA. CFI SUBR ENTRY/EXIT CFLAG FATI RELEASE FAT INTERLOCK SFA FNT,OR+4 SET FNT ADDRESS UJN CFIX RETURN CSZ SPACE 4,10 ** CSZ - CREATE SECTOR OF ZERO WORDS. * * USES CM - CM+1. CSZ SUBR ENTRY/EXIT LDC TBUF SET START OF SECTOR STD CM LDC 505 SET LENGTH TO CLEAR STD CM+1 CSZ1 LDN 0 STI CM AOD CM SOD CM+1 NJN CSZ1 IF MORE TO CLEAR UJN CSZX RETURN GBA SPACE 4,10 ** GBA - GET BAT ADDRESS. * * ENTRY (A) = EST ORDINAL. * * EXIT (EA - EA+1) = EM ADDRESS OF BAT. * * USES T9, CM - CM +4, EA - EA+4. GBA SUBR ENTRY/EXIT SFA EST ADK EQDE CRD CM LDD CM+4 GET EM ADDRESS OF BAT SHN 3 ADK NVGL CRD EA-1 (THIS DESTROYS T9) UJN GBAX RETURN GBI SPACE 4,10 ** GBI - GET BATI INTERLOCK. * * EXIT (A) .LT. 0 AND (BIAA) INCREMENTED IF CANNOT GET * *BATI* INTERLOCK AFTER *NBIR* RETRIES. * * MACROS DELAY, SFLAG. GBI3 AOM BIAA INCREMENT STATISTIC LCN 0 SET FAILURE CONDITION GBI SUBR ENTRY/EXIT LDN NBIR SET MAXIMUM RETRY COUNT STM GBIA UJN GBI2 REQUEST INTERLOCK GBI1 SOM GBIA MJN GBI3 IF RETRIES EXHAUSTED DELAY GBI2 SFLAG BATI,GBI1 LDN 0 UJN GBIX RETURN GBIA CON 0 RETRY COUNT IBF SPACE 4,10 ** IBF - ISSUE *BFMM* FUNCTION. * * ENTRY (FN - FN+4) = REQUEST. * (A) = 6/ OPERATION CODE,6/ERROR CODE. * * EXIT (OR - OR+4) = *BFMM* REPLY. * * USES CM - CM+4, FS - FS+4. * * MACROS MONITOR. IBF SUBR ENTRY/EXIT STD CM+4 SET OPERATION CODE/ERROR CODE LDN ZERL CLEAR FNT ENTRY CRD FS LDD FN SET EST ORDINAL STD FS LDD FN+1 SET CURRENT TRACK STD FS+2 LDN 0 CLEAR CP STD CM+1 STD CM+2 LDD MA SET MB AS FNT ENTRY ADDRESS STD CM+3 ADN 1 CWD FS WRITE PSEUDO FNT ENTRY WORD MONITOR BFMM UJN IBFX RETURN PBR SPACE 4,15 ** PBR - PROCESS BAT REQUESTS. * * EXIT ALL ENTRIES IN *MTBT* PROCESSED. * BRT REWRITTEN TO EM AND STATISTICS UPDATED IF ANY * ENTRIES WERE ADDED. * * USES IN, OT, CM - CM+4, FS - FS+4. * * CALLS AEB, CAP, CBA, RBW. * * MACROS WRITEM. PBR3 LDM BRTT ZJN PBRX IF NO BRT ENTRIES ADDED TLDN 0,MI REWRITE BRT RJM CBA WRITEM *,BRTB LDM BRTB SET CURRENT ENTRY COUNT STM BREC PBR SUBR ENTRY/EXIT TLDC MTIN,PQ READ *MTBT* BUFFER POINTERS CRD CM ADK MTOT-MTIN CRD FS LDD CM+4 SAVE IN STD IN LDD FS+4 SAVE OUT STD OT PBR1 LDM BRTF NJN PBR3 IF BRT IS NOW FULL LDD IN SBD OT ZJN PBR3 IF BUFFER IS EMPTY TLDC MTBT,PQ READ NEXT ENTRY ADD OT CRD FN RJM GBI GET *BATI* INTERLOCK MJP PBR3 IF CANNOT GET *BATI* INTERLOCK AOM BATT INCREMENT BAT REQUEST COUNT RJM RBW READ BAT WORD RJM CAP CHECK ACCESS PERMISSIONS PJN PBR2 IF REQUEST COMPLETE RJM AEB ADD ENTRY TO BRT PBR2 TLDC MTOT,PQ UPDATE OUT POINTER CRD CM AOD OT LPN 77 STD OT STD CM+4 TLDC MTOT,PQ CWD CM UJP PBR1 CHECK NEXT BUFFER ENTRY RBD SPACE 4,15 ** RBD - READ *BDT* ENTRY. * * ENTRY (OR+4) = EST ORDINAL. * * EXIT (FN - FN+4) = *BDT* ENTRY FOR SPECIFIED DEVICE. * (EA - EA+1) = ESM ADDRESS FOR *BDT* ENTRY. * * USES CM - CM+4, EA - EA+1. * * CALLS CBD. * * MACROS READEM, SFA. RBD SUBR ENTRY/EXIT RJM CBD GET ESM ADDRESS OF BDT LDD OR+4 EST ORDINAL SFA EST ADK EQDE CRD CM LDD CM+4 READ MST DRIVER WORD SHN 3 ADK MDGL CRD CM LDD CM ISOLATE DAT INDEX LPC 377 RAD EA+1 ADVANCE TO SELECTED ENTRY SHN -14 RAD EA READEM 1,FN READ BDT ENTRY UJN RBDX RETURN RBR SPACE 4,25 ** RBR - REPROCESS BRT REQUESTS. * * ENTRY (BRTF) = *NBRR*, IF BRT IS FULL. * = 0, OTHERWISE. * * EXIT ALL BRT ENTRY REQUESTS RETRIED. * IF ANY CHANGES, BRT IS REPACKED, HEADER UPDATED, AND * THE TABLE IS REWRITTEN TO EM. * IF THE BRT WAS FULL ON ENTRY THE FIRST *NBRR* ENTRIES * ARE REJECTED BEFORE PROCESSING THE REST. * (BREC) = CURRENT BRT ENTRY COUNT. * * USES T1, T8. * * CALLS CAP, CBA, IBF, RBW, UBH. * * MACROS READEM, WRITEM. * * NOTE - THIS ROUTINE MUST ALWAYS READ THE BRT. * IF BRT PROCESSING IS DISABLED, WE ASSUME THAT ANY * REQUESTS FOR BAT ACCESS WILL BE GRANTED AND NO ENTRIES * WILL NEED TO BE ADDED TO THE BRT. RBR8 LDM RBRC ZJN RBR10 IF BRT NOT CHANGED LDM RBRB SET START OF BRT TO CLEAR STM RBRD RBR9 LDN ZERL CLEAR VACATED PORTION OF BRT CRM **,ON RBRD EQU *-1 LDN 5 RAM RBRD SBM RBRA MJN RBR9 IF MORE TO CLEAR RJM UBH UPDATE BRT HEADER LDN 0 CLEAR BRT CHANGED FLAG STM RBRC TLDN 0,MI REWRITE BRT RJM CBA WRITEM *,BRTB RBR10 LDM BRTB SET ENTRY COUNT RBR11 STM BREC RBR SUBR ENTRY/EXIT LDM BRTP ZJN RBRX IF BRT PROCESSING DISABLED TLDN 0,MI READ BRT RJM CBA READEM *,BRTB LDM BRTB CHECK BRT ENTRY COUNT ZJN RBR11 IF EMPTY STD T8 LDM BRTF INDICATE BRT FULL PROCESSING STM RBRE LDN 0 STM BRTF CLEAR BRT FULL INDICATOR LDC BRTB INITIALIZE ADDRESSES STM RBRA NEXT ENTRY TO READ ADN 5 STM RBRB NEXT ENTRY TO WRITE RBR1 LDN 5 ADVANCE TO READ NEXT ENTRY RAM RBRA SOD T8 RBR2 MJP RBR8 IF DONE LDD MA CWM **,ON RBRA EQU *-1 SBN 1 CRD FN READ NEXT BRT ENTRY LDC ** RBRE EQU *-1 NJN RBR5 IF BRT FULL PROCESSING RJM GBI GET *BATI* INTERLOCK MJN RBR2 IF CANNOT GET *BATI* INTERLOCK RJM RBW READ BAT WORD RJM CAP MJN RBR6 IF REQUEST NOT PROCESSED RBR3 SOM BRTB DECREMENT BRT ENTRY COUNT AOM RBRC INDICATE BRT CHANGED RBR4 UJN RBR1 PROCESS NEXT ENTRY RBR5 SOM RBRE ERRNZ BMCW-BMCR-1 LDD FN+2 SET *BFMM* OPERATION CODE SHN -13 ADN BMCR SHN 6 ADN 1 ADD ERROR CODE RJM IBF ISSUE *BFMM* FUNCTION AOM BRTR INCREMENT REJECTED ENTRIES UJN RBR3 CONTINUE AS IF ENTRY PROCESSED RBR6 LDM RBRA UPDATE MASKS OF MACHINES W/CONFLICTS STD T1 LDD FN+2 LMM 2,T1 ZJN RBR6.1 IF NO CHANGE IN MACHINE MASKS LDD FN+2 STM 2,T1 AOM RBRC INDICATE BRT CHANGED RBR6.1 LDM RBRB SBM RBRA ZJN RBR7 IF NO NEED TO MOVE THIS ENTRY LDD MA MOVE ENTRY CWD FN CRM **,ON RBRB EQU *-1 AOM RBRC INDICATE BRT CHANGED RBR7 LDN 5 ADVANCE ADDRESS FOR WRITE RAM RBRB UJP RBR4 PROCESS NEXT ENTRY RBRC CON 0 NON-ZERO IF BRT CHANGED RBW SPACE 4,15 ** RBW - READ BAT WORD. * * ENTRY (FN - FN+4) = REQUEST (FROM *MTBT* QUEUE OR BRT). * * EXIT (T2) = READ MASK FOR THIS M/F. * (T3) = WRITE MASK FOR THIS M/F. * (T6) = ADDRESS OF BYTE TO UPDATE. * (EA - EA+1) = EM ADDRESS OF WORD TO UPDATE. * (TBUF - TBUF+4) = BAT WORD CONTAINING BYTE TO UPDATE. * * CALLS GBA. * * MACROS READEM. RBW SUBR ENTRY/EXIT LDD FN RJM GBA GET EM ADDRESS OF BAT FOR EQUIPMENT LDD FN+1 CALCULATE OFFSET OF WORD TO READ LPC 3777 SHN -2 RAD EA+1 SHN -14 RAD EA READEM 1,TBUF READ BAT WORD TLDN 0,MM SHN 4 STD T3 WRITE MASK SHN 4 STD T2 READ MASK LDD FN+1 ISOLATE BYTE TO UPDATE LPN 3 ADC TBUF STD T6 UJP RBWX RETURN SDI SPACE 4,10 ** SDI - SET DEVICE INTERLOCK. * * ENTRY (OR - OR+4) = OUTPUT REGISTER. * * EXIT TO *FNR* IF DEVICE BUSY. * TO *CPF* IF SUCCESSFUL. * * USES WC, CM - CM+4, EA - EA+4, OR - OR+4. * * MACROS CFLAG, READED, SFA, SFLAG. SDI6 SFLAG COMI INITIATE EXTENDED MEMORY ERROR RECOVERY SDI7 CFLAG TRTI SDI8 UJP FNR QUEUE FUNCTION SDI LDD OR+1 READ EST ENTRY LPC 777 SFA EST ADK EQDE CRD FS LDD FS+4 SHN 3 ADK SDGL CRD EA LDD EA+4 LPN 76 NJP SDI8 IF FUNCTION IN PROGRESS SFLAG TRTI,SDI8 SET TRT FLAG INTERLOCK READEM SDGL+1,MBUF,SDI6 LDM MBUF+SDGL*5+4 LPN 77 SDI1 NJP SDI7 IF DEVICE INTERLOCKED LDM MBUF+SDGL*5 CHECK FOR CORRECT EXTENDED MEMORY ADDRESS LMD EA ADM MBUF+SDGL*5+1 LMD EA+1 NJN SDI1 IF BAD ADDRESS READ, LOOP TLDN 0,MI2 SET MACHINE INDEX * 2 IN EXTENDED MEMORY RAM MBUF+SDGL*5+4 LMD EA+4 SCN 77 NJN SDI2 IF READ OF MST/TRT NEEDED LDD EA+3 LMM MBUF+SDGL*5+3 NJN SDI2 IF READ OF MST/TRT NEEDED LDD EA+2 LMM MBUF+SDGL*5+2 ZJP SDI3 IF NO READ OF MST/TRT NEEDED SDI2 LDM MBUF+TDGL*5+2 SET TRT WORD COUNT STD T8 LDD HN ADVANCE TO TRT ADDRESS RAD EA+1 SHN -14 RAD EA LDD FS+4 SET CM ADDRESS SHN 3 ADK TRLL CRD FN LDK BRTL SET FULL BUFFER WRITE WORD COUNT STD WC SDI2.1 LDD T8 SBD WC PJN SDI2.2 IF FULL BUFFER TO WRITE RAD WC ZJN SDI2.3 IF DONE LDN 0 SDI2.2 STD T8 READEM *,TBUF,SDI6 READ TRT LDD FN+3 SHN 14 ADD FN+4 CWM TBUF,WC COPY TO CM STD FN+4 ADVANCE CM ADDRESS SHN -14 STD FN+3 LDD WC ADVANCE EM ADDRESS RAD EA+1 SHN -14 RAD EA UJN SDI2.1 CONTINUE COPY LOOP SDI2.3 LDD FS+4 RESET EM ADDRESS SHN 3 ADK SDGL CRD EA LDN SDGL+1 RESET MST WRITE WORD COUNT STD WC LDD HN ADVANCE UPDATE COUNTER RAM MBUF+SDGL*5+4 SHN -14 SDI3 ZJN SDI4 IF NO OVERFLOW RAM MBUF+SDGL*5+3 SHN -14 RAM MBUF+SDGL*5+2 * WRITE INTERLOCKED MST TO EXTENDED MEMORY. SDI4 WRITEM *,MBUF WRITE INTERLOCKED MST CFLAG TRTI CLEAR *TRTI* INTERLOCK LDD FS+4 WRITE MST WORDS TO CM SHN 3 ADK TDGL WRITE UPDATED MST WORDS ERRNZ SDGL-TDGL-2 CODE DEPENDS ON VALUE OF TAG CWM MBUF,TR *SDGL* MUST BE LAST WORD WRITTEN TO CM LJM CPF PASS FUNCTION TO *CPUMTR* SEA SPACE 4,10 ** SEA - SET ESM TRACK ADDRESS. * * ENTRY (A) = TRACK NUMBER IN EXTENDED MEMORY. * * EXIT (A) = ESM ADDRESS OF TRACK. * * USES T1. SEA SUBR ENTRY/EXIT LPC 3777 STD T1 SHN 6 ADD T1 (101B * TRACK) SEAA SHN 4 (2020B * TRACK) * SHN 4+EMSC SEAB ADC 20 * ADC (NUMBER OF SECTORS/TRACK) UJN SEAX RETURN SLA SPACE 4,10 ** SLA - SET LABEL ADDRESS. * * ENTRY (A) = RELATIVE ADDRESS IN *ETLT* SECTOR OF LABEL. * * EXIT (EA - EA+1) = ABSOLUTE LABEL ADDRESS. SLA SUBR ENTRY/EXIT SLAA ADC ETLT*100B * ADC ETLT*100B+(SECTORS PER TRACK) STD EA+1 SHN -14 STD EA UJN SLAX RETURN UBA SPACE 4,10 ** UBA - UPDATE BAT ACCESS. * * ENTRY (UBAA) = *BFMM* REPLY STATUS. * (FN - FN+2) = REQUEST. * * EXIT (A) .LT. 0 IF CANNOT GET *BATI* INTERLOCK. * * CALLS CBI, GBI, RBW. * * MACROS WRITEM. UBA SUBR ENTRY/EXIT RJM GBI GET *BATI* INTERLOCK MJN UBAX IF CANNOT GET *BATI* INTERLOCK RJM RBW READ BAT WORD LDC ** UBAA EQU *-1 *BFMM* REPLY STATUS SHN -7 ZJN UBA1 IF OK TO RELEASE ACCESS * IF THIS MF DOES NOT HAVE WRITE PERMISSION, HANG RATHER THAN * SETTING *URW*. LDI T6 TLPC 0,WM NJN UBA0 IF WRITE MODE ACCESS BIT SET MONITOR HNGM HANG PP UBA0 LDI T6 SET *URW* BIT SCN 10 ADN 10 STI T6 UJN UBA4 UPDATE BAT UBA1 LDD FN+2 SHN -13 ZJN UBA2 IF OTHER M/F WANTS READ ACCESS LDI T6 TLPC 0,RWMC CLEAR READ/WRITE FOR THIS M/F SCN 10 CLEAR *URW* UJN UBA3 UPDATE BAT WORD UBA2 LDI T6 TLPC 0,RWMC CLEAR READ/WRITE FOR THIS M/F LMD T2 ADD READ ACCESS UBA3 STI T6 UBA4 WRITEM 1,TBUF RJM CBI CLEAR *BATI* INTERLOCK UJP UBAX RETURN UBH SPACE 4,10 ** UBH - UPDATE BRT HEADER. * * ENTRY BRT CHANGED DURING REPROCESSING. * (RBRB) = ADDRESS+5 OF LAST BRT ENTRY. * * EXIT BRT HEADER UPDATED. * * USES T1, T8, T9. UBH SUBR ENTRY/EXIT LDN MXMF STD T1 UBH1 SOD T1 MJN UBHX IF ALL MAINFRAMES PROCESSED LDN 0 INITIALIZE HEADER BYTE FOR M/F STM BRTB+1,T1 LDM TMMK,T1 SET MACHINE MASK STM UBHA TLMN 0,MM ZJN UBH1 IF THIS MAINFRAME LDM RBRB INITIALIZE ADDRESS TO START SEARCH STD T8 LDM BRTB BRT ENTRY COUNT ADN 1 STD T9 UBH2 LCN 5 ADVANCE TO NEXT ENTRY RAD T8 SOD T9 ZJN UBH1 IF ALL ENTRIES CHECKED LDM 2,T8 LPC ** UBHA EQU *-1 ZJN UBH2 IF MASK FOR THIS M/F NOT SET LDD T9 SET HEADER ENTRY FOR THIS M/F STM BRTB+1,T1 UJP UBH1 PROCESS NEXT MAINFRAME UMS SPACE 4,10 ** UPDATE *MTE* STATISTICS. * * EXIT STATISTICAL DATA AREA UPDATED. * BRT STATISTICS COUNTERS CLEARED. * * USES CM - CM+4, FN - FN+4, FS - FS+4. UMS SUBR ENTRY/EXIT TLDC DM1S,SDA READ STATSTICS WORDS CRD CM ADK DM2S-DM1S CRD FN LDM BREC CURRENT BRT ENTRY COUNT STD CM SBD CM+1 MJN UMS1 IF NOT NEW WORST CASE RAD CM+1 UMS1 LDM BRTR BRT ENTRIES REJECTED RAD CM+2 LDM BRTT TOTAL BRT ENTRIES RAD CM+4 SHN -14 RAD CM+3 LDK RTCL CRD FS LDD FS+4 SBM CYTM PJN UMS2 IF NO OVERFLOW ADC 10000 UMS2 STD FN CURRENT CYCLE TIME RAM CYTM LDD FN SBD FN+1 MJN UMS3 IF NOT NEW WORST CASE RAD FN+1 UMS3 LDM BIAA *BATI* INTERLOCK ATTEMPTS ABANDONED RAD FN+2 LDM BATT TOTAL BAT REQUESTS RAD FN+4 SHN -14 RAD FN+3 TLDC DM1S,SDA WRITE STATISTICS WORDS CWD CM ADK DM2S-DM1S CWD FN LDN ZERL CLEAR CURRENT TOTALS CRM BRTS,ON UJP UMSX RETURN SPACE 4,10 * COMMON DECKS. FNT$ EQU 1 SELECT FNT PROCESSOR IFP$ EQU 1 SELECT REMOTE INITIALIZATION *CALL COMPGFP TITLE EXTENDED MEMORY INTERFACE ROUTINES. FUNCTION SPACE 4,15 ** FUNCTION - ISSUE EXTENDED MEMORY FUNCTION. * * THE FUNCTION MACRO ISSUES A FUNCTION TO THE ESM LOW SPEED * PORT, AS WELL AS GENERATING A REMOTE TABLE FOR THE * DETERMINATION OF THE OPERATION (READ, WRITE, FLAG) BEING * PERFORMED. * * FUNCTION CD,RTN * * ENTRY *CD* = FUNCTION CODE TO ISSUE. * *ST* = STATUS. * *RD* = READ. * *WT* = WRITE. * *RTN* = ROUTINE WHICH ISSUES FUNCTION. * * CALLS SFN. PURGMAC FUNCTION FUNCTION MACRO CD,OP LOCAL A LDN CD_FN RJM SFN A BSS 0 .SFN MICRO 1,, ".SFN"A,OP, FUNCTION ENDM .SFN MICRO 1,, INITIALIZE FUNCTION CALLER MICRO RDW SPACE 4,15 ** RDW - READ EXTENDED MEMORY WORDS. * * ENTRY (A) = BUFFER ADDRESS FOR SECTOR. * (EA - EA+1) = ADDRESS TO READ FROM. * (WC) = WORD COUNT OF TRANSFER. * * EXIT (A) .LT. 0, IF UNRECOVERABLE PARITY ERROR. * * USES BR. * * CALLS CKS. * * MACROS FUNCTION. RDW2 LDN RDFN RJM CKS CHECK STATUS RDW SUBR ENTRY/EXIT STM RDWA SAVE PP BUFFER ADDRESS FUNCTION RD,RDW ISSUE READ FUNCTION OAM EA,CH OUTPUT ADDRESS LDD WC SET BYTE COUNT TO INPUT SHN 2 ADD WC IAM *,CH RDWA EQU *-1 READ BUFFER ADDRESS STD BR SAVE BYTE COUNT DCN CH+40 UJN RDW2 CHECK STATUS WTW SPACE 4,15 ** WTW - WRITE WORDS TO EXTENDED MEMORY. * * ENTRY (A) = BYTE ADDRESS OF DATA TO WRITE. * (EA - EA+1) =ADDRESS TO READ FROM. * (WC) = WORD COUNT OF TRANSFER. * * EXIT (A) .LT. 0, IF UNRECOVERABLE PARITY ERROR. * * USES BR. * * CALLS CKS. * * MACROS FUNCTION. WTW2 LDN WTFN RJM CKS CHECK STATUS OF WRITE WTW SUBR ENTRY/EXIT STM WTWA SET BUFFER ADDRESS FUNCTION WT,WTW ISSUE WRITE FUNCTION OAM EA,CH OUTPUT ADDRESS LDD WC SET BYTE COUNT OF TRANSFER SHN 2 ADD WC OAM *,CH WTWA EQU *-1 FJM *,CH IF DATA NOT ACCEPTED STD BR SAVE BYTE COUNT DCN CH+40 UJN WTW2 CHECK STATUS IFR SPACE 4,10 ** IFR - ISSUE FLAG FUNCTION. * * ENTRY (A) = ADDRESS OF FLAG FUNCTION WORDS. * * EXIT (A) = 0, IF FLAG FUNCTION PERFORMED. * * USES ST. * * MACROS FUNCTION. IFR SUBR ENTRY/EXIT STM IFRA FUNCTION RD,IFR ISSUE READ FUNCTION OAM **,CH OUTPUT ADDRESS IFRA EQU *-1 FJM *,CH IF CHANNEL STILL FULL DCN CH+40 FUNCTION ST,IFR ISSUE STATUS FUNCTION IAN CH+40 DCN CH+40 STD ST LMN 2 UJN IFRX RETURN STATUS CKS SPACE 4,10 ** CKS - CHECK STATUS OF TRANSFER. * * ENTRY (BR) = BYTES REMAINING IN TRANSFER. * * EXIT (A) = 0, IF NO ERROR. * * MACROS EXECUTE, FUNCTION. CKS SUBR ENTRY/EXIT STM CKSA SAVE CALLER FUNCTION CKS1 FUNCTION ST,CKS ISSUE STATUS FUNCTION IAN CH+40 DCN CH+40 STD ST LMN 2 ADD BR CHECK REMAINING BYTE COUNT ZJN CKSX IF COMPLETE TRANSFER LDD ST LPN 10 NJN CKS1 IF WRITE IN PROGRESS BIT SET ERR EXECUTE 7EA PROCESS INCOMPLETE TRANSFER / STATUS ERROR CKSA CON 0 CALLER FUNCTION CODE REC SPACE 4,10 ** REC - RECOVERED ERROR PROCESSOR. * * ENTRY (RECA) = EXIT ADDRESS. * * USES RC. * * WHEN AN ESM ERROR OCCURS THE EXIT ADDRESS IS SAVED IN *RECA*, * AND THE EXIT IS REPLACED WITH A JUMP TO *REC*. THIS MAKES * IT POSSIBLE FOR *REC* TO RESET THE RETRY COUNT TO ZERO FOR * THE NEXT ERROR. REC LDC 0 GET EXIT ADDRESS RECA EQU *-1 (EXIT ADDRESS) STD T1 LDN 0 STD RC RESET RETRY COUNT STM RECA CLEAR EXIT ADDRESS LJM 0,T1 RETURN SFN SPACE 4,10 ** SFN - SELECT FUNCTION. * * ENTRY (A) = FUNCTION CODE. * * EXIT (A) = 2. * CHANNEL ACTIVATED. * TO *ERR* IF FUNCTION TIMEOUT. SFN2 LDN 2 ACN CH+40 SFN SUBR ENTRY/EXIT ADC SC FAN CH+40 SFN1 IJM SFN2,CH IF FUNCTION ACCEPTED SBN 77 PJN SFN1 IF NOT TIMED OUT UJP ERR PROCESS ERROR DSW SPACE 4,10 ** DSW - DRIVER SERVICE PROCESSING. * * ENTRY (A) = 1, RESERVE CHANNEL. * (A) = 0, RELEASE CHANNEL. * * USES T0, T1, CM - CM+4. * * MACROS MONITOR. DSW2 RAI T0 UPDATE CHANNEL INSTRUCTION AOD CM+4 DSW3 LDI CM+4 STD T0 LDD T4 DSWA SBN CH NJN DSW2 IF MORE INSTRUCTIONS TO MODIFY DSW SUBR ENTRY/EXIT STD CM+3 LMN 1 STD CM LDD MA WRITE *DSWM* PARAMETERS CWD T4 MONITOR DSWM LDD CM+4 SBD T4 ZJN DSWX IF NOT TO MODIFY INSTRUCTIONS RAD T4 LDC ADNI-1 STM MTEB DSW1 AOM MTEB LCN 5 RAD CM+4 PJN DSW1 IF NOT END OF DIVIDE ADC LDDI+CM+5 STM MTEC LDC TCHS START OF CHANNEL LIST STD CM+4 LJM DSW3 MODIFY INSTRUCTIONS SPACE 4,10 * CHANNEL TABLE. CHTL DSWA TERMINATE CHANNEL TABLE TCHS CHTB EEMI EQU * END OF EXTENDED MEMORY INTERFACE ROUTINES TITLE TABLES. TPPR SPACE 4,10 * TPPR - TABLE OF *MTE* PP REQUESTS. * * ENTRY = 1 WORD. * INDEXED BY MONITOR FUNCTION CODE. * *T, 12/ ADDR TPPR EQU *-CPUM DUP MXFNC+1-CPUM,1 CON HNG LIST G PPR HERE INSERT REQUEST PROCESSOR ADDRESSES LIST * ORG TPPR+MXFNC+1 FLAG SPACE 4,10 * FLAG BIT SET/CLEAR FUNCTIONS. SCOMI VFD 24/40000000+.COMI TCOMI VFD 24/60000000+.COMI SFATI VFD 24/40000000+.FATI CFATI VFD 24/70000000+.FATI STRTI VFD 24/40000000+.TRTI CTRTI VFD 24/70000000+.TRTI SBATI VFD 24/40000000+.BATI CBATI VFD 24/70000000+.BATI SBDTI VFD 24/40000000+.BDTI CBDTI VFD 24/70000000+.BDTI SBDRI VFD 24/40000000+.BDRI TBDRI VFD 24/60000000+.BDRI CBDRI VFD 24/70000000+.BDRI CREL STRTI,MM ADD MACHINE MASK TO *TRTI* FLAG OPERATIONS CREL CTRTI,MM LWA EQU *L MAINL EQU LWA-FWA LENGTH OF MAIN BLOCK ERRNG EPFW-* CODE OVERFLOWS INTO ERROR PROCESSOR TITLE UEM SIMULATION OF EXTENDED MEMORY. ** UEM SIMULATION OF EXTENDED MEMORY. * * THE FOLLOWING CODE OVERLAYS THE EXTENDED MEMORY INTERFACE * ROUTINES WHEN UEM IS DECLARED AS THE LINK DEVICE. THE * ENTRY POINTS *IFR*, *RDW*, *WTW*, AND *DSW* MUST BE THE SAME * IN THE OVERLAYED CODE. UEMI BSS 0 BEGINING OF UEM INTERFACE CODE OEMI EQU RDW-1 ORIGIN OF INTERFACE ROUTINES LOC OEMI QUAL UEM IFR EQU //IFR INSURE ENTRY POINTS MATCH RDW EQU //RDW WTW EQU //WTW DSW EQU //DSW RDW SPACE 4,10 ** RDW - READ UEM WORDS. * * ENTRY (A) = BUFFER ADDRESS FOR SECTOR. * (EA - EA+1) = UEM ADDRESS TO READ FROM. * (WC) = WORD COUNT OF TRANSFER. * * EXIT (A) .LT. 0, IF UNRECOVERABLE PARITY ERROR. * * CALLS SUA. BSS RDW-1-* INSURE ENTRY POINT COINCIDES RDW SUBR ENTRY/EXIT STM RDWA SAVE PP BUFFER ADDRESS RJM SUA SET ADDRESS CRM *,WC RDWA EQU *-1 READ BUFFER ADDRESS LDN 0 UJN RDWX RETURN WTW SPACE 4,10 ** WTW - WRITE WORDS TO UEM. * * ENTRY (A) = BYTE ADDRESS OF DATA TO WRITE. * (EA - EA+1) = UEM ADDRESS TO READ FROM. * (WC) = WORD COUNT OF TRANSFER. * * EXIT (A) .LT. 0, IF UNRECOVERABLE PARITY ERROR. * * CALLS SUA. BSS WTW-1-*-7 INSURE ENTRY POINT COINCIDES WTW1 STM WTWA SET BUFFER ADDRESS RJM SUA SET ADDRESS CWM *,WC WTWA EQU *-1 WRITE BUFFER ADDRESS LDN 0 WTW SUBR ENTRY/EXIT UJN WTW1 PROCESS WRITE IFR SPACE 4,10 ** IFR - SIMULATE FLAG FUNCTION FOR UEM. * * ENTRY (A) = ADDRESS OF FLAG FUNCTION WORDS. * * EXIT (A) = 0, IF FLAG FUNCTION PERFORMED. * * USES T1, CM - CM+4. BSS IFR-1-*-13 INSURE ENTRY POINT COINCIDES IFR2 LDD CM+3 CLEAR FLAG BITS IFRA SCN 0 STD CM+3 LDD CM+4 LPC 7777 IFRB EQU *-1 STD CM+4 IFR3 LDK EFRL REWRITE FLAG BITS TO CM CWD CM LDN 0 IFR SUBR ENTRY/EXIT STD T1 LDK EFRL READ CURRENT STATUS CRD CM LDI T1 SHN 21-11 MJN IFR1 IF CLEAR FUNCTION * TEST AND SET FLAG OPERATION. SHN 11-21+22 LMD CM+3 SBD CM+3 LMI T1 NJN IFRX IF BIT SET LDM 1,T1 LMD CM+4 SBD CM+4 LMM 1,T1 NJN IFRX IF BIT SET LDI T1 SHN -11 LMN 6 ZJN IFRX IF TEST FUNCTION LDI T1 SET BIT(S) IN CM WORD LPN 77 RAD CM+3 LDM 1,T1 RAD CM+4 UJP IFR3 RETURN STATUS IFR1 SHN 11-21 CLEAR FLAG BITS ADK SCNI-1000 STM IFRA LCN 0 LMM 1,T1 STM IFRB UJP IFR2 CLEAR FLAG BITS SUA SPACE 4,10 ** SUA - SET UEM ADDRESS. * * ENTRY (EA - EA-1) = UEM ADDRESS TO SET. * * EXIT (A) = 400000 + UEM ADDRESS. * R-REGISTER SET TO UEM BASE ADDRESS. * * USES CM - CM+4. SUA SUBR ENTRY/EXIT LDK UEML SET R REGISTER CRD CM LDD EA SET R-REGISTER SCN 17 SHN 3 ADD CM ADD BASE ADDRESS SHN 3 STD CM+1 SHN -14 STD CM LRD CM LDD EA SET RELATIVE ADDRESS LPN 17 ADN 40 SHN 14 ADD EA+1 UJN SUAX RETURN DSW SPACE 4,10 ** DSW - DRIVER SERVICE PROCESSING. * * USES T4. BSS DSW-1-* INSURE ENTRY POINTS COINCIDE DSW SUBR ENTRY/EXIT LDN 37 INSURE CHANNEL NUMBER IN BOUNDS STD T4 UJN DSWX RETURN QUAL * LOC *O UEMIL EQU *-UEMI LENGTH OF UEM BLOCK ERRPL *-7777 CODE EXCEEDS PP SPACE 4,10 TITLE PRESET. PRS SPACE 4,10 * PRS - PRESET TABLES AND CONSTANTS. USE PRS LDN MXQP-1 PRESET QUEUE ENTRY STD QE LDN NPPU-1 STD QH STD QT LDD OA SET MESSAGE BUFFER ADDRESS ADN 1 STD MA LDN ZERL SET ZERO WORD CRD ZR LDK PPCP CRD CM AOD CM+4 SET *MTR* OUTPUT REGISTER ADDRESS STD OF LDD CM SET EXTENDED PP COMMUNICATION AREA ADDRESS STM PPX LDD CM+1 STM PPX+1 RJM IFP INITIALIZE *COMPGFP* LDN 0 INITIALIZE DRIVER STATUS BYTES STD BR STD ST STD RC LDK CHTP SET CHANNEL INTERLOCK TABLE ADDRESS CRD CM LDD CM+3 STM MTEA+1 LDD CM+2 RAM MTEA LDK MABL READ HARDWARE OPTIONS CRD CM LDD CM+1 CHECK MAINFRAME TYPE SHN 21-13 MJN PRS1 IF NOT CM EXTENSION AOM RWEA CHANGE READ TO *FLSW*+1 PRS1 LDK MMFL SET LINK DEVICE EQUIPMENT CRD CM LDD CM+1 LPC 777 STD T5 SFA EST SET EXTENDED MEMORY EQUIPMENT TYPE CRD CM ADK EQAE-EQDE CRD FS LDD FS+2 SHN -6 LPN 3 STD CM+2 SAVE EXTENDED MEMORY SHIFT COUNT LDD CM+2 PICK UP *EMSC* ADN 5 LMN 77 RAM CLEE MODIFY *CLE* TO ROUND TO *EMBS* LDN 4 SBD CM+2 LMN 77 RAM PRSB LDC 377 PRSB SHN 0 * SHN 4-EMSC STM CLED LDD CM+2 RAM AFPA STM SEAA LDD CM+2 RAM ILDA STM PRSC STM CLEC LDN 20 MINIMUM SECTORS PER TRACK PRSC SHN 0 CALCULATE SECTORS PER TRACK * SHN EMSC STD CM+2 STM CLEB STM SEAB+1 STM EBRA+1 STM EBRB+1 RAM AFAA+1 SHN -14 RAM AFAA LDD CM+2 RAM SLAA+1 SHN -14 RAM SLAA LDD T5 SFA EST CRD CM LDD CM+4 SHN 3 ADN DILL CRD CM SBN DILL SET *AFAM* PRESET RAM AFP+1 SHN -14 RAM AFP LDD CM+3 SHN -6 LPN 7 STM PRSA LMN 4 NJN PRS3 IF NOT UEM LDC UEMIL-1 MOVE EXTENDED MEMORY SIMULATION CODE STD T1 PRS2 LDM UEMI,T1 STM OEMI,T1 SOD T1 PJN PRS2 IF MOVE NOT COMPLETE UJP PRS7 AVOID PORT PRESET PRS3 LDN CH PRESET CHANNEL NUMBER STD T4 LDN 1 RESERVE CHANNEL RJM DSW RJM SCP SET CHANNEL IN PRESET INSTRUCTIONS FNC MCFN+SC,CH MASTER CLEAR PORT LDN 40 PRS4 SBN 1 MJN PRS6 IF FUNCTION TIMED OUT AJM PRS4,CH IF CHANNEL ACTIVE LDC 0 PRSA EQU *-1 EXTENDED MEMORY TYPE SBN 5 MJN PRS7 IF NEITHER ESM NOR STORNET SBN 7-5 PJN PRS7 IF NEITHER ESM NOR STORNET FNC ESFN+SC,CH SET ECS MODE ADDRESSING LDN 40 PRS5 SBN 1 IJM PRS7,CH IF CHANNEL INACTIVE PJN PRS5 IF FUNCTION NOT TIMED OUT PRS6 LDC 200+MS2W CWM MSGA,TR *PORT PRESET FAILED ON MMF LINK.* UJN * HANG ILD SPACE 4,10 ** ILD - INITIALIZE MMF LINK DEVICE. * * ENTRY (IR+4) = RECOVERY MODE. * * EXIT TO MAIN LOOP. * * USES IR+2, RM, T1, T6, T8, CM - CM+4, EA - EA+4, * FS - FS+4, OR - OR+4 * * CALLS CAM, CIR, CLE, IBP, SIC, SLA. * * MACROS CFLAG, DELAY, ISTORE, READEM, SFLAG, WRITEM. PRS7 BSS 0 ILD LDN ZERL ZERO LABEL TRACK ADDRESS CRD EA ADK EFRL-ZERL READ LINK DEVICE PARAMETERS CRD FS CRD CM LDN 0 STD CM+3 STD CM+4 LDK EFRL CLEAR FLAG REGISTER STATUS CWD CM LDD FS+4 STD IR+2 LPN 77 STD T6 LDD FS+2 LPN 20 ZJN ILD3 IF NO INITIALIZE OF LINK DEVICE ILD1 SOD T6 COMPUTE LABEL TRACK ADDRESS MJN ILD4 IF NOT END OF MULTIPLY ILD2 LDC 2020 MINIMUM POSSIBLE WORDS PER TRACK ILDA SHN 0 CALCULATE WORDS PER TRACK * SHN EMSC RAD EA+1 SHN -14 RAD EA LDD FS+2 LPN 20 NJN ILD1 IF INITIALIZE OF LINK DEVICE * SEARCH FOR LABEL TRACK. ILD3 READEM 1,OR READ LABEL LINKAGE WORD LDD OR ADD OR+1 ADD OR+2 ADD OR+3 ADD OR+4 LMC 3777+77+2RLA+2RBE+1RL*100 ZJN ILD4 IF LABEL TRACK FOUND AOD IR+2 ADC -LTKL MJN ILD2 IF MORE TRACKS TO CHECK LDN 1 SET LABEL TRACK NOT FOUND ERROR LJM ILD18 PROCESS ERROR ILD4 LDD EA+1 INSERT LABEL ADDRESS IN *SLA* RAM SLAA+1 SHN -14 ADD EA RAM SLAA LDK DSSL CRD CM ADK MMFL-DSSL CRD OR LDD CM+4 SET RECOVERY MODE LPN 3 STD RM UJN ILD6 SET PRESET INTERLOCK ILD5 LDD FS+2 LPN 40 NJN ILD7 IF TO PRESET ILD6 SFLAG PRSI,ILD5 SET PRESET INTERLOCK ILD7 RJM CAM INITIALIZE MACHINE CLOCKS LDD FS+2 LPN 40 STD T8 ZJP ILD9 IF NO PRESET OF LINK DEVICE * PRESET PROCESSING. * CHECK FOR MACHINES ACTIVE BY STATUSING *MFET* WORDS. LDC 200+MS2W CWM MSGB,TR *CHECKING FOR ACTIVE MACHINES.* DELAY 2048D*10 TOTAL DELAY IS 2048 MILLISECONDS RJM CAM CHECK ACTIVE MACHINES LDD T9 ZJN ILD8 IF NO ACTIVE MACHINE FOUND LDN 6 MACHINE ACTIVITY PREVENTS PRESET LJM ILD18 PROCESS ERROR * THE SECTOR OF ZERO WORDS THAT BEGINS AT *TBUF* MUST NOT * EXTEND PAST HERE, SINCE *CLE* CREATES AND USES THIS BUFFER. ERRNG *-TBUF-505 ILD8 CFLAG FRGI,NW CLEAR ALL FLAG INTERLOCKS EXCEPT *PRSI* RJM CLE CLEAR EXTENDED MEMORY NJP ILD18 IF ERROR IN CLEARING MEMORY LDC 200+MS2W CWM MSGC,TR *LINK DEVICE PRESET COMPLETE.* LDN 1 LJM ILD20 SET MACHINE INDEX * PROCESS NON-PRESET DEADSTARTS. ILD9 LDN MFET PRESET STATE TABLE ADD T8 RJM SLA READEM 1,FN READ *MFET* WORD LDK EFRL GET STATE TABLE ADDRESS CRD CM LDN 0 STD FN+3 STD FN+4 LDD CM WRITE STATE TABLE WORD SHN 14 ADD CM+1 ADK MFST ADD T8 CWD FN AOD T8 LMN MXMF NJN ILD9 IF NOT END OF STATE TABLE LDD RM LMN 3 NJN ILD11 IF NOT LEVEL THREE * RECOVER *MFET* SLOT ON LEVEL THREE RECOVERY. *MFET* ENTRY IS * VERIFIED FOR CORRECT MACHINE ID, MACHINE INDEX AND THAT * *MREC* HAS NOT RUN. LDK MFET-1 ADD OR+4 RJM SLA SET ADDRESS IN LABEL TRACK READEM 1,FN LDD OR LMD FN NJN ILD10 IF NO VERIFY ON MACHINE ID LDD OR+4 LMD FN+4 ILD10 NJN ILD15 IF NO VERIFY ON MACHINE INDEX UJN ILD14 VERIFY *MREC* NOT RUN * ASSIGN OR RECOVER *MFET* SLOT. ILD11 LDN MXMF+1 PRESET MACHINE INDEX STD OR+4 LDN 0 SET EMPTY ENTRY INDEX STD T8 ILD12 SOD OR+4 ZJN ILD16 IF MORE MID-S TO CHECK ADK MFET-1 RJM SLA SET ADDRESS IN LABEL TRACK READEM 1,FN READ *MFET* WORD LDD FN NJN ILD13 IF NOT EMPTY LDD OR+4 SET EMPTY INDEX STD T8 UJN ILD12 TRY NEXT MIN ILD13 LMD OR NJN ILD12 IF NO MATCH ON MID LDD RM ZJN ILD17 IF LEVEL ZERO ILD14 LDD FN+1 NJN ILD19 IF *MREC* NOT RUN ILD15 LDN 2 *RECOVERY DEADSTART PREVENTED THIS MID.* UJN ILD18 RETURN ERROR * NO MATCHING MID FOUND IN EXTENDED MEMORY. ILD16 LDD RM NJN ILD15 IF NOT LEVEL ZERO LDD T8 STD OR+4 NJN ILD19 IF EMPTY SLOT FOUND LDN 4 *MID SPOT UNAVAILABLE.* UJN ILD18 RETURN ERROR ILD17 LDD FN+1 ZJN ILD19 IF *MREC* RUN LDN 3 *MACHINE ID IN USE.* ILD18 STD IR+2 LDD OA RETURN ERROR RESPONSE IN INPUT REGISTER SBN 1 CWD IR CFLAG PRSI UJN * HANG ILD19 RJM IBP INITIALIZE BRT/BDT PROCESSING LDD OR+4 * SET MACHINE INDEX IN *MMFL* AND IN EXTENDED MEMORY. ILD20 STD OR+4 STD T1 STM MI+1 SHN 1 STM MI2+1 SHN 5 STM MIH+1 SHN 2-6 ADD OR+4 STM MI5+1 LDM TMMK-1,OR+4 SET MACHINE MASK STD OR+3 STM MM+1 SHN 4 STM WM+1 MASK FOR WRITE BAT ACCESS BIT SHN 4 ADM WM+1 STM RWM+1 MASK FOR READ/WRITE BAT ACCESS BITS LMC 7777 STM RWMC+1 MASK FOR R/W BAT ACCESS BITS FOR OTHER MFS LDD OR+1 SHN 21-11 PJN ILD20.1 IF NO SHARED BUFFERED DEVICES PRESENT ISTORE MTED,(PSN ) ENABLE BAT/BRT CODE ILD20.1 LDK MMFL CWD OR ILD21 LDN LLLL COMPUTE MACHINE INDEX * LLLL RAM ML+1 SOD T1 NJN ILD21 IF NOT END OF MULTIPLY LDK MFET-1 SET ADDRESS IN LABEL TRACK ADD OR+4 RJM SLA WRITEM 1,OR WRITE *MMFL* WORD RJM CAM INITIALIZE MACHINE CLOCKS CFLAG PRSI CLEAR PRESET INTERLOCK LDK EFRL SET *CPUMTR* REQUEST QUEUE ADDRESS CRM PQ,ON (MUST PRECEDE READ INTO *SDA*) LDK SDAP SET STATISTICAL DATA AREA ADDRESS CRM SDA,ON LDK RTCL INITIALIZE *MTE* CYCLE TIME CRD CM LDD CM+4 STM CYTM LDC TSIC SET RELOCATION TABLE ADDRESS RJM SIC RELOCATE INSTRUCTIONS RJM CIR CLEAR INTERLOCKS ON LEVEL 3 LDD OA SIGNAL COMPLETION VIA INPUT REGISTER SBN 1 CWD IR LJM MTE ENTER MAIN LOOP CFRGI VFD 24/70777777-.PRSI SPRSI VFD 24/40000000+.PRSI CPRSI VFD 24/70000000+.PRSI IFP HERE *COMPGFP* INITIALIZATION CODE CLE SPACE 4,15 ** CLE - CLEAR EXTENDED MEMORY. * * ENTRY PRESET DEADSTART SELECTED. * (FS+2) = *EFRL* PARAMETERS. * * EXIT (A) = 0, IF NO WRITE ERROR DETECTED. * (A) = 5, IF WRITE ERRORS. * * USES WC, CM - CM+4, EA - EA+4, FN - FN+4. * * CALLS SLA. * * MACROS WRITEM. CLE4 RJM SLA CLEAR ENVIRONMENT TABLE WRITEM IBDT,TBUF ZJN CLE5 IF NO ERROR LDN 5 SET ERROR STATUS STD EA+2 CLE5 LDN 4 WRITE *IBDT* STD WC LDK DSDL+1 CRM TBUF,WC LDD FN COMPUTE LENGTH OF LINK DEVICE SHN 6 ADD FN CLEC SHN 0 TRACKS * 101B * SHN EMSC TRACKS * 101B * EMBS ADC ** ROUND UP TO NEAREST *EMBS* CLED EQU *-1 * ADC 37 EMBS = 1000 * ADC 77 EMBS = 2000 * ADC 177 EMBS = 4000 * ADC 377 EMBS = 10000 CLEE SHN 0 * SHN -5-EMSC STM TBUF+5+3 FIRST MACHINE BUFFER START ADDRESS LDN 5 START ALLOCATION FOLLOWING THIS MACHINE STD T2 CLE6 LDM TBUF+3,T2 ADM TBUF+4,T2 STM TBUF+5+3,T2 LDN 5 RAD T2 LMN 5*4 NJN CLE6 IF NOT END OF MACHINES LDN IBDT SET I/O BUFFER TABLE RJM SLA WRITEM *,TBUF WRITE BUFFER ALLOCATION TABLE ZJN CLE7 IF NO ERROR LDN 5 SET ERROR STATUS STD EA+2 CLE7 LDD EA+2 RETURN ERROR STATUS CLE SUBR ENTRY/EXIT RJM CSZ CREATE SECTOR OF ZERO WORDS SFA EST,T5 READ EXTENDED MEMORY EST ENTRY CRD CM LDD CM+4 READ EXTENDED MEMORY TRACK COUNT SHN 3 ADK TDGL CRD FN LDN ZERL CLEAR ERROR STATUS/UEM ADDRESS CRD EA LDD FS+2 LPN 20 ZJP CLE4 IF NO INITIALIZE OF LINK LDC /DSL/DSCP*CPAS+MS2W CWM MSGD,TR *CLEARING EXTENDED MEMORY.* LDC 101 SET SECTOR WORD COUNT STD WC LDD FN SET TOTAL TRACKS STD EA+4 * CLEAR EXTENDED MEMORY. CLE1 LDC ** SET SECTOR COUNT FOR TRACK CLEB EQU *-1 * LDC 20 TRACK SIZE = 20 SECTORS * LDC 40 TRACK SIZE = 40 SECTORS * LDC 100 TRACK SIZE = 100 SECTORS * LDC 200 TRACK SIZE = 200 SECTORS STD EA+3 CLE2 WRITEM *,TBUF WRITE WORDS TO UEM ZJN CLE3 IF NO ERROR LDN 5 WRITE ERROR STATUS STD EA+2 CLE3 LDD WC RAD EA+1 SHN -14 RAD EA SOD EA+3 NJN CLE2 IF MORE SECTORS SOD EA+4 NJN CLE1 IF MORE TRACKS UJP CLE5 WRITE *IBDT* CIR SPACE 4,20 ** CIR - CLEAR FLAG REGISTER AND MST INTERLOCKS ON LEVEL 3. * * ON LEVEL 3 RECOVERIES WHERE NO OTHER MACHINES ARE ACTIVE * FLAG REGISTER INTERLOCKS AND DEVICE INTERLOCKS MUST BE * CLEARED IN EXTENDED MEMORY. THESE INTERLOCKS ARE CLEARED * DURING DOWN MACHINE PROCESSING WHEN OTHER MACHINES ARE * ACTIVE. * * ENTRY (RM) = RECOVERY MODE. * * USES T8, T9, CM - CM+4, EA - EA+4, FN - FN+1. * * CALLS IFR, SFA. * * MACROS CFLAG, READEM, SFA, SFLAG, WRITEM. CIR6 CFLAG CIRI CLEAR INTERLOCK CIR SUBR ENTRY/EXIT LDD RM LMN 3 NJN CIRX IF NOT LEVEL 3 LDN 18D PRESET FLAG REGISTER BIT NUMBER STD T8 UJN CIR2 SET *CIRI* INTERLOCK CIR1 LDN FRET+CIRI CHECK IF INTERLOCKED BY THIS MACHINE RJM SLA READEM 1,FN,CIR2 LDD FN+4 TLMN 0,MI ZJN CIR3 IF INTERLOCKED BY THIS MACHINE CIR2 SFLAG CIRI,CIR1 SET FLAG INTERLOCK TO CLEAR INTERLOCKS * CHECK FLAG OWNER WORDS TO SEE IF ANY OWNED BY THIS MACHINE. CIR3 SOD T8 MJP CIR4 IF END OF FLAG BITS LMN CIRI ZJN CIR3 IF CHECKING *CIRI* BIT LDN FRET CHECK FLAG BIT ADD T8 RJM SLA READEM 1,FN,CIR3 TRY NEXT FLAG BIT ON READ ERROR LDD FN+4 TLMN 0,MI ZJN CIR3 IF NOT OWNED BY THIS MACHINE WRITEM *,ZR CLEAR FLAG OWNER LDD T8 CLEAR FLAG BIT ADD TH ERRNZ 1000-SHNI STM CIRC LDN 1 SET FLAG BIT CIRC SHN ** STD FN+1 SHN -14 ADC 7000 USE CLEAR FLAG FUNCTION STD FN LDN FN RJM IFR ISSUE FLAG FUNCTION UJP CIR3 LOOP FOR NEXT BIT CIR4 LDK ESTP SET LAST EST ORDINAL CRD CM LDD CM+3 STD T9 * CLEAR DEVICE INTERLOCKS IN EXTENDED MEMORY. CIR5 SOD T9 TRY NEXT EQUIPMENT ZJP CIR6 IF END OF EST SFA EST CRD CM LDD CM SHN 21-13 PJN CIR5 IF NOT MASS STORAGE LDD CM+4 SHN 3 ADK SDGL CRD EA LDD EA ADD EA+1 ZJN CIR5 IF NOT SHARED READEM SDGL+1,MBUF READ MST LDM MBUF+SDGL*5+4 LPN 77 SHN -1 TLMN 0,MI NJN CIR5 IF NOT INTERLOCKED BY THIS MACHINE LDM MBUF+TDGL*5+2 SET TRT LENGTH STM CIRE+1 LDD CM+4 SET MST ADDRESS STM CIRE+3 TLDC MTQP,PQ PP QUEUE POINTER ADDRESS CRD CM TLDC MTET,PQ PP QUEUE ADDRESS ADD CM+4 CWM CIRE,ON WRITE CLEAR DEVICE INTERLOCK REQUEST SOD CM+4 TLDC MTQP,PQ WRITE NEW REQUEST QUEUE POINTER CWD CM LJM CIR5 LOOP FOR NEXT DEVICE CIRE CON 0,777,4000,0,CDIF CLEAR DEVICE INTERLOCK SKELETON SCIRI VFD 24/40000000+.CIRI CCIRI VFD 24/70000000+.CIRI IBP SPACE 4,15 ** IBP - INITIALIZE BRT/BDT PROCESSING. * * ON NON-PRESET DEADSTARTS, WHEN SHARED BUFFERED DEVICES ARE * PRESENT, CLEAR THE BRT FOR THIS MACHINE AND CLEAR ANY BDT * INTERLOCKS BELONGING TO THIS MACHINE. * * USES EA, EA+1, T1, T8, FN - FN+4. * * CALLS CBA, CBD, CBJ, CSZ, SEA, SLA. * * MACROS DELAY, READEM, SFLAG, WRITEM. IBP SUBR ENTRY/EXIT LDD OR+1 SHN 21-11 PJN IBPX IF NO SHARED BUFFERED DEVICES PRESENT LDN BAET PRESET BRT ADDRESS RJM SLA READEM 1,FN LDD FN TRACK POINTER FOR BRT STM BRTP RJM SEA SET ESM ADDRESS OF BRT RAM CBAA+1 SHN -14 RAM CBAA LDD FN+1 TRACK POINTER FOR BDT RJM SEA SET ESM ADDRESS OF BDT RAM CBDA+1 SHN -14 RAM CBDA * CLEAR BRT FOR THIS MACHINE. RJM CSZ CREATE SECTOR OF ZERO WORDS LDD OR+4 RJM CBA GET ADDRESS OF BRT LDD HN STD WC LDN BRTL/100 STD T8 IBP1 WRITEM *,TBUF CLEAR BLOCK OF ESM LDD WC RAD EA+1 SHN -14 RAD EA SOD T8 NJN IBP1 IF MORE TO CLEAR * CLEAR BDT INTERLOCKS BELONGING TO THIS MACHINE. IBP2 DELAY SFLAG BDTI,IBP2 LDN DAET RJM SLA READEM 1,FN READ DAET POINTER LDD FN+4 NUMBER OF BDT ENTRIES STD WC RJM CBD SET ESM ADDRESS OF BDT READEM *,TBUF READ BDT LDC TBUF-5 INITIALIZE SEARCH ADDRESS STD T1 IBP3 LDN 5 ADVANCE TO NEXT BDT ENTRY RAD T1 LDC 4000 ADD OR+4 MACHINE INDEX LMI T1 CHECK ERROR PROCESSING INTERLOCK NJN IBP4 IF NOT INTERLOCKED BY THIS MACHINE STI T1 CLEAR ERROR PROCESSING INTERLOCK IBP4 LDC 4000 ADD OR+4 MACHINE INDEX LMM 1,T1 CHECK RESTORE PARITY INTERLOCK NJN IBP5 IF NOT INTERLOCKED BY THIS MACHINE STM 1,T1 CLEAR PARITY RESTORE INTERLOCK STM 2,T1 CLEAR CONTROLLER SERIAL NUMBER STM 3,T1 STM 4,T1 IBP5 SOD FN+4 NJN IBP3 IF MORE TO CHECK WRITEM *,TBUF UPDATE BDT RJM CBJ CLEAR *BDTI* INTERLOCK LJM IBPX RETURN TSIC SPACE 4,10 ** TSIC - INSTRUCTION RELOCATION TABLE. LIST G TSIC BSS 0 INSTRUCTION RELOCATION TABLE SIC HERE CON 0 END OF TABLE LIST * SPACE 4,10 ** INSTRUCTION MODIFICATION VALUES. * * NOTE - INSTRUCTION MODIFICATION VALUES ARE TWO BYTES. PPX CON 0,0 EXTENDED PP COMMUNICATION AREA ADDRESS MI2 CON 0,0 MACHINE INDEX * 2 MI5 CON 0,0 MACHINE INDEX * 5 ML CON 0,0 MACHINE INDEX * LLLL MIH CON 0,0 MACHINE INDEX * 100 MM CON 0,0 MACHINE MASK RWM CON 0,0 READ/WRITE MASK FOR BAT ACCESS WM CON 0,0 WRITE MASK FOR BAT ACCESS RWMC CON 0,0 COMPLEMENT OF READ/WRITE MASK PQ CON 0,0 PP REQUEST QUEUE ADDRESS SDA CON 0,0 STATISTICAL DATA AREA ADDRESS CON 0,0,0 ALLOW SPACE FOR READING INTO *SDA* SCP SPACE 4,10 ** SCP - SET CHANNEL IN PRESET INSTRUCTIONS. * * ENTRY (T4) = CHANNEL TO SET IN INSTRUCTIONS. * * USES T0. SCP SUBR ENTRY/EXIT SCP1 LDM TSCP SCPA EQU *-1 ZJN SCPX IF END OF TABLE STD T0 LDD T4 RAI T0 AOM SCPA UJN SCP1 LOOP TSCP SPACE 4,10 TSCP CHTB PRESET CHANNEL TABLE CON 0 TERMINATE TABLE * PRESET MESSAGES. MSGA DATA 30HPORT PRESET FAILED ON MMF LINK MSGB DATA C*CHECKING FOR ACTIVE MACHINES* MSGC DATA C*LINK DEVICE PRESET COMPLETE* MSGD DATA C*CLEARING EXTENDED MEMORY* SPACE 4,10 ** PRESET COMMON DECKS. *CALL COMPSIC SPACE 4,10 BSS EPFW-MAINL-* INSURE MAIN IS UP AGAINST *EPFW* ERRNG *-EBUF INSURE TRT BUFFER FITS TITLE MTE/2EA - DOWN MACHINE PROCESSING. QUAL 2EA IDENT 2EA,O2EA DOWN MACHINE PROCESSING. *COMMENT MTE - DOWN MACHINE PROCESSING. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. O2EA EQU PPFW ORG O2EA SPACE 4,20 *** 2EA - DOWN MACHINE PROCESSING. * * *2EA* IS CALLED BY *MTE* WHEN THE MACHINE CLOCK STATUS * IS INAPPROPRIATE FOR THE STATE IN *TSTA*. THIS OCCURS * WHEN A MACHINE IS DEADSTARTED OR GOES DOWN. * * *2EA* PERFORMS THE FOLLOWING MACHINE STATE PROCESSING. * * MFDN MACHINE DOWN STATE. * * FOR A MACHINE PREVIOUSLY IN A DOWN STATE, OR ANY * OTHER NON-ACTIVE STATE WHICH IS NOW ACTIVE, SET THE ACTIVE * STATE (*MFAC*) IN THE INTERNAL TABLE *TSTA* AS WELL AS THE * *MFST* TABLE POINTED TO BY *EFRL*. * * MFAC MACHINE ACTIVE STATE. * IF A MACHINE IS NO LONGER UPDATING ITS EXTENDED * MEMORY CLOCK IT IS PLACED IN THE *MFD1* STATE. * * MFD1 MACHINE SENSED DOWN ONCE. * IF A MACHINE IS NO LONGER UPDATING ITS EXTENDED * MEMORY CLOCK AND IT IN THE *MFD1* STATE, IT IS PLACED IN THE * *MFD2* STATE. * * MFD2 MACHINE SENSED DOWN TWO OR MORE TIMES. * IF A MACHINE IS NO LONGER UPDATING ITS EXTENDED * MEMORY CLOCK AND IS IN THE *MFD2* STATE, A CHECK IS MADE * TO SEE IF IT IS A LOW SPEED PORT MACHINE. IF IT IS, THE * MESSAGE * IF XX DOWN, ENTER *DOWN,MID=XX* * IS DISPLAYED AT THE SYSTEM CONTROL POINT. THIS MESSAGE * IS DISPLAYED UNTIL THE OPERATOR RESPONDS WITH THE * *DOWN,MID=XX* COMMAND, OR A *GO,SYS*. IF THE MESSAGE IS * CLEARED BY A *GO,SYS*, BUT THE MACHINE DETECTED AS DOWN IS * STILL IS NOT UPDATING ITS CLOCK, (DUE TO BEING IN STEP MODE * OR A CHANNEL IS HUNG) THE MESSAGE WILL REAPPEAR. * IF THE MACHINE IS NOT A LOW SPEED PORT MACHINE, THE STATE * WILL BE ADVANCED TO *MFDA*. * THE *DOWN,MID=XX* ADVANCES TO THE *MFDA* STATE FOR DOWN * LOW SPPED PORT MACHINES. * * MFDA MAINFRAME DOWN IS ACKNOWLEGED. * IF A MACHINE IS NO LONGER UPDATING ITS EM CLOCK * AND IS IN THE *MFDA* STATE, INTERLOCKS WHICH IT HOLDS MUST * BE RELEASED. FLAG REGISTER AND DEVICE INTERLOCKS ARE * CLEARED UNDER CONTROL OF THE *CIRI* INTERLOCK WHILE IN * THE *MFDA* STATE. WHEN THESE INTERLOCKS ARE CLEARED FOR * THE DOWN MACHINE IT ADVANCES TO THE *MFCD* STATE. * * MFCD DEVICE AND FLAG INTERLOCK CLEARING DONE. * IF A MACHINE IS NO LONGER UPDATING ITS EM CLOCK * AND IS IN THE *MFCD* STATE, *1MR* IS CALLED TO CLEAR TRACK * INTERLOCKS AND PF COUNTS. IF A PP IS AVAILABLE FOR *1MR* * THE DOWN MACHINE ADVANCES TO THE *MFMR* STATE. * * MFMR *1MR* CALLED STATE. * WHEN *1MR* COMPLETES CLEARING TRACK INTERLOCKS * AND PF COUNTS FOR THE DOWN MACHINE IT ADVANCES IT BACK * TO THE *MFDN* STATE. * * ENTRY (T8) = MACHINES REQUIRING STATE PROCESSING. * (T9) = ACTIVE MACHINE MASKS. * * USES T1, T3, FN - FN+4. * * CALLS SLA. * * MACROS READEM. PDM SUBR ENTRY/EXIT LDK EFRL SET STATE TABLE ADDRESS CRD FN LDD FN+1 RAM PDMA+1 SHN -14 ADD FN RAM PDMA LDN MXMF PRESET MACHINE INDEX STD T3 UJN PDM2 ENTER SEARCH LOOP * ADVANCE TO NEXT STATE. PDM1 AOD FN+4 SET NEW STATE STM TSTA,T3 LDM PDMA WRITE STATE ENTRY TO MFST LPN 77 SHN 14 ADM PDMA+1 ADD T3 CWD FN PDM2 SOD T3 MJN PDMX IF END OF MACHINE CHECK PDMA ADC MFST GET MAINFRAME STATE TABLE ENTRY CRD FN LDD T8 LMM TMMK,T3 SBD T8 PJN PDM2 IF NO STATE PROCESSING REQUIRED LDD T9 LMM TMMK,T3 SBD T9 PJN PDM3 IF CLOCK NOT CHANGING * SET MACHINE ACTIVE IN *MFST* AND INTERNAL TABLES. LDN MFET ADD T3 RJM SLA READEM 1,FN LDN 0 STD FN+3 LDN MFAC-1 SET ACTIVE STATE STD FN+4 UJP PDM1 STORE STATE PDM3 LDM TPDM,FN+4 SET MACHINE STATE PROCESSOR STD T1 LJM 0,T1 ENTER STATE PROCESSOR STATE SPACE 4,10 ** STATE - SET STATE PROCESSOR. * * STATE STA,PRC * * ENTRY *STA* = STATE NAME. * *PRC* = ALTERNATE PROCESSOR. * * THIS MACRO BUILDS A TABLE OF STATE PROCESSORS. * THE TABLE IS NAMED *TPDM*, AND EACH ENTRY IS THE * ADDRESS OF THE PROCESSOR FOR THE STATE. PURGMAC STATE STATE MACRO STA,PRC LOCAL A .A IFC EQ,*PRC** A MICRO 2,4, STA "A" BSS 0 .A ELSE A MICRO 1,, PRC .A ENDIF TPDM RMT ORG TPDM+STA CON "A" TPDM RMT STATE ENDM MFDN SPACE 4,10 * DOWN STATE PROCESSOR. STATE MFDN NO STATE CHANGE LDN MFDN SET STATE IN INTERNAL TABLE STM TSTA,T3 LJM PDM2 PROCESS NEXT MACHINE MFAC SPACE 4,10 * ACTIVE STATE PROCESSOR. STATE MFAC,PDM1 ADVANCE TO *MFD1* STATE MFD1 SPACE 4,10 * DOWN SENSED ONCE STATE PROCESSOR. STATE MFD1,PDM1 ADVANCE TO *MFD2* STATE MFD2 SPACE 4,10 * DOWN SENSED TWICE OR MORE STATE PROCESSOR. STATE MFD2 LDD FN+1 CHECK FOR LOW SPEED PORT MMF MACHINE SHN 21-12 PJP PDM1 IF NOT LOW SPEED PORT MMF MACHINE LDD FN SHN 6 LMN 1R STM FD2A+2 SHN 6 STM FD2A+1 LDD FN SHN 6 LMN 1R* STM FD2A+16 SCN 77 LMN 1R= SHN 6 STM FD2A+15 LDD CP ADN MS2W CWM FD2A,TR UJP PDM2 PROCESS NEXT MACHINE FD2A DATA 30HIF XX DOWN ENTER *DOWN,MID=XX* MFDA SPACE 4,10 * DOWN MACHINE ACKNOWLEGED STATE PROCESSOR. STATE MFDA LDD FN SET MACHINE ID IN MESSAGE STM FDAB+4 LDD CP ADN MS2W CWM FDAB,TR SFLAG CIRI,PDM2 OBTAIN FLAG INTERLOCK TO CLEAR INTERLOCKS LDM TMMK,T3 CHECK DOWN MACHINE HAS *TRTI* INTERLOCK STD EA+1 LDC 6000 SET TEST FLAG FUNCTION STD EA LDN EA RJM IFR ZJN FDA1 IF NOT HELD BY DOWN MACHINE LDC .TRTI RAD EA+1 LDC 7000 STD EA LDN EA CLEAR *TRTI* INTERLOCK RJM IFR * CLEAR FLAG BITS HELD BY DOWN MACHINE. FDA1 LDD TH PRESET SHIFT INSTRUCTION STM FDAA LDN 1 SET WORD COUNT FOR READEM/WRITEM STD WC LDN FRET SET FLAG OWNER ADDRESS RJM SLA FDA2 READEM *,FS SOD FS+4 LMD T3 NJN FDA3 IF INTERLOCK NOT HELD BY DOWN MACHINE LDN 1 CLEAR FLAG BIT FDAA SHN ** STD FS+1 SHN -14 ADC 7000 STD FS LDN FS RJM IFR WRITEM *,ZR FDA3 AOD EA+1 ADVANCE EXTENDED MEMORY ADDRESS SHN -14 RAD EA AOM FDAA LMC SHNI+18D NJN FDA2 IF NOT END OF FLAG BITS * CLEAR DEVICE INTERLOCKS. LDK ESTP PRESET EQUIPMENT FOR SEARCH CRD CM LDD CM+3 STD T7 FDA4 RJM SSD SEARCH FOR SHARED DEVICE ZJN FDA5 IF NO MORE DEVICES READEM SDGL+1,MBUF READ MST NJN FDA5 IF EXTENDED MEMORY ERROR LDM MBUF+SDGL*5+4 LPN 76 SHN -1 SBN 1 SBD T3 NJN FDA4 IF NOT INTERLOCKED BY DOWN MACHINE LDM MBUF+SDGL*5+4 SCN 77 STM MBUF+SDGL*5+4 WRITEM *,MBUF REWRITE MST WITH INTERLOCK CLEARED UJN FDA4 TRY NEXT DEVICE FDA5 STD T7 SAVE ADVANCE STATUS CFLAG CIRI CLEAR FLAG INTERLOCK LDD T7 ZJP PDM1 IF PROCESSING COMPLETE ADVANCE TO *MFCD* LJM PDM2 CHECK NEXT MACHINE ON PARITY ERROR FDAB DATA 30CMACHINE XX DOWN. MFCD SPACE 4,10 * *MTE* INTERLOCK CLEARING DONE STATE PROCESSOR. STATE MFCD LDK NCPL SET CONTROL POINT ADDRESS CRD CM AOD CM+1 LMC 2L R STM MFCA+1 LDD T3 SET MACHINE INDEX ADN 1 STM MFCA+4 LDN ZERL SET IMMEDIATE ASSIGNMENT CRD CM LDD MA WRITE REQUEST CWM MFCA,ON MONITOR RPPM LDD CM+1 ZJP PDM2 IF NO PP ASSIGNED UJP PDM1 ADVANCE TO *MFMR* STATE MFCA VFD 18/3L1MR,18/0,6/CDV,18/0 * *1MR* CALLED TO CLEAR TRACK INTERLOCKS STATE PROCESSOR. * NOTE - THIS STATE IS SIMPLY A WAIT FOR *1MR* TO COMPLETE. * *1MR* ADVANCES TO THE NEXT STATE. STATE MFMR,PDM2 TPDM SPACE 4,10 ** TPDM - TABLE OF STATE PROCESSOR ADDRESSES. * * INDEXED BY STATE NUMBER. * 12/ PROCESSOR ADDRESS TPDM BSS 0 DUP MFMX,1 CON HNG TPDM HERE ORG TPDM+MFMX SCIRI VFD 24/40000000+.CIRI CCIRI VFD 24/70000000+.CIRI SSD SPACE 4,15 ** SSD - SEARCH FOR SHARED DEVICE. * * ENTRY (T7) = LAST DEVICE ORDINAL FOUND. * * EXIT (T7) = SHARED DEVICE ORDINAL FOUND. * (A) = 0, IF NO DEVICE FOUND. * (EA - EA+1) = EXTENDED MEMORY MST ADDRESS OF SHARED * DEVICE. * * USES T7, CM - CM+4, EA - EA+4. * * MACROS SFA. SSD SUBR ENTRY/EXIT SSD1 SOD T7 ZJN SSDX IF END OF EST SFA EST,T7 CRD CM LDD CM SHN 21-13 PJN SSD1 IF NOT MASS STORAGE SHN 13-11 PJN SSD1 IF NOT SHARED LDD CM+4 READ EXTENDED MEMORY ADDRESS OF MST SHN 3 ADK SDGL CRD EA UJN SSDX RETURN ERRNG EBUF-* *2EA* OVERFLOW QUAL * TITLE MTE/2EB - EXTENDED MEMORY ERROR RECOVERY. IDENT 2EB,O2EB EXTENDED MEMORY ERROR RECOVERY. *COMMENT MTE - EXTENDED MEMORY ERROR RECOVERY. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. O2EB EQU PPFW ORG O2EB SPACE 4,30 *** 2EB - EXTENDED MEMORY ERROR RECOVERY. * * THERE EXIST FAILURE MODES FOR BOTH ECS AND ESM WHERE * AN ERROR IS PRESENT IN THE DATA STORED IN MEMORY BUT * NOTHING IS INHERENTLY WRONG WITH THE MEMORY. THE DATA * WORD MAY BE REWRITTEN WITH CORRECT DATA THUS ELIMINATING * THE ERROR ON FUTURE READS. THIS IS PRIMARILY A FAILURE * MODE ASSOCIATED WITH ECS WHERE A BIT VALUE READ FROM * MEMORY IS NOT DETECTED PROPERLY. DUE TO THE DESTRUCTIVE * READ THE BAD DATA IS SUBSEQUENTLY REWRITTEN. FOR ESM * CERTAIN TYPES OF DATA CORRUPTION DURING THE WRITE WILL * CAUSE THE GENERATION OF AN INVALID SECDED CODE. THIS * IS ONE WAY A HARD ERROR CAN BE DETECTED DURING A READ. * HARD READ ERRORS ON ESM ARE AN EXTREMELY RARE SITUATION. * THE ERROR RECOVERY LOGIC IMPLEMENTED IN THE FOLLOWING * CODE IS PROVIDED PRIMARILY FOR THE SUPPORT OF ECS AS * A LINK DEVICE. IT IS POSSIBLE THAT THIS LOGIC COULD * CORRECT AN ERROR IN ESM AS WELL. * * *2EB* IS CALLED BY *MTE* WHEN THE *COMI* FLAG BITS IS SET, * INDICATING EXTENDED MEMORY ERRORS WERE DETECTED BY SOME * SOME MACHINE. * * *2EB* PERFORMS THE FOLLOWING ERROR RECOVERY FUNCTIONS. * * 1. FAST ATTACH FILE PARITY ERROR PROCESSING. * FOR EACH GLOBAL FAST ATTACH FILE FOUND IN THE FNT * THE FILE NAME, LOCAL ACCESS COUNT, AND FAMILY NAME * WORDS OF THE FAT ARE GENERATED FROM INFORMATION IN * CM AND THEN WRITTEN TO EM. ALL LOCAL ACCESS COUNTS * ARE SUBSEQUENTLY READ FROM EM WHICH PROVIDES THE * INFORMATION NEEDED TO GENERATE THE GLOBAL ACCESS * COUNT WORD. ONCE GENERATED, THE GLOBAL COUNT WORD * IS WRITTEN BACK TO EM COMPLETING THE RESTORATION OF * A FAT TABLE ENTRY. * 2. MST/TRT PARITY ERROR PROCESSING. * THE ERROR RECOVERY ALGORITHM FOR MST/TRT ERROR * RECOVERY DEPENDS ON BEING ABLE TO READ THE *SDGL* * MST WORD FOR THE DEVICE. WHEN THE *SDGL* WORD READ * FROM EM INDICATES THAT THIS MACHINE HAS THE * UP-TO-DATE COPY OF THE DEVICE TABLE THESE TABLES * ARE REWRITTEN TO EM. RPE SUBR ENTRY/EXIT * ISSUE MESSAGE TO SYSTEM CONTROL POINT. LDK NCPL CRD CM AOD CM+1 SHN 7 ADN MS2W CWM RPEB,TR *MST/TRT PARITY ERROR.* * PROCESS FAST ATTACH FILES. LDN 20 SET RETRY COUNT STD EA+4 RPE1 SOD EA+4 ZJN RPEX IF UNABLE TO INTERLOCK FAT SFLAG FATI,RPE1 SET FAT INTERLOCK LDM TPPR+AFAM LMC AFP ZJP RPE8 IF *AFAM* PRESET NOT EXECUTED YET * SEARCH FNT FOR GLOBAL FAST ATTACH FILES. LDN FNTP CRD OR RPE2 LDN FNTE ADVANCE FNT ADDRESS RAD OR+1 SHN -14 RAD OR READ FST SHN 14 ADD OR+1 ADK FNTG CRD FN ADK FSTG-FNTG CRD FS SOD OR+2 MJP RPE8 IF END OF FNT LDD FN+4 SHN -6 LMN FAFT NJN RPE2 IF NOT FAST ATTACH FILE LDD FN+3 LPN 77 ZJN RPE2 IF NOT GLOBAL FAST ATTACH SHN FATS COMPUTE FAT ADDRESS ADM AFAA+1 STD EA+1 SHN -14 ADM AFAA LPN 77 STD EA LDD FS SAVE EQUIPMENT AND TRACK LPC 777 STD T7 LDD FS+1 STD T6 LDD FN+3 SET FILE NAME IN FAT WORD 0 SCN 77 STD FN+3 LDN 0 STD FN+4 WRITEM 1,FN WRITE FILE NAME TO FAT LDK MMFL BUILD LOCAL FAT WORD CRD CM LDM MI+1 ADVANCE ADDRESS TO LOCAL FAT WORD ADN 1 RAD EA+1 SHN -14 RAD EA LDD CM SET MACHINE ID IN LOCAL FAT WORD STD FS LDN 0 STD FS+1 WRITEM 1,FS WRITE LOCAL FAT WORD LDN MXMF+1 ADVANCE TO FAMILY NAME WORD SBM MI+1 RAD EA+1 SHN -14 RAD EA SFA EST,T7 READ FAMILY NAME FROM MST ADK EQDE CRD CM LDD CM+4 SHN 3 ADN PFGL CRD FN LDN 0 STD FN+4 WRITEM 1,FN WRITE FAMILY NAME WORD * READ LOCAL WORDS CHECKING FOR ERRORS AND ACCUMULATING COUNTS. LDN ZERL CLEAR GLOBAL COUNTS CRD FN LDD T6 SET TRACK STD FN+1 LDN MXMF SET COUNTER STD T7 RPE3 SOD EA+1 ADVANCE BACKWARD FROM FAMILY NAME WORD PJN RPE4 IF NO UNDERFLOW AOD EA+1 SOD EA RPE4 SOD T7 MJN RPE6 IF END OF LOCAL WORDS TO READ READEM 1,FS,RPE5 NOTE IF ERROR LDD FS+4 RAD FN+4 SHN -14 NJN RPE6 IF INVALID BITS SET LDD FS+3 RAD FN+3 SHN -14 NJN RPE6 IF INVALID BITS SET LDD FS+2 RAD FN+2 SHN -14 ZJN RPE3 IF NOT INVALID BITS SET RPE5 AOM RPEA ADVANCE ERROR COUNT UJN RPE7 ADVANCE TO NEXT FILE RPE6 WRITEM 1,FN WRITE GLOBAL WORD RPE7 LJM RPE2 ADVANCE TO NEXT FILE RPE8 CFLAG FATI CLEAR FAT INTERLOCK * PROCESS MST/TRT EXTENDED MEMORY ERRORS. LDN 20 SET RETRY COUNT STD EA+4 RPE9 SOD EA+4 ZJP RPEX IF UNABLE TO INTERLOCK SFLAG TRTI,RPE9 SET TRT INTERLOCK * SEARCH EST FOR SHARED DEVICES. LDN ESTP CRD OR LDN NOPE-1 STD OR UJN RPE11 ENTER SEARCH LOOP RPE10 AOM RPEA NOTE ERROR RPE11 AOD OR LMD OR+3 ZJP RPE14 IF END OF DEVICES SFA EST,OR ADK EQDE CRD FN LDD FN LPC 5020 LMC 5000 NJN RPE11 IF NOT MMF SHARED LDD FN+4 READ *SDGL* MST WORD FROM EXTENDED MEMORY SHN 3 ADK SDGL CRD EA LDK SDGL RAD EA+1 SHN -14 RAD EA READEM 1,FS,RPE10 NOTE ERROR ON EXTENDED MEMORY READ LDD FS+4 LPN 77 NJN RPE11 IF DEVICE INTERLOCKED LDD EA+1 CHECK DATA READ SBN SDGL SBD FS+1 LMD EA SBD FS NJP RPE10 IF ERROR IN ADDRESS LDD EA+4 LMD FS+4 NJP RPE11 IF NOT UP-TO-DATE IN THIS MACHINE LDD EA+3 LMD FS+3 NJP RPE11 IF NOT UP-TO-DATE IN THIS MACHINE LDD EA+2 LMD FS+2 NJP RPE11 IF NOT UP-TO-DATE IN THIS MACHINE * THIS MACHINE HAS THE UP-TO-DATE COPY OF THE MST/TRT. * WRITE THESE TABLES TO EXTENDED MEMORY TO CORRECT ANY ERRORS. LDD FN+4 RESET ADDRESS OF MST SHN 3 ADK SDGL CRD EA ADK TDGL-SDGL CRM MBUF,TR WRITEM SDGL+1,MBUF WRITE MST GLOBAL WORDS LDM MBUF+2 SET TRT LENGTH STD T7 LDD HN SET BUFFER SIZE STD WC LDD FN+4 GET TRT ADDRESS SHN 3 ADN TRLL CRD FS LDK TRST*100-MSST*100 ADVANCE EM ADDRESS TO TRT RAD EA+1 SHN -14 RAD EA RPE12 LDD T7 SBD WC PJN RPE13 IF FULL BUFFER TO WRITE RAD WC ZJP RPE11 IF END OF TRT LDN 0 RPE13 STD T7 LDD FS+3 READ TRT BUFFER SHN 14 ADD FS+4 CRM TBUF,WC STD FS+4 ADVANCE CM ADDRESS SHN -14 STD FS+3 WRITEM *,TBUF LDD WC ADVANCE EXTENDED MEMORY ADDRESS RAD EA+1 SHN -14 RAD EA UJP RPE12 ADVANCE TO NEXT BUFFER * CLEAR TRTI FLAG INTERLOCK. RPE14 CFLAG TRTI * CHECK FOR COMPLETION OF ERROR PROCESSING. LDM RPEA NJN RPE15 IF INCOMPLETE ERROR PROCESSING CFLAG COMI,NW CLEAR ERROR PROCESSING FLAG BIT RPE15 LJM RPEX RETURN RPEA CON 0 ERROR COUNTER RPEB DATA C* MST/TRT PARITY ERROR.* CCOMI VFD 24/70000000+.COMI ERRNG EBUF-* *2EB* OVERFLOW SPACE 4,10 TITLE MTE/7EA - EXTENDED MEMORY ERROR PROCESSING. QUAL 7EA IDENT 7EA,L7EA *COMMENT MTE - EXTENDED MEMORY ERROR PROCESSING. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. SPACE 4,10 L7EA EQU EPFW+3 LOAD ADDRESS FOR *7EA* ORG L7EA SPACE 4,15 *** 7EA - EXTENDED MEMORY ERROR PROCESSING. * * *7EA* IS CALLED WHEN AN ERROR IS DETECTED IN COMMUNICATING * WITH EXTENDED MEMORY. * * *7EA* PERFORMS THE FOLLOWING RECOVERY PROCEEDURES. * 1. REVERSE THE ORDER OF CHANNEL ASSIGNMENT PRIORITY. * 2. RELEASE AND REQUEST THE CHANNEL TO TRY ANOTHER * CHANNEL WHEN PRESENT. * 3. RETRY THE ENTIRE OPERATION, INCLUDING STEPS 1 AND 2 * UP TO 8 TIMES. * 4. THE MESSAGE *MMF LINK DEVICE ERROR.* IS DISPLAYED AT * THE SYSTEM CONTROL POINT. PER BSS 0 ENTRY * SEARCH TABLE FOR OPERATION TYPE. PER1 LDN 2 RAD T1 LDI T1 ZJN * IF END OF TABLE LMM SFN NJN PER1 IF FUNCTION CALLER NOT FOUND LDM 1,T1 STD T2 LMC CKS NJN PER3 IF NOT CALLED FROM CHECK STATUS LDM CKS LMC RDWX ZJN PER2 IF READ OPERATION LDK WTW-RDW PER2 ADC RDW STD T2 PER3 LDM RECA NJN PER4 IF EXIT ADDRESS PREVIOUSLY SET LDI T2 SET EXIT ADDRESS STM RECA LDC REC SET EXIT TO *REC* STI T2 * (T2) = *RDW*, *WTW*, OR *IFR*. PER4 AOD RC INCREMENT ERROR COUNTER * DISPLAY ERROR MESSAGE AT SYSTEM CONTROL POINT. LDK NCPL CRD CM AOD CM+1 SHN 7 ADN MS2W CWM PERA,TR *MMF LINK DEVICE ERROR.* LDD EA SAVE PARITY ERROR DATA STM PERB+2 LDD EA+1 STM PERB+3 LDD WC STM PERB+1 LDM CKSA STM PERB LDD ST STM PERB+4 * REVERSE ORDER OF CHANNEL ASSIGNMENT PRIORITY. LDD T5 STD CM+1 LDK RVCS STD CM+3 MONITOR SCSM * ATTEMPT TO TRY OTHER CHANNEL BY RELEASING AND REQUESTING. LDN 0 RELEASE CHANNEL RJM DSW LDN 1 REQUEST CHANNEL RJM DSW LDD RC SBN 10 PJN PER6 IF UNRECOVERED ERROR LJM 3,T2 RETRY OPERATION * PROCESS UNRECOVERED ERROR. PER6 LCN 2 CHECK FOR ERROR PROCESSOR STD T1 LDM RECA SET EXIT ADDRESS STD T2 PER7 LDN 2 RAD T1 LDM TERP,T1 ZJN PER8 IF END OF TABLE LMD T2 NJN PER7 IF ERROR PROCESSOR NOT FOUND LDM TERP+1,T1 GET ERROR PROCESSOR ADDRESS STD T2 PER8 LDN 0 CLEAR ERROR INDICATION STD RC STM RECA LDN 1 RETURN ERROR STATUS LJM 0,T2 RETURN PERA DATA C*MMF LINK DEVICE ERROR.* PERB CON 0,0,0,0,0 PARITY ERROR INFORMATION TPER SPACE 4,10 ** TPER - TABLE OF FUNCTION CALLER ADDRESSES. * * ENTRY = TWO WORDS. * WORD 1 = *SFN* CALLER RETURN ADDRESS. * WORD 2 = ROUTINE CALLING *SFN*, EITHER *RDW*, *WTW* OR *CKS*. TPER BSS 0 LIST G ECHO 1,A=(".SFN") CON A LIST * TERP SPACE 4,10 ** TERP - TABLE OF ERROR PROCESSOR ADDRESSES. * * ENTRY = TWO WORDS. * WORD 1 = *RDW/WTW* CALLER RETURN ADDRESS. * WORD 2 = ERROR PROCESSOR ADDRESS FOR *RDW/WTW*. TERP BSS 0 LIST G ECHO 1,A=(".ERP") CON A LIST * BSS 10000-* SPARES CON PER-1 (T0) = ENTRY ADDRESS - 1 CON TPER-2 (T1) = TABLE SEARCH POINTER CON RECA (T2) = POINTER TO RECOVERY ADDRESS ERRNZ 10003-* CODE DOES NOT WRAP PP CORRECTLY OVLL EQU *-L7EA LENGTH OF OVERLAY ERRNZ OVLL/5*5-OVLL CODE DOES NOT WRAP PP CORRECTLY QUAL * SPACE 4 END