diff --git a/DumpPDP7.sln b/DumpDT18.sln similarity index 86% rename from DumpPDP7.sln rename to DumpDT18.sln index a3ad7c9..de48c9b 100644 --- a/DumpPDP7.sln +++ b/DumpDT18.sln @@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 15 VisualStudioVersion = 15.0.26403.7 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DumpPDP7", "DumpPDP7\DumpPDP7.csproj", "{88B646C3-54D8-4D63-BB8A-B391C996FE47}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DumpDT18", "DumpDT18\DumpDT18.csproj", "{88B646C3-54D8-4D63-BB8A-B391C996FE47}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/DumpPDP7/App.config b/DumpDT18/App.config similarity index 100% rename from DumpPDP7/App.config rename to DumpDT18/App.config diff --git a/DumpPDP7/DumpPDP7.csproj b/DumpDT18/DumpDT18.csproj similarity index 80% rename from DumpPDP7/DumpPDP7.csproj rename to DumpDT18/DumpDT18.csproj index a0a3ac6..6b41dde 100644 --- a/DumpPDP7/DumpPDP7.csproj +++ b/DumpDT18/DumpDT18.csproj @@ -6,8 +6,8 @@ AnyCPU {88B646C3-54D8-4D63-BB8A-B391C996FE47} Exe - DumpPDP7 - DumpPDP7 + DumpDT18 + DumpDT18 v4.5.2 512 true @@ -47,6 +47,18 @@ + + PreserveNewest + + + + PreserveNewest + + + + + + \ No newline at end of file diff --git a/DumpDT18/Program.cs b/DumpDT18/Program.cs new file mode 100644 index 0000000..216f902 --- /dev/null +++ b/DumpDT18/Program.cs @@ -0,0 +1,303 @@ +using System; +using System.IO; +using System.IO.Ports; + +/* + * This program receives an 18-bit Dectape image from the serial port from the + PDP8 TD8E dump program. It is loosely based on David Gesswein's dumptd8e + program. + + This program should be running before the PDP8 end is started. + +*/ +namespace DumpDT18 +{ + class Program + { + public enum ReadState + { + BlockFlag, + Checksum, + BlockData, + } + + static void Main(string[] args) + { + + if (args.Length < 3) + { + Console.WriteLine("usage: DumpDT18 "); + return; + } + + // + // Open the serial port. Or try, anyway. + // + SerialPort port = new SerialPort(args[0], int.Parse(args[1])); + port.StopBits = StopBits.One; + port.Handshake = Handshake.None; + port.Parity = Parity.None; + port.Open(); + + string tapeFileName = args[2]; + string diagFileName = Path.Combine(Path.GetDirectoryName(tapeFileName), Path.GetFileNameWithoutExtension(tapeFileName) + ".log"); + + // Open the output file + using (FileStream tapeOutput = new FileStream(tapeFileName, FileMode.Create, FileAccess.Write), + diagOutput = new FileStream(diagFileName, FileMode.Create, FileAccess.Write)) + { + StreamWriter diagText = new StreamWriter(diagOutput); + diagText.AutoFlush = true; + diagText.WriteLine("Summary log for 18-bit DECTape image {0} captured on {1}:", tapeFileName, DateTime.Now); + + Console.WriteLine("Initialized, waiting for tape data."); + + ReadState readState = ReadState.BlockFlag; + int wordCount18 = 0; + int blockNumber = 0; + int byteIndex36 = 0; + int byteIndex12 = 0; + ushort temp = 0; + int chksum12 = 0; + ulong thirtySix = 0; + int badBlocks = 0; + + while (true) + { + byte[] buf = new byte[200]; + int read = port.Read(buf, 0, buf.Length); + + for (int i = 0; i < read; i++) + { + ulong b = buf[i]; + switch (readState) + { + case ReadState.BlockFlag: + switch (b) + { + case 0xff: + case 0xfd: + wordCount18 = 0; + byteIndex36 = 0; + readState = ReadState.BlockData; + + if (b == 0xfd) + { + Console.WriteLine("\nBlock {0} bad\n", blockNumber); + diagText.WriteLine("Block {0} bad.", blockNumber); + badBlocks++; + } + break; + + case 0xfe: + readState = ReadState.Checksum; + byteIndex12 = 0; + break; + + default: + diagText.WriteLine("Error during transmission."); + throw new InvalidOperationException("Missing start of block flag. Aborting."); + + } + break; + + case ReadState.Checksum: + // read first byte of checksum + if (byteIndex12 == 0) + { + temp = (ushort)b; + byteIndex12 = 1; + } + else + { + // last byte of checksum + temp = (ushort)(temp | (b << 8)); + chksum12 = (temp + chksum12) & 0xfff; + if (chksum12 != 0) + { + Console.WriteLine("Read completed. Warning: Checksum error: {0}.", ToOctal(chksum12)); + diagText.WriteLine("Checksum error: {0}", ToOctal(chksum12)); + return; + } + Console.WriteLine("Read completed successfully. {0} blocks read, {1} bad blocks.", blockNumber, badBlocks); + diagText.WriteLine("Read successful. {0} blocks read, {1} bad blocks.", blockNumber, badBlocks); + return; + } + break; + + case ReadState.BlockData: + + // + // There are 384 12-bit words per block and each 12-bit word is + // transferred as 1.5 bytes. The 384 12-bit words in a block + // correspond to 256 18-bit words (1.5 12-bit words per 18-bit word) + // which we want to write out to an 18-bit SIMH dectape image. This + // is further complicated by the fact that due to the way the + // bits actually get written to the tape, reading 18-bit words + // as 1.5 12-bit words ends up transposing 6-bit segments inside + // a 36-bit segment: + // If the original 6-bit half-word ordering is: + // 5 4 3 2 1 0 + // When read back into sequential 12-bit words, these half-words get + // rearranged: + // 2 5 4 1 0 3 + // + // To keep things somewhat easy to understand here (so as to preserve + // my own sanity) at the expense of slightly longer code, + // the state machine below parses 9 bytes (72 bits) at a time + // which corresponds to 2 36-bit words (4 18-bit words) and re-arranges the 6-bit + // half-words after each 36-bit word is read in. These re-arranged words are then + // pushed out to disk in standard SIMH 18b format. + // + // We do this while ALSO summing the 12-bit checksum used at the end of the transfer. + // + switch (byteIndex36++) + { + case 0: + thirtySix = b; + break; + + case 1: + thirtySix |= (ulong)(b << 8); + break; + + case 2: + thirtySix |= (ulong)(b << 16); + break; + + case 3: + thirtySix |= (ulong)(b << 24); + break; + + case 4: + thirtySix |= (ulong)((b & 0xf) << 32); + + // First 36-bit word finished. + WriteThirtySix(tapeOutput, MangleBits(thirtySix)); + wordCount18 += 2; + + // Start next 36-bit word + thirtySix = (ulong)((b & 0xf0) >> 4); + break; + + case 5: + thirtySix |= (ulong)(b << 4); + break; + + case 6: + thirtySix |= (ulong)(b << 12); + break; + + case 7: + thirtySix |= (ulong)(b << 20); + break; + + case 8: + thirtySix |= (ulong)(b << 28); + + // Second 36-bit word finished. + WriteThirtySix(tapeOutput, MangleBits(thirtySix)); + wordCount18 += 2; + + byteIndex36 = 0; + break; + + default: + throw new InvalidOperationException("Unexpected state when building 36-bit word."); + + } + + // + // Deal with the 12-bit checksum + // + switch (byteIndex12++) + { + case 0: + temp = (ushort)b; + break; + + case 1: + temp = (ushort)((temp | (b << 8)) & 0xfff); + chksum12 = chksum12 + temp; + temp = (ushort)(b >> 4); + break; + + case 2: + temp = (ushort)((temp | (b << 4)) & 0xfff); + chksum12 = chksum12 + temp; + byteIndex12 = 0; + break; + + default: + throw new InvalidOperationException("Unexpected state when building 12-bit checksum."); + } + + // + // Start next block when at end. + // + if (wordCount18 == 256) + { + readState = ReadState.BlockFlag; + blockNumber++; + byteIndex36 = 0; + if ((blockNumber % 5) == 0) + { + Console.Write("{0}", blockNumber); + } + else + { + Console.Write("."); + } + } + break; + } + } + } + } + } + + private static ulong MangleBits(ulong mangled) + { + ulong unmangled; + + // + // Reading 18-bit DECTapes on a 12-bit PDP-8 presents an interesting + // ordering of 6-bit half-words. + // Effectively, each 36-bit sequence reorders 6-bit sequences as: + // original: 5 4 3 2 1 0 + // mangled: 2 5 4 1 0 3 + // This routine moves things back to the right place in the 36-bit word. + // + unmangled = + ((mangled & 0x00000003f) << 6) | + ((mangled & 0x000000fc0) << 6) | + ((mangled & 0x00003f000) << 18) | + ((mangled & 0x000fc0000) >> 18) | + ((mangled & 0x03f000000) >> 6) | + ((mangled & 0xfc0000000) >> 6); + + return unmangled; + } + + private static void WriteThirtySix(Stream outStream, ulong thirtySix) + { + WriteEighteen(outStream, (uint)(thirtySix & 0x3ffff)); + WriteEighteen(outStream, (uint)((thirtySix & 0xffffc0000) >> 18)); + } + + private static void WriteEighteen(Stream outStream, uint eighteen) + { + outStream.WriteByte((byte) (eighteen & 0x000000ff)); + outStream.WriteByte((byte)((eighteen & 0x0000ff00) >> 8)); + outStream.WriteByte((byte)((eighteen & 0x00ff0000) >> 16)); + outStream.WriteByte((byte)((eighteen & 0xff000000) >> 24)); + + outStream.Flush(); + } + + public static string ToOctal(int i) + { + return Convert.ToString(i, 8); + } + } +} diff --git a/DumpPDP7/Properties/AssemblyInfo.cs b/DumpDT18/Properties/AssemblyInfo.cs similarity index 100% rename from DumpPDP7/Properties/AssemblyInfo.cs rename to DumpDT18/Properties/AssemblyInfo.cs diff --git a/DumpDT18/dump-old.bin b/DumpDT18/dump-old.bin new file mode 100644 index 0000000..777244a Binary files /dev/null and b/DumpDT18/dump-old.bin differ diff --git a/DumpDT18/dump-old.lst b/DumpDT18/dump-old.lst new file mode 100644 index 0000000..f72ef12 --- /dev/null +++ b/DumpDT18/dump-old.lst @@ -0,0 +1,854 @@ + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 1 + + + 1 / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code from D. Gesswein + 2 / (see ftp://ftp.pdp8online.com/software/dumprest). + 3 / Modified for 18-bit DECtape w/standard checksum imaging by J. Dersch + 4 / + 5 / This program will send a DECtape image out the console port. + 6 / The format of the data sent is 0xff (0377) or 0xfd if read error + 7 / followed by 384 12-bit words (256 18-bit words) of data for each block. + 8 / After the last block a 0xfe (0376) is sent + 9 / with a two byte checksum, low 8 bits first then upper 4. + 10 / The words in a block are sent as three bytes for each 2 words. + 11 / 1 = low 8 bits first word + 12 / 2 = upper 4 bits first and lower 4 bits second + 13 / 3 = upper 8 bits second word + 14 / + 15 / The program (PC) receiving the data should be started before this program. + 16 / + 17 / To run, start at 0200. + 18 / SR 11 should be drive, only 0 and 1 supported without reassembling + 19 / SR 6-8 should be maximum memory field in computer, needs 8k minimum + 20 / + 21 / The receiving program should be running first. + 22 / At normal exit hitting cont will restart the program. + 23 / + 24 / Should halt at label finish (140) with number of recoverable errors in AC + 25 / The current block being read will be displayed in the AC + 26 / while running. + 27 / + 28 / The PC program will print out the bad location if an error occurs. + 29 / + 30 / We will retry each read up to four times on error. + 31 / + 32 / This transfers the standard 256 word by 578 blocks used by 18-bit DEC hardware, + 33 / using standard checksums (as used by the PDP-9 and later machines). + 34 / It will read as many blocks are present up to the forward end-zone, so it will + 35 / handle tapes that vary from the standard 1102(8) block length. + 36 / + 37 0030 INAD=030 / Address of serial input, 30 for console + 38 6030 KCF2=6000 INAD + 39 6031 KSF2=6001 INAD + 40 6032 KCC2=6002 INAD + 41 6034 KRS2=6004 INAD + 42 6035 KIE2=6005 INAD + 43 6036 KRB2=6006 INAD + 44 + 45 0040 OUTAD=040 / Address of serial output, 40 for console + 46 6040 TFL2=6000 OUTAD + 47 6041 TSF2=6001 OUTAD + 48 6042 TCF2=6002 OUTAD + 49 6044 TPC2=6004 OUTAD + 50 6045 TSK2=6005 OUTAD + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 2 + + + 51 6046 TLS2=6006 OUTAD + 52 + 53 /2 TD8E INITIALIZER PROGRAM, V7A + 54 / + 55 /COPYRIGHT (C) 1975, 1977 + 56 /DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. + 57 / + 58 / + 59 / + 60 /THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A + 61 /SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLU- + 62 /SION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ANT OTHER + 63 /COPIES THEREOF, MAY NOT BR PROVIDED OR OTHERWISE MADE AVAILABLE + 64 /TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO + 65 /AGREES TO THESE LICENSE TERMS. TITLE TO AND OWNERSHIP OF THE + 66 /SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC. + 67 / + 68 / + 69 /THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT + 70 /NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL + 71 /EQUIPMRNT COROPATION. + 72 / + 73 /DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS + 74 /SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. + 75 / + 76 / + 77 / + 78 / + 79 / + 80 / + 81 + 82 /DECEMBER 21, 1973 GB/RL/EF/SR + 83 + 84 /ABSTRACT-- + 85 / THE ROUTINE DESCRIBED AND LISTED HERE IS A GENERAL + 86 /DATA HANDLER FOR THE TD8E DECTAPE SYSTEM. THE ROUTINE + 87 /CONTAINS SEARCH, READ, AND WRITE FUNCTIONS IN A FORMAT + 88 /WHICH IS COMPATIBLE WITH OS/8 DEVICE HANDLER CALLING + 89 /SEQUENCES. + 90 + 91 /FIXES SINCE FIELD-TEST RELEASE: + 92 + 93 /1. FIXED BUG RE CLA ON RETRY AFTER ERROR + 94 /2. ALLOWED FINAL BOOTSTRAP TO BE INTO A WRITE-LOCKED DEVICE + 95 + 96 /OS/8 V3D CHANGES: + 97 + 98 /3. FIXED BUG RE TD8E BUILD (V6B PATCH) + 99 + 100 /THIS ROUTINE CAN BE RE-EDITED AND ASSEMBLED TO PRODUCE + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 3 + + + 101 /VARIATIONS ON THE BASIC TD8E SYSTEM. ASSEMBLY PARAMETERS + 102 /CONTROL: + 103 /A) WHAT DRIVES (UNITS 0-7) WILL BE USED + 104 /B) THE ORIGIN OF THE TWO PAGE ROUTINE + 105 /C) WHAT MEMORY FIELD THE ROUTINE WILL RUN IN + 106 /D) THE SIZE OF THE DECTAPE BLOCK TO BE READ/WRITTEN + 107 + 108 /FOLLOWING ARE THE PARAMETERS SET UP FOR THE STANDARD + 109 /DEC VERSION OF THIS ROUTINE: + 110 + 111 0010 DRIVE=10 /UNITS 0 AND 1 SELECTED + 112 0600 ORIGIN=600 /ENTER AT ORIGIN, ORIGIN+4 + 113 0000 AFIELD=0 /INITIAL FIELD SETTING + 114 0000 MFIELD=00 /AFIELD*10=MFIELD + 115 0600 WDSBLK=600 /384 12-BIT WORDS PER BLOCK (256 18-BIT DATA WORDS) + 116 + 117 /THE USE OF THE PARAMETERS IS AS FOLLOWS: + 118 + 119 / DRIVE: DRIVE DETERMINES WHICH UNITS WILL BE SELECTED + 120 / DRIVE=10 IMPLIES UNITS 0 &1 + 121 / DRIVE=20 IMPLIES UNITS 2&3 + 122 / DRIVE=30 IMPLIES UNITS 4&5 + 123 / DRIVE=40 IMPLIES UNITS 6&7 + 124 + 125 /ORIGIN: ALTERING ORIGIN CAUSES ASSEMBLY IN A DIFFERENT + 126 / MEMORY LOCATION. WHEN CHANGING ORIGIN KEEP IN MIND + 127 /THAT THIS IS A TWO PAGE ROUTINE. + 128 + 129 /AFIELD: AFIELD DETERMINES THE INITIAL FIELD SETTING FOR THE + 130 / LOADER. PERMISSIBLE VALUES FOR AFIELD ARE 0 TO 7. + 131 + 132 /MFIELD: MFIELD IS USED IN A CIF CDF MFIELD INSTRUCTION. + 133 / THE VALUE INSERTED FOR MFIELD SHOULD BE 10(8) TIMES + 134 / THE VALUE FOR AFIELD. THE PERMISSIBLE VALUES ARE 00-70. + 135 + 136 /WDSBLK: WDSBLK GOVERNS HOW MANY WORDS THE ROUTINE THINKS ARE + 137 / IN A DECTAPE BLOCK. THE STANDARD VALUE IS 201(8) OR + 138 / 128 DECIMAL. NOTE THAT THE FUNCTION WORD BIT 10 CAN + 139 / 129 DECIMAL ??? (DJG) + 140 / BE USED TO SUBTRACT ONE FROM WDSBLK. THE VALUE USED + 141 / FOR WDSBLK SHOULD BE THE NUMBER OF WORDS THE TAPE WAS + 142 / FORMATTED TO CONTAIN. + 143 + 144 /IF WE WANT A HANDLER FOR UNITS 2&3 TO RESIDE IN + 145 /FIELD 2 AT LOCATION 3000 AND READ/WRITE 256(10) WORDS + 146 /PER BLOCK, THE PARAMETERS WOULD BE: + 147 / DRIVE=20 + 148 / ORIGIN=3000 + 149 / AFIELD=2 + 150 / MFIELD=20 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 4 + + + 151 / WDSBLK=400 + 152 /THE CALL TO THE SUBROUTINE FOLLOWS BASICALLY THE + 153 /CALLING SEQUENCE FOR OS/8 DEVICE HANDLERS. + 154 /THE CALLING SEQUENCE IS: + 155 + 156 / CDF CURRENT + 157 / CIF MFIELD /MFIELD=FIELD ASSEMBLED IN + 158 / JMS ENTRY /ENTRY=ORIGIN (EVEN NUMBERED DRIVE + 159 /AND ORIGIN+4 FOR ODD NUMBERED DRIVE. + 160 / ARG1 + 161 / ARG1B (DJG) + 162 / ARG2 + 163 / ARG3 + 164 / ERROR RETURN + 165 / NORMAL RETURN + 166 + 167 /THE ARGUMENTS ARE: + 168 + 169 /ARG1: FUNCTION WORD BIT0: 0=READ, 1=WRITE + 170 / BITS 1-5: UNUSED, WAS # BLOCKS IN OPERATION (DJG) + 171 / BITS 6-8: FIELD OF BUFFER AREA + 172 / BIT 9: UNUSED + 173 / BIT 10: # OF WORDS/BLOCK. + 174 / 0= WDSBLK, 1=WDSBLK-1 + 175 / BIT 11: 1=START FORWARD, 0=REVERSE + 176 /ARG1A: # OF BLOCKS IN OPERATIONA (DJG) + 177 /ARG2: BUFFER ADDRESS FOR OPERATION + 178 /ARG3: STARTING BLOCK FOR OPERATION + 179 + 180 /ERRORS: THE HANDLER DETECTS TWO TYPES OF ERRORS: + 181 /A) FATAL ERRORS- PARITY ERROR, TIMING ERROR, + 182 / TOO GREAT A BLOCK NUMBER + 183 / FATAL ERRORS TAKE ERROR RETURN WITH THE + 184 / AC=4000. + 185 /B) NON-FATAL- SELECT ERROR. + 186 / IF NO PROPER UNIT IS SELECTED, THE ERROR + 187 / RETURN IS TAKEN WITH CLEAR AC. + 188 /FATAL ERRORS TRY THREE TIMES BEFORE TAKING ERROR RETURN. + 189 /THE NORMAL RETURN IS TAKEN AFTER ALL INDICATED + 190 /BLOCKS HAVE BEEN TRANSFERRED. THE AC IS CLEAR. + 191 + 192 /THE TD8E IOT'S ARE: + 193 6771 SDSS=7001-DRIVE /SKIP ON SINGLE LINE FLAG + 194 6772 SDST=7002-DRIVE /SKIP ON TIMING ERROR + 195 6773 SDSQ=7003-DRIVE /SKIP ON QUAD LINE FLAG + 196 6774 SDLC=7004-DRIVE /LOAD COMMAND REGISTER + 197 6775 SDLD=7005-DRIVE /LOAD DATA REGISTER + 198 6776 SDRC=7006-DRIVE /READ COMMAND REGISTER + 199 6777 SDRD=7007-DRIVE /READ DATA REGISTER + 200 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 5 + + + 201 /THE IOT'S IN GENERAL ARE 677X,676X,675X,AND 674X. + 202 /THE OTHERS CONTROL UNITS 2-7. + 203 + 204 / THIS HANDLER USES DECTAPE BLOCKS NOT OS/8 BLOCKS ! + 205 + 206 0600 *ORIGIN + 207 + 208 / MODIFIED SO BIT 0 ON ENTRY IS UNIT 1 + 209 00600 0000 DTA0, 0 + 210 00601 3047 DCA UNIT /SAVE UNIT POSITION + 211 00602 6214 RDF + 212 00603 1362 TAD C6203 /GET DATA FIELD AND SETUP RETURN + 213 00604 3360 DCA LEAVE + 214 00605 1600 TAD I DTA0 /GET FUNCTION WORD + 215 00606 6775 SDLD /PUT FUNCTION INTO DATA REGISTER + 216 00607 7112 CLL RTR /AC STILL HAS FUNCTION. PUT # WORDS PER + 217 /BLOCK INTO LINK + 218 00610 7630 SZL CLA /KNOCK ONE OFF WDSBLK? + 219 00611 7001 IAC /YES + 220 00612 1022 TAD MWORDS + 221 00613 3023 DCA WCOUNT /STORE MASTER WORD COUNT + 222 00614 2200 ISZ DTA0 /TO BLOCK COUNT (DJG) + 223 00615 1600 TAD I DTA0 / (DJG) + 224 00616 7041 CIA / (DJG) + 225 00617 3051 DCA PGCT / (DJG) + 226 00620 2200 ISZ DTA0 /TO BUFFER + 227 00621 1600 TAD I DTA0 + 228 00622 3044 DCA XBUFF /SAVE ADDRESS (DJG) + 229 / DCA BUFF + 230 00623 2200 ISZ DTA0 /TO BLOCK NUMBER + 231 00624 1600 TAD I DTA0 + 232 00625 3046 DCA BLOCK + 233 00626 2200 ISZ DTA0 /POINT TO ERROR EXIT + 234 00627 6203 CIF CDF MFIELD /TO ROUTINES DATA FIELD + 235 / SDRD /GET FUNCTION INTO AC + 236 / CLL RAL + 237 / AND CM200 /GET # PAGES TO XFER + 238 / DCA PGCT + 239 00630 6777 SDRD + 240 00631 0376 AND C70 /GET FIELD FOR XFER + 241 00632 1363 TAD C6201 /FORM CDF N + 242 00633 3253 DCA XFIELD /IF=0 AND DF=N AT XFER. + 243 00634 1047 TAD UNIT /TEST FOR SELECT ERROR + 244 00635 6774 SDLC + 245 00636 7200 CLA / Moved here because my drive 1 is slow selecting + 246 00637 1020 TAD RETRY + 247 00640 3050 DCA TRYCNT /3 ERROR TRIES + 248 00641 6776 SDRC + 249 00642 0366 AND C100 + 250 00643 7640 SZA CLA + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 6 + + + 251 00644 5353 JMP FATAL-1 + 252 00645 6777 SDRD /PUT FUNCT INTO XFUNCT IN SECOND PG. + 253 00646 3765 DCA I CXFUN + 254 00647 1023 TAD WCOUNT + 255 00650 3452 DCA I CXWCT + 256 00651 6777 SDRD /GET MOTION BIT TO LINK + 257 00652 7110 CLL RAR + 258 00653 7402 XFIELD, HLT /INTO NEXT PAGE + 259 00654 5265 JMP GO /AND START THE MOTION. + 260 00655 6772 RWCOM, SDST /ANY CHECKSUM ERRORS? + 261 00656 7640 SZA CLA /OR CHECKSUM ERRORS? + 262 00657 5343 JMP TRY3 /PLEASE NOTE THAT THE LINK IS ALWAYS + 263 /SET AT RWCOM. GETCHK SETS IT. + 264 / TAD PGCT /NO ERROR..FINISHED XFER? + 265 / TAD CM200 + 266 / SNA + 267 00660 2051 ISZ PGCT / (DJG) + 268 00661 7410 SKP / (DJG) + 269 00662 5352 JMP EXIT /ALL DONE. GET OUT + 270 / DCA PGCT /NEW PAGE COUNT + 271 00663 2046 ISZ BLOCK /NEXT BLOCK TO XFER + 272 / TAD WCOUNT /FORM NEXT BUFFER ADDRESS + 273 / CIA + 274 / TAD BUFF + 275 / DCA XBUFF /SAVE ADDRESS (DJG) + 276 / DCA BUFF / (DJG) + 277 00664 7120 CLL CML /FORCES MOTION FORWARD + 278 00665 7232 GO, CLA CML RTR /LINK BECOMES MOTION BIT + 279 00666 1367 TAD C1000 + 280 00667 1047 TAD UNIT /PUT IN 'GO' AND UNIT # + 281 00670 6774 SDLC /LOOK FOR BLOCK NO. + 282 00671 7200 CLA + 283 00672 1044 TAD XBUFF + 284 00673 3043 DCA OLDBUF + 285 00674 6214 RDF + 286 00675 1363 TAD C6201 + 287 00676 3344 DCA OLDFLD + 288 00677 4764 JMS I CRDQUD /WAIT AT LEAST 6 LINES TO LOOK + 289 00700 4764 JMS I CRDQUD + 290 00701 7600 CM200, 7600 /COULD HAVE SAVED A LOC. HERE + 291 00702 6771 SRCH, SDSS + 292 00703 5302 JMP .-1 /WAIT FOR SINGLE LINE FLAG + 293 00704 6776 SDRC + 294 00705 7106 CLL RTL /DIRECTION TO LINK. INFO BITS + 295 /ARE SHIFTED. + 296 00706 0045 AND C374 /ISOLATE MARK TRACK BITS + 297 00707 1325 TAD M110 /IS IT END ZONE? + 298 00710 7450 SNA /THE LINK STAYS SAME THRU THIS + 299 00711 5333 JMP ENDZ + 300 00712 1053 TAD M20 /CHECK FOR BLOCK MARK + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 7 + + + 301 00713 7640 SZA CLA + 302 00714 5302 JMP SRCH + 303 00715 6777 SDRD /GET THE BLOCK NUMBER + 304 00716 7430 SZL /IF WE ARE IN REVERSE, LOOK FOR 3 + 305 /BLOCKS BEFORE TARGET BLOCK. THIS + 306 /ALLOWS TURNAROUND AND UP TO SPEED. + 307 00717 1377 TAD C3 /REVERSE + 308 00720 7040 CMA + 309 00721 1046 TAD BLOCK + 310 00722 7040 CMA /IS IT RIGHT BLOCK? + 311 00723 7450 SNA + 312 00724 5372 JMP FOUND /YES..HOORAY! + 313 00725 7670 M110, SZL SNA CLA /NO, BUT ARE WE HEADED FOR IT? + 314 /ABOVE SNA IS SUPERFLUOUS. + 315 00726 5302 JMP SRCH /YES + 316 00727 6776 SDRC /NO, TURN US AROUND. + 317 00730 7106 CLL RTL /DIRECTION TO LINK + 318 00731 7200 CLA / + 319 00732 5265 JMP GO / + 320 00733 6776 ENDZ, SDRC /WE ARE IN THE END ZONE + 321 00734 7106 CLL RTL /DIRECTION TO LINK + 322 00735 7630 SZL CLA /ARE WE IN REVERSE? + 323 00736 5265 JMP GO /YES..TURN US AROUND + 324 00737 1046 TAD BLOCK /BLOCK 0? + 325 00740 7640 SZA CLA + 326 00741 5355 JMP ENDEX /END OF TAPE. STOP THE UNIT AND TAKE THE END EXIT. + 327 00742 5265 JMP GO + 328 00743 7200 TRY3, CLA + 329 00744 7000 OLDFLD, NOP + 330 00745 1043 TAD OLDBUF + 331 00746 3044 DCA XBUFF + 332 00747 2050 ISZ TRYCNT + 333 00750 5265 JMP GO /TRY 3 TIMES + 334 00751 5354 JMP FATAL /LINK OFF MEANS AC=4000 ON RETURN + 335 00752 2200 EXIT, ISZ DTA0 /TAKE THE NORMAL RETURN + 336 00753 7120 CLL CML /AC=0 ON NORMAL RETURN + 337 00754 2200 FATAL, ISZ DTA0 /TAKE THE ERROR RETURN + 338 00755 1047 ENDEX, TAD UNIT + 339 00756 6774 SDLC /STOP THE UNIT + 340 00757 7230 CLA CML RAR + 341 00760 7402 LEAVE, HLT + 342 00761 5600 JMP I DTA0 + 343 + 344 + 345 00762 6203 C6203, 6203 + 346 00763 6201 C6201, 6201 + 347 00764 1126 CRDQUD, RDQUAD + 348 /WCOUNT, 0 (MOVED PAGE 0 DJG) + 349 /BUFF, 0 (UNUSED, JAD) + 350 /MWORDS, -WDSBLK (MOVED PAGE 0 DJG) + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 8 + + + 351 /UNIT, 0 (MOVED PAGE 0 JAD) + 352 00765 1166 CXFUN, XFUNCT + 353 00766 0100 C100, 100 + 354 00767 1000 C1000, 1000 + 355 + 356 + 357 0772 *ORIGIN+172 + 358 00772 7630 FOUND, SZL CLA /RIGHT BLOCK. HOW ABOUT DIRECTION? + 359 00773 5265 JMP GO /WRONG..TURN AROUND + 360 00774 1047 TAD UNIT /PUT UNIT INTO LINK + 361 00775 7104 CLL RAL /AC IS NOW 0 + 362 00776 0070 C70, 70 /********DON'T MOVE THIS!!!!****** + 363 00777 0003 C3, 3 + 364 / TAD BUFF /GET BUFFER ADDRESS (DJG) + 365 /XFIELD, HLT /INTO NEXT PAGE + 366 1000 *ORIGIN+200 + 367 01000 6202 CIF MFIELD + 368 / DCA XBUFF /SAVE ADDRESS (DJG) + 369 01001 7010 RAR /NOW GET UNIT # + 370 01002 3333 DCA XUNIT + 371 01003 6776 SDRC + 372 01004 6774 SDLC + 373 01005 6771 REVGRD, SDSS + 374 01006 5205 JMP .-1 /LOOK FOR REVERSE GUARD + 375 01007 6776 SDRC + 376 01010 0261 AND K77 + 377 01011 1367 TAD CM32 /IS IT REVERSE GUARD? + 378 01012 7640 SZA CLA + 379 01013 5205 JMP REVGRD /NO.KEEP LOOKING + 380 01014 1373 TAD XWCT + 381 01015 3372 DCA WORDS /WORD COUNTER + 382 01016 1366 TAD XFUNCT /GET FUNCTION READ OR WRITE + 383 01017 7700 K7700, SMA CLA + 384 01020 5262 JMP READ /NEG. IS WRITE + 385 01021 6776 WRITE, SDRC + 386 01022 0316 AND C300 /CHECK FOR WRITE LOCK AND SELECT ERROR + 387 01023 7120 CLL CML /LOCK OUT AND SELECT ARE AC 0 ERRORS + 388 01024 7640 SZA CLA + 389 01025 5764 JMP I CFATAL /FATAL ERROR. LINK MUST BE ON + 390 01026 4326 JMS RDQUAD /NO ONE EVER USES THIS WORD! + 391 01027 7600 C7600, 7600 + 392 01030 1370 TAD C1400 + 393 01031 1333 TAD XUNIT /INITIATE WRITE MODE + 394 01032 6774 SDLC + 395 01033 7240 CLA CMA + 396 01034 4317 JMS WRQUAD /PUT 77 IN REVERSE CHECKSUM + 397 01035 7240 CLA CMA + 398 01036 3371 DCA CHKSUM + 399 01037 1444 WRLP, TAD I XBUFF /GLORY BE! THE ACTUAL WRITE! + 400 01040 4317 JMS WRQUAD + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 9 + + + 401 01041 2044 ISZ XBUFF /BUMP CORE POINTER + 402 01042 5247 JMP STFLD1+1 /NOT AT END OF FIELD (DJG) + 403 01043 6214 RDF + 404 01044 1377 TAD (6211 + 405 01045 3246 DCA STFLD1 + 406 01046 7000 STFLD1, NOP + 407 01047 2372 ISZ WORDS /DONE THIS BLOCK? + 408 01050 5237 JMP WRLP /NOT YET..LOOP A WHILE + 409 01051 1366 TAD XFUNCT /IS THE OPERATION FOR WDSBLK PER BLOCK? + 410 01052 7112 CLL RTR /IF NO, WRITE A 0 WORD + 411 01053 7630 SZL CLA + 412 01054 4317 JMS WRQUAD /WRITE A WORD OF 0 + 413 01055 4350 JMS GETCHK /DO THE CHECK SUM + 414 01056 4317 JMS WRQUAD /WRITE FORWARD CHECKSUM + 415 01057 4317 JMS WRQUAD /ALLOW CHECKSUM TO BE WRITTEN + 416 01060 5765 JMP I CRWCOM + 417 01061 0077 K77, 77 /ABOVE MAY SKIP (NOT ANYMORE DJG) + 418 01062 4326 READ, JMS RDQUAD + 419 01063 4326 JMS RDQUAD + 420 01064 4326 JMS RDQUAD /SKIP CONTROL WORDS + 421 01065 0261 AND K77 + 422 01066 1217 TAD K7700 /TACK 7700 ONTO CHECKSUM. + 423 01067 3371 DCA CHKSUM /CHECKSUM ONLY LOW 6 BITS ANYWAY + 424 01070 4326 RDLP, JMS RDQUAD + 425 01071 4333 JMS EQUFUN /COMPUT CHECKSUM AS WE GO + 426 01072 3444 DCA I XBUFF /IT GETS CONDENSED LATER + 427 01073 2044 ISZ XBUFF /AT END OF FIELD? + 428 01074 5301 JMP STFLD2+1 /NOT AT END OF FIELD (DJG) + 429 01075 6214 RDF + 430 01076 1377 TAD (6211 + 431 01077 3300 DCA STFLD2 + 432 01100 7000 STFLD2, NOP + 433 01101 2372 ISZ WORDS /DONE THIS OP? + 434 01102 5270 JMP RDLP /NO SUCH LUCK + 435 01103 1366 TAD XFUNCT /IF OP WAS FOR WDSBLK-1, READ AND + 436 01104 7112 CLL RTR /CHECKSUM THE LAST TAPE WORD + 437 01105 7620 SNL CLA + 438 01106 5311 JMP RDLP2 + 439 01107 4326 JMS RDQUAD /NOT NEEDED FOR WDSBLK/BLOCK + 440 01110 4333 JMS EQUFUN /CHECKSUM IT + 441 01111 4326 RDLP2, JMS RDQUAD /READ CHECKSUM + 442 01112 0217 AND K7700 + 443 01113 4333 JMS EQUFUN + 444 01114 4350 JMS GETCHK /GET SIX BIT CHECKSUM + 445 01115 5765 JMP I CRWCOM + 446 01116 0300 C300, 300 /PROTECTION (NOT ANYMORE DJG) + 447 + 448 01117 0000 WRQUAD, 0 /WRITE OUT A 12 BIT WORD + 449 01120 4333 JMS EQUFUN /ADD THIS TO CHECKSUM + 450 01121 6773 SDSQ /SKIP ON QUADLINE FLAG + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 10 + + + 451 01122 5321 JMP .-1 + 452 01123 6775 SDLD /LOAD DATA ONTO BUS + 453 01124 7200 CLA /SDLD DOESN'T CLEAR AC + 454 01125 5717 JMP I WRQUAD + 455 + 456 01126 0000 RDQUAD, 0 /READ A 12 BIT WORD + 457 01127 6773 SDSQ + 458 01130 5327 JMP .-1 + 459 01131 6777 SDRD /READ DATA + 460 01132 5726 JMP I RDQUAD + 461 + 462 XUNIT, + 463 01133 0000 EQUFUN, 0 /COMPUTE EQUIVALENCE CHECKSUM + 464 01134 7040 CMA + 465 01135 3374 DCA EQUTMP /ACTUALLY CHECKSUMS ON DECTAPE ARE + 466 01136 1374 TAD EQUTMP /EQUIVALENCE OF ALL WORDS IN A RECORD + 467 01137 0371 AND CHKSUM /SIX BITS AT A TIME. BUT SINCE EQUIVALENCE + 468 01140 7041 CIA /IS ASSOCIATIVE, WE CAN DO IT 12 + 469 01141 7104 CLL RAL /BITS AT A TIME AND CONDENSE LATER. + 470 01142 1374 TAD EQUTMP /THIS ROUTINE USES THESE IDENTITIES: + 471 01143 1371 TAD CHKSUM /A+B=(A.XOR.B)+2*(A.AND.B) + 472 01144 3371 DCA CHKSUM /A.EQU.B=.NOT.(A.XOR.B)=A.XOR.(.NOT.B) + 473 01145 1374 TAD EQUTMP /A.EQU.B=(A+(.NOT.B))-2*(A.AND.(.NOT.B)) + 474 01146 7040 CMA + 475 01147 5733 JMP I EQUFUN + 476 + 477 01150 0000 GETCHK, 0 /FORM 6 BIT CHECKSUM + 478 01151 7200 CLA + 479 01152 1371 TAD CHKSUM + 480 01153 7040 CMA + 481 01154 7106 CLL RTL + 482 01155 7006 RTL + 483 01156 7006 RTL + 484 01157 4333 JMS EQUFUN + 485 01160 7320 CLA CLL CML /FORCES LINK ON AT RWCOM + 486 01161 1371 TAD CHKSUM + 487 01162 0217 AND K7700 + 488 01163 5750 JMP I GETCHK + 489 + 490 01164 0754 CFATAL, FATAL + 491 01165 0655 CRWCOM, RWCOM + 492 01166 0000 XFUNCT, 0 + 493 01167 7746 CM32, -32 + 494 01170 1400 C1400, 1400 + 495 01171 0000 CHKSUM, 0 + 496 01172 0000 WORDS, 0 + 497 01173 0000 XWCT, 0 + 498 01174 0000 EQUTMP, 0 + 499 + 01177 6211 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 11 + + + 500 0020 *20 + 501 00020 7774 RETRY, 7774 / RETRY UP TO 4 TIME + 502 00021 1202 NUMBLK, 1202 / MAX NUMBER OF BLOCKS TO ATTEMPT READING + 503 / (1102(8) blocks of 400(8) 18-bit words + 100 TO HANDLE NONSTANDARD (LONG) TAPES) + 504 00022 7200 MWORDS, -WDSBLK / WORDS PER BLOCK + 505 00023 0000 WCOUNT, 0 + 506 00024 0012 BLKFLD, 12 / 10 386-word-blocks (12-bit words, equivalent to 256 18-bit words + 1 cksum word) + 507 / WRAPPING PAST END OF LAST FIELD DOESN'T WORK + 508 00025 0000 FIELDS, 0 + 509 00026 0000 RDSIZE, 0 / NUMBER BLOCKS PER READ + 510 00027 0000 CBLOCK, 0 / CURRENT BLOCK TO XFER + 511 00030 0000 CLKSUM, 0 + 512 00031 0000 DRVSEL, 0 + 513 00032 0377 READST, 377 + 514 00033 0000 LOC, 0 + 515 00034 0000 LEN, 0 + 516 00035 0000 BCNT, 0 / BLOCKS TO SEND TO PC + 517 00036 0000 TEMP, 0 + 518 00037 0017 C17, 17 + 519 00040 0360 C360, 360 + 520 00041 0000 CHKSM, 0 + 521 00042 0000 ERRCN2, 0 + 522 00043 0000 OLDBUF, 0 / USED BY DTA0 ROUTINE + 523 00044 0000 XBUFF, 0 / USED BY DTA0 ROUTINE + 524 00045 0374 C374, 374 / USED BY DTA0 ROUTINE + 525 00046 0000 BLOCK, 0 / USED BY DTA0 ROUTINE + 526 00047 0000 UNIT, 0 / USED BY DTA0 ROUTINE + 527 00050 7775 TRYCNT, -3 / " + 528 00051 0000 PGCT, 0 / " + 529 00052 1173 CXWCT, XWCT / " + 530 00053 7760 M20, -20 / " + 531 + 532 0140 *140 + 533 00140 7402 FINISH, HLT / Normal good halt + 534 00141 5777@ JMP START + 535 + 536 0200 *200 + 537 00200 6201 START, CDF 0 + 538 00201 6007 CAF + 539 00202 7704 CLA CLL OSR / Get drive + 540 00203 0377 AND (1 + 541 00204 7012 RTR + 542 00205 3031 DCA DRVSEL + 543 00206 7704 CLA CLL OSR / Get max field + 544 00207 7012 RTR + 545 00210 7010 RAR + 546 00211 0376 AND (7 + 547 00212 7450 SNA + 548 00213 7402 HLT / Must have at least 1 field for buffer + 549 00214 7041 CIA + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 12 + + + 550 00215 3025 DCA FIELDS + 551 00216 3042 DCA ERRCN2 + 552 00217 1024 RDSZLP, TAD BLKFLD / Multiply by number of fields available + 553 00220 2025 ISZ FIELDS + 554 00221 5217 JMP RDSZLP + 555 00222 3026 DCA RDSIZE / NUMBER BLOCK PER READ + 556 00223 3027 DCA CBLOCK + 557 00224 3041 DCA CHKSM + 558 + 559 00225 7200 DUMPLP, CLA + 560 00226 1026 TAD RDSIZE + 561 00227 1027 TAD CBLOCK + 562 00230 7041 CIA + 563 00231 1021 TAD NUMBLK / MORE BLOCKS LEFT THAN READSIZE? + 564 00232 7500 SMA / NO, READ NUMBER LEFT + 565 00233 7200 CLA / YES, ONLY READ RDSIZE + 566 00234 1026 TAD RDSIZE + 567 00235 7450 SNA / ANY MORE BLOCKS? + 568 00236 5270 JMP DONE / NO, DO FINISH STUFF + 569 00237 3245 DCA ARGSZ + 570 00240 1027 TAD CBLOCK + 571 00241 3247 DCA ARGBK + 572 00242 1031 TAD DRVSEL + 573 00243 4775@ JMS DTA0 + 574 00244 0010 0010 / READ STARTING IN FIELD 1 + 575 00245 0000 ARGSZ, 0 + 576 00246 0000 0 + 577 00247 0000 ARGBK, 0 + 578 00250 5774@ JMP ENDRET / TAKEN WHEN END OF TAPE IS HIT + 579 00251 5323 JMP ERRRET / TAKEN WHEN AN ERROR IS ENCOUNTERED + 580 00252 1373 TAD (377 / All blocks good + 581 00253 3032 DCA READST + 582 / Send data, each block starts with FF + 583 00254 7300 CLA CLL / then 2 12 bit words in 3 bytes + 584 00255 3033 DCA LOC / ERRRET DUPLICATES SOME OF THIS + 585 00256 1245 TAD ARGSZ + 586 00257 7041 CIA + 587 00260 3035 DCA BCNT / Setup loop counter with number blocks read + 588 00261 6211 CDF 10 + 589 00262 4772@ OUTBL1, JMS OUTBLK / Send a block + 590 00263 2027 ISZ CBLOCK + 591 00264 2035 ISZ BCNT / Send all read? + 592 00265 5262 JMP OUTBL1 / No + 593 00266 6201 CDF 0 + 594 00267 5225 JMP DUMPLP / Go read next batch + 595 + 596 + 597 00270 7200 DONE, CLA / Send FE and -checksum of all words + 598 00271 1371 TAD (376 + 599 00272 4770@ JMS PUN + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 13 + + + 600 00273 7300 CLA CLL + 601 00274 1041 TAD CHKSM / Send checksum in two bytes, low bits first + 602 00275 7041 CIA + 603 00276 4770@ JMS PUN + 604 00277 7300 CLA CLL + 605 00300 1041 TAD CHKSM + 606 00301 7041 CIA + 607 00302 7012 RTR + 608 00303 7012 RTR + 609 00304 7012 RTR + 610 00305 7012 RTR + 611 00306 0037 AND C17 + 612 00307 4770@ JMS PUN + 613 00310 7200 CLA + 614 00311 1031 TAD DRVSEL + 615 00312 4775@ JMS DTA0 / REWIND TAPE + 616 00313 0010 0010 + 617 00314 0001 1 + 618 00315 0000 0 + 619 00316 0000 0 + 620 00317 7000 NOP + 621 00320 7000 NOP + 622 00321 1042 TAD ERRCN2 / Leave AC with # of errors + 623 00322 5140 JMP FINISH + 624 + 625 /SEND GOOD BLOCKS READ WITH GOOD BLOCK FLAG + 626 /THEN BAD WITH BAD BLOCK FLAG. + 627 ERRRET, + 628 / HLT / ****** If we want to stop on error + 629 00323 6211 CDF 10 + 630 00324 7300 CLA CLL + 631 00325 3033 DCA LOC + 632 00326 1027 TAD CBLOCK + 633 00327 7041 CIA + 634 00330 1046 TAD BLOCK /Get - number good blocks read + 635 00331 7041 CIA /Last was bad + 636 00332 7450 SNA + 637 00333 5343 JMP FSTBAD /First block is bad, no good to send + 638 00334 3035 DCA BCNT + 639 00335 1373 TAD (377 + 640 00336 3032 DCA READST + 641 00337 4772@ OUTBL2, JMS OUTBLK /Send good blocks + 642 00340 2027 ISZ CBLOCK + 643 00341 2035 ISZ BCNT + 644 00342 5337 JMP OUTBL2 + 645 00343 1367 FSTBAD, TAD (375 /NOW SEND BAD BLOCK + 646 00344 3032 DCA READST + 647 00345 4772@ JMS OUTBLK + 648 00346 2027 ISZ CBLOCK + 649 00347 2042 ISZ ERRCN2 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 14 + + + 650 00350 6201 CDF 0 + 651 00351 5225 JMP DUMPLP /And read from here on + 652 + 00367 0375 + 00370 0511 + 00371 0376 + 00372 0422 + 00373 0377 + 00374 0400 + 00375 0600 + 00376 0007 + 00377 0001 + 653 PAGE + 654 ENDRET, /SEND LAST SET OF BLOCKS READ BEFORE END OF TAPE AND FINISH. + 655 00400 6211 CDF 10 + 656 00401 7300 CLA CLL + 657 00402 3033 DCA LOC + 658 00403 1027 TAD CBLOCK + 659 00404 7041 CIA + 660 00405 1046 TAD BLOCK / GET NUMBER OF BLOCKS READ IN LAST BATCH + 661 00406 7040 CMA / +1 to -BCNT SO WE SEND ALL BLOCKS + 662 00407 7450 SNA + 663 00410 5777@ JMP DONE / READ ZERO BLOCKS IN LAST BATCH, WE ARE DONE + 664 00411 3035 DCA BCNT + 665 00412 1376 TAD (377 + 666 00413 3032 DCA READST + 667 00414 4222 OUTBL3, JMS OUTBLK / SEND ALL BLOCKS + 668 00415 2027 ISZ CBLOCK + 669 00416 2035 ISZ BCNT + 670 00417 5214 JMP OUTBL3 + 671 00420 6201 CDF 0 + 672 00421 5777@ JMP DONE / NO MORE BLOCKS, DONE. + 673 + 674 00422 0000 OUTBLK, 0 /Send a block of data out serial port + 675 00423 7200 CLA + 676 00424 1023 TAD WCOUNT + 677 00425 3034 DCA LEN + 678 00426 1032 TAD READST /Send good/bad flag + 679 00427 4311 JMS PUN + 680 00430 7300 OUT, CLA CLL + 681 00431 1433 TAD I LOC + 682 00432 1041 TAD CHKSM / Keep checksum of all words sent + 683 00433 3041 DCA CHKSM + 684 00434 1433 TAD I LOC / Send 2 words as 3 bytes + 685 00435 4311 JMS PUN + 686 00436 7300 CLA CLL + 687 00437 1433 TAD I LOC + 688 00440 7012 RTR / Shift top 4 bits to low 4 + 689 00441 7012 RTR + 690 00442 7012 RTR + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 15 + + + 691 00443 7012 RTR + 692 00444 0037 AND C17 + 693 00445 3036 DCA TEMP + 694 00446 2033 ISZ LOC + 695 00447 5254 JMP STFLD3+1 /NOT AT END OF FIELD (DJG) + 696 00450 6214 RDF /At end, inc to next field + 697 00451 1375 TAD (6211 /BUILD CDF + 698 00452 3253 DCA STFLD3 + 699 00453 7000 STFLD3, NOP + 700 00454 2034 ISZ LEN /END IF BUFFER? + 701 00455 7410 SKP /NO + 702 00456 5306 JMP ENDBK /YES + 703 00457 1433 TAD I LOC + 704 00460 1041 TAD CHKSM + 705 00461 3041 DCA CHKSM + 706 00462 1433 TAD I LOC + 707 00463 7006 RTL + 708 00464 7006 RTL + 709 00465 0040 AND C360 + 710 00466 1036 TAD TEMP + 711 00467 4311 JMS PUN + 712 00470 7300 CLA CLL + 713 00471 1433 TAD I LOC + 714 00472 7012 RTR + 715 00473 7012 RTR + 716 00474 4311 JMS PUN + 717 00475 2033 ISZ LOC + 718 00476 5303 JMP STFLD4+1 /NOT AT END OF FIELD (DJG) + 719 00477 6214 RDF + 720 00500 1375 TAD (6211 /BUILD CDF + 721 00501 3302 DCA STFLD4 + 722 00502 7000 STFLD4, NOP + 723 00503 2034 ISZ LEN + 724 00504 5230 JMP OUT + 725 00505 5622 JMP I OUTBLK + 726 00506 1036 ENDBK, TAD TEMP /SEND LAST PART OF WORD + 727 00507 4311 JMS PUN + 728 00510 5622 JMP I OUTBLK + 729 + 730 00511 0000 PUN, 0 / Send byte out serial port + 731 / PLS / Punch for testing with emulator + 732 00512 6046 TLS2 / Send out console + 733 00513 7300 CLA CLL + 734 00514 1027 TAD CBLOCK + 735 / PSF + 736 00515 6041 TSF2 /Wait until character sent + 737 00516 5315 JMP .-1 + 738 00517 7200 CLA + 739 00520 5711 JMP I PUN + 740 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 16 + + + 00575 6211 + 00576 0377 + 00577 0270 + 00177 0200 + 741 $ + + No detected errors + 12 links generated diff --git a/DumpDT18/dump-old.pal b/DumpDT18/dump-old.pal new file mode 100644 index 0000000..d2ee6b5 --- /dev/null +++ b/DumpDT18/dump-old.pal @@ -0,0 +1,741 @@ +/ TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code from D. Gesswein +/ (see ftp://ftp.pdp8online.com/software/dumprest). +/ Modified for 18-bit DECtape w/standard checksum imaging by J. Dersch +/ +/ This program will send a DECtape image out the console port. +/ The format of the data sent is 0xff (0377) or 0xfd if read error +/ followed by 384 12-bit words (256 18-bit words) of data for each block. +/ After the last block a 0xfe (0376) is sent +/ with a two byte checksum, low 8 bits first then upper 4. +/ The words in a block are sent as three bytes for each 2 words. +/ 1 = low 8 bits first word +/ 2 = upper 4 bits first and lower 4 bits second +/ 3 = upper 8 bits second word +/ +/ The program (PC) receiving the data should be started before this program. +/ +/ To run, start at 0200. +/ SR 11 should be drive, only 0 and 1 supported without reassembling +/ SR 6-8 should be maximum memory field in computer, needs 8k minimum +/ +/ The receiving program should be running first. +/ At normal exit hitting cont will restart the program. +/ +/ Should halt at label finish (140) with number of recoverable errors in AC +/ The current block being read will be displayed in the AC +/ while running. +/ +/ The PC program will print out the bad location if an error occurs. +/ +/ We will retry each read up to four times on error. +/ +/ This transfers the standard 256 word by 578 blocks used by 18-bit DEC hardware, +/ using standard checksums (as used by the PDP-9 and later machines). +/ It will read as many blocks are present up to the forward end-zone, so it will +/ handle tapes that vary from the standard 1102(8) block length. +/ + INAD=030 / Address of serial input, 30 for console + KCF2=6000 INAD + KSF2=6001 INAD + KCC2=6002 INAD + KRS2=6004 INAD + KIE2=6005 INAD + KRB2=6006 INAD + + OUTAD=040 / Address of serial output, 40 for console + TFL2=6000 OUTAD + TSF2=6001 OUTAD + TCF2=6002 OUTAD + TPC2=6004 OUTAD + TSK2=6005 OUTAD + TLS2=6006 OUTAD + +/2 TD8E INITIALIZER PROGRAM, V7A +/ +/COPYRIGHT (C) 1975, 1977 +/DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. +/ +/ +/ +/THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A +/SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLU- +/SION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ANT OTHER +/COPIES THEREOF, MAY NOT BR PROVIDED OR OTHERWISE MADE AVAILABLE +/TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO +/AGREES TO THESE LICENSE TERMS. TITLE TO AND OWNERSHIP OF THE +/SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC. +/ +/ +/THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT +/NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL +/EQUIPMRNT COROPATION. +/ +/DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS +/SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. +/ +/ +/ +/ +/ +/ + +/DECEMBER 21, 1973 GB/RL/EF/SR + +/ABSTRACT-- +/ THE ROUTINE DESCRIBED AND LISTED HERE IS A GENERAL +/DATA HANDLER FOR THE TD8E DECTAPE SYSTEM. THE ROUTINE +/CONTAINS SEARCH, READ, AND WRITE FUNCTIONS IN A FORMAT +/WHICH IS COMPATIBLE WITH OS/8 DEVICE HANDLER CALLING +/SEQUENCES. + +/FIXES SINCE FIELD-TEST RELEASE: + +/1. FIXED BUG RE CLA ON RETRY AFTER ERROR +/2. ALLOWED FINAL BOOTSTRAP TO BE INTO A WRITE-LOCKED DEVICE + +/OS/8 V3D CHANGES: + +/3. FIXED BUG RE TD8E BUILD (V6B PATCH) + +/THIS ROUTINE CAN BE RE-EDITED AND ASSEMBLED TO PRODUCE +/VARIATIONS ON THE BASIC TD8E SYSTEM. ASSEMBLY PARAMETERS +/CONTROL: +/A) WHAT DRIVES (UNITS 0-7) WILL BE USED +/B) THE ORIGIN OF THE TWO PAGE ROUTINE +/C) WHAT MEMORY FIELD THE ROUTINE WILL RUN IN +/D) THE SIZE OF THE DECTAPE BLOCK TO BE READ/WRITTEN + +/FOLLOWING ARE THE PARAMETERS SET UP FOR THE STANDARD +/DEC VERSION OF THIS ROUTINE: + + DRIVE=10 /UNITS 0 AND 1 SELECTED + ORIGIN=600 /ENTER AT ORIGIN, ORIGIN+4 + AFIELD=0 /INITIAL FIELD SETTING + MFIELD=00 /AFIELD*10=MFIELD + WDSBLK=600 /384 12-BIT WORDS PER BLOCK (256 18-BIT DATA WORDS) + +/THE USE OF THE PARAMETERS IS AS FOLLOWS: + +/ DRIVE: DRIVE DETERMINES WHICH UNITS WILL BE SELECTED +/ DRIVE=10 IMPLIES UNITS 0 &1 +/ DRIVE=20 IMPLIES UNITS 2&3 +/ DRIVE=30 IMPLIES UNITS 4&5 +/ DRIVE=40 IMPLIES UNITS 6&7 + +/ORIGIN: ALTERING ORIGIN CAUSES ASSEMBLY IN A DIFFERENT +/ MEMORY LOCATION. WHEN CHANGING ORIGIN KEEP IN MIND +/THAT THIS IS A TWO PAGE ROUTINE. + +/AFIELD: AFIELD DETERMINES THE INITIAL FIELD SETTING FOR THE +/ LOADER. PERMISSIBLE VALUES FOR AFIELD ARE 0 TO 7. + +/MFIELD: MFIELD IS USED IN A CIF CDF MFIELD INSTRUCTION. +/ THE VALUE INSERTED FOR MFIELD SHOULD BE 10(8) TIMES +/ THE VALUE FOR AFIELD. THE PERMISSIBLE VALUES ARE 00-70. + +/WDSBLK: WDSBLK GOVERNS HOW MANY WORDS THE ROUTINE THINKS ARE +/ IN A DECTAPE BLOCK. THE STANDARD VALUE IS 201(8) OR +/ 128 DECIMAL. NOTE THAT THE FUNCTION WORD BIT 10 CAN +/ 129 DECIMAL ??? (DJG) +/ BE USED TO SUBTRACT ONE FROM WDSBLK. THE VALUE USED +/ FOR WDSBLK SHOULD BE THE NUMBER OF WORDS THE TAPE WAS +/ FORMATTED TO CONTAIN. + +/IF WE WANT A HANDLER FOR UNITS 2&3 TO RESIDE IN +/FIELD 2 AT LOCATION 3000 AND READ/WRITE 256(10) WORDS +/PER BLOCK, THE PARAMETERS WOULD BE: +/ DRIVE=20 +/ ORIGIN=3000 +/ AFIELD=2 +/ MFIELD=20 +/ WDSBLK=400 + /THE CALL TO THE SUBROUTINE FOLLOWS BASICALLY THE +/CALLING SEQUENCE FOR OS/8 DEVICE HANDLERS. +/THE CALLING SEQUENCE IS: + +/ CDF CURRENT +/ CIF MFIELD /MFIELD=FIELD ASSEMBLED IN +/ JMS ENTRY /ENTRY=ORIGIN (EVEN NUMBERED DRIVE + /AND ORIGIN+4 FOR ODD NUMBERED DRIVE. +/ ARG1 +/ ARG1B (DJG) +/ ARG2 +/ ARG3 +/ ERROR RETURN +/ NORMAL RETURN + +/THE ARGUMENTS ARE: + +/ARG1: FUNCTION WORD BIT0: 0=READ, 1=WRITE +/ BITS 1-5: UNUSED, WAS # BLOCKS IN OPERATION (DJG) +/ BITS 6-8: FIELD OF BUFFER AREA +/ BIT 9: UNUSED +/ BIT 10: # OF WORDS/BLOCK. +/ 0= WDSBLK, 1=WDSBLK-1 +/ BIT 11: 1=START FORWARD, 0=REVERSE +/ARG1A: # OF BLOCKS IN OPERATIONA (DJG) +/ARG2: BUFFER ADDRESS FOR OPERATION +/ARG3: STARTING BLOCK FOR OPERATION + +/ERRORS: THE HANDLER DETECTS TWO TYPES OF ERRORS: +/A) FATAL ERRORS- PARITY ERROR, TIMING ERROR, +/ TOO GREAT A BLOCK NUMBER +/ FATAL ERRORS TAKE ERROR RETURN WITH THE +/ AC=4000. +/B) NON-FATAL- SELECT ERROR. +/ IF NO PROPER UNIT IS SELECTED, THE ERROR +/ RETURN IS TAKEN WITH CLEAR AC. +/FATAL ERRORS TRY THREE TIMES BEFORE TAKING ERROR RETURN. +/THE NORMAL RETURN IS TAKEN AFTER ALL INDICATED +/BLOCKS HAVE BEEN TRANSFERRED. THE AC IS CLEAR. + +/THE TD8E IOT'S ARE: + SDSS=7001-DRIVE /SKIP ON SINGLE LINE FLAG + SDST=7002-DRIVE /SKIP ON TIMING ERROR + SDSQ=7003-DRIVE /SKIP ON QUAD LINE FLAG + SDLC=7004-DRIVE /LOAD COMMAND REGISTER + SDLD=7005-DRIVE /LOAD DATA REGISTER + SDRC=7006-DRIVE /READ COMMAND REGISTER + SDRD=7007-DRIVE /READ DATA REGISTER + +/THE IOT'S IN GENERAL ARE 677X,676X,675X,AND 674X. +/THE OTHERS CONTROL UNITS 2-7. + +/ THIS HANDLER USES DECTAPE BLOCKS NOT OS/8 BLOCKS ! + + *ORIGIN + +/ MODIFIED SO BIT 0 ON ENTRY IS UNIT 1 +DTA0, 0 + DCA UNIT /SAVE UNIT POSITION + RDF + TAD C6203 /GET DATA FIELD AND SETUP RETURN + DCA LEAVE + TAD I DTA0 /GET FUNCTION WORD + SDLD /PUT FUNCTION INTO DATA REGISTER + CLL RTR /AC STILL HAS FUNCTION. PUT # WORDS PER + /BLOCK INTO LINK + SZL CLA /KNOCK ONE OFF WDSBLK? + IAC /YES + TAD MWORDS + DCA WCOUNT /STORE MASTER WORD COUNT + ISZ DTA0 /TO BLOCK COUNT (DJG) + TAD I DTA0 / (DJG) + CIA / (DJG) + DCA PGCT / (DJG) + ISZ DTA0 /TO BUFFER + TAD I DTA0 + DCA XBUFF /SAVE ADDRESS (DJG) +/ DCA BUFF + ISZ DTA0 /TO BLOCK NUMBER + TAD I DTA0 + DCA BLOCK + ISZ DTA0 /POINT TO ERROR EXIT + CIF CDF MFIELD /TO ROUTINES DATA FIELD +/ SDRD /GET FUNCTION INTO AC +/ CLL RAL +/ AND CM200 /GET # PAGES TO XFER +/ DCA PGCT + SDRD + AND C70 /GET FIELD FOR XFER + TAD C6201 /FORM CDF N + DCA XFIELD /IF=0 AND DF=N AT XFER. + TAD UNIT /TEST FOR SELECT ERROR + SDLC + CLA / Moved here because my drive 1 is slow selecting + TAD RETRY + DCA TRYCNT /3 ERROR TRIES + SDRC + AND C100 + SZA CLA + JMP FATAL-1 + SDRD /PUT FUNCT INTO XFUNCT IN SECOND PG. + DCA I CXFUN + TAD WCOUNT + DCA I CXWCT + SDRD /GET MOTION BIT TO LINK + CLL RAR +XFIELD, HLT /INTO NEXT PAGE + JMP GO /AND START THE MOTION. +RWCOM, SDST /ANY CHECKSUM ERRORS? + SZA CLA /OR CHECKSUM ERRORS? + JMP TRY3 /PLEASE NOTE THAT THE LINK IS ALWAYS + /SET AT RWCOM. GETCHK SETS IT. +/ TAD PGCT /NO ERROR..FINISHED XFER? +/ TAD CM200 +/ SNA + ISZ PGCT / (DJG) + SKP / (DJG) + JMP EXIT /ALL DONE. GET OUT +/ DCA PGCT /NEW PAGE COUNT + ISZ BLOCK /NEXT BLOCK TO XFER +/ TAD WCOUNT /FORM NEXT BUFFER ADDRESS +/ CIA +/ TAD BUFF +/ DCA XBUFF /SAVE ADDRESS (DJG) +/ DCA BUFF / (DJG) + CLL CML /FORCES MOTION FORWARD +GO, CLA CML RTR /LINK BECOMES MOTION BIT + TAD C1000 + TAD UNIT /PUT IN 'GO' AND UNIT # + SDLC /LOOK FOR BLOCK NO. + CLA + TAD XBUFF + DCA OLDBUF + RDF + TAD C6201 + DCA OLDFLD + JMS I CRDQUD /WAIT AT LEAST 6 LINES TO LOOK + JMS I CRDQUD +CM200, 7600 /COULD HAVE SAVED A LOC. HERE +SRCH, SDSS + JMP .-1 /WAIT FOR SINGLE LINE FLAG + SDRC + CLL RTL /DIRECTION TO LINK. INFO BITS + /ARE SHIFTED. + AND C374 /ISOLATE MARK TRACK BITS + TAD M110 /IS IT END ZONE? + SNA /THE LINK STAYS SAME THRU THIS + JMP ENDZ + TAD M20 /CHECK FOR BLOCK MARK + SZA CLA + JMP SRCH + SDRD /GET THE BLOCK NUMBER + SZL /IF WE ARE IN REVERSE, LOOK FOR 3 + /BLOCKS BEFORE TARGET BLOCK. THIS + /ALLOWS TURNAROUND AND UP TO SPEED. + TAD C3 /REVERSE + CMA + TAD BLOCK + CMA /IS IT RIGHT BLOCK? + SNA + JMP FOUND /YES..HOORAY! +M110, SZL SNA CLA /NO, BUT ARE WE HEADED FOR IT? + /ABOVE SNA IS SUPERFLUOUS. + JMP SRCH /YES + SDRC /NO, TURN US AROUND. + CLL RTL /DIRECTION TO LINK + CLA / + JMP GO / +ENDZ, SDRC /WE ARE IN THE END ZONE + CLL RTL /DIRECTION TO LINK + SZL CLA /ARE WE IN REVERSE? + JMP GO /YES..TURN US AROUND + TAD BLOCK /BLOCK 0? + SZA CLA + JMP ENDEX /END OF TAPE. STOP THE UNIT AND TAKE THE END EXIT. + JMP GO +TRY3, CLA +OLDFLD, NOP + TAD OLDBUF + DCA XBUFF + ISZ TRYCNT + JMP GO /TRY 3 TIMES + JMP FATAL /LINK OFF MEANS AC=4000 ON RETURN +EXIT, ISZ DTA0 /TAKE THE NORMAL RETURN + CLL CML /AC=0 ON NORMAL RETURN +FATAL, ISZ DTA0 /TAKE THE ERROR RETURN +ENDEX, TAD UNIT + SDLC /STOP THE UNIT + CLA CML RAR +LEAVE, HLT + JMP I DTA0 + + +C6203, 6203 +C6201, 6201 +CRDQUD, RDQUAD +/WCOUNT, 0 (MOVED PAGE 0 DJG) +/BUFF, 0 (UNUSED, JAD) +/MWORDS, -WDSBLK (MOVED PAGE 0 DJG) +/UNIT, 0 (MOVED PAGE 0 JAD) +CXFUN, XFUNCT +C100, 100 +C1000, 1000 + + + *ORIGIN+172 +FOUND, SZL CLA /RIGHT BLOCK. HOW ABOUT DIRECTION? + JMP GO /WRONG..TURN AROUND + TAD UNIT /PUT UNIT INTO LINK + CLL RAL /AC IS NOW 0 +C70, 70 /********DON'T MOVE THIS!!!!****** +C3, 3 +/ TAD BUFF /GET BUFFER ADDRESS (DJG) +/XFIELD, HLT /INTO NEXT PAGE + *ORIGIN+200 + CIF MFIELD +/ DCA XBUFF /SAVE ADDRESS (DJG) + RAR /NOW GET UNIT # + DCA XUNIT + SDRC + SDLC +REVGRD, SDSS + JMP .-1 /LOOK FOR REVERSE GUARD + SDRC + AND K77 + TAD CM32 /IS IT REVERSE GUARD? + SZA CLA + JMP REVGRD /NO.KEEP LOOKING + TAD XWCT + DCA WORDS /WORD COUNTER + TAD XFUNCT /GET FUNCTION READ OR WRITE +K7700, SMA CLA + JMP READ /NEG. IS WRITE +WRITE, SDRC + AND C300 /CHECK FOR WRITE LOCK AND SELECT ERROR + CLL CML /LOCK OUT AND SELECT ARE AC 0 ERRORS + SZA CLA + JMP I CFATAL /FATAL ERROR. LINK MUST BE ON + JMS RDQUAD /NO ONE EVER USES THIS WORD! +C7600, 7600 + TAD C1400 + TAD XUNIT /INITIATE WRITE MODE + SDLC + CLA CMA + JMS WRQUAD /PUT 77 IN REVERSE CHECKSUM + CLA CMA + DCA CHKSUM +WRLP, TAD I XBUFF /GLORY BE! THE ACTUAL WRITE! + JMS WRQUAD + ISZ XBUFF /BUMP CORE POINTER + JMP STFLD1+1 /NOT AT END OF FIELD (DJG) + RDF + TAD (6211 + DCA STFLD1 +STFLD1, NOP + ISZ WORDS /DONE THIS BLOCK? + JMP WRLP /NOT YET..LOOP A WHILE + TAD XFUNCT /IS THE OPERATION FOR WDSBLK PER BLOCK? + CLL RTR /IF NO, WRITE A 0 WORD + SZL CLA + JMS WRQUAD /WRITE A WORD OF 0 + JMS GETCHK /DO THE CHECK SUM + JMS WRQUAD /WRITE FORWARD CHECKSUM + JMS WRQUAD /ALLOW CHECKSUM TO BE WRITTEN + JMP I CRWCOM +K77, 77 /ABOVE MAY SKIP (NOT ANYMORE DJG) + READ, JMS RDQUAD + JMS RDQUAD + JMS RDQUAD /SKIP CONTROL WORDS + AND K77 + TAD K7700 /TACK 7700 ONTO CHECKSUM. + DCA CHKSUM /CHECKSUM ONLY LOW 6 BITS ANYWAY +RDLP, JMS RDQUAD + JMS EQUFUN /COMPUT CHECKSUM AS WE GO + DCA I XBUFF /IT GETS CONDENSED LATER + ISZ XBUFF /AT END OF FIELD? + JMP STFLD2+1 /NOT AT END OF FIELD (DJG) + RDF + TAD (6211 + DCA STFLD2 +STFLD2, NOP + ISZ WORDS /DONE THIS OP? + JMP RDLP /NO SUCH LUCK + TAD XFUNCT /IF OP WAS FOR WDSBLK-1, READ AND + CLL RTR /CHECKSUM THE LAST TAPE WORD + SNL CLA + JMP RDLP2 + JMS RDQUAD /NOT NEEDED FOR WDSBLK/BLOCK + JMS EQUFUN /CHECKSUM IT +RDLP2, JMS RDQUAD /READ CHECKSUM + AND K7700 + JMS EQUFUN + JMS GETCHK /GET SIX BIT CHECKSUM + JMP I CRWCOM +C300, 300 /PROTECTION (NOT ANYMORE DJG) + +WRQUAD, 0 /WRITE OUT A 12 BIT WORD + JMS EQUFUN /ADD THIS TO CHECKSUM + SDSQ /SKIP ON QUADLINE FLAG + JMP .-1 + SDLD /LOAD DATA ONTO BUS + CLA /SDLD DOESN'T CLEAR AC + JMP I WRQUAD + +RDQUAD, 0 /READ A 12 BIT WORD + SDSQ + JMP .-1 + SDRD /READ DATA + JMP I RDQUAD + + XUNIT, +EQUFUN, 0 /COMPUTE EQUIVALENCE CHECKSUM + CMA + DCA EQUTMP /ACTUALLY CHECKSUMS ON DECTAPE ARE + TAD EQUTMP /EQUIVALENCE OF ALL WORDS IN A RECORD + AND CHKSUM /SIX BITS AT A TIME. BUT SINCE EQUIVALENCE + CIA /IS ASSOCIATIVE, WE CAN DO IT 12 + CLL RAL /BITS AT A TIME AND CONDENSE LATER. + TAD EQUTMP /THIS ROUTINE USES THESE IDENTITIES: + TAD CHKSUM /A+B=(A.XOR.B)+2*(A.AND.B) + DCA CHKSUM /A.EQU.B=.NOT.(A.XOR.B)=A.XOR.(.NOT.B) + TAD EQUTMP /A.EQU.B=(A+(.NOT.B))-2*(A.AND.(.NOT.B)) + CMA + JMP I EQUFUN + +GETCHK, 0 /FORM 6 BIT CHECKSUM + CLA + TAD CHKSUM + CMA + CLL RTL + RTL + RTL + JMS EQUFUN + CLA CLL CML /FORCES LINK ON AT RWCOM + TAD CHKSUM + AND K7700 + JMP I GETCHK + +CFATAL, FATAL +CRWCOM, RWCOM +XFUNCT, 0 +CM32, -32 +C1400, 1400 +CHKSUM, 0 +WORDS, 0 +XWCT, 0 +EQUTMP, 0 + + *20 +RETRY, 7774 / RETRY UP TO 4 TIME +NUMBLK, 1202 / MAX NUMBER OF BLOCKS TO ATTEMPT READING + / (1102(8) blocks of 400(8) 18-bit words + 100 TO HANDLE NONSTANDARD (LONG) TAPES) +MWORDS, -WDSBLK / WORDS PER BLOCK +WCOUNT, 0 +BLKFLD, 12 / 10 386-word-blocks (12-bit words, equivalent to 256 18-bit words + 1 cksum word) + / WRAPPING PAST END OF LAST FIELD DOESN'T WORK +FIELDS, 0 +RDSIZE, 0 / NUMBER BLOCKS PER READ +CBLOCK, 0 / CURRENT BLOCK TO XFER +CLKSUM, 0 +DRVSEL, 0 +READST, 377 +LOC, 0 +LEN, 0 +BCNT, 0 / BLOCKS TO SEND TO PC +TEMP, 0 +C17, 17 +C360, 360 +CHKSM, 0 +ERRCN2, 0 +OLDBUF, 0 / USED BY DTA0 ROUTINE +XBUFF, 0 / USED BY DTA0 ROUTINE +C374, 374 / USED BY DTA0 ROUTINE +BLOCK, 0 / USED BY DTA0 ROUTINE +UNIT, 0 / USED BY DTA0 ROUTINE +TRYCNT, -3 / " +PGCT, 0 / " +CXWCT, XWCT / " +M20, -20 / " + + *140 +FINISH, HLT / Normal good halt + JMP START + + *200 +START, CDF 0 + CAF + CLA CLL OSR / Get drive + AND (1 + RTR + DCA DRVSEL + CLA CLL OSR / Get max field + RTR + RAR + AND (7 + SNA + HLT / Must have at least 1 field for buffer + CIA + DCA FIELDS + DCA ERRCN2 +RDSZLP, TAD BLKFLD / Multiply by number of fields available + ISZ FIELDS + JMP RDSZLP + DCA RDSIZE / NUMBER BLOCK PER READ + DCA CBLOCK + DCA CHKSM + +DUMPLP, CLA + TAD RDSIZE + TAD CBLOCK + CIA + TAD NUMBLK / MORE BLOCKS LEFT THAN READSIZE? + SMA / NO, READ NUMBER LEFT + CLA / YES, ONLY READ RDSIZE + TAD RDSIZE + SNA / ANY MORE BLOCKS? + JMP DONE / NO, DO FINISH STUFF + DCA ARGSZ + TAD CBLOCK + DCA ARGBK + TAD DRVSEL + JMS DTA0 + 0010 / READ STARTING IN FIELD 1 +ARGSZ, 0 + 0 +ARGBK, 0 + JMP ENDRET / TAKEN WHEN END OF TAPE IS HIT + JMP ERRRET / TAKEN WHEN AN ERROR IS ENCOUNTERED + TAD (377 / All blocks good + DCA READST + / Send data, each block starts with FF + CLA CLL / then 2 12 bit words in 3 bytes + DCA LOC / ERRRET DUPLICATES SOME OF THIS + TAD ARGSZ + CIA + DCA BCNT / Setup loop counter with number blocks read + CDF 10 +OUTBL1, JMS OUTBLK / Send a block + ISZ CBLOCK + ISZ BCNT / Send all read? + JMP OUTBL1 / No + CDF 0 + JMP DUMPLP / Go read next batch + + +DONE, CLA / Send FE and -checksum of all words + TAD (376 + JMS PUN + CLA CLL + TAD CHKSM / Send checksum in two bytes, low bits first + CIA + JMS PUN + CLA CLL + TAD CHKSM + CIA + RTR + RTR + RTR + RTR + AND C17 + JMS PUN + CLA + TAD DRVSEL + JMS DTA0 / REWIND TAPE + 0010 + 1 + 0 + 0 + NOP + NOP + TAD ERRCN2 / Leave AC with # of errors + JMP FINISH + + /SEND GOOD BLOCKS READ WITH GOOD BLOCK FLAG + /THEN BAD WITH BAD BLOCK FLAG. +ERRRET, +/ HLT / ****** If we want to stop on error + CDF 10 + CLA CLL + DCA LOC + TAD CBLOCK + CIA + TAD BLOCK /Get - number good blocks read + CIA /Last was bad + SNA + JMP FSTBAD /First block is bad, no good to send + DCA BCNT + TAD (377 + DCA READST +OUTBL2, JMS OUTBLK /Send good blocks + ISZ CBLOCK + ISZ BCNT + JMP OUTBL2 +FSTBAD, TAD (375 /NOW SEND BAD BLOCK + DCA READST + JMS OUTBLK + ISZ CBLOCK + ISZ ERRCN2 + CDF 0 + JMP DUMPLP /And read from here on + + PAGE +ENDRET, /SEND LAST SET OF BLOCKS READ BEFORE END OF TAPE AND FINISH. + CDF 10 + CLA CLL + DCA LOC + TAD CBLOCK + CIA + TAD BLOCK / GET NUMBER OF BLOCKS READ IN LAST BATCH + CMA / +1 to -BCNT SO WE SEND ALL BLOCKS + SNA + JMP DONE / READ ZERO BLOCKS IN LAST BATCH, WE ARE DONE + DCA BCNT + TAD (377 + DCA READST +OUTBL3, JMS OUTBLK / SEND ALL BLOCKS + ISZ CBLOCK + ISZ BCNT + JMP OUTBL3 + CDF 0 + JMP DONE / NO MORE BLOCKS, DONE. + +OUTBLK, 0 /Send a block of data out serial port + CLA + TAD WCOUNT + DCA LEN + TAD READST /Send good/bad flag + JMS PUN +OUT, CLA CLL + TAD I LOC + TAD CHKSM / Keep checksum of all words sent + DCA CHKSM + TAD I LOC / Send 2 words as 3 bytes + JMS PUN + CLA CLL + TAD I LOC + RTR / Shift top 4 bits to low 4 + RTR + RTR + RTR + AND C17 + DCA TEMP + ISZ LOC + JMP STFLD3+1 /NOT AT END OF FIELD (DJG) + RDF /At end, inc to next field + TAD (6211 /BUILD CDF + DCA STFLD3 +STFLD3, NOP + ISZ LEN /END IF BUFFER? + SKP /NO + JMP ENDBK /YES + TAD I LOC + TAD CHKSM + DCA CHKSM + TAD I LOC + RTL + RTL + AND C360 + TAD TEMP + JMS PUN + CLA CLL + TAD I LOC + RTR + RTR + JMS PUN + ISZ LOC + JMP STFLD4+1 /NOT AT END OF FIELD (DJG) + RDF + TAD (6211 /BUILD CDF + DCA STFLD4 +STFLD4, NOP + ISZ LEN + JMP OUT + JMP I OUTBLK +ENDBK, TAD TEMP /SEND LAST PART OF WORD + JMS PUN + JMP I OUTBLK + +PUN, 0 / Send byte out serial port +/ PLS / Punch for testing with emulator + TLS2 / Send out console + CLA CLL + TAD CBLOCK +/ PSF + TSF2 /Wait until character sent + JMP .-1 + CLA + JMP I PUN + + $ diff --git a/DumpDT18/dumpdt18-550.bin b/DumpDT18/dumpdt18-550.bin new file mode 100644 index 0000000..8b397db Binary files /dev/null and b/DumpDT18/dumpdt18-550.bin differ diff --git a/DumpDT18/dumpdt18-550.lst b/DumpDT18/dumpdt18-550.lst new file mode 100644 index 0000000..ff754b2 --- /dev/null +++ b/DumpDT18/dumpdt18-550.lst @@ -0,0 +1,887 @@ + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 1 + + + 1 / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code from D. Gesswein + 2 / (see ftp://ftp.pdp8online.com/software/dumprest). + 3 / Modified for 18-bit PDP-7 550 DECtape imaging by J. Dersch + 4 / + 5 / This program will send a DECtape image out the console port. + 6 / The format of the data sent is 0xff (0377) or 0xfd if read error + 7 / followed by 384 12-bit words (256 18-bit words) of data for each block. + 8 / After the last block a 0xfe (0376) is sent + 9 / with a two byte checksum, low 8 bits first then upper 4. + 10 / The words in a block are sent as three bytes for each 2 words. + 11 / 1 = low 8 bits first word + 12 / 2 = upper 4 bits first and lower 4 bits second + 13 / 3 = upper 8 bits second word + 14 / + 15 / The program (PC) receiving the data should be started before this program. + 16 / + 17 / To run, start at 0200. + 18 / SR 11 should be drive, only 0 and 1 supported without reassembling + 19 / SR 6-8 should be maximum memory field in computer, needs 8k minimum + 20 / + 21 / The receiving program should be running first. + 22 / At normal exit hitting cont will restart the program. + 23 / + 24 / Should halt at label finish (140) with number of recoverable errors in AC + 25 / The current block being read will be displayed in the AC + 26 / while running. + 27 / + 28 / The PC program will print out the bad location if an error occurs. + 29 / + 30 / We will retry each read up to four times on error. + 31 / + 32 / This transfers the standard 256 word by 578 blocks used by 18-bit DEC hardware, + 33 / using PDP-7 550 controller checksums (1's complement 18-bit additive). + 34 / It will read as many blocks are present up to the forward end-zone, so it will + 35 / handle tapes that vary from the standard 1102(8) block length. + 36 / NOTE: As the PDP-7 checksum takes significantly longer to calculate than the later + 37 / XOR-based checksums, there is a chance that timeout errors may occur on certain + 38 / combinations of drives, tapes, and controllers. + 39 / + 40 + 41 0030 INAD=030 / Address of serial input, 30 for console + 42 6030 KCF2=6000 INAD + 43 6031 KSF2=6001 INAD + 44 6032 KCC2=6002 INAD + 45 6034 KRS2=6004 INAD + 46 6035 KIE2=6005 INAD + 47 6036 KRB2=6006 INAD + 48 + 49 0040 OUTAD=040 / Address of serial output, 40 for console + 50 6040 TFL2=6000 OUTAD + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 2 + + + 51 6041 TSF2=6001 OUTAD + 52 6042 TCF2=6002 OUTAD + 53 6044 TPC2=6004 OUTAD + 54 6045 TSK2=6005 OUTAD + 55 6046 TLS2=6006 OUTAD + 56 + 57 /CODE BASED ON: + 58 /2 TD8E INITIALIZER PROGRAM, V7A + 59 / + 60 /COPYRIGHT (C) 1975, 1977 + 61 /DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. + 62 / + 63 / + 64 / + 65 /THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A + 66 /SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLU- + 67 /SION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ANT OTHER + 68 /COPIES THEREOF, MAY NOT BR PROVIDED OR OTHERWISE MADE AVAILABLE + 69 /TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO + 70 /AGREES TO THESE LICENSE TERMS. TITLE TO AND OWNERSHIP OF THE + 71 /SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC. + 72 / + 73 / + 74 /THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT + 75 /NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL + 76 /EQUIPMRNT COROPATION. + 77 / + 78 /DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS + 79 /SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. + 80 / + 81 / + 82 / + 83 / + 84 / + 85 / + 86 + 87 /DECEMBER 21, 1973 GB/RL/EF/SR + 88 + 89 /ABSTRACT-- + 90 / THE ROUTINE DESCRIBED AND LISTED HERE IS A GENERAL + 91 /DATA HANDLER FOR THE TD8E DECTAPE SYSTEM. THE ROUTINE + 92 /CONTAINS SEARCH, READ, AND WRITE FUNCTIONS IN A FORMAT + 93 /WHICH IS COMPATIBLE WITH OS/8 DEVICE HANDLER CALLING + 94 /SEQUENCES. + 95 + 96 /FIXES SINCE FIELD-TEST RELEASE: + 97 + 98 /1. FIXED BUG RE CLA ON RETRY AFTER ERROR + 99 /2. ALLOWED FINAL BOOTSTRAP TO BE INTO A WRITE-LOCKED DEVICE + 100 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 3 + + + 101 /OS/8 V3D CHANGES: + 102 + 103 /3. FIXED BUG RE TD8E BUILD (V6B PATCH) + 104 + 105 /THIS ROUTINE CAN BE RE-EDITED AND ASSEMBLED TO PRODUCE + 106 /VARIATIONS ON THE BASIC TD8E SYSTEM. ASSEMBLY PARAMETERS + 107 /CONTROL: + 108 /A) WHAT DRIVES (UNITS 0-7) WILL BE USED + 109 /B) THE ORIGIN OF THE TWO PAGE ROUTINE + 110 /C) WHAT MEMORY FIELD THE ROUTINE WILL RUN IN + 111 /D) THE SIZE OF THE DECTAPE BLOCK TO BE READ/WRITTEN + 112 + 113 / FOLLOWING ARE THE PARAMETERS SET UP FOR THE DEC 550 DECTAPE CONTROLLER: + 114 + 115 0010 DRIVE=10 /UNITS 0 AND 1 SELECTED + 116 0600 ORIGIN=600 /ENTER AT ORIGIN, ORIGIN+4 + 117 0000 AFIELD=0 /INITIAL FIELD SETTING + 118 0000 MFIELD=00 /AFIELD*10=MFIELD + 119 0600 WDSBLK=600 /384 12-BIT WORDS PER BLOCK (256 18-BIT DATA WORDS) + 120 + 121 /THE USE OF THE PARAMETERS IS AS FOLLOWS: + 122 + 123 / DRIVE: DRIVE DETERMINES WHICH UNITS WILL BE SELECTED + 124 / DRIVE=10 IMPLIES UNITS 0 &1 + 125 / DRIVE=20 IMPLIES UNITS 2&3 + 126 / DRIVE=30 IMPLIES UNITS 4&5 + 127 / DRIVE=40 IMPLIES UNITS 6&7 + 128 + 129 /ORIGIN: ALTERING ORIGIN CAUSES ASSEMBLY IN A DIFFERENT + 130 / MEMORY LOCATION. WHEN CHANGING ORIGIN KEEP IN MIND + 131 /THAT THIS IS A TWO PAGE ROUTINE. + 132 + 133 /AFIELD: AFIELD DETERMINES THE INITIAL FIELD SETTING FOR THE + 134 / LOADER. PERMISSIBLE VALUES FOR AFIELD ARE 0 TO 7. + 135 + 136 /MFIELD: MFIELD IS USED IN A CIF CDF MFIELD INSTRUCTION. + 137 / THE VALUE INSERTED FOR MFIELD SHOULD BE 10(8) TIMES + 138 / THE VALUE FOR AFIELD. THE PERMISSIBLE VALUES ARE 00-70. + 139 + 140 /WDSBLK: WDSBLK GOVERNS HOW MANY WORDS THE ROUTINE THINKS ARE + 141 / IN A DECTAPE BLOCK. THE STANDARD VALUE IS 201(8) OR + 142 / 128 DECIMAL. THE VALUE USED + 143 / FOR WDSBLK SHOULD BE THE NUMBER OF WORDS THE TAPE WAS + 144 / FORMATTED TO CONTAIN. + 145 + 146 /IF WE WANT A HANDLER FOR UNITS 2&3 TO RESIDE IN + 147 /FIELD 2 AT LOCATION 3000 AND READ/WRITE 256(10) WORDS + 148 /PER BLOCK, THE PARAMETERS WOULD BE: + 149 / DRIVE=20 + 150 / ORIGIN=3000 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 4 + + + 151 / AFIELD=2 + 152 / MFIELD=20 + 153 / WDSBLK=400 + 154 /THE CALL TO THE SUBROUTINE FOLLOWS BASICALLY THE + 155 /CALLING SEQUENCE FOR OS/8 DEVICE HANDLERS. + 156 /THE CALLING SEQUENCE IS: + 157 + 158 / CDF CURRENT + 159 / CIF MFIELD /MFIELD=FIELD ASSEMBLED IN + 160 / JMS ENTRY /ENTRY=ORIGIN (EVEN NUMBERED DRIVE + 161 /AND ORIGIN+4 FOR ODD NUMBERED DRIVE. + 162 / ARG1 + 163 / ARG1B (DJG) + 164 / ARG2 + 165 / ARG3 + 166 / ERROR RETURN + 167 / NORMAL RETURN + 168 + 169 /THE ARGUMENTS ARE: + 170 + 171 /ARG1: FUNCTION WORD BIT0: 0=READ, 1=WRITE + 172 / BITS 1-5: UNUSED, WAS # BLOCKS IN OPERATION (DJG) + 173 / BITS 6-8: FIELD OF BUFFER AREA + 174 / BIT 9: UNUSED + 175 / BIT 10: UNUSED + 176 / BIT 11: 1=START FORWARD, 0=REVERSE + 177 /ARG1A: # OF BLOCKS IN OPERATIONA (DJG) + 178 /ARG2: BUFFER ADDRESS FOR OPERATION + 179 /ARG3: STARTING BLOCK FOR OPERATION + 180 + 181 /ERRORS: THE HANDLER DETECTS TWO TYPES OF ERRORS: + 182 /A) FATAL ERRORS- PARITY ERROR, TIMING ERROR, + 183 / TOO GREAT A BLOCK NUMBER + 184 / FATAL ERRORS TAKE ERROR RETURN WITH THE + 185 / AC=4000. + 186 /B) NON-FATAL- SELECT ERROR. + 187 / IF NO PROPER UNIT IS SELECTED, THE ERROR + 188 / RETURN IS TAKEN WITH CLEAR AC. + 189 /FATAL ERRORS TRY THREE TIMES BEFORE TAKING ERROR RETURN. + 190 /THE NORMAL RETURN IS TAKEN AFTER ALL INDICATED + 191 /BLOCKS HAVE BEEN TRANSFERRED. THE AC IS CLEAR. + 192 + 193 /THE TD8E IOT'S ARE: + 194 6771 SDSS=7001-DRIVE /SKIP ON SINGLE LINE FLAG + 195 6772 SDST=7002-DRIVE /SKIP ON TIMING ERROR + 196 6773 SDSQ=7003-DRIVE /SKIP ON QUAD LINE FLAG + 197 6774 SDLC=7004-DRIVE /LOAD COMMAND REGISTER + 198 6775 SDLD=7005-DRIVE /LOAD DATA REGISTER + 199 6776 SDRC=7006-DRIVE /READ COMMAND REGISTER + 200 6777 SDRD=7007-DRIVE /READ DATA REGISTER + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 5 + + + 201 + 202 /THE IOT'S IN GENERAL ARE 677X,676X,675X,AND 674X. + 203 /THE OTHERS CONTROL UNITS 2-7. + 204 + 205 / THIS HANDLER USES DECTAPE BLOCKS NOT OS/8 BLOCKS ! + 206 + 207 0600 *ORIGIN + 208 + 209 / MODIFIED SO BIT 0 ON ENTRY IS UNIT 1 + 210 00600 0000 DTA0, 0 + 211 00601 3046 DCA UNIT /SAVE UNIT POSITION + 212 00602 6214 RDF + 213 00603 1360 TAD C6203 /GET DATA FIELD AND SETUP RETURN + 214 00604 3356 DCA LEAVE + 215 00605 1600 TAD I DTA0 /GET FUNCTION WORD + 216 00606 6775 SDLD /PUT FUNCTION INTO DATA REGISTER + 217 00607 7200 CLA + 218 00610 1022 TAD MWORDS + 219 00611 3023 DCA WCOUNT /STORE MASTER WORD COUNT + 220 00612 2200 ISZ DTA0 /TO BLOCK COUNT (DJG) + 221 00613 1600 TAD I DTA0 / (DJG) + 222 00614 7041 CIA / (DJG) + 223 00615 3050 DCA PGCT / (DJG) + 224 00616 2200 ISZ DTA0 /TO BUFFER + 225 00617 1600 TAD I DTA0 + 226 00620 3043 DCA XBUFF /SAVE ADDRESS (DJG) + 227 00621 2200 ISZ DTA0 /TO BLOCK NUMBER + 228 00622 1600 TAD I DTA0 + 229 00623 3045 DCA BLOCK + 230 00624 2200 ISZ DTA0 /POINT TO ERROR EXIT + 231 00625 6203 CIF CDF MFIELD /TO ROUTINES DATA FIELD + 232 00626 6777 SDRD + 233 00627 0376 AND C70 /GET FIELD FOR XFER + 234 00630 1361 TAD C6201 /FORM CDF N + 235 00631 3251 DCA XFIELD /IF=0 AND DF=N AT XFER. + 236 00632 1046 TAD UNIT /TEST FOR SELECT ERROR + 237 00633 6774 SDLC + 238 00634 7200 CLA / Moved here because my drive 1 is slow selecting + 239 00635 1020 TAD RETRY + 240 00636 3047 DCA TRYCNT /3 ERROR TRIES + 241 00637 6776 SDRC + 242 00640 0364 AND C100 + 243 00641 7640 SZA CLA + 244 00642 5351 JMP FATAL-1 + 245 00643 6777 SDRD /PUT FUNCT INTO XFUNCT IN SECOND PG. + 246 00644 3763 DCA I CXFUN + 247 00645 1023 TAD WCOUNT + 248 00646 3451 DCA I CXWCT + 249 00647 6777 SDRD /GET MOTION BIT TO LINK + 250 00650 7110 CLL RAR + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 6 + + + 251 00651 7402 XFIELD, HLT /INTO NEXT PAGE + 252 00652 5263 JMP GO /AND START THE MOTION. + 253 00653 6772 RWCOM, SDST /ANY TD8E TIME ERRORS? + 254 /JMP TIMEOK /UNCOMMENT IF YOU SUSPECT TIMING ISSUES. + 255 /HLT + 256 00654 7640 TIMEOK, SZA CLA /OR CHECKSUM ERRORS? + 257 00655 5341 JMP TRY3 /PLEASE NOTE THAT THE LINK IS ALWAYS + 258 /SET AT RWCOM. GETCHK SETS IT. + 259 00656 2050 ISZ PGCT / (DJG) + 260 00657 7410 SKP / (DJG) + 261 00660 5350 JMP EXIT /ALL DONE. GET OUT + 262 00661 2045 ISZ BLOCK /NEXT BLOCK TO XFER + 263 00662 7120 CLL CML /FORCES MOTION FORWARD + 264 00663 7232 GO, CLA CML RTR /LINK BECOMES MOTION BIT + 265 00664 1365 TAD C1000 + 266 00665 1046 TAD UNIT /PUT IN 'GO' AND UNIT # + 267 00666 6774 SDLC /LOOK FOR BLOCK NO. + 268 00667 7200 CLA + 269 00670 1043 TAD XBUFF + 270 00671 3042 DCA OLDBUF + 271 00672 6214 RDF + 272 00673 1361 TAD C6201 + 273 00674 3342 DCA OLDFLD + 274 00675 4762 JMS I CRDQUD /WAIT AT LEAST 6 LINES TO LOOK + 275 00676 4762 JMS I CRDQUD + 276 00677 7600 CM200, 7600 /COULD HAVE SAVED A LOC. HERE + 277 00700 6771 SRCH, SDSS + 278 00701 5300 JMP .-1 /WAIT FOR SINGLE LINE FLAG + 279 00702 6776 SDRC + 280 00703 7106 CLL RTL /DIRECTION TO LINK. INFO BITS + 281 /ARE SHIFTED. + 282 00704 0044 AND C374 /ISOLATE MARK TRACK BITS + 283 00705 1323 TAD M110 /IS IT END ZONE? + 284 00706 7450 SNA /THE LINK STAYS SAME THRU THIS + 285 00707 5331 JMP ENDZ + 286 00710 1052 TAD M20 /CHECK FOR BLOCK MARK + 287 00711 7640 SZA CLA + 288 00712 5300 JMP SRCH + 289 00713 6777 SDRD /GET THE BLOCK NUMBER + 290 00714 7430 SZL /IF WE ARE IN REVERSE, LOOK FOR 3 + 291 /BLOCKS BEFORE TARGET BLOCK. THIS + 292 /ALLOWS TURNAROUND AND UP TO SPEED. + 293 00715 1377 TAD C3 /REVERSE + 294 00716 7040 CMA + 295 00717 1045 TAD BLOCK + 296 00720 7040 CMA /IS IT RIGHT BLOCK? + 297 00721 7450 SNA + 298 00722 5372 JMP FOUND /YES..HOORAY! + 299 00723 7670 M110, SZL SNA CLA /NO, BUT ARE WE HEADED FOR IT? + 300 /ABOVE SNA IS SUPERFLUOUS. + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 7 + + + 301 00724 5300 JMP SRCH /YES + 302 00725 6776 SDRC /NO, TURN US AROUND. + 303 00726 7106 CLL RTL /DIRECTION TO LINK + 304 00727 7200 CLA /THIS CODE USED TO BE SHARED WITH ENDZ, + 305 00730 5263 JMP GO /BUT NOW ENDZ HANDLES END OF TAPE CASES ONLY. + 306 00731 6776 ENDZ, SDRC /WE ARE IN THE END ZONE + 307 00732 7106 CLL RTL /DIRECTION TO LINK + 308 00733 7630 SZL CLA /ARE WE IN REVERSE? + 309 00734 5263 JMP GO /YES..TURN US AROUND + 310 00735 1045 TAD BLOCK /IF WE ARE ON BLOCK ZERO, IT IS POSSIBLE FOR US TO BE AT THE + 311 /REVERSE ENDZONE GOING FORWARD, EITHER DUE TO A RETRY OR BECAUSE + 312 /THE TAPE WAS STARTED IN A POSITION BEFORE THE END ZONE. + 313 /THESE CASES SHOULD NOT BE TREATED AS END-OF-TAPE. + 314 00736 7640 SZA CLA + 315 00737 5353 JMP ENDEX /END OF TAPE. STOP THE UNIT AND TAKE THE END EXIT. + 316 00740 5263 JMP GO + 317 + 318 00741 7200 TRY3, CLA + 319 00742 7000 OLDFLD, NOP + 320 00743 1042 TAD OLDBUF + 321 00744 3043 DCA XBUFF + 322 00745 2047 ISZ TRYCNT + 323 00746 5263 JMP GO /TRY 3 TIMES + 324 00747 5352 JMP FATAL /LINK OFF MEANS AC=4000 ON RETURN + 325 00750 2200 EXIT, ISZ DTA0 /TAKE THE NORMAL RETURN + 326 00751 7120 CLL CML /AC=0 ON NORMAL RETURN + 327 00752 2200 FATAL, ISZ DTA0 /TAKE THE ERROR RETURN + 328 00753 1046 ENDEX, TAD UNIT + 329 00754 6774 SDLC /STOP THE UNIT + 330 00755 7230 CLA CML RAR + 331 00756 7402 LEAVE, HLT + 332 00757 5600 JMP I DTA0 + 333 + 334 + 335 00760 6203 C6203, 6203 + 336 00761 6201 C6201, 6201 + 337 00762 1050 CRDQUD, RDQUAD + 338 00763 1105 CXFUN, XFUNCT + 339 00764 0100 C100, 100 + 340 00765 1000 C1000, 1000 + 341 + 342 / NOTE THAT THE ABOVE CODE SEGMENT COMES VERY CLOSE TO TOUCHING + 343 / THIS ONE, AND THE BELOW MUST RESIDE AT THE END OF THIS PAGE. + 344 / BE CAREFUL ADDING NEW CODE TO THE ABOVE CODE. + 345 0772 *ORIGIN+172 + 346 00772 7630 FOUND, SZL CLA /RIGHT BLOCK. HOW ABOUT DIRECTION? + 347 00773 5263 JMP GO /WRONG..TURN AROUND + 348 00774 1046 TAD UNIT /PUT UNIT INTO LINK + 349 00775 7104 CLL RAL /AC IS NOW 0 + 350 00776 0070 C70, 70 /********DON'T MOVE THIS!!!!****** + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 8 + + + 351 00777 0003 C3, 3 + 352 /INTO NEXT PAGE + 353 1000 *ORIGIN+200 + 354 01000 6202 CIF MFIELD + 355 01001 7010 RAR /NOW GET UNIT # + 356 01002 3255 DCA XUNIT + 357 01003 6776 SDRC + 358 01004 6774 SDLC + 359 01005 6771 REVGRD, SDSS + 360 01006 5205 JMP .-1 /LOOK FOR REVERSE GUARD + 361 01007 6776 SDRC + 362 01010 0222 AND K77 + 363 01011 1306 TAD CM32 /IS IT REVERSE GUARD? + 364 01012 7640 SZA CLA + 365 01013 5205 JMP REVGRD /NO.KEEP LOOKING + 366 01014 1311 TAD XWCT + 367 01015 3310 DCA WORDS /WORD COUNTER + 368 01016 1305 TAD XFUNCT /GET FUNCTION READ OR WRITE + 369 01017 7700 K7700, SMA CLA + 370 01020 5223 JMP READ /NEG. IS WRITE + 371 01021 7402 WRITE, HLT /WRITE CODE REMOVED. + 372 01022 0077 K77, 77 /ABOVE MAY SKIP (NOT ANYMORE DJG) + 373 01023 4250 READ, JMS RDQUAD + 374 01024 4250 JMS RDQUAD + 375 01025 4250 JMS RDQUAD /SKIP CONTROL WORDS + 376 01026 4250 RDLP, JMS RDQUAD + 377 01027 4777@ JMS P7CHK /COMPUTE PDP-7 550 CHECKSUM AS WE GO + 378 01030 3443 DCA I XBUFF + 379 01031 2043 ISZ XBUFF /AT END OF FIELD? + 380 01032 5237 JMP STFLD2+1 /NOT AT END OF FIELD (DJG) + 381 01033 6214 RDF + 382 01034 1376 TAD (6211 + 383 01035 3236 DCA STFLD2 + 384 01036 7000 STFLD2, NOP + 385 01037 2310 ISZ WORDS /DONE THIS OP? + 386 01040 5226 JMP RDLP /NO SUCH LUCK + 387 01041 4250 JMS RDQUAD /DONE: READ AND CHECKSUM LAST 18-BIT WORD (1.5 12-BIT WORDS) + 388 01042 4777@ JMS P7CHK /CHECKSUM IT + 389 01043 4250 JMS RDQUAD /READ LAST PART OF CKSUM WORD + 390 01044 4777@ JMS P7CHK /CHECKSUM IT + 391 01045 4256 JMS VFYCHK /VERIFY CHECKSUM + 392 01046 5704 JMP I CRWCOM + 393 01047 0300 C300, 300 /PROTECTION (NOT ANYMORE DJG) + 394 + 395 01050 0000 RDQUAD, 0 /READ A 12 BIT WORD + 396 01051 6773 SDSQ + 397 01052 5251 JMP .-1 + 398 01053 6777 SDRD /READ DATA + 399 01054 5650 JMP I RDQUAD + 400 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 9 + + + 401 01055 0000 XUNIT, 0 + 402 / VERIFIES 18-BIT 1'S COMPLEMENT CKSUM. + 403 / SHOULD BE 0 OR -0. + 404 / AC SHOULD BE 0 ON EXIT IF CKSUM IS OK, NONZERO + 405 / OTHERWISE. + 406 / CODE EXPECTS LINK TO BE SET ON EXIT REGARDLESS. + 407 / THIS ROUTINE ALSO RESETS VARIOUS CHECKSUM ROUTINE + 408 / STATE BACK TO INITIAL CONDITIONS IN PREPARATION + 409 / FOR THE NEXT BLOCK. + 410 01056 0000 VFYCHK, 0 + 411 01057 7300 CLA CLL + 412 01060 1056 TAD CK18L /CHECK FOR ZERO + 413 01061 7640 SZA CLA + 414 01062 5265 JMP VFYNEG /NOPE, TRY NEGATIVE ZERO + 415 01063 1057 TAD CK18H + 416 01064 5273 JMP VDONE /VALIDITY IS DEPENDENT ON THE VALUE OF CK18H + 417 01065 7201 VFYNEG, CLA IAC /CHECK FOR NEGATIVE ZERO (777777) + 418 01066 1056 TAD CK18L /LOW 12 BITS SHOULD BE ZERO AFTER INCREMENT + 419 01067 7440 SZA + 420 01070 5273 JMP VDONE /INVALID CKSUM + 421 01071 1057 TAD CK18H + 422 01072 1375 TAD (0100 /HIGH 6 BITS SHOULD BE ZERO AFTER INCREMENT + 423 01073 3060 VDONE, DCA EQUTMP /SAVE RESULT + 424 01074 3056 DCA CK18L /CLEAR 18-BIT CKSUM FOR NEXT GO-ROUND + 425 01075 3057 DCA CK18H + 426 01076 1312 TAD P7TBLL + 427 01077 3010 DCA P7WD /RESET CHECKSUM WORD ROUTINE POINTER + 428 01100 7120 CLL CML /FORCES LINK ON AT RWCOM + 429 01101 1060 TAD EQUTMP /RELOAD RESULT + 430 01102 5656 JMP I VFYCHK + 431 + 432 01103 0752 CFATAL, FATAL + 433 01104 0653 CRWCOM, RWCOM + 434 01105 0000 XFUNCT, 0 + 435 01106 7746 CM32, -32 + 436 01107 1400 C1400, 1400 + 437 01110 0000 WORDS, 0 + 438 01111 0000 XWCT, 0 + 439 01112 1255 P7TBLL, P7TBL + 440 + 01175 0100 + 01176 6211 + 01177 1200 + 441 PAGE + 442 /PDP-7 550 CHECKSUM ROUTINE: + 443 /COMPUTE 18-BIT 1'S COMPLEMENT CHECKSUM + 444 /AC CONTAINS LAST 12-BIT WORD READ FROM TAPE, STOW THESE BITS + 445 /IN THE RIGHT PLACE IN THE 18-BIT WORD AND ADD TO RUNNING SUM + 446 /AC MUST BE RESTORED BEFORE RETURNING + 447 /THIS CURRENTLY EXECUTES IN ABOUT 65US WORST-CASE. + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 10 + + + 448 01200 0000 P7CHK, 0 + 449 01201 3060 DCA EQUTMP /SAVE ORIGINAL AC + 450 + 451 01202 1060 TAD EQUTMP + 452 01203 5410 JMP I P7WD /DISPATCH TO WORD ROUTINE, AUTOINCREMENT P7WD + 453 + 454 P7WD0, /TAPE WORD 0: 18-BIT WORD 0, HIGH 12 BITS. + 455 01204 0377 AND (7700 /STORE HIGH 6 BITS IN 18 BIT HIGH + 456 01205 3054 DCA WD18H + 457 01206 1060 TAD EQUTMP + 458 01207 7002 BSW + 459 01210 0377 AND (7700 /STORE LOW 6 BITS IN UPPER 6 BITS OF 18 BIT LOW WORD + 460 01211 3053 DCA WD18L + 461 01212 5253 JMP P7DONE /DONE, NO 18-BIT WORD READY YET + 462 + 463 P7WD1, /TAPE WORD 1: 18-BIT WORD 0, LOW 6-BITS; 18-BIT WORD 1, HIGH 6-BITS + 464 01213 0377 AND (7700 /TAKE HIGH 6 BITS + 465 01214 7002 BSW + 466 01215 1053 TAD WD18L /FINISH 18-BIT WORD 0 (LOW 6-BITS) + 467 01216 3053 DCA WD18L + 468 01217 1060 TAD EQUTMP /SAVE BITS FOR NEXT WORD (HIGH 6 BITS OF 18-BIT WORD 1) + 469 01220 3055 DCA WD18T + 470 01221 5231 JMP P7CK /DO CHECKSUM, 18-BIT WORD 0 DONE. + 471 + 472 P7WD2, /TAPE WORD 2: 18-BIT WORD 1, LOW 12-BITS + 473 01222 3053 DCA WD18L /THAT WAS EASY. + 474 01223 1055 TAD WD18T /COPY HIGH 6 BITS FROM LAST TAPE WORD + 475 01224 0376 AND (0077 + 476 01225 7002 BSW + 477 01226 3054 DCA WD18H + 478 01227 1255 TAD P7TBL + 479 01230 3010 DCA P7WD / RESET WORD ROUTINE POINTER AND CONTINUE, 18-BIT WORD 1 DONE. + 480 + 481 /DO AN 18-BIT 1'S COMPLEMENT ADDITION TO THE RUNNING CHECKSUM + 482 01231 7300 P7CK, CLL CLA /CLEAR LINK, NEEDED FOR CARRY DETECTION + 483 01232 1053 TAD WD18L /ADD TO LOW 12 BITS + 484 01233 1056 TAD CK18L + 485 01234 3056 DCA CK18L + 486 01235 7420 SNL /CARRY FROM LOW 12 BITS? + 487 01236 5241 JMP P7HI /NO, CONTINUE + 488 01237 7300 CLL CLA /YES, INCREMENT HIGH 6 BITS + 489 01240 1375 TAD (0100 + 490 01241 1057 P7HI, TAD CK18H /ADD CKSUM TO HIGH 6 BITS + 491 01242 1054 TAD WD18H /(NOTE THAT THE ABOVE TWO ADDS CAN RESULT IN AT MOST ONE CARRY OUT) + 492 01243 3057 DCA CK18H + 493 01244 7420 SNL /CARRY? + 494 01245 5253 JMP P7DONE /NO, DONE HERE. + 495 01246 2056 ISZ CK18L /END-AROUND CARRY TO LOW WORD + 496 01247 5253 JMP P7DONE /RESULT NON-ZERO, DONE + 497 01250 1057 TAD CK18H /RESULT ZERO: CARRY FROM LOW 12-BIT WORD TO HIGH SIX BITS + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 11 + + + 498 01251 1375 TAD (0100 /THIS CAN'T OVERFLOW SINCE WE JUST DID A CARRY OUT FROM IT + 499 01252 3057 DCA CK18H + 500 01253 1060 P7DONE, TAD EQUTMP /RESTORE AC + 501 01254 5600 JMP I P7CHK /DONE + 502 + 503 01255 1255 P7TBL, P7TBL / JUMP TABLE FOR 18-BIT CHECKSUM ROUTINE + 504 01256 5204 JMP P7WD0 + 505 01257 5213 JMP P7WD1 + 506 01260 5222 JMP P7WD2 + 507 + 01375 0100 + 01376 0077 + 01377 7700 + 508 0010 *10 + 509 00010 1255 P7WD, P7TBL + 510 + 511 + 512 0020 *20 + 513 00020 7774 RETRY, 7774 / RETRY UP TO 4 TIME + 514 00021 3777 NUMBLK, 3777 / MAX NUMBER OF BLOCKS TO ATTEMPT READING. BY DEFAULT THIS PROGRAM WILL READ UNTIL + 515 / IT HITS THE END OF THE TAPE (FORWARD ENDZONE). IF YOU NEED TO LIMIT THE NUMBER OF BLOCKS + 516 / READ, MODIFY THIS VALUE. + 517 + 518 00022 7200 MWORDS, -WDSBLK / WORDS PER BLOCK + 519 00023 0000 WCOUNT, 0 + 520 00024 0012 BLKFLD, 12 / 10 386 WORD BLOCKS OF 12-BIT WORDS, EQUIVALENT TO 256 18-BIT WORDS. + 521 / WRAPPING PAST END OF LAST FIELD DOESN'T WORK + 522 00025 0000 FIELDS, 0 + 523 00026 0000 RDSIZE, 0 / NUMBER BLOCKS PER READ + 524 00027 0000 CBLOCK, 0 / CURRENT BLOCK TO XFER + 525 00030 0000 DRVSEL, 0 + 526 00031 0377 READST, 377 + 527 00032 0000 LOC, 0 + 528 00033 0000 LEN, 0 + 529 00034 0000 BCNT, 0 / BLOCKS TO SEND TO PC + 530 00035 0000 TEMP, 0 + 531 00036 0017 C17, 17 + 532 00037 0360 C360, 360 + 533 00040 0000 CHKSM, 0 + 534 00041 0000 ERRCN2, 0 + 535 00042 0000 OLDBUF, 0 / BELOW ARE USED BY DTA0 ROUTINE + 536 00043 0000 XBUFF, 0 + 537 00044 0374 C374, 374 + 538 00045 0000 BLOCK, 0 + 539 00046 0000 UNIT, 0 + 540 00047 7775 TRYCNT, -3 + 541 00050 0000 PGCT, 0 + 542 00051 1111 CXWCT, XWCT + 543 00052 7760 M20, -20 + 544 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 12 + + + 545 + 546 00053 0000 WD18L, 0 / Low 12 bits of current 18-bit word + 547 00054 0000 WD18H, 0 / High 6 bits of current 18-bit word - + 548 / upper 6 bits are used to make carry-out testing faster, low bits must be zero. + 549 / (routine actually testing cksum at end of block will need to take this into account.) + 550 00055 0000 WD18T, 0 / Temporary storage while building 18-bit words + 551 00056 0000 CK18L, 0 / Low 12 bits of running 18-bit PDP-7 checksum + 552 00057 0000 CK18H, 0 / High 6 bits -- see WD18H for special info. + 553 00060 0000 EQUTMP, 0 + 554 + 555 0140 *140 + 556 00140 7402 FINISH, HLT / Normal good halt + 557 00141 5777@ JMP START + 558 + 559 0200 *200 + 560 00200 6201 START, CDF 0 + 561 00201 6007 CAF + 562 00202 7704 CLA CLL OSR / Get drive + 563 00203 0377 AND (1 + 564 00204 7012 RTR + 565 00205 3030 DCA DRVSEL + 566 00206 7704 CLA CLL OSR / Get max field + 567 00207 7012 RTR + 568 00210 7010 RAR + 569 00211 0376 AND (7 + 570 00212 7450 SNA + 571 00213 7402 HLT / Must have at least 1 field for buffer + 572 00214 7041 CIA + 573 00215 3025 DCA FIELDS + 574 00216 3041 DCA ERRCN2 + 575 00217 1024 RDSZLP, TAD BLKFLD / Multiply by number of fields available + 576 00220 2025 ISZ FIELDS + 577 00221 5217 JMP RDSZLP + 578 00222 3026 DCA RDSIZE / NUMBER BLOCK PER READ + 579 00223 3027 DCA CBLOCK + 580 00224 3040 DCA CHKSM + 581 00225 3056 DCA CK18L /RESET 18B CHECKSUM DATA + 582 00226 3057 DCA CK18H + 583 00227 1775@ TAD P7TBL + 584 00230 3010 DCA P7WD + 585 + 586 00231 7200 DUMPLP, CLA + 587 00232 1026 TAD RDSIZE + 588 00233 1027 TAD CBLOCK + 589 00234 7041 CIA + 590 00235 1021 TAD NUMBLK / MORE BLOCKS LEFT THAN READSIZE? + 591 00236 7500 SMA / NO, READ NUMBER LEFT + 592 00237 7200 CLA / YES, ONLY READ RDSIZE + 593 00240 1026 TAD RDSIZE + 594 00241 7450 SNA / ANY MORE BLOCKS? + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 13 + + + 595 00242 5274 JMP DONE / NO, DO FINISH STUFF + 596 00243 3251 DCA ARGSZ + 597 00244 1027 TAD CBLOCK + 598 00245 3253 DCA ARGBK + 599 00246 1030 TAD DRVSEL + 600 00247 4774@ JMS DTA0 + 601 00250 0010 0010 / READ STARTING IN FIELD 1 + 602 00251 0000 ARGSZ, 0 + 603 00252 0000 0 + 604 00253 0000 ARGBK, 0 + 605 00254 5773@ JMP ENDRET / TAKEN WHEN END OF TAPE IS HIT + 606 00255 5327 JMP ERRRET / TAKEN WHEN AN ERROR IS ENCOUNTERED + 607 00256 1372 TAD (377 / All blocks good + 608 00257 3031 DCA READST + 609 / Send data, each block starts with FF + 610 00260 7300 CLA CLL / then 2 12 bit words in 3 bytes + 611 00261 3032 DCA LOC / ERRRET DUPLICATES SOME OF THIS + 612 00262 1251 TAD ARGSZ + 613 00263 7041 CIA + 614 00264 3034 DCA BCNT / Setup loop counter with number blocks read + 615 00265 6211 CDF 10 + 616 00266 4771@ OUTBL1, JMS OUTBLK / Send a block + 617 00267 2027 ISZ CBLOCK + 618 00270 2034 ISZ BCNT / Send all read? + 619 00271 5266 JMP OUTBL1 / No + 620 00272 6201 CDF 0 + 621 00273 5231 JMP DUMPLP / Go read next batch + 622 + 623 + 624 00274 7200 DONE, CLA / Send FE and -checksum of all words + 625 00275 1370 TAD (376 + 626 00276 4767@ JMS PUN + 627 00277 7300 CLA CLL + 628 00300 1040 TAD CHKSM / Send checksum in two bytes, low bits first + 629 00301 7041 CIA + 630 00302 4767@ JMS PUN + 631 00303 7300 CLA CLL + 632 00304 1040 TAD CHKSM + 633 00305 7041 CIA + 634 00306 7012 RTR + 635 00307 7012 RTR + 636 00310 7012 RTR + 637 00311 7012 RTR + 638 00312 0036 AND C17 + 639 00313 4767@ JMS PUN + 640 00314 7200 CLA + 641 00315 1030 TAD DRVSEL + 642 00316 4774@ JMS DTA0 / REWIND TAPE + 643 00317 0010 0010 + 644 00320 0001 1 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 14 + + + 645 00321 0000 0 + 646 00322 0000 0 + 647 00323 7000 NOP + 648 00324 7000 NOP + 649 00325 1041 TAD ERRCN2 / Leave AC with # of errors + 650 00326 5140 JMP FINISH + 651 + 652 /SEND GOOD BLOCKS READ WITH GOOD BLOCK FLAG + 653 /THEN BAD WITH BAD BLOCK FLAG. + 654 ERRRET, + 655 / HLT / ****** If we want to stop on error + 656 00327 6211 CDF 10 + 657 00330 7300 CLA CLL + 658 00331 3032 DCA LOC + 659 00332 1027 TAD CBLOCK + 660 00333 7041 CIA + 661 00334 1045 TAD BLOCK /Get - number good blocks read + 662 00335 7041 CIA /Last was bad + 663 00336 7450 SNA + 664 00337 5347 JMP FSTBAD /First block is bad, no good to send + 665 00340 3034 DCA BCNT + 666 00341 1372 TAD (377 + 667 00342 3031 DCA READST + 668 00343 4771@ OUTBL2, JMS OUTBLK /Send good blocks + 669 00344 2027 ISZ CBLOCK + 670 00345 2034 ISZ BCNT + 671 00346 5343 JMP OUTBL2 + 672 00347 1366 FSTBAD, TAD (375 /NOW SEND BAD BLOCK + 673 00350 3031 DCA READST + 674 00351 4771@ JMS OUTBLK + 675 00352 2027 ISZ CBLOCK + 676 00353 2041 ISZ ERRCN2 + 677 00354 6201 CDF 0 + 678 00355 5231 JMP DUMPLP /And read from here on + 679 + 00366 0375 + 00367 0511 + 00370 0376 + 00371 0422 + 00372 0377 + 00373 0400 + 00374 0600 + 00375 1255 + 00376 0007 + 00377 0001 + 680 PAGE + 681 ENDRET, /SEND LAST SET OF BLOCKS READ BEFORE END OF TAPE AND FINISH. + 682 00400 6211 CDF 10 + 683 00401 7300 CLA CLL + 684 00402 3032 DCA LOC + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 15 + + + 685 00403 1027 TAD CBLOCK + 686 00404 7041 CIA + 687 00405 1045 TAD BLOCK / GET NUMBER OF BLOCKS READ IN LAST BATCH + 688 00406 7040 CMA / +1 to -BCNT SO WE SEND ALL BLOCKS + 689 00407 7450 SNA + 690 00410 5777@ JMP DONE / READ ZERO BLOCKS IN LAST BATCH, WE ARE DONE + 691 00411 3034 DCA BCNT + 692 00412 1376 TAD (377 + 693 00413 3031 DCA READST + 694 00414 4222 OUTBL3, JMS OUTBLK / SEND ALL BLOCKS + 695 00415 2027 ISZ CBLOCK + 696 00416 2034 ISZ BCNT + 697 00417 5214 JMP OUTBL3 + 698 00420 6201 CDF 0 + 699 00421 5777@ JMP DONE / NO MORE BLOCKS, DONE. + 700 + 701 00422 0000 OUTBLK, 0 /Send a block of data out serial port + 702 00423 7200 CLA + 703 00424 1023 TAD WCOUNT + 704 00425 3033 DCA LEN + 705 00426 1031 TAD READST /Send good/bad flag + 706 00427 4311 JMS PUN + 707 00430 7300 OUT, CLA CLL + 708 00431 1432 TAD I LOC + 709 00432 1040 TAD CHKSM / Keep checksum of all words sent + 710 00433 3040 DCA CHKSM + 711 00434 1432 TAD I LOC / Send 2 words as 3 bytes + 712 00435 4311 JMS PUN + 713 00436 7300 CLA CLL + 714 00437 1432 TAD I LOC + 715 00440 7012 RTR / Shift top 4 bits to low 4 + 716 00441 7012 RTR + 717 00442 7012 RTR + 718 00443 7012 RTR + 719 00444 0036 AND C17 + 720 00445 3035 DCA TEMP + 721 00446 2032 ISZ LOC + 722 00447 5254 JMP STFLD3+1 /NOT AT END OF FIELD (DJG) + 723 00450 6214 RDF /At end, inc to next field + 724 00451 1375 TAD (6211 /BUILD CDF + 725 00452 3253 DCA STFLD3 + 726 00453 7000 STFLD3, NOP + 727 00454 2033 ISZ LEN /END OF BUFFER? + 728 00455 7410 SKP /NO + 729 00456 5306 JMP ENDBK /YES + 730 00457 1432 TAD I LOC + 731 00460 1040 TAD CHKSM + 732 00461 3040 DCA CHKSM + 733 00462 1432 TAD I LOC + 734 00463 7006 RTL + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 16 + + + 735 00464 7006 RTL + 736 00465 0037 AND C360 + 737 00466 1035 TAD TEMP + 738 00467 4311 JMS PUN + 739 00470 7300 CLA CLL + 740 00471 1432 TAD I LOC + 741 00472 7012 RTR + 742 00473 7012 RTR + 743 00474 4311 JMS PUN + 744 00475 2032 ISZ LOC + 745 00476 5303 JMP STFLD4+1 /NOT AT END OF FIELD (DJG) + 746 00477 6214 RDF + 747 00500 1375 TAD (6211 /BUILD CDF + 748 00501 3302 DCA STFLD4 + 749 00502 7000 STFLD4, NOP + 750 00503 2033 ISZ LEN + 751 00504 5230 JMP OUT + 752 00505 5622 JMP I OUTBLK + 753 00506 1035 ENDBK, TAD TEMP /SEND LAST PART OF WORD + 754 00507 4311 JMS PUN + 755 00510 5622 JMP I OUTBLK + 756 + 757 00511 0000 PUN, 0 / Send byte out serial port + 758 / PLS / Punch for testing with emulator + 759 00512 6046 TLS2 / Send out console + 760 00513 7300 CLA CLL + 761 00514 1027 TAD CBLOCK + 762 / PSF + 763 00515 6041 TSF2 /Wait until character sent + 764 00516 5315 JMP .-1 + 765 00517 7200 CLA + 766 00520 5711 JMP I PUN + 767 + 00575 6211 + 00576 0377 + 00577 0274 + 00177 0200 + 768 $ + + No detected errors + 16 links generated diff --git a/DumpDT18/dumpdt18-550.pal b/DumpDT18/dumpdt18-550.pal new file mode 100644 index 0000000..e9d79d4 --- /dev/null +++ b/DumpDT18/dumpdt18-550.pal @@ -0,0 +1,768 @@ +/ TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code from D. Gesswein +/ (see ftp://ftp.pdp8online.com/software/dumprest). +/ Modified for 18-bit PDP-7 550 DECtape imaging by J. Dersch +/ +/ This program will send a DECtape image out the console port. +/ The format of the data sent is 0xff (0377) or 0xfd if read error +/ followed by 384 12-bit words (256 18-bit words) of data for each block. +/ After the last block a 0xfe (0376) is sent +/ with a two byte checksum, low 8 bits first then upper 4. +/ The words in a block are sent as three bytes for each 2 words. +/ 1 = low 8 bits first word +/ 2 = upper 4 bits first and lower 4 bits second +/ 3 = upper 8 bits second word +/ +/ The program (PC) receiving the data should be started before this program. +/ +/ To run, start at 0200. +/ SR 11 should be drive, only 0 and 1 supported without reassembling +/ SR 6-8 should be maximum memory field in computer, needs 8k minimum +/ +/ The receiving program should be running first. +/ At normal exit hitting cont will restart the program. +/ +/ Should halt at label finish (140) with number of recoverable errors in AC +/ The current block being read will be displayed in the AC +/ while running. +/ +/ The PC program will print out the bad location if an error occurs. +/ +/ We will retry each read up to four times on error. +/ +/ This transfers the standard 256 word by 578 blocks used by 18-bit DEC hardware, +/ using PDP-7 550 controller checksums (1's complement 18-bit additive). +/ It will read as many blocks are present up to the forward end-zone, so it will +/ handle tapes that vary from the standard 1102(8) block length. +/ NOTE: As the PDP-7 checksum takes significantly longer to calculate than the later +/ XOR-based checksums, there is a chance that timeout errors may occur on certain +/ combinations of drives, tapes, and controllers. +/ + + INAD=030 / Address of serial input, 30 for console + KCF2=6000 INAD + KSF2=6001 INAD + KCC2=6002 INAD + KRS2=6004 INAD + KIE2=6005 INAD + KRB2=6006 INAD + + OUTAD=040 / Address of serial output, 40 for console + TFL2=6000 OUTAD + TSF2=6001 OUTAD + TCF2=6002 OUTAD + TPC2=6004 OUTAD + TSK2=6005 OUTAD + TLS2=6006 OUTAD + + /CODE BASED ON: +/2 TD8E INITIALIZER PROGRAM, V7A +/ +/COPYRIGHT (C) 1975, 1977 +/DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. +/ +/ +/ +/THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A +/SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLU- +/SION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ANT OTHER +/COPIES THEREOF, MAY NOT BR PROVIDED OR OTHERWISE MADE AVAILABLE +/TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO +/AGREES TO THESE LICENSE TERMS. TITLE TO AND OWNERSHIP OF THE +/SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC. +/ +/ +/THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT +/NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL +/EQUIPMRNT COROPATION. +/ +/DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS +/SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. +/ +/ +/ +/ +/ +/ + +/DECEMBER 21, 1973 GB/RL/EF/SR + +/ABSTRACT-- +/ THE ROUTINE DESCRIBED AND LISTED HERE IS A GENERAL +/DATA HANDLER FOR THE TD8E DECTAPE SYSTEM. THE ROUTINE +/CONTAINS SEARCH, READ, AND WRITE FUNCTIONS IN A FORMAT +/WHICH IS COMPATIBLE WITH OS/8 DEVICE HANDLER CALLING +/SEQUENCES. + +/FIXES SINCE FIELD-TEST RELEASE: + +/1. FIXED BUG RE CLA ON RETRY AFTER ERROR +/2. ALLOWED FINAL BOOTSTRAP TO BE INTO A WRITE-LOCKED DEVICE + +/OS/8 V3D CHANGES: + +/3. FIXED BUG RE TD8E BUILD (V6B PATCH) + +/THIS ROUTINE CAN BE RE-EDITED AND ASSEMBLED TO PRODUCE +/VARIATIONS ON THE BASIC TD8E SYSTEM. ASSEMBLY PARAMETERS +/CONTROL: +/A) WHAT DRIVES (UNITS 0-7) WILL BE USED +/B) THE ORIGIN OF THE TWO PAGE ROUTINE +/C) WHAT MEMORY FIELD THE ROUTINE WILL RUN IN +/D) THE SIZE OF THE DECTAPE BLOCK TO BE READ/WRITTEN + +/ FOLLOWING ARE THE PARAMETERS SET UP FOR THE DEC 550 DECTAPE CONTROLLER: + + DRIVE=10 /UNITS 0 AND 1 SELECTED + ORIGIN=600 /ENTER AT ORIGIN, ORIGIN+4 + AFIELD=0 /INITIAL FIELD SETTING + MFIELD=00 /AFIELD*10=MFIELD + WDSBLK=600 /384 12-BIT WORDS PER BLOCK (256 18-BIT DATA WORDS) + +/THE USE OF THE PARAMETERS IS AS FOLLOWS: + +/ DRIVE: DRIVE DETERMINES WHICH UNITS WILL BE SELECTED +/ DRIVE=10 IMPLIES UNITS 0 &1 +/ DRIVE=20 IMPLIES UNITS 2&3 +/ DRIVE=30 IMPLIES UNITS 4&5 +/ DRIVE=40 IMPLIES UNITS 6&7 + +/ORIGIN: ALTERING ORIGIN CAUSES ASSEMBLY IN A DIFFERENT +/ MEMORY LOCATION. WHEN CHANGING ORIGIN KEEP IN MIND +/THAT THIS IS A TWO PAGE ROUTINE. + +/AFIELD: AFIELD DETERMINES THE INITIAL FIELD SETTING FOR THE +/ LOADER. PERMISSIBLE VALUES FOR AFIELD ARE 0 TO 7. + +/MFIELD: MFIELD IS USED IN A CIF CDF MFIELD INSTRUCTION. +/ THE VALUE INSERTED FOR MFIELD SHOULD BE 10(8) TIMES +/ THE VALUE FOR AFIELD. THE PERMISSIBLE VALUES ARE 00-70. + +/WDSBLK: WDSBLK GOVERNS HOW MANY WORDS THE ROUTINE THINKS ARE +/ IN A DECTAPE BLOCK. THE STANDARD VALUE IS 201(8) OR +/ 128 DECIMAL. THE VALUE USED +/ FOR WDSBLK SHOULD BE THE NUMBER OF WORDS THE TAPE WAS +/ FORMATTED TO CONTAIN. + +/IF WE WANT A HANDLER FOR UNITS 2&3 TO RESIDE IN +/FIELD 2 AT LOCATION 3000 AND READ/WRITE 256(10) WORDS +/PER BLOCK, THE PARAMETERS WOULD BE: +/ DRIVE=20 +/ ORIGIN=3000 +/ AFIELD=2 +/ MFIELD=20 +/ WDSBLK=400 + /THE CALL TO THE SUBROUTINE FOLLOWS BASICALLY THE +/CALLING SEQUENCE FOR OS/8 DEVICE HANDLERS. +/THE CALLING SEQUENCE IS: + +/ CDF CURRENT +/ CIF MFIELD /MFIELD=FIELD ASSEMBLED IN +/ JMS ENTRY /ENTRY=ORIGIN (EVEN NUMBERED DRIVE + /AND ORIGIN+4 FOR ODD NUMBERED DRIVE. +/ ARG1 +/ ARG1B (DJG) +/ ARG2 +/ ARG3 +/ ERROR RETURN +/ NORMAL RETURN + +/THE ARGUMENTS ARE: + +/ARG1: FUNCTION WORD BIT0: 0=READ, 1=WRITE +/ BITS 1-5: UNUSED, WAS # BLOCKS IN OPERATION (DJG) +/ BITS 6-8: FIELD OF BUFFER AREA +/ BIT 9: UNUSED +/ BIT 10: UNUSED +/ BIT 11: 1=START FORWARD, 0=REVERSE +/ARG1A: # OF BLOCKS IN OPERATIONA (DJG) +/ARG2: BUFFER ADDRESS FOR OPERATION +/ARG3: STARTING BLOCK FOR OPERATION + +/ERRORS: THE HANDLER DETECTS TWO TYPES OF ERRORS: +/A) FATAL ERRORS- PARITY ERROR, TIMING ERROR, +/ TOO GREAT A BLOCK NUMBER +/ FATAL ERRORS TAKE ERROR RETURN WITH THE +/ AC=4000. +/B) NON-FATAL- SELECT ERROR. +/ IF NO PROPER UNIT IS SELECTED, THE ERROR +/ RETURN IS TAKEN WITH CLEAR AC. +/FATAL ERRORS TRY THREE TIMES BEFORE TAKING ERROR RETURN. +/THE NORMAL RETURN IS TAKEN AFTER ALL INDICATED +/BLOCKS HAVE BEEN TRANSFERRED. THE AC IS CLEAR. + +/THE TD8E IOT'S ARE: + SDSS=7001-DRIVE /SKIP ON SINGLE LINE FLAG + SDST=7002-DRIVE /SKIP ON TIMING ERROR + SDSQ=7003-DRIVE /SKIP ON QUAD LINE FLAG + SDLC=7004-DRIVE /LOAD COMMAND REGISTER + SDLD=7005-DRIVE /LOAD DATA REGISTER + SDRC=7006-DRIVE /READ COMMAND REGISTER + SDRD=7007-DRIVE /READ DATA REGISTER + +/THE IOT'S IN GENERAL ARE 677X,676X,675X,AND 674X. +/THE OTHERS CONTROL UNITS 2-7. + +/ THIS HANDLER USES DECTAPE BLOCKS NOT OS/8 BLOCKS ! + + *ORIGIN + +/ MODIFIED SO BIT 0 ON ENTRY IS UNIT 1 +DTA0, 0 + DCA UNIT /SAVE UNIT POSITION + RDF + TAD C6203 /GET DATA FIELD AND SETUP RETURN + DCA LEAVE + TAD I DTA0 /GET FUNCTION WORD + SDLD /PUT FUNCTION INTO DATA REGISTER + CLA + TAD MWORDS + DCA WCOUNT /STORE MASTER WORD COUNT + ISZ DTA0 /TO BLOCK COUNT (DJG) + TAD I DTA0 / (DJG) + CIA / (DJG) + DCA PGCT / (DJG) + ISZ DTA0 /TO BUFFER + TAD I DTA0 + DCA XBUFF /SAVE ADDRESS (DJG) + ISZ DTA0 /TO BLOCK NUMBER + TAD I DTA0 + DCA BLOCK + ISZ DTA0 /POINT TO ERROR EXIT + CIF CDF MFIELD /TO ROUTINES DATA FIELD + SDRD + AND C70 /GET FIELD FOR XFER + TAD C6201 /FORM CDF N + DCA XFIELD /IF=0 AND DF=N AT XFER. + TAD UNIT /TEST FOR SELECT ERROR + SDLC + CLA / Moved here because my drive 1 is slow selecting + TAD RETRY + DCA TRYCNT /3 ERROR TRIES + SDRC + AND C100 + SZA CLA + JMP FATAL-1 + SDRD /PUT FUNCT INTO XFUNCT IN SECOND PG. + DCA I CXFUN + TAD WCOUNT + DCA I CXWCT + SDRD /GET MOTION BIT TO LINK + CLL RAR +XFIELD, HLT /INTO NEXT PAGE + JMP GO /AND START THE MOTION. +RWCOM, SDST /ANY TD8E TIME ERRORS? + /JMP TIMEOK /UNCOMMENT IF YOU SUSPECT TIMING ISSUES. + /HLT +TIMEOK, SZA CLA /OR CHECKSUM ERRORS? + JMP TRY3 /PLEASE NOTE THAT THE LINK IS ALWAYS + /SET AT RWCOM. GETCHK SETS IT. + ISZ PGCT / (DJG) + SKP / (DJG) + JMP EXIT /ALL DONE. GET OUT + ISZ BLOCK /NEXT BLOCK TO XFER + CLL CML /FORCES MOTION FORWARD +GO, CLA CML RTR /LINK BECOMES MOTION BIT + TAD C1000 + TAD UNIT /PUT IN 'GO' AND UNIT # + SDLC /LOOK FOR BLOCK NO. + CLA + TAD XBUFF + DCA OLDBUF + RDF + TAD C6201 + DCA OLDFLD + JMS I CRDQUD /WAIT AT LEAST 6 LINES TO LOOK + JMS I CRDQUD +CM200, 7600 /COULD HAVE SAVED A LOC. HERE +SRCH, SDSS + JMP .-1 /WAIT FOR SINGLE LINE FLAG + SDRC + CLL RTL /DIRECTION TO LINK. INFO BITS + /ARE SHIFTED. + AND C374 /ISOLATE MARK TRACK BITS + TAD M110 /IS IT END ZONE? + SNA /THE LINK STAYS SAME THRU THIS + JMP ENDZ + TAD M20 /CHECK FOR BLOCK MARK + SZA CLA + JMP SRCH + SDRD /GET THE BLOCK NUMBER + SZL /IF WE ARE IN REVERSE, LOOK FOR 3 + /BLOCKS BEFORE TARGET BLOCK. THIS + /ALLOWS TURNAROUND AND UP TO SPEED. + TAD C3 /REVERSE + CMA + TAD BLOCK + CMA /IS IT RIGHT BLOCK? + SNA + JMP FOUND /YES..HOORAY! +M110, SZL SNA CLA /NO, BUT ARE WE HEADED FOR IT? + /ABOVE SNA IS SUPERFLUOUS. + JMP SRCH /YES + SDRC /NO, TURN US AROUND. + CLL RTL /DIRECTION TO LINK + CLA /THIS CODE USED TO BE SHARED WITH ENDZ, + JMP GO /BUT NOW ENDZ HANDLES END OF TAPE CASES ONLY. +ENDZ, SDRC /WE ARE IN THE END ZONE + CLL RTL /DIRECTION TO LINK + SZL CLA /ARE WE IN REVERSE? + JMP GO /YES..TURN US AROUND + TAD BLOCK /IF WE ARE ON BLOCK ZERO, IT IS POSSIBLE FOR US TO BE AT THE + /REVERSE ENDZONE GOING FORWARD, EITHER DUE TO A RETRY OR BECAUSE + /THE TAPE WAS STARTED IN A POSITION BEFORE THE END ZONE. + /THESE CASES SHOULD NOT BE TREATED AS END-OF-TAPE. + SZA CLA + JMP ENDEX /END OF TAPE. STOP THE UNIT AND TAKE THE END EXIT. + JMP GO + +TRY3, CLA +OLDFLD, NOP + TAD OLDBUF + DCA XBUFF + ISZ TRYCNT + JMP GO /TRY 3 TIMES + JMP FATAL /LINK OFF MEANS AC=4000 ON RETURN +EXIT, ISZ DTA0 /TAKE THE NORMAL RETURN + CLL CML /AC=0 ON NORMAL RETURN +FATAL, ISZ DTA0 /TAKE THE ERROR RETURN +ENDEX, TAD UNIT + SDLC /STOP THE UNIT + CLA CML RAR +LEAVE, HLT + JMP I DTA0 + + +C6203, 6203 +C6201, 6201 +CRDQUD, RDQUAD +CXFUN, XFUNCT +C100, 100 +C1000, 1000 + + / NOTE THAT THE ABOVE CODE SEGMENT COMES VERY CLOSE TO TOUCHING + / THIS ONE, AND THE BELOW MUST RESIDE AT THE END OF THIS PAGE. + / BE CAREFUL ADDING NEW CODE TO THE ABOVE CODE. + *ORIGIN+172 +FOUND, SZL CLA /RIGHT BLOCK. HOW ABOUT DIRECTION? + JMP GO /WRONG..TURN AROUND + TAD UNIT /PUT UNIT INTO LINK + CLL RAL /AC IS NOW 0 +C70, 70 /********DON'T MOVE THIS!!!!****** +C3, 3 + /INTO NEXT PAGE + *ORIGIN+200 + CIF MFIELD + RAR /NOW GET UNIT # + DCA XUNIT + SDRC + SDLC +REVGRD, SDSS + JMP .-1 /LOOK FOR REVERSE GUARD + SDRC + AND K77 + TAD CM32 /IS IT REVERSE GUARD? + SZA CLA + JMP REVGRD /NO.KEEP LOOKING + TAD XWCT + DCA WORDS /WORD COUNTER + TAD XFUNCT /GET FUNCTION READ OR WRITE +K7700, SMA CLA + JMP READ /NEG. IS WRITE +WRITE, HLT /WRITE CODE REMOVED. +K77, 77 /ABOVE MAY SKIP (NOT ANYMORE DJG) +READ, JMS RDQUAD + JMS RDQUAD + JMS RDQUAD /SKIP CONTROL WORDS +RDLP, JMS RDQUAD + JMS P7CHK /COMPUTE PDP-7 550 CHECKSUM AS WE GO + DCA I XBUFF + ISZ XBUFF /AT END OF FIELD? + JMP STFLD2+1 /NOT AT END OF FIELD (DJG) + RDF + TAD (6211 + DCA STFLD2 +STFLD2, NOP + ISZ WORDS /DONE THIS OP? + JMP RDLP /NO SUCH LUCK + JMS RDQUAD /DONE: READ AND CHECKSUM LAST 18-BIT WORD (1.5 12-BIT WORDS) + JMS P7CHK /CHECKSUM IT + JMS RDQUAD /READ LAST PART OF CKSUM WORD + JMS P7CHK /CHECKSUM IT + JMS VFYCHK /VERIFY CHECKSUM + JMP I CRWCOM +C300, 300 /PROTECTION (NOT ANYMORE DJG) + +RDQUAD, 0 /READ A 12 BIT WORD + SDSQ + JMP .-1 + SDRD /READ DATA + JMP I RDQUAD + +XUNIT, 0 + / VERIFIES 18-BIT 1'S COMPLEMENT CKSUM. + / SHOULD BE 0 OR -0. + / AC SHOULD BE 0 ON EXIT IF CKSUM IS OK, NONZERO + / OTHERWISE. + / CODE EXPECTS LINK TO BE SET ON EXIT REGARDLESS. + / THIS ROUTINE ALSO RESETS VARIOUS CHECKSUM ROUTINE + / STATE BACK TO INITIAL CONDITIONS IN PREPARATION + / FOR THE NEXT BLOCK. +VFYCHK, 0 + CLA CLL + TAD CK18L /CHECK FOR ZERO + SZA CLA + JMP VFYNEG /NOPE, TRY NEGATIVE ZERO + TAD CK18H + JMP VDONE /VALIDITY IS DEPENDENT ON THE VALUE OF CK18H +VFYNEG, CLA IAC /CHECK FOR NEGATIVE ZERO (777777) + TAD CK18L /LOW 12 BITS SHOULD BE ZERO AFTER INCREMENT + SZA + JMP VDONE /INVALID CKSUM + TAD CK18H + TAD (0100 /HIGH 6 BITS SHOULD BE ZERO AFTER INCREMENT +VDONE, DCA EQUTMP /SAVE RESULT + DCA CK18L /CLEAR 18-BIT CKSUM FOR NEXT GO-ROUND + DCA CK18H + TAD P7TBLL + DCA P7WD /RESET CHECKSUM WORD ROUTINE POINTER + CLL CML /FORCES LINK ON AT RWCOM + TAD EQUTMP /RELOAD RESULT + JMP I VFYCHK + +CFATAL, FATAL +CRWCOM, RWCOM +XFUNCT, 0 +CM32, -32 +C1400, 1400 +WORDS, 0 +XWCT, 0 +P7TBLL, P7TBL + + PAGE + /PDP-7 550 CHECKSUM ROUTINE: + /COMPUTE 18-BIT 1'S COMPLEMENT CHECKSUM + /AC CONTAINS LAST 12-BIT WORD READ FROM TAPE, STOW THESE BITS + /IN THE RIGHT PLACE IN THE 18-BIT WORD AND ADD TO RUNNING SUM + /AC MUST BE RESTORED BEFORE RETURNING + /THIS CURRENTLY EXECUTES IN ABOUT 65US WORST-CASE. +P7CHK, 0 + DCA EQUTMP /SAVE ORIGINAL AC + + TAD EQUTMP + JMP I P7WD /DISPATCH TO WORD ROUTINE, AUTOINCREMENT P7WD + +P7WD0, /TAPE WORD 0: 18-BIT WORD 0, HIGH 12 BITS. + AND (7700 /STORE HIGH 6 BITS IN 18 BIT HIGH + DCA WD18H + TAD EQUTMP + BSW + AND (7700 /STORE LOW 6 BITS IN UPPER 6 BITS OF 18 BIT LOW WORD + DCA WD18L + JMP P7DONE /DONE, NO 18-BIT WORD READY YET + +P7WD1, /TAPE WORD 1: 18-BIT WORD 0, LOW 6-BITS; 18-BIT WORD 1, HIGH 6-BITS + AND (7700 /TAKE HIGH 6 BITS + BSW + TAD WD18L /FINISH 18-BIT WORD 0 (LOW 6-BITS) + DCA WD18L + TAD EQUTMP /SAVE BITS FOR NEXT WORD (HIGH 6 BITS OF 18-BIT WORD 1) + DCA WD18T + JMP P7CK /DO CHECKSUM, 18-BIT WORD 0 DONE. + +P7WD2, /TAPE WORD 2: 18-BIT WORD 1, LOW 12-BITS + DCA WD18L /THAT WAS EASY. + TAD WD18T /COPY HIGH 6 BITS FROM LAST TAPE WORD + AND (0077 + BSW + DCA WD18H + TAD P7TBL + DCA P7WD / RESET WORD ROUTINE POINTER AND CONTINUE, 18-BIT WORD 1 DONE. + + /DO AN 18-BIT 1'S COMPLEMENT ADDITION TO THE RUNNING CHECKSUM +P7CK, CLL CLA /CLEAR LINK, NEEDED FOR CARRY DETECTION + TAD WD18L /ADD TO LOW 12 BITS + TAD CK18L + DCA CK18L + SNL /CARRY FROM LOW 12 BITS? + JMP P7HI /NO, CONTINUE + CLL CLA /YES, INCREMENT HIGH 6 BITS + TAD (0100 +P7HI, TAD CK18H /ADD CKSUM TO HIGH 6 BITS + TAD WD18H /(NOTE THAT THE ABOVE TWO ADDS CAN RESULT IN AT MOST ONE CARRY OUT) + DCA CK18H + SNL /CARRY? + JMP P7DONE /NO, DONE HERE. + ISZ CK18L /END-AROUND CARRY TO LOW WORD + JMP P7DONE /RESULT NON-ZERO, DONE + TAD CK18H /RESULT ZERO: CARRY FROM LOW 12-BIT WORD TO HIGH SIX BITS + TAD (0100 /THIS CAN'T OVERFLOW SINCE WE JUST DID A CARRY OUT FROM IT + DCA CK18H +P7DONE, TAD EQUTMP /RESTORE AC + JMP I P7CHK /DONE + +P7TBL, P7TBL / JUMP TABLE FOR 18-BIT CHECKSUM ROUTINE + JMP P7WD0 + JMP P7WD1 + JMP P7WD2 + + *10 +P7WD, P7TBL + + + *20 +RETRY, 7774 / RETRY UP TO 4 TIME +NUMBLK, 3777 / MAX NUMBER OF BLOCKS TO ATTEMPT READING. BY DEFAULT THIS PROGRAM WILL READ UNTIL + / IT HITS THE END OF THE TAPE (FORWARD ENDZONE). IF YOU NEED TO LIMIT THE NUMBER OF BLOCKS + / READ, MODIFY THIS VALUE. + +MWORDS, -WDSBLK / WORDS PER BLOCK +WCOUNT, 0 +BLKFLD, 12 / 10 386 WORD BLOCKS OF 12-BIT WORDS, EQUIVALENT TO 256 18-BIT WORDS. + / WRAPPING PAST END OF LAST FIELD DOESN'T WORK +FIELDS, 0 +RDSIZE, 0 / NUMBER BLOCKS PER READ +CBLOCK, 0 / CURRENT BLOCK TO XFER +DRVSEL, 0 +READST, 377 +LOC, 0 +LEN, 0 +BCNT, 0 / BLOCKS TO SEND TO PC +TEMP, 0 +C17, 17 +C360, 360 +CHKSM, 0 +ERRCN2, 0 +OLDBUF, 0 / BELOW ARE USED BY DTA0 ROUTINE +XBUFF, 0 +C374, 374 +BLOCK, 0 +UNIT, 0 +TRYCNT, -3 +PGCT, 0 +CXWCT, XWCT +M20, -20 + + +WD18L, 0 / Low 12 bits of current 18-bit word +WD18H, 0 / High 6 bits of current 18-bit word - + / upper 6 bits are used to make carry-out testing faster, low bits must be zero. + / (routine actually testing cksum at end of block will need to take this into account.) +WD18T, 0 / Temporary storage while building 18-bit words +CK18L, 0 / Low 12 bits of running 18-bit PDP-7 checksum +CK18H, 0 / High 6 bits -- see WD18H for special info. +EQUTMP, 0 + + *140 +FINISH, HLT / Normal good halt + JMP START + + *200 +START, CDF 0 + CAF + CLA CLL OSR / Get drive + AND (1 + RTR + DCA DRVSEL + CLA CLL OSR / Get max field + RTR + RAR + AND (7 + SNA + HLT / Must have at least 1 field for buffer + CIA + DCA FIELDS + DCA ERRCN2 +RDSZLP, TAD BLKFLD / Multiply by number of fields available + ISZ FIELDS + JMP RDSZLP + DCA RDSIZE / NUMBER BLOCK PER READ + DCA CBLOCK + DCA CHKSM + DCA CK18L /RESET 18B CHECKSUM DATA + DCA CK18H + TAD P7TBL + DCA P7WD + +DUMPLP, CLA + TAD RDSIZE + TAD CBLOCK + CIA + TAD NUMBLK / MORE BLOCKS LEFT THAN READSIZE? + SMA / NO, READ NUMBER LEFT + CLA / YES, ONLY READ RDSIZE + TAD RDSIZE + SNA / ANY MORE BLOCKS? + JMP DONE / NO, DO FINISH STUFF + DCA ARGSZ + TAD CBLOCK + DCA ARGBK + TAD DRVSEL + JMS DTA0 + 0010 / READ STARTING IN FIELD 1 +ARGSZ, 0 + 0 +ARGBK, 0 + JMP ENDRET / TAKEN WHEN END OF TAPE IS HIT + JMP ERRRET / TAKEN WHEN AN ERROR IS ENCOUNTERED + TAD (377 / All blocks good + DCA READST + / Send data, each block starts with FF + CLA CLL / then 2 12 bit words in 3 bytes + DCA LOC / ERRRET DUPLICATES SOME OF THIS + TAD ARGSZ + CIA + DCA BCNT / Setup loop counter with number blocks read + CDF 10 +OUTBL1, JMS OUTBLK / Send a block + ISZ CBLOCK + ISZ BCNT / Send all read? + JMP OUTBL1 / No + CDF 0 + JMP DUMPLP / Go read next batch + + +DONE, CLA / Send FE and -checksum of all words + TAD (376 + JMS PUN + CLA CLL + TAD CHKSM / Send checksum in two bytes, low bits first + CIA + JMS PUN + CLA CLL + TAD CHKSM + CIA + RTR + RTR + RTR + RTR + AND C17 + JMS PUN + CLA + TAD DRVSEL + JMS DTA0 / REWIND TAPE + 0010 + 1 + 0 + 0 + NOP + NOP + TAD ERRCN2 / Leave AC with # of errors + JMP FINISH + + /SEND GOOD BLOCKS READ WITH GOOD BLOCK FLAG + /THEN BAD WITH BAD BLOCK FLAG. +ERRRET, +/ HLT / ****** If we want to stop on error + CDF 10 + CLA CLL + DCA LOC + TAD CBLOCK + CIA + TAD BLOCK /Get - number good blocks read + CIA /Last was bad + SNA + JMP FSTBAD /First block is bad, no good to send + DCA BCNT + TAD (377 + DCA READST +OUTBL2, JMS OUTBLK /Send good blocks + ISZ CBLOCK + ISZ BCNT + JMP OUTBL2 +FSTBAD, TAD (375 /NOW SEND BAD BLOCK + DCA READST + JMS OUTBLK + ISZ CBLOCK + ISZ ERRCN2 + CDF 0 + JMP DUMPLP /And read from here on + + PAGE +ENDRET, /SEND LAST SET OF BLOCKS READ BEFORE END OF TAPE AND FINISH. + CDF 10 + CLA CLL + DCA LOC + TAD CBLOCK + CIA + TAD BLOCK / GET NUMBER OF BLOCKS READ IN LAST BATCH + CMA / +1 to -BCNT SO WE SEND ALL BLOCKS + SNA + JMP DONE / READ ZERO BLOCKS IN LAST BATCH, WE ARE DONE + DCA BCNT + TAD (377 + DCA READST +OUTBL3, JMS OUTBLK / SEND ALL BLOCKS + ISZ CBLOCK + ISZ BCNT + JMP OUTBL3 + CDF 0 + JMP DONE / NO MORE BLOCKS, DONE. + +OUTBLK, 0 /Send a block of data out serial port + CLA + TAD WCOUNT + DCA LEN + TAD READST /Send good/bad flag + JMS PUN +OUT, CLA CLL + TAD I LOC + TAD CHKSM / Keep checksum of all words sent + DCA CHKSM + TAD I LOC / Send 2 words as 3 bytes + JMS PUN + CLA CLL + TAD I LOC + RTR / Shift top 4 bits to low 4 + RTR + RTR + RTR + AND C17 + DCA TEMP + ISZ LOC + JMP STFLD3+1 /NOT AT END OF FIELD (DJG) + RDF /At end, inc to next field + TAD (6211 /BUILD CDF + DCA STFLD3 +STFLD3, NOP + ISZ LEN /END OF BUFFER? + SKP /NO + JMP ENDBK /YES + TAD I LOC + TAD CHKSM + DCA CHKSM + TAD I LOC + RTL + RTL + AND C360 + TAD TEMP + JMS PUN + CLA CLL + TAD I LOC + RTR + RTR + JMS PUN + ISZ LOC + JMP STFLD4+1 /NOT AT END OF FIELD (DJG) + RDF + TAD (6211 /BUILD CDF + DCA STFLD4 +STFLD4, NOP + ISZ LEN + JMP OUT + JMP I OUTBLK +ENDBK, TAD TEMP /SEND LAST PART OF WORD + JMS PUN + JMP I OUTBLK + +PUN, 0 / Send byte out serial port +/ PLS / Punch for testing with emulator + TLS2 / Send out console + CLA CLL + TAD CBLOCK +/ PSF + TSF2 /Wait until character sent + JMP .-1 + CLA + JMP I PUN + + $ diff --git a/DumpDT18/dumpdt18.bin b/DumpDT18/dumpdt18.bin new file mode 100644 index 0000000..aaf5550 Binary files /dev/null and b/DumpDT18/dumpdt18.bin differ diff --git a/DumpDT18/dumpdt18.lst b/DumpDT18/dumpdt18.lst new file mode 100644 index 0000000..5d975a3 --- /dev/null +++ b/DumpDT18/dumpdt18.lst @@ -0,0 +1,796 @@ + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 1 + + + 1 / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code from D. Gesswein + 2 / (see ftp://ftp.pdp8online.com/software/dumprest). + 3 / Modified for 18-bit DECtape w/standard checksum imaging by J. Dersch + 4 / + 5 / This program will send a DECtape image out the console port. + 6 / The format of the data sent is 0xff (0377) or 0xfd if read error + 7 / followed by 384 12-bit words (256 18-bit words) of data for each block. + 8 / After the last block a 0xfe (0376) is sent + 9 / with a two byte checksum, low 8 bits first then upper 4. + 10 / The words in a block are sent as three bytes for each 2 words. + 11 / 1 = low 8 bits first word + 12 / 2 = upper 4 bits first and lower 4 bits second + 13 / 3 = upper 8 bits second word + 14 / + 15 / The program (PC) receiving the data should be started before this program. + 16 / + 17 / To run, start at 0200. + 18 / SR 11 should be drive, only 0 and 1 supported without reassembling + 19 / SR 6-8 should be maximum memory field in computer, needs 8k minimum + 20 / + 21 / The receiving program should be running first. + 22 / At normal exit hitting cont will restart the program. + 23 / + 24 / Should halt at label finish (140) with number of recoverable errors in AC + 25 / The current block being read will be displayed in the AC + 26 / while running. + 27 / + 28 / The PC program will print out the bad location if an error occurs. + 29 / + 30 / We will retry each read up to four times on error. + 31 / + 32 / This transfers the standard 256 word by 578 blocks used by 18-bit DEC hardware, + 33 / using standard checksums (as used by the PDP-9 and later machines). + 34 / It will read as many blocks are present up to the forward end-zone, so it will + 35 / handle tapes that vary from the standard 1102(8) block length. + 36 / + 37 0030 INAD=030 / Address of serial input, 30 for console + 38 6030 KCF2=6000 INAD + 39 6031 KSF2=6001 INAD + 40 6032 KCC2=6002 INAD + 41 6034 KRS2=6004 INAD + 42 6035 KIE2=6005 INAD + 43 6036 KRB2=6006 INAD + 44 + 45 0040 OUTAD=040 / Address of serial output, 40 for console + 46 6040 TFL2=6000 OUTAD + 47 6041 TSF2=6001 OUTAD + 48 6042 TCF2=6002 OUTAD + 49 6044 TPC2=6004 OUTAD + 50 6045 TSK2=6005 OUTAD + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 2 + + + 51 6046 TLS2=6006 OUTAD + 52 + 53 + 54 /CODE BASED ON: + 55 /2 TD8E INITIALIZER PROGRAM, V7A + 56 / + 57 /COPYRIGHT (C) 1975, 1977 + 58 /DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. + 59 / + 60 / + 61 / + 62 /THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A + 63 /SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLU- + 64 /SION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ANT OTHER + 65 /COPIES THEREOF, MAY NOT BR PROVIDED OR OTHERWISE MADE AVAILABLE + 66 /TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO + 67 /AGREES TO THESE LICENSE TERMS. TITLE TO AND OWNERSHIP OF THE + 68 /SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC. + 69 / + 70 / + 71 /THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT + 72 /NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL + 73 /EQUIPMRNT COROPATION. + 74 / + 75 /DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS + 76 /SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. + 77 / + 78 / + 79 / + 80 / + 81 / + 82 / + 83 + 84 /DECEMBER 21, 1973 GB/RL/EF/SR + 85 + 86 /ABSTRACT-- + 87 / THE ROUTINE DESCRIBED AND LISTED HERE IS A GENERAL + 88 /DATA HANDLER FOR THE TD8E DECTAPE SYSTEM. THE ROUTINE + 89 /CONTAINS SEARCH, READ, AND WRITE FUNCTIONS IN A FORMAT + 90 /WHICH IS COMPATIBLE WITH OS/8 DEVICE HANDLER CALLING + 91 /SEQUENCES. + 92 + 93 /FIXES SINCE FIELD-TEST RELEASE: + 94 + 95 /1. FIXED BUG RE CLA ON RETRY AFTER ERROR + 96 /2. ALLOWED FINAL BOOTSTRAP TO BE INTO A WRITE-LOCKED DEVICE + 97 + 98 /OS/8 V3D CHANGES: + 99 + 100 /3. FIXED BUG RE TD8E BUILD (V6B PATCH) + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 3 + + + 101 + 102 /THIS ROUTINE CAN BE RE-EDITED AND ASSEMBLED TO PRODUCE + 103 /VARIATIONS ON THE BASIC TD8E SYSTEM. ASSEMBLY PARAMETERS + 104 /CONTROL: + 105 /A) WHAT DRIVES (UNITS 0-7) WILL BE USED + 106 /B) THE ORIGIN OF THE TWO PAGE ROUTINE + 107 /C) WHAT MEMORY FIELD THE ROUTINE WILL RUN IN + 108 /D) THE SIZE OF THE DECTAPE BLOCK TO BE READ/WRITTEN + 109 + 110 /FOLLOWING ARE THE PARAMETERS SET UP FOR THE STANDARD + 111 /DEC VERSION OF THIS ROUTINE: + 112 + 113 0010 DRIVE=10 /UNITS 0 AND 1 SELECTED + 114 0600 ORIGIN=600 /ENTER AT ORIGIN, ORIGIN+4 + 115 0000 AFIELD=0 /INITIAL FIELD SETTING + 116 0000 MFIELD=00 /AFIELD*10=MFIELD + 117 0600 WDSBLK=600 /384 12-BIT WORDS PER BLOCK (256 18-BIT DATA WORDS) + 118 + 119 /THE USE OF THE PARAMETERS IS AS FOLLOWS: + 120 + 121 / DRIVE: DRIVE DETERMINES WHICH UNITS WILL BE SELECTED + 122 / DRIVE=10 IMPLIES UNITS 0 &1 + 123 / DRIVE=20 IMPLIES UNITS 2&3 + 124 / DRIVE=30 IMPLIES UNITS 4&5 + 125 / DRIVE=40 IMPLIES UNITS 6&7 + 126 + 127 /ORIGIN: ALTERING ORIGIN CAUSES ASSEMBLY IN A DIFFERENT + 128 / MEMORY LOCATION. WHEN CHANGING ORIGIN KEEP IN MIND + 129 /THAT THIS IS A TWO PAGE ROUTINE. + 130 + 131 /AFIELD: AFIELD DETERMINES THE INITIAL FIELD SETTING FOR THE + 132 / LOADER. PERMISSIBLE VALUES FOR AFIELD ARE 0 TO 7. + 133 + 134 /MFIELD: MFIELD IS USED IN A CIF CDF MFIELD INSTRUCTION. + 135 / THE VALUE INSERTED FOR MFIELD SHOULD BE 10(8) TIMES + 136 / THE VALUE FOR AFIELD. THE PERMISSIBLE VALUES ARE 00-70. + 137 + 138 /WDSBLK: WDSBLK GOVERNS HOW MANY WORDS THE ROUTINE THINKS ARE + 139 / IN A DECTAPE BLOCK. THE STANDARD VALUE IS 201(8) OR + 140 / 128 DECIMAL. NOTE THAT THE FUNCTION WORD BIT 10 CAN + 141 / 129 DECIMAL ??? (DJG) + 142 / BE USED TO SUBTRACT ONE FROM WDSBLK. THE VALUE USED + 143 / FOR WDSBLK SHOULD BE THE NUMBER OF WORDS THE TAPE WAS + 144 / FORMATTED TO CONTAIN. + 145 + 146 /IF WE WANT A HANDLER FOR UNITS 2&3 TO RESIDE IN + 147 /FIELD 2 AT LOCATION 3000 AND READ/WRITE 256(10) WORDS + 148 /PER BLOCK, THE PARAMETERS WOULD BE: + 149 / DRIVE=20 + 150 / ORIGIN=3000 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 4 + + + 151 / AFIELD=2 + 152 / MFIELD=20 + 153 / WDSBLK=400 + 154 /THE CALL TO THE SUBROUTINE FOLLOWS BASICALLY THE + 155 /CALLING SEQUENCE FOR OS/8 DEVICE HANDLERS. + 156 /THE CALLING SEQUENCE IS: + 157 + 158 / CDF CURRENT + 159 / CIF MFIELD /MFIELD=FIELD ASSEMBLED IN + 160 / JMS ENTRY /ENTRY=ORIGIN (EVEN NUMBERED DRIVE + 161 /AND ORIGIN+4 FOR ODD NUMBERED DRIVE. + 162 / ARG1 + 163 / ARG1B (DJG) + 164 / ARG2 + 165 / ARG3 + 166 / ERROR RETURN + 167 / NORMAL RETURN + 168 + 169 /THE ARGUMENTS ARE: + 170 + 171 /ARG1: FUNCTION WORD BIT0: 0=READ, 1=WRITE + 172 / BITS 1-5: UNUSED, WAS # BLOCKS IN OPERATION (DJG) + 173 / BITS 6-8: FIELD OF BUFFER AREA + 174 / BIT 9: UNUSED + 175 / BIT 10: # OF WORDS/BLOCK. + 176 / 0= WDSBLK, 1=WDSBLK-1 + 177 / BIT 11: 1=START FORWARD, 0=REVERSE + 178 /ARG1A: # OF BLOCKS IN OPERATIONA (DJG) + 179 /ARG2: BUFFER ADDRESS FOR OPERATION + 180 /ARG3: STARTING BLOCK FOR OPERATION + 181 + 182 /ERRORS: THE HANDLER DETECTS TWO TYPES OF ERRORS: + 183 /A) FATAL ERRORS- PARITY ERROR, TIMING ERROR, + 184 / TOO GREAT A BLOCK NUMBER + 185 / FATAL ERRORS TAKE ERROR RETURN WITH THE + 186 / AC=4000. + 187 /B) NON-FATAL- SELECT ERROR. + 188 / IF NO PROPER UNIT IS SELECTED, THE ERROR + 189 / RETURN IS TAKEN WITH CLEAR AC. + 190 /FATAL ERRORS TRY THREE TIMES BEFORE TAKING ERROR RETURN. + 191 /THE NORMAL RETURN IS TAKEN AFTER ALL INDICATED + 192 /BLOCKS HAVE BEEN TRANSFERRED. THE AC IS CLEAR. + 193 + 194 /THE TD8E IOT'S ARE: + 195 6771 SDSS=7001-DRIVE /SKIP ON SINGLE LINE FLAG + 196 6772 SDST=7002-DRIVE /SKIP ON TIMING ERROR + 197 6773 SDSQ=7003-DRIVE /SKIP ON QUAD LINE FLAG + 198 6774 SDLC=7004-DRIVE /LOAD COMMAND REGISTER + 199 6775 SDLD=7005-DRIVE /LOAD DATA REGISTER + 200 6776 SDRC=7006-DRIVE /READ COMMAND REGISTER + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 5 + + + 201 6777 SDRD=7007-DRIVE /READ DATA REGISTER + 202 + 203 /THE IOT'S IN GENERAL ARE 677X,676X,675X,AND 674X. + 204 /THE OTHERS CONTROL UNITS 2-7. + 205 + 206 / THIS HANDLER USES DECTAPE BLOCKS NOT OS/8 BLOCKS ! + 207 + 208 0600 *ORIGIN + 209 + 210 / MODIFIED SO BIT 0 ON ENTRY IS UNIT 1 + 211 00600 0000 DTA0, 0 + 212 00601 3047 DCA UNIT /SAVE UNIT POSITION + 213 00602 6214 RDF + 214 00603 1360 TAD C6203 /GET DATA FIELD AND SETUP RETURN + 215 00604 3356 DCA LEAVE + 216 00605 1600 TAD I DTA0 /GET FUNCTION WORD + 217 00606 6775 SDLD /PUT FUNCTION INTO DATA REGISTER + 218 00607 7200 CLA + 219 00610 1022 TAD MWORDS + 220 00611 3023 DCA WCOUNT /STORE MASTER WORD COUNT + 221 00612 2200 ISZ DTA0 /TO BLOCK COUNT (DJG) + 222 00613 1600 TAD I DTA0 / (DJG) + 223 00614 7041 CIA / (DJG) + 224 00615 3051 DCA PGCT / (DJG) + 225 00616 2200 ISZ DTA0 /TO BUFFER + 226 00617 1600 TAD I DTA0 + 227 00620 3044 DCA XBUFF /SAVE ADDRESS (DJG) + 228 00621 2200 ISZ DTA0 /TO BLOCK NUMBER + 229 00622 1600 TAD I DTA0 + 230 00623 3046 DCA BLOCK + 231 00624 2200 ISZ DTA0 /POINT TO ERROR EXIT + 232 00625 6203 CIF CDF MFIELD /TO ROUTINES DATA FIELD + 233 00626 6777 SDRD + 234 00627 0376 AND C70 /GET FIELD FOR XFER + 235 00630 1361 TAD C6201 /FORM CDF N + 236 00631 3251 DCA XFIELD /IF=0 AND DF=N AT XFER. + 237 00632 1047 TAD UNIT /TEST FOR SELECT ERROR + 238 00633 6774 SDLC + 239 00634 7200 CLA / Moved here because my drive 1 is slow selecting + 240 00635 1020 TAD RETRY + 241 00636 3050 DCA TRYCNT /3 ERROR TRIES + 242 00637 6776 SDRC + 243 00640 0364 AND C100 + 244 00641 7640 SZA CLA + 245 00642 5351 JMP FATAL-1 + 246 00643 6777 SDRD /PUT FUNCT INTO XFUNCT IN SECOND PG. + 247 00644 3763 DCA I CXFUN + 248 00645 1023 TAD WCOUNT + 249 00646 3452 DCA I CXWCT + 250 00647 6777 SDRD /GET MOTION BIT TO LINK + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 6 + + + 251 00650 7110 CLL RAR + 252 00651 7402 XFIELD, HLT /INTO NEXT PAGE + 253 00652 5263 JMP GO /AND START THE MOTION. + 254 00653 6772 RWCOM, SDST /ANY CHECKSUM ERRORS? + 255 00654 7640 SZA CLA /OR CHECKSUM ERRORS? + 256 00655 5341 JMP TRY3 /PLEASE NOTE THAT THE LINK IS ALWAYS + 257 /SET AT RWCOM. GETCHK SETS IT. + 258 00656 2051 ISZ PGCT / (DJG) + 259 00657 7410 SKP / (DJG) + 260 00660 5350 JMP EXIT /ALL DONE. GET OUT + 261 00661 2046 ISZ BLOCK /NEXT BLOCK TO XFER + 262 00662 7120 CLL CML /FORCES MOTION FORWARD + 263 00663 7232 GO, CLA CML RTR /LINK BECOMES MOTION BIT + 264 00664 1365 TAD C1000 + 265 00665 1047 TAD UNIT /PUT IN 'GO' AND UNIT # + 266 00666 6774 SDLC /LOOK FOR BLOCK NO. + 267 00667 7200 CLA + 268 00670 1044 TAD XBUFF + 269 00671 3043 DCA OLDBUF + 270 00672 6214 RDF + 271 00673 1361 TAD C6201 + 272 00674 3342 DCA OLDFLD + 273 00675 4762 JMS I CRDQUD /WAIT AT LEAST 6 LINES TO LOOK + 274 00676 4762 JMS I CRDQUD + 275 00677 7600 CM200, 7600 /COULD HAVE SAVED A LOC. HERE + 276 00700 6771 SRCH, SDSS + 277 00701 5300 JMP .-1 /WAIT FOR SINGLE LINE FLAG + 278 00702 6776 SDRC + 279 00703 7106 CLL RTL /DIRECTION TO LINK. INFO BITS + 280 /ARE SHIFTED. + 281 00704 0045 AND C374 /ISOLATE MARK TRACK BITS + 282 00705 1323 TAD M110 /IS IT END ZONE? + 283 00706 7450 SNA /THE LINK STAYS SAME THRU THIS + 284 00707 5331 JMP ENDZ + 285 00710 1053 TAD M20 /CHECK FOR BLOCK MARK + 286 00711 7640 SZA CLA + 287 00712 5300 JMP SRCH + 288 00713 6777 SDRD /GET THE BLOCK NUMBER + 289 00714 7430 SZL /IF WE ARE IN REVERSE, LOOK FOR 3 + 290 /BLOCKS BEFORE TARGET BLOCK. THIS + 291 /ALLOWS TURNAROUND AND UP TO SPEED. + 292 00715 1377 TAD C3 /REVERSE + 293 00716 7040 CMA + 294 00717 1046 TAD BLOCK + 295 00720 7040 CMA /IS IT RIGHT BLOCK? + 296 00721 7450 SNA + 297 00722 5372 JMP FOUND /YES..HOORAY! + 298 00723 7670 M110, SZL SNA CLA /NO, BUT ARE WE HEADED FOR IT? + 299 /ABOVE SNA IS SUPERFLUOUS. + 300 00724 5300 JMP SRCH /YES + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 7 + + + 301 00725 6776 SDRC /NO, TURN US AROUND. + 302 00726 7106 CLL RTL /DIRECTION TO LINK + 303 00727 7200 CLA /THIS CODE USED TO BE SHARED WITH ENDZ, + 304 00730 5263 JMP GO /BUT NOW ENDZ HANDLES END OF TAPE CASES ONLY. + 305 00731 6776 ENDZ, SDRC /WE ARE IN THE END ZONE + 306 00732 7106 CLL RTL /DIRECTION TO LINK + 307 00733 7630 SZL CLA /ARE WE IN REVERSE? + 308 00734 5263 JMP GO /YES..TURN US AROUND + 309 00735 1046 TAD BLOCK /IF WE ARE ON BLOCK ZERO, IT IS POSSIBLE FOR US TO BE AT THE + 310 /REVERSE ENDZONE GOING FORWARD, EITHER DUE TO A RETRY OR BECAUSE + 311 /THE TAPE WAS STARTED IN A POSITION BEFORE THE END ZONE. + 312 /THESE CASES SHOULD NOT BE TREATED AS END-OF-TAPE. + 313 00736 7640 SZA CLA + 314 00737 5353 JMP ENDEX /END OF TAPE. STOP THE UNIT AND TAKE THE END EXIT. + 315 00740 5263 JMP GO + 316 + 317 00741 7200 TRY3, CLA + 318 00742 7000 OLDFLD, NOP + 319 00743 1043 TAD OLDBUF + 320 00744 3044 DCA XBUFF + 321 00745 2050 ISZ TRYCNT + 322 00746 5263 JMP GO /TRY 3 TIMES + 323 00747 5352 JMP FATAL /LINK OFF MEANS AC=4000 ON RETURN + 324 00750 2200 EXIT, ISZ DTA0 /TAKE THE NORMAL RETURN + 325 00751 7120 CLL CML /AC=0 ON NORMAL RETURN + 326 00752 2200 FATAL, ISZ DTA0 /TAKE THE ERROR RETURN + 327 00753 1047 ENDEX, TAD UNIT + 328 00754 6774 SDLC /STOP THE UNIT + 329 00755 7230 CLA CML RAR + 330 00756 7402 LEAVE, HLT + 331 00757 5600 JMP I DTA0 + 332 + 333 + 334 00760 6203 C6203, 6203 + 335 00761 6201 C6201, 6201 + 336 00762 1060 CRDQUD, RDQUAD + 337 00763 1120 CXFUN, XFUNCT + 338 00764 0100 C100, 100 + 339 00765 1000 C1000, 1000 + 340 + 341 + 342 / NOTE THAT THE ABOVE CODE SEGMENT COMES VERY CLOSE TO TOUCHING + 343 / THIS ONE, AND THIS ONE MUST RESIDE AT THE END OF THIS PAGE. + 344 / BE CAREFUL ADDING NEW CODE TO THE ABOVE PAGE. + 345 0772 *ORIGIN+172 + 346 00772 7630 FOUND, SZL CLA /RIGHT BLOCK. HOW ABOUT DIRECTION? + 347 00773 5263 JMP GO /WRONG..TURN AROUND + 348 00774 1047 TAD UNIT /PUT UNIT INTO LINK + 349 00775 7104 CLL RAL /AC IS NOW 0 + 350 00776 0070 C70, 70 /********DON'T MOVE THIS!!!!****** + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 8 + + + 351 00777 0003 C3, 3 + 352 /INTO NEXT PAGE + 353 1000 *ORIGIN+200 + 354 01000 6202 CIF MFIELD + 355 01001 7010 RAR /NOW GET UNIT # + 356 01002 3265 DCA XUNIT + 357 01003 6776 SDRC + 358 01004 6774 SDLC + 359 01005 6771 REVGRD, SDSS + 360 01006 5205 JMP .-1 /LOOK FOR REVERSE GUARD + 361 01007 6776 SDRC + 362 01010 0222 AND K77 + 363 01011 1321 TAD CM32 /IS IT REVERSE GUARD? + 364 01012 7640 SZA CLA + 365 01013 5205 JMP REVGRD /NO.KEEP LOOKING + 366 01014 1325 TAD XWCT + 367 01015 3324 DCA WORDS /WORD COUNTER + 368 01016 1320 TAD XFUNCT /GET FUNCTION READ OR WRITE + 369 01017 7700 K7700, SMA CLA + 370 01020 5223 JMP READ /NEG. IS WRITE + 371 01021 7402 WRITE, HLT /WRITE CODE REMOVED + 372 01022 0077 K77, 77 /ABOVE MAY SKIP (NOT ANYMORE DJG) + 373 01023 4260 READ, JMS RDQUAD + 374 01024 4260 JMS RDQUAD + 375 01025 4260 JMS RDQUAD /SKIP CONTROL WORDS + 376 01026 0222 AND K77 + 377 01027 1217 TAD K7700 /TACK 7700 ONTO CHECKSUM. + 378 01030 3323 DCA CHKSUM /CHECKSUM ONLY LOW 6 BITS ANYWAY + 379 01031 4260 RDLP, JMS RDQUAD + 380 01032 4265 JMS EQUFUN /COMPUT CHECKSUM AS WE GO + 381 01033 3444 DCA I XBUFF /IT GETS CONDENSED LATER + 382 01034 2044 ISZ XBUFF /AT END OF FIELD? + 383 01035 5242 JMP STFLD2+1 /NOT AT END OF FIELD (DJG) + 384 01036 6214 RDF + 385 01037 1377 TAD (6211 + 386 01040 3241 DCA STFLD2 + 387 01041 7000 STFLD2, NOP + 388 01042 2324 ISZ WORDS /DONE THIS OP? + 389 01043 5231 JMP RDLP /NO SUCH LUCK + 390 01044 1320 TAD XFUNCT /IF OP WAS FOR WDSBLK-1, READ AND + 391 01045 7112 CLL RTR /CHECKSUM THE LAST TAPE WORD + 392 01046 7620 SNL CLA + 393 01047 5252 JMP RDLP2 + 394 01050 4260 JMS RDQUAD /NOT NEEDED FOR WDSBLK/BLOCK + 395 01051 4265 JMS EQUFUN /CHECKSUM IT + 396 01052 4260 RDLP2, JMS RDQUAD /READ CHECKSUM + 397 01053 0217 AND K7700 + 398 01054 4265 JMS EQUFUN + 399 01055 4302 JMS GETCHK /GET SIX BIT CHECKSUM + 400 01056 5717 JMP I CRWCOM + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 9 + + + 401 01057 0300 C300, 300 /PROTECTION (NOT ANYMORE DJG) + 402 + 403 01060 0000 RDQUAD, 0 /READ A 12 BIT WORD + 404 01061 6773 SDSQ + 405 01062 5261 JMP .-1 + 406 01063 6777 SDRD /READ DATA + 407 01064 5660 JMP I RDQUAD + 408 + 409 XUNIT, + 410 01065 0000 EQUFUN, 0 /COMPUTE EQUIVALENCE CHECKSUM + 411 01066 7040 CMA + 412 01067 3326 DCA EQUTMP /ACTUALLY CHECKSUMS ON DECTAPE ARE + 413 01070 1326 TAD EQUTMP /EQUIVALENCE OF ALL WORDS IN A RECORD + 414 01071 0323 AND CHKSUM /SIX BITS AT A TIME. BUT SINCE EQUIVALENCE + 415 01072 7041 CIA /IS ASSOCIATIVE, WE CAN DO IT 12 + 416 01073 7104 CLL RAL /BITS AT A TIME AND CONDENSE LATER. + 417 01074 1326 TAD EQUTMP /THIS ROUTINE USES THESE IDENTITIES: + 418 01075 1323 TAD CHKSUM /A+B=(A.XOR.B)+2*(A.AND.B) + 419 01076 3323 DCA CHKSUM /A.EQU.B=.NOT.(A.XOR.B)=A.XOR.(.NOT.B) + 420 01077 1326 TAD EQUTMP /A.EQU.B=(A+(.NOT.B))-2*(A.AND.(.NOT.B)) + 421 01100 7040 CMA + 422 01101 5665 JMP I EQUFUN + 423 + 424 01102 0000 GETCHK, 0 /FORM 6 BIT CHECKSUM + 425 01103 7200 CLA + 426 01104 1323 TAD CHKSUM + 427 01105 7040 CMA + 428 01106 7106 CLL RTL + 429 01107 7006 RTL + 430 01110 7006 RTL + 431 01111 4265 JMS EQUFUN + 432 01112 7320 CLA CLL CML /FORCES LINK ON AT RWCOM + 433 01113 1323 TAD CHKSUM + 434 01114 0217 AND K7700 + 435 01115 5702 JMP I GETCHK + 436 + 437 01116 0752 CFATAL, FATAL + 438 01117 0653 CRWCOM, RWCOM + 439 01120 0000 XFUNCT, 0 + 440 01121 7746 CM32, -32 + 441 01122 1400 C1400, 1400 + 442 01123 0000 CHKSUM, 0 + 443 01124 0000 WORDS, 0 + 444 01125 0000 XWCT, 0 + 445 01126 0000 EQUTMP, 0 + 446 + 01177 6211 + 447 0020 *20 + 448 00020 7774 RETRY, 7774 / RETRY UP TO 4 TIME + 449 00021 3777 NUMBLK, 3777 / MAX NUMBER OF BLOCKS TO ATTEMPT READING. BY DEFAULT THIS PROGRAM WILL READ UNTIL + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 10 + + + 450 / IT HITS THE END OF THE TAPE (FORWARD ENDZONE). IF YOU NEED TO LIMIT THE NUMBER OF BLOCKS + 451 / READ, MODIFY THIS VALUE. + 452 00022 7200 MWORDS, -WDSBLK / WORDS PER BLOCK + 453 00023 0000 WCOUNT, 0 + 454 00024 0012 BLKFLD, 12 / 10 386 WORD BLOCKS OF 12-BIT WORDS, EQUIVALENT TO 256 18-BIT WORDS. + 455 / WRAPPING PAST END OF LAST FIELD DOESN'T WORK + 456 00025 0000 FIELDS, 0 + 457 00026 0000 RDSIZE, 0 / NUMBER BLOCKS PER READ + 458 00027 0000 CBLOCK, 0 / CURRENT BLOCK TO XFER + 459 00030 0000 CLKSUM, 0 + 460 00031 0000 DRVSEL, 0 + 461 00032 0377 READST, 377 + 462 00033 0000 LOC, 0 + 463 00034 0000 LEN, 0 + 464 00035 0000 BCNT, 0 / BLOCKS TO SEND TO PC + 465 00036 0000 TEMP, 0 + 466 00037 0017 C17, 17 + 467 00040 0360 C360, 360 + 468 00041 0000 CHKSM, 0 + 469 00042 0000 ERRCN2, 0 + 470 00043 0000 OLDBUF, 0 / BELOW ARE USED BY DTA0 ROUTINE + 471 00044 0000 XBUFF, 0 + 472 00045 0374 C374, 374 + 473 00046 0000 BLOCK, 0 + 474 00047 0000 UNIT, 0 + 475 00050 7775 TRYCNT, -3 + 476 00051 0000 PGCT, 0 + 477 00052 1125 CXWCT, XWCT + 478 00053 7760 M20, -20 + 479 + 480 0140 *140 + 481 00140 7402 FINISH, HLT / Normal good halt + 482 00141 5777@ JMP START + 483 + 484 0200 *200 + 485 00200 6201 START, CDF 0 + 486 00201 6007 CAF + 487 00202 7704 CLA CLL OSR / Get drive + 488 00203 0377 AND (1 + 489 00204 7012 RTR + 490 00205 3031 DCA DRVSEL + 491 00206 7704 CLA CLL OSR / Get max field + 492 00207 7012 RTR + 493 00210 7010 RAR + 494 00211 0376 AND (7 + 495 00212 7450 SNA + 496 00213 7402 HLT / Must have at least 1 field for buffer + 497 00214 7041 CIA + 498 00215 3025 DCA FIELDS + 499 00216 3042 DCA ERRCN2 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 11 + + + 500 00217 1024 RDSZLP, TAD BLKFLD / Multiply by number of fields available + 501 00220 2025 ISZ FIELDS + 502 00221 5217 JMP RDSZLP + 503 00222 3026 DCA RDSIZE / NUMBER BLOCK PER READ + 504 00223 3027 DCA CBLOCK + 505 00224 3041 DCA CHKSM + 506 + 507 00225 7200 DUMPLP, CLA + 508 00226 1026 TAD RDSIZE + 509 00227 1027 TAD CBLOCK + 510 00230 7041 CIA + 511 00231 1021 TAD NUMBLK / MORE BLOCKS LEFT THAN READSIZE? + 512 00232 7500 SMA / NO, READ NUMBER LEFT + 513 00233 7200 CLA / YES, ONLY READ RDSIZE + 514 00234 1026 TAD RDSIZE + 515 00235 7450 SNA / ANY MORE BLOCKS? + 516 00236 5270 JMP DONE / NO, DO FINISH STUFF + 517 00237 3245 DCA ARGSZ + 518 00240 1027 TAD CBLOCK + 519 00241 3247 DCA ARGBK + 520 00242 1031 TAD DRVSEL + 521 00243 4775@ JMS DTA0 + 522 00244 0010 0010 / READ STARTING IN FIELD 1 + 523 00245 0000 ARGSZ, 0 + 524 00246 0000 0 + 525 00247 0000 ARGBK, 0 + 526 00250 5774@ JMP ENDRET / TAKEN WHEN END OF TAPE IS HIT + 527 00251 5323 JMP ERRRET / TAKEN WHEN AN ERROR IS ENCOUNTERED + 528 00252 1373 TAD (377 / All blocks good + 529 00253 3032 DCA READST + 530 / Send data, each block starts with FF + 531 00254 7300 CLA CLL / then 2 12 bit words in 3 bytes + 532 00255 3033 DCA LOC / ERRRET DUPLICATES SOME OF THIS + 533 00256 1245 TAD ARGSZ + 534 00257 7041 CIA + 535 00260 3035 DCA BCNT / Setup loop counter with number blocks read + 536 00261 6211 CDF 10 + 537 00262 4772@ OUTBL1, JMS OUTBLK / Send a block + 538 00263 2027 ISZ CBLOCK + 539 00264 2035 ISZ BCNT / Send all read? + 540 00265 5262 JMP OUTBL1 / No + 541 00266 6201 CDF 0 + 542 00267 5225 JMP DUMPLP / Go read next batch + 543 + 544 + 545 00270 7200 DONE, CLA / Send FE and -checksum of all words + 546 00271 1371 TAD (376 + 547 00272 4770@ JMS PUN + 548 00273 7300 CLA CLL + 549 00274 1041 TAD CHKSM / Send checksum in two bytes, low bits first + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 12 + + + 550 00275 7041 CIA + 551 00276 4770@ JMS PUN + 552 00277 7300 CLA CLL + 553 00300 1041 TAD CHKSM + 554 00301 7041 CIA + 555 00302 7012 RTR + 556 00303 7012 RTR + 557 00304 7012 RTR + 558 00305 7012 RTR + 559 00306 0037 AND C17 + 560 00307 4770@ JMS PUN + 561 00310 7200 CLA + 562 00311 1031 TAD DRVSEL + 563 00312 4775@ JMS DTA0 / REWIND TAPE + 564 00313 0010 0010 + 565 00314 0001 1 + 566 00315 0000 0 + 567 00316 0000 0 + 568 00317 7000 NOP + 569 00320 7000 NOP + 570 00321 1042 TAD ERRCN2 / Leave AC with # of errors + 571 00322 5140 JMP FINISH + 572 + 573 /SEND GOOD BLOCKS READ WITH GOOD BLOCK FLAG + 574 /THEN BAD WITH BAD BLOCK FLAG. + 575 ERRRET, + 576 / HLT / ****** If we want to stop on error + 577 00323 6211 CDF 10 + 578 00324 7300 CLA CLL + 579 00325 3033 DCA LOC + 580 00326 1027 TAD CBLOCK + 581 00327 7041 CIA + 582 00330 1046 TAD BLOCK /Get - number good blocks read + 583 00331 7041 CIA /Last was bad + 584 00332 7450 SNA + 585 00333 5343 JMP FSTBAD /First block is bad, no good to send + 586 00334 3035 DCA BCNT + 587 00335 1373 TAD (377 + 588 00336 3032 DCA READST + 589 00337 4772@ OUTBL2, JMS OUTBLK /Send good blocks + 590 00340 2027 ISZ CBLOCK + 591 00341 2035 ISZ BCNT + 592 00342 5337 JMP OUTBL2 + 593 00343 1367 FSTBAD, TAD (375 /NOW SEND BAD BLOCK + 594 00344 3032 DCA READST + 595 00345 4772@ JMS OUTBLK + 596 00346 2027 ISZ CBLOCK + 597 00347 2042 ISZ ERRCN2 + 598 00350 6201 CDF 0 + 599 00351 5225 JMP DUMPLP /And read from here on + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 13 + + + 600 + 00367 0375 + 00370 0511 + 00371 0376 + 00372 0422 + 00373 0377 + 00374 0400 + 00375 0600 + 00376 0007 + 00377 0001 + 601 PAGE + 602 ENDRET, /SEND LAST SET OF BLOCKS READ BEFORE END OF TAPE AND FINISH. + 603 00400 6211 CDF 10 + 604 00401 7300 CLA CLL + 605 00402 3033 DCA LOC + 606 00403 1027 TAD CBLOCK + 607 00404 7041 CIA + 608 00405 1046 TAD BLOCK / GET NUMBER OF BLOCKS READ IN LAST BATCH + 609 00406 7040 CMA / +1 to -BCNT SO WE SEND ALL BLOCKS + 610 00407 7450 SNA + 611 00410 5777@ JMP DONE / READ ZERO BLOCKS IN LAST BATCH, WE ARE DONE + 612 00411 3035 DCA BCNT + 613 00412 1376 TAD (377 + 614 00413 3032 DCA READST + 615 00414 4222 OUTBL3, JMS OUTBLK / SEND ALL BLOCKS + 616 00415 2027 ISZ CBLOCK + 617 00416 2035 ISZ BCNT + 618 00417 5214 JMP OUTBL3 + 619 00420 6201 CDF 0 + 620 00421 5777@ JMP DONE / NO MORE BLOCKS, DONE. + 621 + 622 00422 0000 OUTBLK, 0 /Send a block of data out serial port + 623 00423 7200 CLA + 624 00424 1023 TAD WCOUNT + 625 00425 3034 DCA LEN + 626 00426 1032 TAD READST /Send good/bad flag + 627 00427 4311 JMS PUN + 628 00430 7300 OUT, CLA CLL + 629 00431 1433 TAD I LOC + 630 00432 1041 TAD CHKSM / Keep checksum of all words sent + 631 00433 3041 DCA CHKSM + 632 00434 1433 TAD I LOC / Send 2 words as 3 bytes + 633 00435 4311 JMS PUN + 634 00436 7300 CLA CLL + 635 00437 1433 TAD I LOC + 636 00440 7012 RTR / Shift top 4 bits to low 4 + 637 00441 7012 RTR + 638 00442 7012 RTR + 639 00443 7012 RTR + 640 00444 0037 AND C17 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 14 + + + 641 00445 3036 DCA TEMP + 642 00446 2033 ISZ LOC + 643 00447 5254 JMP STFLD3+1 /NOT AT END OF FIELD (DJG) + 644 00450 6214 RDF /At end, inc to next field + 645 00451 1375 TAD (6211 /BUILD CDF + 646 00452 3253 DCA STFLD3 + 647 00453 7000 STFLD3, NOP + 648 00454 2034 ISZ LEN /END OF BUFFER? + 649 00455 7410 SKP /NO + 650 00456 5306 JMP ENDBK /YES + 651 00457 1433 TAD I LOC + 652 00460 1041 TAD CHKSM + 653 00461 3041 DCA CHKSM + 654 00462 1433 TAD I LOC + 655 00463 7006 RTL + 656 00464 7006 RTL + 657 00465 0040 AND C360 + 658 00466 1036 TAD TEMP + 659 00467 4311 JMS PUN + 660 00470 7300 CLA CLL + 661 00471 1433 TAD I LOC + 662 00472 7012 RTR + 663 00473 7012 RTR + 664 00474 4311 JMS PUN + 665 00475 2033 ISZ LOC + 666 00476 5303 JMP STFLD4+1 /NOT AT END OF FIELD (DJG) + 667 00477 6214 RDF + 668 00500 1375 TAD (6211 /BUILD CDF + 669 00501 3302 DCA STFLD4 + 670 00502 7000 STFLD4, NOP + 671 00503 2034 ISZ LEN + 672 00504 5230 JMP OUT + 673 00505 5622 JMP I OUTBLK + 674 00506 1036 ENDBK, TAD TEMP /SEND LAST PART OF WORD + 675 00507 4311 JMS PUN + 676 00510 5622 JMP I OUTBLK + 677 + 678 00511 0000 PUN, 0 / Send byte out serial port + 679 / PLS / Punch for testing with emulator + 680 00512 6046 TLS2 / Send out console + 681 00513 7300 CLA CLL + 682 00514 1027 TAD CBLOCK + 683 / PSF + 684 00515 6041 TSF2 /Wait until character sent + 685 00516 5315 JMP .-1 + 686 00517 7200 CLA + 687 00520 5711 JMP I PUN + 688 + 00575 6211 + 00576 0377 + + + + / TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code fro Page 15 + + + 00577 0270 + 00177 0200 + 689 $ + + No detected errors + 12 links generated diff --git a/DumpDT18/dumpdt18.pal b/DumpDT18/dumpdt18.pal new file mode 100644 index 0000000..a3148c1 --- /dev/null +++ b/DumpDT18/dumpdt18.pal @@ -0,0 +1,689 @@ +/ TD8E 18-bit DECtape DUMP Program. Based on DUMPREST code from D. Gesswein +/ (see ftp://ftp.pdp8online.com/software/dumprest). +/ Modified for 18-bit DECtape w/standard checksum imaging by J. Dersch +/ +/ This program will send a DECtape image out the console port. +/ The format of the data sent is 0xff (0377) or 0xfd if read error +/ followed by 384 12-bit words (256 18-bit words) of data for each block. +/ After the last block a 0xfe (0376) is sent +/ with a two byte checksum, low 8 bits first then upper 4. +/ The words in a block are sent as three bytes for each 2 words. +/ 1 = low 8 bits first word +/ 2 = upper 4 bits first and lower 4 bits second +/ 3 = upper 8 bits second word +/ +/ The program (PC) receiving the data should be started before this program. +/ +/ To run, start at 0200. +/ SR 11 should be drive, only 0 and 1 supported without reassembling +/ SR 6-8 should be maximum memory field in computer, needs 8k minimum +/ +/ The receiving program should be running first. +/ At normal exit hitting cont will restart the program. +/ +/ Should halt at label finish (140) with number of recoverable errors in AC +/ The current block being read will be displayed in the AC +/ while running. +/ +/ The PC program will print out the bad location if an error occurs. +/ +/ We will retry each read up to four times on error. +/ +/ This transfers the standard 256 word by 578 blocks used by 18-bit DEC hardware, +/ using standard checksums (as used by the PDP-9 and later machines). +/ It will read as many blocks are present up to the forward end-zone, so it will +/ handle tapes that vary from the standard 1102(8) block length. +/ + INAD=030 / Address of serial input, 30 for console + KCF2=6000 INAD + KSF2=6001 INAD + KCC2=6002 INAD + KRS2=6004 INAD + KIE2=6005 INAD + KRB2=6006 INAD + + OUTAD=040 / Address of serial output, 40 for console + TFL2=6000 OUTAD + TSF2=6001 OUTAD + TCF2=6002 OUTAD + TPC2=6004 OUTAD + TSK2=6005 OUTAD + TLS2=6006 OUTAD + + +/CODE BASED ON: +/2 TD8E INITIALIZER PROGRAM, V7A +/ +/COPYRIGHT (C) 1975, 1977 +/DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. +/ +/ +/ +/THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A +/SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLU- +/SION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ANT OTHER +/COPIES THEREOF, MAY NOT BR PROVIDED OR OTHERWISE MADE AVAILABLE +/TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO +/AGREES TO THESE LICENSE TERMS. TITLE TO AND OWNERSHIP OF THE +/SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC. +/ +/ +/THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT +/NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL +/EQUIPMRNT COROPATION. +/ +/DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS +/SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. +/ +/ +/ +/ +/ +/ + +/DECEMBER 21, 1973 GB/RL/EF/SR + +/ABSTRACT-- +/ THE ROUTINE DESCRIBED AND LISTED HERE IS A GENERAL +/DATA HANDLER FOR THE TD8E DECTAPE SYSTEM. THE ROUTINE +/CONTAINS SEARCH, READ, AND WRITE FUNCTIONS IN A FORMAT +/WHICH IS COMPATIBLE WITH OS/8 DEVICE HANDLER CALLING +/SEQUENCES. + +/FIXES SINCE FIELD-TEST RELEASE: + +/1. FIXED BUG RE CLA ON RETRY AFTER ERROR +/2. ALLOWED FINAL BOOTSTRAP TO BE INTO A WRITE-LOCKED DEVICE + +/OS/8 V3D CHANGES: + +/3. FIXED BUG RE TD8E BUILD (V6B PATCH) + +/THIS ROUTINE CAN BE RE-EDITED AND ASSEMBLED TO PRODUCE +/VARIATIONS ON THE BASIC TD8E SYSTEM. ASSEMBLY PARAMETERS +/CONTROL: +/A) WHAT DRIVES (UNITS 0-7) WILL BE USED +/B) THE ORIGIN OF THE TWO PAGE ROUTINE +/C) WHAT MEMORY FIELD THE ROUTINE WILL RUN IN +/D) THE SIZE OF THE DECTAPE BLOCK TO BE READ/WRITTEN + +/FOLLOWING ARE THE PARAMETERS SET UP FOR THE STANDARD +/DEC VERSION OF THIS ROUTINE: + + DRIVE=10 /UNITS 0 AND 1 SELECTED + ORIGIN=600 /ENTER AT ORIGIN, ORIGIN+4 + AFIELD=0 /INITIAL FIELD SETTING + MFIELD=00 /AFIELD*10=MFIELD + WDSBLK=600 /384 12-BIT WORDS PER BLOCK (256 18-BIT DATA WORDS) + +/THE USE OF THE PARAMETERS IS AS FOLLOWS: + +/ DRIVE: DRIVE DETERMINES WHICH UNITS WILL BE SELECTED +/ DRIVE=10 IMPLIES UNITS 0 &1 +/ DRIVE=20 IMPLIES UNITS 2&3 +/ DRIVE=30 IMPLIES UNITS 4&5 +/ DRIVE=40 IMPLIES UNITS 6&7 + +/ORIGIN: ALTERING ORIGIN CAUSES ASSEMBLY IN A DIFFERENT +/ MEMORY LOCATION. WHEN CHANGING ORIGIN KEEP IN MIND +/THAT THIS IS A TWO PAGE ROUTINE. + +/AFIELD: AFIELD DETERMINES THE INITIAL FIELD SETTING FOR THE +/ LOADER. PERMISSIBLE VALUES FOR AFIELD ARE 0 TO 7. + +/MFIELD: MFIELD IS USED IN A CIF CDF MFIELD INSTRUCTION. +/ THE VALUE INSERTED FOR MFIELD SHOULD BE 10(8) TIMES +/ THE VALUE FOR AFIELD. THE PERMISSIBLE VALUES ARE 00-70. + +/WDSBLK: WDSBLK GOVERNS HOW MANY WORDS THE ROUTINE THINKS ARE +/ IN A DECTAPE BLOCK. THE STANDARD VALUE IS 201(8) OR +/ 128 DECIMAL. NOTE THAT THE FUNCTION WORD BIT 10 CAN +/ 129 DECIMAL ??? (DJG) +/ BE USED TO SUBTRACT ONE FROM WDSBLK. THE VALUE USED +/ FOR WDSBLK SHOULD BE THE NUMBER OF WORDS THE TAPE WAS +/ FORMATTED TO CONTAIN. + +/IF WE WANT A HANDLER FOR UNITS 2&3 TO RESIDE IN +/FIELD 2 AT LOCATION 3000 AND READ/WRITE 256(10) WORDS +/PER BLOCK, THE PARAMETERS WOULD BE: +/ DRIVE=20 +/ ORIGIN=3000 +/ AFIELD=2 +/ MFIELD=20 +/ WDSBLK=400 + /THE CALL TO THE SUBROUTINE FOLLOWS BASICALLY THE +/CALLING SEQUENCE FOR OS/8 DEVICE HANDLERS. +/THE CALLING SEQUENCE IS: + +/ CDF CURRENT +/ CIF MFIELD /MFIELD=FIELD ASSEMBLED IN +/ JMS ENTRY /ENTRY=ORIGIN (EVEN NUMBERED DRIVE + /AND ORIGIN+4 FOR ODD NUMBERED DRIVE. +/ ARG1 +/ ARG1B (DJG) +/ ARG2 +/ ARG3 +/ ERROR RETURN +/ NORMAL RETURN + +/THE ARGUMENTS ARE: + +/ARG1: FUNCTION WORD BIT0: 0=READ, 1=WRITE +/ BITS 1-5: UNUSED, WAS # BLOCKS IN OPERATION (DJG) +/ BITS 6-8: FIELD OF BUFFER AREA +/ BIT 9: UNUSED +/ BIT 10: # OF WORDS/BLOCK. +/ 0= WDSBLK, 1=WDSBLK-1 +/ BIT 11: 1=START FORWARD, 0=REVERSE +/ARG1A: # OF BLOCKS IN OPERATIONA (DJG) +/ARG2: BUFFER ADDRESS FOR OPERATION +/ARG3: STARTING BLOCK FOR OPERATION + +/ERRORS: THE HANDLER DETECTS TWO TYPES OF ERRORS: +/A) FATAL ERRORS- PARITY ERROR, TIMING ERROR, +/ TOO GREAT A BLOCK NUMBER +/ FATAL ERRORS TAKE ERROR RETURN WITH THE +/ AC=4000. +/B) NON-FATAL- SELECT ERROR. +/ IF NO PROPER UNIT IS SELECTED, THE ERROR +/ RETURN IS TAKEN WITH CLEAR AC. +/FATAL ERRORS TRY THREE TIMES BEFORE TAKING ERROR RETURN. +/THE NORMAL RETURN IS TAKEN AFTER ALL INDICATED +/BLOCKS HAVE BEEN TRANSFERRED. THE AC IS CLEAR. + +/THE TD8E IOT'S ARE: + SDSS=7001-DRIVE /SKIP ON SINGLE LINE FLAG + SDST=7002-DRIVE /SKIP ON TIMING ERROR + SDSQ=7003-DRIVE /SKIP ON QUAD LINE FLAG + SDLC=7004-DRIVE /LOAD COMMAND REGISTER + SDLD=7005-DRIVE /LOAD DATA REGISTER + SDRC=7006-DRIVE /READ COMMAND REGISTER + SDRD=7007-DRIVE /READ DATA REGISTER + +/THE IOT'S IN GENERAL ARE 677X,676X,675X,AND 674X. +/THE OTHERS CONTROL UNITS 2-7. + +/ THIS HANDLER USES DECTAPE BLOCKS NOT OS/8 BLOCKS ! + + *ORIGIN + +/ MODIFIED SO BIT 0 ON ENTRY IS UNIT 1 +DTA0, 0 + DCA UNIT /SAVE UNIT POSITION + RDF + TAD C6203 /GET DATA FIELD AND SETUP RETURN + DCA LEAVE + TAD I DTA0 /GET FUNCTION WORD + SDLD /PUT FUNCTION INTO DATA REGISTER + CLA + TAD MWORDS + DCA WCOUNT /STORE MASTER WORD COUNT + ISZ DTA0 /TO BLOCK COUNT (DJG) + TAD I DTA0 / (DJG) + CIA / (DJG) + DCA PGCT / (DJG) + ISZ DTA0 /TO BUFFER + TAD I DTA0 + DCA XBUFF /SAVE ADDRESS (DJG) + ISZ DTA0 /TO BLOCK NUMBER + TAD I DTA0 + DCA BLOCK + ISZ DTA0 /POINT TO ERROR EXIT + CIF CDF MFIELD /TO ROUTINES DATA FIELD + SDRD + AND C70 /GET FIELD FOR XFER + TAD C6201 /FORM CDF N + DCA XFIELD /IF=0 AND DF=N AT XFER. + TAD UNIT /TEST FOR SELECT ERROR + SDLC + CLA / Moved here because my drive 1 is slow selecting + TAD RETRY + DCA TRYCNT /3 ERROR TRIES + SDRC + AND C100 + SZA CLA + JMP FATAL-1 + SDRD /PUT FUNCT INTO XFUNCT IN SECOND PG. + DCA I CXFUN + TAD WCOUNT + DCA I CXWCT + SDRD /GET MOTION BIT TO LINK + CLL RAR +XFIELD, HLT /INTO NEXT PAGE + JMP GO /AND START THE MOTION. +RWCOM, SDST /ANY CHECKSUM ERRORS? + SZA CLA /OR CHECKSUM ERRORS? + JMP TRY3 /PLEASE NOTE THAT THE LINK IS ALWAYS + /SET AT RWCOM. GETCHK SETS IT. + ISZ PGCT / (DJG) + SKP / (DJG) + JMP EXIT /ALL DONE. GET OUT + ISZ BLOCK /NEXT BLOCK TO XFER + CLL CML /FORCES MOTION FORWARD +GO, CLA CML RTR /LINK BECOMES MOTION BIT + TAD C1000 + TAD UNIT /PUT IN 'GO' AND UNIT # + SDLC /LOOK FOR BLOCK NO. + CLA + TAD XBUFF + DCA OLDBUF + RDF + TAD C6201 + DCA OLDFLD + JMS I CRDQUD /WAIT AT LEAST 6 LINES TO LOOK + JMS I CRDQUD +CM200, 7600 /COULD HAVE SAVED A LOC. HERE +SRCH, SDSS + JMP .-1 /WAIT FOR SINGLE LINE FLAG + SDRC + CLL RTL /DIRECTION TO LINK. INFO BITS + /ARE SHIFTED. + AND C374 /ISOLATE MARK TRACK BITS + TAD M110 /IS IT END ZONE? + SNA /THE LINK STAYS SAME THRU THIS + JMP ENDZ + TAD M20 /CHECK FOR BLOCK MARK + SZA CLA + JMP SRCH + SDRD /GET THE BLOCK NUMBER + SZL /IF WE ARE IN REVERSE, LOOK FOR 3 + /BLOCKS BEFORE TARGET BLOCK. THIS + /ALLOWS TURNAROUND AND UP TO SPEED. + TAD C3 /REVERSE + CMA + TAD BLOCK + CMA /IS IT RIGHT BLOCK? + SNA + JMP FOUND /YES..HOORAY! +M110, SZL SNA CLA /NO, BUT ARE WE HEADED FOR IT? + /ABOVE SNA IS SUPERFLUOUS. + JMP SRCH /YES + SDRC /NO, TURN US AROUND. + CLL RTL /DIRECTION TO LINK + CLA /THIS CODE USED TO BE SHARED WITH ENDZ, + JMP GO /BUT NOW ENDZ HANDLES END OF TAPE CASES ONLY. +ENDZ, SDRC /WE ARE IN THE END ZONE + CLL RTL /DIRECTION TO LINK + SZL CLA /ARE WE IN REVERSE? + JMP GO /YES..TURN US AROUND + TAD BLOCK /IF WE ARE ON BLOCK ZERO, IT IS POSSIBLE FOR US TO BE AT THE + /REVERSE ENDZONE GOING FORWARD, EITHER DUE TO A RETRY OR BECAUSE + /THE TAPE WAS STARTED IN A POSITION BEFORE THE END ZONE. + /THESE CASES SHOULD NOT BE TREATED AS END-OF-TAPE. + SZA CLA + JMP ENDEX /END OF TAPE. STOP THE UNIT AND TAKE THE END EXIT. + JMP GO + +TRY3, CLA +OLDFLD, NOP + TAD OLDBUF + DCA XBUFF + ISZ TRYCNT + JMP GO /TRY 3 TIMES + JMP FATAL /LINK OFF MEANS AC=4000 ON RETURN +EXIT, ISZ DTA0 /TAKE THE NORMAL RETURN + CLL CML /AC=0 ON NORMAL RETURN +FATAL, ISZ DTA0 /TAKE THE ERROR RETURN +ENDEX, TAD UNIT + SDLC /STOP THE UNIT + CLA CML RAR +LEAVE, HLT + JMP I DTA0 + + +C6203, 6203 +C6201, 6201 +CRDQUD, RDQUAD +CXFUN, XFUNCT +C100, 100 +C1000, 1000 + + + / NOTE THAT THE ABOVE CODE SEGMENT COMES VERY CLOSE TO TOUCHING + / THIS ONE, AND THIS ONE MUST RESIDE AT THE END OF THIS PAGE. + / BE CAREFUL ADDING NEW CODE TO THE ABOVE PAGE. + *ORIGIN+172 +FOUND, SZL CLA /RIGHT BLOCK. HOW ABOUT DIRECTION? + JMP GO /WRONG..TURN AROUND + TAD UNIT /PUT UNIT INTO LINK + CLL RAL /AC IS NOW 0 +C70, 70 /********DON'T MOVE THIS!!!!****** +C3, 3 + /INTO NEXT PAGE + *ORIGIN+200 + CIF MFIELD + RAR /NOW GET UNIT # + DCA XUNIT + SDRC + SDLC +REVGRD, SDSS + JMP .-1 /LOOK FOR REVERSE GUARD + SDRC + AND K77 + TAD CM32 /IS IT REVERSE GUARD? + SZA CLA + JMP REVGRD /NO.KEEP LOOKING + TAD XWCT + DCA WORDS /WORD COUNTER + TAD XFUNCT /GET FUNCTION READ OR WRITE +K7700, SMA CLA + JMP READ /NEG. IS WRITE +WRITE, HLT /WRITE CODE REMOVED +K77, 77 /ABOVE MAY SKIP (NOT ANYMORE DJG) +READ, JMS RDQUAD + JMS RDQUAD + JMS RDQUAD /SKIP CONTROL WORDS + AND K77 + TAD K7700 /TACK 7700 ONTO CHECKSUM. + DCA CHKSUM /CHECKSUM ONLY LOW 6 BITS ANYWAY +RDLP, JMS RDQUAD + JMS EQUFUN /COMPUT CHECKSUM AS WE GO + DCA I XBUFF /IT GETS CONDENSED LATER + ISZ XBUFF /AT END OF FIELD? + JMP STFLD2+1 /NOT AT END OF FIELD (DJG) + RDF + TAD (6211 + DCA STFLD2 +STFLD2, NOP + ISZ WORDS /DONE THIS OP? + JMP RDLP /NO SUCH LUCK + TAD XFUNCT /IF OP WAS FOR WDSBLK-1, READ AND + CLL RTR /CHECKSUM THE LAST TAPE WORD + SNL CLA + JMP RDLP2 + JMS RDQUAD /NOT NEEDED FOR WDSBLK/BLOCK + JMS EQUFUN /CHECKSUM IT +RDLP2, JMS RDQUAD /READ CHECKSUM + AND K7700 + JMS EQUFUN + JMS GETCHK /GET SIX BIT CHECKSUM + JMP I CRWCOM +C300, 300 /PROTECTION (NOT ANYMORE DJG) + +RDQUAD, 0 /READ A 12 BIT WORD + SDSQ + JMP .-1 + SDRD /READ DATA + JMP I RDQUAD + +XUNIT, +EQUFUN, 0 /COMPUTE EQUIVALENCE CHECKSUM + CMA + DCA EQUTMP /ACTUALLY CHECKSUMS ON DECTAPE ARE + TAD EQUTMP /EQUIVALENCE OF ALL WORDS IN A RECORD + AND CHKSUM /SIX BITS AT A TIME. BUT SINCE EQUIVALENCE + CIA /IS ASSOCIATIVE, WE CAN DO IT 12 + CLL RAL /BITS AT A TIME AND CONDENSE LATER. + TAD EQUTMP /THIS ROUTINE USES THESE IDENTITIES: + TAD CHKSUM /A+B=(A.XOR.B)+2*(A.AND.B) + DCA CHKSUM /A.EQU.B=.NOT.(A.XOR.B)=A.XOR.(.NOT.B) + TAD EQUTMP /A.EQU.B=(A+(.NOT.B))-2*(A.AND.(.NOT.B)) + CMA + JMP I EQUFUN + +GETCHK, 0 /FORM 6 BIT CHECKSUM + CLA + TAD CHKSUM + CMA + CLL RTL + RTL + RTL + JMS EQUFUN + CLA CLL CML /FORCES LINK ON AT RWCOM + TAD CHKSUM + AND K7700 + JMP I GETCHK + +CFATAL, FATAL +CRWCOM, RWCOM +XFUNCT, 0 +CM32, -32 +C1400, 1400 +CHKSUM, 0 +WORDS, 0 +XWCT, 0 +EQUTMP, 0 + + *20 +RETRY, 7774 / RETRY UP TO 4 TIME +NUMBLK, 3777 / MAX NUMBER OF BLOCKS TO ATTEMPT READING. BY DEFAULT THIS PROGRAM WILL READ UNTIL + / IT HITS THE END OF THE TAPE (FORWARD ENDZONE). IF YOU NEED TO LIMIT THE NUMBER OF BLOCKS + / READ, MODIFY THIS VALUE. +MWORDS, -WDSBLK / WORDS PER BLOCK +WCOUNT, 0 +BLKFLD, 12 / 10 386 WORD BLOCKS OF 12-BIT WORDS, EQUIVALENT TO 256 18-BIT WORDS. + / WRAPPING PAST END OF LAST FIELD DOESN'T WORK +FIELDS, 0 +RDSIZE, 0 / NUMBER BLOCKS PER READ +CBLOCK, 0 / CURRENT BLOCK TO XFER +CLKSUM, 0 +DRVSEL, 0 +READST, 377 +LOC, 0 +LEN, 0 +BCNT, 0 / BLOCKS TO SEND TO PC +TEMP, 0 +C17, 17 +C360, 360 +CHKSM, 0 +ERRCN2, 0 +OLDBUF, 0 / BELOW ARE USED BY DTA0 ROUTINE +XBUFF, 0 +C374, 374 +BLOCK, 0 +UNIT, 0 +TRYCNT, -3 +PGCT, 0 +CXWCT, XWCT +M20, -20 + + *140 +FINISH, HLT / Normal good halt + JMP START + + *200 +START, CDF 0 + CAF + CLA CLL OSR / Get drive + AND (1 + RTR + DCA DRVSEL + CLA CLL OSR / Get max field + RTR + RAR + AND (7 + SNA + HLT / Must have at least 1 field for buffer + CIA + DCA FIELDS + DCA ERRCN2 +RDSZLP, TAD BLKFLD / Multiply by number of fields available + ISZ FIELDS + JMP RDSZLP + DCA RDSIZE / NUMBER BLOCK PER READ + DCA CBLOCK + DCA CHKSM + +DUMPLP, CLA + TAD RDSIZE + TAD CBLOCK + CIA + TAD NUMBLK / MORE BLOCKS LEFT THAN READSIZE? + SMA / NO, READ NUMBER LEFT + CLA / YES, ONLY READ RDSIZE + TAD RDSIZE + SNA / ANY MORE BLOCKS? + JMP DONE / NO, DO FINISH STUFF + DCA ARGSZ + TAD CBLOCK + DCA ARGBK + TAD DRVSEL + JMS DTA0 + 0010 / READ STARTING IN FIELD 1 +ARGSZ, 0 + 0 +ARGBK, 0 + JMP ENDRET / TAKEN WHEN END OF TAPE IS HIT + JMP ERRRET / TAKEN WHEN AN ERROR IS ENCOUNTERED + TAD (377 / All blocks good + DCA READST + / Send data, each block starts with FF + CLA CLL / then 2 12 bit words in 3 bytes + DCA LOC / ERRRET DUPLICATES SOME OF THIS + TAD ARGSZ + CIA + DCA BCNT / Setup loop counter with number blocks read + CDF 10 +OUTBL1, JMS OUTBLK / Send a block + ISZ CBLOCK + ISZ BCNT / Send all read? + JMP OUTBL1 / No + CDF 0 + JMP DUMPLP / Go read next batch + + +DONE, CLA / Send FE and -checksum of all words + TAD (376 + JMS PUN + CLA CLL + TAD CHKSM / Send checksum in two bytes, low bits first + CIA + JMS PUN + CLA CLL + TAD CHKSM + CIA + RTR + RTR + RTR + RTR + AND C17 + JMS PUN + CLA + TAD DRVSEL + JMS DTA0 / REWIND TAPE + 0010 + 1 + 0 + 0 + NOP + NOP + TAD ERRCN2 / Leave AC with # of errors + JMP FINISH + + /SEND GOOD BLOCKS READ WITH GOOD BLOCK FLAG + /THEN BAD WITH BAD BLOCK FLAG. +ERRRET, +/ HLT / ****** If we want to stop on error + CDF 10 + CLA CLL + DCA LOC + TAD CBLOCK + CIA + TAD BLOCK /Get - number good blocks read + CIA /Last was bad + SNA + JMP FSTBAD /First block is bad, no good to send + DCA BCNT + TAD (377 + DCA READST +OUTBL2, JMS OUTBLK /Send good blocks + ISZ CBLOCK + ISZ BCNT + JMP OUTBL2 +FSTBAD, TAD (375 /NOW SEND BAD BLOCK + DCA READST + JMS OUTBLK + ISZ CBLOCK + ISZ ERRCN2 + CDF 0 + JMP DUMPLP /And read from here on + + PAGE +ENDRET, /SEND LAST SET OF BLOCKS READ BEFORE END OF TAPE AND FINISH. + CDF 10 + CLA CLL + DCA LOC + TAD CBLOCK + CIA + TAD BLOCK / GET NUMBER OF BLOCKS READ IN LAST BATCH + CMA / +1 to -BCNT SO WE SEND ALL BLOCKS + SNA + JMP DONE / READ ZERO BLOCKS IN LAST BATCH, WE ARE DONE + DCA BCNT + TAD (377 + DCA READST +OUTBL3, JMS OUTBLK / SEND ALL BLOCKS + ISZ CBLOCK + ISZ BCNT + JMP OUTBL3 + CDF 0 + JMP DONE / NO MORE BLOCKS, DONE. + +OUTBLK, 0 /Send a block of data out serial port + CLA + TAD WCOUNT + DCA LEN + TAD READST /Send good/bad flag + JMS PUN +OUT, CLA CLL + TAD I LOC + TAD CHKSM / Keep checksum of all words sent + DCA CHKSM + TAD I LOC / Send 2 words as 3 bytes + JMS PUN + CLA CLL + TAD I LOC + RTR / Shift top 4 bits to low 4 + RTR + RTR + RTR + AND C17 + DCA TEMP + ISZ LOC + JMP STFLD3+1 /NOT AT END OF FIELD (DJG) + RDF /At end, inc to next field + TAD (6211 /BUILD CDF + DCA STFLD3 +STFLD3, NOP + ISZ LEN /END OF BUFFER? + SKP /NO + JMP ENDBK /YES + TAD I LOC + TAD CHKSM + DCA CHKSM + TAD I LOC + RTL + RTL + AND C360 + TAD TEMP + JMS PUN + CLA CLL + TAD I LOC + RTR + RTR + JMS PUN + ISZ LOC + JMP STFLD4+1 /NOT AT END OF FIELD (DJG) + RDF + TAD (6211 /BUILD CDF + DCA STFLD4 +STFLD4, NOP + ISZ LEN + JMP OUT + JMP I OUTBLK +ENDBK, TAD TEMP /SEND LAST PART OF WORD + JMS PUN + JMP I OUTBLK + +PUN, 0 / Send byte out serial port +/ PLS / Punch for testing with emulator + TLS2 / Send out console + CLA CLL + TAD CBLOCK +/ PSF + TSF2 /Wait until character sent + JMP .-1 + CLA + JMP I PUN + + $ diff --git a/DumpPDP7/Program.cs b/DumpPDP7/Program.cs deleted file mode 100644 index df8bfe9..0000000 --- a/DumpPDP7/Program.cs +++ /dev/null @@ -1,15 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace DumpPDP7 -{ - class Program - { - static void Main(string[] args) - { - } - } -}