Trailing-Edge
-
PDP-10 Archives
-
BB-PBDEB-BB_1990
-
10,7/unsmon/ts1kon.mac
There are 6 other files named ts1kon.mac in the archive. Click here to see a list.
TITLE TS1KON - SA10/STC DEVICE DEPENDENT CODE FOR TAPSER V20
SUBTTL D. P. MASTROVITO/DPM (DEC) & JEFF GUNTER/JEG (ADP) 5-DECEMBER-89
;OLD AUTHORS - CYPHERNETICS CORPORATION 18-MAR-76
SEARCH F,S,DEVPRM,SAXPRM
$RELOC
$HIGH
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED
; OR COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
;COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1987,1988.
;ALL RIGHTS RESERVED.
.CPYRT<1987,1988>
XP VTS1KN,20
SALL
TS1KON::ENTRY TS1KON
;$$*** I DON'T SEE ANY REASON WHY TS1KON CAN'T BE A MULTI-BLOK DRIVER.
;$$*** I DON'T SEE ANY REASON NOT TO SUPPORT READ-BACKWARDS
;SA10 COMMANDS SPECIFIC TO MAGTAPES
MO.NOP==003 ;NOP
MO.SNS==004 ;SENSE COMMAND
MO.CTL==007 ;CONTROL (TAPE MOTION COMMANDS)
MC.BSB==040 ;BACKSPACE RECORD
;DEVICE COMMAND CODES (BITS 8-15 OF DEVICE COMMAND WORD)
O.WR==001 ;WRITE
O.RD==002 ;READ
O.RDB==014 ;READ BACKWARDS
O.SNS==004 ;SENSE
O.CTL==007 ;CONTROL (TAPE MOTION OPERATIONS)
O.TIE==033 ;REQUEST TRACK IN ERROR (9 TRACK NRZI ONLY)
O.7MS==003 ;7 TRACK MODE SET
O.9MS==303 ;9 TRACK MODE SET
O.NOP==003 ;NO OPERATION
;TAPE MOTION OPERATIONS (OR'ED WITH O.CTL)
C.REW==000 !O.CTL ;REWIND
C.RUN==010 !O.CTL ;REWIND AND UNLOAD
C.ERG==020 !O.CTL ;ERASE GAP
C.WTM==030 !O.CTL ;WRITE TAPE MARK
C.BSB==040 !O.CTL ;BACK SPACE BLOCK
C.BSF==050 !O.CTL ;BACK SPACE FILE
C.FSB==060 !O.CTL ;FORWARD SPACE BLOCK
C.FSF==070 !O.CTL ;FORWARD SPACE FILE
C.DSE==220 !O.CTL ;DATA SECURITY ERASE
;9 TRACK MODE SETTINGS (OR'ED WITH O.9MS)
N.PE==000 ;1600 BPI PHASE ENCODED
N.NRZI==010 ;800 BPI NON RETURN TO ZERO INVERTED
N.GCR==020 ;6250 BPI GROUP CODED RECORDING
N.STD==N.PE ;INSTALLATION STANDARD FOR 9 TRACK
;7 TRACK DENSITY SETTINGS (OR'ED WITH O.7MS)
D.200==000 ;200 BPI
D.556==100 ;556 BPI
D.800==200 ;800 BPI
;7 TRACK MODE MODIFIERS (OR'ED WITH O.7MS)
M.DIAG==010 ;FOR DIAGNOSTIC USE ONLY
M.DCON==020 ;DATA CONVERTER ON
M.EPAR==040 ;EVEN PARITY
M.TRON==010 ;TRANSLATOR ON
;MODE DEFINITIONS
F.9TK==F.TAPC ;9 TRACK DEC COMPATIBLE (TAPE COMPATIBILITY MODE)
F.IND==F.BYTE ;9 TRACK IBM COMPATIBLE (BYTE MODE)
F.7TK==F.NAT ;7 TRACK ODD PARITY (NATURAL MODE)
F.7TE==F.BYTE ;7 TRACK EVEN PARITY (BYTE MODE)
NOPCMD==F.NMT!F.XEC!<O.NOP>B15 ;A GENERIC NOP COMMAND
;BYTE POINTERS
CSYDVA: POINT CSSKON+CSSUNI,T1,CSNUNI ;DEVICE ADDR IN CSW
DVYDVA: POINT DVSDVA,T2,DVNDVA ;DEVICE ADDR IN DVW
;PROTOTYPE SENSE CHANNEL PROGRAM
SNSPGM: PHASE 0
SNSNOP:! F.NMT!F.XEC!F.CC!<MO.NOP>B15 ;PUT A CHAINED NOP BEFORE SENSE
SNSDVW:! F.XEC!F.BYTE!<MO.SNS>B15!<000>B23 ;SENSE-I/O COMMAND
SNSDCW:! BYTE (1)1(DCSSIZ)-^D24(DCSADR)0 ;DCW FOR SENSE
SNSHLT:! EXP 0 ;TERMINATE CHANNEL PROG (HALT)
SNSDAT:! BLOCK SNSWDS ;SENSE BYTE STORAGE
SNSLEN:! DEPHASE ;LENGTH OF CHANNEL PROGRAM
TS1DMX==20 ;MAXIMUM DRIVES PER KONTROLLER
TS1HDN==TS1DMX-1 ;HIGHEST DRIVE NUMBER ON KONTROLLER
TS1ELN==6 ;SIZE OF FEP TABLE
DCWMAX==^D40 ;LENGTH OF CHANNEL PROGRAM AREA
;DRIVER CHARARCTERISTICS
; TS1 = TS1CNF
; MTA = MAGTAPE
; 0 = MAXIMUM DEVICES IN SYSTEM (NO LIMIT)
; K.TS1 = KONTROLLER TYPE
; TS1DMX = MAXIMUM DRIVES PER KONTROLLER
; TS1HDN = HIGHEST DRIVE NUMBER ON KONTROLLER
; MDSEC0 = SECTION FOR KDB/UDB
; MDSEC0 = SECTION FOR DDB
DRVCHR (TS1,MTA,0,K.TS1,TS1DMX,TS1HDN,MDSEC0,MDSEC0,<DR.XAD!DR.MCD!DR.DPU!DR.UCK!DR.GCC!DR.DDN>)
.ORG TKBUDB ;START OF SA10 SPECIFIC DATA
TS1UTB:! BLOCK TS1DMX ;TABLE OF POINTERS TO UDBS
TS1SNS:! BLOCK SNSLEN ;SENSE CHANNEL PROGRAM
TS1SUN:! BLOCK 1 ;NON-EXISTANT DRIVE BEING SENSED
TS1IUM:! BLOCK TS1DMW ;IGNORE UNIT MASK
TS1NUM:! BLOCK TS1DMW ;NEW UNIT MASK
TS1UNI:! BLOCK 1 ;SAVED UNIT NUMBER
TS1LCI:! BLOCK 1 ;CONI OF SA10 AT LAST INTERRUPT
TS1ICC:! BLOCK 1 ;SAVE INITIAL CSW AROUND SENSE CMD
TS1LST:! BLOCK 1 ;CSW AT LAST INTERRUPT
TS1SCN:! BLOCK 1 ;LH = SUBCHANNEL IN CONO POS, RH = SUBCHANNEL
TS1GSN:! BLOCK 1 ;GLOBAL SUBCHANNEL NUMBER
TS1DVP:! BLOCK 1 ;ADDRESS OF OUR DEVL SLOT
TS1PPC:! BLOCK 1 ;PROGRAM PC DESIRED
TS1OFL:! BLOCK 1 ;-1 IF WE THINK KON IS OFFLINE, 0 IF NOT
TTSCSW:! BLOCK 1 ;ADDR OF CHANNEL STATUS WORD
TTSOFS:! BLOCK 1 ;DEVICE ADDR FOR UNIT ZERO (@TTSOFS(W))
TTSTCA:! BLOCK 1 ;TERMINAL COUNT,ADDR LAST IO INT (NOT SENSE)
TTSBUS:! BLOCK 1 ;(U) THAT GOT BUS-OUT ON USER OPERATION
TTSBSM:! BLOCK 1 ;BUS-OUT MAP FOR POLLER
TS1STI:! BLOCK 1 ;(U) FOR UNIT THAT GOT DEFERED AT STIDON
TS1DUM:! BLOCK 1 ;(U) FOR UNIT THAT GOT DEFERED AT TTSDMD
TTSOPU:! BLOCK 1 ;(U) FOR UNIT THAT GOT BUSYED
TTSBCT:! BLOCK 1 ;TIMER SET WHEN BUSY RECEIVED
TTSBRC:! BLOCK 1 ;COUNT OF BUSYS,,COUNT OF TIMER EXPIRED
TTSDMD:! BLOCK 1 ;ADDR OF UNIT WAITING FOR DUMMY STATUS
TTSMIO:! BLOCK 1 ;VIRTUAL ADDRESS OF 1ST DCW IN TTSPRG
TTSPRG:! BLOCK DCWMAX ;THE ACTUAL CHANNEL PROGRAM LIVES HERE
BLOCK 3 ;THIS IS OVERWRITTEN WITH SENSE + HALT
TS1MDW:! BLOCK 1 ;STORAGE FOR MDT DATA WORD
TS1KLN:! ;LENGTH OF KDB
.ORG
.ORG TUBLEN
TS1SND:! ;START OF SENSE DATA
TS1IST:! BLOCK TS1ELN ;LAST ERROR INITIAL STATUS
TS1FST:! BLOCK TS1ELN ;LAST ERROR FINAL STATUS
TS1SIP:! BLOCK 1 ;SENSE IN PROGRESS - CONI WORD
BLOCK 1 ;SENSE IN PROGRESS - CSW WORD
TS1TIE:! BLOCK 1 ;SENSE BYTES 0,1,2,3 WHERE BYTE2=TIE BYTE
TS1ULN:! ;LENGTH OF UDB
.ORG
TS1KDB: KDBBEG (TS1,TS1KLN)
SETWRD (KDBNAM,<SIXBIT/MT/>) ;KONTROLLER NAME
SETWRD (KDBIUN,<TKBUDB>) ;INITIAL POINTER TO UDBS
SETWRD (KDBCUN,<TKBUDB>) ;CURRENT POINTER TO UDBS
SETWRD (KDBIUM,<TS1IUM>) ;OFFSET TO IGNORE UNIT MASK
SETWRD (KDBNUM,<TS1NUM>) ;OFFSET TO NEW UNIT MASK
SETWRD (KDBSTS,<INSVL.(1,KD.MPT)>) ;INITIALLY ONE PATH
KDBEND
TS1UDB: UDBBEG (TS1,TS1ULN)
SETWRD (UDBNAM,<SIXBIT/MT/>) ;DRIVE NAME
SETWRD (UDBPCC,< TS1ELN,,TS1FST>) ;PHYSICALLY CONTIGUOUS CORE
SETWRD (TUBIEP,<-TS1ELN,,TS1IST>) ;INITIAL ERROR POINTER
SETWRD (TUBFEP,<-TS1ELN,,TS1FST>) ;FINAL ERROR POINTER
UDBEND
EQUATE (LOCAL,0,<TS1ICD,TS1ICL,TS1ULP,TS1ULB>)
EQUATE (LOCAL,CPOPJ##,<TS1CMD,TS1EDL,TS1IDL,TS1LOD>)
EQUATE (LOCAL,CPOPJ1##,<TS1CFG>)
TS1INT==TAPINT## ;INTERRUPT SERVICE
TS1ELG==TPELGX## ;MAKE AN ERROR LOG ENTRY
TS1DSP: DRVDSP (TS1,TAPCHN##,TDVDDB##,TDVLEN##,TPMDIA##)
TPK (TS1,NO,377777) ;SERVICE DEPENDENT DISPATCH
TS1CKT: EXP K.TX1,K.DX2,K.TS1,0 ;COMPATIBLE KONTROLLER TABLE
TS1NBF: TPNBF (RW,RU) ;NON-BLOCKING FUNCTION MASK
SAXDSP (TS1) ;GENERATE SA10 DRIVER DISPATCH
;DEFAULT MONGEN'ED DEVICE TABLE
DEFMDT: MDKL10 (7,274,0,0,<MD.KON>) ;DEVICE CODE 274
MDKL10 (7,270,0,0,<MD.KON>) ;DEVICE CODE 270
MDTERM ;TERMINATE TABLE
SUBTTL TAPE INTERUPT SERVICE
;CALLED FROM TAPSER WITH W := KDB
TS1ISR: PUSHJ P,SAVE4## ;SAVE SOME ACS
PUSHJ P,TRK111 ;$ GO TRACK "INT"
XCT KDBCNI(W) ;CONI SA10,T1
DMOVE T2,@TTSCSW(W) ;GET CSW & RESIDUAL COUNT
EXCH T1,T2 ;SWAP AROUND
MOVEM T1,TS1LST(W) ;SAVE INTERRUPTING STATUS
MOVEM T2,TS1LCI(W) ;SAVE CONI
TLNE T1,(S.BUSY) ;SKIP IF NOT BUSY
PJRST WTCUE ;GO WAIT FOR CUE IF WE'RE BUSYED
TLNE T1,(S.CUE) ;CHECK FOR NOT-BUSY-ANYMORE
PUSHJ P,GOTCUE ;CALL IF NOT BUSY ANYMORE
TRNE T2,SI.PAR!SI.NXM ;SKIP UNLESS MEMORY ERROR
JRST STECHN ;GO HANDLE CHANNEL ERROR
LDB T4,[POINT 2,TS1LST(W),1] ;GET STATUS TYPE BYTE
SETZM TS1OFL(W) ;IF WE GET INT CAN'T BE COMPLETELY OFFLINE
SKIPE T1 ;SKIP IF CSW WORD IS 0 (??)
TLNE T1,(S.SE) ;SKIP IF SELECT-ERROR IS CLEAR
JRST TS1IS3 ;BRANCH IF CSW=0 OR IF SELECT-ERROR IS ON
SKIPE T2,TTSDMD(W) ;SKIP IF NO DUMMY DEVICE
CAIE T4,S.DUM ;SKIP IF DUMMY STATUS
LDB T2,CSYDVA ;GET DEVICE FROM STATUS
SUBI T2,@TTSOFS(W) ;GET UNIT NUMBER
SETZB U,P1 ;DEFAULT TO NO UDB, NO IORB
PUSHJ P,SETUDB## ;SET UP UDB
PJRST NEWUNI ;POSSIBLY A NEW DRIVE JUST POWERED UP
PUSHJ P,CHKIRB## ;CHECK FOR IORB AND LOAD UP T1 WITH IT
JRST ONLUNI ;MAYBE THIS IS AN ONLINE INTERRUPT
PUSHJ P,SETACS ;LOAD UP VARIOUS PRESERVED STATUS
SKIPE TS1SIP(U) ;SKIP IF NOT SENSING
JRST [PUSHJ P,SNSANA ;GO ANALYZE SENSE DATA
PJRST TS1IS2] ;...THEN BRANCH TO COMPLETION ROUTINES
MOVEM T3,TTSTCA(W) ;SAVE FOR WORD COUNT CALCULATERS
MOVE T1,P1 ;GET IORB INTO T1 INCASE WE EXIT HERE AND NOW
CAIN T4,S.DUM ;SKIP UNLESS DUMMY STATUS
JRST TS1IS4 ;BRANCH IF WE GOT DUMMY INT FOR IDLE CTL
JUMPE P1,STSCLR
MOVSI T1,TUSBOT## ;GET BOT BIT
ANDCAM T1,TUBSTS(U) ;CLEAR SINCE IT WILL BE SET LATER IF NEEDED
TLNE P4,(S.UC) ;SKIP IF NO ERRORS DETECTED
JRST ERRSNS ;START SENSE, EXIT, RETURN LATER
MOVE T1,P1 ;GET IORB ADDRESS
LDB T1,PRBFCN## ;AND THE FUNCTION CODE
CAIE T1,RB.FRW ;REWIND?
CAIN T1,RB.FRU ;UNLOAD?
JRST TS1IS2 ;BRANCH IF INITIAL-STATUS FOR REW/RUN
TLNE P4,(S.DE) ;DEVICE END (COMMAND FINISHED)?
JRST TS1IS2 ;YES
PJRST NXTWAT ;ODD, MUST BE MORE STATUS COMING
;HERE WHEN WE (FINALLY) GET DEVICE-END FOR AN IORB PROGRAM
TS1IS2: MOVE T1,P1 ;WHERE TAPSER LIKES THE IORB
LDB T2,PRBFCN## ;GET DESIRED FCN
CAIG T2,STIMAX ;CHECK VALIDITY
JUMPG T2,@STIDSP(T2) ;DO IT
JRST TAPIFI## ;FUNCTION ERROR
;HERE IF SA10 OR TCU IS OFFLINE
TS1IS3: MOVSI T2,TKSOFL## ;GET THE OFFLINE BIT
IORM T2,TKBSTS##(W) ;SET IN KDB SINCE KON ITSELF IS OFFLINE
SETOM TS1OFL(W) ;REMEMBER TO OURSELVES IT IS OFFLINE
HRROS TS1SUN(W) ;UNLOCK THE POLLER IF WE DROP OFFLINE
HRROS KDBNUM(W) ;...
SETZM TTSOPU(W) ;NOTHING TO RESTART
SETZM TS1PPC(W) ;NOTHING TO START
LDB T2,CSYDVA ;TRY TO GET A VALID UNIT ADDRESS
SUB T2,TTSOFS(W) ;COMPUTE UNIT NUMBER
SETZB T1,P1 ;NO IORB YET
PUSHJ P,SETUDB## ;FIND UNIT
PJRST STSCLR ;EXIT INTERRUPT
MOVSI T1,TKSOFL## ;GET OFFLINE BIT AGAIN
IORM T1,TUBSTS##(U) ;MARK THE UNIT OFFLINE TOO
PUSHJ P,CHKIRB## ;GET IORB IF ANY
PJRST STSCLR ;EXIT INTERRUPT
MOVSI T2,RB.SOL!RB.SNM ;OFFLINE, NO MOTION
IORM T2,TRBSTS##(T1) ;SET OFFLINE
MOVE P1,T1 ;COPY IORB ADDRESS
JRST STIDON ;AND THEN SHORT CUT TO EXIT AND DISMISS INT
;HERE IF WE GET DUMMY INTERRUPT
TS1IS4: SKIPE TS1PPC(W) ;SKIP IF NO PROGRAMS IN PROGRESS
JRST TS1IS5 ;BRANCH IF PROGRAM RUNNING FOR THIS KON
SETZM TS1DUM(W) ;NO LONGER A DEFERED DUMMY INTERRUPT
SETZM TTSDMD(W) ;NO LONGER A PENDING DUMMY INTERRUPT
SKIPGE TTSBCT(W) ;SKIP IF BUSY TIMER NOT RUNNING
JRST DISMIS ;BRANCH IF BUSY TIMER RUNNING
PUSHJ P,CKSTRT ;CHECK SELECTION STATE
POPJ P, ;EXIT IF NEITHER STARTED NOR SELECTED. REQUEST SCHED
JRST STCSI1 ;BRANCH TO SETUP COMMANDS AND START UNIT
;HERE IF WE GET DUMMY INTERRUPT, BUT POLLER IS BUSY WITH A UNIT
TS1IS5: MOVEM U,TS1DUM(W) ;REMEMBER THE UNIT THAT UUO LEVEL WANTS
JRST NXTWAT ;AND DISMISS TO WAIT FOR POLLER DONE INTERRUPT
;ROUTINE TO ANALYZE SENSE DATA AND SETUP VARIOUS UDB AND IORB THINGS
SNSANA: PUSHJ P,SNSUNI ;GO SETUP UDB THINGS
PUSHJ P,SNSIOR ;GO SETUP IORB THINGS
POPJ P, ;RETURN TO CALLER
;ROUTINE TO DO SENSE ANALYSIS AND SETUP UDB THINGS
SNSUNI: PUSHJ P,TRK333 ;TRACK A SENSE DATA CALLBACK
JUMPE U,CPOPJ## ;EXIT IF NO UNIT (??????!!!!??!?!)
MOVEI T1,SNSWDS ;LOAD T1=# WORDS IN SENSE DATA
XMOVEI T2,TS1SND(U) ;POINT T2=SENSE DATA FROM SENSE CMD
XMOVEI T3,TS1IST(U) ;POINT T3="BEFORE" BUFFER FOR SENSE DATA
EXTEND T1,[XBLT] ;COPY DATA FROM UNIT BUFFER TO "BEFORE" BUFFER
MOVSI T1,TUSWTL## ;LOAD T1=UNIT BIT SAYING "WRITE-LOCKED-UNIT"
TLNN P2,(S01WLK) ;SKIP IF UNIT IS ACTUALLY LOCKED
ANDCAM T1,TUBSTS##(U) ;CLEAR BIT IF UNIT IF REALLY ENABLED
TLNE P2,(S01WLK) ;SKIP IF UNIT IS ACTUALLY ENABLED
IORM T1,TUBSTS##(U) ;SET BIT IF UNIT IS REALLY LOCKED
TLNN P2,(S00IRQ!S00BOC) ;SKIP IF UNIT HAS FALLEN OFFLINE
TLNE P2,(S01BOT) ;SKIP IF NOT BEGINNING-OF-TAPE
PUSHJ P,REWDON## ;LET TAPE-SERVICE KNOW WE HIT B-O-T
MOVSI T1,TKSOFL## ;LOAD T1=UNIT BIT SAYING "UNIT OFFLINE"
TLNE P2,(S00IRQ!S00BOC) ;SKIP IF ONLINE WITHOUT ERROR
IORM T1,TUBSTS(U) ;SET OFFLINE BIT IF OFFLINE OR BUS PARITY ERR
TLNE P2,(S00BOC) ;SKIP IF NOT BUS-OUT PARITY ERROR
MOVEM U,TTSBUS(W) ;REMEMBER LAST UNIT ON OUR KON HAVING ERROR
TLNE P2,(S00DCK) ;SKIP IF NOT DATA-CHECK
MOVEM P2,TS1TIE(U) ;SAVE T-I-E INFO IF DATA CHECK
; (N.B.: TIE ONLY VALID IF 800 NRZI 9 TRACK UNIT)
TLNE P3,(S067TK) ;SKIP IF 9-TRACK UNIT
SETOM TS1TIE(U) ;REJECT TIE INFO IF 7TRACK UNIT
TRNE P2,S03D16 ;SKIP IF NOT 1600 BPI
SETOM TS1TIE(U) ;REJECT TIE INFO IF PE UNIT
TRNE P3,S06D62 ;SKIP IF NOT 6250 BPI CAPABLE UNIT
SETOM TS1TIE(U) ;REJECT TIE INFO IF GCR UNIT
POPJ P, ;EXIT WHEN DONE WITH UDB STUFF
;HERE TO ANALYZE SENSE DATA AND SETUP IORB STUFF
SNSIOR: JUMPE P1,CPOPJ## ;EXIT IF NO IORB!
SETZ T1, ;START OFF WITH NO MODIFIER BITS
TLNE P2,(S00IRQ!S00BOC) ;SKIP IF OFFLINE AND NO BUS ERRORS
TLO T1,RB.SOL!RB.SNM ;SET OFFLINE AND NO-MOTION
MOVE T2,TS1SND+S04WRD(U) ;GET SENSE DATA
TLNE T2,(S04TPI) ;SKIP IF "INDICATE" LIGHT IS OFF
TLO T1,RB.SET ;SET "END-OF-TAPE" IF BEYOND EOT MARKER
TLNE P2,(S00DCK) ;SKIP IF DATA-CHECK
TLO T1,RB.SDE ;SET DATA-ERROR
IORM T1,TRBSTS(P1) ;SET BITS IN IORB
MOVE T1,P1 ;POINT T1 AT IORB FOR PRBDEN
TLNN P2,(S01BOT) ;CAN'T UPDATE DENSITY IF HAVEN'T READ TAPE
TLNE P2,(S017TK) ;SKIP IF 9TRACK UNIT
POPJ P, ;7TRK DOESNT NEED UPDATE (AND WE CAN"T READ IT)
MOVEI T2,RB.D62 ;IF 3600 SERIES, DEFAULT TO 6250
TRNN P3,S06D62 ;SKIP IF 3600 SERIES DRIVE
MOVEI T2,RB.D8 ;IF 3400 SERIES, DEFAULT
TRNE P2,S03D16 ;SKIP IF NOT 1600 BPI
MOVEI T2,RB.D16 ;IF KNOWN TO BE 1600 BPI, MUST BE 1600 BPI!
DPB T2,PRBDEN## ;UPDATE IORB WITH CURRENT DENSITY INFO
POPJ P, ;EXIT WITH IORB INFO UPDATED
;ROUTINE TO LOAD THE INTERESTING ACS.
; P1= IORB
; P2= 1ST 4 SENSE BYTES, OR ZERO IF NOT SENSING
; P3= 2ND 4 SENSE BYTES, OR ZERO IF NOT SENSING
; P4= CSW WORD APLLYING TO THE ERROR, IF ANY
SETACS: MOVE P1,T1 ;SAVE IORB IN A SAFER PLACE
SETZB P2,P3 ;DEFAULT TO NO ERRORS
SKIPE TS1SIP(U) ;SKIP IF NOT SENSING
DMOVE P2,TS1SND+S00WRD(U) ;LOAD UP THE FIRST 8 SENSE BYTES
SKIPE TS1SIP(U) ;SKIP IF NOT SENSING
SKIPA P4,TS1SIP+1(U) ;LOAD UP THE SAVED CSW INFO
MOVE P4,TS1LST(W) ;LOAD UP THE "REAL" CSW INFO
POPJ P,
;HERE ON UN-EXPECTED INTERRUPT FOR KNOWN DRIVE (IE: UDB BUT NO IORB)
ONLUNI: MOVE T1,TS1LST(W) ;GET CSW WORD
TLNE T1,(S.CUE) ;SKIP IF NOT BUSY-CALL-BACK
JRST NXTWAT ;IGNORE INTERRUPT IF BUSY-CALL-BACK
SKIPN TS1SIP(U) ;SKIP IF WE'VE GOT SENSE DATA ALREADY
PJRST ERRSNS ;PICK UP SENSE DATA
PUSHJ P,SETACS ;SETUP THE ACS
MOVE P1,TUBSTS(U) ;FORGET IORB AND REMEMBER TUSREW INSTEAD
PUSHJ P,SNSUNI ;SETUP UDB DATA
TLNN P1,TUSREW## ;SKIP IF WE JUST REWINDING
TLNE P2,(S00IRQ) ;SKIP IF NOT OFFLINE
SKIPA ;SKIP IF REWINDING OR OFFLINE
PUSHJ P,TPMONL## ;TELL MDC WHEN DRIVE COMES ONLINE
SETZB P1,T1 ;MAKE SURE THERE IS NO IORB HANGING AROUND
PJRST STIDON ;FINISH INTERRUPT
;HERE ON AN UNSOLICITED INTERRUPT FROM AN UNKNOWN DRIVE
;IF NOT THE POLLER'S DRIVE, JUST IGNORE IT, AS POLLER WILL EVENTUALLY
;DO A SENSE AND CLEAR THE CONNECTION.
NEWUNI: CAME T2,TS1SUN(W) ;SKIP IF THE UNIT WE WERE EXPECTING
JRST NXTWAT ;BR IF BAD UNIT. IGNORE-WILL BE SENSED LATER.
MOVE T1,BITTBL##(T2) ;GET ASSOCIATED BIT
TDNE T1,TS1IUM(W) ;WANT TO IGNORE THIS DRIVE?
JRST NEWUN1 ;BR IF WE WANT TO IGNORE IT (??!)
MOVE T3,TS1SNS+SNSDAT+S23WRD(W) ;GET LAST WORD
TRNE T3,17 ;SKIP IF SENSE PROCEEDED CORRECTLY
JRST NEWUN3 ;BR IF SENSE DIDN'T HAPPEN OR FAILED
MOVE T3,TS1SNS+SNSDAT+S01WRD(W) ;GET SENSE BYTE 1
TLNE T3,(S01TUA!S01TUB) ;DOES DRIVE EXIST?
JRST NEWUN2 ;BRANCH IF DRIVE SEEMS TO EXIST
;HERE DRIVE DOESN'T (OR SHOULDN'T) EXIST. UNFREEZE POLLER AND DISMISS INTRP
NEWUN1: HRROS TS1SUN(W) ;OK TO CHECK ANOTHER DRIVE NOW
HRROS KDBNUM(W) ;GIVE AUTCON A FLAG
JRST NEWUN4 ;CHECK FOR PENDING UNIT, DISMISS
;HERE IF WE FIND A NEWLY EXISTING DRIVE
NEWUN2: MOVE T3,TS1SNS+SNSDAT+S06WRD(W) ;GET SENSE BYTE 6 ET AL
TDNN T3,[S06MOD] ;IS MODEL FIELD FILLED IN?
JRST NEWUN1 ;HM - MUSTBE FALSE ALARM?
IORM T1,TS1NUM(W) ;TELL PER-SECOND LEVEL WHICH DRIVE TO FIND
JRST NEWUN4 ;CHECK FOR PENDING UNIT, DISMISS
;HERE TO START A SENSE BECAUSE EXISTING FAILED OR DIDN'T HAPPEN
NEWUN3: MOVEI T3,TS1SNS+SNSDVW(W) ;POINT AT VIRTUAL ADDRESS OF PROGRAM
MOVEM T3,TS1PPC(W) ;SAVE FOR STARTUP/RESTARTS
MAP T3,TS1SNS+SNSDVW(W) ;POINT AT SENSE AFTER NO-OP CMD
ADDI T2,@TTSOFS(W) ;COMPUTE FULL UNIT ADDRESS
DPB T2,[POINT SASDLD,T3,SANDLD] ;INSERT IT
MOVEI T2,DL.STA ;GET START OPCODE
DPB T2,[POINT SASDLO,T3,SANDLO] ;INSERT OPCODE
PMOVEM T3,TS1DVP(W) ;CREATE NEW DEVL ENTRY
SETZM TS1SNS+SNSDAT+SNSWDS-1(W) ;MAKE IT LOOK LIKE IT WON THIS TIME
JRST SETGOB ;START SENSE-ONLY PROGRAM
;HERE WHEN SENSE COMPLETED. DECLARE PENDING UUO LEVEL DONE.
NEWUN4: SETZM TS1PPC(W) ;NO MORE POLLING PROGRAM
SKIPN U,TS1STI(W) ;GET PENDING UNIT'S U
JRST NEWUN5 ;BRANCH IF NO "STIDON" PENDING UNIT
SETZM TS1STI(W) ;NOTHING PENDING NOW
PUSHJ P,CHKIRB## ;GET IORB FOR IT
SETZ T1, ;VERY STRANGE
MOVE P1,T1 ;GET P1=IORB FOR STIDON ET AL
PJRST STIDON ;END IT
;HERE WHEN SENSE COMPLETED BUT NO "STIDON" IS PENDING
NEWUN5: SKIPN TS1DUM(W) ;SKIP IF PENDING DUMMY INTERRUPT
JRST NXTWAT ;BRANCH IF NOTHING MORE TO DO
MOVE U,TS1DUM(W) ;GET THE UNIT WE'RE DEFERRING
SETZM TS1DUM(W) ;NO LONGER DEFERRING IT
JRST STCSI1 ;START IT UP
;$ TRACK SUPPORT
;$ TRACK 111111 - TRACK AN INTERRUPT
;$
TRK111: MOVSI T1,111000 ;$ TYPE 1
IOR T1,TIME## ;$ MERGE WITH TIME STAMP
PUSHJ P,SHOVE
DMOVE T1,@TTSCSW(W) ;$ T1=CSW, T2=WC
PUSHJ P,SHOVE ;$
MOVE T2,T1 ;$ T1=WC
PUSHJ P,SHOVE ;$
CONI 274,T1 ;$
PUSHJ P,SHOVE
POPJ P,
;$ TRACK 222222 - TRACK AN INTENT TO SET GO FLAG
;$
TRK222: PUSHJ P,SAVT## ;$ SAVE ALL ACS
PUSHJ P,TRKLOK ;$ DON'T PERMIT AN INTERRUPTION
PUSH P,SHVPTR ;$ SAVE THE SHOVE POINTER
MOVE T1,[222222,,3] ;$ INITIAL RECORD TYPE 2
PUSHJ P,SHOVE ;$ REMEMBER IT
MOVE T1,UDBNAM(U) ;$ PICK UP THE UNIT NAME
PUSHJ P,SHOVE ;$ SAVE IT
PMOVE T1,TS1DVP(W) ;$ GET DEVL POINTER
MOVE T2,T1 ;$ COPY DEVL POINTER
PUSHJ P,SHOVE ;$ SAVE DEVL POINTER
MOVSI T3,-50 ;$
LDB T1,[POINT 4,T2,11] ;$ GET STATE
CAIN T1,17 ;$ SKIP IF NOT STOPPED
JRST TRK22B ;$ BRANCH IF STOPPED
AND T2,[17,,-1] ;$ ISOLATE ADDRESS ONLY
TRK22A: PMOVE T1,T2 ;$ PICK UP A PROGRAM INSTRUCTION
PUSHJ P,SHOVE ;$
TLZ T1,400000 ;$ TURN OFF MUX BIT
SKIPE T1 ;$ SKIP IF WE HALTED
AOBJN T3,[AOJA T2,TRK22a] ;$ LOOP FOR ALL ISNTRUCTIONS
TRK22B: POP P,T1 ;$ GET SHOVE POINTER
MOVE T3,SHVPTR ;$ GET SHOVE POINTER
SUB T3,T1 ;$ GET TRUE COUNT
SKIPE T1 ;$ SKIP IF POINTER WAS BOGUS TO START WITH
HRRM T3,(T1) ;$ FIXUP HEADER
POPJ P, ;$ RETURN
TRK333: PUSHJ P,TRKLOK ;$ DON'T PERMIT INTERRUPTION
MOVE T1,[333333,,10] ;$
PUSHJ P,SHOVE
MOVE T1,UDBNAM(U) ;$
PUSHJ P,SHOVE
MOVE T1,TS1SND(U) ;$
PUSHJ P,SHOVE
MOVE T1,TS1SND+1(U) ;$
PUSHJ P,SHOVE
MOVE T1,TS1SND+2(U) ;$
PUSHJ P,SHOVE
MOVE T1,TS1SND+3(U) ;$
PUSHJ P,SHOVE
MOVE T1,TS1SND+4(U) ;$
PUSHJ P,SHOVE
MOVE T1,TS1SND+5(U) ;$
PUSHJ P,SHOVE
POPJ P,
;$ TRACK A CONO
TRK444: PUSHJ P,TRKLOK ;$ DON"T PERMIT INTERRUPTION
PUSH P,T1
MOVE T1,[444444,,3]
PUSHJ P,SHOVE
MOVE T1,UDBNAM(U)
PUSHJ P,SHOVE
POP P,T1
PUSHJ P,SHOVE
POPJ P,
TRK555: PUSHJ P,TRKLOK ;$ DON'T PERMIT INTERRUPTION
PUSH P,T1 ;$ SAVE IORB POINTER
MOVE T1,[555555,,6] ;$ 5=SETCMD TIME
PUSHJ P,SHOVE ;$
MOVE T1,UDBNAM(U) ;$
PUSHJ P,SHOVE
MOVE T1,0(P1) ;$IORB
PUSHJ P,SHOVE
MOVE T1,1(P1)
PUSHJ P,SHOVE
MOVE T1,2(P1)
PUSHJ P,SHOVE
MOVE T1,3(P1)
PUSHJ P,SHOVE
POP P,T1
POPJ P,
SHOVE: SKIPE SHVPTR
SKIPN SHVCTR
POPJ P,
MOVEM T1,@SHVPTR
AOS SHVPTR
SOSLE SHVCTR
POPJ P,
PUSH P,T1
MOVEI T1,6000
MOVEM T1,SHVCTR
MOVEI T1,SHVBFR
MOVEM T1,SHVPTR
POP P,T1
POPJ P,
$LOW
SHVPTR: EXP SHVBFR
SHVCTR: 6000
SHVBFR: BLOCK 6001
$HIGH
TRKLOK: CONSZ PI,PI.IPA-PI.IP7 ;SKIP IF UUO LEVEL
POPJ P, ;$ EXIT IF ALREADY AT INTRP LEVEL
TAPOFF ;$ DISABLE TAPE INTERRUPTS
PUSHJ P,@(P) ;$ CALL CALLER
SKIPA ;$ NO SKIP RETURN
AOS -1(P) ;$ PASS ALONG SKIP
POP P,(P) ;$ WASTE CALLER'S PC
TAPON ;$ RE-ENABLE TAPE INTERRUPTS
POPJ P, ;$ RETURN TO CALLER'S CALLER
STIDSP: IFIW TAPIFI## ;(00) ILLEGAL
IFIW STIRD ;(01) READ
IFIW STIWT ;(02) WRITE
IFIW TAPIFI## ;(03) READ BACKWARDS (ILLEGAL)
IFIW STISR ;(04) SKIP RECORD
IFIW STIBR ;(05) BACKSPACE RECORD
IFIW STISF ;(06) SKIP FILE
IFIW STIBF ;(07) BACKSPACE FILE
IFIW STIEG ;(10) ERASE GAP
IFIW STIDSE ;(11) DATA SECURITY ERASE
IFIW STIRW ;(12) REWIND
IFIW STIUN ;(13) REWIND / UNLOAD
IFIW STITM ;(14) WRITE TAPE MARK
IFIW STISTS ;(15) STATUS REQUEST
IFIW STIRD ;(16) CORRECTION READ
IFIW STIRD ;(17) READ LOW THRESHOLD
STIMAX==.-STIDSP-1
;HERE IF NO IORB - MAKE SURE DONT LOSE CUE OR DE
STCIN1: SKIPE TTSOPU(W) ;SKIP UNLESS WAITING FOR CUE/DE
PUSHJ P,SETGOP ;SET UP COMMAND WAITING FOR
JRST TAPDIS## ;DISMISS THIS INT
;HERE TO CHECK FOR DUMMY STATUS INTERUPT - SEE IF ALREADY SELECTED
; NON-SKIP IF NOT SELECTED
; SKIP RETURN IF ALREADY SELECTED
CKSTRT: MOVSI T2,TKSSEL##
TDNN T2,TKBSTS(W) ;SELECTED?
PJRST CLRCTL ;NOT STARTED OR SELECTED, CLEAR CONTROL
MOVSI T2,TKSSTD## ;SELECTED, SEE IF ALSO STARTED
TDNE T2,TKBSTS(W) ;SKIP IF NOT STARTED
PJRST CPOPJ1## ;SELECTED AND STARTED, CONTINUE
PJRST CLRCTL ;CLEAR CONTROL, ASK FOR SCHEDULING
;ROUTINE TO MAKE CONTROLLER IDLE
CLRCTL:
STCIDL: SETOM TS1UNI(W) ;NO UNIT SELECTED
PJRST STSCLR ;CLEAR STATUS FLAG AND RETURN
;HERE TO RESET ACTIVE I/O
TS1RES: MOVEI T2,SO.RCH ;RESET SUBCHANNEL
PUSHJ P,CNOCLR ;DO IT
PUSHJ P,CLRCTL ;CLEAR WORLD
SETZM TTSBCT(W) ;AND CLEAR BUSY TIMER
SETZM TTSOPU(W) ;AND NO BUSY UNIT
HRROS TS1SUN(W) ;FREE UP POLLER IF RUNNING
HRROS KDBNUM(W) ;FREE AUTO MASK
SETZM TS1PPC(W) ;FORGET PROGRAM IN PROGRESS
HLRZ T1,TS1SCN(W) ;SUBCHANNEL IN CONO POSITION
TRO T1,SO.CME+SO.RCH ;CLEAR SUBCHANNEL AND MEMORY ERRORS
XCT KDBCNO(W) ;CONO SA10,(T1)
MOVEI T2,SO.ENB ;ENABLE INTERRUPTS
PUSHJ P,CNOSET ;DO IT
XCT KDBCNI(W) ;CONI SA10,T1
HRRZ T3,TS1SCN(W) ;GET SA10 SUBCHANNEL
MOVNS T3 ;T3=MINUS SUBCHANNEL NUMBER
MOVEI T2,SI.ENB ;INTERRUPT ENABLE FLAG FOR CHAN 0
LSH T2,(T3) ;T2=INTERRUPT ENABLE FLAG FOR OUR CHAN
TDNE T1,T3 ;SKIP IF ENABLE DIDNT SET
POPJ P, ;OK
;ROUTINE TO CAUSE AN INTERUPT TO FORCE A SCHEDULE CYCLE
STCRSL: ;ALSO REQUEST SELECTION INTERRUPT
TS1SCH: PUSHJ P,SAVE4## ;SAVE ACS FOR CALLER
MOVE T1,UDBPDN(U) ;GET PHYSICAL DRIVE NUMBER
ADDI T1,@TTSOFS(W) ;MAKE DEVICE ADDR
MOVEM T1,TTSDMD(W) ;SAVE AS LAST DUMMY DEVICE
MOVSI T2,(KD.SIR) ;SOFT-INTERUPT-REQUEST BIT
IORM T2,KDBSTS(W) ;SET IT FOR SAXSER
MOVEI T2,SO.SRQ ;STATUS REQUEST
PUSHJ P,CNOSET ;REQUESTS AN INTERRUPT
POPJ P,
;ROUTINE TO CHECK IF KONTROLLER IS ON LINE
;CALLED ONCE A SECOND.
;TAKE THIS OPPORTUNITY TO CHECK BUSY TIMER
TS1ONL: SKIPE TTSBCT(W) ;SKIP IF TIMER NOT SET
SOSLE TTSBCT(W) ;SKIP IF TIMER EXPIRES
JRST TS1ON1 ;GO CHECK/POLL FOR NEW UNITS
SETOM TTSBCT(W) ;MAKE SURE NEGATIVE FOR ENSUING INTERRUPT
AOS TTSBRC(W) ;COUNT TIMES TIMER EXPIRED
MOVE U,KDBCUN(W) ;GET CURRENT UNIT
MOVE U,(U) ;ADDR OF UDB
PUSHJ P,TS1SCH ;REQUEST SCHEDULING INTERRUPT
TS1ON1: PUSHJ P,TS1BOC ;GO REPORT BUS OUT CHECK IF NEEDED
SKIPE TS1OFL(W) ;SKIP IF WE THINK WE'RE ONLINE
JRST TS1ON0 ;BRANCH IF WE'RE OFFLINE
;$ SKIPL @KDBCHN(W) ;CHANNEL BUSY?
;$ JRST CPOPJ1## ;LEAVE IT ALONE
SKIPE T1,TS1NUM(W) ;GET BIT MASK
JFFO T1,TS1ON4 ;FIND FIRST UNIT NUMBER
HRRZS KDBNUM(W) ;INDICATE NO DRIVES TO CONFIGURE
SKIPL T1,TS1SUN(W) ;GET NON-EXISTANT UNIT BEING SENSED
JRST CPOPJ1## ;DO NOTHING IF SENSE IN PROGRESS
PUSHJ P,SAVE4## ;SAVE SOME ACS
AOS T1 ;ADVANCE TO NEXT UNIT
HRRZS T1 ;CLEAR LH FLAG
CAILE T1,TS1HDN ;OVERFLOW?
MOVEI T1,0 ;START WITH DRIVE ZERO
ADD T1,KDBIUN(W) ;INDEX INTO TABLE
TS1ON2: SKIPN (T1) ;KNOWN UNIT?
JRST TS1ON3 ;NO
CAMGE T1,KDBFUN(W) ;END OF TABLE?
AOJA T1,TS1ON2 ;TRY ANOTHER
SETOM TS1SUN(W) ;RESET COUNTER
JRST CPOPJ1## ;AND INDICATE CONTROLLER ONLINE
TS1ON3: SUB T1,KDBIUN(W) ;REDUCE TO A DRIVE NUMBER
MOVEM T1,TS1SUN(W) ;SAVE FOR NEXT TIME
SKIPL @KDBCHN(W) ;SKIP IF CHANNEL IS FREE
JRST CPOPJ1## ;BRAND (AND RETURN LATER) IF CHANNEL BUSY
;HERE FROM INTERRUPT LEVEL WHEN WE COMPLETE AN IORB
TS1ONI: PUSH P,M ;SAVE M
MOVE M,TS1GSN(W) ;GET GLOBAL SUBCHANNEL NUMBER
LDB P1,[POINT WIDCUA,KDBUNI(W),17] ;GET TCU NUMBER
XMOVEI P4,TS1SNS(W) ;POINT TO SENSE PROGRAM
HRRO P3,T1 ;GET MASSBUS UNIT (NONE),,DRIVE NUMBER
PUSHJ P,TS1DCK ;QUEUE UP SENSE REQUEST
JFCL ;SHOULD NEVER SKIP
JRST MPOPJ1## ;RETURN
TS1ON4: PUSHJ P,AUTLOK## ;GET AUTCON INTERLOCK
JRST CPOPJ1## ;TRY AGAIN NEXT TIME
PUSHJ P,SAVE4## ;SAVE SOME ACS
PUSH P,M ;SAVE M TOO
LDB P1,[POINT WIDCUA,KDBUNI(W),17] ;GET TCH
HRRO P3,T2 ;GET MASSBUS UNIT (NONE),,DRIVE NUMBER
XMOVEI P4,TS1SNS(W) ;POINT TO SENSE PROGRAM
MOVE T1,KDBDVC(W) ;DEVICE CODE
XMOVEI T2,TS1DSP ;DISPATCH
MOVE T3,KDBCHN(W) ;CHANNEL DATA BLOCK
PUSHJ P,AUTSET## ;SET UP CPU VARIABLES
PUSHJ P,TS1DRS ;TRY TO CONFIGURE A DRIVE
JFCL ;IGNORE ERRORS
PUSHJ P,AUTULK## ;RELEASE AUTCON INTERLOCK
HRROS TS1SUN(W) ;RELEASE THE POLLER (IE: UNLOCK THE SENSE BFR)
HRROS KDBNUM(W) ;GIVE AUTCON A FLAG
JRST MPOPJ1## ;TELL TAPSER THE CONTROLLER IS ALIVE
;HERE IF WE THINK WE'RE OFFLINE
TS1ON0: MOVE T1,KDBIUN(W) ;POINT AT UNIT TABLE
SOS (P) ;(UGH!) UNDO SKIP RETURN
JRST TS1ON3 ;GO FORCE A POLL FOR UNIT #0
TS1BOC: SKIPN TTSBUS(W) ;SKIP IF ANY UNITS GOT BUS OUT
POPJ P, ;EXIT IF OK
MOVE U,OPRLDB## ;POINT U FOR OUTPUT
PUSHJ P,INLMES## ;
ASCIZ *
% BUS-OUT Parity Error for * ;
SETZ T2,
EXCH T2,TTSBUS(W) ;GET OFFENDING UNIT
SKIPE T2 ;SKIP IF UNIT SOMEHOW DISAPPEARS
SKIPN T2,UDBNAM(T2) ;GET UNIT NAME
MOVSI T2,'MTA' ;THIS CAN'T HAPPEN
PUSHJ P,PRNAME## ;TYPE UNIT NAME
MOVE T2,.CPLOG## ;GET CPU NAME
LSH T2,-6 ;GET A LEADING SPACE
PUSHJ P,PRNAME ;TYPE CPU NAME
PUSHJ P,INLMES## ;
ASCIZ * SA* ;
LDB T1,[POINT 9,KDBCNO(W),11] ;GET DEVICE CODE
TRZ T1,3 ;TURN OFF OPCODE
PUSHJ P,PRTDI8## ;TYPE DEVICE CODE
PUSHJ P,INLMES## ;
ASCIZ * SC* ;
HRRZ T1,TS1SCN(W) ;GET LOCAL SUBCHANNEL #
PUSHJ P,PRTDI8## ;TYPE IT
PUSHJ P,INLMES## ;
ASCIZ * TCU* ;
HRRZ T1,TTSOFS(W) ;GET CU BASE ADDRESS
PUSHJ P,PRTDI8## ;
PJRST CRLF## ;EXIT
SUBTTL AUTOCONFIGURE
;CONFIGURE A SINGLE TCU
;P1/ TCU NUMBER
;P2/ JUNK,,LOCAL SUBCHANNEL #
;P4/ ADDRESS OF CHANNEL PROGRAM
;M/ GLOBAL SUBCHANNEL NUMBER
TS1CFS: PUSHJ P,SAVE4## ;SAVE SOME ACS
PUSHJ P,SAVW## ;SAVE FOR SAXSER
PUSH P,M ;SAVE M TOO
SETZ W, ;DON'T HAVE A KDB YET
MOVSI P3,-TS1DMX ;SET UP POINTER
PUSHJ P,TS1DC1 ;DO A SENSE TO GET SOME USEFUL INFORMATION
JFCL ;IGNORE POSSIBLE TIMEOUT (RELY ON SENSE BYTES)
MOVE T1,S17WRD+SNSDAT(P4) ;WORD WITH SENSE BYTE 17
AND T1,[S17TCE] ;ISOLATE TCU EC LEVEL
JUMPE T1,MPOPJ1## ;TCU ALWAYS HAS A NON-ZERO VALUE
HRRZ T1,P1 ;GET "TCU" NUMBER
TRO T1,400000 ;DON'T LET TAPINT THINK THIS IS RH
PUSHJ P,AUTKDB## ;BUILD A KDB
JRST MPOPJ## ;GIVE UP IF NO CORE
SKIPE TS1SNS(W) ;ALREADY HAVE A SENSE PROGRAM?
JRST TS1CF1 ;YES--EXISTING KDB
XMOVEI T1,TS1MDT## ;POINT TO MONGEN'ED DEVICE (SUB-)TABLE
SETZ T2, ;IMPLICIT DEFAULT MDT
HRLOI T3,(P2) ;SUB-CHANNEL,,ALL DRIVES
MOVEI T4,MD.KON ;KONTROLLER INFORMATION DESIRED
PUSHJ P,AUTMDT## ;SEE IF WE HAVE ANY DATA
SETZ T1, ;NO DATA
TRNN T1,-1 ;IF NO PORTING INFORMATION,
HRRI T1,-1 ;SET UP TO TRUST THE TX
MOVEM T1,TS1MDW(W) ;SAVE THE MDT DATA WORD
MOVEI T1,SNSLEN ;WORDS TO XFER
XMOVEI T2,SNSPGM ;SENSE CHANNEL PROGRAM
XMOVEI T3,TS1SNS(W) ;DENSTINATION
EXTEND T1,[XBLT] ;COPY
MOVEI T1,1 ;NUMBER OF DEVICE LIST ENTRIES NEEDED
PUSHJ P,SAXDVL## ;FILL IN THE TABLE
JRST MPOPJ## ;FAILED
MOVEM T1,TS1DVP(W) ;SAVE FOR LATER REFERENCE
TS1CF1: MOVEI T1,(P2) ;GET SUBCHANNEL
IMULI T1,SO.CHN ;POSITION
HRLZS T1 ; FOR CONI
HRRI T1,(P2) ;PUT SUBCHANNEL IN RH TOO
MOVEM T1,TS1SCN(W) ;SAVE
MOVEM M,TS1GSN(W) ;SAVE GLOBAL SUBCHANNEL NUMBER TOO
SETOM TS1SUN(W) ;NOT SENSING NON-EXISTANT UNITS
MOVE T2,SNSDVW(P4) ;GET SENSE COMMAND (FOR DRIVE#0)
LDB T1,DVYDVA ;GET ADDRESS FOR DRIVE#0
MOVEM T1,TTSOFS(W) ;REMEMBER DRIVE0 ADDRESS FOR LATER
MOVE T1,SAXSBA##(M) ;GET GLOBAL SUBCHANNEL DATA BLOCK ADDRESS
ADDI T1,.CLCSW ;ADD OFFSET TO COMPUTE ENDING STATUS WORD
MOVEM T1,TTSCSW(W) ;SAVE ADDRESS OF ENDING STATUS WORD
MOVE T1,KDBCSO(W) ;GET CONSO SKIP ADDRESS
MOVEI P3,(P1) ;GET TCU ADDRESS
MOVSI P3,-TS1DMX ;START WITH DRIVE ZERO
TS1CF2: PUSHJ P,TS1DRS ;BUILD UDB
JFCL ;PROBABLY NO DRIVE SWITCHED IN
AOBJN P3,TS1CF2 ;LOOP BACK FOR EACH POSSIBLE DRIVE
;$$*** DO WE WANT TO CALL TS1RES?
;$$*** DOESN'T IT ENABLE INTS?
;$$*** WE WOULD NEED TO INSERT WAIT TIMING SINCE
;$$*** ANY OTHER CU'S OF ANY KIND ON THE SAME SUBCHANNEL
;$$*** WILL REFUSE TO ANSWER OR RETURN BUSY'S WHILE RESET IS GOING.
PUSHJ P,TS1RES ;RESET SUBCHANNEL
JRST MPOPJ## ;RESTORE M AND RETURN
;AUTOCONFIGURE A SINGLE DRIVE FROM "UUO" LEVEL
TS1DRV: PUSHJ P,SAVE4## ;SAVE SOME ACS
PUSH P,M ;SAVE SOME MORE
LDB P1,[POINT WIDCUA,KDBUNI(W),17] ;GET TCU# FROM KDB
HRRO P3,U ;LOAD P3=<NO-MASS-BUS>,,DRIVE#
XMOVEI P4,TS1SNS(W) ;POINT P4 AT SENSE PROGRAM AND BUFFER
MOVE M,TS1GSN(W) ;GET GLOBAL SUBCHANNEL NUMBER FROM KDB
PUSHJ P,TS1DRS ;CALL INTERNAL ROUTINE TO CONFIGURE DRIVE
PJRST MPOPJ## ;NORMAL RETURN
PJRST MPOPJ1## ;SKIP RETURN
;AUTOCONFIGURE A SINGLE DRIVE VIA AN INTERNAL CALL
TS1DRS: PUSHJ P,TS1DCK ;DOES DRIVE EXIST?
POPJ P, ;NO
LDB T1,[POINTR (SNSDAT+S13WRD(P4),S13TCH)] ;HIGH BYTE TX S/N
LDB T2,[POINTR (SNSDAT+S14WRD(P4),S14TCL)] ;LOW BYTE TX S/N
ROT T2,-10 ;LEFT JUSTIFY
LSHC T1,10 ;MERGE HIGH + LOW BYTES
SKIPN T1 ;HAVE A NON-ZERO S/N?
MOVE T1,P1 ;NO, USE TCU NUMBER INSTEAD
SETZM KDBSER+0(W) ;NO HIGH ORDER S/N WORD
MOVEM T1,KDBSER+1(W) ;SAVE LOW ORDER S/N WORD
MOVE T1,SNSDAT+S17WRD(P4) ;SENSE BYTES 16-19
TLNN T1,(S172CH) ;TWO CHANNEL SWITCH CAPABILITY?
TLZ T1,(S17SWF) ;NO, IGNORE PORTING
LDB T1,[POINTR (T1,S17SWF)] ;GET SWITCH FEATURES
ANDI T1,3 ;STRIP OFF HI/LO UNIT BIT
AOS T1 ;GET MAXIMUM NUMBER OF PORTS
LSH T1,1 ;ACCOUNT FOR A/B PATH PER TCU
HRRZ T2,TS1MDW(W) ;GET PORT COUNT FROM MDT DATA WORD
CAILE T1,(T2) ;IF THE MDT KNOWS BETTER THAN WE DO,
MOVE T1,T2 ;THEN TRUST IT
DPB T1,[POINTR (KDBSTS(W),KD.MPT)] ;SAVE
MOVSI T2,(KD.MPD) ;GET A BIT
CAIE T1,1 ;IF MORE THAN ONE PATH,
IORM T2,KDBSTS(W) ;THEN SAY MULTI-PORTED DEVICE
TS1DR1: MOVSI T1,(S05NSS) ;BIT TO TEST
TDNN T1,S05WRD+SNSDAT(P4) ;NEW SUBSYSTEM?
JRST TS1DR2 ;MUST DUMMY UP S/N IF A TX01
MOVE T1,S12WRD+SNSDAT(P4) ;SENSE BYTES 12-15
MOVE T2,S16WRD+SNSDAT(P4) ;SENSE BYTES 16-19
LSH T1,-4 ;POSITION HIGH ORDER S/N BITS
ANDI T1,377 ;ISOLATE HIGH ORDER S/N BITS
LSHC T1,-34 ;MERGE HIGH AND LOW BITS
JUMPN T2,TS1DR3 ;CONTINUE IF S/N IS NON-ZERO
TS1DR2: DMOVE T1,KDBSER(W) ;GET TCU SERIAL NUMBER
IMULI T2,^D100 ;TIMES 100
ADDI T2,(P3) ;INCLUDE DRIVE NUMBER
TS1DR3: DMOVEM T1,.CPTSN## ;SAVE TEMPORARILY
HRRZ T3,P3 ;GET PHYSICAL DRIVE NUMBER
PUSHJ P,AUTDPU## ;LINK UP DUAL PORTED DRIVES
JFCL ;MUST PROCEED EVEN IF DUAL PORTED
MOVEI T1,TUCD80##+TUCD16## ;ASSUME TU70
MOVE T2,S13WRD+SNSDAT(P4) ;SENSE BYTE 13
TLNN T2,(S13FET) ;SKIP IF WE HAVE NRZI FEATURE
MOVEI T1,TUCD16## ;ASSUME 1600 BPI ONLY
MOVE T2,S06WRD+SNSDAT(P4) ;SENSE BYTE 6
TLNE T2,(S067TK) ;7 TRACK?
MOVEI T1,TUCD20##+TUCD55##+TUCD80##+TUC7TK##
TRNE T2,S06D62 ;6250 DRIVE?
MOVEI T1,TUCD16##+TUCD62##
TRO T1,TUCIRD##+K.TS1 ;INCLUDE REWIND INTERRUPT AND KONT TYPE
MOVE T2,T1 ;COPY DRIVE INFO
HRRZ T1,P3 ;GET PHYSICAL DRIVE NUMBER
HRLS T1 ;MAKE IT THE TABLE INDEX TOO
PUSH P,P1 ;SAVE P1
HRRZ P1,P3 ;GET PHYSICAL DRIVE NUMBER
LDB T3,[POINTR (SNSDAT+S06WRD(P4),S06MOD)] ;GET TU MODEL BITS
SETZ T4, ;INCASE WE CAN'T FIGURE IT OUT
CAIN T3,5 ;TU70/71?
MOVE T4,['TU70 '] ;YES
TRNE T2,TUC7TK## ;BUT IS IT 7-TK?
TRO T4,10000 ;MAKE IT A TU71
CAIN T3,14 ;TU72?
MOVE T4,['TU72 '] ;YES
CAIN T3,15 ;TU73?
MOVE T4,['TU73 '] ;YES
XMOVEI T3,HNGTBL ;POINT TO HUNG TIMER TABLE
PUSHJ P,TAPDRV## ;BUILD AND LINK UP UDB AND DDB
JFCL ;FAILED
POP P,P1 ;RESTORE
DMOVE T1,.CPTSN## ;RETRIEVE DRIVE SERIAL NUMBER
DMOVEM T1,UDBDSN(U) ;SAVE IN UDB
JRST CPOPJ1## ;RETURN SUCCESS
;CHECK FOR DRIVE EXISTANCE
TS1DCK: JUMPE W,TS1DC2 ;JUMP IF NO KDB
HRRZ T1,P3 ;GET DRIVE NUMBER
MOVE T1,BITTBL##(T1) ;AND IT'S BIT
TDNE T1,TS1IUM(W) ;WANT TO IGNORE THIS DRIVE?
POPJ P, ;SAY IT DOESN'T EXIST
TS1DC1: JUMPE W,TS1DC2 ;JUMP IF NO KDB
SKIPL T1,TS1SUN(W) ;FULL AUTOCONFIGURE?
JRST TS1DC2 ;NO
HRRZS T1 ;ISOLATE POSSIBLE DRIVE NUMBER
HRRZ T2,P3 ;AND THE ONE BEING CONFIGURED NOW
CAIN T1,(T2) ;MATCH?
JRST CPOPJ1## ;THEN INTERRUPT LEVEL TOLD US IT EXISTED
TS1DC2: MOVE T1,P1 ;GET TCU #
LSH T1,WIDUNA ;POSITION IN DEVICE ADDRESS
ADDI T1,(P3) ;INCLUDE DRIVE NUMBER
MOVE T2,SNSPGM+SNSDVW ;GET SENSE COMMAND
DPB T1,DVYDVA ;INSERT DEVICE ADDRESS
MOVEM T2,SNSDVW(P4) ;STORE DVW
MOVE T2,SNSPGM+SNSNOP ;GET NOP COMMAND
DPB T1,DVYDVA ;INSERT ADDRESS
MOVEM T2,SNSNOP(P4) ;STORE NOP
MOVE T2,SNSPGM+SNSDCW ;GET THE -VE BYTE COUNT FOR SENSE DATA
HRRI T2,SNSDAT(P4) ;FILL IN ADDRESS OF SENSE DATA
MOVEM T2,SNSDCW(P4) ;STORE DCW
SETZM SNSHLT(P4) ;INSERT A HALT
MOVSI T2,SNSHLT(P4) ;SET UP TO CLEAR SENSE DATA
HRRI T2,SNSDAT(P4) ; (CONVENIENT WE CLEARED WORD 2, HUH?)
BLT T2,SNSDAT+SNSWDS-2(P4) ;ZERO THE SENSE DATA AREA
SETOM SNSDAT+SNSWDS-1(P4) ;LEAVE LAST BYTES -1 FOR VALIDITY CHECK
JUMPE W,TS1DC3 ;IF FIRST TIME HERE, NO KDB
SKIPGE TS1SUN(W) ;FULL AUTOCONFIGURE?
JRST TS1DC3 ;GLET SAXSER RUN THE CHANNEL PROGRAM
MOVEI T2,TS1SNS+SNSNOP(W) ;GET VIRTUAL PC OF SENSE PROGRAM
MOVEM T2,TS1PPC(W) ;WHERE TO START/RESTART
MAP T2,TS1SNS+SNSNOP(W) ;GET THE PHYSICAL PC OF THE SENSE'S NOP
MOVE T1,TTSOFS(W) ;GET UNIT#0 ADDRESS
ADD T1,P3 ;COMPUTE OUR UNIT #
DPB T1,[POINT SASDLD,T2,SANDLD] ;INSERT THE DEVICE ADDRESS
MOVEI T1,DL.STA ;GET THE "START" OPCODE
DPB T1,[POINT SASDLO,T2,SANDLO] ;INSERT THE OPCODE
PMOVEM T2,TS1DVP(W) ;CREATE NEW DEVL ENTRY
PJRST SETGOB ;SET "GO" BIT AND RETURN
TS1DC3: MOVE T1,P4 ;COPY CHANNEL PROGRAM ADDRESS
ADDI T1,SNSDVW ;SKIP OVER THE NO-OP -- CALLER ALREADY DID IT
PUSHJ P,SAXRCP## ;RUN THE CHANNEL PROGRAM
POPJ P, ;ERROR
MOVE T1,S17WRD+SNSDAT(P4) ;GET THE TCU EC WORD
AND T1,[S17TCE] ;ISOLATE THE LEVEL
JUMPE T1,CPOPJ## ;BRANCH IF UNIT IS NOT A TAPE UNIT
MOVSI T1,(S01TUA!S01TUB) ;BITS TO TEST
TDNN T1,S01WRD+SNSDAT(P4) ;DRIVE EXIST?
POPJ P, ;NO
;$$ MOVE T1,S06WRD+SNSDAT(P4) ;GET SENSE BYTE 6 (MODEL ID)
;$$ TDNN T1,[S06MOD] ;SKIP IF MODEL TYPE KNOWN
;$$ POPJ P, ;RETURN IF NOT A GOOD DRIVE AFTER ALL
JUMPE W,CPOPJ1## ;GIVE GOOD RETURN IF NO KDB TO FIX UP
HRRZ T1,P3 ;GET DRIVE NUMBER
SETCA T1,BITTBL##(T1) ;TRANSLATE DRIVE NUMBER TO A BIT
SETZ T2, ;ASSUME NO OTHER NEW DRIVES
SYSPIF ;AVOID RACE WITH INTERRUPT LEVEL
ANDB T1,TS1NUM(W) ;CLEAR SINCE DRIVE IS NO LONGER "NEW"
SKIPE T1 ;WORK PENDING FOR OTHER DRIVES?
MOVNI T2,1 ;YES
HLLM T2,KDBNUM(W) ;UPDATE FLAG
SYSPIN ;RELEASE INTERLOCK
JRST CPOPJ1## ;SAY DRIVE EXISTS
SUBTTL START I/O
;ROUTINE TO START I/O
;USER JOB MUST BE NAILED DOWN - CAUSE SELECTION INTERUPT
;OR JUST START I/O IF UNIT ALREADY SELECTED
TS1SIO: PUSHJ P,SAVE1## ;SAVE P1
MOVE T1,UDBPDN(U) ;PHYSICAL DEVICE NUMBER
CAME T1,TS1UNI(W)
PJRST STCRSL ;REQUEST SELECTION INTERRUPT
STCSI1: PUSHJ P,CHKIRB## ;GET IORB
JRST STSCLR ;BRANCH IF NO IORB AND DISMISS INTERRUPT
TAPOFF ;PREVENT POLLER INTERRUPT
SKIPE TS1PPC(W) ;SKIP IF POLLER IS IDLE
JRST TS1SI2 ;BRANCH TO DEFER STARTUP TILL POLLER IS DONE
TAPON ;ALLOW INTERRUPT AGAIN
MOVE P1,T1 ;LOAD UP IORB IN A SAFER PLACE
PUSHJ P,SETCMD ;SET-UP THE COMMAND LIST
JRST STIDON ;JUST EXIT IF ILLEGAL REQUEST
SETGOP: SKIPN TS1PPC(W) ;SKIP IF A PROGRAM TO DO
JRST NXTWAT ;PUNT IF NO PROGRAM TO RUN
PUSHJ P,SETDVP ;SETUP DEVL FROM PPC
SETGOB: MOVEI T2,SO.GO ;GO FLAG
PUSHJ P,CNOSET ;SET IT
PUSHJ P,TRK222 ;$ DO A GO TRACK
NXTWAT: PUSHJ P,STSCLR ;CLEAR STATUS FLAG
MOVEI T1,0 ;MORE INTS COMING
POPJ P, ;RETURN
TS1SI2: MOVEM U,TS1DUM(W) ;REMEMBER TO START UNIT WHEN POLLER IS DONE
TAPON ;ALLOW POLLER TO COMPLETE
JRST NXTWAT ;TILL UUO LEVEL THAT IT IS IN PROGRESS
;HERE IF NO STATUS WORTH REMEMBERING
STCOFL: MOVSI T2,RB.SOL ;SET OFF-LINE STATUS
IORM T2,TRBSTS(P1)
PUSHJ P,CLRCTL ;RESET CTL
PJRST STIDON ;AND DISMISS INTERRUPT
SUBTTL COMMAND SETUP
;ROUTINE TO SET UP CHANNEL PROGRAM HEADER
;T1 := IORB FOR THIS REQUEST
SETCMD: MOVE T1,P1 ;WHERE TAPSER NEEDS IORB ADDRESSES
PUSHJ P,TRK555 ;$ TRACK IORB REQUEST
PUSHJ P,SAVR## ;SAVE R
MOVEI R,TTSPRG(W) ;POINT AT PROGRAM
LDB T4,PRBFCN## ;GET DESIRED FCN
CAIG T4,IOFMAX ;SKIP IF NEW FUNCTION
SKIPN T2,IOFTAB(T4) ;CHECK LEGAL
JRST SETILG ;NOPE - ERROR
TRNE T2,IOXLST ;SKIP IF NOT DATA TRANSFER
JRST SETXFR ;HANDLE DATA XFER
TRNE T2,IOXDSE ;SKIP IF NOT DATA-SECURITY-ERASE
JRST SETDSE ;BRANCH TO HANDLE DATA-SECURITY-ERASE
TRNE T2,IOXXCW ;SKIP IF NOT "XCW HAS A SPACING COUNT"
JRST SETXCW ;BRANCH TO HANDLE SPACING-OPERATIONS
JRST SETCTL ;BRANCH TO HANDLE RANDOM CONTROL COMMAND
SETEND: MOVE T2,[BMXEND] ;GET THE END OF PROGRAM
MOVEM T2,(R) ;SAVE IT
MOVEI T4,TTSPRG(W) ;GET INITIAL ADDRESS OF PROGRAM
MOVEM T4,TS1PPC(W) ;SAVE PROGRAM-PC
JRST CPOPJ1## ;GIVE GOOD RETURN
;HERE TO BUILD A COMMAND LIST FOR DATA-SECURITY-ERASE
SETDSE: PUSH P,T2 ;SAVE THE DSE OPCODE
HLLZ T2,IOFTAB+RB.FLG ;GET ERG COMMAND
PUSHJ P,SETDVW ;SET A DEVICE-WORD INTO THE PROGRAM
POP P,T2 ;GET BACK THE DSE CMD
PUSHJ P,SETDVW ;INSERT DSE INTO PROGRAM
JRST SETEND ;SET UP END-OF-PROGRAM
;HERE TO BUILD A COMMAND LIST FOR A MULTI-REC SPACING OPERATION
; N.B.: TAPSER DOES THIS TO IMPLEMENT FORWARD/BACKWARD FILE.
; TAPSER DOES NOT NECESSARILY EXPECT THE TRUE COUNT OF OPS
; TO ACTUALLY TAKE PLACE, SO LONG AS WE RETURN IF WE FAIL.
SETCTL: SKIPA T4,[1] ;FAKE UP A COUNT OF 1 IF RANDOM-CTL COMMAND
SETXCW: HRRZ T4,@IRBACC(P1) ;GET COUNT
TRZN T2,IOXWRT ;SKIP IF READ OPERATION
JRST SETXC1 ;BRANCH IF A READ OPERATION
PUSHJ P,SETMOD ;SETUP MODE-SET-1/2
JRST SETILG ;BRANCH IF ILLEGAL SET REQUESTED
SETXC1: CAIN T4,1 ;SKIP IF NOT LAST OPERATION
TLZ T2,(F.CC) ;TURN OFF CHAINING FOR LAST OPERATION
PUSHJ P,SETDVW ;INSERT THE REQUESTED OPERATION
SOJLE T4,SETEND ;EXIT WHEN LAST OP INSERTED, SKIP TRAILING NOP
PUSHJ P,SETNOP ;INSERT A CHAINED NOP
JRST SETXC1 ;LOOP BACK FOR MORE OPS
SETNOP: PUSH P,T2 ;SAVE AN AC
MOVE T2,[F.CC!NOPCMD] ;GET A CHAINED NO-OP
PUSHJ P,SETDVW ;INSERT THE NO-OP INTO THE PROGRAM
POP P,T2 ;RESTORE THE AC
POPJ P, ;RETURN TO CALLER
;HERE AT INTERRUPT LEVEL TO LOAD T1=COUNT OF XCW OPS THAT WON
FNDXCW: LDB T1,[POINT 22,TTSTCA(W),35] ;GET UNDONE PC
;*** N.B.: THIS WORKS BECAUSE THE PROGRAM IS MAPPED 1:1 S0 WITH PHYSICAL
SUBI T1,TTSPRG(W) ;COMPUTE OFFSET INTO PROGRAM
LSH T1,-1 ;DIVIDE BY TWO
POPJ P, ;EXIT WITH WIN-COUNT IN T1
;HERE TO BUILD A PROGRAM TO DO ACTUAL USER-REQUEST DATA I/O
SETXFR: TRNE T2,IOXTIE ;SKIP IF NOT TRYING TIE RECOVERY
SKIPGE TS1TIE(U) ;SKIP IF TRYING TIE, AND WE HAVE VALID TIE DATA
PUSHJ P,SETMOD ;INSERT THE MODE-SET AS NEEDED
JFCL SETILG ;BRANCH IF MODE-SET REQUESTED IS ILLEGAL
TRZE T2,IOXTIE ;SKIP IF TIE CMD NOT NEEDED
PUSHJ P,SETTIE ;SETUP THE TRACK-IN-ERROR IF NEEDED
PUSHJ P,SETDVW ;INSERT THE I/O COMMAND INTO THE PROGRAM
PUSHJ P,MAPIO ;FINALLY, CONVERT DF10 LIST INTO SA10 LIST
JRST SETEND ;SET-UP THE END OF PROGRAM
;ROUTINE TO POSSIBLY SETUP A TRACK-IN-ERROR-REQUEST COMMAND
; IF THIS COMMAND REQUIRES IT
SETTIE: SKIPGE TS1TIE(U) ;SKIP IF TIE DATA TO USE
POPJ P, ;RETURN IF NO TIE DATA
PUSHJ P,SAVT## ;DON'T DESTROY CONTEXT
MOVE T2,[F.NMT!F.CC!F.SLI!F.OFP!<O.TIE>B15] ;TIE COMMAND
PUSHJ P,SETDVW ;INSERT IT
MAP T2,TS1TIE(U) ;GET PHYSICAL ADDRESS OF TIE BYTE
TLO T2,777700 ;INSERT BYTE COUNT OF 1
PUSHJ P,SETDCW ;INSERT DCW
SETOM TS1TIE(U) ;NO MORE TIE DATA
POPJ P, ;RETURN
;ROUTINE TO INSERT A MODE-SET-1 OR MODE-SET-2 INTO PROGRAM
SETMOD: PUSHJ P,SETFLG ;SET PROPER MODE BITS IN COMMAND IN T2
PUSH P,T2 ;SAVE THE I/O COMMAND
MOVE T1,P1 ;WHERE TAPSER DEMANDS IORB ADDRESSES
LDB T3,PRBDEN## ;GET DENSITY BYTE
MOVSI T2,RB.PAR ;CHECK PARITY
TDNE T2,TRBFNC(P1) ;ON FOR EVEN PARITY
TRO T3,20 ;REMEMBER EVEN PARITY
MOVEI T2,TUC7TK## ;7-TRACK BIT
TDNE T2,TUBCNF##(U) ;SKIP IF 9-TRACK UNIT
TRO T3,10 ;REMEMBER 7-TRACK
ROT T3,-1 ;DIVIDE BY TWO, REMAINDER TO SIGN BIT
HLLZ T2,MODTAB(T3) ;ASSUME WANT LH
SKIPGE T3 ;SKIP IF WAS EVEN
HRLZ T2,MODTAB(T3) ;THATS ODD, WANT RH
JUMPE T2,T2POPJ## ;BRANCH IF ILLEGAL SET REQUEST
TLO T2,(F.NMT!F.CC) ;NO MEMORY XFER, CHAINED
PUSHJ P,SETDVW ;SET MODE-SET INTO PROGRAM
JRST T2POJ1## ;GIVE GOOD RETURN
;THE FOLLOWING TABLE IS INDEXED BY THE 5 BIT QUANTITY FORMED BY
;PARITY,CHAN7,DENSITY,DENSITY,DENSITY
;THEN DIVIDED BY 2 TO ACCOUNT FOR HALF WORDS.
;(INDUSTRY-COMPATIBLE MODE IS FILTERED OUT BEFORE GET THIS FAR).
MODTAB: XWD <O.9MS+N.STD>_2 ,<O.9MS+N.NRZI>_2 ;0,,1
XWD <O.9MS+N.PE>_2 ,<O.9MS+N.NRZI>_2 ;2,,3
XWD <O.9MS+N.PE>_2 ,<O.9MS+N.GCR>_2 ;4,,5
XWD 0 ,0 ;6,,7
XWD <O.7MS+D.556+M.DCON>_2 ,<O.7MS+D.200+M.DCON>_2 ;10,,11
XWD <O.7MS+D.556+M.DCON>_2 ,<O.7MS+D.800+M.DCON>_2 ;12,,13
XWD 0 ,0 ;14,,15
XWD 0 ,0 ;16,,17
XWD 0 ,0 ;20,,21
XWD 0 ,0 ;22,,23
XWD 0 ,0 ;24,,25
XWD 0 ,0 ;26,,27
XWD <O.7MS+M.EPAR+D.556>_2 ,<O.7MS+M.EPAR+D.200>_2 ;30,,31
XWD <O.7MS+M.EPAR+D.556>_2 ,<O.7MS+M.EPAR+D.800>_2 ;32,,33
XWD 0 ,0 ;34,,35
XWD 0 ,0 ;36,,37
;SET IMPROPER MODE AND RETURN
SETILG: MOVSI T2,RB.SIL!RB.SER ;ILLEGAL OP
IORM T2,TRBSTS(P1) ;SET IN IORB
POPJ P, ;ERROR RETURN
;SUBROUTINE TO STORE DEVICE ADDR IN T2
SETDVA: MOVE T3,UDBPDN(U) ;PHYSICAL DEVICE NUMBER
ADDI T3,@TTSOFS(W) ;MAKE PROPER DEVICE ADDRESS
DPB T3,[POINT DVSDVA,T2,DVNDVA] ;STORE IT
POPJ P, ;RETURN
;SUBROUTINE TO SET SA10 MODE FLAGS
SETFLG: MOVEI T3,TUC7TK## ;7-TRACK FLAG
TDNN T3,TUBCNF##(U) ;SKIP IF 7-TRACK DRIVE
JRST SETF.9 ;NO, 9-TRACK
MOVSI T3,RB.PAR
TDNE T3,TRBFNC(P1) ;SKIP IF ODD PARITY
TLOA T2,(F.7TE) ;7-TRACK, EVEN PARITY FLAGS
TLO T2,(F.7TK) ;7-TRACK, ODD PARITY FLAGS
POPJ P, ;RETURN
SETF.9: MOVE T1,P1 ;WHERE TAPSER REQUIRES IORB ADDRESSES
LDB T3,PRBMOD## ;GET MODE
CAIN T3,RB.MBY ;SKIP UNLESS INDUSTRY-COMPATIBILITY
TLOA T2,(F.IND) ;9-TRACK, INDUSTRY-COMPATIBLE FLAGS
TLO T2,(F.9TK) ;9-TRACK, DEC-MODE
POPJ P,
;SUBROUTINE TO INSERT A DEVICE COMMAND IN T2 INTO THE PROGRAM BUFFER.
;ALWAYS INSERT THE DEVICE-ADDRESS, ALWAYS TURN ON COMMAND-CHAINING.
SETDVW: PUSHJ P,SETDVA ;ADDRESS DEVICE ADDRESS FIELD
TLO T2,(F.XEC) ;EXECUTE, NOT HALT.
SETDCW: MOVEM T2,(R) ;INSERT INTO THE PROGRAM
AOJA R,CPOPJ## ;EXIT
;TABLE FOR I/O FUNCTIONS - ALREADY IN POSITION
DEFINE IOT(CMD,BITS) <
BITS+<CMD>
>
;ALLOWABLE SPECIAL FCN BITS
IOXTIE==1B31 ;OPERATION REQUIRES TRACK-IN-ERROR REQUEST FIRST
IOXLST==1B32 ;DATA XFER LIST REQUIRED
IOXXCW==1B33 ;SPACING OPERATION FOR WHICH COUNT IMPLEMENTED
IOXDSE==1B34 ;DATA SECURITY ERASE
IOXWRT==1B35 ;WRITE OPERATION
IOFTAB: 0 ;0 - ILLEGAL
IOT(<<O.RD>B15>,IOXLST) ;1 - READ
IOT(<F.SLI!<O.WR>B15>,IOXLST!IOXWRT) ;2 - WRITE
0 ;3 - ILLEGAL
IOT(<F.NMT!F.CC!<C.FSB>B15>,IOXXCW) ;4 - FORWARD SPACE BLOCK
IOT(<F.NMT!F.CC!<C.BSB>B15>,IOXXCW) ;5 - BACKWARD SPACE BLOCK
IOT(<F.NMT!<C.FSF>B15>) ;6 - FORWARD SPACE FILE
IOT(<F.NMT!<C.BSF>B15>) ;7 - BACKSPACE FILE
IOT(<F.NMT!F.CC!<C.ERG>B15>,IOXWRT!IOXXCW) ;10 - WRITE LONG GAP
IOT(<F.NMT!<C.DSE>B15>,IOXWRT!IOXDSE) ;11 - DATA SECURITY ERASE
IOT(<F.NMT!<C.REW>B15>) ;12 - REWIND
IOT(<F.NMT!<C.RUN>B15>) ;13 - REWIND / UNLOAD
IOT(<F.NMT!<C.WTM>B15>,IOXWRT) ;14 - WRITE TAPE MARK
IOT(<<O.NOP>B15>) ;15 - "YELLOW BALL" STATUS
IOT(<<O.RD>B15>,IOXTIE!IOXLST) ;16 - CORRECTION READ
IOT(<<O.RD>B15>,IOXLST) ;17 - READ LOW THRESHOLD
IOFMAX==.-IOFTAB ;REMEMBER MAX FCN NUMBER
;HUNG TIMER TABLE
EXP ^D480 ;MAXIMUM TIMEOUT VALUE
HNGTBL: BYTE(9) ^D000,^D046,^D046,^D046 ;IL,RD,WT,RB
BYTE(9) ^D046,^D046,^D480,^D480 ;SR,BR,SF,BF
BYTE(9) ^D046,^D480,^D135,^D135 ;LG,SE,RW,RU
BYTE(9) ^D046,^D046,^D046,^D046 ;TM,YB,CR,RL
;ROUTINE TO CONVERT A DF10 IOWD LIST INTO AN SA10 LIST FOR A TAPE XFER
;ENTER:
; T1/ IORB ADDRESS
; U/ UDB ADDRESS
; W/ KDB ADDRESS
;BUT THEN:
; P1/ POINTER TO DF10 LIST
; P2/ POINTER TO SA10 LIST
; P3/ COUNT AS RETURNED IN T1 FROM GETIOW
; P4/ PA AS RETURNED IN T2 FROM GETIOW
MAPIO: PUSHJ P,SAVE4## ;SAVE SOME ACS
HLRE M,TRBRCT(P1) ;GET -VE COUNT
MOVMS M ;MAKE IT +VE COUNT
HRRZ T3,TRBRCT(P1) ;GET UVA OR 0 IF M IS BYTES
MOVE T1,P1 ;GET IORB ADDRESS
MOVEI T4,1 ;MULTIPLIER IS 1
LDB T2,PRBMOD## ;GET BYTE CONTAINING MODE INFO
CAIE T2,RB.MBY ;SKIP IF "MTIND." INDUSTRIAL MODE
SKIPN T3 ;SKIP IF WORD COUNT IS IN WORDS
MOVEI T4,4 ;IF A BYTE MODE, WE ONLY SUPPORT 4 BYTES PER WORD
HRRZ P1,@IRBACC(P1) ;POINT AT DF10 IOWD LIST
MOVEI P2,(R) ;POINT AT SA10 COMMAND LIST
MOVEM P2,TTSMIO(W) ;SAVE POINTER TO 1ST IOWD WORD
;HERE TO FETCH SOME MORE DF10 IOWDS
MAPIO1: PUSH P,T4 ;PROTECT THE MODE INFO
PUSHJ P,GETIOW## ;GET AN EXPANDED IOWD FROM DF10 LIST
POP P,T4 ;RESTORE THE MODE INFO
JUMPE T1,MAPIO4 ;BRANCH WHEN WE GET A HALT
IMULI T1,(T4) ;POSSIBLY CONVERT WORD COUNT TO BYTE COUNT
DMOVE P3,T1 ;COPY "IOWD" INTO P3/P4
;HERE TO SPLIT A DF10 EXPANDED IOWD INTO AS MANY SA10 DCWs AS NEEDED
MAPIO2: CAIG P3,^D2048 ;SKIP IF WE CAN'T FIT INTO ONE DCW
JRST MAPIO3 ;BRANCH IF ONLY ONE DCW FOR THIS IOWD
MOVE T1,P4 ;COPY ADDRESS PORTION (CUZ COUNT FIELD IS 0S)
MOVEM T1,(P2) ;INSERT THE DCW WORD WITH COUNT OF 2048
SUBI P3,^D2048 ;ADJUST THE COUNT REGISTER
MOVEI T1,^D2048 ;GET POSSIBLE COUNT
IDIVI T1,(T4) ;COMPUTE THE NUMBER OF ADDRESS UNITS
ADD P4,T1 ;COMPUTE NEW ADDRESS
AOJA P2,MAPIO2 ;LOOP TO FURTHER SPLIT UP THIS DF10 IOWD
;HERE WHEN THE REST OF A DF10 EXPANDED IOWD CAN EXACTLY FIT IN ONE SA10 DCW
MAPIO3: IMUL P3,[-100,,0] ;MAKE COUNT -VE AND POSITION
TLZ P3,(1B0) ;TURN OFF "THIS IS LAST DCW" BIT
OR P3,P4 ;INSERT THE ADDRESS PORTION
MOVEM P3,(P2) ;INSERT THE LAST ONE FOR THIS DF10 IOWD
AOJA P2,MAPIO1 ;BRANCH BACK TO GET ANOTHER DF10, IF ANY
;HERE WHEN WE ENCOUNTER THE DF10 HALT
MAPIO4: MOVSI T1,(1B0) ;GET THE "THIS IS LAST DCW" BIT
IORM T1,-1(P2) ;TURN IT ON
MOVEI R,(P2) ;PUT NEW PC INTO R
POPJ P, ;RETURN
SUBTTL CHECK FOR KONTROLLER BUSY
;CHECK FOR KONTROLLER BUSY
;CALL: MOVE W, KDB ADDRESS
; MOVE U, UDB FOR DRIVE TRYING TO SCHEDULE
; PUSHJ P,TS1BSY
; <NON-SKIP> ;BUSY
; <SKIP> ;NOT-BUSY
;
;USES T1 AND T2
TS1BSY: PUSHJ P,SAVE2## ;SAVE P1 AND P2
PUSH P,U ;SAVE U
MOVE P1,KDBIUN(W) ;POINT TO START OF DRIVE TABLE
MOVSI P2,-<TS1DMX/2> ;ACTUAL RANGE OF DRIVES PER KONT
MOVE T1,UDBPDN(U) ;GET PHYSICAL DRIVE NUMBER
TRZ T1,<TS1DMX/2>-1 ;MASK OUT DRIVE LEAVING KONTROLLER OFFSET
ADDI P1,(T1) ;ADJUST STARTING TABLE INDEX
TS1BS1: SKIPE U,(P1) ;GET A TUB ADDRESS
PUSHJ P,CHKIRB## ;SEE IF IT HAS A VALID IORB
JRST TS1BS2 ;TRY ANOTHER DRIVE
LDB T2,PRBFCN## ;GET FUNCTION CODE
MOVE T2,BITTBL## ;NOT PICK UP THE ASSOCIATED BIT
TDNN T2,TS1NBF ;NON-BLOCKING FUNCTION?
POPJ P, ;NO--KONT IS BUSY
TS1BS2: AOBJN P2,TS1BS1 ;LOOP BACK IF MORE DRIVES TO CHECK
JRST UPOPJ1## ;RESTORE U AND RETURN KONT NOT BUSY
SUBTTL STATUS REQUEST ("YELLOW BALL")
STISTS: SKIPN TS1SIP(U) ;SKIP IF WE GOT SENSE DATA
JRST ERRSNS ;CAUSE SNSANA TO BE INVOKED
JRST STIDON ;EXIT BECAUSE SNSANL DID OUR WORK
;HERE ON DONE INTERRUPT FOR DSE
STIDSE: PUSHJ P,CHKWLK ;CHECK FOR WRITE-LOCK
PUSHJ P,STCKMV ;CHECK FOR MOTION ERROR
JRST MOTERR ;PASS ALONG MOTION ERROR TO TAPSER
PUSHJ P,CHKEOT ;CHECK FOR AND SET EOT
PJRST STIDON ;ALL DONE
SUBTTL READ
;HERE ON DONE INTERUPT FOR READ
STIRD: SKIPN TS1SIP(U) ;SKIP IF WE HAVE SENSE DATA
PUSHJ P,STISNS ;GO FORCE A SENSE IF RECORD 0
PUSHJ P,STCKMV ;SEE IF TAPE MOVED
PJRST MOTERR ;BRANCH IF TAPE DID NOT MOVE
AOS TUBREC(U) ;ONE MORE RECORD
PUSHJ P,CHRCT ;GET CHARACTER COUNT
JRST [MOVSI T4,RB.STL
IORM T4,TRBSTS(P1)
JRST .+1]
MOVEM T2,TRBRCT(P1) ;SAVE COUNT IN IORB
MOVEM T2,TUBCCR##(U) ;AND IN UDB
TLNE P4,(S.UE) ;SKIP IF NO TAPE MARK
PUSHJ P,NXTFIL ;ADJUST TUBFIL AND TRBSTS FOR ONE MORE FILE
MOVE T2,TUBCCR##(U) ;GET CHAR COUNT FOR THIS RECORD
ADDM T2,TUBCRD##(U) ;AND UPDATE STATISTICS
ADDM T2,TKBCRD(W)
ADDM T2,.CPTFI##
; PJRST STIDON ;DISMISS INTERRUPT
;HERE TO FINISH INTERUPT AND EXIT TO TAPSER
STIDON: SETZM TS1SIP(U) ;NO LONGER SENSING
SETZM TS1PPC(W) ;NO MORE PROGRAM TO RUN
MOVE T1,P1 ;COPY IORB ADDRESS FOR TAPINT
JUMPE T1,STIDO3 ;BRANCH IF NO IORB TO UPDATE
MOVE T3,UDBPDN(U) ;PHYSICAL DEVICE NUMBER
MOVEM T3,TS1UNI(W) ;AND SAVE IT FOR LATER CHECK
HLRZ T3,TRBSTS(P1) ;LOOK AT FLAGS
JUMPE T3,STIDO2 ;RETURN IF NONE
MOVSI T2,RB.EXC ;ELSE SET EXCEPTION
IORM T2,TRBFNC(P1) ;IN IORB
STIDO2:
STIDO3: SKIPN TS1NUM(W) ;SKIP IF POLLER HAS INPUT ALREADY
SKIPGE TS1SUN(W) ;SKIP IF POLLER IS WAITING FOR A UNIT
JRST DISMIS ;DISMIS IF NO POLLING TO BE DONE
MOVE T1,TS1SUN(W) ;GET T1 NOW WE KNOW WE DON'T NEED IORB IN T1
PUSHJ P,TS1ONI ;STARTUP PENDING POLLING NOW
JFCL ;SO?
MOVEM U,TS1STI(W) ;REMEMBER UNIT NEEDING STIDON'ING
SETZ T1, ;TELL TAPSER THAT UUO ISN'T DONE YET
POPJ P, ;(IE: TELL IT LATER WHEN POLL IS COMPLETED)
DISMIS: SETZM TTSBCT(W) ;MAKE SURE STOP BUSY TIMER IF GET INT
SKIPE TTSOPU(W) ;SKIP IF NOTHING NEEDS RESTARTING
JRST SETGOP
MOVN T2,TS1SCN(W) ;GET NEGATIVE SUBCHANNEL NUMBER
MOVEI T3,SI.GO ;GO FLAG FOR SUBCHANNEL ZERO
LSH T3,(T2) ;GET OUR GO FLAG
MOVEI T2,SO.GO ;BIT TO START THE SUBCHANNEL
TDNN T3,TS1LCI(W) ;SKIP IF GO FLAG WAS ON
PJRST STSCLR ;CLEAR STATUS FLAG AND EXIT INTERRUPT
PUSHJ P,TRK222 ;$ TRACK GO
PJRST CNOSET ;$ SET THE GO BIT AND EXIT
SUBTTL WRITE
;HERE ON DONE INTERUPT FOR WRITE
STIWT: PUSHJ P,CHKWLK ;CHECK FOR AND SET WLK
PUSHJ P,STCKMV ;DID IT MOVE
PJRST MOTERR ;IF NO MOTION, BRANCH TO SET ERRORS AND EXIT
AOS TUBREC(U) ;ONE MORE RECORD FORWARD
TLNE P4,(S.UC) ;SKIP IF NO OTHER ERRORS PRESENT
PUSHJ P,STEANL ;BRANCH TO ANALYZE ERRORS AND SETUP TRBSTS
PUSHJ P,CHRCT ;GET CHARACTER COUNT
JFCL ;DON'T CARE
ADDM T2,TUBCWR##(U) ;ADD TO STATS
ADDM T2,TKBCWR(W)
ADDM T2,.CPTFO##
PUSHJ P,CHKEOT ;CHECK FOR AND SET EOT
PJRST STIDON ;AND EXIT
;HERE ON DONE INTERUPT FOR WRITE TAPE MARK
STITM: PUSHJ P,CHKWLK ;CHECK FOR AND SET WLK
PUSHJ P,STCKMV ;SKIP IF TAPE REALLY MOVED
PJRST MOTERR ;BRANCH IF NO MOTION
SETZM TUBREC(U) ;ZEROTH RECORD
AOS TUBFIL(U) ;AND 1 MORE FILE
TLNE P4,(S.UC) ;SKIP IF NO "SERIOUS" ERROR
PUSHJ P,STEANL ;UPDATE TRBSTS
PUSHJ P,CHKEOT
PJRST STIDON ;EXIT
SUBTTL REWIND/REWIND-UNLOAD
;HERE ON INTERUPT AFTER STARTING UNLOAD OR REWIND
;FINAL STATUS IS SEEN BY AND HANDLED BY "ONLUNI", NOT HERE
STIRW:
STIUN: TLNN P4,(S.UC) ;SKIP IF WE HAD PROBLEMS
PJRST STIDON ;EXIT IF NO PROBLEMS, LET TAPUUO DISCARD IORB
SKIPN TS1SIP(U) ;SKIP IF WE HAVE SENSE DATA ALREADY (?)
PJRST ERRSNS ;BRANCH TO GET SENSE DATA
PUSHJ P,REWDON## ;FAKE DONE TO AVOID HANG (SNSANL MIGHT NOT)
PJRST STIDON ;AND THEN EXIT INTERRUPT
;HERE ON DONE INTERUPT FROM BACKSPACE RECORD
STIBR: PUSHJ P,FNDXCW ;FIND THE XCW COUNT
MOVNS T1 ;MAKE THE XCW COUNT -VE (CUZ BACKWARDS MOTION)
ADDB T1,TUBREC(U) ;UPDATE TUBREC
SKIPGE T1 ;SKIP IF STILL POSSIBLE
SETZB T1,TUBREC(U) ;OOPS
TLNE P4,(S.UE) ;SKIP IF UNIT-EXCEPTION IS OFF
PUSHJ P,LSTFIL ;IF U-E ON, WE BSB'D BACK OVER TAPE MARK
STIBR2: TLNN P3,(S01BOT) ;SKIP IF SENSE BYTES SAY WE'RE AT BOT
PUSHJ P,STEANL ;UPDATE TRBSTS
JRST STIDON ;EXIT INTERRUPT
;HERE ON DONE INTERRUPT FROM BACKSPACE FILE
STIBF: SKIPN TS1SIP(U) ;SKIP IF WE HAVE SENSE DATA
PUSHJ P,STISNS ;GO GET SENSE BYTES
TLNN P4,(S.UC) ;UNIT CHECK?
JRST STIBF2 ;NO
SKIPN TUBFIL(U) ;SHOULD BE AT BOT
SKIPE TUBREC(U) ;ARE WE?
JRST STIBF3 ;NO
MOVSI T2,RB.SNM!RB.SBT ;NO MOTION + BOT BIT
JRST STIBF4 ;FINISH UP
STIBF2: SOS TUBFIL(U) ;PREVIOUS
SETZM TUBREC(U) ;..
STIBF3: TLNN P3,(S01BOT) ;LOAD POINT?
JRST STIDON ;NO
MOVSI T2,RB.SBT ;BOT BIT
STIBF4: IORM T2,TRBSTS(P1) ;UPDATE IORB
PUSHJ P,UNIBOT## ;TELL TAPSER WE'RE AT THE LOAD POINT
JRST STIDON ;GO DISMISS INTERRUPT
SUBTTL SKIP RECORD/FILE/ERASE GAP
;HERE ON DONE INTERUPT FROM SKIP FORWARD RECORD
STISR: PUSHJ P,FNDXCW ;FIND XCW COUNT (IE: # OF RECORDS THAT WON)
ADDM T1,TUBREC(U) ;UPDATE TUBREC
TLNE P4,(S.UE) ;SKIP IF NOT A TAPE MARK ABORT
PUSHJ P,NXTFIL ;COUNT A FILE IF WE GOT IT
JRST STIDON ;EXIT FROM INTERRUPT
;HERE ON DONE INTERRUPT FROM SKIP FORWARD FILE
STISF: SKIPN TS1SIP(U) ;SKIP IF WE HAVE SENSE DATA
PUSHJ P,STISNS ;GO GET SENSE BYTES
TLNE P4,(S.UC) ;UNIT CHECK?
PJRST MOTERR ;YES, MUST BE A MOTION ERROR
PUSHJ P,NXTFIL ;COUNT ONE MORE FILE
JRST STIDON ;AND EXIT
;HERE ON DONE INTERUPT FROM ERASE GAP
STIEG: PUSHJ P,CHKWLK ;CHECK FOR WRITE-LOCK
PUSHJ P,STCKMV ;SKIP IF MOTION TOOK PLACE
JRST MOTERR ;BRANCH IF NO MOTION
PUSHJ P,CHKEOT ;CHECK FOR END-OF-TAPE
PJRST STIDON ;EXIT INT
;HERE FOR CHANNEL ERROR
STECHN: PUSHJ P,SAVE1## ;SAVE P1
HRRZ P1,KDBCHN(W) ;PTR TO CHANNEL DATA BLOCK
MOVEI T3,CHENXM## ;ASSUME NXM
TRNE T2,SI.PAR ;SKIP UNLESS MEMORY PARITY ERROR
MOVEI T3,CHEMPE## ;NO - PARITY ERROR
MOVEI T1,@TTSCSW(W) ;ADDR OF CSW
MOVE T1,1(T1) ;GET TERMINAL COUNT,ADDR WORD
PUSHJ P,0(T3) ;EXERCISE ROUTINE
MOVEI T2,SO.CME ;CLEAR MEMORY ERROR
PUSHJ P,CNOCLR ;DO IT
MOVEI T2,SO.SRS ;SELECTIVE RESET REQUIRED TO GET OUT OF THIS
PUSHJ P,CNOCLR ;DO IT
MOVE U,KDBCUN(W) ;GET CURRENT UNIT
MOVE U,(U) ;ADDR OF UDB
PUSHJ P,CHKIRB## ;GET IORB PTR
JRST TAPDIS## ;NO USE CONTINUING IF NO IORB
MOVE P1,T1 ;PUT IORB IN A SAFER PLACE
MOVSI T2,RB.SER!RB.SED
IORM T2,TRBSTS(P1) ;TELL HIM WORLD ENDED
PJRST STIDON ;RETURN - NO RETRIES
;ROUTINE TO DETERMINE IF TAPE MOVED (DIVINATION)
STCKMV: SKIPN TS1SIP(U) ;SKIP IF WE HAD AN ERROR
JRST CPOPJ1## ;MUST HAVE MOVED IF NO ERROR
TLNE P2,(S00REJ!S00IRQ) ;SKIP IF MOTION HAPPENED
POPJ P, ;RETURN ERROR IF NO MOTION
JRST CPOPJ1##
;HERE FOR MOTION ERROR
MOTERR: MOVSI T2,RB.SER!RB.SNM ;NOTE NO MOTION
IORM T2,TRBSTS(P1) ;STASH INTO IORB
PJRST STIDON ;TELL TAPSER
;ROUTINE TO ANALYSE THE GENERIC SENSE BYTE ERRORS
STEANL: MOVEI T2,0 ;SET INITIAL ZERO
TLNE P2,(S00IRQ) ;SKIP IF NOT INTERVENTION REQUIRED
PUSHJ P,STCOFL ;SET UNIT OFF-LINE
TLNE P2,(S00REJ!S00IRQ);SKIP IF NO MOTION
TLO T2,RB.SNM!RB.SED;SET NO MOTION
TLNE P2,(S00OVR)
TLO T2,RB.SED ;SOME ERROR DETECTED (IE: CHANNEL OVERRUN)
TLNE P2,(S00DCK)
TLO T2,RB.SDE!RB.SED ;DATA ERROR
IORM T2,TRBSTS(P1) ;SET SELECTED BITS
POPJ P, ;RETURN
LSTFIL: SOSA TUBFIL(U) ;ONE LESS FILE
NXTFIL: AOS TUBFIL(U) ;ONE MORE FILE
SETZM TUBREC(U) ;ASSUME AT ZEROTH RECORD
MOVSI T2,RB.STM ;"SAW TAPE MARK"
IORM T2,TRBSTS(P1) ;FLAG IN IORB
POPJ P,
CHKEOT: MOVSI T1,RB.SET ;"SAW END(OF)TAPE"
ANDCAM T1,TRBSTS(P1) ;START OFF WITH IT OFF FOR SURE
TLNE P4,(S.UE) ;GOT UNIT EXCEPTION ON A WRITE COMMAND
IORM T1,TRBSTS(P1) ;SO REMEMBER WE SAW THE TAPE MARK GO BY
POPJ P,
CHKWLK: MOVSI T1,RB.SLK ;BITS FOR ABORTED FOR WRITE-LOCK
TLNE P2,(S01WLK) ;SKIP IF RING-PRESENT
TLNN P2,(S00REJ) ;SKIP IF NOT REJECTED
SKIPA
IORM T1,TRBSTS(P1) ;REJECTED, AND RING-NOT-PRESENT
POPJ P,
SUBTTL COMPUTE CHARACTER COUNTS
;ROUTINE COMPUTES CHARACTER COUNT
;RETURNS COUNT IN T2 , T1 SAVED
CHRCT: PUSHJ P,WRDCTS ;GET WORD COUNT
SKIPA ;LENGTH ERROR RETURN
AOS (P) ;SET FOR SKIP RETURN
MOVE T2,T1 ;WORD COUNT INTO T2
SETZ T4,
CHRCT1: DPB T4,PMTNCR## ;NOTE NO RESIDUE FOR MTCHR.
HRLM T2,TUBCHR##(U) ;STORE LAST WORD COUNT FOR MTCHR.
MOVE T1,P1 ;GET IORB FOR PRBMOD
LDB T1,PRBMOD## ;GET MODE
IMUL T2,TMODTB##(T1) ;WORDS TIMES CHARS PER WORD
DPB T4,PMTCRC## ;STORE ZERO FOR CRC FOR MTCHR.
POPJ P, ;RETURN
;ROUTINE TO COMPUTE NUMBER OF WORDS TRANSFERRED ON READ OPERATIONS
;RETURNS WORD COUNT IN T1
;CALLED WITH P1 := IORB
WRDCTS: SETZ T1, ;ACCUMULATE COUNT IN T1
MOVE T3,TTSMIO(W) ;GET 1ST DCW ADDRESS FROM MAPIO
LDB T4,[POINT DCSADR,TTSTCA(W),DCNADR] ;GET TERMINATION ADDRESS
; (THIS IS EITHER THE ADDRESS OF LAST
; DCW EXECUTED +1, OR, +2 IF FINISHED
; LIST AND LAST WORD)
WRD.1: LDB T2,[POINT DCSSIZ,(T3),DCNSIZ] ;LOAD NEGATIVE COUNT IN THIS DCW
ORCMI T2,<1_DCSSIZ>-1 ;CONVERT TO A TRUE NEGATIVE
SUB T1,T2 ;ACCUMULATE BY SUBTRACTION TO FORM
;A POSITIVE COUNT
SKIPL (T3) ;TEST FOR END OF LIST BY LOOKING, FIRST,
CAIL T3,-1(T4) ;AT HIGH-ORDER BIT OF DCW; THEN, BY
;COMPARING WITH TERMINATION ADDRESS
JRST WRD.2 ;END, T3 POINTS TO LAST DCW EXECUTED
AOJA T3,WRD.1 ;NOT END, LOOP FOR NEXT DCW
WRD.2: LDB T2,[POINT DCSSIZ,TTSTCA(W),DCNSIZ] ;ADJUST COUNT BY TERMINATION
JUMPE T2,WRD.3 ;COUNT (RESIDUAL COUNT) IF IT IS NONZERO
ORCMI T2,<1_DCSSIZ>-1 ;MAKE INTO A TRUE NEGATIVE
ADD T1,T2 ;BEFORE SUBTRACTING
WRD.3: PUSH P,T1 ;SAVE COUNT ON STACK
PUSHJ P,CHKMOD ;IF NOT WORD MODE,
TDZA T4,T4 ;CONVERT BYTE COUNT TO WORD COUNT
SETO T4, ;WORD MODE
POP P,T1 ;RESTORE WORD COUNT
JUMPN T4,WRD.4 ;JUMP IF WORD MODE
ADDI T1,3 ;BYTE MODE,
LSH T1,-2 ;CONVERT
WRD.4: SKIPGE (T3) ;TEST FOR LENGTH ERROR IF
SKIPE T2 ;FINISHED DATA CHAIN LIST INCLUDING LAST WORD
JRST CPOPJ1## ;DIDN'T FINISH LIST, RETURN
TLNN P4,(S.LE) ;TEST FOR LENGTH ERROR
AOS (P) ;NO LENGTH ERROR, SKIP RETURN
POPJ P, ;RETURN
WTCUEP: POP P,(P) ;WASTE RETURN
WTCUE: SETZM TTSOPU(W) ;UNIT NOT BUSY ANYMORE (YET)
TLNE T1,(S.CUE+S.DE) ;SKIP UNLESS NOT REALLY BUSY ANY MORE
JRST SETGOP ;START PROGRAM AND DISMISS INTERRUPT
LDB T2,CSYDVA ;GET UNIT ADDRESS FROM STATUS
SUBI T2,@TTSOFS(W) ;COMPUTE UNIT NUMBER
PUSHJ P,SETUDB## ;PICK UP U
SETZ U, ;HM - COUNT BE NXM UNIT FROM POLLER
SKIPN TS1PPC(W) ;SKIP IF WE HAVE A PROGRAM TO RESTART
JRST NXTWAT ;ULP - JUST TRY TO IGNORE IT
HRROM U,TTSOPU(W) ;REMEMBER UNIT THAT GOT BUSY
MOVEI T2,^D25 ;WAIT FOR 25 SECONDS (LESS THAN HUNG TIMER)
MOVEM T2,TTSBCT(W) ;WHEN TIMER EXPIRES, RETRY EVEN IF NO CUE
MOVSI T2,1 ;COUNT BUSYS IN LH
ADDM T2,TTSBRC(W) ;COUNT BUSYS
PJRST NXTWAT ;EXIT INT QUICKLY FOR NOW
GOTCUE: TLNE T1,(S.UC+S.DE+S.UE) ;SKIP UNLESS SOMETHING MORE IMPORTANT
POPJ P, ;JUST RETURN IF SOMETHING MORE IMPORTANT
SKIPE TTSOPU(W) ;SKIP IF NO UNIT KNOWN TO BE BUSY
SKIPN TS1PPC(W) ;SKIP IF KNOWN UNIT WITH KNOWN PROGRAM
JRST WTCUEP ;ODD, BUT PRETEND IT IS A BUSY
PUSHJ P,SAVT## ;SAVE THE ACS
HRRZ U,TTSOPU(W) ;GET THE U WHICH IS PENDED
SETZM TTSOPU(W) ;NO MORE U
SETZM TTSBCT(W) ;NO MORE TIMER
PUSHJ P,SETDVP ;SETUP DEVL ENTRY, ETC
MOVEI T2,SO.GO ;GET GO BIT
PUSHJ P,CNOSET ;SET GO BIT
PUSHJ P,TRK222 ;$ TRACK GO BIT
POPJ P, ;RETURN TO HANDLE REAL INTERRUPT
SETDVP: MAP T2,@TS1PPC(W) ;GET PC
MOVE T1,TS1SUN(W) ;ASSUME POLLER'S UNIT
SKIPE U ;SKIP IF AN UNKNOWN UNIT (IE: POLLER'S UNIT)
MOVE T1,UDBPDN(U) ;GET DRIVE NUMBER FROM UDB IF KNOWN UNIT
ADD T1,TTSOFS(W) ;COMPUTE ADDRESS OF UNIT
DPB T1,[POINT SASDLD,T2,SANDLD] ;INSERT UNIT ADDRESS INTO DEVL ENTRY
MOVEI T1,DL.STA ;GET "START" CODE
DPB T1,[POINT SASDLO,T2,SANDLO] ;INSERT OPCODE INTO DEVL ENTRY
PMOVEM T2,TS1DVP(W) ;INSERT DEVL ENTRY INTO PROPER SLOT
POPJ P, ;RETURN
;ROUTINE TO POSSIBLY CALL ERRSNS IF WE'RE AT INTERRUPT LEVEL
; ON A FORWARD MOTION AT RECORD 0
STISNS: SKIPN TUBFIL(U) ;SKIP IF NOT FILE 0
SKIPE TUBREC(U) ;SKIP IF BOTH FILE 0 AND RECORD 0
POPJ P, ;RETURN
POP P,(P) ;WASTE THE RETURN AS SNSANL WILL DO IT
; JRST ERRSNS ;ARRANGE A SENSE-DATA-CALLBACK FOR OUR CALLER
;ROUTINE TO DO SENSE COMMAND AT INTERRUPT LEVEL
ERRSNS: MOVE T1,TS1LCI(W) ;GET THE CONI
MOVE T2,TS1LST(W) ;GET THE CSW WORD
DMOVEM T1,TS1SIP(U) ;REMEMBER A SENSE IN PROGRESS
PUSHJ P,SETSNS ;SETUP FOR SENSE OPERATION
PJRST SETGOP ;START THE SENSE COMMAND
;ROUTINE TO SET UP FOR SENSE OPERATION
SETSNS: MOVE T2,UDBPDN(U) ;GET PHYSICAL DRIVE NUMBER
ADDI T2,@TTSOFS(W) ;COMPUTE ACTUAL DEVICE ADDRESS
DPB T2,[POINT DVSDVA,TS1SNS+SNSDVW(W),DVNDVA] ;UPDATE SENSE
MAP T1,TS1SND(U) ;GET PHYSICAL ADDRESS OF SENSE BYTES
DPB T1,[POINT DCSADR,TS1SNS+SNSDCW(W),DCNADR] ;UPDATE IOWD
MOVEI T2,TS1SNS+SNSDVW(W) ;GET VIRTUAL ADDRESS OF SENSE PROGRAM
MOVEM T2,TS1PPC(W) ;SAVE PC WE WANT TO RUN
SETZM TS1SND(U) ;INVALIDATE OLD SENSE
POPJ P,
;SUBROUTINE TO DECIDE IF CURRENT MODE IS BYTE MODE OR WORD MODE
;ARGS P1 := IORB
CHKMOD: MOVE T1,P1 ;GET IORB ADDRESS
LDB T1,PRBMOD## ;GET CURRENT MODE
CAIN T1,RB.MBY ;SKIP UNLESS INDUSTRY COMPATIBLE 9-TRACK
POPJ P, ;BYTE MODE
MOVEI T1,TUC7TK## ;7-TRACK BIT
TDNN T1,TUBCNF##(U) ;SKIP IF 7-TRACK DRIVE
JRST CPOPJ1## ;9-TRACK WORD MODE
MOVE T1,TRBFNC(P1) ;GET PARITY BIT
TLNN T1,RB.PAR ;SKIP IF EVEN PARITY
AOS (P) ;7-TRACK ODD PARITY IS WORD MODE
POPJ P, ;7-TRACK EVEN PARITY IS BYTE MODE
SUBTTL SA10 FUNCTIONS
;SUBROUTINE TO CLEAR STATUS FLAG
STSCLR: CONSO PI,PI.IPA-PI.IP7;SKIP IF ANY REAL INTERRUPT IN PROGRESS
POPJ P, ;RETURN IF AT UUO LEVEL
MOVEI T2,SO.STS ;STATUS FLAG
PJRST CNOCLR ;CLEAR IT
;SUBROUTINES TO SET OR CLEAR SA10 FLAGS
; T2=SA10 FUNCTION
CNOSET: TRO T2,SO.SET ;SET THE FLAG
CNOCLR: PUSH P,T1 ;SAVE T1
HLRZ T1,TS1SCN(W) ;GET SUBCHANNEL IN CONO POSITION
IOR T1,T2 ;COMBINE THEM
IORI T1,TAPCHN## ;INCLUDE PI
PUSHJ P,TRK444 ;$ DO A CONO RECORD
XCT KDBCNO(W) ;CONO SA10,(T1)
JRST TPOPJ## ;RESTORE T1 AND RETURN
SUBTTL END
$LIT
TS1END::!END