Trailing-Edge
-
PDP-10 Archives
-
BB-F493Z-DD_1986
-
10,7/703mon/rnxkon.mac
There are 8 other files named rnxkon.mac in the archive. Click here to see a list.
TITLE RNXKON -- DRIVER FOR RP20'S V050
SUBTTL G.M. UHLER/GMU 10 SEP 85
SEARCH F,S,ICHPRM
$RELOC
$HIGH
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
; OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
.CPYRT<1980,1986>
;COPYRIGHT (C) 1980,1982,1984,1986
;BY DIGITAL EQUIPMENT CORP., MAYNARD, MASS.
;ALL RIGHTS RESERVED.
;
XP VRNKON,050
SALL
;ASSEMBLY INSTRUCTIONS:
; .R MACRO
; *RNXKON,RNXKON/C=KONPAR,RNXKON
RNXKON::ENTRY RNXKON
;NOTE THAT LABELS OF THE FORM RNXBP? ARE USED BY THE RP20 TRACE
;PROGRAM FOR SNOOP. BREAKPOINTS. DO NOT REMOVE THESE LABELS.
;TECHNICAL INFORMATION AND TECHNIQUES FOR PROGRAMMING THE
;RH20/DX20/RP20 ARE AVAILABLE IN THE FOLLOWING DOCUMENTS:
;
; FUNCTIONAL SPECIFICATION FOR DX20-V210 MICRO CODE,
; AUG 79
; DX20 PROGRAMMED DEVICE ADAPTER TECHNICAL MANUAL,
; DOCUMENT NUMBER EK-0DX20-TM-001, FEB 78
; RH20 MASSBUS CONTROLLER UNIT DESCRIPTION,
; DOCUMENT NUMBER EK-RH20-UD-001, AUG 76
; DX20-V210 RP20 DISK SUBSYSTEM MICRO-CODE,
; DOCUMENT NUMBER MAINDEC-10-DXMCD-A, AUG 79
SUBTTL RH20/DX20 DEVICE DEPENDENT REGISTER/BIT DEFINITIONS
.DXCTR==00B5 ;CONTROL REGISTER
CR.IGN==1B14 ;BIT SET IN UNILAS TO INDICATE THAT THIS
; COMMAND WAS TOSSED
CR.FNC==76B35 ;FUNCTION CODE
.CRNOP==01 ;NO-OP
.CRRCL==07 ;RECALIBRATE
.CRSRC==31 ;SEARCH
.CRWRT==61 ;WRITE DATA
.CRWTF==63 ;WRITE FORMAT
.CRRED==71 ;READ DATA
.CRRDF==73 ;READ FORMAT
CR.IOP==40B35 ;BITS TELLING THAT THIS OPERATION WAS
; AN I/O FUNCTION
CR.RED==10B35 ;BIT TELLING THAT THIS I/O OPERATION WAS
; A READ
CR.GO==1B35 ;GO BIT
.DXSTR==01B5 ;STATUS REGISTER
ST.CER==1B21 ;COMPOSITE ERROR
ST.RUN==1B23 ;MICROPROCESSOR RUNNING
.DXERR==02B5 ;ERROR REGISTER
ER.SCC==17B23 ;ERROR SUB CLASS CODE
ER.ECC==17B27 ;ERROR CLASS CODE
.ERSEL==3 ;DEVICE SELECT ERROR
ER.UPE==1B28 ;MICROPROCESSOR ERROR
ER.STP==1B29 ;MICROPROCESSOR STOPPED
ER.MPE==1B30 ;MICRO BUS PARITY ERROR
ER.DPE==1B31 ;DATA BUS PARITY ERROR
ER.CPE==1B32 ;CONTROL BUS PARITY ERROR
ER.RMR==1B33 ;REGISTER MODIFICATION REFUSED
ER.ILR==1B34 ;ILLEGAL REGISTER
ER.ILF==1B35 ;ILLEGAL FUNCTION
ER.ERR==ER.MPE!ER.DPE!ER.CPE!ER.RMR!ER.ILR!ER.ILF
.DXMTR==03B5 ;MAINTENANCE REGISTER
MR.SCY==1B31 ;MICROPROCESSOR SINGLE CYCLE
MR.STR==1B33 ;MICROPROCESSOR START
MR.RES==1B34 ;MICROPROCESSOR RESET
.DXASR==04B5 ;ATTENTION SUMMARY REGISTER
AT.ATN==377B35 ;THE ATTENTION BITS
.DXDAR==05B5 ;DESIRED ADDRESS REGISTER (TRACK/SECTOR)
DA.TRK==377B27 ;TRACK
DA.SEC==377B35 ;SECTOR
.DXDTR==06B5 ;DRIVE TYPE REGISTER
DT.COD==777B35 ;DRIVE TYPE
.DTCOD==061 ;CODE FOR DX20
.DXESR==20B5 ;ENDING STATUS REGISTER
ES.STM==1B21 ;STATUS MODIFIER
ES.CUE==1B22 ;CONTROL UNIT END
ES.BSY==1B23 ;BUSY
ES.CHE==1B24 ;CHANNEL END
ES.DVE==1B25 ;DEVICE END
ES.UCK==1B26 ;UNIT CHECK
ES.UEX==1B27 ;UNIT EXCEPTION
ES.SUI==1B28 ;STATUS UPDATE INTERLOCK
ES.IDX==177B35 ;STATUS INDEX
.ESSB0==0 ;INDEX TO GET SENSE BYTE 0(-3)
.ESSB7==1 ;INDEX TO GET SENSE BYTE (4-)7
.DXASY==21B5 ;ASYNCHRONOUS STATUS REGISTER
AS.DVS==377B27 ;DRIVE STATUS
AS.DRV==377B35 ;DRIVE NUMBER
AS.UNF==17B35 ;UNIT NUMBER
.DXFLG==22B5 ;FLAGS/ARGUMENT
FA.RTY==1B23 ;COMMAND RETRY
FA.FNC==377B35 ;FUNCTION FOR SENSE/NOOP
.FATIO==0 ;CODE FOR TEST I/O
.DXDNM==23B5 ;DRIVE NUMBER REGISTER
DN.CUA==17B31 ;CONTROL UNIT ADDRESS
DN.DRV==17B35 ;DRIVE NUMBER
.DXDCR==24B5 ;DESIRED CYLINDER REGISTER
.DXES1==26B5 ;EXTENDED STATUS REGISTER 1
.DXES2==27B5 ;EXTENDED STATUS REGISTER 2
.DXMIR==30B5 ;MICROCONTROLLER INSTRUCTION REGISTER
.DXPCR==31B5 ;MICROPROCESSOR PC REGISTER
PC.IRE==1B20 ;INSTRUCTION REGISTER ENABLE
PC.MSE==1B21 ;MICROSTORE ENABLE
PC.PCE==1B22 ;PC ENABLE
PC.PCI==1B23 ;PC AUTO INCREMENT
PC.MPC==7777B35 ;MICROPROCESSOR PC
.DXIPE==37B5 ;DIAGNOSTIC REGISTER 7
DX.IPE==1B22 ;INSTRUCTION REGISTER PARITY ERROR
;SENSE BYTE DEFINITIONS
S0.CRJ==1B2 ;COMMAND REJECT
S0.IRQ==1B3 ;INTERVENTION REQUIRED
S0.BOP==1B4 ;CHANNEL BUS OUT PARITY
S0.EQC==1B5 ;EQUIPMENT CHECK
S0.DTC==1B6 ;DATA CHECK
S0.OVR==1B7 ;OVERRUN
S1.PER==1B10 ;PERMANENT ERROR
S1.ITF==1B11 ;INVALID TRACK FORMAT
S1.ECY==1B12 ;END OF CYLINDER
S1.NRF==1B14 ;NO RECORD FOUND
S1.FPR==1B15 ;FILE PROTECTED
S1.WRI==1B16 ;WRITE INHIBITED
S1.OPI==1B17 ;OPERATION INCOMPLETE
DEFINE HEX(SYM,VAL),<
SYM==0
IRPC VAL,<
SYM==SYM*^D16
IFLE <"VAL"-"9">,<SYM==SYM+"VAL"-"0">
IFG <"VAL"-"9">,<SYM==SYM+"VAL"-"A"+^D10>
>
>
HEX(.S7ECC,53) ;SENSE BYTE 7 CODE INDICATING ECC RECOVERABLE ERROR
;RH20 CONI/CONO/LOGOUT AREA BIT DEFINITIONS
CI.ERR==CI.DBP!CI.LWC!CI.DRE!CI.RAE!CI.OVR
;ALL CONI ERROR BITS
CO.CLR==CO.RAE!CO.TEC!CO.CCD ;CONO BITS TO CLEAR ERRORS
CS.ERR==CS.MPE!CS.NAE!CS.NXM!CS.RHE!CS.LWC!CS.SWC!CS.OVR
;ALL CHANNEL LOGOUT AREA ERROR BITS
SUBTTL KONEBK/UNIEBK BLOCK OFFSETS
;OFFSETS IN THE KONEBK AND UNIEBK BLOCKS FOR THE RP20. DAEMON KNOWS
;ABOUT THESE OFFSETS SO IF YOU CHANGE THEM, BE SURE TO CHANGE DAEMON
;ALSO. IF YOU CHANGE THE LENGTH OF THIS BLOCK, YOU MUST ALSO MAKE
;THE CORRESPONDING CHANGE IN THE DATA BLOCK GENERATION MACROS IN COMMOD.
;
;FIRST DEFINE THE SYMBOLS USED IN RNXKON FOR THE OFFSETS.
.EBNMR==RNVNMR ;NUMBER OF MASSBUS REGISTERS (DEFINED BY MBRLST)
.EBNDR==^D24 ;NUMBER OF DRIVE REGISTERS
.EBTYP==0 ;BYTE (9) DX20 ADDR(9)0(18) MICROCODE VERSION
.EBCS0==1 ;CHANNEL LOGOUT 0
.EBCS1==2 ;CHANNEL LOGOUT 1
.EBCS2==3 ;CHANNEL LOGOUT 2
.EBCC1==4 ;FIRST CCW
.EBCC2==5 ;SECOND CCW
.EBMPE==6 ;COUNT OF MPE
.EBNXM==7 ;COUNT OF NXM
.EBMBR==10 ;+LEN,,OFFSET FROM . OF MASSBUS REGISTERS
.EBDVL==11 ;+LEN,,OFFSET FROM . OF DEVICE REGISTERS
.EBSMR==12 ;START OF MASSBUS REGISTER BLOCK
.EBSTR==.EBSMR+1 ;WHERE STATUS REGISTER IS STORED
.EBERR==.EBSMR+2 ;WHERE ERROR REGISTER IS STORED
.EBESR==.EBSMR+7 ;WHERE ENDING STATUS REGISTER IS STORED
.EBSDR==.EBSMR+.EBNMR ;START OF DEVICE REGISTER BLOCK
.EBS07==.EBSDR+1 ;WORD CONTAINING SENSE BYTE 7
EB.S07==377B35 ;POSITION OF SENSE BYTE 7
.EBS18==.EBSDR+4 ;WORD CONTAINING SENSE BYTES 18 AND 19
EB.S18==177777B35 ;POSITION OF SENSE BYTES 18 AND 19
.EBS20==.EBSDR+5 ;WORD CONTAINING SENSE BYTES 20 AND 21
EB.S20==177777B17 ;POSITION OF SENSE BYTES 20 AND 21
.EBICR==.EBSDR+.EBNDR ;CONTENTS OF INITIAL CONTROL REGISTER
;NOW DEFINE THE VALUES THAT THE REST OF THE MONITOR USES TO INTERFACE
;TO THIS BLOCK.
RNVEBK==:.EBICR ;LENGTH OF THE ???EBK BLOCK
RNVSMR==:.EBSMR ;OFFSET OF START OF MASSBUS REGISTERS IN KONEBK/UNIEBK
SUBTTL DATA STRUCTURE FIELD AND BYTE POINTER DEFINITIONS
RNXMVR==:300,,1 ;MINIMUM MICROCODE VERSION ALLOWED
;FIELDS IN RNXFLG(J)
RN.DCU==1B0 ;KNOW THE DCU CONTROLLER ADDRESS
;MUST BE SIGN BIT FOR SKIPL
RN.UPA==:1B1 ;BEEN THROUGH RNXUPA ONCE FOR THIS CONTROLLER
RNPUPA==:(RN.UPA) ;PUBLISH THIS SYMBOL FOR THE REST OF THE MONITOR
RN.FKA==1B2 ;FOUND THE DX20 MASSBUS ADDRESS FOR THIS CONTROLLER
RN.FTL==1B3 ;LAST TRANSFER ERROR WAS FATAL
RN.CLR==RN.FTL ;BITS TO CLEAR IN CONECT
RN.DCA==17B31 ;4 BITS OF DCU ADDRESS (SUBFIELD OF RN.CUA)
RN.DXN==7B35 ;DX20 ADDRESS (MASSBUS SLOT)
;BYTE POINTERS TO ABOVE FIELDS
RNYDCA::POINTR RNXFLG##(J),RN.DCA ;DCU ADDRESS
RNYDXN::POINTR RNXFLG##(J),RN.DXN ;DX20 ADDRESS
;FIELDS IN RNXCMD(J)
CM.FNC==77B5 ;FUNCTION ISSUED TO DRIVE (I.E., BITS 30-35
; OF DATAO TO CONTROL REGISTER OR STCR)
CM.XFR==1B0 ;THIS FUNCTION CAUSES A DATA TRANSFER
CM.IO==1B2 ;1=READ, 0=WRITE
CM.HNG==1B6 ;THIS INTERRUPT CAME THROUGH RNXSTP
CM.DVA==377B35 ;DEVICE ADDRESS FOR THIS OPERATION
CM.UNF==17B35 ;4 BIT UNIT NUMBER
;MISCELLANEOUS PARAMETER DEFINITIONS
.CRM10==210 ;CONTENTS OF CRAM LOCATION 10
.DXSAD==5 ;DX20 RESTART ADDRESS
MAXRSC==^D8 ;NUMBER OF TIMES TO SIMPLY RESTART THE
; DX20 WHEN WE DISCOVER THAT IT STOPPED
; BEFORE SIMPLY CALLING IT DEAD
RTYNUM==^D24 ;NUMBER OF RETRIES TO DO IN ERROR RECOVERY
ATNRTY==^D10 ;NUMBER OF TIMES TO RETRY CLEARING AN
; ATTENTION BIT FOR A DX20 THAT WE KNOW
; ABOUT BEFORE RESORTING TO A MASSBUS
; INIT TO CLEAR IT
ALLERR==777770B35 ;ALL POSSIBLE ERROR BITS SET BY INTERRUPT
;SERVICE IN THE COMMUNICATIONS WORD
MAXDCU==^D16 ;MAXIMUM NUMBER OF DCU ADDRESSES WE
; CAN HAVE ON A DX20
MAXSPD==^D16 ;MAXIMUM NUMBER OF SPINDLES WE CAN HAVE
; ON A DCU
SUBTTL MACRO DEFINITIONS
;MACRO TO COMPUTE THE WIDTH OF A MASK
; "WID" RETURNS THE LENGTH OF THE LEFTMOST STRING OF
; CONSECUTIVE ONES IN THE WORD.
DEFINE WID(MASK),<<^L<-<<MASK>_<^L<MASK>>>-1>>>
;MACRO TO COMPUTE THE POSITION OF A MASK
DEFINE POS(MASK),<<^L<MASK>+^L<-<<MASK>_<^L<MASK>>>-1>-1>>
;MACRO TO BUILD A POINTER TO A MASKED QUANTITY
; POINTR LOCATION,MASK
DEFINE POINTR(LOC,MASK),<<POINT WID(MASK),LOC,POS(MASK)>>
;MACRO TO LOAD AN ARBITRARY BYTE FROM A LOCATION INTO AN AC.
; LOAD AC,LOC,MASK
DEFINE LOAD(A,B,C),<.LDST.(A,B,C,HRRZ,HLRZ,LDB,MOVE)>
;MACRO TO STORE AN ARBITRARY BYTE FROM AN AC INTO A LOCATION
; STORE AC,LOC,MASK
DEFINE STORE(A,B,C),<.LDST.(A,B,C,HRRM,HRLM,DPB,MOVEM)>
;UTILITY MACRO USED BY LOAD AND STORE
DEFINE .LDST.(A,B,C,D,E,F,G),<
IFNB <C>,<..T==0
IFE C-777777,<..T==1
D A,B>
IFE C-777777000000,<..T==1
E A,B>
IFE ..T,<F A,[POINTR(B,C)]>>
IFB <C>,<G A,B>
> ;END OF DEFINE .LDST.
;MACRO TO INSERT A VALUE IN A MASKED FIELD
; INSVL.(VALUE,MASK)
DEFINE INSVL.(VALUE,MASK),<<<<VALUE>B<POS(<MASK>)>>&<MASK>>>
;MACRO TO WAIT AWHILE. USED IN DODTI TO GIVE THE DRIVE TIME TO
;RESPOND WITH THE VALUE OF THE EXTERNAL REGISTER.
DEFINE STALL, <
IMULI T2,1
XLIST
IMULI T2,1
LIST
>
;MACRO TO DEFINE THE MASSBUS REGISTERS TO SAVE IN THE KDB WHEN AN
;ERROR IS DETECTED. ARGUMENT IS A LIST OF THE OCTAL MASSBUS REGISTER
;NUMBERS TO SAVE. THE TOTAL NUMBER OF REGISTERS MUST NOT EXCEED ^D36.
DEFINE MBRLST (LST), <
..CNT==0 ;START WITH 0 REGISTERS
MBRTBL==0 ;AND WITH NO BITS
IRP LST, <
IFE <LST-0>,<.EBM00==..CNT>
IFE <LST-30>,<.EBM30==..CNT>
..CNT==..CNT+1 ;BUMP NUMBER BY 1
MBRTBL==MBRTBL!<1_<^D35-LST>> ;SET BIT IN TABLE
> ;END IRP LST
RNVNMR==:..CNT ;DEFINE THE NUMBER OF REGISTERS
>
MBRLST <0,1,2,3,4,5,6,20,21,22,23,24,25,26,27,30,31,32,33,34,35,36,37>
SUBTTL START DRIVE POSITIONING
;ROUTINE TO CAUSE THE DRIVE TO DO A RECALIBRATE OPERATION.
;CALL:
; J/KDB ADDRESS
; U/UDB ADDRESS
; PUSHJ P,RNXRCL
;RETURN CPOPJ IF ERROR
; CPOPJ1 WITH RECAL STARTED
RNXRCL::MOVEI T1,.DXCTR!.CRRCL ;GET RECAL FUNCTION CODE
PUSHJ P,CONECT ;CONNECT TO THE DRIVE
JRST RNXDWN ;DRIVE IS DOWN
MOVSI T2,(.DXDCR) ;SET CYLINDER AND
MOVSI T3,(.DXDAR) ; TRACK/SECTOR TO ZERO
PJRST RNXGO ;JOIN COMMON CODE
;ROUTINE TO START A POSITION OPERATION GOING. FOR RP20'S, FILIO ALWAYS
;DOES A SEEK BEFORE EVERY TRANSFER REGARDLESS OF WHETHER THE DRIVE IS
;ALREADY ON CYLINDER. WE TURN THAT INTO A SEARCH COMMAND SO THAT WE
;GET AN INTERRUPT WHEN THE DRIVE IS BOTH ON CYLINDER AND ON SECTOR.
;CALL WITH UNIBLK(U) CONTAINING THE DESIRED BLOCK NUMBER.
;CALL:
; J/KDB ADDRESS
; U/UDB ADDRESS
; PUSHJ P,RNXPOS
;RETURN CPOPJ IF ERRORS
; CPOPJ1 WITH POSITION STARTED
RNXPOS::MOVEI T1,.DXCTR!.CRSRC ;GET SEARCH COMMAND
PUSHJ P,CONECT ;CONNECT TO DRIVE
JRST RNXDWN ;DRIVE IS DOWN
PJRST RNXGO ;JOIN COMMON CODE
SUBTTL START DATA TRANSFERS
;ROUTINES TO START A DATA TRANSFER GOING ON A DRIVE. ENTRY POINTS
;ARE:
; RNXRED - READ DATA, DON'T STOP ON ERROR
; RNXRDS - READ DATA, STOP ON ERROR
; RNXRDF - READ FORMAT
; RNXWRT - WRITE DATA, DON'T STOP ON ERROR
; RNXWTS - WRITE DATA, STOP ON ERROR
; RNXWTF - WRITE FORMAT
;CALL:
; J/KDB ADDRESS
; U/UDB ADDRESS
; P1/CHANNEL DATA BLOCK ADDRESS
; PUSHJ P,ROUTINE
;RETURN CPOPJ IF ERRORS WITH:
; T1/ERROR BITS
; CPOPJ1 IF TRANSFER STARTED SUCCESSFULLY
;HERE TO START TRANSFER TO READ/WRITE FORMATS.
RNXRDF::SKIPA T1,[.CRRDF] ;GET FUNCTION CODE FOR READ FORMAT
RNXWTF::MOVEI T1,.CRWTF ;DITTO FOR WRITE FORMAT
MOVE T2,KONCNT##(J) ;WHEN READING OR WRITING FORMATS,
IDIVI T2,202 ; SECTORS ARE 202 WORDS LONG BUT FILIO
SKIPE T3 ; COMPUTED THE BLOCK COUNT BASED ON 200
ADDI T2,1 ; WORD SECTORS. RECOMPUTE THE BLOCK
HRRM T2,CHNNUM##(P1) ; COUNT TO KEEP THE RH20 HAPPY.
JRST RNXDGO ;JOIN COMMON TRANSFER CODE
;HERE TO START TRANSFER TO READ/WRITE DATA, NOT STOPPING ON ERRORS.
RNXRED::SKIPA T1,[DO.DTE!.CRRED] ;GET FUNCTION FOR READ DATA+DXES
RNXWRT::MOVEI T1,DO.DTE!.CRWRT ;DITTO FOR WRITE DATA+DXES
JRST RNXDGO ;JOIN COMMON CODE
;HERE TO START TRANSFER TO READ/WRITE DATA, STOPPING ON ERRORS.
RNXRDS::SKIPA T1,[.CRRED] ;GET FUNCTION CODE FOR READ DATA
RNXWTS::MOVEI T1,.CRWRT ;DITTO FOR WRITE DATA
;HERE FROM ALL TRANSFER OPERATIONS TO ACTUALLY DO THE WORK WITH
;T1 CONTAINING THE FUNCTION.
RNXDGO: PUSHJ P,CONECT ;CONNECT TO DRIVE
JRST RNXDWN ;DRIVE IS DOWN
PUSH P,T4 ;SAVE IGNORE COMMAND FLAG
MOVN T4,CHNNUM##(P1) ;GET NEGATIVE BLOCK COUNT FOR TRANSFER
STORE T4,T1,DO.CNT ;STORE IN APPRPRIATE PLACE IN STCR
TLO T1,(.DOSTC!DO.RCP!DO.SCS) ;SETUP TO TALK TO STCR
POP P,T4 ;RESTORE T4
;HERE TO START ALL OPERATIONS GOING THROUGH EITHER THE STCR OR THE
;DX20 CONTROL REGISTER WITH:
; T1/STCR OR CONTROL REGISTER DATAO
; T2/DATAO TO SETUP DESIRED CYLINDER REGISTER
; T3/DATAO TO SETUP DESIRED ADDRESS REGISTER
; T4/NON-ZERO TO TOSS THIS COMMAND
RNXGO: JUMPN T4,RNXGO1 ;DON'T DO DATAO'S IF TOSSING COMMAND
PUSH P,T3 ;SAVE DESIRED ADDRESS REGISTER
PUSHJ P,DODTO ;WRITE DESIRED CYLINDER REGISTER
POP P,T2 ;RESTORE DESIRED ADDRESS REGISTER
PUSHJ P,DODTO ;WRITE THAT ALSO
RNXGO1: LDB T3,RNYDXN ;GET DX20 NUMBER
TLO T1,<(DO.LDR!DO.DRE)>(T3) ;SET LDR, DRE, AND DS
SKIPE T4 ;TOSSING THIS COMMAND?
TLO T1,(CR.IGN) ;YES, SET FLAG SO WE CAN TELL
MOVEM T1,UNILAS##(U) ;STORE AS LAST COMMAND FOR THIS UNIT
JUMPN T4,RNXGO2 ;EXIT NOW IF TOSSING COMMAND
STORE T1,RNXCMD##(J),CM.FNC ;STORE FUNCTION IN KDB
TRNE T1,CR.IOP ;THIS AN I/O FUNCTION?
RDTIME RNXITB##(J) ;YES, READ THE STARTING TIME BASE
RNXBP1: XCT RNXDO1##(J) ;START THE OPERATION
RNXGO2: PUSHJ P,REASPI ;REASSIGN PIA
JRST CPOPJ1## ;GIVE SKIP RETURN
;HERE IF THE DRIVE OR KONTROLLER WAS DECLARED DOWN BY CONECT TO RETURN
;AN ERROR INDICATION TO FILIO.
RNXDWN: PUSHJ P,SETCO ;SET CONO MASK
TRO T4,CO.RAE ;MAKE SURE RAE IS CLEAR
XCT RNXCO4##(J) ;GIVE IT A PIA
XCT RNXCI2##(J) ;GET CONI INTO T2
MOVE T3,KONEBK##+.EBERR(J) ;GET ERROR REGISTER
HRL T3,KONEBK##+.EBSTR(J) ;MAKE IT STATUS,,ERROR REGISTER
RNXBP5: POPJ P, ;RETURN
SUBTTL STOP TRANSFER FOR HUNG RECOVERY
;ROUTINE TO STOP THE CURRENT TRANSFER WHEN THE HUNG TIMER TIMES
;OUT. NOTE THAT THE SETTING OF STOP TRANSFER CAUSES AN IMMEDIATE
;INTERRUPT SO RNXINT HAS TO KNOW ABOUT THESE KINDS OF INTERRUPTS.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXSTP
;RETURN CPOPJ IF COULDN'T GET BUSY TO CLEAR
; CPOPJ1 IF SUCCESSFUL
RNXSTP::XCT RNXCI2##(J) ;GET CONI BEFORE STOPPING TRANSFER
PUSH P,T2 ;SAVE IT
PUSHJ P,RNXIVI ;ASSIGN AN IVI SINCE WE MIGHT BE HERE
; AS THE RESULT OF POWER FAIL RESTART
MOVSI T2,(CM.HNG) ;SET BIT TELLING RNXINT THAT THIS
IORM T2,RNXCMD##(J) ; INTERRUPT WAS THE RESULT OF A HUNG
MOVEI T2,CO.STP ;GET THE STOP TRANSFER BIT
XCT RNXCO2##(J) ;STOP THE RH20
XCT RNXCI2##(J) ;GET THE CONI BACK
RNXBP6: TRNN T2,CI.BSY ;DID BUSY CLEAR?
AOS -1(P) ;YES, GIVE SKIP RETURN
POP P,T2 ;RESTORE CONI
MOVEI T3,0 ;DATAI WILL BE SAVED BY RNXINT
PJRST REASPI ;REASSIGN PIA AND RETURN
SUBTTL INTERRUPT HANDLER
;ROUTINE TO PROCESS RP20 INTERRUPTS.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXINT
;EXITS CPOPJ ALWAYS THROUGH FILINT WITH:
; T1/COMMUNICATIONS WORD (ATN BITS+DRIVE,,ERROR+FUNCTION)
; T2/CONI
; T3/ENDING STATUS,,ERROR REGISTER
RNXINT::PUSHJ P,SAVE3## ;SAVE P1-P3
XCT RNXDI2##(J) ;GET REGISTER RH20 IS CONNECTED TO
PUSH P,T2 ;SAVE IT
MOVEI T2,^D2000 ;JUST IN CASE SOMETHING IS HAPPENING,
PUSHJ P,WGOCLR ; WAIT FOR THE GO BIT TO CLEAR
PUSHJ P,RNXINR ;PROCESS ANY OPERATION IN PROGRESS
; PLUS ANY ERRORS THAT OCCURRED WHILE
; THERE WAS NO OPERATION IN PROGRESS
; (MICRODIAGNOSTIC FAILURE, UCODE RELOAD)
PUSHJ P,CHKATN ;CHECK ON ASYNCHRONOUS EVENTS AND CALL FILIO
HLLZ T2,0(P) ;GET BACK REGISTER (WE MAY HAVE INTERRUPTED
TLZ T2,^-<(DO.REG!DO.DRV)> ; BETWEEN THE DATAO AND DATAI
XCT RNXDO2##(J) ; IN DODTI AT UUO LEVEL SO RESTORE IT
JRST T2POPJ## ;RESTORE T2 AND RETURN
;ROUTINE TO PROCESS ANY OPERATION CURRENTLY IN PROGRESS OR ERRORS
;THAT OCCURRED WHILE THERE WAS NO OPERATION IN PROGRESS SUCH
;AS MICRODIAGNOSTIC FAILURES OR INTERRUPTS FOR MICROCODE RELOADS.
;CALLED FROM INTERRUPT SERVICE AND CONECT.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXINR
;RETURN CPOPJ ALWAYS WITH:
; J/KDB ADDRESS
; T1/FILIO COMMUNICATION WORD
; P1/FLAGS FROM RNXCMD OR 0 IF NO OPERATION IN PROGRESS
; P2/ERROR REGISTER,,ENDING STATUS REGISTER
; P3/CHANNEL STATUS,,CONI
RNXINR: SETZB T1,P2 ;CLEAR COMMUNICATION AND DATAI WORDS
XCT RNXCI2##(J) ;GET CONI IN T2
MOVEI P3,(T2) ;MOVE TO P3
MOVEI P1,0 ;START WITH ZERO FLAGS
EXCH P1,RNXCMD##(J) ;ZERO FLAG WORD, PUT FLAGS IN P1
MOVEM P1,RNXLAS##(J) ;SAVE VALUE FOR DEBUGGING
MOVSI T2,(.DXESR) ;POINT AT ENDING STATUS REGISTER
PUSHJ P,DODTI ;READ IT
MOVEI P2,(T2) ;MOVE TO P2
JUMPGE P1,RNXIN2 ;GO IF NOT A DATA TRANSFER OPERATION
MOVE T2,KONIOC##(J) ;GET ADDRESS OF RH20 LOGOUT AREA
HLL P3,.CSCLP(T2) ;COPY CHANNEL STATUS TO LH(P3)
RNXIN2: MOVE U,KONCUA##(J) ;SETUP POSSIBLE UDB ADDRESS
PUSHJ P,CHKERR ;CHECK ON DX20 DETECTED ERRORS
JUMPL P1,DATINT ;DISPATCH TO DATA XFER DONE HANDLER
JUMPE P1,NOPINT ;DISPATCH IF NO OPERATION IN PROGRESS
LDB T2,UNYPUN## ;GET PHYSICAL UNIT NUMBER
MOVE T2,BITTBL##(T2) ;AND CORRESPONDING BIT
TLNE P1,(CM.HNG) ;COME THROUGH RNXSTP?
IORM T2,RNXATN##(J) ;YES, MUST BE A HUNG RECAL
;; PJRST POSINT ;FALL INTO POSITION DONE HANDLER
;HERE ON A POSITION INTERRUPT AT POSINT OR AN INTERRUPT WITH NO
;OPERATION IN PROGRESS AT NOPINT WITH THE FOLLOWING AC'S SETUP:
; T1/ERROR BITS
; P1/FLAGS FROM RNXCMD OR 0 IF NO OPERATION IN PROGRESS
; P2/ERROR REGISTER,,ENDING STATUS REGISTER
; P3/CONI
POSINT: LOAD T2,P1,CM.UNF ;GET UNIT NUMBER OF DRIVE
TRNN T1,ALLERR ;NO 2ND INTERRUPT IF WE GOT AN ERROR
TRNE P2,ES.DVE ;DEVICE END UP IN ENDING STATUS REGISTER?
PUSHJ P,POSDON ;YES, SET CORRESPONDING BIT IN RNXATN
NOPINT: TRO T1,OPPOS ;FLAG THIS AS A POSITION OPERATION
TRZE T1,ALLERR ;ANY ERRORS DETECTED?
PUSHJ P,LOGUPE ;YES, LOG THEM
POPJ P, ;RETURN
;HERE ON A DATA TRANSFER INTERRUPT WITH THE FOLLOWING AC'S SETUP:
; T1/ERROR BITS
; P1/FLAGS FROM RNXCMD
; P2/ERROR REGISTER,,ENDING STATUS REGISTER
; P3/CHANNEL STATUS,,CONI
DATINT: TLNE P1,(CM.HNG) ;HERE FROM RNXSTP?
TRO T1,IODERR ;YES, SET DEVICE ERROR
TLNE P1,(CM.IO) ;DOING A READ?
TROA T1,OPRED ;YES, FLAG IT AS SUCH
TRO T1,OPWRT ;NO, FLAG IT AS A WRITE
TLC P3,(CS.NAE) ;COMPLEMENT ADDRESS PARITY BIT
TDNN P3,[CS.ERR!CI.ERR] ;ANY CHANNEL OR RH20 ERRORS DETECTED?
JRST DATIN1 ;NO
TLNE P3,(CS.MPE) ;MEMORY PARITY ERROR?
TRO T1,IOCHMP ;YES
TLNE P3,(CS.NXM) ;NXM?
TRO T1,IOCHNX ;YES
TLNE P3,(CS.OVR) ;OVERRUN?
TRO T1,IOVRUN ;YES
TRNN T1,ALLERR ;ANY ERRORS FLAGGED (BETTER BE)
TRO T1,IODERR ;NO??? FLAG A DEVICE ERROR
DATIN1: TLC P3,(CS.NAE) ;RECOMPLEMENT ADDRESS PARITY BIT
TRNN T1,ALLERR ;ANY ERRORS DETECTED?
SKIPLE UNIECT##(U) ;NO, READ SUCCEED ON RETRY?
PUSHJ P,RDREG ;YES, READ THE REGISTERS
HRRZ T2,UNICHN##(U) ;UPDATE THE LAST KNOWN POSITION
MOVE T2,CHNNUM##(T2) ; OF THE DISK
ADD T2,UNIBLK##(U)
ADDI T2,^D14 ;PLUS A FUDGE FACTOR
LDB T3,UNYBPT##
IDIV T2,T3
DPB T3,UNYLKP##
POPJ P, ;RETURN
;ROUTINE TO CHECK FOR ASYNCHRONOUS EVENTS AND DO THE FINAL INTERRUPT
;PROCESSING BEFORE CALLING FILINT.
;CALL:
; J/KDB ADDRESS
; T1/ERROR BITS
; P1/FLAGS FROM RNXCMD OR 0
; P2/ERROR REGISTER,,ENDING STATUS REGISTER
; P3/CHANNEL STATUS,,CONI
; PUSHJ P,CHKATN
;RETURN CPOPJ ALWAYS
CHKATN: PUSHJ P,CLRATN ;CLEAR ATTENTION BITS
PUSHJ P,CLRERG ;CLEAR THE ERROR REGISTER
MOVSI T2,(.DXASY) ;POINT AT THE ASYNCHRONOUS STATUS REGISTER
PUSHJ P,DODTI ;READ IT
JUMPE T2,INTDON ;GO IF NONE THERE
TRNE T2,AS.DVS ;ANY STATUS BITS SET?
JRST RNXBP2 ;YES, CONTINUE
MOVSI T2,(.DXASY) ;THERE'S A UCODE RACE WHICH CAUSES IT TO GIVE
PUSHJ P,DODTI ;US A DRIVE WITH NO STATUS, SO READ IT AGAIN
RNXBP2: PUSH P,T2 ;SAVE IT
MOVSI T2,(.DXASY) ;POINT AT REGISTER AGAIN
PUSHJ P,DODTO ;CLEAR IT SO WE CAN GET MORE
POP P,T2 ;RESTORE VALUE TO PROCESS
SKIPN P1 ;IF NO OPERATION IN PROGRESS,
MOVEI P2,(T2) ;MOVE ASYNCHRONOUS STATUS TO P2 FOR .SYS P
LOAD T2,T2,AS.UNF ;GET UNIT NUMBER PRESENTING STATUS
PUSHJ P,POSDON ;SET THE CORRESPONDING BIT IN RNXATN
;; PJRST INTDON ;FALL INTO INTDON
;HERE TO DO THE FINAL EXIT PROCESSING BEFORE CALLING FILINT WITH:
; J/KDB ADDRESS
; T1/ERROR BITS
; P1/FLAGS FROM RNXCMD OR 0
; P2/ERROR REGISTER,,ENDING STATUS REGISTER
; P3/CHANNEL STATUS,,CONI
; LH(RNXATN(J))/ATTENTION BITS OF DRIVES IN POSITION
INTDON: MOVEI T4,CO.CLR ;GET BITS TO CLEAR RH20
XCT RNXCO4##(J) ;DO SO
PUSHJ P,REASPI ;REASSIGN PIA
HLLZ T4,RNXATN##(J) ;GET ATTENTION BITS
LOAD T2,P1,CM.UNF ;GET UNIT NUMBER LAST CONNECTED TO
TLO T1,(T2) ;SET IN LH OF T1
TRNN T1,OPPOS ;THIS A POSITION OPERATION?
TDZ T4,BITTBL##(T2) ;NO, MAKE SURE WE DON'T CALL FILIO WITH
; A POSITION DONE INTERRUPT ON A TRANSFERRING
; DRIVE. IT HAPPENS AND IT CONFUSES FILIO
;PJRST CALFIO ;CALL FILIO TO PROCESS THIS EVENT
;ROUTINE TO ACTUALLY CALL FILIO TO PROCESS AND INTERRUPT.
;CALL:
; J/KDB ADDRESS
; T1/COMMUNICATION WORD
; T4/ATTENTION BITS
; P2/ERROR REGISTER,,ENDING STATUS REGISTER
; P3/CHANNEL STATUS,,CONI
; PUSHJ P,CALFIO
;RETURN CPOPJ ALWAYS
CALFIO: PUSH P,J ;SAVE KONTROLLER ADDRESS; FILINT MAY SMASH IT
HRRZS RNXATN##(J) ;CLEAR ATTENTION BITS IN KDB
MOVE T2,P3 ;GET CONI IN T2
MOVS T3,P2 ; AND DATAI'S IN T3
MOVEM T1,RNXEC3##(J) ;****; TEMPORARY FOR DEBUGGING
TLZ T1,777700 ;CLEAR UNUSED BITS
TRNE T1,OPPOS ;POSITION INTERRUPT?
TLNE T4,777774 ; WITH NO ATTENTION BITS UP?
RNXBP3: PUSHJ P,FLHTID## ;NO, CALL FILIO AND RETURN
PJRST JPOPJ## ;YES, AVOID A LONG NO-OP IN FILIO
SUBTTL DETERMINE CAPACITY AND STATUS
;ROUTINE TO RETURN CAPACITY AND STATUS OF AN RP20 DRIVE TO FILSER.
;CALL: J/KDB ADDRESS
; U/UDB ADDRESS
; PUSHJ P,RNXCPY
;RETURN CPOPJ IF ERROR
; CPOPJ1 IF DRIVE EXISTS AND IS OK TO USE WITH:
; T1/BLOCKS PER UNIT
; T2/BLOCKS PER UNIT INCLUDING MAINTENANCE CYLINDERS
; T3/BLOCKS PER UNIT IN 10/11 COMPATABILITY MODE
; T4/STATUS BITS (KOPUHE,KOPNSU,KOP22B),,UNIT TYPE
; LH(J)/DRIVE SERIAL NUMBER
; W/BLOCKS PER TRACK,,BLOCKS PER CYLINDER
RNXCPY::PUSHJ P,SAVE2## ;SAVE P1-P2
MOVEI T2,CO.MBE ;MAKE SURE MASSBUS
XCT RNXCO2##(J) ; ENABLE IS ON AND DEASSIGN PI
PUSHJ P,RNXIVI ;SET INTERRUPT VECTOR ADDRESS
MOVSI T2,U2PNRM## ;SET NON-REMOVABLE MEDIUM
IORM T2,UNIDS2##(U) ; IN UDB
MOVSI T4,KOP22B## ;RP20 IS ALWAYS 22 BIT, UNIT TYPE IS 0
SKIPE RNXCMD##(J) ;ARE WE DOING SOMETHING NOW?
JRST RNXCP4 ;YES, CAN'T TOUCH THE DRIVE
PUSHJ P,RNXFKA ;FIND DX20 ADDRESS, CHECK MICROPROCESSOR
JRST RNXCP6 ;SOMETHING FAILED, BITS SET IN T4
MOVSI P1,-MAXDCU ;LOOP INDEX FOR ALL POSSIBLE DCU'S
RNXCP1: PUSHJ P,MPRUN ;DX20 STILL RUNNING?
JRST RNXCP4 ;NO, CALL UNIT OFF-LINE
SKIPL RNXFLG##(J) ;DO WE KNOW THE DCU CONTROLLER ADDRESS?
DPB P1,RNYDCA ;NO, TRY THE NEXT
PUSHJ P,DO2TIO ;DO TWO TEST I/O'S
JRST RNXCP4 ;GO IF THE DX20 DIDN'T RESPOND
PUSHJ P,INIERR ;CHECK FOR ERRORS
JRST RNXCP5 ;DRIVE IS ON-LINE
JRST RNXCP4 ;DRIVE EXISTS BUT IS OFF-LINE
SKIPL RNXFLG##(J) ;ALREADY KNOW THE DCU CONTROLLER ADDRESS?
AOBJN P1,RNXCP1 ;NO, TRY NEXT CONTROLLER FOR THIS UNIT
;HERE IF NO SUCH UNIT EXISTS OR THE DRIVE TYPE REGISTER IS NOT
;FOR A DX20.
RNXCP3: TLOA T4,KOPUHE##!KOPNSU## ;INDICATE NO SUCH UNIT
;HERE IF THE UNIT EXITS BUT IS OFF-LINE OR IF WE'RE NOT REALLY SURE
;AND DON'T WANT TO TELL FILSER THAT NO SUCH UNIT EXISTS.
RNXCP4: TLO T4,KOPUHE## ;INDICATE OFF-LINE
JRST RNXCP6 ;JOIN COMMON EXIT CODE
;HERE IF THE DRIVE IS ON-LINE AND NO ERRORS WERE DETECTED.
RNXCP5: AOS 0(P) ;GIVE SKIP RETURN
MOVSI T2,(RN.DCU) ;INDICATE THAT WE NOW KNOW THE
IORM T2,RNXFLG##(J) ; DCU CONTROLLER ADDRESS
RNXCP6: LDB T1,RNYDCA ;GET DCU
IFN FTDUAL,<
;THERE'S NO WAY TO READ THE SERIAL NUMBER OF AN RP20 SO WE
;BUILD A FAKE SERIAL NUMBER BASED ON THE UNIT NUMBER.
;THE QUESTION IS: IF YOU'VE GOT SEVERAL RH20'S WORTH OF
;RP20'S, HOW DO YOU TELL WHICH RH20 IS DUAL PORTED WITH WHICH?
;THE ANSWER IS: YOU CUT THE TWO DCU'S TO BE THE SAME ADDRESS.
;IF THE DCU'S MATCH THE DRIVES WILL BE CONSIDERED DUAL PORTED.
;THERE'S A SPECIAL CASE, HOWEVER, IN THAT A DCU OF ZERO DOESN'T
;MATCH ANYTHING. NOTE THAT THE FACTORY SETS ALL THE DCU ADDRESSES TO ZERO.
;YOU CAN INSTALL ANY NUMBER OF THESE WITH NO MODIFICATION AND THEY WILL
;ALL BE SINGLE PORTED. IF YOU WANT THEM TO BE DUAL PORTED THEN YOU
;HAVE TO ASSIGN A UNIQUE DCU ADDRESS.
JUMPE T1,RNXCP7 ;GO IF FACTORY JUMPERS
>
LSH T1,4 ;MAKE ROOM FOR UNIT NUMBER
LDB T2,UNYPUN## ;GET UNIT NUMBER
IOR T1,T2 ;DUMMY UP A DRIVE SERIAL NUMBER
MOVEI T2,.DTCOD ;GET DT VALUE, VERIFIED BY CHKDTR
RNXCP7: HRRZM T1,UNISER##(U) ;RETURN SERIAL NUMBER IN UNISER
PUSHJ P,CLRERG ;CLEAR ERROR REGISTER
PUSHJ P,CLRATN ;CLEAR ATTENTIONS
PUSHJ P,REASPI ;RESTORE PI ASSIGNMENT
DMOVE T1,[EXP ^D839250,^D840000] ;BLOCKS/UNIT WITH/WITHOUT MAINT CYL
TRNE T4,KOPNSU## ;NO SUCH UNIT?
SETZB T1,T2 ;YES, RETURN 0'S
MOVEI T3,0 ;NO BLOCKS IN 10/11 COMPATABILITY MODE
MOVE W,[^D25,,^D750] ;BLOCKS/TRACK,,BLOCKS/CYLINDER
POPJ P, ;RETURN
;ROUTINE TO FIND THE DX20 CONTROLLER MASSBUS ADDRESS AND CHECK
;THE INTEGRETY OF THE MICROPROCESSOR CONTROL STORE.
;CALL:
; J/KDB ADDRESS
; U/UDB ADDRESS
; PUSHJ P,RNXFKA
;RETURN CPOPJ IF ERROR WITH:
; T4/ERROR BITS INDICATING TYPE OF FAILURE
; CPOPJ1 IF NO ERROR WITH MICROPROCESSOR RUNNING
RNXFKA::MOVSI T2,(RN.FKA) ;DO WE ALREADY KNOW
TDNE T2,RNXFLG##(J) ; THE DX20 CONTROLLER ADDRESS?
JRST RNXFK2 ;YES, JUST CHECK THE MICROPROCESSOR
PUSHJ P,SAVE1## ;SAVE P1
HLLZ P1,KONTBP##(J) ;MAKE AOBJN POINTER TO MAX CONTROLLER ADDR
RNXFK1: DPB P1,RNYDXN ;STORE CONTROLLER ADDRESS
PUSHJ P,CHKDTR ;CHECK DRIVE TYPE REGISTER
JRST RNXFK4 ;NO MATCH, TRY NEXT
RNXFK2: PUSHJ P,MPINI ;CHECK AND RELOAD MICRO IF NECESSARY
JRST RNXFK5 ;FAILED, CALL THE DRIVE OFF-LINE
MOVSI T2,(RN.FKA) ;SET FLAG INDICATING THAT WE
IORM T2,RNXFLG##(J) ; KNOW THE DX20 ADDRESS
AOS 0(P) ;GIVE SKIP RETURN
JRST RNXFK6 ;AND EXIT
RNXFK4: MOVEI T2,CO.RAE!CO.MBE ;GET BIT TO CLEAR RAE
XCT RNXCO2##(J) ;CLEAR ANY POSSIBLE RAE
AOBJN P1,RNXFK1 ;AND TRY NEXT DX20 ADDRESS
TLOA T4,KOPUHE##!KOPNSU## ;IF NO DX20, MARK THIS UNIT NONEXISTANT
RNXFK5: TLO T4,KOPUHE## ;ELSE JUST CALL IT OFF-LINE
RNXFK6: MOVEI T2,CO.CLR!CO.MBE ;GET BITS TO CLEAR THE RH20
XCT RNXCO2##(J) ;DO SO
POPJ P, ;RETURN SKIP/NONSKIP
SUBTTL RETURN ECC MASK AND POSITION
;ROUTINE TO RETURN THE ECC POSITION AND MASK TO FILIO FOR AN ECC
;CORRECTABLE ERROR IN A BLOCK. THE RP20 RETURNS THE ECC POSITION
;AND MASK IN THE SENSE BYTES WHICH ARE NOW IN KONEBK AS FOLLOWS:
; 18-19 FIRST BYTE IN ERROR COUNTED FROM THE LAST BYTE IN THE
; BLOCK. A COUNT OF ZERO MEANS THAT THE ECC ERROR OCCURRED
; IN THE ECC BYTE ITSELF AND MAY BE IGNORED.
; 20-21 MASK WHICH WHEN XORED WITH THE DATA ACTUALLY READ WILL
; CORRECT THE ERROR.
;NOTE THAT THE BOTH MASK WORDS ARE SWAPPED SINCE THAT'S THE WAY AN
;RP06 WOULD RETURN THEM AND THE WAY FILIO EXPECTS THEM.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXECC
;RETURN CPOPJ IF NO ECC INFORMATION AVAILABLE
; CPOPJ1 WITH CORRECTION DATA AS FOLLOWS:
; T1/WORD POSITION OF START OF ERROR RELATIVE TO START OF BLOCK
; T2-T3/MASK
RNXECC::HLRZ T2,KONEBK##+.EBDVL(J) ;GET NUMBER OF DEVICE REGS STORED
JUMPE T2,CPOPJ## ;GIVE UP IF NONE
LOAD T3,KONEBK##+.EBS07(J),EB.S07 ;GET FORMAT TYPE AND CODE
CAIN T3,.S7ECC ;ECC ERROR?
CAIGE T2,.EBS07-.EBSDR+1 ;OR IF WE DIDN'T GET AT LEAST 0-7
POPJ P, ;NO ECC INFORMATION AVAILABLE
SETZB T2,T3 ;ZERO MASKS FOR EARLY EXIT
LOAD T1,KONEBK##+.EBS18(J),EB.S18 ;GET BYTES 18-19
JUMPE T1,CPOPJ1## ;NO CORRECTION IF IN ECC BYTE
CAILE T1,^D576 ;OR IF OUT
POPJ P, ; OF RANGE
MOVNI T1,-^D576(T1) ;COMPUTE NUMBER OF BYTES FROM START OF BLOCK
LSH T1,3 ;CONVERT TO COUNT OF BITS
TLZ T1,-1 ;CLEAR JUNK
IDIVI T1,^D36 ;COMPUTE WORD COUNT, OFFSET IN WORD
MOVNI T4,-<^D36-^D16>(T2) ;COMPUTE SHIFT COUNT IN THIS WORD
LOAD T2,KONEBK##+.EBS20(J),EB.S20 ;GET CORRECTION MASK
LSHC T2,(T4) ;SHIFT TO PROPER POSITION FOR MASK
MOVSS T2 ;SWAP THE MASK SO THAT IT
MOVSS T3 ; LOOKS LIKE THAT RETURNED BY AN RP06
JRST CPOPJ1## ;GIVE SKIP RETURN
SUBTTL DIRECT FILIO IN ERROR RECOVERY
;ROUTINE TO DIRECT FILIO IN ERROR RECOVERY. SINCE THE DCU DOES ITS OWN
;SEEK ERROR RECOVERY AND SINCE WE DON'T HAVE ANY OFFSET CAPABILITY,
;THE BASIC ERROR RECOVERY ALGORITHM IS TO SIMPLY DO 24 STRAIGHT RETRIES.
;IF RN.FTL IS SET IN RNXFLG, HOWEVER, WE GIVE UP IMMEDIATELY.
;CALL:
; J/KDB ADDRESS
; T1/RETRY NUMBER
; P1/CHANNEL DATA BLOCK ADDRESS
; PUSHJ P,RNXERR
;RETURN CPOPJ ALWAYS WITH:
; T1/0 IF STRAIGHT RETRY
; 2 IF LAST TIME
; 3 IF GIVE UP
RNXERR::MOVE T2,RNXFLG##(J) ;GET ERROR FLAGS SET BY CHKERR
TLNE T2,(RN.FTL) ;FATAL ERROR?
MOVEI T1,RTYNUM ;YES, FORCE IT TO BE FATAL
CAIGE T1,RTYNUM-1 ;STILL DOING STRAIGHT RETRIES?
MOVEI T2,0 ;YES
CAIN T1,RTYNUM-1 ;LAST TIME?
MOVEI T2,2 ;YES
CAIL T1,RTYNUM ;TIME TO GIVE UP?
MOVEI T2,3 ;YES
MOVEI T1,(T2) ;MOVE TO WHERE FILIO WANTS IT
POPJ P, ;RETURN
SUBTTL MISCELANEOUS GLOBAL FUNCTIONS
;ROUTINE TO RETURN THE LATENCY TIME FOR AN RP20 DRIVE. SINCE THE
;RP20 CAN'T TELL US WHERE IT REALLY IS (THAT'S RIGHT, NO LOOK AHEAD
;REGISTER RP06 FANS), AND SINCE WE ALWAYS DO SEARCHES BEFORE EACH
;DATA TRANSFER SO THAT WE GET AN INTERRUPT WHEN THE DRIVE IS ON
;BOTH CYLINDER AND SECTOR, WE ALWAYS RETURN A LATENCY TIME OF
;ZERO IN THE HOPE THAT FILIO WILL GET BACK TO START THE TRANSFER
;BEFORE THE DISK REVOLVES PAST THE BLOCK.
;CALL:
; PUSHJ P,RNXLTM
;RETURN CPOPJ1 ALWAYS WITH:
; T1/LATENCY TIME (ZERO)
RNXLTM::MOVEI T1,0 ;RETURN A ZERO
JRST CPOPJ1## ;GIVE SKIP RETURN
;ROUTINE TO RETURN THE DISTANCE TO THE TARGET CYLINDER. SINCE WE WANT
;TO DO SEEKS (REALLY SEARCHES), WE ALWAYS TELL FILIO THAT WE ARE OFF
;CYLINDER EVEN IF WE ARE ON CYLINDER.
;BE AWARE THAT WHEN CHOOSING SOMEBODY FROM THE POSITION WAIT QUEUE,
;IF THERE ARE SEVERAL PEOPLE ALREADY ON CYLINDER, FILIO
;WILL TRY TO CHOOSE THE ONE WHOSE ROTATIONAL LATENCY IS THE
;SMALLEST. IN THE CASE OF AN RP20, WE MUST LIE TO FILIO.
;IF WE'RE ON CYLINDER, LIE TO FILIO AND TELL HIM THAT WE'RE OFF
;CYLINDER. BUT LIE BY AN AMOUNT LINEARLY PROPORTIONATE TO THE
;EXPECTED ROTATIONAL LATENCY OF THE DISK. THE EXPECTED LATENCY
;IS CALCULATED FROM THE LAST KNOWN POSITION OF THE DISK.
;THE ONLY TIME WE CAN ACCURATELY KNOW THE POSITION OF THE DISK
;IS AT THE CONCLUSION OF A TRANSFER. IT HAPPEN'S THAT'S
;THE ONLY TIME WE PICK SOMEBODY FROM THE POSITION WAIT QUEUE
;ANYWAY.
;CALL:
; PUSHJ P,RNXCCM
;RETURN CPOPJ ALWAYS WITH:
; T1/DISTANCE FROM CURRENT CYLINDER TO TARGET CYLINDER
RNXCCM::PUSHJ P,CYLCM## ;LET FILIO COMPUTE THE REAL DISTANCE
MOVMS T1
ADDI T1,100 ;EXCESS 100
CAIE T1,100 ;ON CYL?
POPJ P, ;NO
MOVE T1,DEVBLK##(F) ;YES, COMPUTE TARGET SECTOR
LDB T3,UNYBPT##
IDIV T1,T3
LDB T1,UNYLKP## ;LAST KNOWN POSITION OF DISK
CAMLE T1,T2 ;TOO LATE?
ADD T2,T3 ;YES, WAIT ANOTHER REVOLUTION
SUBM T2,T1 ;DISTANCE TO TARGET
ADDI T1,1 ;ASSURE NON-ZERO
SKIPL UNIECT##(U) ;IN ERROR RECOVERY?
SETZ T1, ;YES, TELL THE TRUTH (ON CYL)
POPJ P, ;RETURN
;ROUTINES WHICH SHOULD NEVER BE CALLED SINCE THE DISPATCH BITS
;IN COMMOD PROHIBIT THIS. IF WE DO GET HERE HOWEVER...
RNXRDC:: ;READ 10/11 COMPATABILITY MODE
RNXWTC:: ;WRITE 10/11 COMPATABILITY MODE
RNXUNL:: ;UNLOAD DRIVE
STOPCD CPOPJ1##,DEBUG,NIF, ;++RNXKON ISN'T FANCY
SUBTTL CHECK DRIVE/CONTROLLER STATUS
;ROUTINE TO INSURE THAT THE RH20 AND DX20 ARE OK FOR THE OPERATION
;ABOUT TO BE DONE AND SETUP FOR THAT OPERATION.
;CALL:
; J/KDB ADDRESS
; U/UDB ADDRESS
; T1/FUNCTION
; PUSHJ P,CONECT
;RETURN CPOPJ IF ERROR WITH:
; T1/ERROR BITS
; CPOPJ1 IF OK WITH:
; T1/FUNCTION
; T2/CYLINDER
; T3/TRACK/SECTOR IN .DXDAR FORMAT
; T4/NON-ZERO TO TOSS THIS COMMAND
CONECT: MOVEI T4,CO.MBE ;MAKE SURE PIA IS OFF AND MBE
XCT RNXCO4##(J) ; IS ON
SKIPE T4,RNXCMD##(J) ;COMMAND IN PROGRESS ALREADY?
RNXBP4: PUSHJ P,CMDWAT ;YES, WAIT FOR IT TO FINISH
JUMPN T4,CONEC2 ;GO IF TOSSING COMMAND
MOVSI T2,(RN.CLR) ;CLEAR TEMPORARY BITS
ANDCAM T2,RNXFLG##(J) ; IN KDB
PUSHJ P,RNXIVI ;MAKE SURE RH20 HAS AN IVI
XCT RNXCI2##(J) ;GET CONI IN T2
TRNE T1,CR.IOP ;TRYING TO DO I/O?
TRNN T2,CI.BSY!CI.DON ;YES, IS BUSY OR DONE UP?
JRST CONEC1 ;NO
;HERE WHEN WE ARE TRYING TO DO AN I/O OPERATION AND BUSY OR DONE
;IS STILL UP IN THE RH20 CONI. TRY TO FORCE THE RH20 INTO A
;REASONABLE STATE, FIRST GENTLY AND, IF THAT FAILS, BY BLASTING IT.
PUSH P,T1 ;SAVE FUNCTION
PUSHJ P,RDREG ;READ THE REGISTERS
POP P,T1 ;RESTORE FUNCTION
MOVSI T2,UNPHNG##+UNPFIR## ;IF NOT IN ERROR RECOVERY,
SKIPGE UNIECT##(U) ; SET A FLAG
MOVEM T2,UNIECT##(U) ; FOR FILIO
XCT RNXCI2##(J) ;GET THE CONI BACK
MOVEI T4,CO.MBE!CO.STP ;GET BITS TO CLEAR BUSY, SET DONE
TRNE T2,CI.BSY ;IS BUSY STILL UP?
XCT RNXCO4##(J) ;YES, ATTEMPT TO CLEAR IT
AOS UNIHNG##(U) ;COUNT THE OCCURRANCE
MOVEI T2,CO.MBE!CO.CLR ;GET BITS TO CLEAR DONE
XCT RNXCO2##(J) ;DO SO
XCT RNXCI2##(J) ;GET THE CONI BACK
TRNE T2,CI.BSY ;IS BUSY STILL SET?
JRST CONERR ;YES, CALL THE DRIVE DOWN
TRNN T2,CI.DON ;HOW ABOUT DONE?
JRST CONEC1 ;CLEAR, CONTINUE WITH SETUP
PUSHJ P,CLRRH2 ;BLAST THE RH20
XCT RNXCI2##(J) ;GET THE CONI BACK
TRNE T2,CI.BSY!CI.DON ;DID WE MANAGE TO CLEAR IT UP?
JRST CONERR ;NO, GIVE UP AND CALL IT OFFLINE
;HERE WHEN THE RH20 IS IN SOME KIND OF REASONABLE STATE TO START THE
;OPERATION. MAKE SURE THAT THE DX20 IS ALSO IN SOME REASONABLE STATE
;AND CONTINUE THE FINAL SETUP.
CONEC1: SETZ T4, ;LET THIS COMMAND GO THROUGH
CONEC2: SKIPL RNXFLG##(J) ;MUST KNOW THE CONTROLLER ADDRESS
JRST CONOFL ;CALL THE DRIVE OFF-LINE
PUSHJ P,MPRUN ;IS THE DX20 STILL RUNNING?
AOSA T2,@RNXRSC##(J) ;NO, COUNT THIS
JRST CONEC3 ;YES, CONTINUE
CAIG T2,MAXRSC ;ALREADY RESTARTED IT TOO MANY TIMES?
PUSHJ P,MPCHKS ;NO, TRY TO RESTART IT AGAIN
JRST CONMPS ;FAILED, CALL THE DRIVE OFF-LINE
CONEC3: JUMPN T4,CONEC5 ;DON'T TOUCH HARDWARE IF TOSSING COMMAND
TRNE T1,CR.IOP ;THIS AN I/O FUNCTION?
TRNE T1,CR.RED ;YES, A WRITE?
JRST CONEC4 ;NO, DON'T CARE ABOUT WRITE PROTECT
MOVSI T2,UNPHWP## ;GET HARDWARE WRITE PROTECT BIT
TDNE T2,UNIDES##(U) ;IS THE UNIT WRITE PROTECTED?
JRST CONHWP ;YES
CONEC4: MOVSI T2,UNPOFL## ;GET OFF-LINE BIT (SET BY CHKERR)
TDNE T2,UNIDES##(U) ;DRIVE OFF-LINE?
JRST CONOFL ;YES
PUSHJ P,SETDRV ;SETUP TO TALK TO THAT DRIVE
STORE T2,RNXCMD##(J),CM.DVA ;STORE DRIVE ADDRESS
CONEC5: MOVE T2,UNIBLK##(U) ;GET THE BLOCK WE WANT TO ACCESS
LDB T3,UNYBPY## ; AND THE NUMBER OF BLOCKS/CYLINDER
IDIVI T2,(T3) ;T2=CYLINDER, T3=REMAINDER
MOVEM T2,UNICYL##(U) ;STORE IN UDB
HRLI T2,(.DXDCR) ;SETUP REGISTER SELECT FOR DCR
PUSH P,T2 ;SAVE CYLINDER
MOVE T2,T3 ;MOVE REMAINDER TO T2
LDB T3,UNYBPT## ;GET NUMBER OF BLOCKS PER TRACK
IDIVI T2,(T3) ;T2=TRACK, T3=BLOCK
STORE T2,T3,DA.TRK ;STORE IN CORRECT PLACE IN T3
HRLI T3,(.DXDAR) ;SETUP REGISTER SELECT FOR DAR
JRST T2POJ1## ;RESTORE T2 AND GIVE SKIP RETURN
;HERE WHEN AN ERROR WAS DETECTED IN EITHER THE RH20 OR DX20 DURING
;THE SETUP. READ THE REGISTERS AND RETURN AN ERROR INDICATION TO FILIO.
CONHWP: TDZA T1,T1 ;SET NO FLAGS IF WRITE PROTECTED
CONMPS: PUSHJ P,RNXSSB ;SET KOPMPS FOR KONTROLLER
CONOFL: PUSHJ P,RDREG ;READ THE REGISTERS
JUMPE T1,CPOPJ## ;GO IF HARDWARE WRITE PROTECTED
CONERR: MOVEI T1,KOPOFL## ;SET BIT FOR OFF-LINE
POPJ P, ; AND RETURN
;ROUTINE TO CHECK IF THE RH20 HAS A PI
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXALV
;RETURN CPOPJ ALWAYS
RNXALV::XCT RNXCI2##(J) ;CONI
TRNE T2,7 ;IS IT ALIVE?
POPJ P, ;YES
PUSHJ P,CLRRH2 ;NO, CLEAR THE RH
PJRST REASPI ;GIVE IT A PI AND RETURN
SUBTTL ERROR ANALYSIS ROUTINES
;ROUTINE TO CHECK TO SEE IF THE DX20 MICROCODE DETECTED AN ERROR
;IN THE LAST OPERATION.
;CALL:
; J/KDB ADDRESS
; T1/ERROR BITS
; P1/FLAGS FROM RNXCMD OR 0 IF NO OPERATION IN PROGRESS
; P2/ENDING STATUS REGISTER
; P3/CHANNEL STATUS OR 0,,CONI
; PUSHJ P,CHKERR
;RETURN CPOPJ ALWAYS WITH AC'S AS ABOVE AND:
; LH(P2)/ERROR REGISTER IF ERRORS
CHKERR: MOVSI T2,(.DXSTR) ;POINT AT STATUS REGISTER
PUSHJ P,DODTI ;READ IT
TRNN T2,ST.RUN ;IS MICROPROCESSOR STILL RUNNING?
JRST FTLERR ;NO
TRNN T2,ST.CER ;COMPOSITE ERROR UP?
POPJ P, ;NO, NO ERRORS
MOVSI T2,(.DXERR) ;POINT AT ERROR REGISTER
PUSHJ P,DODTI ;READ IT
HRLI P2,(T2) ;MOVE TO P2
TLNE P2,ER.ERR ;ANY GENERIC HARDWARE FAILURES?
TRO T1,IODERR ;YES, FLAG A DEVICE ERROR
TLNN P2,ER.UPE ;MICROPROCESSOR ERROR?
POPJ P, ;NO, CODE IS MEANINGLESS
LOAD T2,P2,<ER.ECC_^D18> ;GET ERROR CODE IN T2
CAIL T2,ERRTBL ;IN THE RANGE WE KNOW ABOUT?
JRST FTLERR ;NO, THAT'S FATAL
JRST @ERRTAB(T2) ;DISPATCH TO PROCESSING ROUTINE
;THE FOLLOWING TABLE GIVES THE DISPATCH ADDRESS FOR EACH CLASS OF ERROR.
ERRTAB: EXP FTLERR ;0 - UNKNOWN
EXP UDSERR ;1 - UNUSUAL DEVICE STATUS
EXP RLNERR ;2 - RECORD LENGTH ERROR
EXP SELERR ;3 - DEVICE SELECTION ERROR
EXP RCVERR ;4 - RECOVERABLE ERROR
EXP RTYERR ;5 - COMMAND RETRY REQUEST
EXP NRCERR ;6 - NON-RECOVERABLE ERROR
EXP LOGUPE ;7 - RETRY LOG INFORMATION, LOG IT
EXP FTLERR ;10 - FATAL ERROR
EXP FTLERR ;11 - MICRODIAGNOSTIC FAILURE
EXP RLDERR ;12 - MICROCODE RELOAD FOR INFORMATION
ERRTBL==.-ERRTAB
;HERE ON UNUSUAL DEVICE STATUS
UDSERR: TRNN P2,ES.UCK ;UNIT CHECK UP IN ENDING STATUS BYTE?
JRST RCVERR ;NO, JUST CALL IT RECOVERABLE
MOVEI T2,.ESSB0 ;INDEX INTO EST TO GET SENSE BYTES
PUSHJ P,RDEST ;READ SENSE BYTES 0-3
MOVEI T2,0 ;SHOULDN'T HAPPEN, DEFAULT TO ZERO BYTES
JUMPE P1,UDSER1 ;DON'T KNOW DRIVE IF NO OPERATION
MOVSI T3,UNPHWP## ;GET WRITE PROTECT BIT
TLNE T2,(S1.WRI) ;WRITE INHIBITED?
IORM T3,UNIDES##(U) ;YES, SET THE BIT IN THE UDB
TLNE T2,(S0.IRQ) ;INTERVENTION REQUIRED?
JRST SELERR ;YES, CALL THE DRIVE OFF-LINE
UDSER1: TLNE T2,(S0.DTC) ;DATA CHECK?
TROA T1,IODTER ;YES, CALL IT A DATA ERROR
TRO T1,IODERR ;NO, FLAG A DEVICE ERROR
MOVEI T2,.ESSB7 ;EST INDEX TO GET SENSE BYTE 7
PUSHJ P,RDEST ;READ IT (ACTUALLY 4-7)
MOVEI T2,0 ;SHOULDN'T HAPPEN, DEFAULT TO 0
ANDI T2,EB.S07 ;KEEP JUST THE ONE BYTE
CAIN T2,.S7ECC ;ECC ERROR?
TRO T1,IOECCX ;YES, SET BIT FOR FILIO
POPJ P, ;RETURN
;HERE ON A RECORD LENGTH ERROR
RLNERR: SKIPE DINITF## ;IN ONCE-ONLY?
TLNN P1,(CM.IO) ; AND DOING A READ?
JRST RLNER1 ;NO
TRNE T1,ALLERR ;ANY OTHER ERRORS DETECTED SO FAR?
POPJ P, ;YES, THEY TAKE PRECEDENCE
TDZ P3,[CS.SWC!CS.OVR!CI.OVR] ;NO, MUST BE ONCE READING THE
TLZA P2,-1 ; HOME BLOCKS OF A TOPS20 FORMATTED PACK
RLNER1: TRO T1,IODERR ;ELSE FLAG A DEVICE ERROR
POPJ P, ;RETURN
;HERE ON A DEVICE SELECTION ERROR
SELERR: MOVSI T3,UNPOFL## ;GET OFF-LINE BIT
SKIPE P1 ;DON'T NO WHAT DRIVE IF NO OPERATION
IORM T3,UNIDES##(U) ;MARK THE DRIVE OFF-LINE
;; PJRST RCVERR ;FALL INTO RCVERR
;HERE ON RECOVERABLE ERROR
RCVERR: TRO T1,IODERR ;FLAG DEVICE ERROR
POPJ P, ;RETURN
;HERE ON COMMAND RETRY REQUEST
RTYERR: TRO T1,IODERR ;FLAG DEVICE ERROR
MOVSI T2,(.DXFLG) ;POINT AT FLAG REGISTER
PUSHJ P,DODTI ;READ IT
TRZ T2,FA.RTY ;CLEAR RETRY REQUEST BIT
HRLI T2,(.DXFLG) ;SET TO CLEAR IT
PJRST DODTO ;CLEAR BIT AND RETURN
;HERE ON NON-RECOVERABLE ERROR
NRCERR:
;HERE ON FATAL ERROR OR UNKNOWN CODE
FTLERR: TRO T1,IODERR ;FLAG DEVICE ERROR
MOVSI T2,(RN.FTL) ;FLAG THIS FOR CALL TO RNXERR
IORM T2,RNXFLG##(J) ; AS UNRECOVERABLE
POPJ P, ;RETURN
;HERE ON MICROCODE RELOAD. DETERMINE WHICH UNITS ON THIS DX20
;ARE OFFLINE WAITING FOR OPERATOR INTERVENTION AND GIVE A FREE
;ATTENTION INTERRUPT TO FILIO FOR THOSE DRIVES. THIS MEANS THAT
;RELOADING THE MICROCODE SHOULD BE SUFFICIENT TO RESTART ANY JOBS THAT
;ARE STOPPED WITH OFFLINE MESSAGES BECAUSE THE DX20 STOPPED.
RLDERR: PUSHJ P,LOGUPE ;LOG IT SINCE MPCHK WILL BLAST THE REGISTERS
PUSHJ P,MPCHKS ;MAKE SURE IT'S VALID MICROCODE
JRST FTLERR ;IT'S NOT, CALL IT FATAL
SETZM @RNXRSC##(J) ;CLEAR RESTART COUNTER
PUSHJ P,RNXCSB ;CLEAR THE BIT IN THE KDB
PUSHJ P,SAVE2## ;SAVE P1-P2
;HERE FOR EACH KDB ASSOCIATED WITH THIS DX20 WITH THE KDB ADDRESS IN
;J TO LOOK AT ALL UDB'S TO SEE IF WE SHOULD GIVE FILIO AN ATTENTION
;INTERRUPT FOR THE UNIT.
RLDER1: PUSH P,U ;SAVE U
MOVE P1,KONTBP##(J) ;GET AOBJN POINTER TO UDB TABLE
MOVEI P2,0 ;START WITH NO BITS TO SET
RLDER2: HRRZ U,(P1) ;GET THE NEXT KDB ADDRESS
JUMPE U,RLDER3 ;GO IF NO UDB
MOVE T2,UNISTS##(U) ;GET THE UNIT STATUS FOR THIS UDB
LDB T3,UNYPUN## ;PLUS THE PHYSICAL UNIT NUMBER ON THE KDB
CAIE T2,OWCOD## ;IS IT IN ONE OF THE STATES WAITING FOR
CAIN T2,OCOD## ; OPERATOR INTERVENTION?
IOR P2,BITTBL##(T3) ;YES, SET THE CORRESPONDING BIT IN P2
RLDER3: AOBJN P1,RLDER2 ;LOOP FOR ALL UDB'S ON THIS KDB
IORM P2,RNXATN##(J) ;SET THE APPROPRIATE ATTENTION BITS
JRST UPOPJ## ;RESTORE U AND RETURN
SUBTTL ERROR LOGGING ROUTINES
;ROUTINE TO READ THE "REGISTERS" INTO KONEBK FOR THE RP20.
;ENTER AT RDREG FOR INTERNAL CALL.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXREG
;RETURN CPOPJ ALWAYS
;DESTROYS T2-T3
RNXREG::PUSHJ P,SETRH2 ;SET IVI, MBE, PIA
RDREG: PUSHJ P,SAVE2## ;SAVE P1-P2
MOVSI T2,(.DIPBA) ;POINT AT RH20 PBAR
PUSHJ P,DODTIC ;READ IT
MOVEM T2,KONEDB##(J) ;STORE IN KDB
MOVSI T2,(.DIPTC) ;POINT AT RH20 PTCR
PUSHJ P,DODTIC ;READ IT
MOVEM T2,KONECR##(J) ;STORE IN KDB
MOVE T2,KONIOC##(J) ;GET ADDRESS OF LOGOUT AREA
MOVE T2,.CSICW(T2) ;GET INITIAL CHANNEL JUMP WORD
MOVEI T3,0 ;ASSUME NO IOWDS
TRNE T2,-1 ;ANY ADDRESS?
MOVE T3,0(T2) ;YES, GET FIRST CCW
MOVEM T3,KONEBK##+.EBCC1(J) ;STORE IT
TRNE T2,-1 ;ANY ADDRESS?
MOVE T3,1(T2) ;YES, GET SECOND CCW
MOVEM T3,KONEBK##+.EBCC2(J) ;STORE IT
HRLZ T2,KONIOC##(J) ;GET LOGOUT AREA ADDRESS BACK
HRRI T2,KONEBK##+.EBCS0(J) ;MAKE IT A BLT POINTER
BLT T2,KONEBK##+.EBCS2(J) ;STORE LOGOUT AREA WORDS 0-2
MOVE T2,KONCHN##(J) ;GET ADDRESS OF CHANNEL DATA BLOCK
MOVE T3,.CHMPE(T2) ;GET COUNT OF MEMORY PARITY ERRORS
MOVEM T3,KONEBK##+.EBMPE(J) ;STORE IT
MOVE T3,.CHNXM(T2) ;GET COUNT OF NXM'S
MOVEM T3,KONEBK##+.EBNXM(J) ;STORE IT
LDB T2,RNYDXN ;GET DX20 ADDRESS
LSH T2,^D9 ;SHIFT BY 9 BITS
HRLM T2,KONEBK##+.EBTYP(J) ;STORE IN KDB
;CONTINUED ON THE NEXT PAGE
;CONTINUED FROM THE PREVIOUS PAGE
;HERE TO STORE THE MASSBUS REGISTERS IN THE KDB. WE ONLY SAVE THOSE
;REGISTERS SPECIFIED BY THE BIT TABLE MBRTBL.
MOVE T2,[.EBNMR,,.EBSMR-.EBMBR] ;GET POINTER TO MASSBUS REGS
MOVEM T2,KONEBK##+.EBMBR(J) ;STORE IN KDB
MOVEI P1,KONEBK##+.EBSMR(J) ;POINT TO START OF BLOCK
MOVE P2,[MBRTBL] ;GET BIT TABLE OF REGISTERS TO SAVE
RDREG1: JUMPGE P2,RDREG2 ;IF BIT NOT SET, DON'T SAVE THIS ONE
HLLZ T2,P1 ;GET REGISTER ADDRESS
CAMN T2,[.DXMIR] ;TRYING TO READ THE IR?
TDZA T2,T2 ;YES, DO IT LATER
PUSHJ P,DODTI ;READ IT
MOVEM T2,(P1) ;STORE IN BLOCK
HRRI P1,1(P1) ;BUMP BLOCK POINTER BY 1
RDREG2: ADD P1,[1B5] ;PLUS REGISTER ADDRESS BY 1
LSH P2,1 ;SHIFT BIT TABLE BY 1
JUMPN P2,RDREG1 ;LOOP IF MORE TO READ
PUSHJ P,REDMIR ;CONDITIONALLY READ THE IR REGISTER
;HERE TO STORE THE DX20 REGISTERS IN THE KDB. THE DX20 MUST BE RUNNING
;IN ORDER TO DO THIS SINCE WE REQUEST EACH REGISTER THROUGH THE
;EXTENDED STATUS TABLE.
PUSHJ P,MPRUN ;MICROPROCESSOR STILL RUNNING?
JRST RDREG5 ;NO, ZERO COUNT AND RETURN
MOVSI P1,-.EBNDR ;BUILD AOBJN POINTER TO REGISTERS
RDREG3: MOVEI T2,(P1) ;MOVE INDEX INTO EST TO T2 FOR RDEST
PUSHJ P,RDEST ;READ APPROPRIATE SENSE BYTES
JRST RDREG4 ;QUIT IF DX20 DIDN'T RESPOND
MOVEI T3,KONEBK##+.EBSDR(J) ;GET ADDRESS OF START OF BLOCK
ADDI T3,(P1) ;OFFSET INTO IT FOR THIS REGISTER
MOVEM T2,(T3) ;STORE REGISTER IN BLOCK
AOBJN P1,RDREG3 ;LOOP FOR ALL REGISTERS
RDREG4: MOVSS P1 ;PUT NUMBER OF REGISTERS IN LH
HRRI P1,.EBSDR-.EBDVL ;PUT OFFSET IN RH
TLNN P1,-1 ;IF COUNT IS ZERO,
RDREG5: MOVEI P1,0 ;ZERO THE WHOLE WORD
MOVEM P1,KONEBK##+.EBDVL(J) ;STORE IN KDB
POPJ P, ;RETURN
;ROUTINE TO CONDITIONALLY READ THE MICROPROCESSOR INSTRUCTION
;REGISTER. WE DON'T DO THIS UNLESS THE MICROPROCESSOR IS STOPPED
;BECAUSE READING THE IR WITH IR ENABLE SET CAUSES IT TO BE LOADED
;FROM THE MICROSTORE LOCATION CURRENTLY POINTED TO BY THE PC. THIS
;SOMETIMES CAUSES IR PARITY ERRORS.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,REDMIR
;RETURN CPOPJ ALWAYS
REDMIR: DMOVE T2,KONEBK##+.EBSMR+.EBM00(J) ;GET CONTROL AND STATUS REGS
TRNN T2,CR.GO ;IS GO STILL UP?
TRNE T3,ST.RUN ;NO, IS THE UCODE STILL RUNNING?
POPJ P, ;YES, DON'T READ THE REGISTER
MOVSI T2,(.DXPCR) ;SETUP TO READ THE PC REGISTER
PUSHJ P,DODTI ;DO SO
TRZ T2,PC.IRE ;TURN OFF IR ENABLE
HRLI T2,(.DXPCR) ;PUT THE REGISTER NUMBER BACK
PUSHJ P,DODTO ;WRITE OFF IR ENABLE
MOVSI T2,(.DXMIR) ;POINT TO IR REGISTER
PUSHJ P,DODTI ;READ IT
MOVEM T2,KONEBK##+.EBSMR+.EBM30(J) ;STORE WHERE IT BELONGS
POPJ P, ;RETURN
;ROUTINE TO CALL DAEMON TO LOG AN ERROR THAT FILIO WILL NOT, E.G.,
;POSITIONING ERRORS, MICRODIAGNOSTICS FAILURES WHILE NO OPERATION
;IS IN PROGRESS, ETC.
;CALL:
; J/KDB ADDRESS
; P1/FLAGS FROM RNXCMD
; P3/CHANNEL STATUS OR 0,,CONI
; PUSHJ P,LOGUPE
;RETURN CPOPJ ALWAYS
LOGUPE: SKIPE DINITF## ;IN ONCE-ONLY?
POPJ P, ;YES, CAN'T LOG THEM THIS EARLY
PUSHJ P,SAVT## ;SAVE T1-T4
PUSH P,U ; AND U
PUSH P,F ; AND F
MOVSI T2,1 ;COUNT THE NUMBER OF TIMES WE
ADDM T2,RNXEC1##(J) ; WERE CALLED TO LOG AN ERROR
PUSHJ P,RDREG ;READ THE REGISTERS
HRRZ U,KONTBP##(J) ;GET BASE ADDRESS OF UDB TABLE
LOAD T2,P1,CM.UNF ;GET UNIT NUMBER FOR OPERATION
ADDI U,(T2) ;OFFSET TO CORRECT WORD IN TABLE
HRRZ U,(U) ;GET UDB ADDRESS
JUMPE U,FUPOPJ## ;QUIT IF NO UDB
SKIPL UNIECT##(U) ;IF THIS UDB IS IN ERROR RECOVERY, DON'T
JRST FUPOPJ## ;OVERWRITE THE (MORE IMPORTANT) DATA
MOVEI F,DSKDDB## ;GET THE GENERIC DDB
PUSHJ P,FSTREG## ;COPY INITIAL REGISTERS TO UDB
PUSHJ P,LSTER## ; PLUS FINAL REGISTERS
MOVEM P3,UNISOF##(U) ;STORE INITIAL CONI
MOVEM P3,UNIERR##(U) ; AND FINAL CONI
MOVEI T1,.ERDPE ;GET CODE FOR DISK ERROR
HRL T1,F ;PUT DDB ADDRESS IN LH(T1)
PUSH P,J ;DAEEIM SMASHES J
PUSHJ P,DAEEIM## ;TELL DAEMON
POP P,J ;RESTORE J
JRST FUPOPJ## ;RESTORE F, U AND RETURN
;ROUTINE TO REQUEST AND THEN READ INFORMATION FROM THE TWO EXTENDED
;STATUS REGISTERS IN THE DX20. THE INFORMATION THAT IS RETURNED IS
;A FUNCTION OF THE VALUE OF THE STATUS INDEX WHICH IS AN INPUT ARGUMENT
;TO THIS ROUTINE.
;CALL:
; T2/STATUS INDEX
; J/KDB ADDRESS
; PUSHJ P,RDEST
;RETURN CPOPJ IF THE DX20 DIDN'T RESPOND TO THE HANDSHAKE
; CPOPJ1 IF WE GOT THE DATA WITH:
; T2/.DXES1,,.DXES2
RDEST: PUSHJ P,SAVE1## ;GET A REGISTER TO USE
IOR T2,[.DXESR!ES.SUI] ;SET REGISTER AND REQUEST UPDATE
PUSHJ P,DODTO ;ASK THE DX20 FOR THE REGISTERS
MOVEI P1,^D1000 ;TIME TO WAIT FOR THE BIT TO CLEAR
RDEST1: MOVSI T2,(.DXESR) ;POINT TO STATUS INDEX REGISTER
PUSHJ P,DODTI ;READ IT
TRNE T2,ES.SUI ;DID THE DX20 CLEAR THE BIT YET?
SOJG P1,RDEST1 ;NO, LOOP
JUMPLE P1,CPOPJ## ;RETURN NON-SKIP IF THE DX20 DIDN'T RESPOND
MOVSI T2,(.DXES2) ;POINT AT SECOND EXTENDED STATUS REGISTER
PUSHJ P,DODTI ;READ IT
PUSH P,T2 ;SAVE FOR LATER
MOVSI T2,(.DXES1) ;POINT AT FIRST REGISTER
PUSHJ P,DODTI ;READ IT
HRLM T2,0(P) ;STORE IN LH OF STACK LOCATION
JRST T2POJ1## ;GIVE SKIP RETURN WITH VALUE IN T2
SUBTTL MISCELLANEOUS SUPPORT SUBROUTINES
;ROUTINE TO SET .DXDNM TO THE DRIVE NUMBER OF THE DRIVE FOR WHICH
;WE ARE ABOUT TO PERFORM AN OPERATION.
;CALL:
; J/KDB ADDRESS
; U/UDB ADDRESS
; PUSHJ P,SETDRV
;RETURN CPOPJ ALWAYS WITH:
; RH(T2)/DRIVE ADDRESS
;DESTROYS T3
SETDRV: LDB T2,UNYPUN## ;GET PHYSICAL UNIT NUMBER FROM UDB
LDB T3,RNYDCA ;GET CONTROL UNIT ADDRESS FROM KDB
LSH T3,4 ;POSITION IT
IOR T2,T3 ;BUILD FULL DRIVE ADDRESS
;; PJRST WDVNUM ;FALL INTO WDVNUM
;ROUTINE TO SET .DXDNM TO THE DRIVE NUMBER OF THE DRIVE FOR WHICH
;WE ARE ABOUT TO PERFORM AN OPERATION
;CALL:
; T2/DRIVE ADDRESS
; J/KDB ADDRESS
; PUSHJ P,WDVNUM
;RETURN CPOPJ ALWAYS WITH:
; RH(T2)/DRIVE ADDRESS
WDVNUM: HRLI T2,(.DXDNM) ;GET REGISTER TO WRITE
PJRST DODTO ;WRITE REGISTER AND RETURN
;ROUTINE TO WAIT FOR A COMMAND TO COMPLETE AND CALL RNXINR TO PROCESS
;IT BEFORE STARTING A NEW COMMAND.
;CALL:
; T1/CURRENT COMMAND
; T4/FLAGS FROM RNXCMD FOR OLD COMMAND
; U/UDB ADDRESS
; J/KDB ADDRESS
; PUSHJ P,CMDWAT
;RETURN CPOPJ ALWAYS WITH:
; T4/NON-ZERO TO TOSS THIS COMMAND
;PRESERVES T1, U
CMDWAT: AOS RNXEC2##(J) ;COUNT NUMBER OF TIMES WE GOT HERE
JUMPGE T4,CMDWA2 ;GO IF PREVIOUS COMMAND NOT AN XFER
PUSHJ P,RDREG ;READ THE REGISTERS FOR THE DUMP
STOPCD CPOPJ##,DEBUG,KCP, ;++KDB COMMAND IN PROGRESS
CMDWA2: MOVEI T2,^D2000 ;WAIT FOR THE COMMAND
PUSHJ P,WGOCLR ; TO FINISH
JUMPLE T2,CMDWA3 ;JUMP IF GO STILL UP
PUSHJ P,SAVE3## ;RNXINR DESTROYS P1-P2
PUSH P,T1 ; AND T1
PUSH P,U ; AND U
PUSHJ P,RNXINR ;DO SUBSET OF INTERRUPT PROCESSING
POP P,U ;RESTORE U
SETZ T4, ;LET THIS COMMAND THROUGH
JRST TPOPJ## ;RESTORE T1 AND RETURN
;HERE IF THE GO BIT DIDN'T COME DOWN IN TIME.
;EXIT FROM THE NEW COMMAND WITHOUT DOING ANYTHING.
;WAIT FOR THE PREVIOUS COMMAND TO FINISH, THEN TELL
;FILIO THAT THE NEW COMMAND IS FINISHED (THIS IS A LIE).
;IF THE NEW COMMAND IS A TRANSFER, THEN TELL FILIO "POSITION DONE".
;FILIO WILL THINK HE'S IN THUNG RECOVERY AND WILL RE-ISSUE THE
;TRANSFER COMMAND.
;IF THE NEW COMMAND IS A POSITION, THEN TELL FILIO "RECAL DONE".
;FILIO WILL THINK HE'S IN PHUNG RECOVERY AND WILL RE-ISSUE THE
;POSITION COMMAND.
CMDWA3: MOVSI T4,(1B0) ;RECAL BIT (PHUNG RECOVERY)
CAIN T1,.DXCTR!.CRSRC;POSITION COMMAND?
IORM T4,UNISTS##(U) ;YES, TELL FILIO "RECAL DONE"
LDB T4,UNYPUN## ;GET PHYSICAL UNIT NUMBER OF UNIT
MOVE T4,BITTBL##(T4) ;GET CORRESPONDING BIT
IORM T4,RNXATN##(J) ;SET IN KDB FOR INTERRUPT
MOVSI T4,1 ;COUNT THIS EVENT
ADDM T4,RNXEC2##(J) ; IN THE KDB
POPJ P, ;RETURN WITH T4 NON-ZERO
;ROUTINE TO WAIT FOR THE GO BIT TO CLEAR IN THE CONTROL REGISTER.
;CALL:
; J/KDB ADDRESS
; T2/LOOP COUNT TO WAIT BEFORE TIMING OUT
; PUSHJ P,WGOCLR
;RETURN CPOPJ ALWAYS WITH:
; T2/LOOP COUNT AT WHICH GO BIT CLEARED
;DESTROYS T2,T3
WGOCLR: PUSH P,T2 ;SAVE LOOP COUNT
WGOCL1: MOVSI T2,(.DXCTR) ;POINT AT CONTROL REGISTER
PUSHJ P,DODTI ;READ IT
TRNN T2,CR.GO ;GO BIT STILL UP?
JRST T2POPJ## ;NO, RETURN
SOSLE 0(P) ;DECREMENT LOOP COUNT
JRST WGOCL1 ;AND LOOP
AOS RNXEC1##(J) ;COUNT NUMBER OF TIMES GO BIT DIDN'T CLEAR
JRST T2POPJ## ;TIMED OUT, RETURN ANYWAY
;ROUTINE TO CLEAR THE ATTENTION SUMMARY REGISTER FOR THIS DX20. WE
;ALSO CHECK TO MAKE SURE THAT NO SPURIOUS ATTENTION BITS HAVE COME UP
;FOR SOME OTHER DEVICE ON THIS RH20 AND MAKE SURE THAT THEY ARE
;CLEARED.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,CLRATN
;RETURN CPOPJ ALWAYS
;DESTROYS T2,T3
CLRATN: PUSH P,T4 ;SAVE T4 (SEE RNXCPY)
MOVEI T4,1 ;GET A BIT TO SHIFT
LDB T2,RNYDXN ;GET DX20 MASSBUS SLOT
LSH T4,(T2) ;SHIFT TO CORRECT POSITION
HRLS T4 ;COPY TO LH
TLC T4,AT.ATN ;MAKE IT ALL BUT THAT BIT IN LH
MOVSI T2,(.DXASR) ;SET TO READ ATTENTION SUMMARY REGISTER
PUSHJ P,DODTI ;READ IT
; TSNE T2,T4 ;ANY UNEXPECTED ATTENTION BITS SET?
; PUSHJ P,LOGUPE ;YES, LOG THIS AS AN ERROR
TRNN T2,AT.ATN ;ANY ATTENTION BITS TO CLEAR?
JRST CLRAT2 ;NO, EXIT
HRLI T2,(.DXASR) ;SET TO CLEAR THE BITS WE READ
PUSHJ P,DODTO ;CLEAR THE ATTENTION BITS
MOVSI T2,(.DXASR) ;SET TO READ THE REGISTER AGAIN
PUSHJ P,DODTI ;READ IT
TSNE T2,T4 ;STILL HAVE UNEXPECTED BITS SET?
JRST CLRAT1 ;YES, HAVE TO BLAST THE RH20 THEN
TDNN T2,T4 ;STILL HAVE THE DX20 BIT UP?
JRST CLRAT2 ;NO, EXIT
AOS T2,RNXAEC##(J) ;INCREMENT RETRY COUNT OF TIMES TO CLEAR IT
TLZ T2,-1 ;CLEAR LEFT HALF
CAIG T2,ATNRTY ;FAIL TO CLEAR IT TOO MANY TIMES?
JRST T4POPJ## ;BELOW THE THRESHOLD, JUST EXIT
; PUSHJ P,LOGUPE ;LOG THIS AS AN ERROR
CLRAT1: MOVSI T2,1 ;INCREMENT THE LEFT HALF TO
ADDM T2,RNXAEC##(J) ; INDICATE THAT WE DID SOMETHING
PUSHJ P,CLRRH2 ;BLAST THE RH20 TO CLEAR THE BITS
CLRAT2: HLLZS RNXAEC##(J) ;CLEAR RH OF RETRY COUNT WORD
JRST T4POPJ## ;RESTORE T4 AND EXIT
;The calls to LOGUPE are not assembled because CLRATN is called from
;RNXCPY without P1 and P3 containing the data that LOGUPE wants in
;those ACs. We really need a BUGCHK mechanism for this kind of
;thing.
;ROUTINE TO CLEAR THE ERROR REGISTER IN THE DX20.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,CLRERG
;RETURN CPOPJ ALWAYS
;DESTROYS T2,T3
CLRERG: MOVSI T2,(.DXERR) ;POINT AT ERROR REGISTER
PJRST DODTO ;CLEAR IT AND RETURN
;ROUTINES TO SET/CLEAR KOPMPS IN THE KDB WHEN THE MICROPROCESSOR
;STOPS/RESTARTS.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNX?SB
;RETURN CPOPJ ALWAYS
;DESTROYS T2
RNXCSB::SKIPA T2,[ANDCAM T2,KONMPS##(J)] ;GET INSTR TO CLEAR BIT
RNXSSB: MOVE T2,[IORM T2,KONMPS##(J)] ;OR INSTR TO SET BIT
PUSH P,T2 ;SAVE INSTRUCTION
MOVSI T2,KOPMPS## ;GET THE BIT
XCT 0(P) ;SET/CLEAR IT
JRST T2POPJ## ;BRING STACK INTO PHASE AND RETURN
;ROUTINE TO READ THE DRIVE TYPE REGISTER FOR THE DX20 AND CHECK
;TO MAKE SURE THAT IT IS CORRECT FOR THE RP20.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,CHKDTR
;RETURN CPOPJ IF NOT A DX20 FOR AN RP20
; CPOPJ1 IF MATCH WITH:
; T2/CONTENTS OF REGISTER
CHKDTR: MOVSI T2,(.DXDTR) ;POINT AT DRIVE TYPE REGISTER
PUSHJ P,DODTI ;READ IT
PUSH P,T2 ;SAVE FOR RETURN
ANDI T2,DT.COD ;MASK OFF JUST THE DRIVE TYPE
CAIN T2,.DTCOD ;DOES IT MATCH?
AOS -1(P) ;YES, GIVE SKIP RETURN
PJRST T2POPJ ;RETURN VALUE IN T2
;ROUTINE TO ASSIGN AN INTERRUPT VECTOR ADDRESS TO THE RH20 AND
;GIVE IT A PIA WITH OR WITHOUT ATTENTION INTERRUPT ENABLE DEPENDING
;ON WHAT'S HAPPENING.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,SETRH2
;RETURN CPOPJ ALWAYS
;PRESERVES ALL AC'S
SETRH2: PUSHJ P,RNXIVI ;ASSIGN IVI, ENABLE MASSBUS
; PJRST REASPI ;FALL INTO REASPI
;ROUTINE TO REASSIGN THE PIA FOR THE RH20 WITH OR WITHOUT ATTENTION
;INTERRUPT ENABLE DEPENDING ON WHAT'S HAPPENING.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,REASPI
;RETURN CPOPJ ALWAYS
;PRESERVES ALL AC'S
REASPI: PUSH P,T4 ;SAVE T4
PUSHJ P,SETCO ;SETUP CONO MASK
XCT RNXCO4##(J) ;LIGHT PIA, POSSIBLY AIE
JRST T4POPJ## ;RESTORE T4 AND RETURN
;ROUTINE TO FORCE THE RH20 AND CONNECTED DEVICES INTO A KNOWN STATE.
;THIS INVOLVES DOING A MASSBUS INIT, A STOP TRANSFER, AND A CLEAR
;DONE. WE THEN HAVE TO REASSIGN THE RH20 IVI AND RESTART THE MICRO-
;PROCESSOR.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,CLRRH2
;RETURN CPOPJ ALWAYS
CLRRH2: MOVEI T2,CO.MBI ;THE ONLY THING LEFT TO DO IS TO
XCT RNXCO2##(J) ; BLAST THE RH20. DO A MASSBUS INIT FIRST
MOVEI T2,CO.MBE!CO.STP ;THEN A
XCT RNXCO2##(J) ; STOP TRANSFER
MOVEI T2,CO.MBE!CO.CLR ;AND FINALLY A
XCT RNXCO2##(J) ; CLEAR DONE
PUSHJ P,RNXIVI ;GIVE IT AN IVI AGAIN SINCE MBI BLASTS IT
PJRST RNXMPS ;START THE MICROPROCESSOR GOING AGAIN
;ROUTINE TO ASSIGN AN INTERRUPT VECTOR ADDRESS TO THE RH20.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXIVI
;RETURN CPOPJ ALWAYS
;PRESERVES ALL AC'S
RNXIVI::PUSHJ P,SAVT## ;SAVE T1-T4
MOVEI T2,CO.MBE ;ENABLE MASSBUS TRANSCEIVERS
XCT RNXCO2##(J) ; FIRST
LDB T2,KOYPI## ;GET PI ASSIGNMENT
LSH T2,1 ;COMPUTE AN INTERRUPT
ADDI T2,40 ; ADDRESS OF 40+2N
HRLI T2,(.DOIVI) ;POINT TO PROPER REGISTER
PJRST DODTO ;WRITE REGISTER AND RETURN
;ROUTINE TO SETUP A CONO MASK WITH THE PIA AND POSSIBLY ATTENTION
;INTERRUPT ENABLE IF NO TRANSFER IS TAKING PLACE.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,SETCO
;RETURN CPOPJ ALWAYS WITH:
; T4/CONO MASK
SETCO: LDB T4,KOYPI## ;GET PIA FOR THE RH20
TRO T4,CO.MBE ;SET TO ENABLE MASSBUS TRANSCEIVERS
SKIPL RNXCMD##(J) ;TRANSFER IN PROGRESS?
TRO T4,CO.AIE ;NO, ALLOW INTERRUPTS ON ATTENTIONS
POPJ P, ;RETURN
;ROUTINE TO SET A BIT IN RNXATN CORRESPONDING TO A DRIVE NUMBER
;WHICH JUST COMPLETED A POSITION OPERATION.
;CALL:
; T2/DRIVE NUMBER (ALL 4 BITS)
; PUSHJ P,POSDON
;RETURN CPOPJ ALWAYS
POSDON: MOVE T3,BITTBL##(T2) ;GET THE APPROPRIATE BIT
IORM T3,RNXATN##(J) ;SET BIT IN KDB
HRRZ T3,T2 ;COPY 4 BIT DRIVE ADDRESS
ADD T3,KONTBP##(J) ;POINT AT UDB ADDRESS SLOT IN KDB
SKIPN T3,(T3) ;GET UDB ADDRESS
JRST POSDO3 ;NO UDB, CALL NEWDSK
MOVSI T2,UNPHWP## ;GET HARDWARE WRITE PROTECT BIT
SKIPE T4,UNISTS##(T3) ;UNIT IDLE?
CAIL T4,OWCOD## ; OR SOME FORM OF OPERATOR WAIT?
ANDCAM T2,UNIDES##(T3) ;CLEAR HARDWARE WRITE PROTECT BIT
POPJ P, ;RETURN
;HERE IF THERE WAS NO UDB FOR THE DRIVE. CALL NEWDSK TO TELL THE
;MONITOR THAT A NEW DRIVE JUST CAME ON-LINE. T2 CONTAINS THE 4 BIT
;DRIVE ADDRESS OF THE UNIT THAT CAME ON-LINE.
POSDO3:
IFE FTAUTC,<
POPJ P, ;CHUCK IT IF NO AUTCON
>
IFN FTAUTC,<
PUSHJ P,SAVT## ;SAVE THE T AC'S
MOVEI T1,.DTCOD ;SETUP DRIVE TYPE FOR NEWDSK
HRLZS T2 ;PUT THE DRIVE NUMBER IN THE LEFT HALF
PJRST NEWDSK## ;CALL NEWDSK AND RETURN
>
SUBTTL INITIALIZATION SUPPORT SUBROUTINES
;ROUTINE TO DO TWO TEST I/O COMMANDS TO A PARTICULAR DRIVE TO SEE
;IF IT IS ON-LINE. TWO COMMANDS ARE REQUIRED BECUASE SOMETIMES THE
;8000 LIES AND SAYS THE DRIVE IS ON-LINE WHEN IT ISN'T AND THE FIRST
;ATTEMPT TO ACCESS THE DRIVE CAUSES OFF-LINE MESSAGES. TWO TEST I/O'S
;ALWAYS SEEM TO WORK (IF YOU BELIEVE...)
;CALL DOTIOC IF THE CONTROLLER AND DRIVE NUMBERS HAVE ALREADY BEEN
;WRITTEN INTO MASSBUS REGISTER .DXDNM. THIS ENTRY POINT DOES NOT
;REQUIRE THAT U BE SETUP TO THE UDB ADDRESS.
;CALL:
; U/UDB ADDRESS
; J/KDB ADDRESS
; PUSHJ P,DO2TIO
;RETURN CPOPJ IF THE DX20 DIDN'T RESPOND
; CPOPJ1 IF IT PROCESSED BOTH COMMANDS
DO2TIO: PUSHJ P,SETDRV ;SETUP TO TALK TO THE DRIVE
DOTIOC: MOVSI T2,<(.DXFLG)>+INSVL.(.FATIO,FA.FNC) ;TELL THE DX20
PUSHJ P,DODTO ; THAT IT'S A TEST I/O
PUSHJ P,DO2TI1 ;DO THE FIRST TEST I/O
POPJ P, ;RETURN IF THE DX20 DIDN'T RESPOND
DO2TI1: PUSHJ P,CLRERG ;CLEAR THE ERROR REGISTER
MOVEI T2,.DXCTR!.CRNOP ;NO-OP IS THE GENERIC COMMAND
PUSHJ P,DODTO ;START IT GOING
MOVEI T2,^D5000 ;MAX TIME TO WAIT FOR IT TO FINISH
PUSHJ P,WGOCLR ;WAIT FOR THE GO BIT TO CLEAR
JUMPG T2,CPOPJ1## ;GIVE SKIP RETURN IF THE BIT CLEARED
POPJ P, ;NON-SKIP IF IT DIDN'T
;ROUTINE TO CHECK FOR ERRORS IN THE TEST I/O SEQUENCE DONE TO
;SEE IF A UNIT IS ON-LINE.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,INIERR
;RETURN CPOPJ IF DRIVE IS ON-LINE
; CPOPJ1 IF DRIVE EXISTS BUT IS OFF-LINE
; CPOPJ2 IF DRIVE DOESN'T EXIST
INIERR: MOVSI T2,(.DXERR) ;POINT TO THE ERROR REGISTER
PUSHJ P,DODTI ;READ IT
TRNN T2,ER.UPE!ER.STP!ER.ERR ;ANY ERRORS SEEN?
POPJ P, ;NO, DRIVE IS ON-LINE
LOAD T2,T2,ER.ECC ;GET ERROR CLASS CODE
CAIE T2,.ERSEL ;WAS IT SELECT ERROR?
JRST CPOPJ1## ;NO, IT EXISTS BUT IT'S OFF-LINE
JRST CPOPJ2## ;ELSE IT DOESN'T EXIST
;ROUTINE TO FIND THE NEXT RP20 UNIT THAT EXISTS AND RETURN THE
;CONTROLLER AND UNITS NUMBERS TO AUTCON.
;CALL:
; T1/CONTROLLER ADDRESS,,UNIT ADDRESS (-1 FOR FIRST TIME)
; T2/DRIVE SELECT CODE FOR DATAO (RNYDXN)
; J/KDB ADDRESS
; PUSHJ P,RNXCFG
;RETURN CPOPJ IF NO MORE UNITS ON THIS DX20
; CPOPJ1 IF ANOTHER UNIT FOUND WITH:
; T1/CONTROLLER ADDRESS,,UNIT ADDRESS OF NEXT UNIT
RNXCFG::PUSHJ P,SAVE3## ;SAVE P1-P3
MOVE P1,T1 ;SAVE INITIAL VALUE OF T1 FOR FLAG
HLRE P2,T1 ;GET THE INITIAL CONTROLLER NUMBER
HRRE P3,T1 ; AND THE INITIAL UNIT NUMBER
DPB T2,RNYDXN ;STORE THE DRIVE SELECT CODE IN THE KDB
AOJN P3,RNXCF1 ;GO IF NOT THE FIRST TIME FOR THIS DX20
PUSHJ P,MPINI ;MAKE SURE THE MICROCODE IS VALID
POPJ P, ;IT'S NOT, GIVE UP
RNXCF1: PUSHJ P,MPRUN ;CHECK TO MAKE SURE IT'S STILL RUNNING
POPJ P, ;IT'S NOT, GIVE UP ON THAT ALSO
RNXCF2: CAIL P3,MAXSPD ;DONE ALL THE POSSIBLE UNITS YET?
POPJ P, ;YES, NO MORE UNITS FOUND
JUMPGE P1,RNXCF4 ;GO IF ALREADY HAD THE CONTROLLER ADDR
SETOM P2 ;INITIALIZE IT TO ZERO
RNXCF3: AOS P2 ;INCREMENT THE CONTROLLER ADDRESS
CAIL P2,MAXDCU ;CHECKED ALL THE ONES FOR THIS UNIT?
AOJA P3,RNXCF2 ;YES, INCREMENT THE UNIT AND CONTINUE
RNXCF4: HRRZ T2,P2 ;GET THE CONTROLLER ADDRESS
LSH T2,4 ;MAKE ROOM FOR THE UNIT NUMBER
IOR T2,P3 ;OR IN THE UNIT NUMBER
PUSHJ P,WDVNUM ;TELL THE DX20 WHICH UNIT
PUSHJ P,DOTIOC ;DO TWO TEST I/O'S ON THE DRIVE
POPJ P, ;DX20 DIDN'T RESPOND, GIVE UP
PUSHJ P,INIERR ;CHECK FOR ERRORS
JRST RNXCF5 ;ON-LINE DRIVE, RETURN IT
JRST RNXCF5 ;OFF-LINE DRIVE, RETURN IT
JUMPL P1,RNXCF3 ;TRY NEXT DCU ADDR IF NOT FOUND YET
AOJA P3,RNXCF2 ;ELSE INCREMENT UNIT ADDRESS AND CONTINUE
RNXCF5: MOVSI T1,(RN.FKA) ;SET FLAG TO AVOID THE DRIVE
IORM T1,RNXFLG##(J) ; SELECT LOOP IN RNXFKA
; DPB P2,RNYDCA ;STORE DCU
; MOVSI T1,(RN.DCA)
; IORM T1,RNXFLG##(J)
HRLZ T1,P2 ;CONTROLLER ADDRESS TO LH
HRR T1,P3 ;UNIT ADDRESS TO RH
JRST CPOPJ1## ;GIVE SKIP RETURN
SUBTTL KONTROLLER ONCE-A-SECOND CODE
;ROUTINE TO CHECK THE MICROPROCESSOR
;CALL: PUSHJ P,RNXSEC
;RETURN CPOPJ ALWAYS
RNXSEC::MOVSI T2,(.DXSTR) ;POINT AT STATUS REGISTER
PUSHJ P,DODTI ;READ IT
TRNN T2,ST.RUN ;IS MICROPROCESSOR STILL RUNNING?
SKIPG KONRLD##(J) ;NOT RUNNING--OK TO ATTEMPT RELOAD?
POPJ P, ;RETURN
PJRST RNXRLD ;GO RELOAD MICROPROCESSOR
SUBTTL MICROPROCESSOR HANDLING ROUTINES
;ROUTINE TO START ALL DX20'S FOR RP20'S ON THIS CPU IF THEY ARE NOT
;ALREADY RUNNING.
;CALL: PUSHJ P,RNXSAK
;RETURN CPOPJ ALWAYS
RNXSAK::PJSP T1,RNXAPP ;RETURN AT .+1 FOR EACH DX20
PUSHJ P,MPRUN ;THIS DX20 RUNNING?
PUSHJ P,MPCHKS ;NO, CHECK THE CRAM AND RESTART IT
POPJ P, ;ALWAYS GIVE CPOPJ RETURN
POPJ P, ;DITTO
;ROUTINE TO CALL A SUBROUTINE FOR EACH RP20 DX20 ON THIS CPU.
;CALL:
; T1/ADDRESS OF ROUTINE TO CALL
; PUSHJ P,RNXAPP
;RETURN CPOPJ ALWAYS
;THE ROUTINE BEING CALLED MUST RETURN CPOPJ ONLY.
RNXAPP: PUSHJ P,SAVT## ;SAVE THE T REGS
PUSH P,J ;DON'T SMASH J
PUSH P,T1 ;SAVE THE ROUTINE ADDRESS
MOVEI J,SYSKON##-KONNXT## ;POINT TO START OF KDB CHAIN
RNXAP1: HLRZ J,KONNXT##(J) ;STEP TO NEXT DISK KDB
JUMPE J,RNXAP2 ;GO IF END OF CHAIN
LDB T1,KOYKTP## ;GET KONTROLLER TYPE
MOVE T2,KONCAM##(J) ; AND OWNING CPU MASK
CAIN T1,TYPRN## ;THIS AN RP20?
TDNN T2,.CPBIT## ;YES, IS IT ON THIS CPU?
JRST RNXAP1 ;NO, CONTINUE
PUSHJ P,CHKDTR ;MAKE SURE IT'S REALLY AN RP20
JRST RNXAP1 ;NOT, CONTINUE
PUSHJ P,@0(P) ;CALL ROUTINE FOR THIS ONE
JRST RNXAP1 ;TRY NEXT
RNXAP2: POP P,0(P) ;BRING STACK INTO PHASE
JRST JPOPJ## ;RESTORE J AND RETURN
;ROUTINE TO CHECK THE VALIDITY OF THE MICROPROCESSOR CONTROL STORE.
;THIS INVOLVES CHECKING THREE THINGS AS FOLLOWS:
; 1. CRAM LOCATION 7 MUST CONTAIN A COPY OF THE DRIVE TYPE REGISTER
; 2. CRAM LOCATION 10 MUST CONTAIN AN OCTAL 210 (.CRM10)
; 3. DX.IPE MUST NOT COME UP WHILE READING ANY OF THE ABOVE
;STORES THE MICROCODE VERSION NUMBER IN THE KDB(S) FOR THE DX20.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,MPCHK
;RETURN CPOPJ IF AN ERROR IS DETECTED
; CPOPJ1 IF ALL OK
;PRESERVES T1
MPCHK: PUSHJ P,MPRES ;RESET THE MICROPROCESSOR
MOVE T2,[.DXPCR!PC.IRE!PC.PCE!PC.PCI!INSVL.(7,PC.MPC)] ;REGISTER TO WRITE+
; IR ENABLE+PC ENABLE+PC AUTO INCR+PC TO READ
PUSHJ P,DODTO ;WRITE THE REGISTER
MOVSI T2,(.DXMIR) ;POINT AT IR REGISTER
PUSHJ P,DODTI ;READ THE CONTENTS
PUSH P,T2 ;SAVE FOR COMPARE
MOVSI T2,(.DXDTR) ;POINT AT DRIVE TYPE REGISTER
PUSHJ P,DODTI ;READ THAT
POP P,T3 ;RESTORE CRAM LOCATION 7
CAME T2,T3 ;HAVE TO BE THE SAME
POPJ P, ;ERROR IF NOT
MOVSI T2,(.DXIPE) ;POINT AT DIAGNOSTIC REGISTER 7
PUSHJ P,DODTI ;READ IT
TRNE T2,DX.IPE ;IR PARITY ERROR ON LAST READ?
POPJ P, ;YES, THAT'S AN ERROR
MOVSI T2,(.DXMIR) ;POINT AT DIAGNOSTIC REGISTER 0 AGAIN
PUSHJ P,DODTI ;READ CRAM LOC 10 (PC AUTO INCR SET)
CAIE T2,.CRM10 ;MUST BE THIS VALUE
POPJ P, ;NOT, ERROR
MOVSI T2,(.DXIPE) ;POINT AT DIAGNOSTIC REGISTER 7
PUSHJ P,DODTI ;READ IT
TRNE T2,DX.IPE ;IR PARITY ERROR ON LAST READ?
POPJ P, ;YES, THAT'S AN ERROR
MOVE T2,[.DXPCR!PC.IRE!PC.PCE!INSVL.(0,PC.MPC)] ;SET TO READ CRAM LOC 0
PUSHJ P,DODTO ;TELL THE DX20
MOVSI T2,(.DXMIR) ;ANSWER APPEARS HERE
PUSHJ P,DODTI ;READ VERSION NUMBER
MOVEM T2,KONEBK##+.EBTYP(J) ;STORE MP VERSION IN KDB
JRST CPOPJ1## ;GIVE SKIP RETURN
;ROUTINE TO CHECK THE VALIDITY OF THE MICROPROCESSOR CONTROL STORE AND
;START IT IF NO ERRORS ARE DETECTED.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,MPCHKS
;RETURN CPOPJ IF AN ERROR IS DETECTED
; CPOPJ1 WITH MICROPROCESSOR RESTARTED
;PRESERVES T1
MPCHKS:!PUSHJ P,MPCHK ;CHECK THE CONTROL STORE
POPJ P, ;ERROR DETECTED
AOS 0(P) ;GIVE SKIP RETURN
;; PJRST RNXMPS ;FALL INTO RNXMPS
;ROUTINE TO START THE MICROPROCESSOR AT .DXSAD.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXMPS
;RETURN CPOPJ ALWAYS
RNXMPS::PUSHJ P,MPRES ;RESET THE MICROPROCESSOR
MOVE T2,[.DXPCR!PC.IRE!PC.PCE!PC.PCI!INSVL.(.DXSAD,PC.MPC)]
;POINT TO REGISTER AND SET BITS
PUSHJ P,DODTO ;TELL MP ITS START ADDRESS
MOVE T2,[.DXMTR!MR.STR] ;SET START BIT IN MAINTENANCE REG
PJRST DODTO ;START IT AND RETURN
;ROUTINE TO RESET THE MICROPROCESSOR
;CALL:
; J/KDB ADDRESS
; U/UDB ADDRESS
; PUSHJ P,MPRES
;RETURN CPOPJ ALWAYS
MPRES: MOVE T2,[.DXMTR!MR.RES] ;SET RESET BIT IN MAINT REG
PJRST DODTO ;WRITE REGISTER AND RETURN
;ROUTINE TO SEE IF THE DX20 MICROCODE IS STILL RUNNING.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,MPRUN
;RETURN CPOPJ IF NOT RUNNING
; CPOPJ1 IF RUNNING
;DESTROYS T2,T3
MPRUN: MOVSI T2,(.DXSTR) ;POINT AT STATUS REGISTER
PUSHJ P,DODTI ;READ IT
TRNE T2,ST.RUN ;IS IT RUNNING?
AOS 0(P) ;YES
POPJ P, ;RETURN
;ROUTINE TO CHECK THE VALIDITY OF THE MICROPROCESSOR CONTROL STORE
;AND ATTEMPT TO RELOAD IT IF IT IS BAD. RETURNS WITH THE
;MICROPROCESSOR STARTED.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,MPINI
;RETURN CPOPJ IF COULDN'T VERYIFY, RELOAD, OR START IT
; CPOPJ1 WITH THE PROCESSOR RUNNING
MPINI: PUSHJ P,MPCHKS ;CHECK INTEGRETY OF MP CONTROL STORE
JRST RNXRLD ;BAD, TRY TO RELOAD IT
JRST CPOPJ1## ;GIVE SKIP RETURN
; ENABLE/DISABLE MICROCODE LOADING
RNXEDL::SE1ENT ;ENTER SECTION ONE
HRRZS J ;REMOVE JUNK IN LH
MOVE T2,T1 ;COPY BIT
XMOVEI T1,RNXULB##(W) ;POINT TO UCODE LOADER BLOCK IN KDB
PJRST BTUEDL## ;ENABLE OR DISABLE
;ROUTINE TO RELOAD THE DX20 MICROCODE IF IT IS FOUND BAD. CALLED
;VIA THE KONRLD KDB DISPATCH AND FROM MPINI INTERNALLY. RETURNS
;WITH THE MICROPROCESSOR STARTED.
;CALL:
; J/KDB ADDRESS
; PUSHJ P,RNXRLD
;RETURN CPOPJ IF COULDN'T VERIFY, RELOAD OR START MICROPROCESSOR
; CPOPJ1 WITH THE PROCESSOR RUNNING
RNXRLD::SE1ENT ;ENTER SECTION ONE
HRRZS KONRLD##(J) ;ASSUME RELOAD WILL SUCCEED
LDB T1,[POINT 7,RNXDO2##(J),9] ;GET RH20 DEVICE CODE
LSH T1,2 ;MAKE IT FULL 9 BIT DEVICE CODE
LDB T2,RNYDXN ;GET THE DX20 NUMBER
HRL T2,T1 ;MAKE IT DEVICE CODE,,DX20 NUMBER
MOVEM T2,RNXULB##+.ULDEV(J) ;SAVE
MOVEI T1,RNXULB##(J) ;POINT TO MICROCODE LOADER BLOCK
PUSHJ P,DXLOAD## ;TRY TO RELOAD AND VERIFY THE DX20
SKIPA ;FAILED
JRST CPOPJ1## ;GIVE SKIP RETURN
HRROS KONRLD##(J) ;INDICATE RELOAD FAILED
POPJ P, ;AND RETURN
SUBTTL ROUTINES TO ACCESS MASSBUS REGISTERS
;ROUTINE TO WRITE ONE MASSBUS REGISTER.
;CALL:
; T2/DATAO ARGUMENT
; J/KDB ADDRESS
; PUSHJ P,DODTO
;RETURN CPOPJ ALWAYS
;DESTROYS T3
DODTO: LDB T3,RNYDXN ;GET "DRIVE NUMBER" OF DX20 ON MASSBUS
TLO T2,<(DO.LDR!DO.DRE)>(T3) ;DRIVE NUMBER, LOAD REG, DISABLE RAE
XCT RNXDO2##(J) ;DO THE DATAO
XCT RNXRAE##(J) ;DID IT RESULT IN AN RAE?
AOSA RNXRAC##(J) ;YES, INCREMENT COUNT AND RETRY
POPJ P, ;NO, RETURN
PUSH P,T4 ;SAVE T4
MOVEI T3,^D10 ;RETRY OPERATION 10 TIMES
MOVEI T4,CO.MBE!CO.RAE ;MASSBUS ENABLE PLUS CLEAR RAE
DODTO1: XCT RNXCO4##(J) ;CLEAR THE ERROR
XCT RNXDO2##(J) ;RETRY THE OPERATION
XCT RNXRAE##(J) ;STILL HAVE AN ERROR?
SOJG T3,DODTO1 ;YES, LOOP BUT NOT TOO MANY TIMES
XCT RNXCO4##(J) ;INSURE THAT RAE IS CLEARED
JRST T4POPJ## ;RESTORE T4 AND RETURN
;ROUTINE TO READ A DRIVE OR CONTROLLER REGISTER.
;CALL:
; T2/DATAO ARGUMENT TO LOAD PREPARATION REGISTER
; J/KDB ADDRESS
; PUSHJ P,DODTI
;RETURN CPOPJ ALWAYS WITH:
; T2/16 BITS OF RETURNED DATAI
;DESTROYS T3
DODTI: LDB T3,RNYDXN ;GET "DRIVE NUMBER" OF DX20 MASSBUS SLOT
TLO T2,<(DO.DRE)>(T3) ;INSERT NUMBER AND DISABLE RAE
XCT RNXDO2##(J) ;SETUP THE PREPARATION REGISTER
PUSH P,T2 ;SAVE THE ARGUMENT
STALL ;WAIT FOR THINGS TO SETTLE
XCT RNXDI2##(J) ;READ THE VALUE
XCT RNXRAE##(J) ;DID WE GET AN RAE?
JRST DODTI2 ;YES, TRY TO RECOVER
DODTI1: POP P,(P) ;BRING STACK INTO PHASE
ANDI T2,177777 ;RETURN ONLY DATA BITS
POPJ P, ;RETURN
DODTI2: MOVSI T3,1 ;ASSUME CONTROL BUS PARITY ERROR
TLNN T2,(DI.TRA) ;DID TRA COME UP?
MOVEI T3,1 ;NO, MUST BE NON-EXISTENT DRIVE
ADDM T3,RNXRAC##(J) ;INCREMENT CORRECT COUNT
PUSH P,T4 ;SAVE T4
MOVEI T3,^D10 ;RETRY OPERATION 10 TIMES
MOVEI T4,CO.MBE!CO.RAE ;MASSBUS ENABLE PLUS CLEAR RAE
DODTI3: XCT RNXCO4##(J) ;CLEAR THE ERROR
MOVE T2,-1(P) ;GET DATAO ARGUMENT BACK
XCT RNXDO2##(J) ;SETUP THE PREPARATION REGISTER AGAIN
STALL ;WAIT FOR THINGS TO SETTLE
XCT RNXDI2##(J) ;READ THE VALUE
XCT RNXRAE##(J) ;STILL HAVE THE ERROR?
SOJG T3,DODTI3 ;YES, LOOP
XCT RNXCO4##(J) ;MAKE SURE THE RAE IS CLEARED
POP P,T4 ;RESTORE T4
JRST DODTI1 ;RETURN TO THE USER
;ROUTINE TO READ A CONTROLLER REGISTER
;CALL:
; T2/DATAO ARGUMENT TO LOAD PREPARATION REGISTER
; J/KDB ADDRESS
; PUSHJ P,DODTIC
;RETURN CPOPJ ALWAYS WITH:
; T2/36 BITS OF RETURNED DATAI
DODTIC: XCT RNXDO2##(J) ;SETUP THE PREPARATION REGISTER
XCT RNXDI2##(J) ;READ THE DATA
POPJ P, ;RETURN
END