From dfda271d58baa844d639689032246cd2c41dbae2 Mon Sep 17 00:00:00 2001 From: Josh Dersch Date: Wed, 8 Nov 2017 13:24:43 -0800 Subject: [PATCH] Initial commit --- DumpPDP7.sln => DumpDT18.sln | 2 +- {DumpPDP7 => DumpDT18}/App.config | 0 .../DumpDT18.csproj | 16 +- DumpDT18/Program.cs | 303 ++++++ .../Properties/AssemblyInfo.cs | 0 DumpDT18/dump-old.bin | Bin 0 -> 1238 bytes DumpDT18/dump-old.lst | 854 +++++++++++++++++ DumpDT18/dump-old.pal | 741 +++++++++++++++ DumpDT18/dumpdt18-550.bin | Bin 0 -> 1270 bytes DumpDT18/dumpdt18-550.lst | 887 ++++++++++++++++++ DumpDT18/dumpdt18-550.pal | 768 +++++++++++++++ DumpDT18/dumpdt18.bin | Bin 0 -> 1158 bytes DumpDT18/dumpdt18.lst | 796 ++++++++++++++++ DumpDT18/dumpdt18.pal | 689 ++++++++++++++ DumpPDP7/Program.cs | 15 - 15 files changed, 5053 insertions(+), 18 deletions(-) rename DumpPDP7.sln => DumpDT18.sln (86%) rename {DumpPDP7 => DumpDT18}/App.config (100%) rename DumpPDP7/DumpPDP7.csproj => DumpDT18/DumpDT18.csproj (80%) create mode 100644 DumpDT18/Program.cs rename {DumpPDP7 => DumpDT18}/Properties/AssemblyInfo.cs (100%) create mode 100644 DumpDT18/dump-old.bin create mode 100644 DumpDT18/dump-old.lst create mode 100644 DumpDT18/dump-old.pal create mode 100644 DumpDT18/dumpdt18-550.bin create mode 100644 DumpDT18/dumpdt18-550.lst create mode 100644 DumpDT18/dumpdt18-550.pal create mode 100644 DumpDT18/dumpdt18.bin create mode 100644 DumpDT18/dumpdt18.lst create mode 100644 DumpDT18/dumpdt18.pal delete mode 100644 DumpPDP7/Program.cs 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 0000000000000000000000000000000000000000..777244a2f27b671586e7e5d88ca93f0e8d3f7062 GIT binary patch literal 1238 zcmd^94SSj}5I(@#U|h*?YDU@##flAGajcpIBU!uef3=^!i?-Xd->~F?+;h42eJ{C# zU%&pZ@dV!hfLHC9wqkPu>R?7a*8xfSB!vsm1;6zxUmoA96xv9+sHY#ZnpDbmKp0=E zKHBwpT`RZPlF6l1&JY{Qt?JNQvRg}P$ySDS8CB1yB`;C)qgYlC)k6=;)S>Fl5N_zy zu4_SRM25;)PMyxlO6Tb9dVPxO0J$-`=W~G}^S4+gZM{aPJ5Xc7Rl=gKuR0G$g?rKKWAyCCC31i4B-*^#k@c240K|K@ zdCYCtxF=|X&AA&yPLKFoH_#(ZqTa4;h`lrA*W?YG%7oAOoEO+FGcwl&d40ef$;_^$ z&Thy&tH|5xfTcN(#?}+M=h+^(7~LStRU20wo3ks~wt<}b(^Yy8q|n97imJy6i%KK& zi7oJS+V{ovZQjP7@2I}g1$I-(ue{2Mxn5B9Y+rkg&nh~c#Zf;^BeZ?&JUf literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..8b397dbbd8a5bc40239b2f775b2f3b0d80661ac9 GIT binary patch literal 1270 zcmd^9i3{@b>h>*^BNjp(U+JR&f7&`$xvsD zKe|XgR`%hHiw(;fjU&%h!`4`&230EdwP-^B-S?;+ZJF=wdYhC<*+Eq+sJeOzzxxZ5 zsufC(gvuK7t&VW7Bepi3zIrvl*zDbrJma1{l{`0~0k^ahi99PAKrI3oxX3seXI+jk z^(G@g_|gn)tr0Sf&pLUU)_}&`*i3PbZ4%lsaor&G-#7;hN z_Fec!!vf{~Hcj}PpDZ7{T+8YrxdvIvDqH|FMtg_3yfh=sOe8Ou`z;leQSQ$OYk@_U z-N>l|u!ngc1hdmW?FdS52LJMo3M`K3S~_B(9hOQe*J=k9DJAFjPhUhmxE zS$9pZ*%rX_>i`w$r?w;!P#6*qRwna+spSkE-Nok@+uUG<7$d?{YZJG!SOMSU&q zT0-updtB-me`}%FO)3p{+A>r~iQ&r|Mt)ICzoFFyD4abq+NSi9S}eszK9wW6YQWb? z#Z`!O{4AM$nD8d482O6EuMOM;+&S@MRC+z$z`oZp_gg}np5=dQcK&Ny8q44b7B6Bo}MdkWWpN zZR@69huWF3Od}C<7=4r+2fE`}5R$_^Ik71IPS=oT9a!^gxg9qlDbv~mx zW`eRtFsmb)>IkECqc5l$kQ>pBkb9aUGMD=rG|;73@wMFN(u0b7aMlvW*<#gYhZZjH z0EM6RIWMcam_mL*>1Y}pRHKZlFMBzFO^3*GS-)-Re&N?1b$+ubs(#b`-%8L^yarmb=o;YCh$6vMf7tjJK;YeFPfo_|2l~dBY;p z$b4bzv~;?iWwMD%x8*ylr#i+LuoQQ#%7r;!F!kyut;SbHPFF5zx*oAz=mGSh^9}yt zz*n@h$kB)(@y^u^%gzq_hWfsk(_o2;!;r=z9)=hHy-IP