IMD 1.16: 2/09/2008 14:42:59 84-93738-01 b000 f73801 scout winchester interface test program source disk 22nov82    @0|)wwЀЀtQql)  " }gA `_l M@IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIOS4 MF282090918493100820909184931 820909184931@CF73801 VOLSCOUT WINCHESTER INTERFACE TEST PROGRAM - SOURCE DISK   IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII_l M@iGyy GGG`HZ@ b G`^Y e IQ BBp@;:9 :7P@ G:پN 8!0. * C'xC# b# }B!9 @0DAJL w+™ЀЀΖQA1"   i ž} š} @EEFF)DEۄF8 џ} ԟ} ̟} * `jUBBI,v BI, # @ G9H@pܾrCHC C GTq` Lg"gEXC P+s=胾P+c fQN p $Rxnj  ޔniZ ތ⊞ } }HGž Ÿ@ALS)"$ C k20j.h( +$`%ꂜ\1 !M' y %'+os慾)sY ed|{ @8 o O m J K i gN )V% t%sLn`"E F. F„ D>) =`;nrgy w"G,{Kq1 A&}E*`(t@% ;c  765y342(.OS:: SYS"iwvc Bc A@6<# Ic B# gIjHc r TITL SCOUT WINCHESTER DISK TEST PROGRAM 93738-10B000 TITL TITLE PAGE * * * * SCOUT WINCHESTER DISK * * *  DIAGNOSTIC/FORMATTER * * * 84-93738-10B000 * * * * * COPYRIGHT 1982 COMPUTER AUTOMATION INC. * * TITL REVISION HISTORY ****************************** * * REVISION HISTORY * ****************************** * * REVISION  ISSUE DATE COMMENTS * -------- ----------- -------- * * A000 AUGUST 1982 ORIGINAL RELEASE * BY KENNETH T SPOOR * * B000  NOV. 1982 UPDATED TO INCLUDE * BAD TRKS FROM THE MFR. *  SEE QUERYP0, QUERYQ0, * QUERYR0, & FMCHK. *  MARK HAYES. * REV: EQU 'B0' LATEST REVISION TITL LINKER INFORMATION * EXTR DEBUG4 LINK TO DEBUG NAM G:0 LINK ADDRESS * OBJNOTE ' SWI TEST PROG. - REV. ',REV:%-8,REV:&:FF * * OPTIONS -:1000 NO XADDRESSING TITL DIAGNOSTIC/FORMATTER INFORMATION ****************************** * * DIAGNOSTIC/FORMATTER INFORMATION * *********************** ******* * * * CONSISTS OF: * * FORMATTER (FORMATS IN STANDARD CAI FORMAT) ** * DIAGNOSTIC: * TEST A - BASIC STATUS, TIO, INTERRUPTS TEST * TEST B - SEEK TEST * TEST C - FORMAT TEST * TEST D - SHORT WORD TRANSFER TEST * TEST E - RANDOM WRITE/VERIFY READ TEST * TEST F - INITIALIZE TEST * TEST G - FORCED ERRORS TEST * TEST H - TIO/SEEK/UPDATE TEST + * - HIGH MEMORY TEST + * - INTERRUPT LEVELS TEST * TEST I - FULL WORD TRANSFER TEST ** * TECH TEST (SCOPING LOOPS) ** * OPTIONS: * * BIT HEX * * 0 :01 INCLUDE BUFFER DUMP IN ERROR REPORTS *  WHERE APPLICABLE * * 1 :02 SUPPRESS ERROR REPORTS * * 2 :04 OUTPUT ERROR TALLIES AT END OF *  EACH TEST * * 3 :08 RUN CONTINUOUSLY * * 4 :10 HALT ON HARD ERROR * * 5 :20 OUTPUT ALL TEST AND ERROR MESSAGES * ON THE LINE PRINTER. * ** * SENSE SWITCH: * * SET - SUPPRESS OUTPUT OF PASS NUMBER, * UNIT NUMBER AND TEST TITLES * ****************************** TITL EQUATES ****************************** * * EQUATES * ****************************** * * IOB EQUATES * OP EQU 0 0P CODE, CIOB. US EQU 1  UNIT SELECT, CIOB. CS EQU 2 CYLINDER SELECT. HS EQU 3 HEAD SELECT. SSS EQU 4  SECTOR SELECT WC EQU 5 WORD COUNT AND SKIP OP. MA EQU 6 MEMORY ADDRESS. IN EQU 7 INTERRUPT ADDRESS/ENABLE. NB EQU 8 NEXT IOB ADDRESS. XF EQU 9 WORDS TRANSFERRED CST EQU 10  PME STATUS DST EQU 11 DRIVE STATUS * * OP CODES EQUATES * TIO EQU :0000 TEST I/O FRMT EQU :0001 FORMAT WRTDAT EQU :0002 WRITE WORD. RDDAT EQU :0004 READ WORD. DRVPAR EQU :0007 SPECIFY DRIVE PARAMETER RDVER EQU :0008 READ VERIFY. SEEK EQU :0009 SEEK ONLY. UPDATE EQU :0080 UPDATE DISK ADDRESS * *  TRAP/EXCEPTION CONSOLE INT. DISPLAYS * ER3100 EQU :3100 UNIMPLEMENTED INSTRUCTION TRAP ER3300 EQU :3300 UNINSTALLED MEMORY TRAP ER3500 EQU :3500 POWER FAIL ER3900 EQU :3900 STACK OVERFLOW TRAP ER3B00 EQU :3B00 USER TRAP ER3D00 EQU :3D00 SYSTEM TRAP ER3F00 EQU :3F00 ARITHMETIC TRAP ER3600 EQU :3600 LINEPRINTER TIME-OUT * * PROGRAM EQUATES * CONSL EQU :00 CONSOLE DEVICE ADDRESS DTTYDA EQU :7C DIO CRT/TTY DEVICE ADDRESS DLPDA EQU :7F DIO LP DEVICE ADDRESS MCSLPDA EQU :40 MULTI CHANNEL DEVICE ADDRESS * * CONSOLE FUNCTIONS * SENSE EQU :00 CONSOLE SENSE SWITCH FUNCTION CODE INT EQU :01 CONSOLE INT. LIGHT FUNCTION CODE CDR EQU :04 CONSOLE DATA REG. FUNCTION CODE * * PSW BIT EQUATES * CY: EQU 0 CARRY BIT OV: EQU 1 OVERFLOW BIT BY: EQU 2 BYTE MODE BIT CI: EQU 4 CONSOLE INTERRUPT ENABLE BIT RC: EQU 5 REAL-TIME CLOCK ENABLE BIT XA: EQU 6 EXTENDED ADD. ENABLE BIT GI: EQU 8 GLOBAL INT. ENABLE BIT EI: EQU 12 EOB INT. BIT DI: EQU 13 DATA INT. BIT * * * * * GENERAL EQUATES * SMDA EQU :15 STD DEVICE ADDRESS BADBUFSZ EQU :1F BUFFER FOR MFR'S BAD TRKS DTTYDA EQU :7C DIO TTY DEVICE ADDRESS (SHIFTED RIGHT) PAT EQU :6DB6  DEFAULT PATTERN TSTCEPAT EQU :B66D TEST C AND E DEFAULT PATTERN MEMINC EQU :400 1K MEMORY INCREMENT LF: EQU 10 ASCII  LINE FEED CR: EQU 13 ASCII CARRIAGE RETURN CRLF: EQU :0D0A ASCII CARRIAGE RETURN/LINE FEED BCKAR: EQU :5F ASCII BACK ARROW UPARR: EQU :5E ASCII UP ARROW SPACE: EQU :20 ASCII SPACE UNITS EQU 2 MAXIMUM NUMBER OF UNITS UNDER TEST TITL STANDARD NM-4 TRAP/EXCEPTION LOCATIONS ****************************** * * STANDARD NM-4 TRAP/EXCEPTION LOCATIONS * * CONSOLE INTERRUPT AND * REAL-TIME-CLOCK INTERRUPT LOCATIONS * ****************************** * ABS 0 DEBUG JUMP DEBUG JST *$+1 JUMP TO DEBUG WORD DEBUG4 DEBUG ADDRESS * ABS :80 POWER UP TRAP PWRUP JST *$+1 JUMP TO POWER UP ROUTINE WORD PWRUP: ADDRESS OF ROUTINE * ABS :84 UNIMPLEMENTED INSTRUCTION TRAP UNINT RES 2,0 ADDRESS AND INSTRUCTION JST *$+1 JUMP TO SERVICE ROUTINE WORD UNINT: ADDRESS OF ROUTINE * UNMET RES 2,0 UNINSTALLED MEMORY TRAP JST *$+1 JUMP TO SERVICE ROUTINE WORD UNMET: ADDRESS OF ROUTINE * PWRFL RES 2,0 POWER FAIL JST *$+1 JUMP TO SERVICE ROUTINE WORD PWRFL: ADDRESS OF ROUTINE * ABS :91 REAL-TIME-CLOCK RTCCNT RES 1,0 RTC TICKS JST *$+1 JUMP TO SERVICE ROUTINE RTCRTN RES 1,0 ADDRESS OF SERVICE ROUTINE * CNINT JST *$+1 CONSOLE INTERRUPT LOCATION WORD CNINT: ADDRESS OF SERVICE ROUTINE * ABS :9C * STKOV RES 2,0 STACK OVERFLOW JST *$+1 JUMP TO SERVICE ROUTINE WORD STKOV: ADDRESS OF ROUTINE * USETR RES 2,0 USER TRAP JST *$+1 JUMP TO SERVICE ROUTINE WORD USETR: ADDRESS OF ROUTINE * SYSTR RES 2,0 SYSTEM TRAP JST *$+1 JUMP TO SERVICE ROUTINE WORD SYSTR: ADDRESS OF ROUTINE * ARIER RES 2,0 ARITHMETIC ERROR JST *$+1 JUMP TO SERVICE ROUTINE WORD ARIER: ADDRESS OF ROUTINE * TITL PROGRAM STARTUP ****************************** * * PROGRAM START UP * * :200 STANDARD ENTRY POINT * * RESET STATUS REG. * RESET SENSE SWITCH * RESET CONSOLE INT. * RESET CDR DISPLAY *  INITIALIZE WINCHESTER CONTROLLER * PRINT TITLE * ENABLE CONSOLE INTERRUPT * * CALLS: * SEL *  MSGA * ****************************** * ABS :200 * SMD EQU $ PROGRAM START G:0 EQU $ DEBUG LINK ENT EQU $ THIS IS WERE IT ALL BEGINS * COPY =-PRMSIZ,A SIZE OF PARAMETER TABLE JST MOVE RESET WORKING TABLE WORD PRAMSX WORD PRAMS ENT1A COPY =-BADBUFSZ,A GET BUFFER SIZE JST MOVE INIT MFR BAD TRK BUFFER WORD BUFCLR MOVE FROM WORD BADBUF MOVE TO COPY =:FFFF,A LOGICAL-END FLAG COPY A,BADBUF STORE IT COPY =0,A SET A TO ZERO COPY A,S RESET STATUS REG. OUT A,0 RESET SENSE SWITCH OUT A,1 RESET CONSOLE INT. SELP A,4 RESET CDR DISPLAY COPY =-5,A JST MOVE WORD PASCTX WORD PASCTR * IN DTTYDA%1;1,A GET DIO STATUS IF THERE IS ONE COPY =0,X JNE A,NO:MCS JMP IF THERE IS A DIO THERE ADD =1,X SET MULTI CHANNEL FLAG COPY X,MCSFLG GET THE FLAG JST SETRDY SET UP THE MULTI-CHANNEL * NO:MCS EQU $ JST MSGA PRINT TITLE WORD TITLE TITLE ADDRESS SBIT 4,S ENABLE CONSOLE INT. SBIT 8,S ENABLE INTS. TITL QUERIES (DRIVE SELECTION) ***************************** * * DRIVE SELECTION * * QUERY: * *  DRIVE PARAMETER SWITCH SETTING (0)? * * SELECTION: * 0 - ST406, CM5606, MS2006 * 1 - ST412, MS2012, CM5612 * 2 - ST419, CM5619 * 3 - R0204 * 4 - RMS518 * 5 - RESERVED *  6 - RESERVED * 7 - RESERVED * 8 - DEFINE DISK PARAMETERS * * DEFAULT IS '0' *  * CALLS: * MOVE * MSGA * IDEC * CHRIN * ***************************** * QUERY10 EQU $ COPY =0,A SET A TO ZERO COPY A,NONSTND CLEAR NON-STANDARD FLAG COPY A,TEMP2 RESET INPUT FLAG JST MSGA OUTPUT QUERY WORD QUERYM10 JST IDEC GET INPUT JEQ X,$+2 IF ZERO, CHECK TERMINATOR IMS TEMP2 SET INPUT FLAG JST CHRIN CHECK TERMINATOR JMP QUERY12 CR JMP QUERY11 # JMP QUERY10 BACK ARROW JMP QUERY10 UP ARROW JMP QUERY10 COMMA JMP QUERY10 ANYTHING ELSE QUERY11 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY10 ILLEGAL IF THERE IS AN INPUT JMP QUERND DEFAULT QUERY12 COPY A,TEMP3 COPY X,TEMP4 COPY =-PRMSIZ,A  JST MOVE WORD PRAMSX WORD PRAMS COPY TEMP3,A COPY TEMP4,X CSK X,=8 CHECK SELECTION JMP $+3 IF LESS THAN, A OK JMP QUERY10 IF MORE THAN, ERROR IMS NONSTND SET DISK PARAMETER FLAG ADD =DRTBL,X ADD IN TABLE OFFSET COPY 0(X),X GET ADDRESS OF PARAMETER TABLE COPY X,QUERY13 STORE FOR MOVE COPY X,DISK SET DRIVE PARAMETER TABLE ADDRESS COPY =HCP-EHCP,A PARAMETER TABLE SIZE -(EHCP-HCP) JST MOVE SET NEW DISK PARAMETERS QUERY13 WORD 0 WORD HCP TITL QUERIES (FUNCTION SELECTION) ***************************** * * FUNCTION SELECTION * * QUERY: * * DIAG, FMATTER, OR TECH TEST (D,F,T)? * * SELECTION: *  D - SELECTS DIAGNOSTIC FUNCTION * F - SELECTS FORMATTER FUNCTION * T - SELECTS TECH TEST * DEFAULT IS 'D' * * CALLS: * MSGA * IDEC * CHRIN * IKB * ***************************** * QUERY20 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY MODEX,A SET FUNCTION TO DEFAULT COPY A,MODE JST MSGA OUTPUT QUERY WORD QUERYM20 JST IDEC GET RESPONSE JNE X,QUERY20 NUMERIC RESPONSE IS INCORRECT COPY IDCTM3,A GET INPUT COUNT JNE A,QUERY20 A ZERO IS INCORRECT QUERY21 JST CHRIN CHECK TERMINATOR JMP QUERY30 CR JMP QUERY23 # JMP QUERY20 BACK ARROW JMP QUERY24 UP ARROW JMP QUERY20 COMMA CLSN ='F',A FORMATTER? JMP QUERY22 YES, STORE IT CLSN ='D',A DIAGNOSTIC? JMP QUERY22 YES, STORE IT CLSN ='T',A TECH TEST? JMP QUERY22 YES, STORE IT JMP QUERY20 ANYTHING ELSE IS WRONG QUERY22 COPY A,MODE SET FUNCTION IMS TEMP2 SET INPUT FLAG JST IKB GET TERMINATOR COPY A,IDCTM2 STORE TERMINATOR JMP QUERY21 CHECK TERMINATOR QUERY23 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY20 CAN'T DO JMP QUERND CAN DO QUERY24 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY20 CAN'T DO JMP QUERY10 CAN DO * LPOOL TITL QUERIES (DEVICE ADDRESS) ***************************** * * DEVICE ADDRESS * * QUERY: * * DEV AD (:15)?: * * SELECTION: * :01 TO :1F * DEFAULT IS ':15' * * CALLS: * MSGA * IHEX *  CHRIN * ***************************** * QUERY30 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY DEVADX,A SET DEVICE ADDRESS TO DEFAULT COPY A,DEVAD JST MSGA OUTPUT QUERY WORD QUERYM30 JST IHEX GET RESPONSE JEQ X,QUERY32 IF ZERO, SEE WHY IMS TEMP2 SET INPUT FLAG CSK X,=:1F DO RANGE CHECK JMP $+2 MUST BE 1-:1F JMP QUERY30 BAD INPUT COPY X,DEVAD STORE INPUT QUERY31 JST CHRIN CHECK TERMINATOR JMP QUERYF0 CR JMP QUERY33 # JMP QUERY30 BACK ARROW JMP QUERY34 UP ARROW JMP QUERY30 COMMA JMP QUERY30 ANYTHING ELSE IS ILLEGAL QUERY32 COPY IDCTM3,A GET INPUT COUNT JEQ A,QUERY31 IF ZERO, DEFAULT JMP QUERY30  ELSE, INPUT = 0 (ERROR) QUERY33 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY30 IF INPUT THEN IT IS ILLEGAL JMP QUERND QUERY34 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY30 IF INPUT THEN IT IS ILLEGAL JMP QUERY20 OTHERWISE, JUMP * LPOOL TITL QUERIES (TEST NUMBERS) ****************************** * * TEST NUMBERS * * QUERY: * * TSTS (A-H)? * * SELECTION: * A - SELECTS TEST A * B - SELECTS TEST B * C - SELECTS TEST C * D - SELECTS TEST D * E - SELECTS TEST E * F - SELECTS TEST F * G - SELECTS TEST G * H - SELECTS TEST H * I - SELECTS TEST I * DEFAULT IS A,B,D,E,F,H * * CALLS: * MOVE * MSGA * IDEC * CHRIN * ****************************** * QUERY40 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY MODE,A GET FUNCTION CLSN ='D',A DIAGNOSTIC? JMP $+2 IF SO, CONTINUE JMP QUERY50 OTHERWISE, SKIP TO NEXT QUERY COPY =-TSTSIZ,A RESET TEST SELECTION JST MOVE TO DEFAULT VALUES WORD TESTSX WORD TESTS JST MSGA OUTPUT QUERY WORD QUERYM40 COPY =-TSTSIZ+1,A RESET COUNT OF INPUTS -(TSTSIZ-1) COPY A,TEMP1 QUERY41 JST IDEC GET AN INPUT JNE X,QUERY40 DECIMAL INPUT IS AN ERROR JST CHRIN CHECK TERMINATOR JMP QUERYS0 CR JMP QUERY42 # JMP QUERY40 BACK ARROW JMP QUERY43 UP ARROW JMP QUERY41 COMMA SUB ='A',A SEE IF INPUT IS JLT A,QUERY40 BETWEEN A AND I INCLUSIVE CSK A,=TSTSIZ-2 J - Z? JMP $+2 IF NOT, CONTINUE JMP QUERY40 IF SO, ERROR IMS TEMP2 SET INPUT FLAG ADD =TSTABL,A ADD IN TEST ADDRESS OFFSET COPY A,X COPY 0(X),X X = ADDRESS OF TEST COPY TEMP1,A ADD =TESTS+TSTSIZ-1,A A = TABLE ENTRY ADDRESS EXCH A,X COPY A,0(X) STORE TEST ADDRESS IN TABLE COPY =-1,A SET TERMINATOR IN A COPY A,1(X) STORE TERMINATOR IN TABLE IMS TEMP1 BUMP INPUT COUNT JMP QUERY41 GO FOR MORE JMP QUERY40 TOO MANY, ERROR QUERY42 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY40 IF INPUT, THEN IT IS ILLEGAL TO DEFAULT JMP QUERND OTHERWISE, JUMP QUERY43 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY40 IF INPUT, THEN IT IS ILLEGAL TO JUMP BACK JMP QUERYJ0 OTHERWISE, JUMP * LPOOL TITL QUERIES (NUMBER OF USER CYLINDERS) ****************************** * * NUMBER OF USER CYLINDERS * * QUERY: * * USER CYLS? * * SELECTION: *  TOTAL NUMBER OF CYLINDERS, * STARTING CYLINDER NUMBER, - MUST BE < TOTAL NO. OF CYLS. * ENDING CYLINDER NUMBER - MUST BE > START. CYL. NO. AND * MUST BE < TOTAL NO. OF CYLS. *  DEFAULT IS THE SELECTED DRIVE PARAMETERS * * CALLS: * MOVE * MSGA * IDEC * CHRIN * ****************************** * QUERY50 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY SHORTX,A SET SHORT TEST FLAG TO COPY A,SHORT DEFAULT VALUE COPY DISK,X GET PARAMETER TABLE ADDRESS COPY CYLS-HCP(X),A GET DEFAULT PARAMETER FOR USER CYLINDERS COPY A,CYLS SET DEFAULT PARAMETER FOR USER CYLINDERS JST MSGA OUTPUT QUERY WORD QUERYM50 JST IDEC GET INPUT JEQ X,QUERY53 TERMINATOR OR ZERO INPUT IMS TEMP2 SET INPUT FLAG COPY X,A CSK A,CYLMX MUST BE LESS THXN MAX CYLINDER JMP $+3 OK NOP JMP QUERY50 WRONG MUST BE LESS THAN MAX CYLINDER COPY X,CYLS STORE INPUT COPY =0,A STORE 0 IN STARTING CYL. COPY A,SCYL TENTATIV ELY SUB =1,X SET TOTAL-1 IN ENDING CYL. COPY X,ECYL TENTATIVELY COPY IDCTM2,A GET TERMINATOR CHAR. CLSN =',',A WAS IT A COMMA? JMP QUERY54 IF SO, GET STARTING CYL. NO. QUERY52 JST CHRIN CHECK TERMINATOR JMP QUERYK0 CR JMP QUERY57 # JMP QUERY50 BACK ARROW JMP QUERY55 UP ARROW JMP QUERY50 COMMA JMP QUERY50 ANYTHING ELSE IS ILLEGAL QUERY53 COPY IDCTM3,A GET ACTUAL INPUT COUNT JEQ A,QUERY52 IF ZERO, CHECK TERMINATOR JMP QUERY50 OTHERWISE, ERROR QUERY54 IMS SHORT BUMP SHORT TEST FLAG JST IDEC GET STARTING CYL. NO. COPY X,A CSK A,ECYL DO RANG CHECK JMP $+2 MUST BE 0 - (TOTAL CYLS.-1) JMP QUERY50 OUT OF RANGE COPY A,SCYL STORE STARTING CYLINDER NO. COPY A,ECYL ASSUME IT'S ALSO ENDING CYL. NO. COPY IDCTM2,A GET TERMINATOR CLSN =',',A IS IT A COMMA? JMP QUERY56 YES, GET ENDING CYL. NO. JMP QUERY52 NO, CHECK FOR TERMINATOR QUERY55 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY50 ILLEGAL TO JUMP BACK IF INPUT COPY NONSTND,A JNE A,$+2 JUMP IF NON-STANDARD PARAM. JMP QUERYF0 IF ENTERING STANDARD PARA. THEN GOTO SCOUT BRD ID JMP QUERYG0 OTHERWISE, ASK FOR PRECOMP Y/N QUERY56 JST IDEC GET ENDING CYL. NO. COPY X,A CSK A,CYLS MUST BE LESS THAN TOTAL CYLS. JMP $+3 IF SO, CONTINUE NOP NOP NOP NOP NOP NOP NOP NOP NOP JMP QUERY50 OTHERWISE, ERROR CSK A,SCYL MUST BE GREATER THAN STARTING CYL. NO. JMP QUERY50 IF NOT, ERROR NOP COPY X,ECYL STORE ENDING CYL. NO. JMP QUERY52 CHECK TERMINATOR QUERY57 COPY TEMP2,A GET INPUT FLAG JEQ A,$+2 OK TO DO SO JMP QUERY50 ILLEGAL TO DEFAULT IF INPUT JMP QUERND * LPOOL TITL QUERIES (WRITE PRE COMP) ****************************** * * WRITE PRE COMPENSATION * * QUERY: * * WRITE PRE COMP CYL? * * SELECTION: * STARTING CYLINDER FOR WRITE PRE- * COMPENSATION - MUST BE > START. CYL. NO. AND * MUST BE < END. CYL. NO. * DEFAULT IS THE SELECTED DRIVE PARAMETERS * * CALLS: * MSGA * IDEC * CHRIN * ****************************** * QUERY60 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY PCMPEN,A SEE IF WANTED JNE A,$+4 JUMP IF WANTED COPY =0,A COPY A,PCMP JMP QUERYL0 COPY DISK,X COPY PCMP-HCP(X),A COPY A,PCMP JST MSGA OUTPUT QUERY WORD QUERYM60 JST IDEC GET RESPONSE JEQ X,QUERY64 IF ZERO, SEE WHY QUERY60A EQU $ IMS TEMP2 SET INPUT FLAG COPY X,A CSK A,SCYL MUST BE BETWEEN SCYL AND ECYL JMP QUERY60 MUST BE GREATER THAN SCYL NOP CSK A,ECYL MUST BE LESS THAN ECYL JMP $+2 JMP QUERY60 ERROR IF GREATER COPY A,PCMP STORE WRITE PRE COMP CYL QUERY61 JST CHRIN CHECK TERMINATOR JMP QUERYL0 CR JMP QUERY62 # JMP QUERY60 BACK ARROW JMP QUERY63 UP ARROW JMP QUERY60 COMMA JMP QUERY60 ANYTHING ELSE IS BAD QUERY62 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY60 CAN'T IF INPUT JMP QUERND DEFAULT QUERY63 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY60 CAN'T IF INPUT JMP QUERYK0 GO BACK QUERY64 COPY IDCTM3,A GET INPUT COUNT JEQ A,QUERY61 CHECK TERMINATOR JMP QUERY60A * LPOOL TITL QUERIES (SHORT TEST-CYLINDERS) ****************************** * *  SHORT TEST - CYLINDERS * * QUERY: * * SHORT TEST-CYLS? * * SELECTION: * * NUMBER OF CYLINDERS TO - MUST BE <1/2 OF TOTAL NO. OF CYLS. * BE TESTED AT BEGINING * AND END OF DISK FOR SHORT * TESTING. * *   DEFAULT IS 0 * * CALLS: * MSGA * IDEC * CHRIN * ****************************** * QUERYS0 EQU $  COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY SHORTCX,A GET DEFAULT VALUE COPY A,SHORTC STORE IT JST MSGA OUTPUT QUERY WORD QUERYMS0 JST IDEC GET RESPONSE JEQ X,QUERYS3 IF ZERO, SEE WHY COPY X,SHORTC STORE RESULT SUB =1,X DECREMENT NUMBER COPY ECYL,A GET ENDING CYLINDER NUMBER SUB SCYL,A GET TOTAL NUMBER OF CYLINDERS SHIFT A,RO,1 DIVIDE TOTAL BY HALF CSK A,X COMPARE TO SHORT TEST CYLINDER JMP QUERYS0 CAN'T DO NOP CAN DO QUERYS1 IMS TEMP2 SET INPUT FLAG QUERYS2 JST CHRIN CHECK TERMINATOR JMP QUERYA0 CR JMP QUERYS4 # JMP QUERYS0 BACK ARROW JMP QUERYS5 UP ARROW JMP QUERYS0 COMMA JMP QUERYS0 ANYTHING ELSE QUERYS3 COPY IDCTM3,A GET INPUT COUNT JEQ A,QUERYS2 CHECK TERMINATOR JMP QUERYS1 OTHERWISE, INPUT = 0 QUERYS4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYS0 CAN'T DO JMP QUERND DEFAULT QUERYS5 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYS0 CAN'T DO JMP QUERY40 GO BACK * LPOOL TITL QUERIES (NUMBER OF HEADS) ****************************** * * NUMBER OF HEADS * * QUERY: * *  HDS? * * SELECTION: * TOTAL NUMBER OF HEADS, * STARTING HEAD NUMBER, - MUST BE < TOTAL HEAD NO. *  ENDING HEAD NUMBER - MUST BE > START. HEAD NO. AND * MUST BE < END. HEAD NO. *  DEFAULT IS THE SELECTED DRIVE PARAMETERS * * CALLS: * MOVE * MSGA * IDEC * CHRIN * ****************************** * QUERY70 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP1 RESET INTERMIDIATE SHORT TEST FLAG COPY A,TEMP2 RESET INPUT FLAG COPY DISK,A GET ADDRESS OF PARAMETER TABLE ADD =HDS-HCP,A ADD 'HEAD PARAMETERS' OFFSET COPY A,QUERY71 STORE FOR MOVE COPY =HDS-EHD-1,A SET MOVE COUNT -(EHD-HDS+1) JST MOVE RESET HEAD PARAMETERS TO DEFAULT QUERY71 WORD 0 WORD HDS JST MSGA OUTPUT QUERY WORD QUERYM70 JST IDEC GET INPUT JEQ X,QUERY73 TERMINATOR OR ZERO INPUT? IMS TEMP2 SET INPUT FLAG COPY X,HDS STORE NUMBER OF HEADS COPY =0,A SET STARTING HEAD TO COPY A,SHD ZERO, TENTATIVELY SUB =1,X SET ENDING HEAD TO (HDS-1)  COPY X,EHD TENTATIVELY COPY IDCTM2,A GET TERMINATOR CLSN =',',A IS IT A COMMA? JMP QUERY74 YES, GET STARTING HEAD NUMBER QUERY72 JST CHRIN CHECK TERMINATOR JMP QUERY78 CR JMP QUERY75 # JMP QUERY70 BACK ARROW JMP QUERY76 UP ARROW JMP QUERY70 COMMA  JMP QUERY70 ANYTHING ELSE IS BAD QUERY73 COPY IDCTM3,A GET ACTUAL INPUT COUNT JEQ A,QUERY72 IF ZERO, CHECK TERMINATOR JMP QUERY70 ELSE INPUT = 0 (ERROR) QUERY74 IMS TEMP1 BUMP SHORT TEST FLAG JST IDEC GET STARTING HEAD NUMBER COPY X,A DO RANGE CHECK CSK A,EHD MUST BE BETWEEN 0 AND (HDS-1) JMP $+2 JMP QUERY70 RANGE ERROR COPY A,SHD STORE STARTING HEAD NUMBER COPY A,EHD ASSUME ENDING HEAD ALSO COPY IDCTM2,A CHECK TERMINATOR CLSN =',',A IS IT A COMMA? JMP QUERY77 YES, GET ENDING HEAD NUMBER JMP QUERY72 NO, CHECK TERMINATOR QUERY75 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY70 CAN'T DO IT JMP QUERND YES, WE CAN QUERY76 COPY TEMP2,A GET INPUT FLAG JNE A,QUERY70 CAN'T DO IT COPY NONSTND,A GET NON-STANDARD FLAG JNE A,$+2 JMP QUERY50 IF STANDARD THEN GO BACK TO USER CYLS JMP QUERYI0 GO BACK 1 QUERY77 JST IDEC GET ENDING HEAD NUMBER COPY X,A DO RANGE CHECK CSK A,HDS MUST BE  LESS THAN TOTAL JMP $+3 NOP JMP QUERY70 RANGE ERROR CSK A,SHD MUST NOT BE LESS THAN JMP QUERY70 STARTING HEAD NUMBER NOP  COPY A,EHD STORE ENDING HEAD NUMBER JMP QUERY72 CHECK TERMINATOR QUERY78 COPY TEMP1,A GET INTERMIDIATE SHORT TEST FLAG ADD SHORT,A ADD SHORT TEST FLAG COPY A,SHORT STORE NEW SHORT TEST FLAG COPY MODE,A GET FUNCTION CLSN ='F',A ARE WE USING THE FORMATTER JMP QUERYE0 YES GO TO THE FORMATTER CLSN ='T',A ARE WE USING THE TECH TEST JMP QUERND YES JMP QUERYJ0 MUST BE THE DIAGNOSTIC, GO TO THE # OF BOARDS QUERY * LPOOL TITL QUERIES (USER'S PATTERN) ****************************** * * USER'S PATTERN * * QUERY: * * PATN (:6DB6)?: * * SELECTION: * :0000 TO :FFFF * DEFAULT IS ':6DB6' * * CALLS: *  MSGA * IHEX * CHRIN * ****************************** * QUERYA0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY WCPATX,A GET DEFAULT PATTERN COPY A,WCPAT STORE AS USER PATTERN JST MSGA OUTPUT QUERY WORD QUERYMA0 JST IHEX GET INPUT JEQ X,QUERYA3 IF ZERO, SEE WHY QUERYA1 IMS TEMP2 SET INPUT FLAG COPY X,WCPAT STORE PATTERN QUERYA2 JST CHRIN CHECK TERMINATOR JMP QUERYB0 CR JMP QUERYA4 # JMP QUERYA0 BACK ARROW JMP QUERYA5 UP ARROW JMP QUERYA0 COMMA JMP QUERYA0 ANYTHING ELSE IS BAD QUERYA3 COPY IDCTM3,A LOOK AT ACTUAL INPUT COUNT JEQ A,QUERYA2 IF ZERO, CHECK TERMINATOR JMP QUERYA1 ELSE STORE INPUT QUERYA4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYA0 CAN'T DO JMP QUERND CAN DO QUERYA5 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYA0 CAN'T DO JMP QUERYS0 CAN DO * LPOOL TITL QUERIES (UNIT NUMBERS) ****************************** * * UNIT NUMBERS * * QUERY: * * UNITS (0-'MAX. NUMBER OF UNITS')? * * SELECTION: * 0 TO MAXIMUM NUMBER OF TESTABLE *  UNITS (SEE 'UNITS' EQUATE) * DEFAULT IS '0' * * CALLS: * MOVE * MSGA * IDEC * CHRIN * ****************************** * QUERYB0 EQU $ COPY =-UNITS-1,A GET MOVE COUNT -(UNITS+1) JST MOVE SET UNIT SELECTION TO DEFAULT VALUES WORD UNX WORD UN JST MSGA OUTPUT QUERY WORD QUERYMB0 COPY =0,A SET A TO ZERO COPY A,TEMP1 RESET COUNT OF INPUTS QUERYB1 JST IDEC GET INPUT JEQ X,QUERYB4 IF ZERO, SEE WHY COPY X,A DO RANGE CHECK CSK A,=UNITS-1 MUST BE 0 - (UNITS-1) JMP $+2 JMP QUERYB0 NOT OK QUERYB2 COPY TEMP1,A CHECK COUNT CLSN =UNITS,A MAX. UNITS? JMP QUERYB0 YES, ERROR ADD =UN,A EXCH A,X X = ADDRESS OF UNIT TABLE IN PARAMETER TABLE COPY A,0(X) STORE UNIT NUMBER IN TABLE COPY =-1,A STORE DELIMITER COPY A,1(X) AT NEXT LOCATION IN TABLE IMS TEMP1 BUMP COUNT QUERYB3 JST CHRIN CHECK TERMINATOR JMP QUERYC0 CR JMP QUERYB5 # JMP QUERYB0 BACK ARROW JMP QUERYB6 UP ARROW JMP QUERYB1 COMMA JMP QUERYB0 ANYTHING ELSE IS BAD QUERYB4 COPY IDCTM3,A LOOK AT ACTUAL INPUT COUNT JEQ A,QUERYB3 IF ZERO, CHECK TERMINATOR JMP QUERYB2 ELSE, STORE IT QUERYB5 COPY TEMP1,A GET INPUT COUNT JNE A,QUERYB0 CAN'T DO JMP QUERND CAN DO QUERYB6 COPY TEMP1,A GET INPUT FLAG JNE A,QUERYB0 CAN'T DO JMP QUERYA0 CAN DO * LPOOL TITL QUERIES (DESTRUCTIVE MODE) ****************************** * * DESTRUCTIVE MODE * * QUERY: * * SAVE DATA (Y OR N)? * * SELECTION: * Y - YES, SAVE DATA ON THE DISK * N - NO, DON'T SAVE DATA ON THE DISK * DEFAULT IS 'N' * *  CALLS: * MSGA * IDEC * CHRIN * IKB * ****************************** * QUERYC0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY NONDEX,A GET DEFAULT VALUE COPY A,NONDES STORE AS RESULT JST MSGA OUTPUT QUERY WORD QUERYMC0 JST IDEC GET RESPONSE JNE X,QUERYC0 IF DECIMAL ERROR COPY IDCTM3,A GET INPUT COUNT JNE A,QUERYC0 A ZERO IS BAD QUERYC1 JST CHRIN CHECK TERMINATOR JMP QUERYD0 CR JMP QUERYC4 # JMP QUERYC0 BACK ARROW JMP QUERYC5 UP ARROW JMP QUERYC0 COMMA CLSN ='Y',A IS IT YES? JMP QUERYC2 OK CLSN ='N',A IS IT NO? JMP QUERYC3 OK JMP QUERYC0 ANYTHING ELSE IS BAD QUERYC2 ADD =1,X SET FLAG QUERYC3 COPY X,NONDES STORE FLAG IMS TEMP2 SET INPUT FLAG JST IKB GET TERMINATOR COPY A,IDCTM2 STORE TERMINATOR JMP QUERYC1 CHECK TERMINATOR QUERYC4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYC0 CAN'T DO JMP QUERND CAN DO QUERYC5 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYC0 CAN'T DO JMP QUERYB0 CAN DO * LPOOL TITL QUERIES (RUN OPTIONS) ****************************** * * RUN OPTIONS * * QUERY: * * RUN OPTIONS (:00)?: * * SELECTION: * :00 TO :1F * DEFAULT IS ':00' * * BIT HEX OPTION * --- --- ------ * 0 :01 INCLUDE BUFFER DUMP IN ERROR REPORTS * WHERE APPLICABLE * * 1 :02 SUPPRESS ERROR REPORTS * * 2 :04 OUTPUT ERROR TALLIES AT END OF EACH TEST * * 3 :08 RUN CONTINUOUSLY * * 4 :10 HALT ON HARD ERROR * * 5 :20 OUTPUT ALL MESSAGES ON LINEPRINTER * * * CALLS: * MSGA * IHEX * CHRIN * ****************************** * QUERYD0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY CARX,A GET DEFAULT VALUE  COPY A,CAR STORE VALUE JST MSGA OUTPUT QUERY WORD QUERYMD0 JST IHEX GET RESPONSE JEQ X,QUERYD3 IF ZERO, SEE WHY QUERYD1 IMS TEMP2 SET INPUT FLAG COPY X,A RANGE CHECK SHIFT A,RO,6 :00 - :20 JNE A,QUERYD0 COPY X,CAR STORE VALUE QUERYD2 JST CHRIN CHECK TERMINATOR JMP QUERND CR JMP QUERYD4 # JMP QUERYD0 BACK ARROW JMP QUERYD5 UP ARROW JMP QUERYD0 COMMA JMP QUERYD0 ANYTHING ELSE IS BAD QUERYD3 COPY IDCTM3,A GET ACTUAL INPUT COUNT JEQ A,QUERYD2 IF ZERO, CHECK TERMINATOR JMP QUERYD1 ELSE, INPUT = 0 QUERYD4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYD0 CAN'T DO JMP QUERND CAN DO QUERYD5 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYD0 CAN'T DO JMP QUERYC0 CAN DO * LPOOL TITL QUERIES (UNIT TO FORMAT) ****************************** * * UNIT TO FORMAT * *  QUERY: * * UNIT TO FORMAT (0-MAX. UNITS)? * * SELECTION: * 0 TO MAXIMUM NUMBER OF UNITS * (SEE 'UNITS' EQUATE) * DEFAULT IS '0' * * CALLS: * MSGA * IDEC * CHRIN * ****************************** * QUERYE0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY A,UCUR SET UNIT TO DEFAULT JST MSGA OUTPUT QUERY WORD QUERYME0 JST IDEC GET RESPONSE JEQ X,QUERYE3 IF ZERO, SEE WHY QUERYE1 IMS TEMP2 SET INPUT FLAG COPY X,A CSK A,=UNITS-1 DO RANGE CHECK JMP $+2 OK JMP QUERYE0 NOT OK COPY X,UCUR SAVE UNIT NUMBER QUERYE2 JST CHRIN CHECK TERMINATOR JMP QUERYN0 CR JMP QUERYE4 # JMP QUERYE0 BACK ARROW JMP QUERYE5 UP ARROW JMP QUERYE0 COMMA JMP QUERYE0 ANYTHING ELSE IS BAD QUERYE3 COP  Y IDCTM3,A GET ACTUAL INPUT COUNT JEQ A,QUERYE2 IF ZERO, CHECK TERMINATOR JMP QUERYE1 ELSE, GOOD INPUT QUERYE4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYE0 CAN'T DO JMP QUERYN0 CAN DO QUERYE5 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYE0 CAN'T DO JMP QUERY70 CAN DO * LPOOL TITL QUERIES (SECTOR INTERLEAVE) ***************************** * * SECTOR INTERLEAVE * * QUERY: * * SECTOR INTERLEAVE (0)?: * * SELECTION: * :1 TO :E * DEFAULT IS ':0' * * CALLS: * MSGA * IHEX * CHRIN * ***************************** * QUERYN0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY STAGX,A SET DEVICE ADDRESS TO DEFAULT COPY A,STAG JST MSGA OUTPUT QUERY WORD QUERYMN0 JST IHEX GET RESPONSE JEQ X,QUERYN1 IF ZERO, SEE WHY IMS TEMP2 SET INPUT FLAG CSK X,=:E DO RANGE CHECK JMP $+2 MUST BE :0 - :E JMP QUERYN0 BAD INPUT COPY X,STAG STORE INPUT QUERYN1 JST CHRIN CHECK TERMINATOR JMP QUERYP0 CR JMP QUERYN3 # JMP QUERYN0 BACK ARROW JMP QUERYN4 UP ARROW JMP QUERYN0 COMMA JMP QUERYN0 ANYTHING ELSE IS ILLEGAL QUERYN3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYN0 IF INPUT THEN IT IS ILLEGAL JMP QUERND QUERYN4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYN0 IF INPUT THEN IT IS ILLEGAL JMP QUERYE0 OTHERWISE, JUMP * LPOOL TITL QUERIES (MANUFACTURER'S BAD TRACKS) ****************************** * * MANUFACTURER'S BAD TRACKS * * QUERY: * *  ANY BAD TRACKS FROM MANUFACTURER (Y/[N])? * * DEFAULT IS NO. * * CALLS: * MSGA * IDEC *  CHRIN * ****************************** * QUERYP0 EQU $ COPY =-BADBUFSZ,A GET SIZE OF BAD BUFFER JST MOVE CLEAR OUT THE BAD TRACK BUFFER WORD BUFCLR MOVE FROM WORD BADBUF MOVE TO COPY =:FFFF,A COPY A,BADBUF LOGICAL END OF BUFFER JST MSGA OUTPUT QUERY WORD QUERYMP0 JST IDEC GET RESPONSE JNE X,QUERYP0 NUMERIC RESPONSE IS A NO-NO JST CHRIN CHECK TERMINATOR JMP QUERND CR - DEFAULT, NO MFR BAD TRKS JMP QUERND # - DEFAULT, NO MFR BAD TRKS JMP QUERYP0 BACK ARROW JMP QUERYN0 UP ARROW JMP QUERYP0 COMMA CLSN A,='Y' BAD TRACKS - YES? JMP QUERYP1 GO ASK FOR BAD ONES CLSN A,='N' BAD TRACKS - NO? JMP QUERYP2 NO BAD ONES JMP QUERYP0 ANYTHING ELSE IS A NO-NO. * QUERYP1 JST IDEC GET TERMINATOR JNE X,QUERYP0 NUMERIC RESPONSE IS NO GOOD JST CHRIN CHECK TERMINATOR JMP QUERYQ0 GO GET THE BAD ONES JMP QUERYP0 '#' AFTER A 'Y' IS NO GOOD JMP QUERYP0 BACK ARROW DITTO JMP QUERYP0 UP ARROW DITTO JMP QUERYP0 COMMA DITTO JMP QUERYP0 ANYTHING ELSE DITTO * QUERYP2 JST IDEC GET TERMINATOR JNE X,QUERYP0 NUMERIC RESPONSE IS NO GOOD JST CHRIN CHECK TERMINATOR JMP QUERYP3 CR AFTER 'N' IS OK JMP QUERYP0 '#' AFTER 'N' IS NO GOOD JMP QUERYP0 BACK ARROW DITTO JMP QUERYP0 UP ARROW DITTO JMP QUERYP0 COMMA DITTO JMP QUERYP0 ANYTHING ELSE DITTO * QUERYP3 JST MSGA TELL 'EM IT'S FORMATTING WORD QUERYMP1 JMP QUERND LPOOL * TITL QUERIES (MFR'S BAD CYLINDER NUMBERS) ****************************** * * MANUFACTURER'S BAD CYLINDER NUMBERS * * QUERY: * * ENTER CYLINDER NUMBER (DECIMAL) * * DEFAULT IS CR, WHICH INDICATES NO MORE BAD ONES. * * CALLS: * MOVE * MSGA * IDEC * CHRIN * ****************************** * QUERYQ0 EQU $ COPY =BADBUF,A GET BUFFER ADDR COPY A,BUFPTR INIT BUFFER POINTER * QUERYQ1 COPY =0,A SET A TO  ZERO COPY A,TEMP2 RESET INPUT FLAG JST MSGA OUTPUT QUERY WORD QUERYMQ0 CYLINDER QUERY JST IDEC GET RESPONSE JLT X,QUERYQ1 NEG. CYLINDER # IS A NO-NO JEQ X,QUERYQ4 IF ZERO, SEE WHY. * QUERYQ2 IMS TEMP2 SET INPUT FLAG COPY CYLS,A GET MAX NO OF CYLINDERS ALLOWED SUB =1,A CSK X,A CHECK RANGE JMP $+2 OK JMP QUERYQ1 CYL # IS TOO LARGE COPY X,BADCYL SAVE BAD CYL # * QUERYQ3 JST CHRIN CHECK TERMINATOR JMP QUERYQ5 CR JMP QUERYQ6 # JMP QUERYQ1 BACK ARROW JMP QUERYP0 UP ARROW JMP QUERYQ1 COMMA JMP QUERYQ1 ANYTHING ELSE IS BAD * QUERYQ4 COPY IDCTM3,A SEE WHY IDEC-VALUE IS ZERO JEQ A,QUERYQ3 THEY TYPED JUST A TERMINATOR JMP QUERYQ2 MUST BE CYLINDER #0 * QUERYQ5 COPY TEMP2,A THEY TYPED A CR JEQ A,$+2 JUST CR, ALL DONE JMP QUERYR0 CYL# + CR, NOW GET BAD HEAD COPY =:FFFF,A END OF BAD TRK BUFFER COPY A,*BUFPTR STORE IT JST MSGA TELL 'EM IT'S FORMATTING WORD QUERYMP1 JMP QUERND ALL BAD TRACKS ENTERED, EXIT * QUERYQ6 COPY TEMP2,A TERMINATOR WAS A '#' JEQ A,$+2 THEY DEFAULTED JMP QUERYQ1 CYL# FOLLOWED BY A '#' IS A NO-NO COPY =BADBUF,A GET ADDR OF BAD BUF CSK Y,A SEE IF THEY ENTERED ANY BAD ONES YET NOP JMP QUERYQ1 CAN'T DEFAULT AFTER ENTERING SOME BAD ONES JMP QUERND OK * BUFCLR RES BADBUFSZ,0 ALL ZEROS TO CLEAR THE BAD BUFFER BADBUF RES BADBUFSZ,0 BAD CYL/HEAD PAIRS BADCYL RES 1,0 BAD CYLINDER # BADHEAD RES 1,0 BAD HEAD # BUFPTR RES 1,0 BUFFER POINTER LIMIT WORD =BADBUF+BADBUFSZ-1 ADDR OF LAST WORD IN BUFFER LPOOL TITL QUERIES (MANUFACTURER'S BAD HEAD NUMBERS) ****************************** * * GET MFR'S BAD HEAD NUMBERS * * QUERY: * * ENTER BAD HEAD (DECIMAL) * * CALLS: * MSGA * IDEC * CHRIN * ****************************** * QUERYR0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG JST MSGA OUTPUT 'BAD HEAD?' QUERY WORD QUERYMR0 JST IDEC GET RESPONSE JLT X,QUERYR0 NEG. HEAD # IS A NO-NO JEQ X,QUERYR3 IF IDEC-VALUE IS ZERO, SEE WHY * QUERYR1 IMS TEMP2 WE GOT A DIGIT, SET FLAG COPY HDS,A GET MAX # OF HEADS SUB =1,A CSK X,A CHECK RANGE  JMP $+2 OK JMP QUERYR0 HEAD # OUT OF RANGE COPY X,BADHEAD SAVE BADHEAD # * QUERYR2 JST CHRIN CHECK TERMINATOR JMP QUERYR4 CR (MUST FOLLOW A HEAD #) JMP QUERYR0 # (NO GOOD HERE) JMP QUERYR0 BACK ARROW (RESTART HEAD QUERY) JMP QUERYQ1 UP ARROW (RESTART MOST RECENT CYL QUERY) JMP QUERYR0 COMMA JMP QUERYR0 ANYTHING ELSE IS BAD * QUERYR3 COPY IDCTM3,A SEE WHY IDEC-VALUE IS ZERO JEQ A,QUERYR2 THEY TYPED JUST A TERMINATOR JMP QUERYR1 MUST BE HEAD 0 * QUERYR4 COPY TEMP2,A THEY TYPED A CR JEQ A,QUERYR0 JUST A CR IS NO GOOD QUERYR5 COPY BADCYL,A GET BAD CYL # SHIFT A,LO,4 PUT IN UPPER 3 NIBBLES OR BADHEAD,A PUT HEAD IN LOWER NIBBLE COPY A,*BUFPTR PUT CYL/HD IN TABLE COPY LIMIT,A GET POINTER TO END OF BUFFER SUB BUFPTR,A BUFFER FULL YET? JEQ A,QUERYR6 YES, PRINT ERROR MSG IMS BUFPTR NO, SO BUMP POINTER JMP QUERYQ1 GET NEXT BAD CYL# * QUERYR6 JST MSGA EXCESSIVE BAD TRACKS WORD QUERYMR1 HLT QUIT JMP $-3 LPOOL TITL QUERYF0 (SCOUT BOARD ID) ****************************** * * SCOUT BOARD ID * * QUERY: * * SCOUT BOARD ID (07)?: * * SELECTION: * :01 TO :E * DEFAULT IS '07' * * CALLS: * MSGA * IHEX * CHRIN * ****************************** * QUERYF0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET IN  PUT FLAG COPY BDIDX,A SET DEVICE ADDRESS TO DEFAULT COPY A,BDID COPY DISK,A GET DRIVE PARAMETER TABLE ADDRESS COPY A,QUERYF0A STORE FOR MOVE COPY =HCP-EHCP,A PARAMETER TABLE SIZE -(EHCP-HCP) JST MOVE RESET DRIVE PARAMETERS QUERYF0A WORD 0 WORD HCP JST MSGA OUTPUT QUERY WORD QUERYMF0 JST IHEX GET RESPONSE JEQ X,QUERYF2 IF ZERO, SEE WHY IMS TEMP2 SET INPUT FLAG CSK X,=:E DO RANGE CHECK JMP $+2 MUST BE 1-:E JMP QUERYF0 BAD INPUT COPY X,BDID STORE INPUT QUERYF1 JST CHRIN CHECK TERMINATOR JMP QUERYG0 CR JMP QUERYF3 # JMP QUERYF0 BACK ARROW JMP QUERYF4 UP ARROW JMP QUERYF0 COMMA JMP QUERYF0 ANYTHING ELSE IS ILLEGAL QUERYF2 COPY IDCTM3,A GET INPUT COUNT JEQ A,QUERYF1 IF ZERO, DEFAULT JMP QUERYF0 ELSE, INPUT = 0 (ERROR) QUERYF3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYF0 IF INPUT THEN IT IS ILLEGAL JMP QUERND QUERYF4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYF0 IF INPUT THEN IT IS ILLEGAL JMP QUERY30 OTHERWISE, JUMP * LPOOL * TITL QUERIES (MAX CYLINDER) ****************************** * * MAX CYLS * * QUERY: * * MAX CYLS? * * SELECTION: * ENTER THE MAXIMUM CYLINDER VALUE * * CALLS: * MOVE * MSGA * IDEC * ****************************** * QUERYG0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY DISK,X GET ADDRESS OF PARAMETER TABLE COPY CYLMX-HCP(X),A GET DEFAULT MAX CYLINDERS COPY A,CYLMX STORE DEFAUTL VALUE FOR MAX CYLINDERS COPY NONSTND,A JNE A,$+2 ASK THIS QUERY IF USING NONSTANDARD PARAMETERS JMP QUERY50 GOTO NEXT QUERY IF USING STANDARD PARAMETERS JST MSGA OUTPUT QUERY WORD QUERYMG0 JST IDEC GET RESPONSE JEQ X,QUERYG2 IF ZERO, SEE WHY IMS TEMP2 SET INPUT FLAG COPY X,CYLMX STORE INPUT QUERYG1 JST CHRIN CHECK TERMINATOR JMP QUERY50 CR JMP QUERYG3 # JMP QUERYG0 BACK ARROW JMP QUERYG4 UP ARROW JMP QUERYG0 COMMA JMP QUERYG0 ANYTHING ELSE IS ILLEGAL QUERYG2 COPY IDCTM3,A GET INPUT COUNT JEQ A,QUERYG1 IF ZERO, DEFAULT JMP QUERYG0 ELSE, INPUT = 0 (ERROR) QUERYG3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYG0 IF INPUT THEN IT IS ILLEGAL JMP QUERND QUERYG4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYG0 IF INPUT THEN IT IS ILLEGAL JMP QUERYF0 OTHERWISE, JUMP * LPOOL * TITL QUERIES (REDUCED WRITE CURRENT) ****************************** * * QUERY: * * REDUCED WRITE CURRENT CYL? * * SELECTION: * STARTING CYLINDER FOR WRITE PRECOMPENSATION * - MUST BE > STARTING CYL. NO. AND *  - MUST BE < END CYL. NO. * DEFAULT IS THE SELECTED DRIVE PARAMETERS * * CALLS: * MSGA * IDEC * CHRIN * ****************************** * QUERYH0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY RWCUREN,A GET REDUCE WRITE CURRENT ENABLE FLAG JNE A,$+3 JUMP IF THIS QUERY IS NEEDED COPY A,RWCUR RWCUR NOT NEEDED SO ZERO IT OUT JMP QUERYM0 GO TO NEXT QUERY COPY DISK,X COPY RWCUR-HCP(X),A COPY A,RWCUR COPY NONSTND,A JNE A,$+2 IF USING STANDARD PARAMETERS SKIP THIS QUERY JMP QUERY70 GOTO NUMBER OF HEADS QUERY (MUST BE USEING STANDARD DRIVE) JST MSGA OUTPUT QUERY WORD QUERYMH0 JST IDEC GET RESPONSE JEQ X,QUERYH4 IF ZERO, SEE WHY QUERYH0A EQU $ IMS TEMP2 SET INPUT FLAG COPY X,A CSK A,SCYL MUST BE BETWEEN SCYL AND ECYL JMP QUERYH0 MUST BE GREATER THAN SCYL NOP CSK A,ECYL MUST BE LESS THAN ECYL JMP $+2 JMP QUERY  H0 ERROR IF GREATER COPY A,RWCUR STORE WRITE PRE COMP CYL QUERYH1 JST CHRIN CHECK TERMINATOR JMP QUERYM0 CR JMP QUERYH2 # JMP QUERYH0 BACK ARROW JMP QUERYH3 UP ARROW JMP QUERYH0 COMMA JMP QUERYH0 ANYTHING ELSE IS BAD QUERYH2 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYH0 CAN'T IF INPUT JMP QUERND DEFAULT QUERYH3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYH0 CAN'T IF INPUT JMP QUERYL0 GO BACK QUERYH4 COPY IDCTM3,A GET INPUT COUNT JEQ A,QUERYH1 CHECK TERMINATOR JMP QUERYH0A MUST BE ZERO * LPOOL * TITL QUERIES (STEP PULSE CODE) ****************************** * * STEP PULSE CODE * * QUERY: * * STEP PULSE CODE (3)? * * SELECTION: * 0 - 3MS PER STEP * 1 - 60MS PER STEP * 2 - STEP PULSES ARE ISSUED ACCORDING TO * THE SEAGATE INC. ST-506 1/2 STEP * RAMP STEP ALGORITHM. * 3 - 200 MS PER STEP * 4 - STEP PULSES ARE ISSUED ACCORDING TO * THE MINISCRIBE INC. MS-1012 1/2 STEP * RAMPED STEP ALGORITHM. * *********************************** * QUERYI0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY DISK,X COPY STPLSE-HCP(X),A COPY A,STPLSE JST MSGA OUTPUT QUERY WORD QUERYMI0 JST IHEX GET RESPONSE JEQ X,QUERYI2 IF ZERO, SEE WHY IMS TEMP2 SET INPUT FLAG CSK X,=4 DO RANGE CHECK JMP $+2 MUST BE 0-4 JMP QUERYI0 BAD INPUT COPY X,STPLSE STORE INPUT QUERYI1 JST CHRIN CHECK TERMINATOR JMP QUERY70 CR JMP QUERYI3 # JMP QUERYI0 BACK ARROW JMP QUERYI4 UP ARROW JMP QUERYI0 COMMA JMP QUERYI0 ANYTHING ELSE IS ILLEGAL QUERYI2 COPY IDCTM3,A GET INPUT COUNT JEQ A,QUERYI1 IF ZERO, DEFAULT JMP QUERYI1-1 ELSE, INPUT = 0 QUERYI3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYI0 IF INPUT THEN IT IS ILLEGAL JMP QUERND QUERYI4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYI0 IF INPUT THEN IT IS ILLEGAL JMP QUERYM0 OTHERWISE, JUMP * LPOOL * TITL QUERIES (NUMBER OF BOARDS) ****************************** * * NUMBER OF BOARDS * * QUERY: * * NUMBER OF BOARDS (1)? * * SELECTIONS: * NUMBER OF BOARDS TO TEST * MUST BE > 1 AND < 31 * * CALLS: * MSGA * IDEC * CHRIN * ******************************* * QUERYJ0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY =1,A SET DEFAULT NUMBER OF BOARDS COPY A,NMBBRD JST MSGA OUTPUT QUERY WORD QUERYMJ0 JST IHEX GET RESPONSE JEQ X,QUERYJ2 IF ZERO, SEE WHY IMS TEMP2 SET INPUT FLAG CSK X,=31 DO RANGE CHECK JMP $+2 MUST BE 1-31 JMP QUERYJ0 BAD INPUT COPY X,NMBBRD STORE INPUT QUERYJ1 JST CHRIN CHECK TERMINATOR JMP QUERY40 CR JMP QUERYJ3 # JMP QUERYJ0 BACK ARROW JMP QUERYJ4 UP ARROW JMP QUERYJ0 COMMA  JMP QUERYJ0 ANYTHING ELSE IS ILLEGAL QUERYJ2 COPY IDCTM3,A GET INPUT COUNT JEQ A,QUERYJ1 IF ZERO, DEFAULT JMP QUERYJ0 ELSE, INPUT = 0 (ERROR) QUERYJ3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYJ0 IF INPUT THEN IT IS ILLEGAL JMP QUERND QUERYJ4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYJ0 IF INPUT THEN IT IS ILLEGAL JMP QUERY70 OTHERWISE, JUMP * TITL QUERIES (PRECOMPENSATION Y/N) ****************************** * * IS PRECOMPENSATION NEEDED YES OR NO * * QUERY: * * PRECOMPENSATION Y/N (Y)? * * SELECTION: * TO BE ANSWERED Y OR N (YES OR NO) * DEFAULT ID "Y" (YES). * ******************************* * QUERYK0 EQ  U $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY NONSTND,A JNE A,$+2 DON'T JUMP IF STANDARD DISK PARAMETERS JMP QUERY70 GOTO # OF HEADS QUERY COPY PCMPENX,A SET FUNCTION TO DEFAULT COPY A,PCMPEN JST MSGA OUTPUT QUERY WORD QUERYMK0 JST IDEC GET RESPONSE JNE X,QUERYK0 NUMERIC RESPONSE IS INCORRECT COPY IDCTM3,A GET INPUT COUNT JNE A,QUERYK0 A ZERO IS INCORRECT QUERYK1 JST CHRIN CHECK TERMINATOR JMP QUERY60 CR JMP QUERYK3 # JMP QUERYK0 BACK ARROW JMP QUERYK4 UP ARROW JMP QUERYK0 COMMA CLSN ='Y',A IS IT WANTED? JMP QUERYK2A YES CLSN ='N',A NOT WANT FLAG IT? JMP QUERYK2 YES, STORE IT JMP QUERYK0 ANYTHING ELSE IS WRONG QUERYK2 COPY =0,A 0=NO COPY A,PCMPEN SET THE FLAG TO NO COPY A,PCMP IF WERE NOT USING IT SET IT TO 0 QUERYK2A EQU $ IMS TEMP2 SET INPUT FLAG JST IKB GET TERMINATOR COPY A,IDCTM2 STORE TERMINATOR JMP QUERYK1 CHECK TERMINATOR QUERYK3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYK0 CAN'T DO JMP QUERND CAN DO QUERYK4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYK0 CAN'T DO JMP QUERY50 CAN DO * LPOOL TITL QUERIES (REDUCE WRITE CURRENT Y/N) ****************************** * * IS REDUCE WRITE CURRENT NEEDED YES OR NO * * QUERY: * * REDUCE WRITE CURRENT Y/N (Y)? * * SELECTION: * TO BE ANSWERED Y OR N (YES OR NO) * DEFAULT ID "Y" (YES). * ******************************* * QUERYL0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY RWCURENX,A SET FUNCTION TO DEFAULT COPY A,RWCUREN JST MSGA OUTPUT QUERY WORD QUERYML0 JST IDEC GET RESPONSE JNE X,QUERYL0 NUMERIC RESPONSE IS INCORRECT COPY IDCTM3,A GET INPUT COUNT JNE A,QUERYL0 A ZERO IS INCORRECT QUERYL1 JST CHRIN CHECK TERMINATOR JMP QUERYH0 CR JMP QUERYL3 # JMP QUERYL0 BACK ARROW JMP QUERYL4 UP ARROW JMP QUERYL0 COMMA CLSN ='Y',A IS IT WANTED? JMP QUERYL2A YES CLSN ='N',A NOT WANT FLAG IT? JMP QUERYL2 YES, STORE IT JMP QUERYL0 ANYTHING ELSE IS WRONG QUERYL2 COPY =0,A 0=NO COPY A,RWCUREN SET THE FLAG TO NO COPY A,RWCUR IF WERE NOT USING IT CLEAR IT TO 0 QUERYL2A EQU $ IMS TEMP2 SET INPUT FLAG JST IKB GET TERMINATOR COPY A,IDCTM2 STORE TERMINATOR JMP QUERYL1 CHECK TERMINATOR QUERYL3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYL0 CAN'T DO JMP QUERND CAN DO QUERYL4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYL0 CAN'T DO COPY PCMPEN,A DO WE WANT TO GO BACK 1 JNE A,$+2 JUMP IF WE DO JMP QUERYK0 GO BACK 2 JMP QUERY60 CAN DO * LPOOL * TITL QUERIES (BAD TRACK MAPPING Y/N) ****************************** * * IS BAD TRACK MAPPING NEEDED YES OR NO * * QUERY: * * BAD TRACK MAPPING Y/N (Y)? * * SELECTION: * TO BE ANSWERED Y OR N (YES OR NO) * DEFAULT ID "Y" (YES). * ******************************* * QUERYM0 EQU $ COPY =0,A SET A TO ZERO COPY A,TEMP2 RESET INPUT FLAG COPY BADTRCKX,A SET FUNCTION TO DEFAULT COPY A,BADTRCK JST MSGA OUTPUT QUERY WORD QUERYMM0 JST IDEC GET RESPONSE JNE X,QUERYM0 NUMERIC RESPONSE IS INCORRECT COPY IDCTM3,A GET INPUT COUNT JNE A,QUERYM0 A ZERO IS INCORRECT QUERYM1 JST CHRIN CHECK TERMINATOR JMP QUERYI0 CR JMP QUERYM3 # JMP QUERYM0 BACK ARROW JMP QUERYM4 UP ARROW JMP QUERYM0 COMMA CLSN ='Y',A IS IT WANTED? JMP QUERYM2A YES CLSN ='N',A NOT WANT FLAG IT? JMP QUERYM2 YES, STORE IT JMP QUERYM0 ANYTHING ELSE IS WRONG QUERYM2 COPY =0,A 0=NO COPY A,BADTRCK SET THE FLAG T O NO QUERYM2A EQU $ IMS TEMP2 SET INPUT FLAG JST IKB GET TERMINATOR COPY A,IDCTM2 STORE TERMINATOR JMP QUERYM1 CHECK TERMINATOR QUERYM3 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYM0 CAN'T DO JMP QUERND CAN DO QUERYM4 COPY TEMP2,A GET INPUT FLAG JNE A,QUERYM0 CAN'T DO COPY RWCUREN,A DO WE WANT RETURN TO REDUCE WRITE CURRENT CYL. JNE A,$+2 JMP QUERYL0 NO, SO ASK IF REDUCE WRITE CURRENT IS NEEDED JMP QUERYH0 YES * LPOOL TITL TEST CONTROL (DEVICE ADDRESS MODIFICATION) ****************************** * * DEVICE ADDRESS MODIFICATION * FUNCTION EXECUTION * * CALLS: * NONE * ****************************** * QUERND EQU $ COPY DEVAD,Q GET DEVICE ADDRESS SHIFT Q,LO,3 SHIFT INTO CORRECT POSITION COPY =-DASIZ,A GET TOTAL NUMBER OF I/O ADDRESSES COPY A,TEMP1 STORE AS COUNT COPY =DAFRST,Y GET TABLE ADDRESS DAADO COPY 0(Y),X GET AN I/O INSTRUCTION ADDRESS COPY =-:F9,A 'AND' OUT THE AND 0(X),A OLD DEVICE ADDRESS OR Q,A 'OR' IN THE NEW DEVICE ADDRESS COPY A,0(X) REPLACE THE INSTRUCTION ADD =1,Y INCREMENT TABLE POINTER IMS TEMP1 AND THE ADDRESS COUNTER JMP DAADO GO FOR MORE * COPY CAR,A GET RUN OPTION WORD AND =:20,A ISOLATE LP ENABLE BIT COPY A,LPFLG PUT IN LP FLAG * COPY MODE,A GET FUNCTION CLSN ='F',A FORMATTER? JMP FMATTR YES, JUMP CLSN ='T',A TECH TEST? JMP TECH YES, JUMP JMP REPASS CONT. TITL SET DRIVE PARAMETER ******************************** * * SET DRIVE PARAMETER * * THIS ROUTINE SETS THE PARAMETERS ON THE * SCOUT WINCHESTER INTERFACE FOR NON-STANDARD * DISK DRIVES. * * CALLS: * DOIO * STATUS * CRE:TBLE * ******************************** * SET:PARA ENT COPY NONSTND,A GET THE NON-STANDARD PARAMETER FLAG JNE A,$+2 JUMP IF WE ARE USING A NON-STANDARD DRIVE JMP STANDARD MUST BE A STANDARD DRIVE SKIP THIS STUFF SET:PARX JST CRE:TBLE GO CREATE THE PARAMETER TABLE JST TIMER RESET THE TIMER JST PREP INITIALIZE THE DISK COPY UCUR,A GET CURRENT UNIT NUMBER COPY =DP:IOB,X COPY A,US(X) SET THE UNIT NUMBER OF THE DRIVE COPY =-1,A COPY A,XF(X) PRESET THE WORDS TRANSFERERD COPY A,CST(X) PRESET CONTROLLER STATUS COPY A,DST(X) PRESET DRIVE STATUS COPY X,ADRIOB PUT THE ADDRESS WERE ALL SHALL KNOW WERE IT IS JST OTX DO THE I/O SBIT 8,S ENABLE INTERRUPTS JST TIME TIME THE I/O JMP $-1 JUMP BACK UNTIL FINISHED OR TIME OUT COPY =:90,A REPORT THE ERRROR JST ERROR JMP ENT IF THIS DON'T WORK NOTHING WILL, GO BACK THE BEGINING * STANDARD EQU $ JMP *SET:PARA CONTINUE * LPOOL * DP:IOB EQU $ WORD DRVPAR,0,0,0,0 WORD :08 WORD BUF WORD STANDARD WORD 0,0,0,0 * LPOOL * TITL CRE:TBLE (CREATE DRIVE PARAMETER TABLE) ****************************** * * CRE:TBLE * * THIS SUB-ROUTINE CREATES THE DRIVE PARAMETER * TABLE FOR THE SET:PARA ROUTINE * ******************************* * CRE:TBLE ENT CREATE THE DRIVE PARAMETER TABLE COPY =BUF,X GET THE ADDRESS OF THE DRIVE PARAMETER TABLE COPY CYLMX,A GET THE MAX NUMBER OF CYLINDERS SUB =1,A COPY A,0(X) SET CYLINDERS PER DISK COPY CYLS,A GET MAX USER CYLINDER NUMBER COPY A,1(X) SET USER CYLINDERS COPY PCMPEN,A GET PRECOMP YES/ON FLAG SHIFT A,LO,8 MOVE PRECOMP FLAG TO UPPER BYTE ADD RWCUREN,A ADD THE REDUCE WRITE CUR. FLAG COPY A,2(X) SET THE PRECOMP AND REDUCED WRITE CUR FLAG COPY PCMP,A GET PRECOMPENSATION CYLINDER COPY A,3(X) SET PRECOMPENSATION CYLINDER COPY RWC UR,A GET REDUCED WRITE CURRENT CYLINDER COPY A,4(X) SET REDUCED WRITE CURRENT CYLINDER COPY BADTRCK,A GET BAD TRACK YES/NO FLAG SHIFT A,LO,8 PUT IN UPPER BYTE ADD STPLSE,A ADD THE STEP PULSE CODE COPY A,5(X) SET BAD TRACK MAPPING AND STEP PULSE CODE COPY HDS,A GET THE # OF HEADS COPY A,6(X) SET # OF HEADS COPY =0,A COPY A,7(X) CLEAR RESERVE WORD JMP *CRE:TBLE * LPOOL * TITL TEST CONTROL (TEST EXECUTION) ****************************** * * INCREMENT AND PRINT PASS NUMBER * INCREMENT AND PRINT UNIT NUMBER * EXECUTE TESTS * * CALLS: * MSGA * ODEC * ****************************** * REPASS EQU $ COPY PASCTR,A GET PASS NUMBER CSK A,=10000 GREATER THAN 10,000? IMS PASCTR NO, INCREMENT PASS NUMBER NOP YES, DON'T INCREMENT JT SS,REUNIT SKIP OUTPUT IF SENSE SWITCH IS SET JST MSGA PRINT 'PASS' MESSAGE WORD PASSMG COPY PASCTR,A GET PASS NUMBER JST ODEC PRINT IT OR '****' REUNIT COPY =UN-1,A PRESET UNIT NUMBER POINTER COPY A,UPTR * NUUNIT IMS UPTR BUMP TO NEXT REQUESTED UNIT COPY UPTR,X SET UNIT POINTER COPY 0(X),A GET UNIT NUMBER JGE A,PRTUNIT PRINT UNIT COPY CAR,A GET RUN OPTIONS SHIFT A,RO,4 CONTINUOUS TESTING? (BIT 3 SET) JF OV,$+2 NO, JUMP JMP REPASS YES, DON'T STOP AT PASS END JST MSGA PRINT 'END OF TEST' MESSAGE WORD EOT JMP ENT1A GO TO QUERIES PRTUNIT EQU $ COPY A,UCUR STORE UNIT NUMBER ADD =SPACE:%8+'0',A SET UNIT NUMBER TO ASCII COPY A,PRUNIT STORE ASCII UNIT NUMBER JST SET:PARA SET THE PARAMETER'S IF NECESSARY JT SS,RETEST SKIP OUTPUT IF SENSE SWITCH IS SET JST MSGA PRINT 'UNIT' MESSAGE WORD UNITMG RETEST COPY =TESTS-1,A PRESET TEST TABLE POINTER COPY A,TPTR STORE POINTER * NUTEST IMS TPTR BUMP POINTER TO NEXT TEST COPY TPTR,X GET POINTER COPY 0(X),X GET TEST NUMBER JLT X,NUUNIT GET NEXT UNIT IF END OF TABLE SBIT 4,S ENABLE CONSOLE INTERRUPT SBIT 8,S ENABLE INTERRUPTS JMP 0(X) DO TEST * NMBBRD EQU $ WORD 1 * LPOOL TITL TEST CONTROL (END OF TESTING) ****************************** * * END OF TEST * OUTPUT ERROR TALLIES * FOR EACH UNIT * * CALLS: *  MSGA * ODEC * ****************************** * TSTEND EQU $ COPY CAR,A GET RUN OPTIONS SHIFT A,RO,3 TALLIES WANTED? (BIT 2 SET) JF OV,NUTEST NO, JUMP JST MSGA YES, PRINT TALLY MESSAGES WORD TALTTL COPY =0,A COPY A,TEMP1 START WITH UNIT 0 TALLY1 COPY =UN,X SET UNIT TABLE POINTER TALLY2 COPY 0(X),A GET UNIT ADD =1,X INCREMENT TABLE POINTER JLT A,TALLY3 JUMP IF END OF TABLE XOR TEMP1,A DOES TABLE ENTRY MATCH SCANNER? JNE A,TALLY2 NO, TRY AGAIN COPY =SPACE:%8+'0',A GET ASCII OFFSET ADD TEMP1,A ADD IN UNIT COPY A,PRUNIT STORE ASCII UNIT NUMBER JST MSGA PRINT UNIT NUMBER WORD UNITMG JST MSGA PRINT 'SOFT ERRORS' MESSAGE WORD SOFTMS COPY TEMP1,X GET UNIT NUMBER ADD =ERR0,X ADD IN ERROR TABLE ADDRESS COPY SOFT0-ERR0(X),A GET SOFT ERROR COUNT JST ODEC PRINT SOFT ERRORS JST MSGA PRINT 'FIRM ERRORS' MESSAGE WORD FIRMS COPY FIRM0-ERR0(X),A GET FIRM ERROR COUNT JST ODEC PRINT ERRORS JST MSGA PRINT 'HARD ERRORS' MESSAGE WORD HARDMS COPY HARD0-ERR0(X),A GET HARD ERROR COUNT JST ODEC PRINT ERRORS JST MSGA PRINT 'TOTAL ERRORS' MESSAGE WORD ALLMS COPY ERR0-ERR0(X),A GET TOTAL ERROR COUNT JST ODEC PRINT ERRORS TALLY3 IMS TEMP1 DO NEXT UNIT COPY TEMP1,A CLSN =UNITS,A DONE ALL UNITS YET? JMP $+2 YES, EXIT JMP TALLY1 NO, DO NEXT ON E JST MSGA PRINT 'PASS' MESSAGE WORD PASSMG COPY PASCTR,A GET PASS NUMBER JST ODEC PRINT PASS NUMBER JMP NUTEST LOOP FOR MORE * LPOOL TITL TEST A - TESTS BASIC STATUS ****************************** * * TEST A - TESTS BASIC STATUS * *  TEST A TESTS BASIC STATUS USING THE * TIO OPCODE WITH AND WITHOUT * INTERRUPTS * * CALLS: CALLED BY: * TSTITL TEST CONTROL (TEST EXECUTION) * PREP * RYINIT * MKIOB * DOIO * STATUS * RETRY * ******************************* * TESTA EQU $ TEST A - BASIC STATUS TEST COPY ='A',A PRINT TEST A TITLE JST TSTITL JST SALTEST CHECK SAL INSTRUCTION JST PREP INITIALIZE COPY =TAIOB,X INDEX IOB COPY =TIO,A STORE OPCODE COPY A,OP(X) COPY =0,A NO INTERRUPTS COPY A,IN(X) JST RYINIT RESET RETRIES WORD TESTA1 WORD TESTA2 JST MKIOB SET UP IOB JST DOIO DO I/O TESTA1 JST MKIOB SET UP IOB AGAIN  JST DOIO DO I/O AGAIN JST STATUS CHECK STATUS AFTER SECOND TIO JST RETRY RETRY IF ERROR TESTA2 COPY =INTLOC,A SET UP INT LOC TO IOB COPY A,IN(X) JST RYINIT RESET RETRIES WORD TESTA3 WORD TESTA4 TESTA3 JST MKIOB SET UP IOB JST DOIO DO I/O JST STATUS CHECK STATUS JST RETRY RETRY ON ERROR TESTA4 JMP TSTEND EXIT * TAIOB WORD TIO  TEST A IOB RES 4,0 WORD 0,BUF RES 5,0 * LPOOL TITL TEST B - TESTS SEEK ****************************** * * TEST B - TESTS SEEK FUNCTIONS * * TEST B TESTS THE BASIC FUNCTION OF * THE SEEK . ALSO TESTS CASE SEEKS, * 'SEEK ERROR' TESTING. * * CALLS: CALLED BY: * TSTITL TEST CONTROL (TEST EXECUTION) * PREP * MKIOB * TESTB1 * RANDOM * RYINIT * DOIO * OTA * SENRDY * TB5J * RETRY * DINIT * ERROR * STATUS * NXTHDR * CRC * ERSET * MSGA * TSTB1F * OHEX * OTTY * DUMP * ****************************** * TMP:B1 RES 1,0 TEMPORARY CELL * TESTB EQU $ COPY ='B',A PRINT TEST B TITLE JST TSTITL JST SALTEST CHECK SAL INSTRUCTION JST PREP RESET DMA ADDRESS, DISK COPY =0,A TO CYL 0 JST TESTB1 DO I/O COPY CYLS,A SEEK TO LAST CYL SUB =1,A JST TESTB1 DO SEEK COPY =-400,X PRESET FOR 400 RANDOM SEEKS COPY SHORTC,A GET SHORT TEST CYL. JEQ A,$+2 NO, SHORT TESTING NEG A,X NEGATE COPY X,TEMP1 STORE RANDOM SEEK NUMBER COPY =1,A INITIALIZE RANDOM RTNE COPY A,SEED TESTB3 COPY TEMP1,A SET RUN INDICATOR NEG A,A OR =:2000,A SELP A,4 COPY =-1,X GET A RANDOM NO JST RANDOM FOR CYL NO CSK A,CYLS WITHIN RANGE? JMP TESTB2 YES, USE IT NOP JMP TESTB3 NO, GETANOTHERONE TESTB2 JST TESTB1 DO SEEK IMS TEMP1  BUMP 400 COUNTER JMP TESTB3 DO NEXT SEEK TB2B COPY =0,A COPY A,TEMP1 SET UP WORST CASE SEEK COPY CYLS,A TEMP1=UP COUNT SUB =1,A COPY A,TEMP2 TEMP2=DOWN COUNT ADD =1,A RESTORE NUMBER COPY SHORTC,X GET SHORT TEST CYLS. JEQ X,$+2 IF NONE, JUMP COPY X,A PUT INTO X NEG A NEGATE COPY A,TMP:B1 STORE CYLINDER COUNT TESTB4 COPY TEMP1,A SET RUN IN D OR =:2000,A SELP A,4 COPY TEMP1,A SEEK TO OUTSIDE JST TESTB1 COPY TEMP2,A SEEK TO INSIDE JST TESTB1 IMS TEMP1 BUMP UP COUNTER COPY TEMP2,A BUMP DOWN COUNTER SUB =1,A COPY A,TEMP2 IMS TMP:B1 INCREMENT CYLINDER COUNT JMP TESTB4 IF NOT DONE, GO BACK FOR MORE JMP TSTEND NEXT TEST LPOOL TITL TEST B SUBROUTINES (TESTB1) ****************************** * * TESTB1 - SEEK I/O * * THIS SUBROUTINE IS USED BY TEST B * TO DO THE SEEK TESTING. * * CALLING SEQUENCE: * COPY =SEEK CYLINDER,A * JST TESTB1 * * CALLS: CALLED BY: *  RYINIT TESTB * MKIOB * DOIO * STATUS * RETRY * FILCON * NXTHDR *  CRC * ERROR * ERSET * MSGA * TSTB1F * ****************************** * TESTB1 ENT TEST B I/O CALLER COPY A,CCUR STORE REQUESTED SEEK CYL COPY =TBIOB2,X SET UP SEEK IOB COPY =SEEK,A SET SEEK FC COPY A,OP(X) JST RYINIT RESET RETRIES WORD TSTB11 WORD TSTB12 TSTB11 EQU $ JST MKIOB JST DOIO DO THE SEEK JST STATUS TSTB14 JST RETRY RETRY TSTB12 EQU $ COPY =0,A COPY A,SCUR JMP *TESTB1 EXIT $$$ * LPOOL TITL TEST B TABLES AND IOBS * TBIOB2 WORD SEEK RES 6,0 WORD INTLOC RES 4,0 * * TITL TEST C - FORMAT FUNCTION TESTING ****************************** * * TEST C - FORMAT FUNCTION TESTING * * FORMAT 1 SECTOR - SHOULD COMPLETE WITHOUT ERROR * TEST SECTOR OVERRUN - SHOULD GET FORMAT ERROR * TEST TRACK OVERRUN - SHOULD GET FORMAT ERROR * * FORMAT TESTING IS DONE ON EACH TRACK AS FOLLOWS: * A FORMAT FUNCTION IS ISSUED TO EACH TRACK IN * STANDARD CAI FORMAT, FOR A LENGTH OF TWO TRACKS. * THEN A READ VERIFY OPERATION IS DONE TO *  THE FIRST TRACK, FOR A LENGTH OF TWO TRACKS. * * OVERRUN TESTING USE'S 4094 WORDS IN 3 SECTORS. * * THIS TEST IS NOT RUN IF NONDESTRUCTIVE TESTING * IS REQUESTED. * * CALLS: CALLED BY: * TSTITL  TEST CONTROL (TEST EXECUTION) * PREP * RYINIT * MKIOB * DOIO * STATUS * RETRY * ERROR * INCRH * FMBLDC * MOVE * TESTC4 * COMPAR * CRC * ERSET *  DUMP * ****************************** * TMP:C1 RES 1,0 TEMPORARY CELL TMP:C2 RES 1,0 TEMPORARY CELL * TESTC EQU $ TEST C - FORMAT TEST COPY ='C',A PRINT TEST C TITLE JST TSTITL JST SALTEST CHECK THE SAL INSTRUCTION COPY NONDES,A  NONDESTRUCTIVE? JEQ A,$+2 NO JMP TSTEND YES, DONT RUN IT COPY SHORTC,A GET SHORT TEST CYLS. JNE A,$+3 IF SHORT TESTING, JUMP JST TEST:C DO TEST C OVER FULL RANGE JMP TSTEND EXIT TEST COPY ECYL,A GET ENDING CYL. NUMBER COPY A,TMP:C1 SAVE IT  COPY SCYL,A GET STARTING CYL. NUMBER COPY A,TMP:C2 SAVE IT ADD SHORTC,A ADD IN SHORT TEST CYLS. SUB =1,A DECREMENT ONCE COPY A,ECYL STORE NEW ENDING CYL. NUMBER JST TEST:C DO TEST C COPY TMP:C1,A GET ENDING CYL. NUMBER COPY A,ECYL STORE ENDING CYL. NUMBER SUB SHORTC,A GENERATE STARTING CYL. NUMBER ADD =1,A INCREMENT ONCE COPY A,SCYL STORE NEW STARTING CYL. NUMBER JST TE ST:C DO TEST C COPY TMP:C2,A GET OLD STARTING CYL. NUMBER COPY A,SCYL STORE VALUE JMP TSTEND * LPOOL TITL * TEST:C ENT START OF TEST C COPY WDS,A COPY SECS,X TC60A COPY A,TCWDS COPY X,TCSECS JST PREP INITIALIZE DISK TC73 EQU $ COPY SECS,A COPY A,TCSECS COPY UCUR,A STORE UNIT NO COPY A,TCIOB1+US COPY A,TCIOB2+US COPY  A,TCIOB3+US COPY A,TCIOB4+US TESTC1 COPY =-2,A COUNT 2 TRACKS COPY A,TEMP1 COPY =TCIOB1,X INDEX IOB COPY CCUR,A COPY A,CS(X) OR =:3000,A OUTPUT A RUN INDICATOR SELP A,4 COPY HCUR,A GET CURRENT HEAD COPY A,HS(X)  COPY TCSECS,A GET SECTORS/TRACK SHIFT A,LO,1 DOUBLE IT COPY A,WC(X) TO FORMAT 2 TRACKS COPY TCSECS,A GET SECTORS/TRACK SHIFT A,LO,2 TIMES 4 ADD TCSECS,A TIMES 5--EACH SECTOR BLOCK COPY A,TEMP3 REQUIRES FIVE WORDS TSTC1X COPY CCUR,A BUILD COPY A,FMCS FORMAT BUFFER COPY A,FMCN COPY HCUR,A COPY A,FMHS COPY A,FMHN JST INCRH BUMP HEAD/CYL JMP TSTC2X CONTINUE JMP *TEST:C EXIT TEST * LPOOL TITL TSTC2X COPY CCUR,A COPY A,FMCL COPY HCUR,A COPY A,FMHL COPY TEMP1,X SET UP BUF PTR NEG X,X COPY =BUF,A BUF FOR FIRST TRACK  ADD TEMP3,A BUF+TEMP3 FOR SECOND TRACK CLSN =2,X SUB TEMP3,A FIRST TRACK COPY A,X JST FMBLDC BUILD FORMAT BUFFER * * ALTERNATE ENTRY POINT * IMS TEMP1 BUMP 2-TRACK COUNTER JMP TSTC1X DO SECOND TRACK COPY =TCIOB1,X INDEX IOB JST RYINIT RESET RETRIES WORD TESTC7 TESTC7 DATA GOES HERE WORD TESTC8 TESTC8 DATA GOES HERE TESTC7 EQU $ JST DOIO DO FORMAT 2 TRACKS JST STATUS CHECK STATUS JST RETRY RETRIES TESTC8 EQU $ COPY =-4,A JST MOVE AND TO VERIFY IOB WORD TCIOB1+US WORD TCIOB4+US COPY =SAVBUF,A BUILD COMPARE BUFFER COPY A,TEMP2 COPY TCSECS,A SUB =1,A NEG A,A COPY A,TEMP1 NEG NUMBER OF WORD CHAIN IOBS COPY =TCLINK-1,X GET WORD CHAIN IOB TABLE ADD-1 JMP TESTC3 * LPOOL TITL TESTC3 EQU $ TC3D EQU $ COPY =TCIOB4,X INDEX VERIFY IOB COPY TCSECS,A NEG A,A COPY A,TCTEMP NEG NUMBER OF SECTORS/TRACK COPY =0,A TC3G ADD TCWDS,A SECTORS/TRACK  IMS TCTEMP TIMES WDS/SECTOR JMP TC3G GIVES WDS/TRACK SHIFT A,LO,1 DOUBLE IT FOR 2 TRACKS COPY A,WC(X) TO IOB WORD COUNT JST RYINIT RESET RETRIES WORD TC3E WORD TC3F TC3E EQU $ JST DOIO VERIFY 2 TRACKS JST STATUS CK STATUS JST RETRY RETRY TC3F JMP TESTC1 DO NEXT TRACK * LPOOL TITL TEST C TABLES AND IOBS * TCWDS WORD 0  WDS/SECTOR TCSECS WORD 0 SECTORS/TRACK * TCIOB1 WORD FRMT TWO TRACK FORMAT IOB RES 5,0 WORD BUF,INTLOC RES 4,0 * TCIOB2 WORD 0 SECOND TRACK RES 4,0 READ REGARDLESS IOB WORD 7,SAVBUF FOR 7 WDS/SECTOR WORD INTLOC,TCLINK RES 3,0 * TCIOB3 WORD 0 FIRST TRACK RES 5,0 READ REGARDLESS IOB FOR WORD SAVBUF 1-FULL SECTOR WORD INTLOC RES 4,0 * TCIOB4 WORD RDVER READ VERIFY IOB FOR RES 6,0 2 TRACKS WORD INTLOC RES 4,0 * TCLINK RES 220,0 WORD CHAIN IOB TABLE * TITL TEST D - SHORT WORD TRANSFER TEST ****************************** * * TEST D - S HORT WORD TRANSFER TEST * * TEST D PERFORMS WRITE/READ/VERIFY OPERATIONS IN * SEQUENTIAL SECTOR ORDER, USING THE WORST * CASE PATTERN AS DATA ON THE FIRST AND LAST * 10 CYLINDERS ONLY. THE LENGTH OF EACH I/O *  IS ONE SECTOR FOR THE OUTSIDE CYLINDERS AND * TWO SECTORS FOR THE INSIDE CYLINDERS. * * THE TWO-SECTOR I/O IS PERFORMED WITH THESE * DATA-CHAINED WORD COUNTS: * * CIOB (WDS * 2) * .75 (MORE THAN 1 SECTOR) *  DCIOB (WDS * 2) * .25 (LESS THAN 1 SECTOR) * * CALLS: CALLED BY: * TSTITL TEST CONTROL (TEST EXECUTION) * PREP * TESTD1 * INCR * ****************************** * TMP:D1 RES 1,0 TEMPORARY CELL TMP:D2 RES 1,0 TEMPORARY CELL * TESTD EQU $ COPY ='D',A PRINT TITLE JST TSTITL JST SALTEST TEST THE SAL INSTRUCTION COPY SHORTC,A GET SHORT TEST CYLS. JEQ A,TESTDA IF NONE, JUMP COPY ECYL,A GET ENDING CYL. NUMBER COPY A,TMP:D1 STORE VALUE COPY SCYL,A GET STARTING CYL. NUMBER COPY A,TMP:D2 SAVE NUMBER ADD SHORTC,A ADD IN SHORT TEST CYL. OFFSET SUB =1,A DECREMENT ONCE COPY A,ECYL STORE NEW ENDING CYL. NUMBER JST PREP SET UP DISK TEST:D1 JST TESTD1 DO TEST JST INCR INCREMENT CYLINDER NUMBER JMP TEST:D1 IF NOT DONE, DO MORE COPY TMP:D1,A GET OLD ENDING CYL. NUMBER COPY A,ECYL RESTORE VALUE SUB SHORTC,A GENERATE NEW STARTING CYL. NUMBER ADD =1,A INCREMENT ONCE COPY A,SCYL STORE NEW STARTING CYL. NUMBER COPY A,CCUR SET STARTING CYLINDER TEST:D2 JST TESTD1 DO TEST JST INCR INCREMENT CYLINDER NUMBER JMP TEST:D2 IF NOT DONE, DO MORE COPY TMP:D2,A GET STARTING CYL. NUMBER COPY A,SCYL RESTORE NUMBER JMP TSTEND EXIT TEST * TESTDA JST PREP SET UP DISK JST TESTD1 TEST ONE SECTOR JST INCR BUMP DMA ADDR JMP $+2 NOT DONE YET JMP TSTEND DONE, EXIT COPY =10,A SEE IF TESTING CYL 10 CSK A,CCUR JMP TESTDA+1 NO JMP TESTDA+1 NO COPY =-9,A YES, DO LAST 10 NOW ADD ECYL,A COPY A,CCUR  JMP TESTDA+1 CONTINUE TITL TEST I - SAME AS TEST D,EXCEPT ALL CYLS ****************************** * * TEST I - LONG WORD TRANSFER TEST * * TEST I IS THE SAME AS TEST D, EXCEPT * ALL REQUESTED CYLINDERS ARE TESTED. * * CALLS:  CALLED BY: * TSTITL TEST CONTROL (TEST EXECUTION) * PREP * TESTD1 * INCR * ******************************* * TESTI EQU $ COPY ='I',A PRINT TEST TITLE JST TSTITL JST SALTEST CHECK THE SAL INSTRUCTION TESTI1 JST PREP INITIALIZE STUFF JST TESTD1 CALL SECTOR TEST ROUTINE JST INCR BUMP DMA ADDR JMP $-2 CONTINUE JMP TSTEND EXIT * LPOOL TITL TEST D1 - SINGLE SECTOR TEST ROUTINE ****************************** * *  TEST D1 - SINGLE SECTOR TEST ROUTINE. * * COMMON TO BOTH TEST D AND TEST I. * * CALLS: CALLED BY: *  NXTHDR TESTD * TESTD4 TESTI * FILCON * RYINIT * TD4C *  COMPAR * ERROR * ERSET * DUMP * RETRY * MKIOB * DOIO * STATUS * ******************************* * TESTD1 ENT COPY TCUR,A OUTPUT TEST NO TO LIGHTS SHIFT A,LO,8 SHIFT A,LO,4 OR CCUR,A  ALSO CURRENT CYL NO SELP A,4 COPY WDS,A SHIFT A,LO,1 DOUBLE WORD COUNT COPY A,TEMP1 SHIFT A,LO,1 DOUBLE THIS QUABTITY ADD WDS,A TIMES 3 SHIFT A,RO,2 DIVIDE BY 4 COPY A,WC1 CIOB WORD COUNT COPY TEMP1,A DIFFERENCE BETWEEN DOUBLE WC SUB WC1,A AND CIOB WC COPY A,WC2 IS DCIOB WORD COUNT JST NXTHDR CALCULATE NEXT DMAADDR COPY CNEXT,A IF NEGATIVE, JGE A,$+2 JMP *TESTD1 THEN WERE DONE COPY ECYL,A CALCULATE WHETHER ITS SUB SCYL,A INSIDE OR OUTSIDE CYL COPY A,TEMP1 COPY CCUR,A SHIFT A,LO,1 MULT BY TWO SUB TEMP1,A DETERMINE WHICH SIDE JGE A,TESTD7 OF THE DISK WE'RE ON COPY WDS,A OUTSIDE. 1 SECTOR COPY A,TDIOB1+WC COPY A,TDIOBS+WC COPY =0,A COPY A,TDIOB1+NB AND NO WORD CHAIN JMP TESTD8 CONTINUE TESTD7 COPY WC1,A INSIDE. 2 SECTORS COPY A,TDIOB1+WC COPY WDS,A SHIFT A,LO,1 DOUBLE WORD COUNT COPY A,TDIOBS+WC TO SAVE 2 SECTORS COPY WC2,A  COPY A,TDIOB2 DCIOB WD CNT COPY =TDIOB2,A WORD CHAINING COPY A,TDIOB1+NB COPY =TDIOB2,X COPY =BUF,A ADD WC1,A GET MEM ADDR COPY A,1(X) FOR DCIOB TESTD8 COPY NONDES,A SAVE USER AREA? JEQ A,TESTD3 NO COPY =TDIOBS,X YES, SAVE IT COPY =RDDAT,A READ IT IN JST TESTD4 PERFORM THE I/O TESTD3 COPY WCPAT,A SPREAD PATTERN FOR WRITE JST FILCON COPY =TDIOB1,X INDEX WRITE IOB COPY =WRTDAT,A JST TESTD4 DO THE WRITE COPY =RDVER,A JST TESTD4 DO THE VERIFY COPY =0,A CLEAR THE BUFFER FOR READ JST FILCON COPY =RDDAT,A COPY A,OP(X) STORE OPCODE JST RYINIT RESET RETRIES WORD TD3A WORD TD3B TD3A JST TD4C COPY =BUF,A DO WORD COMPARE NOW COPY A,MISCAD SET COMPARE ADDR COPY WCPAT,A AND EXPECTED DAT COPY A,EXP COPY TDIOBS+WC,A GET LENGTH NEG A,A JST COMPAR JMP TESTD5 MISCOMPARE JMP TESTD6 CONTINUE TESTD5 EQU $ COPY =40,A PRINT MISCOMP ERROR JST ERROR JST ERSET JMP TESTD6 COPY =BUF,X DO BUFFER DUMP IF WANTED COPY TDIOBS+WC,A NEG A,A SET LENGTH JST DUMP TESTD6 JST RETRY RETRY ON ERROR TD3B COPY NONDES,A SEE IF SAVING JEQ A,TSTD6A NO COPY =TDIOBS,X YES, RESTORE IT TO DISK COPY =WRTDAT,A JST TESTD4 DO THE WRITE TSTD6A JMP *TESTD1 EXIT * LPOOL TITL TEST D1 SUBROUTINES (TESTD4) ****************************** * * TESTD4 - RETRY I/O * * THIS SUBROUTINE WILL RESET RETRY *  ADDRESSES AND RETRY THE I/O OPERATION. * * CALLING SEQUENCE: * COPY =OP CODE,A * JST TESTD4 * * CALLS: CALLED BY: * RYINIT TESTD1 * TD4C * RETRY * ****************************** * TESTD4 ENT COPY A,OP(X) STORE OPCODE JST RYINIT RESET RETRIES WORD TD4A WORD TD4B TD4A JST TD4C DO I/O JST RETRY RETRY ON ERROR TD4B JMP *TESTD4 EXIT TITL TEST D1 SUBROUTINES (TD4C) ****************************** * * TD4C - DO TEST D1 I/O * * THIS SUBROUTINE IS USED TO * DO TEST D1 I/O OPERATIONS. * * CALLING SEQUENCE: * JST TD4C * * CALLS: CALLED BY: * MKIOB TESTD4 * DOIO   TESTD1 * STATUS * ERROR * ****************************** * TD4C ENT I/O ROUTINE JST MKIOB BUILD IOB  JST DOIO DO THE I/O JST STATUS CHECK STATUS COPY CCUR,A SEE IF IOB DMA ADDR XOR CS(X),A HAS CHANGED JNE A,TSTD4D YES, ERROR COPY HCUR,A XOR HS(X),A JNE A,TSTD4D COPY SCUR,A XOR SSS(X),A JEQ A,TSTD4C OK TSTD4D EQU $ COPY =41,A JST ERROR DMA ADDR CHANGED TSTD4C JMP *TD4C EXIT * LPOOL TITL TEST D1 IOBS * TDIOB1 RES 5,0 TEST D I/B WORD 0 WORD COUNT WORD BUF WORD INTLOC WORD TDIOB2 CHAINED TO TDIOB2 RES 3,0 * TDIOB2 WORD 0 WORD CHAIN IOB WORD 0 WORD 0,0 * TDIOBS RES 5,0 USER SAVE IOB WORD 0 WD COUNT WORD SAVBUF INTO SAVBUF WORD INTLOC RES 4,0 * WC1 WORD 0 FIRST WD COUNT WC2 WORD 0 SECOND WD COUNT TITL TEST E - RANDOM I-O TEST ****************************** * * TEST E - RANDOM I/O TEST * * THE RANDOM NUMBER GENERATOR IS USED TO * DETERMINE THE CYLINDER, HEAD, SECTOR * AND DATA LENGTH TO BE USED IN THE * TEST. THE DATA WRITTEN IS AN INCREMENTING * PATTERN WITH THE FIRST WORD EQUAL TO THE * CYLINDER NUMBER. USING THIS PATTERN AND * DMA ADDRESS, WRITE AND READ/VERIFY FUNCTIONS * ARE PERFORMED. THEN A READ IS PERFORMED FOR * THE RANDOM DATA LENGTH. A SECOND READ IS * PERFORMED FOR A FULL SECTOR TO VERIFY UNUSED * SECTOR (FILLED WITH :6DB6). THIS READ * CONSISTS OF A TEN WORD SKIP FUNCTION CHAINED * TO A DATA-CHAIN IOB CONTAINING THE REMAINDER * WORD COUNT. EACH I/O FUNCTION IS ISSUED USING * THE 'RETURN NEXT DMA ADDRESS' FEATURE, WHICH *  IS VERIFIED. * * THIS IS DONE FOR ALL REQUESTED CYLINDERS. * * CALLS: CALLED BY: * TSTITL  TEST CONTROL (TEST EXECUTION) * PREP * MASK * RANDOM * TESTE4 * FILINC *  TESTEC * FILCON * RYINIT * TE4C * COMPAR * RETRY * ERROR * ERSET * DUMP * MKIOB * DOIO * STATUS * NXTHDR * ***************************** * TESTE EQU $ COPY ='E',A PRINT TEST E TITLE JST TSTITL JST SALTEST CHECK THE SAL INSTRUCTION COPY SCYL,A CALCULATE PASSES SUB ECYL,A THROUGH THIS SUB =1,A COPY SHORTC,X GET SHORT TEST CYLS. JEQ X,$+2 IF NO, JUMP NEG X,A NEGATE COPY A,TEMP1 JST PREP SET DISK, DMA ADDR COPY =1,A PRESET RANDOM COPY A,SEED NO.GENERATOR TESTE1 COPY TEMP1,A SET RUN INDICATOR NEG A,A OR =:5000,A SELP A,4 COPY CYLS,A JST MASK GET CYLINDER MASK COPY X,TEMP2 TESTEF JST RANDOM GET CYL NO AND TEMP2,A MASK OFF UNWANTED BITS CSK A,CYLS JMP CHECK1 MAKE RANGE CHECK SUB CYLS,A DECREASE SUB =1,A SIZE CHECK1 CSK A,ECYL WITHIN RANGE? CSK A,SCYL JMP TESTEF NO, TRY AGAIN NOP COPY A,CCUR STORE CURRENTCYL COPY HDS,A JST MASK GET HEAD MASK COPY X,TEMP2 TESTE2 JST RANDOM GET HEAD NO AND TEMP2,A MASK OFF UNWANTED BITS CSK A,HDS JMP CHECK2 MAKE RANGE CHECK SUB HDS,A DECREASE SUB =1,A SIZE CHECK2 CSK A,EHD   WITHIN RANGE? CSK A,SHD JMP TESTE2 NO NOP COPY A,HCUR YES, SAVE IT COPY SECS,A JST MASK GET SECTOR MASK COPY X,TEMP2 TESTE3 JST RANDOM GET SECTOR NO AND TEMP2,A MASK OFF UNWANTED BITS CSK A,SECS JMP CHECK3 MAKE RANGE CHECK SUB SECS,A DECREASE SUB =1,A SIZE CHECK3 CSK A,ESEC WITHIN RANGE CSK A,SSEC JMP TESTE3 NO  NOP COPY A,SCUR OK COPY NONDES,A SAVE USER STUFF? JEQ A,TESTE5 NO COPY =TEIOBS,X YES, READ IT IN COPY WDS,A COPY A,WC(X) COPY =RDDAT;UPDATE,A JST TESTE4 TESTE5 COPY X,TEMP5 COPY =BUF,A COPY A,TTBUF ADD =2,A COPY A,TTBUF+1 COPY =1,X COPY CCUR,A THE FIRST WORD WORD OF A SECTOR COPY A,TEMP2 IS THE CYLINDER NUMBER JST FILINC SPREAD THE PATTERN COPY TEMP5,X COPY WDS,A JST MASK GET WORD MASK COPY X,TCTEMP TESTE7 JST RANDOM GET WORD LENGTH AND TCTEMP,A MASK OFF UNWANTED BITS JEQ A,TESTE7 CAUTION: DON'T USE 0 WORD CT CSK A,WDS  WITHIN RANGE? JMP TESTE8 YES JMP TESTE7 NO TESTE8 COPY =TEIOB1,X INDEX IOB COPY A,TEMP3 SAVE WORD LENGTH COPY A,WC(X) COPY =WRTDAT;UPDATE,A JST TESTE4 DO WRITE OP COPY =RDVER;UPDATE,A JST TESTE4 DO VERIFY OP  JST TESTEC DO READ OP, PARTIAL SEC COPY =TEIOB3,X INDEX 4-WORD WORD CHAIN COPY WDS,A SUB =10,A COPY A,TEMP4 COPY A,0(X) STORE WORD COUNT (WORD 0) COPY =TEIOB2,X INDEX CHAINED IOB JST TESTEC NOW ODO FULL SECTOR READ  COPY NONDES,A SAVE USER STUFF? JEQ A,TESTE6 NO COPY =TEIOBS,X YES COPY =WRTDAT;UPDATE,A JST TESTE4 WRITE IT BACK OUT TESTE6 IMS TEMP1 BUMP COUNTER JMP TESTE1 JMP TSTEND EXIT * LPOOL TITL TEST E SUBROUTINES (TESTEC) ****************************** * * TESTEC - READ/DATA COMPARE * * THIS SUBROUTINE IS USED BY TEST E * TO DO A READ OPERATION THEN * COMPARE THE DATA FOR A MISMATCH. * * CALLING SEQUENCE: * COPY =IOB ADDRESS,X *  JST TESTEC * * CALLS: CALLED BY: * FILCON TESTE * RYINIT * TE4C *  COMPAR * RETRY * DUMP * ****************************** * TESTEC ENT READ/WORD COMP ROUTINE COPY =0,A CLEAR BUF JST FILCON COPY =RDDAT;UPDATE,A COPY A,OP(X) STORE OPCODE JST RYINIT RESET RETRIOES WORD TE4E WORD TE4F TE4E JST TE4C DO READ COPY WC(X),A IF SKIP BIT NOT ON, JGE A,TE4G ITS PARTIAL READ COPY =BUF,A ELSE ITS A FULL READ COPY A,MISCAD FOR WHICH THE FIRST TEN COPY =0,A WORDS ARE ZERO COPY A,EXP COPY =-10,A COMPARE FIRST TEN WORDS JST COMPAR FOR ZERO JMP TESTEE MISCOMPARE COPY =10,A IS RANDOM LENGTH 10 SUB TEMP3,A OR LESS? JLT A,TE4J NO COPY TEMP4,X YES,NEXT TEMP4 WORDS SHOULD BE NEG X,X JMP TE4H 4294 TE4J COPY =10,A COMPARE RANDOM PATTERN ADD TEMP2,A PLUS 10 COPY A,EXP COPY TEMP3,A FOR A LENGTH OF  SUB =10,A TEMP3-10 JST COMPAR JMP TESTEE MISCOMPARE COPY TEMP4,A NOW COMPARE THE NEXT NEG A,A ADD TEMP3,A TEMP4-(TEMP3-10) WORDS SUB =10,A FOR 4294 JEQ A,TESTED COPY A,X JMP TE4H TE4G COPY =BUF,A PARTIA L READ COMPARE. COPY A,MISCAD COMPARE FIRST TEMP3 WDS COPY TEMP2,A OF TEMP2 PATTERN COPY A,EXP COPY TEMP3,A JST COMPAR JMP TESTEE MISCOMPARE COPY =0,A NOW COMPARE REMAINEDER COPY A,EXP SHOULD BE ZERO. COPY WDS,A NEG A,A ADD TEMP3,A JEQ A,TESTED JMP TE4M TE4H COPY =TSTCEPAT,A SET EXP PATTERN COPY A,EXP COPY X,A SET LENGTH COPY ADRIOB,X RESTORE IOB ADDR TE4M EQU $ JST COMPAR JMP TESTEE MISCOMPARE TESTED JST RETRY RETRY ON ERROR TE4F JMP *TESTEC EXIT TESTEE EQU $ COPY =50,A WORD MISCOMPARE JST ERROR JST ERSET  JMP TESTED COPY =BUF,X COPY WDS,A DO BUFF DUMP NEG A,A JST DUMP JMP TESTED * LPOOL TITL TEST E SUBROUTINES (TESTE4) ****************************** * * TESTE4 - RETRY I/O * * THIS SUBROUTINE IS USED BY TEST E *  TO RETRY AN I/O OPERATION. * * CALLING SEQUENCE: * COPY =OP CODE,A * JST TESTE4 * * CALLS:  CALLED BY: * RYINIT TESTE * TE4C * RETRY * ****************************** * TESTE4 ENT COPY A,OP(X) STORE OPCODE JST RYINIT RESET RETRIES WORD TE4A WORD TE4B TE4A JST TE4C DO I/O JST RETRY RETRY ON ERROR TE4B JMP *TESTE4 EXIT TITL TEST E SUBROUTINES (TE4C) ****************************** * * TE4C - DO I/O * * THIS SUBROUTINE IS USED BY TEST E * TO DO THE I/O OPERATION. * * CALLING SEQUENCE: * COPY =IOB ADDRESS,X * JST TE4C * * CALLS: CALLED BY: * MKIOB TESTE * DOIO  TESTEC * STATUS TESTE4 * NXTHDR * ERROR * ****************************** * TE4C  ENT JST MKIOB BUILD IOB JST DOIO DO I/O JST STATUS CK STATUS JST NXTHDR SEE WHAT NEXT DMA ADDR COPY CNEXT,A SHOULD BE, THEN COMPARE XOR CS(X),A IT TO THE IOB JNE A,TSTE4A MISCOMPARE COPY =:FF,A AND HNEXT,A NOW DO THE HEAD NO XOR HS(X),A JNE A,TSTE4A MISCOMPARE COPY =:FF,A NOW DO SECTOR NO XOR SSS(X),A AND SNEXT,A JEQ A,TSTE4B OK TSTE4A COPY =51,A IOB NOT UPDATED JST ERROR CORRECTLY TSTE4B JMP *TE4C EXIT * LPOOL TITL TEST E IOBS * TEIOB1 RES 6,0 TEST E IOB WORD BUF WORD INTLOC RES 4,0 * TEIOBS RES 6,0 TEST E SAVE IOB WORD SAVBUF WORD INTLOC RES 4,0 * TEIOB2 RES 5,0 CHAINED READ IOB WORD :800A SKIP TEN WORDS WORD BUF  WORD INTLOC WORD TEIOB3 RES 3,0 * TEIOB3 WORD 0 WORD CHAIN IOB WORD BUF+10 WORD 0,0 TITL TEST F - INITALIZE TESTING/ ****************************** * * TEST F - INITIALIZE TEST * * THIS TEST VERIFIES THAT AN INITIALIZE (SELP R,DA;4) * FUNCTION, ISSUED BEFORE A PREVIOUS OPERATION * HAS TERMINATED, WILL ABORT THE OPER- * ATION AND RESET THE I/O INTERRUPT. * * THIS IS DONE AS FOLLOW: * * THIS IS DONE BY ISSUING A READ * FUNCTION TO THE INSIDE CYLINDER. AN * INITIALIZE IS ISSUED BEFORE THE READ HAS * COMPLETED. THEN A TIMEOUT IS ENTERED TO * ALLOW SUFFICIENT TIME TO TERMINATE. AN * ERROR IS REPORTED IF AN I/O INTERRUP T * SUBSEQUENTLY OCCURS, OR IF THE INPUT BUFFER * IS ALTERED. * * CALLS: CALLED BY: * TSTITL TEST CONTROL (TEST EXECUTION) * PREP * RYINIT * MKIOB * FILCON * TIMER * OTX * SEL * TIME * ERROR * ERSET * TSTB1F * RETRY * ****************************** * TESTF EQU $ TEST F - INITIALIZE TEST COPY ='F',A PRINT TEST F TITLE JST TSTITL JST SALTEST CHECK THE SAL INSTRUCTION JST PREP RESET DMA ADDR, DRIVE COPY =TFIOB,X INDEX IOB JST RYINIT RESET RETRIES WORD TF3 WORD TF6 TF3 EQU $ SBIT 8,S COPY =RDDAT,A COPY A,OP(X) JST MKIOB SET UP RESTOF IOB COPY =-1,A FILL BUF WITH FFFF JST FILCON JST TIMER RESET TIME CONSTANTS JST OTX SELECT RD DATA JST SEL INITIALIZE JST TIME TIME OUT JMP $-1 JMP TF5 OK, NO INTERRUPT TFINT EQU $ INT PT JST $+1 SERVICE INTERRUPT  NOP COPY =60,A INTERRUPTED AFTER INIT JST ERROR TF5 EQU $ COPY CST(X),A GET STATUS ADD =1,A SHOULD BE UNCHANGED JEQ A,TF1 (FFFF) COPY =61,A ERROR. STATUS CHANGED JST ERROR SAY SO TF1 COPY =BUF,X CHECK BUFFER. SHOULD BE COPY 0(X),A UNCHANGTED (FFFF) AND 1(X),A AND 2(X),A AND 3(X),A AND 4(X),A ADD =1,A JEQ A,TESTF2 OK COPY =62,A ERROR. BUF ALTERED JST ERROR JST ERSET JMP TESTF2 COPY CAR,A SEE IF ERRORS WANTED SHIFT A,RO,2 JT OV,TESTF2 NO JST MSGA YES, DISPLAY ACTUAL HDR WORD ACTHDM COPY =BUF,A INDEX HDR BUFFER * JST TSTB1F PRINT ITOUT TESTF2 JST RETRY RETRY ON ERROR TF6 JMP *$+1 WORD TSTEND EXIT * TFIOB RES 5,0 RD DATA IOB WORD 5 LENGTH OF HEADER WORD BUF WORD TFINT INT LOC RES 4,0 * LPOOL TITL TEST G - FORCED ERRORS TEST ****************************** * * TEST G - FORCED ERRORS TEST. * * THE FOLLOWING ERRORS ARE FORCED: * *  ILLEGAL OPERATION (:7FFF) * END OF MEDIA (NOT RUN IF SHORT TEST REQUESTED) * * CALLS: CALLED BY: * TSTITL TEST CONTROL (TEST EXECUTION) * PREP * RYINIT * MKIOB * DOIO * ERROR * RETRY * ****************************** * TESTG EQU $ TEST G - FORCED ERRORS COPY ='G',A PRINT TEST G TITLE JST TSTITL JST SALTEST CHECK THE SAL INSTRUCTION JST PREP RESET DISK, DMA ADDR COPY =TGIOB1,X INDEX IOB TG6 EQU $ COPY =:7FFF,A COPY A,OP(X) JST RYINIT RESET RETRIES WORD TG7 WORD TG8 TG7 EQU $  JST MKIOB JST DOIO DO IT COPY CST(X),A GET STATUS XOR =:8400,A RIGHT STATUS? JEQ A,TESTG4 YES, OK COPY =74,A ERROR. DIDNT GET JST ERROR ILLEGAL OP CODE STATUS TESTG4 EQU $ JST RETRY RETRY ON ERROR TG8 EQU $ COPY SHORT,A DON'T RUN END OF MEDIA TEST JNE A,TG10 IF SHORT TEST SPECIFIED COPY =TGIOB3,X INDEX IOB COPY =RDDAT,A READ FUNC COPY A,OP(X) COPY UCUR,A GET UNIT COPY A,US(X) COPY CYLS,A DO LAST CYL SUB =1,A COPY A,CS(X) COPY EHD,A GET LAST HEAD COPY A,HS(X) TO IOB WORD 3 COPY SECS,A SUB =1,A LAST SECTOR   COPY A,SSS(X) TO IOB WORD 4 COPY WDS,A ADD =1,A EXCESS WORD COUNT COPY A,WC(X) TO IOB WORD 5 TG8B JST RYINIT RETRY RESET WORD TG9 WORD TG10 TG9 EQU $ JST DOIO READ PAST LAST SEC COPY CST(X),A GET STATUS XOR =:8C00,A SHD BE END OF MEDIA JEQ A,TESTG5 OK COPY =75,A NO END OF MEDIA STATUS JST ERROR TESTG5 EQU $ JST RETRY RETRY ON ERROR TG10 JMP *$+1 WORD TSTEND EXIT * LPOOL TITL TEST G IOBS * TGIOB1 EQU $ TEST G IOB RES 5,0 WORD 1 WORD LENGTH WORD BUF BUFFER AD WORD INTLOC INT LOC RES 4,0 * TGIOB2 WORD 1 CHAINED IOB FOR RATE ERR WORD BUF WORD 0 WORD TGIOB2 * TGIOB3 EQU $ WORD RDDAT,0,0,0,0,0 WORD BUF,INTLOC,0,0,0,0 TITL TEST H - RETURN NEXT ADDRESS TEST ****************************** * * TEST H - RETURN NEXT ADDRESS TEST * *  THIS TEST VERIFIES THE OPERATION OF * THE 'RETURN NEXT ADDRESS' FEATURE FOR * SEEK, TIO, AND READ-DATA *  FUNCTIONS. * * THESE FUNCTIONS ARE EACH EXECUTED WITHOUT * THE UPDATE BIT ON IN THE OPCODE. THEN THEY * ARE EXECUTED A SECOND TIME, THIS TIME WITH * THE UPDATE BIT ON. IN EVERY CASE, IT IS * EXPECTED THAT THE ADDRESS IN THE IOB WILL * REMAIN UNCHANGED. * * PART 2 OF THEST H IS THE HIGH MEMORY TEST. *  THE HIGHEST READ/WRITE LOCATION IS FOUND. * AN INCREMENTING PATTERN IS WRITTEN FOR 1 * SECTOR, THEN READ INTO THE ORIGINAL OUTPUT * BUFFER TO MAKE SURE THAT WHAT WAS READ EQUALS * WHAT WAS WRITTEN. THIS IS PERFORMED UNDER * THREE CONDITIONS: * * 1) IOB AT END-OF-MEMORY, DATA BUFFER IN LOW MEMORY, * 2) IOB IN LOW MEMORY, DATA BUFFER AT END-OF-MEMORY, * 3) IOB AND DATA BUFFER AT END-OF-MEMORY. * * PART 3 OF TEST H IS THE INTERRUPT LEVELS TEST. A TIO * OPERATION IS PERFORMED WITH AN INTERRUPT ADDRESS IN * IOB WORD 7. FOUR I/O'S ARE PERFORMED WITH BITS 12 AND * 13 OF THE PSW SET AS FOLLOWS: * * PASS PSW BIT 13 PSW BIT 12 ACTION * ---- ---------- ---------- ------ * 1 OFF ON SUPPRESS INT. TIME OUT * 2 ON ON SUPPRESS INT. TINE OUT * 3 OFF  OFF SHOULD REACH INT. ADDR. * 4 ON OFF SHOULD REACH INT. ADDR. * * CALLS:  CALLED BY: * TSTITL TEST CONTROL (TEST EXECUTION) * PREP * MKIOB * RYINIT *  DOIO * STATUS * ERROR * RETRY * TSTHR3 * TSTHR1 * TSTHR2 * TSTHR4 *  DUMP * SEL * TIMER * TIME * OTX * ****************************** * TESTH EQU $ COPY ='H',A OUTPUT TEST TITLE JST TSTITL JST SALTEST CHECK THE SAL INSTRUCTION COPY =:8001,A OUTPUT RUN INDICATOR SELP A,4 JST PREP RESET DISK, ADDRESSES COPY =THIOB2,X INDEX IOB COPY X,ADRIOB JST MKIOB SET UP ADDRESS COPY =THIOB1,X NOW SET UP ADDRESS FOR COPY X,ADRIOB JST MKIOB REAL IOB. COPY =-6,A (THIOB1 IS ACTUAL IOB,  COPY A,TEMP1 THIOB2 IS COMPARATOR IOB. TESTH1 COPY TEMP1,A FIND OPCODE IN TABLE ADD =THTBL+6,A COPY A,TEMP2 COPY TEMP2,Y COPY 0(Y),A COPY A,OP(X) STORE OPCODE JST RYINIT RESET RETRIES WORD TH1 WORD TH2 TH1 EQU $  JST DOIO DO OPERATION JST STATUS CHECK STATUS COPY THIOB2+CS,A COMPARE CYL NO XOR THIOB1+CS,A JNE A,TESTH2 MISCOMPARE COPY THIOB2+HS,A COMPARE HEADNO XOR THIOB1+HS,A JNE A,TESTH2 MISCOMPARE COPY THIOB2+SSS,A  XOR THIOB1+SSS,A COMPARE SECTOR NO JEQ A,TESTH3 OK TESTH2 COPY =80,A MISCOMPARE JST ERROR TESTH3 EQU $ JST RETRY RETRY ON ERROIR TH2 EQU $ IMS TEMP1 DO NEXT OPCODE JMP TESTH1 JMP TESTH4 THIS PART OF TEST FINISHED * * HIGH MEMORY TEST *FIND END OF MEMORY--- STORE IN EOMPTR * TESTH4 EQU $ COPY =TESTH5:,A COPY A,UNMET+3 SBIT 6,S ALLOW 64K ADDRESSING COPY =:8002,A OUTPUT RUN INDICATOR SELP A,4 COPY FLBTOP,X MAX MEMORY +1K-1 JMP $+2 TESTH5: ENT TESTH5 SUB FLBDEC,X SUBTRACT MEMORY INCREMENT COPY =:55,A GET PATTERN EXCH 0(X),A WRITE IT OUT EXCH 0(X),A AND READ IT BACK IN SUB =:55,A IS IT THE SAME? JNE A,TESTH5 NO--KEEP TRYING EXCH 0(X),A IF SO, TRY THE SAME THING EXCH 0(X),A WITH A ZERO JNE A,TESTH5 KEEP TRYING IF NOT ZERO * * EOM FOUND * COPY X,EOMPTR PTR TO LAST READ/WRITE CELL COPY =UNMET:,A COPY A,UNMET+3 SBIT 8,S * *IOB IN HIGH MEMORY--WORD BUFFER IN LOW MEMORY * TESTH6 COPY =0,A COPY A,TEMP1 ERROR INCREMENT COPY EOMPTR,A SUB =11,A ALLOW 12 HIGH MEM WORDS COPY A,EOMIOB IOB IN HIGH MEMORY JST PREP RESET DISK ADDRESSES COPY =BUF,X BUFFER ADDRESS JST TSTHR1 SET UP OUTPUT BUFFER COPY EOMIOB,X COPY =BUF,A GET BUFF ADDR COPY A,MA(X) STORE IT IN IOB COPY EOMIOB,X JST TSTHR3 BUILD PART OF IOB JST RYINIT RESET RETRIES WORD TEST6H WORD TESTH7 TEST6H COPY EOMIOB,X JST MKIOB BUILD REST OF IOB FOR WRITE JST DOIO DO I/O JST STATUS GET STATUS JST RETRY RETRY IF ERROR TESTH7 COPY EOMIOB,X COPY =RDDAT,A READ WORD BACK INTO BUFF COPY A,OP(X) JST RYINIT RESET RETRIES WORD TEST77 WORD TESTHA TEST77 COPY EOMIOB,X JST MKIOB SET UP I/O FOR READ JST DOIO DO I/O JST STATUS GET STATUS COPY =BUF,X JST TSTHR2 SEE IF WE READ WHAT WE WROTE JST TSTHR4 NO--OUTPUT ERROR MESSAGE JST RETRY RETRY ON ERROR JMP TESTHA * LPOOL TITL * *IOB IN LOW MEMORY--WORD BUFFER IN HIGH MEMORY * TESTHA COPY =1,A COPY A,TEMP1 ERROR INCREMENT COPY EOMPTR,A SUB WDS,A ADD =1,A COPY A,EOMBUF WORD BUFF IN HIGH MEMORY COPY EOMBUF,X GET WORD BUF ADDRESS JST TSTHR1 SET UP OUTPUT BUFFER COPY =THIOB3,X COPY EOMBUF,A COPY A,MA(X) PUT BUFFER ADDR IN IOB JST TSTHR3 BUILD PART OF IOB JST RYINIT RESET RETRIES WORD TESTHB WORD TESTHC TESTHB JST MKIOB SET UP REST OF IOB FOR WRITE JST DOIO DO I/O JST STATUS GET STATUS JST RETRY RETRY ON ERROR TESTHC COPY =THIOB3,X COPY =RDDAT,A READ WORD BACK INTO BUFFER COPY A,OP(X) JST RYINIT RESET RETRIES WORD TESTHD WORD TESTHF TESTHD JST MKIOB SET UPIOB FOR R EAD JST DOIO DO I/O JST STATUS GET STATUS COPY EOMBUF,X GET BUFF ADDRESS JST TSTHR2 SEE IF WE READ WHAT WE WROTE JST TSTHR4 NO--OUTPUT ERROR MESSAGE JST RETRY RETRY ON ERROR JMP TESTHF * *BOTH IOB AND BUFF IN HIGH MEMORY * TESTHF COPY =2,A COPY A,TEMP1 ERROR INCREMENT COPY EOMPTR,A SUB WDS,A ADD =1,A COPY A,EOMBUF WORD BUFF IN HIGH MEMORY SUB =12,A COPY A,EOMIOB IOB IN HIGH MEMORY COPY EOMBUF,X JST TSTHR1 SET UP OUTPUT BUFFER COPY EOMIOB,X COPY EOMBUF,A GET BUFF ADDR COPY A,MA(X) STORE IT IN IOB JST TSTHR3 BUILD PART OF IOB  JST RYINIT RESET RETRIES WORD TESTHG WORD TESTHH TESTHG COPY EOMIOB,X JST MKIOB BUILD REST OF IOB FOR WRITE JST DOIO DO I/O JST STATUS GET STATUS JST RETRY RETRY ON ERROR TESTHH COPY EOMIOB,X COPY =RDDAT,A READ WORD BACK INTO BUFFER COPY A,OP(X) JST RYINIT RESET RETRIES WORD TESTHI WORD TESTHJ TESTHI JST MKIOB SET UP I/O FOR READ JST DOIO DO I/O JST STATUS GET STATUS COPY EOMBUF,X GET BUFF ADDR JST TSTHR2 SEE IF WE READ IN WHAT WE WROTE JST TSTHR4 NO--OUTPUT ERROR MESSAGE JST RETRY RETRY IF ERROR TESTHJ RBIT 6,S END 64K TEST JMP TESTHK THIS PART OF TEST FINISHED * LPOOL TITL TEST H - SUBROUTINES (TSTHR1) ****************************** * * TSTHR1 - SET UP OUTPUT BUFFER * * THIS SUBROUTINE WILL SET UP THE * OUTPUT BUFFER CONTAINING THE * INCREMENTING PATTERN, * * ENTER WITH XR = BUFFER ADDRESS. * * CALLING SEQUENCE: * COPY =BUFFER ADDRESS,X *  JST TSTHR1 * * CALLS: CALLED BY: * NONE TESTH * ****************************** * TSTHR1 ENT COPY X,TCTEMP SAVE X COPY WDS,A NEG A,A COPY A,TEMP2 NEG WD COUNT COPY =0,A H6 COPY  A,0(X) ADD =1,X BUMP BUFFER INDEX ADD =1,A BUMP PATTERN IMS TEMP2 BUMP WD COUNT JMP H6 COPY TCTEMP,X RESTORE X JMP *TSTHR1 TITL TEST H - SUBROUTINES (TSTHR2) ****************************** * * TSTHR2 - EXAMINE INPUT BUFFER * * THIS SUBROUTINE WILL EXAMINE * THE INPUT BUFFER AFTER A * READ OPERATION. * * ENTER WITH XR = BUFFER ADDRESS. * RETURN TO CALL+1 IF MISCOMPARE * OTHERWISE CALL+2. * * CALLIN SEQUENCE: *  COPY =BUFFER ADDRESS,X * JST TSTHR2 * JMP ? MISCOMPARE R * JMP ? GOOD  R+1 * * CALLS: CALLED BY: * NONE TESTH * ****************************** * TSTHR2 ENT COPY X,TCTEMP SAVE X COPY WDS,A NEG A,A COPY A,TEMP2 NEG WD COUNT COPY =0,A COPY A,TEMP3 H7 COPY 0(X),A CSK A,TEMP3 JMP H8 MISCOMPARE JMP H8 MISCOMPARE IMS TEMP3 BUMP PATTERN ADD =1,X BUMP BUFFER INDEX IMS TEMP2 BUMP WD COUNT JMP H7 IMS TSTHR2 MADE IT! H8 COPY TCTEMP,X RESTORE X JMP *TSTHR2 TITL TEST H - SUBROUTINES (TSTHR3) ****************************** * * TSTHR3 - BUILD IOB * * THIS SUBROUTINES BUILDS WORDS 0, 5, 7, * AND 8 OF THE IOB FOR A WRITE OPERATION. * * ENTER WITH XR = IOB ADDRESS * * CALLING SEQUENCE:  * COPY =IOB ADDRESS,X * JST TSTHR3 * * CALLS: CALLED BY: * NONE TESTH * ****************************** * TSTHR3 ENT COPY =WRTDAT,A COPY A,OP(X) WRITE WORD OP CODE COPY WDS,A  COPY A,WC(X) WRITE 1 SECTOR COPY =0,A COPY A,IN(X) NO INTERRUPTS COPY A,NB(X) NO WORD CHAINING JMP *TSTHR3 TITL TEST H - SUBROUTINES (TSTHR4) ****************************** * * TSTHR4 - OUTPUT ERROR MESSAGE * * THIS SUBROUTINE WILL OUTPUT AN * ERROR MESSAGE 'TEMP1+81'. IT WILL * DUMP THE BUFFER. * * CALLING SEQUENCE: *  JST TSTHR4 * * CALLS: CALLED BY: * DUMP TESTH * ****************************** * TSTHR4 ENT COPY =81,A DIDN'T READ IN WHAT WE WROTE OUT ADD TEMP1,A JST ERROR COPY ADRIOB,X COPY MA(X),A GET BUFF ADDR COPY A,X TO X COPY WDS,A NEG A,A NEG WD COUNT TO A JST DUMP DUMP BUFFER H9 JMP *TSTHR4 * LPOOL TITL TEST H - INTERRUPT LEVELS TEST ****************************** * * TEST H - INTERRUPT LEVELS TEST * * THIS IS THE SECOND PART OF TEST H * ****************************** * *BIT 12 OF PSW ON. THIS SHOULD SUPPRESS INTERRUPTS + CAUSE TIME OUT * TESTHK COPY =:8003,A SET RUN INDICATOR SELP A,4 COPY =-2,A TWO-PASS COUNTER COPY A,TEMP1 RBIT 8,S JST SEL RESET THE DISK COPY =:1000,A PASS 1: PSW BIT 12 ON; BIT 13 OFF TSTHK COPY A,BITMSK COPY =THIOB4,X JST RYINIT SET UP RETRIES WORD TESTHL WORD TESTHM TESTHL COPY S,A UPDATE PSW OR BITMSK,A COPY A,S UIS SBIT 8,S ENABLE INTERRUPTS JST TIMER RESET TIME COPY =THIOB4,X JST OTX  INITIATE THE I/O JST TIME TIME THE I/O JMP $-1 3-SECOND DELAY RBIT 8,S TIMER EXPIRED. GOOD JST SEL  RESET THE DISK JMP TESTHM PERFORM NEXT PASS THINT1 EQU $ OOPS! GOT AN INTERRUPT JST $+1 SERVICE IT NOP COPY =85,A GOT AN INTERRUPT WHEN PSW BIT 12 ON JST ERROR JST RETRY RETRY THE I/O TESTHM IMS TEMP1 BUMP PASS COUNTER  JMP TESTHN DO PASS 2 JMP TESTHO GO TO PASS 3 TESTHN COPY =:3000,A PASS 2: PSW BIT 12 ON; BIT 13 ON JMP TSTHK * *BIT 12 OF PSW OFF. THIS SHOULD ALLOW INTERRUPTS. * TESTHO EQU $ COPY =-2,A TWO-PASS COUNTER COPY A,TEMP1 RBIT 8,S JST SEL RESET THE DISK COPY =:EFFF,A PASS 3: PSW BIT 12 OFF;BIT 13 ON TESTHP COPY A,BITMSK COPY =THIOB5,X JST RYINIT SET UP RETRIES WORD TESTHQ WORD TESTHR TESTHQ COPY S,A UPDATE PSW AND BITMSK,A COPY  A,S UIS SBIT 8,S ENABLE INTERRUPTS JST TIMER RESET TIME COPY =THIOB5,X JST OTX INITIATE THE I/O  JST TIME TIME THE I/O JMP $-1 3-SECOND DELAY RBIT 8,S TIMED OUT. ERROR JST SEL RESET THE DISK COPY =86,A NO INTERRUPT WHEN PSW BIT 12 OFF JST ERROR JST RETRY THINT2 EQU $ GOOD. INTERRUPT OCCURRED JST $+1  SERVICE IT NOP TESTHR IMS TEMP1 JMP TESTHS DO PASS 4 JMP TSTEND EXIT TESTHS COPY =:CFFF,A PASS 4: PSW BIT 12 OFF; BIT 13 OFF JMP TESTHP * LPOOL TITL TEST H IOBS * THIOB1 RES 5,0 WORD 6,BUF,INTLOC RES 4,0 * THIOB2 RES 12,0  * THIOB3 RES 12,0 * THIOB4 RES 6,0 TIO IOB WORD BUF FOR PSW BIT 12 ON WORD THINT1 RES 4,0 * THIOB5 RES 6,0 TIO IOB WORD BUF FOR PSW BIT 12 OFF WORD THINT2 RES 4,0 * THTBL WORD SEEK WORD TIO WORD TIO FOR SCOUT WORD SEEK;UPDATE WORD TIO;UPDATE WORD TIO;UPDATE * EOMPTR WORD 0 POINTER TO END OF MEMORY EOMIOB WORD 0 POINTER TO EOM IOB EOMBUF WORD 0 POINTER TO EOM WORD BUFFER FLBTOP WORD MEMINC-1 START SEARCHING FOR EOM HERE FLBDEC WORD MEMINC BITMSK WORD 0 PSW MASK TITL FORMATTER ****************************** * * FORMATTER - THIS IS THE FORMATTING ROUTINE * * IT FORMATS THE ENTIRE DISK (OR PART * OF A DISK) IN STANDARD CAI FORMAT. * * FIRST ALL THE TRACK OUTSIDE THE USER'S TRACKS * WILL BE FORMATTED AS SPARE TRACKS. THEN THE *  USER'S TRACKS ARE FORMATTED AS FOLLOWS: * EACH SECTOR IS SEQUENTIALLY LINKED TO THE * NEXT SECTOR AND WHEN ALL HEADS ARE EXHAUSTED, * LINKAGE CONTINUES WITH THE NEXT CYLINDER. * * BAD TRACKS HAVE :F000 OR'ED INTO THE UPPER * FOUR BITS OF WORDS 0 OF EACH SECTOR BLOCK. * THE CONTROLLER THEN RE-FORMAT A SPARE TRACK * AS A DATA TRACK, AND THE FLAWED USER TRACK * WILL THEN BE FORMATTED TO POINT TO THE SPARE * TRACK. ANY SUBSEQUENT ACCESSES TO THE FLAWED * TRACK WILL AUTOMATICLLY BE DIRECTED TO THE *  APPROPRIATE SPARE TRACK. THE BAD TRACK AND * HEAD ARE OUTPUT ON THE CRT/TTY. FORMATTING * THEN CONTINUES UNTILL ALL REQUESTED TRACK * HAVE BEEN FORMATTED. * * CALLS: CALLED BY: * PREP  TEST CONTROL (FUNCTION EXECUTION) * MKIOB * DOIO * STALT * FMBUMP * FMBLD * FMWRIT * MSGA * ODEC * ****************************** * FMATTR EQU $ FMTR2A EQU $ COPY UCUR,A GET CURRENT UNIT COPY A,UPTR JST SET:PARA SET PARAMETER IF NECCESARY JST PREP INITIALIZE COPY =TAIOB,X INDEX TEST A IOB COPY X,ADRIOB COPY =TIO,A COPY A,OP(X) COPY =0,A COPY A,IN(X) NO INTERRUPTS JST MKIOB SET UP IOB JST DOIO JST MKIOB SET UP IOB AGAIN JST DOIO DO I/O AGAIN JST STALT CHECK STATUS JST FMSPARE GO FORMAT THE SPARE TRACKS. FMATR3 EQU $ COPY ECYL,A GET ENDING CYLINDER ADD =1,A COPY A,FMAT3B SET UP LAST CYL+1 COPY SCYL,A GET STARTING CYLINDER COPY SHD,X GET STARTING HEAD JST FMAT3A FORMAT THE USER'S TRACKS JMP ENT1A FINISHED FORMATTING, RETURN TO PROGRAM * FMAT3A ENT ENTRY POINT INTO THE FORMATTER FMAT3A1 COPY A,FMCS SAVE CURRENT CYLINDER OR =:F000,A SET THE CDR FOR FORMATTER SELP A,4 AND =:FFF,A STRIP TH FORMAT DISPLAY INDICATOR COPY A,FMCL WHICH IS ALSO LAST CYLINDER COPY X,FMHS SAVE CURRENT HEAD COPY X,FMHL WHICH IS ALSO LAST HEAD JST FMBUMP BUMP TO FIND NEXT CYL/HD FMAT3B WORD $-$ CYL LIMIT JMP $+2 OK, BUMP DIDN'T EXCEED LAST CYL., GO ON TO NEXT CYL. JMP *FMAT3A PAST THE LAST CYLINDER, MUST BE THE END COPY A,FMCN STORE NEW NEXT CYL COPY X,FMHN STORE NEW NEXT HEAD COPY =0,A CO PY A,FMFLAG FLAG=0=NORMAL FMAT COPY =BUF,X INDEX BUFFER JST FMBLD BUILD TRACK HDR FMATB3 JST FMWRIT FORMAT A TRACK JMP FMAT3L GOOD WRITE. CONTINUE JMP FMATNG BAD TRACK--FLAG IT FMAT3L COPY FMCN,A GE NEXT CYLINDER COPY FMHN,X GET NEXT HEAD JMP FMAT3A1 CONTINUE WITH NEXT TRACK FMATNG EQU $ BAD TRACK FOUND JST MSGA SAY SO WORD BADTRK  COPY FMCS,A PRINT CYL NO JST ODEC JST MSGA WORD BADTK1 AND HEAD NO COPY FMHS,A JST ODEC COPY =:F000,A SET BAD TRK FLAG COPY A,FMFLAG COPY =BUF,X INDEX BUFFER JST FMBLD BUILD BAD TRACK HEADER JST FMWRIT WRITE BAD TRACK HEADER NOP IGNORE STATUS--WE KNOW ITS BAD JMP FMAT3L CONTINUE * LPOOL * TITL FORMAT SPARE TRACK SUBROUTINE ****************************** * * FMSPARE - FORMATE SPARE TRACK * * THIS SUBROUTINE FORMATS THE SPARE * BEFORE THE USER TRACKS ARE FORMATTED. * ****************************** * * FMSPARE ENT COPY CYLMX,A GET THE END CYLINDER COPY A,FMAT3B SET UP LAST CYLINDER+1 COPY CYLS,A GET LAST USER CYLINDER ADD =1,A MAKE FIRST SPARE TRACK NUMBER COPY SHD,X GET STARTING HEAD NUMBER JST FMAT3A FORMAT THE SPARE TRACKS JMP *FMSPARE RETURN TO FORMAT THE USER CYLS. * LPOOL * TITL FORMATTER - SUBROUTINES (FMBUMP) ****************************** * * FMBUMP - INCREMENT PARAMETERS * * THIS SUBROUTINE WILL INCREMENT * THE CURRENT CYLINDER, HEAD TO * NEXT VALUE. * * ENTER WITH * AR = CURRENT CYLINDER * XR = CURRENT HEAD * EXIT WITH * AR = CURRENT CYLINDER, OR IF HEADS OVERFLOW, * NEXT HIGHEST CYLINDER * XR = NEXT HIGHEST HEAD, IF CYLINDER IS INCREMENTED. *  OTHERWISE, THE INITIAL HEAD NUMBER. * * IF CYLINDER NUMBER REACHES LAST LEGAL CYLINDER, THEN * IT DOE'S A RETURN+2. * * CALLING SEQUENCE: * COPY =CURRENT CYLINDER,A * COPY =CURRENT HEAD,X * JST FMBUMP * WORD (LAST LEGAL CYLINDER NUMBER) * JMP ? NORMAL RETURN R+1 * JMP ? BUMP EXCEED THE LAST LEGAL CYL. R+2 * * CALLS: CALLED BY: * NONE FMATTR * ****************************** * FMBUMP ENT COPY A,FMBMPC SAVE CURRENT CYL COPY X,FMBMPH SAVE CURRENT HEAD IMS FMBMPH BUMP HEAD FIRST COPY FMBMPH,A CSK A,EHD HAS HEAD OVERFLOWED? JMP FMBMP0 NO JMP FMBMP2 YES IT HAS FMBMP0 COPY FMBMPH,X RESTORE X WITH NEW HEAD FMBMP1 IMS FMBUMP BUMP PAST DELIMITER COPY FMBMPC,A JMP *FMBUMP AND RETURN WITH BUMPED HEAD FMBMP2 COPY SHD,X RESTORE STARTING HEAD COPY X,FMBMPH IMS FMBMPC NOW BUMP CYL COPY *FMBUMP,A COMPARE IT TO DELIMITER CSK A,FMBMPC CHECK TO SEE IF THIS IS PAST THE LAST CYL. JMP FMBMP3 THIS IS THE END OF THE LINE NOP COPY  FMBMPC,A NOT AT END YET JMP FMBMP1 RETURN WITH BUMPED CYL FMBMP3 COPY =-1,A FLAG END OF MEDIA COPY =-1,X IMS FMBUMP IMS FMBUMP INCREMENT TO END OF MEDIA RETURN (R+2) JMP *FMBUMP * FMBMPC WORD 0 CYL SAVE CELL FMBMPH WORD 0 HEAD SAVE CELL * LPOOL TITL FORMATTER - SUBROUTINES (FMBLD) ****************************** * * FMBLD - BUILDS THE HEADERS *  * THIS SUBROUTINE BUILDS THE HEADERS * NEEDED TO FORMAT ONE TRACK. IT * REQUIRES THE FOLLOWING UPON ENTRY: * * XR = HEADER ADDRESS * FMCS = HEADER WORD 0 (CURRENT CYLINDER) * FMHS = HEADER WORD 1 (CURRENT HEAD) * 0000 = HEADER WORD 2 (RESERVED) * 0000 = HEADER WORD 3 (RESERVED) * WDS = HEADER WORD 4 (NUMBER OF WORDS PER SECTOR) * * FMFLAG = SETTING OF FLAG BITS FOR CYLINDER NUMBER. * :F000 = BAD TRACK * :0000 = NORMAL TRACK * * CALLING SEQUENCE: * COPY =HEADER ADDRESS,X * JST FMBLD * * CALLS: CALLED BY: * NONE TESTC * FMATTR * ****************************** * FMBLD ENT COPY X,BUFTEMP SAVE THE BUFFER ADDRESS COPY =HEADTBLE,X GETR THE TEMP BUFFER COPY SECS,A HEADERS=NO OF SECT/TRACK FMBLD0 NEG A,A COPY A,FMBLDA COPY SSEC,A COPY A,FMS STARTING SECTOR FMBLD1 COPY FMCS,A GET CURRENT CYL OR FMFLAG,A OR IN FLAG COPY A,0(X) TO SECTOR BLOCK WORD 0 COPY FMS,A GET SECTOR NUMBER SHIFT A,LO,8 MOVE TO MS BYTE OR FMHS,A OR IN CURRENT HEAD COPY A,1(X) TO SECTOR BLOCK WORD 1 IMS FMS BUMP SECIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII! IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIe820909184931820909184931820909184931e@820909184931820909184931820907172036" e820909184931820909184931820909184931e820909184931820909184931820909184931820909184931820909184931820909184931e8209071724167582090717335650820909190857e8111201808047581112018080925820907172104# $ % & ' ( ) * + ?. SWITP ASMSWITP JCL, TOR NO. COPY =0,A COPY A,2(X) TO SECTOR BLOCK WORD 2 COPY A,3(X) TO SECTOR BLOCK WORD 3 FMBLD2 COPY WDS,A GET WDS PER SECTOR COPY A,4(X) TO SECTOR BLOCK WORD 4 ADD =5,X MOVE BUF PTR TO NEXT SECTOR BLOCK IMS FMBLDA INC SECTOR COUNT JMP FMBLD1 DO NEXT HEADER JST STAGGER NOW REARRANGE THE HEADER FOR INTERLEAVEING FMBLD3 JMP *FMBLD EXIT * LPOOL * TITL STAGGER (SECTOR INTERLEAVEING SUBROUTINE) ********************************************** * * STAGGER * *  THIS ROUTINE REARRANGES THE HEADER * TO REFLECT THE INTERLEAVE REQUESTED * BY THE USER. * ********************************************** * STAGGER ENT $ COPY BUFTEMP,X GET THE HEADER TABLE DESTINATION COPY =STAGTBLE,Q GET THE STAGGER TABLE ADDRESS COPY STAG,A GET THE STAGGER REQUESTED SHIFT A,LO,4 CREATE OFFSET INTO STAGGER TABLE ADD A,Q ADD THE OFFSET TO THE TABLE ADDRESS COPY Q,STAGPNT STAGGER TABLE POINTER COPY SECS,A NUMBER OF SECTORS NEG A MINUS COUNT OF THE SECTORS COPY A,SECCOUNT STAG1 EQU $ COPY =-5,Q HEADER WORD COUNT COPY *STAGPNT,A GET SECTOR NUMBER FROM TABLE COPY A,Y SHIFT A,LO,2 MULTIPLY BY 4 ADD A,Y TOTAL OF MULTIPLY OF 5 ADD =HEADTBLE,Y ADD THE HEADER ADDRESS TO THE OFFSET STAG2 EQU $ COPY 0(Y),A ONE WORD OF THE HEADER COPY A,0(X) GO'S TO THE DESTINATION BUFFER ADD =1,Y BUMP THE SOURCE POINTER ADD =1,X BUMP THE DESTINATION POINTER ADD =1,Q BUMP THE WORD COUNT JNE Q,STAG2 MOVE ALL 5 WORDS IMS STAGPNT BUMP THE NEXT SECTOR POINTER IMS SECCOUNT BUMP THE SECTOR COUNT JMP STAG1 JUMP IF NOT END JMP *STAGGER * LPOOL * FMBLDA WORD 0 SECTOR NUMBER STAGPNT WORD 0 POINTER INTO THE STAGGER TABLE SECCOUNT WORD 0 SECTOR COUNT STAGTBLE EQU $ WORD 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 WORD 0,8,1,9,2,10,3,11,4,12,5,13,6,14,7,15 WORD 0,11,6,1,12,7,2,13,8,3,14,9,4,15,10,5 WORD 0,4,8,12,1,5,9,13,2,6,10,14,3,7,11,15 WORD 0,13,10,7,4,1,14,11,8,5,2,15,12,9,6,3 WORD 0,8,3,11,6,14,1,9,4,12,7,15,2,10,5,13 WORD 0,7,14,5,12,3,10,1,8,15,6,13,4,11,2,9 WORD 0,2,4,6,8,10,12,14,1,3,5,7,9,11,13,15 WORD 0,9,2,11,4,13,6,15,8,1,10,3,12,5,14,7 WORD 0,8,5,13,2,10,7,15,4,12,1,9,6,14,3,11 WORD 0,3,6,9,12,15,2,5,8,11,14,1,4,7,10,13 WORD 0,4,8,12,3,7,11,15,2,6,10,14,1,5,9,13 WORD 0,5,10,15,4,9,14,3,8,13,2,7,12,1,6,11 WORD 0,8,7,15,6,14,5,13,4,12,3,11,2,10,1,9 WORD 0,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 TITL * * FMBLDC - ALTERNATE ENTRY POINT INTO FORMATTER * SUBROUTINE 'FMBLD' USED IN TEST C. * FMBLDC ENT COPY FMBLDC,A COPY A,FMBLD COPY TCSECS,A GET SECTORS/ TRACK JMP FMBLD0 * BUFTEMP WORD 0 TEMP CELL FOR BUFFER ADDRESS * LPOOL * HEADTBLE RES 128,0 TEMP BUFFER OF HEADER TABLE TITL FORMATTER - SUBROUTINES (FMWRIT) ****************************** * * FMWRIT - BUILD IOB * * THIS SUBROUTINE BUILDS THE IOB * TO BE USED IN A FORMAT OPERATION. * THE FORMAT FUNCTION WILL FORMAT *  ONE TRACK. * * CALLING SEQUENCE: * JST FMWRIT * * CALLS: CALLED BY: * DOIO  FMATTR * STALT * ****************************** * FMWRIT ENT WRITE FORMAT ROUTINE COPY =FMTIOB,X INDEX THE IOB COPY X,ADRIOB COPY =FRMT,A SET UP FORMAT FC COPY A,OP(X) COPY UCUR,A STORE UNIT NO COPY A,US- (X) COPY BUF,A STORE CYL NO COPY A,CS(X) COPY =:FF,A AND HEAD NO AND BUF+1,A COPY A,HS(X) COPY  =:FF00,A AND BUF+1,A AND SECTOR NO SHIFT A,RO,8 COPY A,SSS(X) COPY SECS,A GET SECTOR BLOCK COUNT COPY A,WC(X) STORE IN IOB WORD 5 JST FMCHK SEE IF IT'S A MFR BAD TRK JMP FMWRT1 JUMP IF IT'S BAD JST DOIO THDO THE I/O COPY CST(X),A GET STATUS AND =:160,A CRC/FORMAT ERROR? JNE A,FMWRT1 YES, BAD TRACK JST STALT NO, CHECK NORMAL STATUS JMP *FMWRIT EXIT GOOD FMWRT1 IMS FMWRIT BUMP RETURN JMP *FMWRIT BAD RETURN * FMTIOB WORD FRMT FORMAT IOB RES 5,0 WORD BUF WORD INTLOC RES 4,0 * FMCS WORD 0 CURRENT CYL FMHS WORD 0 CURRENT HEAD FMCN WORD 0 NEXT CYL FMHN WORD 0 NEXT HEAD FMCL WORD 0 LAST CYL FMHL WORD 0 LAST HEAD FMS WORD 0 SECTOR NO FMFLAG WORD 0 MODE FLAG: - :F000 (BAD), :0000 (GOOD) * LPOOL TITL FORMATTER - SUBROUTINES (FMCHK) ****************************** * * FMCHK - FORMAT CHECK * * DURING THE QUERIES, THE USER MAY ENTER BAD TRACK #'S * FROM THE MANUFACTURER. THEY ARE KEPT IN A TABLE * CALLED 'BADBUF' IN THE FORM OF A CYL/HD PAIR. * * AS EACH TRACK IS ABOUT TO BE FORMATTED, IT IS COMPARED * AGAINST THE ENTRIES IN THE TABLE. IF IT'S THERE IT * IS FORMATTED AS A BAD TRACK, OTHERWISE, THE PROGRAM * CONTINUES AS NORMAL. * * CALLING SEQUENCE: CALLED BY: * *  JST FMCHK FMWRIT * BAD RETURN * GOOD RETURN * ****************************** * FMCHK ENT COPY =BADBUF,A GET ADDR OF BUFFER COPY A,BUFPTR INIT POINTER FMCHK1 COPY *BUFPTR,X GET CYL/HD PAIR CLSN X,=:FF END OF BUFFER YET? JMP FMCHK3 YES, EXIT SHIFT X,RO,4 ISOLATE BAD CYL# COPY BUF,A GET CURRENT CYL AND =:0FFF,A IGNORE FLAGS IN UPPER NIBBLE CSK X,A BAD TRK ON THIS CYL? NOP NO JMP FMCHK2 NO COPY *BUFPTR,X POSSIBLY, SO GET HEAD AND =:000F,X ISOLATE HEAD # COPY BUF+1,A GET CURRENT HEAD# AND =:001F,A JUST NEED LS 5 BITS CSK X,A BAD TRACK? NOP NO JMP FMCHK2 NO JMP *FMCHK YES, FORMAT AS BAD FMCHK2 IMS BUFPTR BUMP BUFFER POINTER JMP FMCHK1 CHECK REST OF BUFFER FMCHK3 COPY =FMTIOB,X RESTORE X-REG. IMS FMCHK BUMP FOR GOOD RETURN JMP *FMCHK LPOOL TITL TECH TEST ****************************** * * TECH - TECH TEST * *  THE TECH TEST WILL REQUEST INPUTS FOR * PARAMETERS FOR WHICH AN IOB WILL BE * BUILT. THEN THE TECH TEST WILL * REPEATEDLY PERFORM THE REQUESTED * FUNCTION, WITH NO STATUS CHECKING * OR TIMEOUT LOOPS. AS SOON AS AN * OPERATION COMPLETES, IT IS REPEATED. * * ESCAPE IS VIA THE CONSOLE INTERRUPT WHICH * RETURNS TO THE QUERIES. * * CALLS: CALLED BY: * SEL TEST CONTROL (FUNCTION EXECUTION) * SENRDY * MOVE * MSGA * GNF * IKB * OTA * IHEX * ****************************** * TECH EQU $ TECH1 EQU $ RBIT 8,S JST SEL KILL ANY DISK INTS SBIT 8,S NEED INTERRUPTS SBIT 4,S FOR CONSOLE TOO COPY =0,A COPY A,TTFC CLEAR PARAMETER TABLE COPY =-15,A JST MOVE WORD TTFC WORD TTFC+1 . COPY WDS,A GET WD COUNT SHIFT A,LO,1 DOUBLE IT COPY A,TTLT FOR MAX WORD LENGTH JST MSGA REQUEST PARAMETERS  WORD TTMS JST GNF GET NEXT FIELD COPY A,TTFC SAVE FC AND =:7F7F,A CSK A,=6 CSK A,=0 JMP TECH1 NOP COPY X,TTMP COPY A,X COPY TTFC,A AND =:FFF0,A ADD =OPCODE,X ADD 0(X),A COPY A,TTFC COPY TTMP,X CLSN =CR:,X DONE? JMP TECH2 YES, SKIP NEXT QUERIES JST GNF GET UNIT NO COPY A,TTU SAVE UNIT NO JLT A,TECH1 MUST BE 0-MAX. UNITS-1 SUB =UNITS-1,A JGT A,TECH1 NO, START OVER CLSN =CR:,X DONE? JMP TECH2 YES COPY CYLS,A SUB =1,A COPY A,TCTEMP HIGHEST CYLINDER NO JST GNF NO, GET CYL NO COPY A,TTC SAVE CYL NO  COPY =:FFF,A MUST BE WITHIN RANGE AND TTC,A CSK A,TCTEMP JMP $+2 OK TOTT1 JMP TECH1 BAD.START OVER CLSN =CR:,X DONE? JMP TECH2 YES COPY HDS,A SUB =1,A COPY A,TCTEMP HIGHEST HEAD NO JST GNF NO, GET HEAD NO COPY A,TTH SAVE HEAD NO JLT A,TECH1 MUST BE WITHIN RANGE AND =:FF1F,A SUB TCTEMP,A JGT A,TECH1  ERROR. START OVER CLSN =CR:,X DONE? JMP TECH2 YES COPY SECS,A SUB =1,A COPY A,TCTEMP HIGHEST SECTOR NO JST GNF NO, GET SECTOR NO COPY A,TTS SAVE SECTOR NO JLT A,TOTT1 MUST BE WITHIN RANGE SUB TCTEMP,A  JGT A,TOTT1 NO, SGART OVER CLSN =CR:,X DONE? JMP TECH2 YES JST IKB GET INTERRUPT REQUEST CLSN ='Y',A Y OR N JMP TECH1A CLSN ='N',A JMP TECH1A TECH1B CLSN =',',A COMMA OK JMP TECH1C CLSN =CR:,A CARRIAGE RETURN OK TOO JMP TECH2 JMP TECH1 ELSE ILLEGAL * LPOOL TITL * TECH1A SUB ='Y',A SET FLAG 0=YES COPY A,TTIN  JST IKB GET TERMINATOR JMP TECH1B TECH1C JST GNF GET LENGTH JNE A,$+2 ZERO=1 COPY =1,A COPY A,TTLN CSK A,TTLT MUST BE TWO SECTORS OR LESS JMP $+2 JMP TECH1 BAD COPY =:F,A AND IF FORMAT, AND TTFC,A CLSN =1,A JMP $+2 JMP TECH1D COPY TTLN,A THEN IT MUST BE .LE. SECS CSK A,SECS JMP TECH1D OK TECH1X JMP TECH1 TRY AGAIN TECH1D CLSN =CR:,X DONE? JMP TECH2 YES JST IHEX NO, GET WORD PATTERN EXCH A,X COPY A,TTDP  COPY A,TTDP1 COPY =0,A COPY A,PATFLG CLSN =CR:,X DONE? JMP TECH2 CLSN =',',X JMP TECH2A CLSN ='+',X  JMP BUFPAT CLSN ='-',X JMP BUFPAT CLSN ='.',X JMP BUFSET JMP TECH1 BUFPAT COPY X,PATFLG JST GNF COPY A,INCCNT JMP TECH2A BUFSET COPY X,PATFLG JST GNF COPY A,TTDP1 TECH2A CLSN =CR:,X JMP TECH2 JST GNF INPUT THE OPTION COPY A,TOPT STORE IT CLSN =CR:,X JMP TECH2 YES JST GNF GET CHAINED LENGTH IF ANY COPY A,TTCL SAVE IT ADD TTLN,A THIS LENGTH JLT A,TECH1X PLUS OTHER LENGTH CSK A,TTLT MUST BE 1-512 OR 1-256 JMP $+2 JMP TECH1 BAD CLSN =CR:,X DONE? JMP TECH2 YES JST GNF GET CHAIN WORD PATTERN COPY A,TTCP SAVE INPUT CLSN  =',',X COMMA ILLEGAL HERE JMP TECH1 JMP TECH2 * LPOOL TITL TECH2 COPY TTLN,A LENGTH MUST BE AT LEAST 1 JNE A,$+2  IMS TTLN COPY =-6,A FILL IOB WITH ADDRESS JST MOVE WORD TTFC WORD TTIOB1 COPY TTBUF,A STORE BUF/  AD COPY A,TTIOB1+MA COPY =TTINTL,A STORE INTERRUPT AD COPY TTIN,X UNLESS NOT WANTED JEQ X,$+2 COPY =0,A COPY A,TTIOB1+IN COPY =TTIOB2,A INDEX CHAINED IOB COPY TTCL,X ANY CHAINING? JNE X,$+2 YES COPY  =0,A NO, NO CHAIN ADDR COPY A,TTIOB1+NB STORE CHAIN ADDR COPY X,TTIOB2 STORE LENGTH IN CHAINED IOB COPY =SAVBUF,A AND CHAINED BUF AD COPY A,TTIOB2+1 COPY =:F,A CERTAIN FUNCTIONS AND TTFC,A CAN'T BE CHAINED COPY TTIOB1+NB,X CLSN =FRMT,A FORMAT=NO CHAIN COPY =0,X CLSN =SEEK,A SEEK=NO CHAIN COPY =0,X CLSN =TIO,A TIO=NO CHAIN COPY =0,X COPY X,TTIOB1+NB CLSN =FRMT,A FORMAT? COPY X,TTIOB1+SSS YES FIRST SECTOR IS 0 CLSN =FRMT,A IF FORMAT? JMP TECH3 BUILD FORMAT BUFFER CLSN =WRTDAT,A IF WRITE, JMP TECH4 PUT WORD IN BUFFER COPY TTBUF,A COPY A,CLEAR1 ADD =1,A COPY A,CLEAR1+1 COPY =0,A COPY A,*TTBUF COPY =-511,A JST MOVE CLEAR1 WORD BUF WORD BUF+1 JMP TECH5 ELSEDO I/O LPOOL TECH3 COPY TTH,A BUILD FORMAT BUFFER COPY A,TEMP2 COPY TTLN,A SET COUNT OF HEADERS NEG A,A COPY A,TEMP1 COPY TTBUF,X INDEX BUFFER TECH3A COPY TTC,A PUT CYLINDER NO COPY A,0(X) IN WORD 1 COPY A,2(X) AND WORD 3 COPY TEMP2,A PUT SECTOR/HD COPY A,1(X)  IN WORD 2 ADD =:100,A AND SECTOR+1 COPY A,3(X) IN WORD 4 COPY A,TEMP2 COPY WDS,A PUT SECTOR WD COUNT COPY A,4(X) IN WORD 5 ADD =5,X BUMP TO NEXT HEADER IMS TEMP1 BUMP COUNT JMP TECH3A DO NEXT HEADER SUB =5,X LAST HEADER IS SPECIAL COPY TTH,A BUMP HEAD NO ADD =1,A CSK A,HDS IF HEAD OV,DO NEXT CYL JMP TECHBB NOP JMP TECH3B TECHBB COPY A,3(X) ELSE PUT HEAD+1 IN WD 4 JMP TECH5 TO I/O TECH3B COPY =0,A SECTOR/HEAD=0 COPY A,3(X) COPY =:FFF,A BUMP CYL NO AND TTC,A ADD =1,A XOR CYLS,A LAST CYL ALREADY JEQ A,TECH3C  YES IMS 2(X) ELSE BUMP CYL NO JMP TECH5 TO I/O TECH3C COPY =-1,A SET EOMFLAG COPY A,2(X) IN CYL COPY  A,3(X) AND SECTOR/HD JMP TECH5 TO I/O TECH4 COPY PATFLG,A CLSN ='+',A JMP TTBFI CLSN ='-',A JMP TTBFD CLSN ='.',A JMP TTBFC JNE A,TOTTT TTBFC COPY TTDP,A COPY TTBUF,X COPY A,0(X) COPY TTDP1,A COPY A,1(X) COPY =-510,A JST MOVE TTBUF WORD BUF WORD BUF+2 JMP TECH5 TTBFI COPY TTDP,A COPY INCCNT,X JST FILINC JMP TECH5 TTBFD COPY TTDP,A COPY INCCNT,X NEG X,X JST FILINC COPY TTCP,A PUT CHAINED WORD COPY A,SAVBUF COPY =-511,A INTO CHAIN BUFFER JST MOVE WORD SAVBUF WORD SAVBUF+1 JMP TECH5 TOTTT JMP TOTT TECH5 EQU $ COPY TTFC,A GET FUNCTION CODE XOR =07,A IS IT SET DRIVE PARAMETER JNE A,TECH5A JUMP IF NOT JST CRE:TBLE CREATE DRIVE PARAMETER TABLE TECH5A EQU $ JST SEL RESET DISK SBIT 8,S I/O ROUTINE SBIT 4,S ENABLE CONSOLE FOR EXIT COPY =-3,A RESTORE CYL/HD/SECTOR JST MOVE IN CASE UPDATE BIT IS USED WORD TTC WORD TTIOB1+CS JST TIMER RESET TIME COPY =TTIOB1,X GET IOB ADDRESS COPY TTIOB1+IN,A INTERRUPTS? JST OTX DO I/O JEQ A,TECH6 NO JST TIME TIME THE I/O JMP $-1 JT0  SS,TOTT JMP TECH5A NO INTERRUPT TTINTL EQU $ INTERRUPT PT JST $+1 FOR INTERRUPTS NOP TECH51 COPY TTIOB1+CST,A  SELP A,4 COPY TOPT,A SHIFT A,RO,1 JT OV,TTDMP1 JT SS,TOTT JMP TECH5A DO IT AGAIN TECH6 JST SENRDY WAIT UNTIL DONE JMP $+2 NOT DONE JMP TECH51 DONE JST TIME TIME THE I/O JT SS,TOTT JMP TECH6 FINISHED JMP TECH5A TIME OUT, NOT READY TOTT COPY =0,A ADD =1,A JNE A,$-1 OUT A,0 JMP TECH1 * LPOOL * * GNF - INPUTS PARAMETES FOR THE * TECH TEST TO BUILD AN * IOB FROM * GNF ENT GET NEXT FIELD ROUTINE JST IHEX INPUT VALUE EXCH A,X CLSN =',',X COMMA? JMP *GNF YES, OK CLSN =CR:,X CARRIAGE RETURN? JMP *GNF YES, OK CLSN =:5E,X IS IT A UP ARROW JMP ENT1A YES SO GO TO THE BEGINING JMP TECH1 ILLEGAL. START OVER * * TTDMP1 COPY TOPT,A SHIFT A,RO,2 JF OV,TTDMP2 COPY TTLN,A NEG A,A COPY TTBUF,X JST DUMP TTDMP2 COPY TOPT,A SHIFT A,RO,3 JF OV,TTDMP3 COPY TTLN,A NEG A,A COPY =SAVBUF,X JST DUMP TTDMP3 JMP TECH1 * * TTFC WORD 0 FC TTU WORD 0 UNIT TTC WORD 0 CYLINDER TTH WORD 0 HEAD TTS WORD 0 SECTOR TTLN WORD 0 LENGTH TTIN WORD 0 INTERRUPTS FLAG TTDP WORD 0 WORD PATTERN TTCL WORD 0 CHAINED IOB LENGTH TTCP WORD 0 CHAINED IOB WORD PATTERN TTLT WORD 0 MAX WD CNT/2 SECTORS TOPT WORD 0 OPTION TTDP1 WORD 0 SECOND DATA PATTERN WORD TTMP WORD 0 TEMP CELL INCCNT WORD 0 INCREMENT COUNT PATFLG WORD 0 PATTERN FLAG TTIOB1 RES 12,0 MAIN IOB TTIOB2 RES 4,0 CHAINED IOB OPCODE WORD 0,1,2,4,7,8,9 TITL 'CHRIN' SUBROUTINE ****************************** * * CHRIN - CHECK TERMINATOR * * THIS SUBROUTINE WILL CHECK THE * TERMINATOR CHARACTER FOR INPUT THROUGH * THE 'IHEX' OR 'IDEC' SUBROUTINE IS ONE * OF THE FOLLOWING: * * CARRIAGE RETURN  - RETURN TO STANDARD RETURN ADDRESS * POUND SIGN (#) - RETURN TO RETURN ADDRESS + 1 * BACK ARROW - RETURN TO RETURN ADDRESS + 2 * UP ARROW - RETURN TO RETURN ADDRESS + 3 * COMMA (,) - RETURN TO RETURN ADDRESS + 4 * ANYTHING ELSE - RETURN TO RETURN ADDRESS + 5 * * CALLING SEQUENCE: * JST CHRIN * JMP ? CARRIAGE RETURN R * JMP ? POUND SIGN R+1 *  JMP ? BACK ARROW R+2 * JMP ? UP ARROW R+3 * JMP ? COMMA  R+4 * JMP ? ANYTHING ELSE R+5 * * CALLS: CALLED BY: * NONE QUERIES * ****************************** * CHRIN ENT TERMINATOR CHECK ROUTINE COPY IDCTM2,A GET TTY INPUT CHAR CLSN  =CR:,A IS IT C/R JMP *CHRIN YES IMS CHRIN CLSN ='#',A IS IT '#' JMP *CHRIN YES IMS CHRIN CLSN =BCKAR:,A IS IT BACK ARROW JMP *CHRIN YES IMS CHRIN CLSN =UPARR:,A IS IT UP ARROW JMP *CHRIN YES IMS CHRIN CLSN =',',A IS IT COMMA JMP *CHRIN YES IMS CHRIN ITS SOMETHING ELSE JMP *CHRIN * LPOOL TITL 'COMPAR' SUBROUTINE ****************************** * * COMPAR - DATA COMPARE ROUTINE * * THE DATA LENGTH FOR THE COMPARISON * 1  IS IN THE A REGISTER UPON ENTRY. * IF THE A REGISTER IS NEGATIVE, THE * VALUE IN 'EXP' IS COMPARED AGAINST * EACH WORD IN THE BUFFER (POINTED TO BY * 'MISCAD'). * IF THE A REGISTER IS POSITIVE, 'EXP' IS * INCREMENTED AFTER EACH SUCCESSFUL COMPARE. * * THE FOLLOWING IS REQUIRED UPON ENTRY: * AR = DATA LENGTH * EXP = EXPECTED VALUE * MISCAD = POINTER TO BUFFER * * CALLING SEQUENCE: * COPY =DATA LENGTH,A * JST COMPAR * JMP ? MISCOMPARE R * JMP ? GOOD COMPARE R+1 * * CALLS: CALLED BY: * NONE TESTC * TESTD1 *  TESTE * ****************************** * COMPAR ENT COPY A,COMPFG SAVE INCREMENTFLAG JLT A,$+2 DONT INCREMENT PATTERN NEG A,A NEGATE COUNT COPY A,COMPCT STORE COUNT CMPAR1 COPY MISCAD,Y GET A WORD COPY 0(Y),A  COPY A,ACT SAVE IT FOR ERROR ROUTINE XOR EXP,A COMPARE IT JNE A,CMPAR2 MISCOMPARE COPY COMPFG,A SEE IF INCREMENTING PATTERN JLT A,CMPAR3 NO IMS EXP YES, BUMP PATTERN NOP CMPAR3 IMS MISCAD BUMP ADDR PTR IMS COMPCT AND COUNT JMP CMPAR1 CONTINUE IMS COMPAR GOOD RETURN CMPAR2 JMP *COMPAR BAD RETURN * COMPCT WORD 0 WORD COUNT COMPFG WORD 0 INCREMENT FLAG * LPOOL TITL 'CRC' SUBROUTINE ****************************** * * CRC - GENERATES CRC CHARACTER * * THIS SUBROUTINE WILL COMPUTE THE * CRC FOR A GIVEN DATA REGION VIA THE * FOLLOWING POLYNOMIAL: * *  X**16 + X**15 + X**13 + X**7 + X**4 + X**2 + X**1 + X**0 * * UPON ENTRY XR SHOULD CONTAIN THE ADDRESS OF THE * DATA REGION AND AR SHOULD CONTAIN THE DATA LENGTH * IN WORDS. * * UPON EXIT AR WILL CONTAIN THE COMPUTED CRC AND * LOCATION 'CRCC' WILL ALSO CONTAIN THE COMPUTED * CRC. * * CALLING SEQUENCE: * COPY =DATA ADDRESS,X *  COPY =DATA LENGTH,A * JST CRC * * CALLS: CALLED BY: * NONE TESTB *  TESTC * ******************************** * CRC ENT ENTRY/EXIT. COPY X,CRCX: SAVE 'X' REGISTER. NEG A,A - SIZE OF WORD ZONE. COPY A,CRCN BIND LENGTH COUNTER. COPY A,CRCN1 FIRST SWAP COUNT COPY A,CRCN2 SECOND SWAP COUNT COPY =0,A COPY A,CCRC INITIALIZE CRC ACCUMLATOR. * * FIRST SWAP * CRC99 COPY =-8,A COPY A,SHFTCNT COPY 0(X),A GET WORD CRC98 ROTATE A,LO,1 SHIFT MS. BIT OF A TO OV JF OV,$+3 RESET BIT 0 OF A SBIT 0,A SET LS. BIT OF A JMP $+2 CONTINUE RBIT 0,A RESET LS. BIT OF A IMS SHFTCNT INCREMENT SHIFT COUNT JMP CRC98 LOOP FOR MORE COPY A,0(X) STORE WORD ADD =1,X INCREMENT POINTER IMS CRCN1 INCREMENT COUNT JMP CRC99 LOOP FOR MORE COPY CRCX:,X RESTORE 'X' REG. * CRC2 EQU $ COPY  =-16,A COMPUTATIONAL CONSTANT. COPY A,CRCX BIND COUNTER. COPY CCRC,A FETCH CRC ACCUMLATOR. XOR 0(X),A INITATE MODULUS COMPUTATION. CRC1 EQU $ SHIFT A,LO,1 SAMPLE JF OV,$+2 CONTINUE MODULUS COMPUTATION. XOR CRCP,A APPLY CRC POLYNOMIAL AND CONTINUE COMPUTATION. IMS CRCX BUMP COMPUTATIONAL STEP COUNT. JMP CRC1 CONTIUE COMPUTATION. CO2 PY A,CCRC BIND FINALIZE CRC COMPUTATION. ADD =1,X BUMP INDEX TO WORD REGION. IMS CRCN TEST FOR WORD REGION EXPIRATION. JMP CRC2 CONTINUE CRC COMPUTATION FOR REMAINING WORD REG COPY CRCX:,X REFRESH 'X' REGISTER. * * SECOND SWAP * CRC100 COPY =-8,A SET SHIFT COUNT COPY A,SHFTCNT STORE SHIFT COUNT COPY 0(X),A GET WORD CRC101 ROTATE A,LO,1 ROTATE A 1 BIT JF OV,$+3 RESET BIT 0 OF A SBIT 0,A SET LS. BIT OF A JMP $+2 CONTINUE RBIT 0,A RESET LS. BIT OF A IMS SHFTCNT INCREMENT SHIFT COUNT JMP CRC101 LOOP FOR MORE COPY A,0(X) STORE WORD ADD =1,X INCREMENT POINTER IMS CRCN2 INCREMENT COUNT JMP CRC100 LOOP FOR MORE COPY CRCX:,X RESTORE 'X' REG. * * SWAP CRC CHARACTER * COPY =-8,A SET SHIFT COUNT COPY A,SHFTCNT STORE SHIFT COUNT COPY CCRC,A REFRESH 'A' REGISTER CRC102 ROTATE A,LO,1 SHIFT MS. BIT OF A TO OV JF OV,$+3 RESET BIT 0 OF A SBIT 0,A SET LS. BIT OF A JMP $+2 CONTINUE RBIT 0,A RESET LS. BIT OF A IMS SHFTCNT INCREMENT SHIFT COUNT JMP CRC102 LOOP FOR MORE * COPY A,CCRC STORE CRC CHARACTER JMP *CRC BACK TO CALLER. * SHFTCNT RES 1 SHIFT COUNT CRCP WORD :A097 CRC POLYNOMIAL MASK CRCX RES 1 -16 UP COUNTER. CRCN RES 1 - WORD REGION LENGTH KEEPER, IN WORDS. CRCN1 RES 1 FIRST SWAP COUNT CRCN2 RES 1 SECOND SWAP COUNT CCRC RES 1 CRC ACCUMALTOR. CRCX: RES 1 'X' KEEPER. TITL 'CRLF' SUBROUTINE ****************************** * * CRLF - OUTPUT CR/LF * * THIS SUBROUTINE WILL OUTPUT * AN ASCII CARRIAGE RETURN FOLLOWED * BY AN ASCII LINE FEED TO THE * CRT/TTY. * * CALLING SEQUENCE: * JST CRLF * * CALLS: CALLED BY: * OTTY DUMP * TSTITL * ****************************** * CRLF ENT COPY =CR:,A OUTPUT CR JST OTTY COPY =LF:,A OUTPUT LF JST OTTY JMP *CRLF * LPOOL TITL 'DINIT' SUBROUTINE ****************************** * * DINIT - INITIALIZE DISK * * THIS SUBROUTINE WILL RESET THE DISK, * SENSE FOR PRESENCE OF THE DISK, * SENSE FOR THE DISK READY, PERFORM * MICRODIAGNOSTIC, AND STATUS * VERIFICATION. * *  CALLING SEQUENCE: * JST DINIT * * CALLS: CALLED BY: * SEL PREP * SENHIM TESTB * SENRDY * OTA * TIMER * TIME * ERROR * ****************************** * DINIT ENT COPY =MUIOB,A INDEX IOB EXCH ADRIOB,A SAVE ADRIOB COPY A,DINIOB JST SEL INITIALIZE JST SENHIM SENSE PRESENCE JMP DINIT1 ERROR JST SENRDY SENSE READY JMP DINIT2 ERROR COPY ADRIOB,A JST OTA DO IT JST TIMER RESET TIMER DINIT0 JST TIME TIME OUT MICRODIAG JMP $+2 JMP DINIT3 TIMER EXPIRED. ERROR  JST SENRDY DONE YET? JMP DINIT0 NO, KEEP TRYING COPY =:400,A YES CHECK STATUS XOR MUIOB+CST,A JNE A,DINIT4  BAD STATUS. ERROR COPY MUIOB+DST,A CHECK DRIVE STATUS NEG A,A SHOULD BE COMPLEMENT OF SUB =1,A XOR MUIOB+OP,A FC FIELD JNE A,DINIT4 IT ISNT. ERROR JMP DINIT6 NO ERROR DINIT1 COPY =0,A CONTROLLER NOT PRESENT JMP DINIT5 DINIT2 COPY =1,A CONTROLLER NOT IDLE JMP DINIT5 DINIT3 COPY =11,A MUDIAG TIMER EXPIRED JMP DINIT5 DINIT4 COPY 3 =12,A STATUS ERROR DINIT5 JST ERROR PRINT ERROR DINIT6 COPY DINIOB,A RESTORE ADRIOB COPY A,ADRIOB JMP *DINIT EXIT * DINIOB WORD 0 ADRIOB HOLDER MUIOB WORD :AA55 MU-DIAG IOB RES 11,0 * LPOOL TITL 'DOIO' SUBROUTINE ****************************** * * DOIO - PERFORM I/O * * THIS SUBROUTINE WILL PERFORM * AN I/O OPERATION TO THE DISK, *  WITH OR WITHOUT INTERRUPTS. * * CALLING SEQUENCE: * JST DOIO * * CALLS: CALLED BY: * TIMER TESTA * OTX TESTB * TIME TESTC * SEL  TESTD1 * ERROR TESTE * SENRDY TESTG *  TESTH * FMATTR * FMWRIT * ****************************** * DOIO ENT COPY ADRIOB,X SAVE IOB ADDR COPY =-1,A COPY A,XF(X) PRESET WDS XFRRED COPY A,CST(X) AND STATUS COPY A,DST(X) JST TIMER RESET TIME COPY IN(X),A INTERRUPTS BEING USED JEQ A,DOIO1 NO SBIT 8,S YES JST OTX SELECT DISK JST TIME TIME THE I/O JMP $-1 JST SEL RESET DISK COPY =2,A JST ERROR NO INTERRUPT JMP *DOIO EXIT INTLOC EQU $ I/O INTERRUPT LOC JST $+1 SERVICE INTERRUPT NOP JST SENRDY SEE IF IDLE JMP $+2 JMP *DOIO OK EXIT COPY =3,A NOT IDLE AFTERINTERRUPT JST ERROR JMP *DOIO DOIO1 JST OTX SELECT DISK DOIO2 JST SENRDY SENSE FOR COMPLETION JMP DOIO3 NOT DONE JMP *DOIO EXIT DOIO3 JST TIME TIME THE I/O JMP DOIO2 COPY =4,A TIME EXPIRED, DISK NOTREADY JST ERROR TO ERROR SUB JMP *DOIO EXIT * LPOOL TITL 'DUMP' SUBROUTINE ****************************** * * DUMP - DISPLAYS I/O BUFFER * * THIS SUBROUTINE WILL DISPLAY * THE I/O BUFFER TO THE CRT/TTY * WITH 14 WORDS PER LINE. * * ENTER WITH AR = NEGATIVE WORD LENTH TO DUMP * AND XR = BUFFER ADDRESS * * CALLING SEQUENCE: * COPY =-WORD LENGTH,A * COPY =BUFFER ADDRESS,X *  JST DUMP * * CALLS: CALLED BY: * ERSET TESTB * DUMPND TESTC * MSGA TESTD1 * OHEX TESTE * CRLF TSTHR4 *  OTTY * ****************************** * DUMP ENT BUFFER DUMP ROUTINE COPY A,DUMPLN SAVE LENGT COPY X,DUMPAD AND ADDRESS COPY MODE,A CLSN ='T',A JMP DUMP5 JST ERSET 6 JMP DUMP4 COPY CAR,A ERROR MESS AGE? (BIT 1 SET) SHIFT A,RO,2 JT OV,DUMP3 YES, SKIP IT JST DUMPND SEE IF DUMP SUPRESSED DUMP5 JST MSGA PRINT "DUMP"  WORD DUMPMG COPY DUMPAD,A GET ADDRESS JST OHEX PRINT IT DUMP1 JST CRLF COPY =-14,A 14 WDS/LINE COPY A,DUMPCT DUMP2 COPY MODE,A CLSN ='T',A JMP $+2 JST DUMPND EXIT IF DUMP SUPRESSED COPY *DUMPAD,A GET A WORD  JST OHEX PRINT IT IMS DUMPAD BUMP PTR COPY =' ',A PRINT SPACE JST OTTY IMS DUMPLN BUMP COUNT JMP $+2 DUMP3 JMP *DUMP EXIT IF DONE IMS DUMPCT BUMP WDS PERLINE COUNT JMP DUMP2 PRINT NEXT WORD JMP DUMP1 PRINT NEXT LI4 NE DUMPND ENT SEE IF COPY CAR,A DUMP WANTED? (BIT 0 SET?) SHIFT A,RO,1 JF OV,DUMP3 NO, EXIT DUMP4 EQU $ JMP *DUMPND YES,CONTINUE * DUMPAD WORD 0 BUF PTR DUMPLN WORD 0 TOTAL COUNT DUMPCT WORD 0 WDS PER LINE COUNT * LPOOL TITL 'ERROR' SUBROUTINE ****************************** * * ERROR - PRINTS ERROR REPORT * * THIS SUBROUTINE WILL PRINT * AN ERROR REPORT IN THE FOLLOWING * FORMAT: * * ER XXXX * ER AD :XXXX PASS XXXX UNIT XXXX TEST X * IOB ADDRESS :XXXX * STATUS :XXXX ( XXXX XXXX XXXX XXXX ) * DRIVE STATUS :XXXX ( XXXX XXXX XXXX XXXX ) * FUNC :XXXX (FUNCTION) CYL XXXX HEAD XXXX SECT XXXX * BUF :XXXX LEN :XXXX WDS XFRD :XXXX * INT LOC :XXXX * * CALLING SEQUENCE: * COPY =ERROR NUMBER,A * JST ERROR * * CALLS: CALLED BY: * ERSET  TESTB * MSGA TESTC * ODEC TESTD1 * OHEX  TESTE * SPACE TESTF * OTTY TESTG * OBIN TESTH * DINIT * DOIO * STATUS * ****************************** * ERROR ENT COPY S,Q SAVE PSW RBIT 6,S XA-BIT MUST BE OFF COPY A,ERT1 SAVE ERROR NO COPY ERROR,A DONT CALL ERSET IF SUB =STAT8,A STALT CALL JEQ A,ERRO20 COPY MODE,A OR IF FORMATTER  CLSN ='F',A JMP ERRO20 COPY =ERR0,A BUMP TOTAL ERROR COUNT ADD UCUR,A COPY A,X IMS 0(X) NOP  COPY ERROR,A SUB =DINIT6,A OR DINIT CALL JEQ A,ERRO20 COPY ADRIOB,X INDEX IOB JST ERSET JMP ER3A EXIT ERRO20 EQU $ COPY =-5,A ALLOW FIVE NEXT DIB'S COPY A,ERT2 COPY ADRIOB,X GET IOB ADDR COPY CAR,A ERROR MESSAGE? (BIT 1 SET) SHIFT A,RO,2 JT OV,ERRTT NO, EXIT JST MSGA PRINT ERRORNO WORD ERMS1 COPY ERT1,A JST ODEC COPY MODE,A CLSN ='F',A FORMATTING? JMP $+2 YES JMP ERROR6 NO JST MSGA YES, SAY SO WORD ERMS2 ERROR6 JST MSGA PRINT ERROR ADDR WORD ERMS3 COPY STATER,A DID ERROR OCCUR IN STATUS ROUTINE? JEQ A,ERRR6A COPY STATAD,A YES JMP ERRR6B ERRR6A COPY ERROR,A NO ERRR6B SUB =1,A JST OHEX COPY MODE,A CLSN ='F',A FORMAT? JMP ERROR5 YES, DONT PRINT PASS JST SPACE JST MSGA PRINT PASS NO WORD ERMS4  COPY PASCTR,A JST ODEC ERROR5 JST SPACE JST MSGA PRINT UNIT NO WORD ERMS5 COPY UCUR,A JST ODEC  COPY MODE,A CLSN ='F',A FORMAT? JMP ERROR7 YES DONT PRINT TEST NO JST SPACE JST MSGA PRINT CURRENT TEST NO WORD ERMS6 COPY TCUR,A JST OTTY COPY ERT1,A GET ERROR NUMBER SUB =91,A IS IT THE SAL ERROR JNE A,ERROR7 JMP ERRSAL ERROR7 JNE X,$+2 EXIT IF NO IOB ADDRESS ERRTT JMP ER3A EXIT COPY ERT1,A ALSO EXIT IF JEQ A,ERRTT ERROR #0 SUB =1,A OR ERROR #1 JEQ A,ERRTT JST MSGA PRINT IOB ADDR WORD ERMS7 COPY X,A JST OHEX JST MSGA PRINT CONTROLLER STATUS WORD ERMS8 COPY CST(X),A JST OHEX COPY CST(X),A JST OBIN5  ALSO IN BINARY JST MSGA WORD ERMS9 PRINT DRIVE STATUS COPY DST(X),A JST OHEX COPY DST(X),A JST OBIN ALSO IN BINARY JST MSGA PRINT FUNCTION WORD ERMS10 COPY OP(X),A OUTPUT OPCODE JST OHEX COPY  =:F,A AND OP(X),A COPY A,ERT3 COPY =ERFCTB,A ADD ERT3,A FIND FUNCTION IN TABLE COPY A,X COPY 0(X),A COPY ADRIOB,X COPY A,$+2 STORE ADDR IN PRINT CALL JST MSGA PRINT FUNC WORD $-$ ADDR OF FUNCMSG GOES HERE JST SPACE JST MSGA PRINT CYL WORD ERMS11 JMP ERRO13 LPOOL ERRO13 EQU $ COPY ERT1,A GET ERROR NO CLSN =41,A IF 41 JMP ERRO11 CLSN =51,A OR 51 JMP ERRO11 THEN PRINT ORIGINAL ADDR COPY CS(X),A AND =:FFF,A JST ODEC JST SPACE JST MSGA PRINT HEAD WORD ERMS12 COPY HS(X),A JST ODEC JST SPACE JST MSGA PRINT SECTOR WORD ERMS13 COPY SSS(X),A JMP ERRO10 * LPOOL TITL ERRO11 COPY CCUR,A SHOW ORIGINAL CYL JST ODEC JST SPACE JST MSGA WORD ERMS12 COPY HCUR,A ORIGINAL HEAD JST ODEC JST SPACE JST MSGA WORD ERMS13 COPY SCUR,A AND ORIG SECTOR NOS ERRO10 JST ODEC JST MSGA PRINT BUFFER ADDR WORD ERMS14 COPY MA(X),A JST OHEX JST SPACE JST MSGA PRINT REQUESTED LENGTH WORD ERMS15 COPY WC(X),A JST OHEX JST SPACE JST MSGA PRINT WDS ACTUALLY XFERRED WORD ERMS16 COPY XF(X),A JST OHEX COPY ERT1,A SEE IF WORD MISCOMP ERROR CLSN =40,A JMP ERRO12 CLSN =50,A JMP ERRO12 JMP ERROR1 NO, SKIP NEXT INFO ERRO12 JST MSGA YES PRINT MISCOMP STUFF WORD ERMS17 COPY MISCAD,A JST OHEX JST SPACE JST MSGA PRINT EXPECTED WORD WORD ERMS18 COPY EXP,A JST OHEX JST SPACE JST MSGA PRINT ACTUAL WORD WORD  ERMS19 COPY ACT,A JST OHEX ERROR1 COPY IN(X),A JEQ A,ERROR9 NO, SKIP NEXT JST MSGA YES, PRINT INT LOC  WORD ERMS20 COPY IN(X),A JST OHEX ERROR9 COPY ERT1,A SEE IF ERROR NO IS CLSN =41,A 41 JMP ERROR8 CLSN =51,A OR 51 JMP ERROR8 IF SO, PRINT JMP ERROR2 ERROR8 JST MSGA CHANGED CYL/HD/SECTOR STUFF WORD ERMS21  COPY CS(X),A PRINT NEW CYL NO AND =:FFF,A JST ODEC JST SPACE COPY HS(X),A NEW HEAD, JST ODEC JST SPACE COPY SSS(X),A AND NEW SECTOR NO JST ODEC ERROR2 COPY NB(X),A JEQ A,ERROR3 NO, SKIP IT ERROR4 COPY A,ERT4 SAVE CHAINED IOB ADDR JST MSGA PRINT WORD CHAINED IOB WORD ERMS22 COPY ERT4,A JST OHEX PRINT ADDRESS JST SPACE JST MSGA PRINT WORD COUNT WORD ERMS23 COPY ERT4,X COPY 0(X),A JST OHEX JST SPACE  JST MSGA PRINT BUF ADDR WORD ERMS24 COPY 1(X),A JST OHEX COPY 3(X),A ANOTHER CHAINED IOB JEQ A,ERROR3 NO, SKIP IT COPY ERT1,A GET ERROR NO CLSN =72,A IF 72,EXIT JMP ERROR3 COPY 3(X),A IMS ERT2  YES BUMP COUNT OF 5 JMP ERROR4 PRINT NEXT CHAINED IOB ER3A EQU $ ERROR3 COPY ADRIOB,X RESTORE IOB ADDRESS COPY CAR,A GET RUN OPTIONS TBIT 4,A HALT ON HARD ERROR? JF OV,$+2 IF NOT, JUMP HLT OTHERWISE HALT COPY Q,S RESTORE STATUS REGISTER C6 OPY ERROR,Y JMP 0(Y) AND EXIT ERRSAL EQU $ JST MSGA WORD SALERR JST MSGA WORD ERMS18 COPY DEVAD,A GET EXPECTED DEVICE ADDRESS JST OHEX PRINT IT JST SPACE JST MSGA WORD ERMS19 COPY SALACT,A JST OHEX PRINT ACTAL DEVICE ADDRESS JMP ERROR3 * ERT1 WORD 0 SAVED ERROR NO. ERT2 WORD 0 COUNT OF 5 IOB'S ERT3 WORD 0 FUNC CODE (0-9) ERT4 WORD 0 NEXT DIOB ADDRESS * LPOOL TITL 'ERSET' SUBROUTINE ****************************** * * ERSET - CHECK 'ERFLAG' * * THIS SUBROUTINE IS CALLED PRIOR TO * AN ERROR PRINTOUT, TO SEE IF WE ARE * IN THE MIDDLE OF A RETRY SEQUENCE. *  IF SO, THE ERROR SHOULD NOT BE * DISPLAYED. THIS SUBROUTINE ALSO * INCREMENTS 'ERFLAG' FOR RETRY. * * CALLING SEQUENCE: * JST ERSET * JMP ? SKIP ERROR REPORT R * JMP ? PRINT ERROR REPORT R+1 * * CALLS: CALLED BY: * NONE TESTB * TESTC *  TESTD1 * TESTE * TESTF *  DUMP * ERROR * ****************************** * ERSET ENT IMS ERFLAG BUMP ERROR FLAG COPY ERCT1,A IS THIS FIRST ERROR JNE A,$+2 NO, SKIP ERROR PRINT IMS ERSET YES PRINT ERROR  JMP *ERSET RETURN TITL 'FILCON' SUBROUTINE ****************************** * * FILCON - FILL I/O BUFFER * * THIS SUBROUTINE FILLS THE 520 WORD * I/O BUFFER WITH THE CONTENTS OF THE * A REGISTER. THE A REGISTER MUST *  BE LOADED WITH THE FILL CHARACTER * PRIOR TO ENTERING THIS ROUTINE. * * CALLING SEQUENCE: * COPY =FILL CHARACTER,A * JST FILCON * * CALLS: CALLED BY: * MOVE TESTB *  TESTD1 * TESTE * TESTF * ****************************** * FILCON ENT SPREAD A CONSTANT COPY A,BUF TO BUFFER COPY =-519,A 519 WORDS JST MOVE MOVE IT  WORD BUF WORD BUF+1 JMP *FILCON EXIT * LPOOL TITL 'FILINC' SUBROUTINE ****************************** * * FILINC - FILL I/O BUFFER * * THIS SUBROUTINE WILL SPREAD * AN INCREMENTING PATTERN INTO THE * 520 WORD BUFFER. * * ENTER WITH THE STARTING VALUE IN * THE A REGISTER. * * CALLING SEQUENCE: * COPY =STARTING VALUE,A * JST FILINC * * CALLS: CALLED BY: * NONE TESTE * ****************************** * FILINC ENT COPY X,FILNCX SAVE X-REG COPY TTBUF,X PTR TO BUFFER COPY A,0(X) STORE FIRST VALUE COPY =-519,A SET COUNT COPY A,FILNCT FILNC1 COPY 0(X),A SPREAD TO NEXT WORD ADD FILNCX,A BUMP IT COPY A,1(X) ADD =1,X BUMP POINTER IMS FILNCT AND COUNT JMP FILNC1 CONTINUE COPY FILNCX,X RESTORE X-REG JMP *FILINC RETURN * FILNCT WORD 0 COUNT FILNCX WORD 0 X-REG SAVER TITL 'IDEC' SUBROUTINE ****************************** * * IDEC - INPUT DECIMAL NUMBER * * THIS SUBROUTINE WILL INPUT, FROM * THE CRT/TTY, AN ASCII-DECIMA7 L VALUE * WHICH IT WILL CONVERT TO BINARY AND * RETURN IT IN THE X REGISTER. * * THIS SUBROUTINE IS EXITED UPON INPUT OF * THE FIRST NON ASCII-DECIMAL CHARACTER, WHICH * IT WILL RETURN IN THE A REGISTER. * * DURING THIS SUBROUTINE, A QUESTION MARK IS * OUTPUT IF THE INPUT VALUE BECOMES GREATER * THAN 32768 AND RESTARTS THE INPUT. * * CALLING SEQUENCE: * JST IDEC * * CALLS: CALLED BY: * IKB QUERIES * OTTY * ****************************** * IDEC ENT INPUT A DECIMAL VALUE IDEC4 COPY =0,A CLEAR VALUE CELL COPY A,IDCTM1 COPY A,IDCTM3 AND COUNT IDEC3 JST IKB GET A CHAR COPY A,IDCTM2 SAVE IT SUB ='0',A SEE IF ASCII 0-9 JLT A,IDEC1 TERMINATOR SUB =10,A JGE A,IDEC1 TERMINATOR IMS IDCTM3 BUMP COUNT COPY IDCTM1,A ADD TO VALUE SHIFT A,LO,2 TIMES 4 ADD IDCTM1,A TIMES 5 SHIFT A,LO,1 TIMES 10 ADD IDCTM2,A ADD NEW VALUE SUB ='0',A LESS ASCII PART JLT A,IDEC2 MINUS IS BAD COPY A,IDCTM1 STORE NEW VALUE JMP IDEC3 GET NEXT INPUT IDEC1 COPY IDCTM2,A GET VALUE IN A COPY IDCTM1,X GET TERMINATOR IN X JMP *IDEC EXIT IDEC2 COPY ='?',A ERROR JST OTTY OUTPUT "?" JMP IDEC4 START AGAIN * IDCTM1 WORD 0 VALUE CELL IDCTM2 WORD 0 ASCII CHAR CELL IDCTM3 WORD 0 COUNT * LPOOL TITL 'IHEX' SUBROUTINE ****************************** * * IHEX - INPUT HEXADECIMAL NUMBER * *  THIS SUBROUTINE WILL INPUT, THROUGH * THE CRT/TTY, AN ASCII-HEX VALUE WHICH * IT WILL CONVERT TO BINARY AND RETURN IT * IN THE X REGISTER. * * THIS SUBROUTINE IS EXITED UPON INPUT OF THE * FIRST NON ASCII-HEX CHARACTER WHICH IT * RETURNS IN THE A REGISTER * * CALLING SEQUENCE: * JST IHEX * * CALLS: CALLED BY: * IKB QUERIES * ****************************** * IHEX ENT INPUT HEX VALUE (4-DIGIT) COPY  =0,A CLEAR VALUE AREA COPY A,IDCTM1 COPY A,IDCTM3 AND COUNT IHEX3 JST IKB GET A CHAR COPY A,IDCTM2 SAVE IT SUB ='0',A CHECK FOR HEX JLT A,IHEX4 TERMINATOR SUB =9,A ITS 0-9 JLE A,IHEX1 ITS 0-9 SUB =9,A  ADD =1,A JLT A,IHEX4 TERMINATOR SUB =5,A JGT A,IHEX4 TERMINATOR ADD =:F,A ITS A-F IHEX2 COPY A,IDCTM2 SAVE HEX CHAR COPY IDCTM1,A INCLUDE IT IN VALUE SHIFT A,LO,4 OR IDCTM2,A 6 COPY A,IDCTM1 IMS IDCTM3 BUMP COUNT JMP IHEX3 GET NEXT CHAR IHEX1 ADD =9,A HEX 0-9 JMP IHEX2 IHEX4 COPY IDCTM2,A LOAD TERMINATOR IN 4  COPY IDCTM1,X LOAD VALUE IN X JMP *IHEX RETURN TITL PROGRAM UTITLITIES (IKB) ****************************** * * IKB - THIS SUBROUTINE WILL INPUT, INTO * THE LEAST SIGNIFICANT BYTE OF THE * A REG., AN ASCII CHAR. FROM * THE CRT KEYBOARD/TTY. * * CALLING SEQUENCE: * JST IKB * ****************************** * IKB ENT INPUT FROM CRT/TTY COPY Q,IKBTMP1 SAVE Q REG. COPY X,IKBTMP2 SAVE X REG. COPY MCSFLG,Q ARE WE USING MCS JEQ Q,$+3 JUMP IF NOT JST MCSIN MUST BE MULTI-CHANNEL JMP MCSDIO COMMON CODE FOR SPI & MCS COPY =:8618,A GET CRT/TTY INPUT STARTUP COM. OUT A,DTTYDA%1;1 SEND TO CRT/TTY 8 IN DTTYDA%1;1,A GET STATUS FROM CRT/TTY SHIFT A,RO,4 SHIFT 'DATA READY' BIT (3) INTO OV JF OV,$-2 IF 'DATA READY' BIT IS RESET, LOOP BACK IN DTTYDA%1,A INPUT ASCII CHAR. FROM CRT/TTY COPY =:100,X GET CRT/TTY RESET COM. CODE OUT X,DTTYDA%1;1 SEND TO CRT/TTY MCSDIO EQU $ AND =:7F,A MASK OFF POSSIBLE PARITY BIT COPY IKBTMP1,Q RESTORE Q REG. COPY IKBTMP2,X RESTORE X REG. JMP *IKB EXIT * TITL MULTI-CHANNEL INPUT DRIVER (MCSIN) *********************************** * * MCSIN MULTI-CHANNEL INPUT * *  THIS SUBROUTINE IS USED TO GET * INPUT FROM THE KEYBOARD THROUGH * THE MULTI-CHANNEL SERIAL CARD. * THE A REG. WILL HAVE THE INPUTED * CHARACTER ON RETURN FROM THIS ROUTINE. * * CALLING SEQUENCE: * JST MCSIN * *********************************** * MCSIN ENT NOW ENTERING THE WORLD OF MULTI-CHANNEL ECHOWT EQU $ COPY =MCSDA,Q GET DEVICE ADDRESS OF THE MCS XNX Q IN 1,A TRANSMITTED BEFORE ENABLING ECHO TBIT 2,A IS TRANSMITTER EMPTY??? JF OV,ECHOWT IF NOT, THEN MUST WAIT UNTIL THEN... COPY =MCECHO,A NOW, SET ECHO TO RECIEVE XNX Q SELP A,3 BOARD CONTROL WORD WAIT2 EQU $ XNX Q IN 1,A GET CHANNEL ZERO STATUS TBIT 7,A DEVICE READY JF OV,WAIT2 IF NOT, KEEP WAITING .... COPY =MC06,A DTR & RECEIVE ENABLE CONTROL WORD XNX Q OUT A,1 CHANNEL CONTROL WORD WAITR EQU $ XNX Q IN 1,A WAIT FOR RECEIVE READY TBIT 1,A JF OV,WAITR XNX Q IN 0,A GET DATA BYTE COPY =0,X CLEAR TRANS/REC. XNX Q OUT X,1 CHANNEL CONTROL WORD COPY =MCNECHO,X DISABLE AUTO ECHO XNX Q SELP X,3 BOARD CONTROL WORD JMP *MCSIN RETURN * MCECHO EQU :18 MC06 EQU :06 IKBTMP RES 1,0 SAVED INPUT CHAR. IKBTMP1 RES 1,0 SAVE Q REG. IKBTMP2 RES 1,0 SAVE X REG. TITL 'INCR' SUBROUTINE ****************************** * * INCR - INCREMENT CURRENT SECTOR, HEAD, CYLINDER * * THIS SUBROUTINE WILL INCREMENT THE CURRENT * SECTOR NUMBER. WHEN ALL SECTORS ARE DONE, *  IT WILL INCREMENT THE CURRENT HEAD NUMBER. * WHEN ALL HEADS ARE DONE, IT WILL INCREMENT * THE CURRENT CYLINDER NUMBER. WHEN ALL * CYLINDER ARE DONE, IT WILL RETURN TO * RETURN ADDRESS + 1. * * CALLING SEQUENCE: *  JST INCR * JMP ? STILL INCREMENTING R * JMP ? ALL CYLINDERS ARE DONE R+1 * * CALLS:  CALLED BY: * NONE TESTD * TESTI * ****************************** * INCR ENT BUMPSECTOR NO IMS SCUR COPY SCUR,A LAST SECTOR? CSK A,SECS JMP *INCR NO, EXIT NOP INCR2 COPY =0,A RESET SECTOR NO COPY A,SCUR IMS HCUR COPY EHD,A NO CSK A,HCUR LAST HEAD JMP INCR6 YES, RESET HEAD NO NOP NO JMP *INCR INCR6 COPY SHD,A RESET HEAD NO COPY A,HCUR IMS CCUR COPY ECYL,A IS THIS LAST CYL CSK A,CCUR JMP INCR3 YES NOP NO JMP *INCR NO, RETURN INCR3 COPY SCYL,A RESET CYL COPY A,CCUR IMS INCR SPECIAL RETURN JMP *INCR * * INCRH - SAME AS 'INCR' EXCEPT THE * HEAD AND CYLINDER NUMBERS * ONLY ARE INCREMENTED. * * SECTOR = 0 * INCRH ENT COPY INCRH,A SAVE RETURN AD COPY A,INCR JMP INCR2 SKIP SECTOR UPDATE * LPOOL TITL I/O SUBROUTINES ****************************** * * OTA * OTX * SEL * S9 ENHIM * SENRDY - I/O SUBROUTINES * * THESE SUBROUTINES PERFORM THE * ACTUAL I/O TO THE CONTROLLER. * *  OTA - OUPUT A REGISTER FC. = 0 * * OTX - OUPUT X REGISTER FC. = 0 * * SEL - SELECT AND PRESENT A FC. = 4 * * SENHIM - SENSE PRESENCE FC. = 4 * * SENRDY - SENSE READY FC. = 0 * * CALLING SEQUENCE: * OTA - COPY =IOB ADDRESS,A * JST OTA * * OTX - COPY =IOB ADDRESS,X * JST OTX * * SEL - JST SEL * * SENHIM - JST SENHIM * JMP ? CONTROLLER NOT PRESENT R * JMP ? CONTROLLER PRESENT R+1 * * SENRDY - JST SENRDY * JMP ?  CONTROLLER NOT READY R * JMP ? CONTROLLER READY R+1 * * CALLS: CALLED BY: *  NONE TESTB * TECH TEST * DINIT *  TESTF * TESTH * DOIO *  PROGRAM START UP * TRAP SERVICE ROUTINES * CONSOLE SERVICE ROUTINE * ****************************** * OTA ENT DA1 EQU $ OUT A,SMDA*8+0 OUTPUT A-REG JMP *OTA * OTX ENT DA2 EQU $ OUT X,SMDA*8+0 OUTPUT X-R JMP *OTX * SEL ENT COPY A,SEL1 JST TIMER COPY =0,A DA3 SELP A,SMDA*8+4 COPY SEL1,A XYZZY JST SENRDY WAIT FOR READY DRIVE JMP $+2 JMP $+3 JST TIME WE WILL ONLY WHAT FOR 7 SECONDS JMP XYZZY NOT TIMED OUT JMP *SEL SEL1 WORD 0 * SENHIM ENT DA4 EQU $ SST SMDA*8+4 SENSE PRESENCE JMP *SENHIM IMS SENHIM JMP *SENHIM * SENRDY ENT DA5 EQU $ SST SMDA*8+0 SENSE IDLE JMP *SENRDY IMS SENRDY JMP *SENRDY * TITL 'MASK' SUBROUTINE ****************************** * * MASK - MASK UNWANTED BITS * * THIS SUBROUTINE IS USED * TO MASK OUT UNWANTED BITS AFTER * A RANDOM NUMBER IS GENERATED. * * ENTER WITH HIGHEST POSSIBLE VALUE IN A REGISTER * EXIT WITH NUMBER IN X REGISTER. * * CALLING SEQUENCE: * COPY =HIGHEST POSSIBLE VALUE,A * JST MASK * * CALLS: CALLED BY: * NONE TESTE * ****************************** * MASK ENT COPY =0,X MASK1 JEQ A,MASK2 IF A=0, MASK COMPLETE SHIFT A,RO,1 SBIT 1,S ROTATE X,LO,1 SHIFT "1" BIT INTO X JMP MASK1 MASK2 JMP *MASK TITL 'MKIOB' SUBROUTINE ****************************** * * MKIOB - UPDATE IOB * * THIS SUBROUTINE IS USED * TO UPDATE THE FOLLOWING * PARAMETERS IN THE IOB: * * UNIT *  CYLINDER * HEAD * SECTOR * * IT ALSO PRESETS THE WORDS TRANSFERRED, * RETURNED STATUS, AND RETURNED DRIVE STATUS * TO :FFFF. * * CALLING SEQUENCE: * JST MKIOB * * CALLS: CALLED BY: * NONE TESTA * TESTB * TESTC *  TD4C * TE4C * TESTF * :  TESTG * TESTH * FMATTR * ******************************** * MKIOB ENT COPY ADRIOB,X INDEX IOB COPY UCUR,A SET CURRENT UNIT COPY A,US(X) STORE UNIT COPY CCUR,A SET CURRENT CYL COPY A,CS(X) STORE CYL COPY HCUR,A SET CURRENT HEAD COPY A,HS(X) STORE HEAD COPY SCUR,A SET CURRENT SECTOR COPY A,SSS(X) STORE SECTOR COPY =-1,A COPY A,XF(X) PRESET WDS XFRRED COPY A,CST(X) AND STATA COPY A,DST(X) JMP *MKIOB BACK TO CALLER. * LPOOL TITL 'MOVE' SUBROUTINE ****************************** * * MOVE - MOVE A BLOCK OF DATA * * THIS SUBROUTINE IS USED * TO MOVE A BLOCK OF DATA FROM *  ONE AREA OF MEMORY TO ANOTHER. * * ENTER WITH NEGATIVE DATA LENGTH IN * A REGISTER * * CALLING SEQUENCE: *  COPY =-DATA LENGTH,A * JST MOVE * WORD AREA1 ADDRESS OF 'FROM AREA' * WORD AREA2 ADDRESS OF 'TO AREA' * * CALLS: CALLED BY: * NONE QUERIES *  TESTB * TESTC * TECH TEST * FILCON * ****************************** * MOVE ENT MOVE WORD ROUTINE COPY A,MOVECT SAVE LENGTH COPY *MOVE,A  GET "FROM" ADRESS COPY A,MOVEFM IMS MOVE COPY *MOVE,A GET "TO" ADRESS COPY A,MOVETO IMS MOVE BUMP FOR RTN MOVE1 COPY *MOVEFM,A GET A WORD COPY A,*MOVETO MOVE IT IMS MOVEFM BUMP FROM IMS MOVETO BUMP TO IMS MOVECT BUMP COUNT JMP MOVE1 MOVE NEXT WORD JMP *MOVE EXIT * MOVECT WORD 0 COUNT MOVEFM WORD 0 FROM AD MOVETO WORD 0 TO AD TITL 'MSGA' SUBROUTINE ****************************** * * MSGA - PRINT ASCII MESSAGE * * THIS SUBROUTINE WILL * PRINT AN ASCII MESSAGE TO * THE CRT/TTY. THE LAST * CHARACTER OF THE MESSAGE MUST * BE :FF. * * CALLING SEQUENCE: * JST MSGA * WORD MESSAGE ADDRESS * * CALLS: CALLED BY: * OTTY  QUERIES * TEST CONTROL * TESTB *  TESTF * FMATTR * TECH TEST *  DUMP * ERROR * ODEC *  TSTITL * TRAP SERVICE ROUTINES * ****************************** * MSGA ENT PRINT A MSG ROUTINE COPY X,MSGA3 SAVE X REG COPY *MSGA,X GET MSG ADRESS SHIFT X,LO,1 IMS MSGA BUMP FOR RTN MSGA1 SBIT 2,S COPYB 0(X),A GET A CHAR RBIT 2,S CLSN =:FF,A IS IT END OF MSG JMP MSGA2 YES EXIT JST OTTY PRINT A CHAR ADD =1,X BUMP PTR JMP MSGA1 GET NEXT CHAR MSGA2 COPY MSGA3,X RESTORE X REG SBIT 8,S ENABLE INTERRUPTS JMP *MSGA EXIT * MSGA3 WORD 0 SAVE XREG CELL * LPOOL TITL 'NXTHDR' SUBROUTINE ****************************** * * NXTHDR - GENERATE NEXT PARAMETERS * * THIS SUBROUTINE WILL GENERATE * THE NEXT VALUES FOR THE FOL; LWING * PARAMETERS: * * CYLINDER * HEAD * SECTOR * * IF END-OF-MEDIA OCCURS IN THE GENERATION, * A :FFFF IS STORED. * * CALLING SEQUENCE: * JST NXTHDR * * CALLS: CALLED BY: * NONE TESTB * TESTD1 * TE4C * ****************************** * NXTHDR ENT CALC NEXT HDR ADDR COPY CCUR,A UPDATE PTRS COPY A,CNEXT COPY HCUR,A COPY A,HNEXT COPY SCUR,A LOOK AT CURRENT SECTOR COPY A,SNEXT ADD =1,A SUB SECS,A JLT A,$+3 LAST COPY =0,A YES JMP $+2 ADD SECS,A NO COPY A,SNEXT STORE IT JNE A,NXT1 LAST SECT? IMS HNEXT YES. LOOK AT NEXT HEAD COPY EHD,A CSK A,HNEXT LAST HEAD? JMP NXT0 YES NOP JMP *NXTHDR NXT0 COPY SHD,A RESET HEAD NO. COPY A,HNEXT IMS CNEXT BUMP CYL NO COPY ECYL,A CSK A,CNEXT LAST CYL? JMP NXT2 YES  NOP NXT1 JMP *NXTHDR RETURN NXT2 COPY =-1,A SET EOM FLAG COPY A,SNEXT COPY A,HNEXT COPY A,CNEXT  JMP *NXTHDR RETURN * SNEXT WORD 0 NEXT SECTOR HNEXT WORD 0 NEXT HEAD CNEXT WORD 0 NEXT CYL TITL 'OBIN' SUBROUTINE ****************************** * * OBIN - PRINT BINARY NUMBER * * THIS SUBROUTINE WILL PRINT A * BINARY NUMBER TO THE CRT/TTY. * * ENTER WITH THE NUMBER IN THE A * REGISTER * * CALLING SEQUENCE: * COPY =BINARY NUMBER,A * JST OBIN * * CALLS: CALLED BY: * SPACE ERROR * OTTY * ****************************** * OBIN ENT COPY A,OBINA SAVE VALUE JST SPACE COPY ='(',A JST OTTY PRINT OPEN PAREN COPY =' ',A JST OTTY COPY =-4,A COPY A,OBINB SET NIBBLE COUNT OBIN1 COPY =-4,A COPY A,OBINC SET 4-BIT COUNT OBIN2 COPY OBINA,A SHIFT A,LO,1 PICK OFF NEXT BIT COPY A,OBINA COPY ='0',A ITS EITHER A ZERO JF OV,$+2 ADD =1,A OR A '1' JST OTTY PRINT IT IMS OBINC BUMP 4-BIT COUNTER JMP OBIN2 PRINT NEXT BIT COPY =' ',A PRINT SPACE EACH 4 BITS JST OTTY IMS OBINB BUMP NIBBLE COUNT JMP OBIN1 GET NEXT NIBBLE COPY =')',A ALL DONE JST OTTY PRINT CLOSE PAREN JMP *OBIN EXIT * OBINA WORD 0 VALUE OBINB WORD 0 NIBBLE COUNT OBINC WORD 0 4-BIT COUNT * LPOOL TITL 'ODEC' SUBROUTINE ****************************** * * ODEC - PRINT DECIMAL NUMBER * * THIS SUBROUTINE WILL CONVERT THE * A REGISTER TO AN EQUIVALENT DECIMAL * NUMBER AND PRINT IT TO THE CRT/TTY IF * IT IS LESS THAN 10000. IF IT IS GREATER * THAN 10000 IT WILL PRINT '****'. * * ENTER WITH NUMBER IN THE A REGISTER * * CALLING SEQUENCE: * COPY =NUMBER,A * JST ODEC * * CALLS: CALLED BY: * MSGA TEST CONTROL * OTTY FMATTR * ERROR * ****************************** * ODEC ENT OUTPUT A 5-DIGIT DECIMAL NO COPY X,ODECX SAVE X-REG COPY A,IDCTM1 SAVE BINARY VALUE CSK A,ODCTBL+1 IS IT GREATER THAN 10,000? JMP ODEC0 NO, CONTINUE NOP JST MSGA YES, PRINT '****' < WORD STARS JMP ODEC2 EXIT ODEC0 COPY ODCTBL,A GET TABLE COPY A,IDCTM2 COPY =-5,A COUNT 5 DIGITS COPY A,IDCTM3 ODEC1 COPY IDCTM1,A GET REMAINDER COPY IDCTM2,Y COPY ='0'-1,X SUB 0(Y),A DIVIDE INDECIMAL ADD =1,X ADD TO OUTPUT VALUE JGE A,$-2 ADD 0(Y),A ADD BACK IN IF GONE NEG COPY A,IDCTM1 STORE REMAINDER COPY X,A JST OTTY PRINT CALCULATED DIGIT IMS IDCTM2 BUMP TABLE PTR IMS IDCTM3 AND COUNT JMP ODEC1 DO NEXT DIGIT ODEC2 COPY  ODECX,X RESTORE X-REG JMP *ODEC EXIT AFTER 5 * ODCTBL WORD $+1,10000,1000,100,10,1 ODECX WORD 0 X-REG SAVE * LPOOL TITL 'OHEX' SUBROUTINE ****************************** * * OHEX - PRINT HEX NUMBER * * THIS SUBROUTINE WILL CONVERT * THE A REGISTER TO AN EQUIVALENT * ASCII-HEX NUMBER AND PRINT IT TO * THE CRT/TTY. * * ENTER WITH NUMBER IN THE A REGISTER * * CALLING SEQUENCE: * COPY =NUMBER,A * JST OHEX * * CALLS: CALLED BY: * OTTY TESTB * DUMP * ERROR * ****************************** * OHEX ENT OUTPUT 4 HEX DIGITS COPY X,ODECX SAVE X-REG COPY A,X SAVE NO FOR OUTPUT COPY =-4,A COPY A,OHEXC1 OUTPUT 4 HEX DIGITS OHEX1 COPY =-4,A COPY A,OHEXC SHIFT COUNT = 4 COPY =0,A CLEAR OUT A REG. OHEX2 ROTATE X,LO,1 MS. BIT OF X ROTATE A,LO,1 BECOMES LS. BIT OF A IMS OHEXC BUMP SHIFT COUNT JMP OHEX2 AND COUNTINUE SUB =10,A FIX TO ASCII JLT A,$+2 NUMERIC? ADD =7,A ADD ='9'+1,A NO, ITS A-F JST OTTY OUTPUT THE DIGIT IMS OHEXC1 4 DIGITS YET? JMP OHEX1 NO. DO ANOTHER COPY ODECX,X YES RESTORE X JMP *OHEX AND EXIT * OHEXC1 WORD 0 4-DIGIT COUNTER OHEXC WORD 0 4-BIT SHIFT COUNT * LPOOL * TITL PROGRAM UTILITIES (OTTY) ****************************** * * OTTY - OUTPUT THE LEAST SIGNIFICANT BYTE OF * THE A REG. TO THE CRT/TTY AND LP IF 'LPFLG' * IS SET. IF THE LP TIMES OUT, AN * ERROR MESSAGE WILL BE DISPLAYED ON THE * CRT/TTY. TO RESTART PRESS ANY KEY ON THE *  KEYBOARD. * * THIS SUBROUTINE WILL BE BYPASSED IF THE * SENSE SWITCH IS SET. * * * LPFLG: * 0 - CRT/TTY ONLY * 1 - CRT/TTY AND LP * * CALLING SEQUENCE: * COPY =CHAR.,A * JST OTTY * * ENTER WITH THE ASCII CHAR. IN THE A REG. * ****************************** * OTTY ENT OUTPUT TO CRT/TTY RBIT 8,S ENSURE INTS. ARE DISABLED JF SS,$+2 IF SENSE SWITCH IS SET, BYPASS OUTPUT JMP *OTTY EXIT COPY X,OTTMP1 SAVE X REG. COPY A,OTTMP2 SAVE A REG. COPY Q,OTTMP7 SAVE THE Q REG. COPY MCSFLG,Q IS IT MULTI-CHANNEL JEQ Q,$+3 JUMP IF NOT JST MCSOUT MUST BE MULTI CHANNEL JMP *OTTY EXIT COPY =:100,X GET CRT RESET COM. OUT X,DTTYDA%1;1 RESET CRT/TTY PICO COPY =:8612,X CRT/TTY STARTUP COM. OUT X,DTTYDA%1;1 SEND COM. CODE TO CRT/TTY OUT A,DTTYDA%1 SEND CHAR. TO CRT/TTY IN DTTYDA%1;1,X INPUT STATUS FROM CRT/TTY SHIFT X,RO,5 SHIFT 'TX EMPTY' BIT (4) INTO OV JT OV,$-2 IF TRUE -TX EMPTY- LOOP BACK IN DTTYDA%1;1,X INPUT STATUS FROM CRT/TTY SHIFT X,RO,5 SHIFT 'TX EMPTY' BIT (4) INTO OV JF OV,$-2 IF FALSE -TX FULL- LOOP BACK COPY =:100,X GET CRT/TTY RESET COM. CODE OUT X,DTTYDA%1;= 1 SEND TO CRT/TTY OTTY0 COPY LPFLG,X GET LP FLAG JNE X,OTTY1 JUMP IF LP IS WANTED JMP OTTY6 LP NOT WNAT, EXIT * LPOOL TITL * OTTY1 EQU $ JST TIMER SET TIME COPY OTTMP2,A RESTORE A-REG. OTTY7 COPY =:100,X GET SPI RESET COM OUT X,DLPDA%1;1 SEND IT TO SPI BOARD IN DLPDA%1;1,X INPUT SPI STATUS SHIFT X,RO,1 SHIFT SPI READY BIT TO OV JF OV,$+4 IF READY, SEND CHAR. JST TIME ELSE DO DELAY JMP OTTY7 IF NOT EXPIRED, LOOP BACK JMP OTTERR ELSE DISPLAY TIME OUT MESS. COPY =:8612,X GET SPI START UP COM. OUT X,DLPDA%1;1 SEND IT TO SPI BOARD OUT A,DLPDA%1 SEND CHAR. TO SPI JMP OTTY2 FINISH DELAY * OTTY2 IN DLPDA%1;1,A INPUT STATUS  SHIFT A,RO,1 SHIFT 'BUSY BIT' TO OV JF OV,OTTY5 IF NOT BUSY, EXIT JST TIME DO DELAY JMP OTTY2 LOOP BACK IF NOT DONE OTTERR COPY OTTMP2,A GET ORIGINAL A-REG. CONTENTS COPY A,OTTMP6 SAVE IT COPY LPFLG,A GET LP FLAG COPY A,OTTMP5 SAVE IT COPY =0,A SET NEW LP FLAG COPY A,LPFLG STORE NEW LP FLAG COPY OTTMP1,A GET ORIGINAL X REG. VALUE COPY A,OTTMP3 SAVE IT COPY OTTY,A GET RETURN ADD. COPY A,OTTMP4 SAVE IT IN CONSL;CDR,A GET 'CDR' CONTENTS AND =:FF,A MASK FOR TEST NUMBER ONLY OR =ER3600,A 'OR' IN ERROR CODE SELP A,CONSL;CDR SEND TO 'CDR' COPY =LPMSG*2,X GET ERROR MESSAGE ADD. 'LP TIMEOUT' OTTY3 SBIT BY:,S SET BYTE MODE COPYB 0(X),A GET CHAR. RBIT BY:,S SET WORD MODE JEQ A,OTTY4 IF END OF MESSAGE, EXIT LOOP JST OTTY DISPLAY ON CRT/TTY ADD =1,X INC. MESSAGE ADD. JMP OTTY3 LOOP FOR MORE OTTY4 JST IKB INPUT CHAR. FROM KEYBOARD COPY OTTMP4,A GET RETURN ADD. COPY A,OTTY RESTORE RETURN ADD. COPY OTTMP3,A GET ORIGINAL CONTENTS OF X REG. COPY A,OTTMP1 RESTORE TEMP. CONTENTS COPY OTTMP5,A GET LP FLAG COPY A,LPFLG SET FLAG COPY OTTMP6,A GET ORIGINAL A-REG. CONTENTS COPY A,OTTMP2 SAVE IT JMP OTTY1 TRY TO OUTPUT TO LP AGAIN OTTY5 COPY =:100,X GET LP RESET COMMAND OUT X,DLPDA%1;1 RESET LP SHIFT X,RO,1 WASTE SOME TIME JNE X,$-1 DITTO OTTY6 COPY OTTMP1,X RESTORE X REG. COPY OTTMP2,A RESTORE A REG. JMP *OTTY EXIT * TITL MULTI-CHANNEL OUTPUT DRIVER (MCSOUT) ********************************** * * MCSOUT - MULTI CHANNEL OUTPUT * * THIS SUBROUTINE WILL OUTPUT THE * LEAST SIGNIFICANT BYTE OF THE * A REG. TO THE CRT/TTY AND LINEPRINTER * IF 'LPFLG' IS SET. IF THE LINEPRINTER *  TIMES OUT, AN ERROR MESSAGE WILL BE * DISPLAYED ON THE CRT/TTY. TO RESTART * PRESS ANY KEY ON THE KEYBOARD. * * LPFLG: * 0 - CRT/TTY ONLY * 1 - CRT/TTY AND LP * * CALLLING SEQUENCE: * COPY =CHAR.,A *  JST MCSOUT * ********************************** * * MCSOUT ENT THIS IS THE WERE WE TALK TO THE MCS COPY =MCSDA,Q GET THE DEVICE ADDRESS AND CHANNEL COPY =MCNECHO,X SET FOR NO ECHO XNX Q SELP X,3 BOARD CONTROL WORD COPY =:22,X PSEUDO CONTROL WORD JUST TO READ STATUS XNX Q OUT X,1 NOT ENABLING TRANSMITTER WAIT1 EQU $ XNX Q IN 1,X GET CHANNEL STATUS TBIT 7,X DEVICE READY? JF OV,WAIT1 JUMP IF NOT READY COPY =MC0023,X RTS, DTR, TRANSMIT ENABLE XNX Q OUT X,1 CHANNEL CONTROL WORD WAITW EQU $ XNX Q IN 1,X WAIT FOR TRAMSMIT READY TBIT 0,X JF OV,WAITW XNX Q OUT A,0 SEND DATA BYTE OUT * * THIS IS THE LINE PRINTER DRIVER * COPY LPFLG,X GET LP FLAG JEQ X,OUTEND JUMP TO FINISH IF LP NOT WANTED COPY =MCSDA,Q GET THE DEVICE ADDRESS AND CHANNEL SBI> T 1,Q MAKE IT THE DEVICE ADDRESS FOR CH #1 COPY =MCNECHO,X SET FOR NO ECHO XNX Q SELP X,3 BOARD CONTROL WORD COPY =:22,X PSEUDO CONTROL WORD JUST TO READ STATUS XNX Q OUT X,1 NOT ENABLING TRANSMITTER JST TIMER PRESET THE TIMER WAITLP2 EQU $ XNX Q IN 1,X GET CHANNEL STATUS TBIT 7,X DEVICE READY? JT OV,WAIT3 JUMP IF NOT READY JST TIME CHECK FOR TIME OUT JMP WAITLP2 JMP IF NOT TIMED OUT JMP OTTERR TIMED OUT GO SAY SO WAIT3 EQU $ COPY =MC0023,X RTS, DTR, TRANSMIT ENABLE XNX Q OUT X,1 CHANNEL CONTROL WORD JST TIMER PRESET THE TIME-OUT ROUTINE WAITX EQU $ XNX Q IN 1,X WAIT FOR TRAMSMIT READY TBIT 0,X JT OV,WAIT4 JST TIME CHECK THE TIMEING JMP WAITX STILL OK JMP OTTERR TIME-OUT GO PRINT MESSAGE WAIT4 EQU $ COPY OTTMP2,A GET THE CHARACTER THAT IS TO BE PRINTED XNX Q OUT A,0 SEND DATA BYTE OUT OUTEND EQU $ COPY OTTMP1,X RESTORE THE X REG. COPY OTTMP2,A RESTORE THE A REG. COPY OTTMP7,Q RESTORE THE Q REG. JMP *MCSOUT RETURN TO YOUR MASTER OTTMP1 RES 1,0 SAVED X REG. OTTMP2 RES 1,0 SAVED A REG. OTTMP3 RES 1,0 ORIGINAL X REG. OTTMP4 RES 1,0 ORIGINAL RETURN ADD. OTTMP5 RES 1,0 SAVED LP FLAG OTTMP6 RES 1,0 ORIGINAL A REG. OTTMP7 RES 1,0 SAVE Q REG. MCSDA EQU :40 MULTI-CHANNEL DEVICE ADDRESS MCNECHO EQU :8 MC0023 EQU :23 * LPOOL TITL 'PREP' SUBROUTINE ****************************** * * PREP - PREPARE DISK * * THIS SUBROUTINE WILL PREPARE THE DISK * FOR A NEW TEST. IT WILL RESET THE * CURRENT CYLINDER, CURRENT HEAD AND CURRENT * SECTOR TO THE STARTING VALUES. * * CALLING SEQUENCE: * JST PREP * * CALLS: CALLED BY: * DINIT TESTA *  TESTB * TESTC * TESTD *  TESTI * TESTE * TESTF *  TESTG * TESTH * FMATTR * ****************************** * PREP ENT INITALIZE CYL/HD/SECTOR NOS COPY SSEC,A RESET SECTOR NO COPY A,SCUR COPY SHD,A RESET HD NO  COPY A,HCUR COPY SCYL,A RESET CYL NO COPY A,CCUR JST DINIT RESET THE DISK JMP *PREP EXIT * LPOOL  TITL 'RANDOM' SUBROUTINE ****************************** * * RANDOM - RANDOM NUMBER GENERATOR * * THIS SUBROUTINE WILL GENERATE * A PSEDUO RANDOM NUMBER USING THE * FOLLOWING EQUATION: * * C(I+1) = C(C(I)*Y+U)MOD(P)) * * WHERE * * C(I) = SEED VALUE * C(I+1) = PSEUDO RANDOM NUMBER * U = 0 *  Y = 5**(2K+1) K = 2 * P = 983 * * THE PERIOD FOR THE ABOVE RANDOM SEQUENCE IS 983. * *  EXIT WITH THE RANDOM NUMBER IN THE A REGISTER. * * CALLING SEQUENCE: * JST RANDOM * * CALLS: CALLED BY: * NONE TESTB * TESTE * ****************************** * RANDOM ENT ENTRY/EXIT. COPY X,RMD:X SAVE 'X' REGISTER. COPY =0,A CLEAR A-REG COPY SEED,X SET C(I) --> 'X'. * * NOW CALC C(I)*YYYYYY * MUL YYYYYY,AX * * NOW CALC (C(I)*YYYYYY)MOD(PPPPPP) * DIV PPPPPP,AX COPY A,SEED ? SET NEXT SEED. COPY RMD:X,X REFRESH 'X' REGISTER. JMP *RANDOM BACK TO CALLER. * SEED RES 1 C(I) VALUE. YYYYYY WORD 3125 5**(2K+1) FOR K=2. PPPPPP WORD 983 CAREFULLY CHOOSEN MODULUS. RMD:X RES 1,0 'X' REGISTER KEEPER FOR RANDOM ROUTINE. TITL 'RETRY' SUBROUTINE ****************************** * * RETRY - RETRY I/O * * THIS SUBROUTINE WILL RETRY THE I/O * FUNCTION USING NEXT OFFSET BITS, IF THE * ERFLAG HAS BEEN SET TO A NON ZERO VALUE * (BY 'ERSET'), AND GOING TO "RLOOP" (SET * UP BY 'RYINT'). OTHERWISE, IT WILL GO TO * "*RLOOPX" TO EXIT THE RETRY LOOP. * * THIS SUBROUTINE WILL ALSO INCREMENT THE * SOFT, FIRM, AND HARD ERROR COUNTS. * * CALLING SEQUENCE: *  JST RETRY * * CALLS: CALLED BY: * NONE TESTA * TESTB * TESTC * TESTD1 * TESTE * TESTF * TESTG * TESTH * ****************************** * RETRY ENT COPY =0,A GET ERFLAG EXCH ERFLAG,A AND CLEAR IT TO ZERO JEQ A,RETRY2 IF NO ERRORS, EXIT IMS ERCT1 ELSE BUMP ERROR COUNT IMS ERCOUNT JMP $+2 JMP RETRY1 ALL RETRY'S ARE DONE COPY  ERCT1,A IF FIRST ERROR, CLSN =1,A IMS ERCT2 BUMP SOFT COUNT CLSN =4,A IF FIRST OFFSET IMS ERCT2 BUMP FIRM COUNT JMP *RLOOP GO RETRY RETRY1 IMS ERCT2 BUMP HARD COUNT JMP RETRY3 GO TALLY ERRORS RETRY2 EXCH ERCT1,A ANY PREVIOUS ERRORS? JEQ A,RETRY4 NO, EXIT RETRY3 COPY SFHTBL,A FIND ERROR ADDR IN TBL COPY ADRIOB,X ADD ERCT2,A  COPY A,RETRYA COPY *RETRYA,A ADD US(X),A ADD IN UNIT NO FOR COPY A,RETRYA TABLE ENTRY IMS *RETRYA BUMP ACTUAL ERR COUNT RETRY4 JMP *RLOOPX EXIT * RETRYA WORD 0 TEMP SFHTBL WORD $,SOFT0,FIRM0,HARD0 RLOOP WORD 0 RETRY ADDREDS RLOOPX WORD 0 END RETRY ADDR ERCT1 WORD 0 PRIMARY ERROR COUNT ERCT2 WORD 0 SOFT/FIRM/HARD FLAG ERFLAG WORD 0 ERROR INDICATOR ERCOUNT WORD 0 NEGITIVE ERROR COUNT * * LPOOL TITL 'RYINIT' SUBROUTINE ****************************** * * RYINIT - INITIALIZE ERROR RETRY COUNTERS * * THIS SUBROUTINE WILL INITIALIZE THE * ERROR RETRY COUNTERS, RETRY AND END * RETRY ADDRESSES. * * ENTER WITH IOB ADDRESS IN X REGISTER * * CALLING SEQUENCE: *  COPY =IOB ADDRESS,X * JST RYINIT * WORD ADDRESS1 RETRY ADDRESS * WORD ADDRESS2 END RETRY ADDRESS * * CALLS: CALLED BY: * NONE TESTA * TESTB * TESTC * TESTD1 * TESTE *  TESTF * TESTG * TESTH * ****************************** * RYINIT ENT COPY X,ADRIOB STORE IOB COPY *RYINIT,A GET RETRY ADDRESS COPY A,RLOOP  IMS RYINIT BUMP FOR END RETRY ADDR COPY *RYINIT,A GET IT COPY A,RLOOPX IMS RYINIT BUMP FOR RETURN COPY =-5,A@  RETRY COUNT COPY A,ERCOUNT SET MINUS ERROR COUNT COPY =0,A RESET ERROR COUNTERS COPY A,ERCT1 COPY A,ERCT2 COPY A,ERFLAG JMP *RYINIT EXIT * TITL 'SALTEST' SUBROUTINE ****************************** * * SALTEST - TEST THE SAL INSTRUCTION * * THIS ROUTINE IS CALLED BEFORE * EVERY TEST AND CHECK TO MAKE * SURE THAT THE SAL INSTRUCTION * RETURNS THE PROPER DEVICE ADDRESS. * IF NOT IT REPORTS IT AS A ERROR * DECLARING THAT IT EXCPECTED AND * WHAT IT GOT. * ****************************** * SALTEST ENT COPY BDID,A GET THE DEVICE ADDRESS XNX A SAL 2,0 OK DO THE INSTRUCTION SHIFT A,RO,3 AND =:FF,A COPY DEVAD,Q CSK A,Q CHECK TO SEE IF WE GOT WHAT WE EXCPECTED NOP JMP SALERROR THE DEVICE ADDRESS'S DON'T MATCH JMP *SALTEST ALL'S WELL SO RETURN SALERROR EQU $ COPY A,SALACT COPY =91,A COPY =0,X JST ERROR REPORT THE ERROR JMP TSTEND EXIT * SALACT WORD 0 * LPOOL TITL 'SET READY' SUBROUTINE ****************************** * * SETRDY - SET THE MULTI CHANNEL TO READY * * THIS SUBROTINE RESETS THE * MULTI CHANNEL INTO A READY * STATE. * ****************************** * SETRDY ENT COPY =:8,X UN-RESET CODE SELP X,MCSDA;3 BOARD CONTROL WORD COPY =2,X MEANINGLESS VALUE TO... OUT X,MCSDA;1 JUST FORCE CHANNEL (0) TO TAKE OUT X,MCSDA+2;1 JUST FORCE CHANNEL (1) TO TAKE COPY =:50,X FOR INTERNAL RESET (CONTROL WORD) OUT X,MCSDA;1 IN ORDER TO SEND THE....(CH 0) OUT X,MCSDA+2;1 IN ORDER TO SEND THE....(CH 1) COPY =MCSMODE,X MODE WORD OUT X,MCSDA;1 SEND IT OUT (CH 0) COPY =MCSLPMDE,X GET THE LP MODE WORD OUT X,MCSDA+2;1 SEND IT OUT (CH1) JMP *SETRDY RETURN * MCSMODE EQU :BA EVEN PARITY ENABLE, 1 STP BIT, 7 BIT CHAR. MCSLPMDE EQU :8E LP MODE WORD * LPOOL TITL 'SPACE' SUBROUTINE ****************************** * * SPACE - PRINT SPACES * * THIS SUBROUTINE WILL PRINT * THREE ASCII SPACES TO THE * CRT/TTY. * * CALLING SEQUENCE: * JST SPACE * * CALLS: CALLED BY: * OTTY ERROR * OBIN * ****************************** * SPACE ENT PRINT 3 SPACES COPY =' ',A FOR ERROR REPORT JST OTTY JST OTTY JST OTTY  JMP *SPACE EXIT * LPOOL TITL 'STATUS' SUBROUTINE ****************************** * * STATUS - STATUS CHECK * * THIS SUBROUTINE WILL CHECK * THE RETURNED STATUS FROM AN * I/O OPERATION. IF A BAD STATUS * IS RETURNED IT WILL CALL 'ERROR'. * * CALLING SEQUENCE: * JST STATUS * * CALLS: CALLED BY: * ERROR  TESTA * TESTB * TESTC *  TESTD1 * TESTE * TESTH * ****************************** * STATUS ENT COPY =0,A CLEAR STALT FLAG STATS COPY A,STFG COPY STATUS,A COPY A,STATAD SAVE STATUS CALLING ADDR COPY =1,A LET ERROR ROUTINE KNOW COPY A,STATER WE'RE IN STATUS ROUTINE COPY ADRIOB,X INDEX IOB  COPY CST(X),A LOOK AT STATUS ADD =1,A ALL FFFF'S? JEQ A,STAT1 YES, NO STATUS AT ALL SUB =1,A SHIFT A,RO,A 6 ID CRC? JT OV,STAT2 YES SHIFT A,RO,1 WORD CRC? JT OV,STAT3 YES COPY CST(X),A ELSE XOR =:400,A GOOD STATUS? JNE A,STAT1 NO COPY US(X),A GET UNIT COPY =:8000,X STAT1B JEQ A,STAT1A MASK OFF OTHER UNITS SHIFT X,RO,1 SUB =1,A JMP STAT1B STAT1A COPY X,A COPY ADRIOB,X AND DST(X),A CHECK DRIVE STATUS (BITS 12-15)  JNE A,STAT4 BAD DRIVE STATUS COPY DST(X),A GET DRIVE STATUS AGAIN AND =:FF,A MASK OFF HIGH ORDER BITS STAT1C JNE A,STAT4 BAD STATUS COPY ADRIOB,X COPY XF(X),A SEE IF REQUESTED LENGTH SUB WC(X),A =ACTUAL LENGTH JNE A,STAT5 NO, SEE WHY NOT JMP STAT8 ALL OK,EXIT STAT1 COPY =5,A STATUS ERROR JMP STAT6 STAT2 COPY =7,A ID CRC ERROR JMP STAT6 STAT3 COPY =8,A WORD CRC ERROR JMP STAT6 STAT4 COPY =6,A DRIVE STATUS ERROR JMP STAT6 STAT5  COPY =:F,A LENGTH BAD. AND OP(X),A IS THIS A CLSN =SEEK,A SEEK? JMP STAT5A YES, SHD BE ZERO CLSN =TIO,A IS IT A TIO? JMP STAT5A YES, SHD BE ZERO COPY NB(X),A IS IT WORD CHAINED? JNE A,STAT8 OH, THAT EXPLAINS IT.  COPY =9,A NO, JUST BAD LENGTH JMP STAT6 STAT5A COPY XF(X),A LENGTH = 0? JNE A,$+2 NO, ERROR JMP STAT8 YES,OK COPY =10,A ERROR STAT6 COPY STFG,X IS THIS STALT CALL? JNE X,STAT7 YES, USE SPECIAL ERR CALL COPY ADRIOB,X RESTORE IOB ADDR JST ERROR CALL ERROR JMP STAT8 EXIT STAT7 COPY ADRIOB,X STALT ERROR CALL. JST ERROR (ERROR WONT CALL ERSET) STAT8 COPY =0,A COPY A,STATER RESET ERROR ROUTINE FLAG JMP *STATUS EXIT * STFG WORD 0  STALT FLAG STATAD WORD 0 CALLING ADDRESS STATER WORD 0 FLAG FOR JST ERROR * * STALT - ALTERNATE ENTRY POINT TO STATUS. * THIS SUBROUTINE DOESN'T CALL * ERSET TO INCREMENT ERROR FLAG. * STALT ENT STALT STUFF COPY STALT,A MOVE RETURN ADDRESS COPY A,STATUS COPY =1,A SET STALT FLAG JMP STATS CONTINUE * LPOOL TITL 'TIME' SUBROUTINE ****************************** * * TIME - TIME DELAY ROUTINE, TAKES * APPROXIMATELY 7 SECONDS IF * TIMING CELLS ARE INITIALIZED BY * 'TIMER' * * CALLING SEQUENCE: * JST TIME * JMP ? TIME NOT FULLY EXPIRED R * JMP ? TIME FULLY EXPIRED R+1 * * CALLS: CALLED BY: * NONE TESTF * TESTH * DINIT * DOIO * ******************************* * TIME ENT IMS TC1 BUMP LSP TIMING CONSTANT. JMP *TIME EXIT IMS TC2 BUMP MSP TIMING CONSTANT. JMP *TIME EXIT TO CALL+1 IMS TIME SPECIAL RETURN..EXPIRED JMP *TIME EXIT * TC1 RES 1,0 TC2 RES 1,0 TITL 'TIMER' SUBROUTINE ******************************* * * TIMER - INITIALIZES TIMING CELLS * FOR 'TIME' * * CALLING SEQUENCE: * JST TIMER * * CALLS: CALLED BY: * NONE TESTF *  TESTH * DINIT * DOIO * ******************************* * TIMER ENT COPY =0,A SET LOW WORD COPY A,TC1 COPY =-7,A SET HIGH WORD COPY A,TC2 B  JMP *TIMER TITL 'TSTITL' SUBROUTINE ******************************* * * TSTITL - PRINTS TEST TITLE * * CALLING SEQUENCE: *  COPY =TEST LETTER,A * JST TSTITL * * CALLS: CALLED BY: * CRLF TESTA * MSGA TESTB * OTTY TESTC * TESTD *  TESTE * TESTF * TESTG *  TESTH * TESTI * ******************************* * TSTITL ENT PRINT TEST TITLE COPY A,TCUR STORE TEST NO SHIFT A,LO,8 IN BITS 12-15 OF THE CDR SHIFT A,LO,4 SELP A,4 JT SS,TSTTL1 SEE IF WANTED JST CRLF JST MSGA PRINT TITLE WORD ERMS6 COPY TCUR,A JST OTTY TSTTL1 JMP *TSTITL ESXIT * LPOOL TITL TRAP/EXCEPTION SERVICE ROUTINES ****************************** * * TRAP EXCEPTION SERVICE ROUTINES * * CONSOLE INTERRUPT SERVICE ROUTINE * * CALLS: * SEL * MSGA * ****************************** * * POWER UP * PWRUP: ENT POWER UP SERVICE ROUTINE SIN 3 STATUS INHIBIT COPY =PFMSG,X GET MESSAGE ADDRESS SERVR EQU $ COPY A,S SET PSW TO ZERO JST SEL RESET/INITIALIZE CONTROLLER COPY X,$+2 STORE MESSAGE ADDRESS JST MSGA DISPLAY TRAP/EXCEPTION MESSAGE WORD 0 MESSAGE ADDRESS HLT WAIT HERE JMP ENT1A TO TO QUERIES * * UNIMPLEMENTED INSTRUCTION TRAP * UNINT: ENT UNI. INSTR. SERVICE ROUTINE SIN 9 STATUS INHIBIT COPY =INMSG,X GET MESSAGE ADDRESS COPY =ER3100,A GET THE ERROR CODE COPY MODE,Q GWHAT MODE ARE WE IN CLSN ='D',Q IS IT THE DIAG. JMP $+3 YES COPY =:F,Q LET THEM NOW ITS THE FORMATTER JMP $+3 COPY TCUR,Q MUST BE THE DIAG. THEN WHAT TEST ADD =:0F,Q ONLY WANT THE NUMBER OF THE TEST OR Q,A ADD THE TEST # TO THE ERROR CODE JMP SERVR DISPLAY MESSAGE * * UNINSTALLED MEMORY TRAP * UNMET: ENT UNI. MEM. TRAP SERVICE ROUTINE SIN 9 STATUS INHIBIT COPY =MEMSG,X GET MESSAGE ADDRESS COPY =ER3300,A GET THE ERROR CODE COPY MODE,Q GWHAT MODE ARE WE IN CLSN ='D',Q IS IT THE DIAG. JMP $+3 YES COPY =:F,Q LET THEM NOW ITS THE FORMATTER JMP $+3 COPY TCUR,Q MUST BE THE DIAG. THEN WHAT TEST ADD =:0F,Q ONLY WANT THE NUMBER OF THE TEST OR Q,A ADD THE TEST # TO THE ERROR CODE JMP SERVR DISPLAY MESSAGE * * POWER FAIL * PWRFL: ENT POWER FAIL SERVICE ROUTINE HLT WAIT FOR POWER * * STACK OVERFLOW * STKOV: ENT STK. OVR. TRAP SERVICE ROUTINE SIN 9 STATUS INHIBIT COPY =STMSG,X GET MESSAGE ADDRESS COPY =ER3900,A GET THE ERROR CODE COPY MODE,Q GWHAT MODE ARE WE IN CLSN ='D',Q IS IT THE DIAG. JMP $+3 YES COPY =:F,Q LET THEM NOW ITS THE FORMATTER JMP $+3 COPY TCUR,Q MUST BE THE DIAG. THEN WHAT TEST ADD =:0F,Q ONLY WANT THE NUMBER OF THE TEST OR Q,A ADD THE TEST # TO THE ERROR CODE JMP SERVR DISPLAY MESSAGE * * USER TRAP * USETR: ENT USER TRAP SERVICE ROUTINE SIN 9 STATUS INHIBIT COPY =USMSG,X GET MESSAGE ADDRESS COPY =ER3B00,A GET THE ERROR CODE COPY MODE,Q GWHAT MODE ARE WE IN CLSN ='D',Q IS IT THE DIAG. JMP $+3 YES COPY =:F,Q LET THEM NOW ITS THE FORMATTER JMP $+3 COPY TCUR,Q MUST BE THE DIAG. THEN WHAT TEST ADD =:0F,Q ONLY WANT THE NUMBER OF THE TEST OR Q,A ADD THE TEST # TO THE ERROR CODE JMP SERVR DISPLAY MESSAGE * * SYSTEM TRAP *C  SYSTR: ENT SYSTEM TRAP SERVICE ROUTINE SIN 9 STATUS INHIBIT COPY =SYMSG,X GET MESSAGE ADDRESS COPY =ER3D00,A GET THE ERROR CODE COPY MODE,Q GWHAT MODE ARE WE IN CLSN ='D',Q IS IT THE DIAG. JMP $+3 YES COPY =:F,Q LET THEM NOW ITS THE FORMATTER JMP $+3 COPY TCUR,Q MUST BE THE DIAG. THEN WHAT TEST ADD =:0F,Q ONLY WANT THE NUMBER OF THE TEST OR Q,A ADD THE TEST # TO THE ERROR CODE JMP SERVR DISPLAY MESSAGE * * ARITHMETIC ERROR * ARIER: ENT ARIT. ERROR SERVICE ROUTINE SIN 9 STATUS IHNIBIT COPY =ARMSG,X GET MESSAGE ADDRESS COPY =ER3F00,A GET THE ERROR CODE COPY MODE,Q GWHAT MODE ARE WE IN CLSN ='D',Q IS IT THE DIAG. JMP $+3 YES COPY =:F,Q LET THEM NOW ITS THE FORMATTER JMP $+3 COPY TCUR,Q MUST BE THE DIAG. THEN WHAT TEST ADD =:0F,Q ONLY WANT THE NUMBER OF THE TEST OR Q,A ADD THE TEST # TO THE ERROR CODE JMP SERVR DISPLAY MESSAGE * * CONSOLE INTERRUPT * CNINT: ENT CONSOLE INTERRUPT SERVICE ROUTINE SIN 2 STATUS INHIBIT COPY =0,A SET A TO ZERO COPY A,S SET PSW TO ZERO OUT A,1 RESET CONSOLE INT LIGHT JST SEL RESET/INITIALIZE CONTROLLER JMP ENT1A GO TO QUERIES * LPOOL TITL TABLES (GLOBAL VARIABLES) ****************************** * * GLOBAL VARIABLES * * USED THROUGH OUT THE PROGRAM * ****************************** * OPTIONS +:20 * ACT WORD 0 ACTUAL WORD * ADRIOB WORD 0 CURRENT IOB ADDRESS * CCUR WORD 0 CURRENT CYL NUMBER * NONSTND WORD 0 DISK QUERY FLAG FOR NON-STANDARD DISK * EXP WORD 0 EXPECTED WORD * EOM WORD 0 END OF MEDIA FLAG * HCUR WORD 0 CURRENT HEAD NUMBER * LPFLG WORD 0 LINEPRINTER ON FLAG * MCSFLG WORD 0 MULTI CHANNEL FLAG * MISCAD WORD 0 WORD IN ERROR * SCUR WORD 0 CURRENT SECTOR NUMBER * TCTEMP WORD 0 BUFFER POINTER * TCUR WORD SPACE: CURRENT TEST NUMBER (A-I) * TEMP1 WORD 0 TEMP. CELL * TEMP2 WORD 0 TEMP. CELL * TEMP3 WORD 0 TEMP. CELL * TEMP4 WORD 0 TEMP. CELL * TEMP5 WORD 0 TEMP. CELL * TPTR WORD 0 POINTER TO TEST NUMBER * UCUR WORD 0 CURRENT UNIT NUMBER * UPTR WORD 0 POINTER TO UNIT NUMBER * TITL TABLES (I/O INSTRUCTION ADDRESSES) ****************************** * *  I/O INSTRUCTION ADDRESSES * * TABLE OF I/O INSTRUCTION ADDRESSES * WHICH REQUIRE MODIFICATION WHEN THE * DEVICE ADDRESS IS CHANGED. * * TABLE MUST BE KEPT CONTIGUOUS * ****************************** * DAFRST EQU $ START OF DEVICE ADDRESSES TABLE * WORD DA1 'OTA' I/O SUBROUTINE * WORD DA2 'OTX' I/O SUBROUTINE * WORD DA3 'SEL' I/O SUBROUTINE * WORD DA4 'SENHIM' I/O SUBROUTINE * WORD DA5 'SENRDY' I/O SUBROUTINE * DASIZ EQU $-DAFRST DEVICE ADDRESSES TABLE SIZE TITL TABLES (FC. ERROR MSGS. ADDRESSES) ****************************** * * TABLE OF FUNCTION CODE ERROR MESSAGE ADDRESSES * * TABLE MUST BE KEPT CONTIGUOUS * ****************************** * ERFCTB EQU $ POINTER TO FUNCTION MESSAGES * WORD ERFC0 * WORD ERFC1 * WORD ERFC2 * WORD ERFC3 * WORD ERFC4 * WORD ERFC5 * WORD ERFC6 * WORD ERFC7 * WORD ERFC8 * WORD ERFC9 * WORD ERFCA * WORD ERFCB * WORD ERFCC * WORD ERFCD * WORD ERFCE * WORD ERFCF * TITL TABLES (TEST ADDRESSES) ****************************** * * TABLE OF TEST ADDRESSES * * TABLE MUST BE KEPT CONTIGUOUS * ****************************** * TSTABL WORD TESTA * WORD TESTB * WORD TESTC * WORD TESTD * WORD TESTE * WORD TESTF * WORD TESTG * WORD TESTH * WORD TESTI * TITL TABLES (DRIVE PARAMED TER ADDRESSES) ****************************** * * TABLE OF DRIVE PARAMETER ADDRESSES * * TABLE MUST BE KEPT CONTIGUOUS * ****************************** * DRTBL EQU $ START OF DRIVE PARAMETER ADDRESSES * WORD PSS00 ST-406, CM-5606, MS-2006 * WORD PSS01 ST-412, CM5612, MS-2012 * WORD PSS02 ST-419, CM-5619 * WORD PSS03 RO-204 * WORD PSS04 RMS-518 * WORD PSS05 ST-506 * WORD PSS06 RO-104 * WORD PSS07 MS-1012 * WORD PSS00 * * ADD NEW DRIVE PARAMETER TABLE ADDRESSES HERE * DRTBLZ EQU $-DRTBL-1 NUMBER OF DRIVES-1 TITL TABLES (RESET-PARAMETER TABLE) ****************************** * * RESET-PARAMETER TABLE * * THESE ARE THE DEFAULT PARAMETERS. * TABLE MUST BE KEPT IN ORDER * ****************************** * PRAMSX EQU $ START OF RESET-PARAMETER TABLE * TESTSX WORD TESTA WORD TESTB WORD TESTC WORD TESTD WORD TESTE WORD TESTF WORD TESTG WORD TESTH WORD -1 TESTI WORD -1 TERMINATOR WORD -1 * DISKX WORD PSS01 DRIVE PARAMETER TABLE ADDRESS (DEFAULT) * MODEX WORD 'D' DIAGNOSTIC FLAG * NONDEX WORD 0 DESTRUCTIVE FLAG * HCPX EQU $ * ST-412 PARAMETERS ************ CYLMXX WORD 305 * MAXIMUM NUMBER OF CYLS * CYLSX WORD 300 * NUMBER OF USER CYLS. * SCYLX WORD 0 * STARTING CYL. NUMBER * ECYLX WORD 299  * ENDING CYL. NUMBER * PCMPX WORD 153 * WRITE PRE. COMP. CYL. * RWCURX WORD 153 * REDUCED WRITE CURRENT CYL * STPLSEX WORD STPLSE3 * STEP PULSE CODE * HDSX WORD 4 * NUMBER OF HEADS * SHDX WORD 0 * STARTING HEAD NUMBER * EHDX WORD 3 * ENDING HEAD NUMBER * SECSX WORD 16  * NUMBER OF SECTORS * SSECX WORD 0 * STARTING SECTOR NUMBER * ESECX WORD 15 * ENDING SECTOR NUMBER * WDSX WORD 256 * WORDS PER SECTOR * EHCPX EQU $ ******************************** * WCPATX WORD PAT PATTERN DEFAULT * UNX WORD 0,-1 UNIT TABLE RES UNITS-1,0 * DEVADX WORD SMDA DEVICE ADDRESS * BDIDX WORD :7 SCOUT BOARD ID * PCMPENX WORD :FF PRECOMP ENABLE, YES * RWCURENX WORD :FF REDUCE WRITE CURRENT, YES * BADTRCKX WORD :FF BAD TRACK MAPPING, YES * SHORTX WORD 0 SHORT TEST FLAG * SHORTCX WORD 0 SHORT TEST CYLINDERS * CARX WORD 0 RUN OPTION SETTING * STAGX WORD 0 INTERLEAVE AMOUNT * PASCTX WORD 0 PASS ZERO FIRST * ERR0X RES UNITS,0 TOTAL ERRORS * SOFT0X RES UNITS,0 SOFT ERRORS * FIRM0X RES UNITS,0 FIRM ERRORS * HARD0X RES UNITS,0 HARD ERRORS * TITL TABLES (WORKING-PARAMETER TABLE) ****************************** * * WORKING-PARAMETER TABLE * * THIS IS THE ACTUAL WORKING * PARAMETER TABLE. TABLE MUST * BE KEPT IN ORDER * ****************************** * PRAMS EQU $ START OF WORKING-PARAMETER TABLE * TESTS WORD TESTA WORD TESTB WORD TESTC WORD TESTD WORD TESTE WORD TESTF WORD TESTG WORD TESTH WORD -1 TESTI WORD -1 TERMINATOR TSTSIZ EQU $-TESTS TEST TABLE SIZE * WORD -1 * DISK WORD PSS01 DRIVE PARAMETER TABLE ADDRESS * MODE WORD 'D' DIAGNOSTIC FLAG * NONDES WORD 0 DESTRUCTIVE FLAG * HCP EQU $  * ST-412 PARAMETERS ************ CYLMX WORD 305 * MAXIMUM NUMBER OF CYLS * CYLS WORD 300 * NUMBER OF USER CYLS. * SCYL WORD 0 * STARTING CYL. NUMBER * ECYL WORD 299 * ENDING CYL. NUMBER * PCE MP WORD 153 * WRITE PRE. COMP. CYL. * RWCUR WORD 153 * REDUCED WRITE CURRENT CYL * STPLSE WORD STPLSE3 * STEP PULSE CODE * HDS WORD 4 * NUMBER OF HEADS * SHD WORD 0 * STARTING HEAD NUMBER * EHD WORD 3 * ENDING HEAD NUMBER * SECS WORD 16 * NUMBER OF SECTORS * SSEC WORD 0 * STARTING SECTOR NUMBER * ESEC WORD 15 * ENDING SECTOR NUMBER * WDS WORD 256 * WORDS PER SECTOR * EHCP EQU $ ******************************** * WCPAT WORD PAT PATTERN * UN WORD 0,-1 UNIT TABLE RES UNITS-1,0 * DEVAD WORD SMDA DEVICE ADDRESS * BDID WORD :7 SCOUT BOARD ID * PCMPEN WORD :FF PRECOMP ENABLE, YES * RWCUREN WORD :FF REDUCE WRITE CURRENT, YES * BADTRCK WORD :FF BAD TRACK MAPPING, YES * SHORT WORD 0 SHORT TEST FLAG * SHORTC WORD 0 SHORT TEST CYLINDERS * CAR WORD 0 RUN OPTION SETTING * STAG WORD 0 INTERLEAVE AMOUNT * PASCTR WORD 0 PASS COUNT AT FIRST * ERR0 RES UNITS,0 TOTAL ERRORS * SOFT0 RES UNITS,0 SOFT ERRORS * FIRM0 RES UNITS,0 FIRM ERRORS * HARD0 RES UNITS,0 HARD ERRORS * PRMSIZ EQU $-PRAMS SIZE OF PARAMETER TABLE TITL TABLES (PSS00 PARAMETERS) ****************************** * * DEFAULT PARAMETER TABLE FOR * * SEAGATE ST-406 * COMPUTER MEMORIES CM-5606 * MINISCRIBE MS-2006 * * TABLE MUST BE KEPT IN ORDER * ****************************** * PSS00 EQU $ START OF TABLE * WORD 305 MAXIMUM NUMBER OF CYLINDERS * WORD 300 NUMBER OF USER CYLINDERS * WORD 0 STARTING CYLINDER NUMBER * WORD 299 ENDING CYLINDER NUMBER * WORD 153 WRITE PRE COMPENSATION CYLINDER * WORD 153 REDUCED WRITE CURRENT CYLINDER * WORD STPLSE3 STEP PULSE CODE * WORD 2 NUMBER OF HEADS * WORD 0 STARTING HEAD NUMBER * WORD 1 ENDING HEAD NUMBER * WORD 16 NUMBER OF SECTORS * WORD 0 STARTING SECTOR NUMBER * WORD 15 ENDING SECTOR NUMBER * WORD 256 WORDS PER SECTOR * TITL TABLES (PSS01 PARAMETERS) ************************************* * * DEFAULT PARAMETER TABLE FOR * * SEAGATE ST-412 * COMPUTER MEMORIES CM-5612 * MINISCRIBE MS-2012 * * TABLE MUST BE KEPT IN ORDER * ************************************* * PSS01 EQU $ START OF TABLE * WORD 305 MAXIMUM NUMBER OF CYLINDERS * WORD 300 NUMBER OF USER CYLINDERS * WORD 0 STARTING CYLINDER NUMBER * WORD 299 ENDING CYLINDER NUMBER * WORD 153 WRITE PRE COMPENSATION CYLINDER * WORD 153 REDUCED WRITE CURRENT CYLINDER * WORD STPLSE3 STEP PULSE CODE * WORD 4 NUMBER OF HEADS * WORD 0 STARTING HEAD NUMBER * WORD 3 ENDING HEAD NUMBER * WORD 16 NUMBER OF SECTORS * WORD 0 STARTING SECTOR NUMBER * WORD 15 ENDING SECTOR NUMBER * WORD 256 WORDS PER SECTOR * TITL TABLES (PSS02 PARAMETERS) ****************************** * * DEFAULT PARAMETER TABLE FOR * * SEAGATE ST-419 * COMPUTER MEMORIES CM-5619 * * TABLE MUST BE KEPT IN ORDER * ****************************** * PSS02 EQU $ START OF TABLE * WORD 305 MAXIMUM NUMBER OF CYLINDERS * WORD 300 NUMBER OF USER CYLINDERS * WORD 0 STARTING CYLINDER NUMBER * WORD 299 ENDING CYLINDER NUMBER * WORD 153 WRITE PRE COMPENSATION CYLINDER * WORD 153 REDUCED WRITE CURRENT CYLINDER * WORD STPLSE3 STEP PULSE CODE * WORD 6 NUMBER OF HEADS * WORD 0 STARF TING HEAD NUMBER * WORD 5 ENDING HEAD NUMBER * WORD 16 NUMBER OF SECTORS * WORD 0 STARTING SECTOR NUMBER * WORD 15 ENDING SECTOR NUMBER * WORD 256 WORDS PER SECTOR * TITL TABLES (PSS03 PARAMETERS) ****************************** * * DEFAULT PARAMETER TABLE FOR * * RODIME RO-204 * * TABLE MUST BE KEPT IN ORDER * ****************************** * PSS03 EQU $ START OF TABLE * WORD 305 MAXIMUM NUMBER OF CYLINDERS * WORD 300 NUMBER OF USER CYLINDERS * WORD 0 STARTING CYLINDER NUMBER * WORD 299 ENDING CYLINDER NUMBER * WORD 153 WRITE PRE COMPENSATION CYLINDER * WORD 153 REDUCED WRITE CURRENT CYLINDER * WORD STPLSE3 STEP PULSE CODE * WORD 8 NUMBER OF HEADS * WORD 0 STARTING HEAD NUMBER * WORD 7 ENDING HEAD NUMBER * WORD 16 NUMBER OF SECTORS * WORD 0 STARTING SECTOR NUMBER * WORD 15 ENDING SECTOR NUMBER * WORD 256 WORDS PER SECTOR * TITL TABLES (PSS04 PARAMETERS) ****************************** * * DEFAULT PARAMETER TABLE FOR * * ROTATING MEMORY SYSTEM RMS-518 * *  TABLE MUST BE KEPT IN ORDER * ****************************** * PSS04 EQU $ START OF TABLE * WORD 215 MAXIMUM NUMBER OF CYLINDERS * WORD 210 NUMBER OF USER CYLINDERS * WORD 0 STARTING CYLINDER NUMBER * WORD 209 ENDING CYLINDER NUMBER * WORD 77 WRITE PRE COMPENSATION CYLINDER * WORD 77 REDUCED WRITE CURRENT CYLINDER * WORD STPLSE3 STEP PULSE CODE * WORD 8 NUMBER OF HEADS *  WORD 0 STARTING HEAD NUMBER * WORD 7 ENDING HEAD NUMBER * WORD 16 NUMBER OF SECTORS * WORD 0 STARTING SECTOR NUMBER * WORD 15 ENDING SECTOR NUMBER * WORD 256 WORDS PER SECTOR * TITL DRIVE TABLE (PSS05) ***************************** * * DRIVE PARAMETER TABLE FOR * * SEAGATE ST-506 * * TABLE MUST BE KEEP IN ORDER * ***************************** * PSS05 EQU $ START OF TABLE * WORD 152 MAXIMUM NUMBER OF CYLINDERS * WORD 147 NUMBER OF USER CYLINDERS * WORD 0 STARTING CYLINDER NUMBER * WORD 146 ENDING CYLINDER NUMBER * WORD 77 WRITE PRE COMPENSATION CYLINDER * WORD 77 REDUCED WRITE CURRENT CYLINDER (NO REDUCE WRITE CURRENT) * WORD STPLSE2 STEP PULSE CODE * WORD 4 NUMBER OF HEADS * WORD 0 STARTING HEAD NUMBER * WORD 3 ENDING HEAD NUMBER * WORD 16 NUMBER OF SECTORS * WORD 0 STARTING SECTOR NUMBER * WORD 15 ENDING SECTOR NUMBER * WORD 256 WORDS PER SECTOR * TITL DRIVE TABLE (PSS06) ***************************** * * DRIVE PARAMETER TABLE FOR * * RODINE RO-104 * *  TABLE MUST BE KEEP IN ORDER * ***************************** * PSS06 EQU $ START OF TABLE * WORD 191 MAXIMUM NUMBER OF CYLINDERS * WORD 186 NUMBER OF USER CYLINDERS * WORD 0 STARTING CYLINDER NUMBER * WORD 185 ENDING CYLINDER NUMBER * WORD 00 WRITE PRE COMPENSATION CYLINDER * WORD 00 REDUCED WRITE CURRENT CYLINDER (NO REDUCE WRITE CURRENT) * WORD STPLSE3 STEP PULSE CODE * WORD 8 NUMBER OF HEADS * WORD 0 STARTING HEAD NUMBER * WORD 7 ENDING HEAD NUMBER * WORD 16 NUMBER OF SECTORS * WORD 0 STARTING SECTOR NUMBER * WORD 15 ENDING SECTOR NUMBER * WORD 256 WORDS PER SECTOR * TITL TABLES (PSS07 PARAMETERS) ************************************* * * DEFAULT PARAMETER TABLE FOR * * MINISCRIBE MS-1012 * * TABLE MUST BE KEPT IN ORDER * ************************************* * PSS07 EQU $ START OF TABLE * WORD 305 MAXIMUM NUMBER OF CYLINDERS * WORD 300 NUG MBER OF USER CYLINDERS * WORD 0 STARTING CYLINDER NUMBER * WORD 299 ENDING CYLINDER NUMBER * WORD 153 WRITE PRE COMPENSATION CYLINDER * WORD 153 REDUCED WRITE CURRENT CYLINDER * WORD STPLSE0 STEP PULSE CODE * WORD 4 NUMBER OF HEADS * WORD 0 STARTING HEAD NUMBER * WORD 3 ENDING HEAD NUMBER * WORD 16 NUMBER OF SECTORS * WORD 0 STARTING SECTOR NUMBER * WORD 15 ENDING SECTOR NUMBER * WORD 256 WORDS PER SECTOR * TITL STEP PULSE CODE TABLE **************************** * * STEP PULSE CODE TABLE * **************************** * STPLSE0 EQU 0 3MS PER STEP STPLSE1 EQU 1 60MS PER STEP STPLSE2 EQU 2 STEP PULSE ARE ISSUED ACCORDING TO THE COMMENT SEAGATE INC. ST-506 1/2 RAMP SEEK ALGORITHM. STPLSE3 EQU 3 200MS PER STEP STPLSE4 EQU 4 STEP PULSE ARE ISSUED ACCORDING TO THE COMMENT MINISCRIBE INC. MS-1012 1/2 STEP RAMP SEEK ALGORITH. TITL CRT/TTY MESSAGES (QUERIES) ****************************** * * QUERY MESSAGES * ****************************** * TITLE BYTE CR:,LF:,LF:,'WINCHESTER DIAGNOSTIC/FORMATTER 96120-' WORD REV:,CRLF:,-1 * QUERYM10 BYTE CR:,LF:,'DRIVE PARAMETER SWITCH SETTING (1)?',:FF * QUERYM20 BYTE CR:,LF:,'DIAG, FMATTER OR TECH TEST (D,F,T)?',:FF * QUERYM30 BYTE CR:,LF:,'DEVICE ADDRESS (:15)?',:FF * QUERYMF0 BYTE CR:,LF:,'SCOUT BOARD ID (:07)?:',:FF * QUERYMG0 BYTE CR:,LF:,'MAX CYLS?',:FF * QUERYM40 BYTE CR:,LF:,'TSTS (A-H)?',:FF * QUERYM50 BYTE CR:,LF:,'USER CYLS?',:FF * QUERYM60 BYTE CR:,LF:,'WRITE PRE COMP CYL?',:FF * QUERYMH0 BYTE CR:,LF:,'REDUCED WRITE CURRENT CYL?',:FF * QUERYMI0 BYTE CR:,LF:,'STEP PULSE CODE?',:FF * QUERYMS0 BYTE CR:,LF:,'SHORT TEST-CYLS?',:FF * QUERYM70 BYTE CR:,LF:,'HDS?',:FF * QUERYMJ0 BYTE CR:,LF:,'NUMBER OF BOARDS (1)?',:FF * QUERYMA0 BYTE CR:,LF:,'PATN (:6DB6)?:',:FF * QUERYMB0 BYTE CR:,LF:,'UNITS (0 OR 1)?',:FF * QUERYMC0 BYTE CR:,LF:,'SAVE DATA (Y OR N)?',:FF * QUERYMD0 BYTE CR:,LF:,'RUN OPTIONS (:00)?:',:FF * QUERYME0 BYTE CR:,LF:,'UNIT TO FORMAT (0 OR 1)?',:FF * QUERYMK0 BYTE CR:,LF:,'PRECOMPENSATION Y/N (Y)?',:FF * QUERYML0 BYTE CR:,LF:,'REDUCE WRITE CURRENT Y/N (Y)?',:FF * QUERYMM0 BYTE CR:,LF:,'BAD TRACK MAPPING Y/N (Y)?',:FF * QUERYMN0 BYTE CR:,LF:,'SECTOR INTERLEAVE (0)?: ',:FF * QUERYMP0 BYTE CR:,LF:,'ANY BAD TRACKS FROM THE MANUFACTURER (Y/[N])?',:FF * QUERYMP1 BYTE CR:,LF:,'FORMATTING...',:FF * QUERYMQ0 BYTE CR:,LF:,CR:,LF:,' ENTER CYLINDER NUMBER (DECIMAL) ',:FF * QUERYMR0 BYTE CR:,LF:,' ENTER HEAD NUMBER (DECIMAL) ',:FF * QUERYMR1 BYTE CR:,LF:,'*** EXCESSIVE BAD TRACKS',:FF * TTMS BYTE CR:,LF:,'ENTER:',CR:,LF: TECH TEST QUERY BYTE 'FC,U,C,H,S,IN,LN,DP,OP,CL,CP',CR:,LF:,'?',:FF * TITL CRT/TTY MESSAGES (ERROR FUNC. CODES) ****************************** * * ERROR FUNCTION CODE MESSAGES * ****************************** * ERFC0 BYTE ' (TEST I/O)',:FF * ERFC1 BYTE ' (FORMAT)',:FF * ERFC2 BYTE ' (WRITE)',:FF * ERFC3 EQU $ RESERVED * ERFC4 BYTE ' (READ)',:FF * ERFC5 EQU $ RESERVED * ERFC6 EQU $ ' (RD REG)',:FF THIS IS NOT YET INPLEMENTED ON THE SWI * ERFC7 BYTE ' (WRITE DISK PARAM)',:FF * ERFC8 BYTE ' (VERIFY)',:FF * ERFC9 BYTE ' (SEEK)',:FF * ERFCA EQU $ RESERVED * ERFCB EQU $ RESERVED * ERFCC EQU $ RESERVED * ERFCD EQU $ RESERVED * ERFCE EQU $ RESERVED * ERFCF EQU $ RESERVED * TITL CRT/TTY MESSAGES (ERROR REPORT) ****************************** * * ERROR REPORT MESSAGES * *************H ***************** * ERMS1 BYTE CR:,LF:,LF:,'ER ',:FF * ERMS2 BYTE ' (FORMATTER)',:FF * ERMS3 BYTE CR:,LF:,'ER AD :',:FF * ERMS4 BYTE 'PASS ',:FF * ERMS5 BYTE 'UNIT ',:FF * ERMS6 BYTE 'TEST ',:FF * ERMS7 BYTE CR:,LF:,'IOB ADDRESS :',:FF * ERMS8 BYTE CR:,LF:,'STATUS :',:FF * ERMS9 BYTE CR:,LF:,'DRIVE STATUS :',:FF * ERMS10 BYTE CR:,LF:,'FUNC :',:FF * ERMS11 BYTE 'CYL ',:FF * ERMS12 BYTE 'HEAD ',:FF * ERMS13 BYTE 'SECT ',:FF * ERMS14 BYTE CR:,LF:,'BUF :',:FF * ERMS15 BYTE 'LEN :',:FF * ERMS16 BYTE 'WDS XFRD :',:FF * ERMS17 BYTE CR:,LF:,'WD IN ERROR :',:FF * ERMS18 BYTE 'EXP :',:FF * ERMS19 BYTE 'ACT :',:FF * ERMS20 BYTE CR:,LF:,'INT LOC :',:FF * ERMS21 BYTE CR:,LF:,'SECTOR ADDRESS AFTER I/O ',:FF * ERMS22 BYTE CR:,LF:,LF:,'WORD CHAIN IOB :',:FF * ERMS23 BYTE 'WD COUNT :',:FF * ERMS24 BYTE 'BUF AD :',:FF * TITL CRT/TTY MESSAGES (TRAPS) ***************************** * * TRAP MESSAGES * ***************************** * INMSG BYTE CR:,LF:,LF:,'UNIMPLEMENTED INSTRUCTION TRAP',CR:,LF:,:FF * MEMSG BYTE CR:,LF:,LF:,'UNINSTALLED MEMORY TRAP',CR:,LF:,:FF * PFMSG BYTE CR:,LF:,LF:,'POWER FAIL',CR:,LF:,:FF * * STMSG BYTE CR:,LF:,LF:,'STACK OVERFLOW',CR:,LF:,:FF * USMSG BYTE CR:,LF:,LF:,'USER TRAP',CR:,LF:,:FF * SYMSG BYTE CR:,LF:,LF:,'SYSTEM TRAP',CR:,LF:,:FF * ARMSG BYTE CR:,LF:,LF:,'ARITHMETIC TRAP',CR:,LF:,:FF * TITL CRT/TTY MESSAGES (MISCELLANEOUS) ****************************** * * MISCELLANEOUS MESSAGES * ****************************** * TALTTL BYTE CR:,LF:,LF:,'ERROR TOTALS',:FF * UNITMG BYTE CR:,LF:,'UNIT' * PRUNIT BYTE ' ',:FF * SOFTMS BYTE ' SOFT ',:FF * FIRMS BYTE ' FIRM ',:FF * HARDMS BYTE ' HARD ',:FF * ALLMS BYTE ' ALL ',:FF * ACTHDM BYTE CR:,LF:,'ACT HEADER: ',:FF * EXPHDM BYTE CR:,LF:,'EXP HEADER: ',:FF * ACCRCM BYTE CR:,LF:,'ACT CRC: ',:FF * XPCRCM BYTE CR:,LF:,'EXP CRC: ',:FF * BADTRK BYTE CR:,LF:,LF:,'BAD TRACK: CYL ',:FF * BADTK1 BYTE ' HEAD ',:FF * DUMPMG BYTE CR:,LF:,LF:,'BUFFER DUMP, AT :',:FF * EOT BYTE CR:,LF:,'END OF TEST',:FF * LPMSG BYTE CR:,LF:,'LINEPRINTER TIME-OUT',CR:,LF:,:FF * PASSMG BYTE CR:,LF:,'PASS ',:FF * STARS BYTE '****',:FF * SALERR BYTE CR:,LF:,'SAL INSTRUCTION DID NOT RETURN EXPECTED' * BYTE 'DEVICE ADDRESS',CR:,LF:,:FF * TITL I/O BUFFERS ****************************** * * I/O BUFFERS * * BUF - STANDARD BUFFER * * SAVBUF - USER'S SAVE BUFFER * ****************************** * BUF RES 570,0 STANDARD BUFFER * SAVBUF RES 570,0 USER'S SAVE BUFFER * ENDPROG EQU $ THAT'S ALL FOLKES !!!! END SMD D OF TEST',:FF * LPMSG BYTE CR:,LF:,'LINEPRINTER TIME-OUT',CR:,LF:,:FF *AS LO=LP DE SWITP.OBJ MACRO SWITP(MACH=404) DE SWITP.MAP DE OS::.SYS CRE SWITP.MAP 1 1 AS LO=SWITP.MAP LINK OS::.SYS=SWITP.OBJ(AB=0)+DEBUGS.OBJ(AB=2000) ALL DONE !!!!!!!! 820909184931820909184931820909184931IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJ IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIK IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIL IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII