Retro/pcjs
Watch
1
0
Fork
You've already forked pcjs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into gh-pages

Browse source
This commit is contained in:
Jeff Parsons 2017-02-04 15:53:43 -08:00
commit f39608efde
44 changed files with 1991 additions and 781 deletions
Download patch file Download diff file Expand all files Collapse all files

2
apps/pdp11/tapes/README.md
View file

@ -42,7 +42,7 @@ p. 155, "PAPER TAPE SOFTWARE", the following software was available on paper tap
- [IOX](iox/) (PDP-11 Input/Output eXecutive)
- [PDP-11 BASIC](basic/) (Beginners All-purpose Symbolic Instruction Code)
There was a separate DEC publication, [PDP-11 Paper Tape Software Handbook](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Paper_Tape_Software_Handbook.pdf),
There was a separate DEC publication, [PDP-11 Paper Tape Software Handbook](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Paper_Tape_Software_Handbook_1976.pdf),
that described all of the above software in greater detail, and it included some programs that the 1971 Handbook listed under
"Disk Operating System" instead of "Paper Tape System", such as:

4
apps/pdp11/tapes/absloader/README.md
View file

@ -43,7 +43,7 @@ we know about the "Absolute Format":
[Other sites](http://www.retrocmp.com/stories/dec-pc05-papertape/242-dec-pc05-working-with-paper-tapes)
have referred to this tape format as the "Standard Absolute" format, but I've not found that terminology
used in any DEC publication. In fact, I think that term may have arisen from a misreading of instructions
found in DEC manuals like the ["MEM EXER 16K" Diagnostics Manual](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Mem-Exer-16k_Feb78.pdf):
found in DEC manuals like the ["MEM EXER 16K" Diagnostics Manual](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-9045F-MC_CZQMCFO_MEM_EXER_16K_Feb78.pdf):
Load the program using any standard absolute loader.
@ -54,5 +54,5 @@ for which a specific address has been selected, based on the amount of RAM prese
PCjs has archived the following Absolute Loader resources:
- [Absolute Loader](DEC-11-L2PC-PO.json)
- [LISTING OF PDP-11 ABSOLUTE LOADER (June 1975)](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Absolute_Loader_Listing_Jun75.pdf)
- [LISTING OF PDP-11 ABSOLUTE LOADER (June 1975)](http://archive.pcjs.org/pubs/dec/pdp11/other/DEC-11-UABLA_ABSOLUTE_LOADER_LISTING_Jun75.pdf)
- "APPENDIX D: THE BOOTSTRAP AND ABSOLUTE LOADERS" from the [PDP-11 BASIC PROGRAMMING MANUAL (December 1970)](http://archive.pcjs.org/pubs/dec/pdp11/basic/BASIC_Programming_Manual_Dec70.pdf)

53
apps/pdp11/tapes/basic/README.md
View file

@ -15,8 +15,8 @@ DEC PDP-11 BASIC
[![DEC-11-AJPB-PB](DEC-11-AJPB-PB.jpg)](DEC-11-AJPB-PB.json)
According to the [PDP-11/20 Handbook (1971)](http://archive.pcjs.org/pubs/dec/pdp11/1120/PDP1120_Handbook_1971.pdf), p. 160,
notable features of PDP-11 BASIC included:
According to the [PDP-11/20 Handbook (1971)](http://archive.pcjs.org/pubs/dec/pdp11/1120/PDP1120_Handbook_1971.pdf),
p. 160, notable features of PDP-11 BASIC included:
- Use of BASIC statements in immediate mode (no line number)
- Ability to use any BASIC command (RUN, LIST, etc.) in deferred mode (with a line number)
@ -47,19 +47,19 @@ Debugging Notes
### PDPjs Debugger vs. SIMH
When I first tried to run BASIC in a PDPjs machine, it crashed almost immediately. It was attempting to use memory beyond
the 16Kb of installed RAM. After a bit of poking around, I found BASIC's memory sizing code here:
When I first tried to run BASIC in a PDPjs machine, it crashed almost immediately. It was attempting to use memory
beyond the 16Kb of installed RAM. After a bit of poking around, I found BASIC's memory sizing code here:
016142: 012701 160000 MOV #160000,R1
016146: 022626 CMP (SP)+,(SP)+
016150: 014111 MOV -(R1),@R1
The code sets R1 to highest possible RAM address and starts scanning backwards for the first valid memory location. However,
the scanning process wasn't clear to me at first glance, and the `CMP (SP)+,(SP)+` was a bit of a head-scratcher, so I decided
to do an instruction-by-instruction comparison with SIMH.
The code sets R1 to highest possible RAM address and starts scanning backwards for the first valid memory location.
However, the scanning process wasn't clear to me at first glance, and the `CMP (SP)+,(SP)+` was a bit of a
head-scratcher, so I decided to do an instruction-by-instruction comparison with SIMH.
After cloning the [SIMH project](https://github.com/simh/simh) and building the *pdp11* binary, I created a *pdp11.ini* text file
that contained:
After cloning the [SIMH project](https://github.com/simh/simh) and building the *pdp11* binary, I created a *pdp11.ini*
text file that contained:
ECHO Configuring PDP-11/20 with 16Kb of RAM...
SET CPU 11/20
@ -154,15 +154,15 @@ After typing several "do tr" commands, I was surprised to see SIMH execution con
Step expired, PC: 016150 (MOV -(R1),(R1))
until I remembered that when the PDP-11 accesses an invalid address, it's supposed to trap to vector 000004, and that BASIC
must have modified vector 000004 to jump into the middle of this code.
until I remembered that when the PDP-11 accesses an invalid address, it's supposed to trap to vector 000004, and that
BASIC must have modified vector 000004 to jump into the middle of this code.
This code fragment was simply marching down the address space until it reached an address that didn't trap. The odd-looking
`CMP (SP)+,(SP)+` instruction was throwing away the PC and PSW that each trap pushed onto the stack, by effectively adding
4 to SP.
This code fragment was simply marching down the address space until it reached an address that didn't trap. The
odd-looking `CMP (SP)+,(SP)+` instruction was throwing away the PC and PSW that each trap pushed onto the stack, by
effectively adding 4 to SP.
The problem with PDPjs was that it wasn't generating a trap to vector 000004 when an invalid address was accessed. After fixing
that, I verified with the PDPjs Debugger that the memory sizing code was working properly:
The problem with PDPjs was that it wasn't generating a trap to vector 000004 when an invalid address was accessed.
After fixing that, I verified with the PDPjs Debugger that the memory sizing code was working properly:
PDPjs v1.30.1
Copyright © 2012-2016 Jeff Parsons <Jeff@pcjs.org>
@ -263,18 +263,19 @@ When the code starts, the TRAP instruction has already pushed two words onto the
0(SP): previous PC
2(SP): previous PSW
The first instruction, `MOV @SP,2(SP)`, copies the *previous PC* onto the *previous PSW*, which is where we'll eventually want
*previous PC*, so that the handler can eventually return with a simple `RTS PC`.
The first instruction, `MOV @SP,2(SP)`, copies the *previous PC* onto the *previous PSW*, which is where we'll
eventually want *previous PC*, so that the handler can eventually return with a simple `RTS PC`.
The next instruction, `SUB #2,@SP`, subtracts 2 from the original *previous PC*, so that it now points to the TRAP instruction.
The next instruction, `SUB #2,@SP`, subtracts 2 from the original *previous PC*, so that it now points to the TRAP
instruction.
Then `@(SP)+,-(SP)` fetches the TRAP instruction while also "popping" the original *previous PC* and then "pushing" TRAP
instruction onto the stack, overwriting the original *previous PC*.
Then `@(SP)+,-(SP)` fetches the TRAP instruction while also "popping" the original *previous PC* and then "pushing"
TRAP instruction onto the stack, overwriting the original *previous PC*.
The next few instructions shift the TRAP right to see if bit 0 is set, and if it is not, then the TRAP instruction is restored
by shifting it left again, and then a large offset is added to it, transforming the TRAP instruction (which is now known to be
an *even* value) into a jump table index.
The next few instructions shift the TRAP right to see if bit 0 is set, and if it is not, then the TRAP instruction
is restored by shifting it left again, and then a large offset is added to it, transforming the TRAP instruction (which
is now known to be an *even* value) into a jump table index.
The final instruction, `MOV @(SP)+,PC`, moves the address at the jump table index into PC, while also removing the TRAP
instruction from the stack, leaving only the *previous PC* on the stack, so that when the TRAP handler is done, it can execute
`RTS PC` to return to the caller.
instruction from the stack, leaving only the *previous PC* on the stack, so that when the TRAP handler is done, it can
execute `RTS PC` to return to the caller.

2
devices/pdp11/README.md
View file

@ -12,7 +12,7 @@ PDP-11 Device Configurations
* [Control Panels](panel/)
* Serial Interface for Display Terminals [(DL11)](dl11/)
* High-Speed Paper Tape Reader/Punch [(PC11)](pc11/)
* Disk Controllers ([RK11](rk11/), [RL11](rl11/))
* Disk Controllers ([RK11](rk11/), [RL11](rl11/), [RX11](rx11/))
* [ROM Images](rom/)
Sample machines include a

1
devices/pdp11/machine/1170/panel/debugger/machine.xml
View file

@ -11,6 +11,7 @@
<panel ref="/devices/pdp11/panel/1170/debugger/front.xml"/>
<debugger id="debugger" base="8" messages="" commands=""/>
<device ref="/devices/pdp11/pc11/default.xml"/>
<device ref="/devices/pdp11/rx11/default.xml"/>
<device ref="/devices/pdp11/rk11/default.xml"/>
<device ref="/devices/pdp11/rl11/default.xml"/>
</machine>

1
devices/pdp11/machine/1170/panel/machine.xml
View file

@ -10,6 +10,7 @@
<serial id="dl11" adapter="0" binding="print"/>
<panel ref="/devices/pdp11/panel/1170/front.xml"/>
<device ref="/devices/pdp11/pc11/default.xml"/>
<device ref="/devices/pdp11/rx11/default.xml"/>
<device ref="/devices/pdp11/rk11/default.xml"/>
<device ref="/devices/pdp11/rl11/default.xml"/>
</machine>

1
devices/pdp11/machine/1170/vt100/debugger/machine-left.xml
View file

@ -10,6 +10,7 @@
<panel ref="/devices/pdp11/panel/1170/debugger/front.xml"/>
<debugger id="debugger" base="8" messages="" commands=""/>
<device ref="/devices/pdp11/pc11/default.xml"/>
<device ref="/devices/pdp11/rx11/default.xml"/>
<device ref="/devices/pdp11/rk11/default.xml"/>
<device ref="/devices/pdp11/rl11/default.xml"/>
</machine>

1
devices/pdp11/machine/1170/vt100/debugger/machine-right.xml
View file

@ -10,6 +10,7 @@
<panel ref="/devices/pdp11/panel/1170/debugger/front.xml"/>
<debugger id="debugger" base="8" messages="" commands=""/>
<device ref="/devices/pdp11/pc11/default.xml"/>
<device ref="/devices/pdp11/rx11/default.xml"/>
<device ref="/devices/pdp11/rk11/default.xml"/>
<device ref="/devices/pdp11/rl11/default.xml"/>
</machine>

1
devices/pdp11/machine/1170/vt100/debugger/machine.xml
View file

@ -10,6 +10,7 @@
<panel ref="/devices/pdp11/panel/1170/debugger/front.xml"/>
<debugger id="debugger" base="8" messages="" commands=""/>
<device ref="/devices/pdp11/pc11/default.xml"/>
<device ref="/devices/pdp11/rx11/default.xml"/>
<device ref="/devices/pdp11/rk11/default.xml"/>
<device ref="/devices/pdp11/rl11/default.xml"/>
</machine>

1
devices/pdp11/machine/1170/vt100/machine-left.xml
View file

@ -9,6 +9,7 @@
<serial id="dl11" adapter="0"/>
<panel ref="/devices/pdp11/panel/1170/front.xml"/>
<device ref="/devices/pdp11/pc11/default.xml"/>
<device ref="/devices/pdp11/rx11/default.xml"/>
<device ref="/devices/pdp11/rk11/default.xml"/>
<device ref="/devices/pdp11/rl11/default.xml"/>
</machine>

1
devices/pdp11/machine/1170/vt100/machine-right.xml
View file

@ -9,6 +9,7 @@
<serial id="dl11" adapter="0"/>
<panel ref="/devices/pdp11/panel/1170/front.xml"/>
<device ref="/devices/pdp11/pc11/default.xml"/>
<device ref="/devices/pdp11/rx11/default.xml"/>
<device ref="/devices/pdp11/rk11/default.xml"/>
<device ref="/devices/pdp11/rl11/default.xml"/>
</machine>

1
devices/pdp11/machine/1170/vt100/machine.xml
View file

@ -9,6 +9,7 @@
<serial id="dl11" adapter="0"/>
<panel ref="/devices/pdp11/panel/1170/front.xml"/>
<device ref="/devices/pdp11/pc11/default.xml"/>
<device ref="/devices/pdp11/rx11/default.xml"/>
<device ref="/devices/pdp11/rk11/default.xml"/>
<device ref="/devices/pdp11/rl11/default.xml"/>
</machine>

3
devices/pdp11/pc11/README.md
View file

@ -44,3 +44,6 @@ used to control the device, such as choosing which tape should be "loaded" into
</control>
</device>
```
For details about the PC11 hardware, we relied upon the [PDP-11 Peripherals Handbook (1976)](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Peripherals_Handbook_1976.pdf),
p. 4-376 (p. 408 of the PDF).

5
devices/pdp11/rk11/README.md
View file

@ -7,9 +7,12 @@ permalink: /devices/pdp11/rk11/
RK11 Disk Controller
--------------------
The RK11 Disk Controller controls up to eight RK05 disk drives, which in turn read/write [RK03-KA](/disks/dec/rk03/)
The RK11 Disk Controller controls up to eight RK05 disk drives, which in turn read/write [RK03](/disks/dec/rk03/)
disk cartridges.
RK03 disks are single-platter cartridges with 203 tracks per side, 12 sectors per track, and a sector size of 256 words
(512 bytes), for a total capacity of 2.38Mb (2,494,464 bytes).
Machines containing the [RK11 Component](/modules/pdp11/lib/rk11.js) include:
- [PDP-11/70 with Front Panel](/devices/pdp11/machine/1170/panel/) (with [Debugger](/devices/pdp11/machine/1170/panel/debugger/))

3
devices/pdp11/rk11/default.xml
View file

@ -1,6 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
<device id="rk11" type="rk11" autoMount='{RK0:{path:"http://archive.pcjs.org/disks/dec/rk03/RK03-XXDP.json"}}' pos="left" width="35%" padLeft="8px" padBottom="8px">
<name>Disk Drive Controls</name>
<device id="rk11" type="rk11" autoMountExample='{RK0:{path:"http://archive.pcjs.org/disks/dec/rk03/RK03-XXDP.json"}}' pos="left" width="35%" padLeft="8px" padBottom="8px">
<control type="container">
<control type="list" binding="listDrives"/>
<control type="list" binding="listDisks">

8
devices/pdp11/rl11/README.md
View file

@ -8,7 +8,13 @@ RL11 Disk Controller
--------------------
The RL11 Disk Controller controls up to four RL01 or RL02 disk drives, which in turn read/write
[RL01K](/disks/dec/rl01k/) or [RL02K](/disks/dec/rl02k/) disk cartridges.
[RL01K](/disks/dec/rl01k/) or [RL02K](/disks/dec/rl02k/) disk cartridges, respectively.
RL01K disks are single-platter cartridges with 256 tracks per side, 40 sectors per track, and a sector size of
256 bytes, for a total capacity of 5Mb (5,242,880 bytes).
RL02K disks are single-platter cartridges with 512 tracks per side, 40 sectors per track, and a sector size of
256 bytes, for a total capacity of 10Mb (10,485,760 bytes).
Machines containing the [RL11 Component](/modules/pdp11/lib/pc11.js) include:

175
devices/pdp11/rx11/README.md Normal file
View file

@ -0,0 +1,175 @@
---
layout: page
title: RX11 Disk Controller
permalink: /devices/pdp11/rx11/
---
RX11 Disk Controller
--------------------
The RX11 Disk Controller controls up to two RX01 disk drives, which in turn read/write 8-inch diskettes that DEC
merely describes as "compatible with the IBM 3740 family of equipment." We refer to them simply as RX01 diskettes.
RX01 diskettes are single-sided, with a logical format of 77 tracks, 26 sectors per track, and a sector size of 128
bytes, for a total capacity of 250Kb (256,256 bytes).
> **SIDEBAR**: DEC's [documentation](/pubs/dec/pdp11/rx11/) claims a capacity of "256K bytes", but like many disk drive
manufacturers, they overstated the capacity by treating "K" as 1000 rather than 1024, which was its traditional meaning
within the computer industry at the time. DEC's own processor handbooks, for example, invariably used "K" to mean 1024.
> Since 1998, standards organizations have been pushing the term "kibibyte" (abbreviated KiB) to mean 1024 bytes,
in an effort to redefine the "K" in "Kilobyte" (Kb) as 1000, but that doesn't change what the term commonly meant prior
to 1998.
Machines containing the [RX11 Component](/modules/pdp11/lib/rx11.js) include:
- [PDP-11/70 with Front Panel](/devices/pdp11/machine/1170/panel/) (with [Debugger](/devices/pdp11/machine/1170/panel/debugger/))
- [PDP-11/70 with VT100 Terminal](/devices/pdp11/machine/1170/vt100/) (with [Debugger](/devices/pdp11/machine/1170/vt100/debugger/))
PCjs has archived a selection of [RX01 Disk Images](/disks/dec/rx01/) for use by those machines, which are listed in
the following RX11 Device XML file:
- [Default](/devices/pdp11/rx11/default.xml)
which is typically referenced by a Machine XML file as:
```xml
<device ref="/devices/pdp11/rx11/default.xml"/>
```
Device XML files not only configure a device, but also list all the resource the device will use, and define UI elements
used to control the device, such as choosing which disks should be "auto-mounted" by the RX11 device. For example:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<device id="rx11" type="rx11" pos="left" width="35%" padLeft="8px" padBottom="8px">
<name>Disk Drive Controls</name>
<control type="container">
<control type="list" binding="listDrives"/>
<control type="list" binding="listDisks">
<disk id="disk01" name="RT-11 V3 SYS (1 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-1.json"/>
<disk id="disk01" name="RT-11 V3 SYS (2 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-2.json"/>
<disk id="disk01" name="RT-11 V3 SYS (3 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-3.json"/>
<disk id="disk01" name="RT-11 V3 SYS (4 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-4.json"/>
<disk id="disk01" name="RT-11 V3 SYS (5 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-5.json"/>
<disk id="disk01" name="RT-11 V3 SYS (6 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-6.json"/>
<disk id="disk01" name="RT-11 V3 SYS (7 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-7.json"/>
<disk id="disk01" name="RT-11 V3 SYS (8 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-8.json"/>
<disk id="disk01" name="RT-11 V3 SYS (9 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-9.json"/>
</control>
<control type="button" binding="loadDisk">Load</control>
<control type="button" binding="bootDisk">Boot</control>
<control type="description" binding="descDisk" padRight="8px"/>
<control type="file" binding="mountDisk"/>
</control>
</device>
```
Loading the RX11 Bootstrap
--------------------------
From the [RT-11 v4.0 Installation Manual (March 1981)](/pubs/dec/pdp11/rt11/), p. E-9:
The procedure to deposit the RX11 disk bootstrap loader in memory depends on the type of processor you have.
If your computer is a PDP-11V/03, PDP-11/03, or LSI-11, see the PDP-11/03 user's manual for instructions.
1. Set the ENABLE/HALT switch to HALT.
2. Set the first address, 010000, in the switch register (see Table E-3).
3. Press the LOAD ADDR switch.
4. Set the contents for the first address (from Table E-3) in the switch register.
5. Lift the DEP switch. The computer automatically advances to the next address.
6. Set the contents for the next address (from Table E-3) in the switch register.
7. Lift the DEP switch.
8. Repeat steps 6 and 7 until you have deposited all the instructions.
Now verify that you deposited the bootstrap program properly.
1. Set the first address, 001000, in the switch register.
2. Press the LOAD ADDR switch.
3. Press the EXAM switch to display the contents of that address in the data register.
4. Compare the number in the data register with the value for that address in Table E-3.
5. If the values are the same, press EXAM again to display the contents of the next address.
If the values are not the same, repeat the entire procedure for depositing the bootstrap.
Verify the contents of all the addresses in this way. If any instruction is incorrect,
repeat the entire deposit procedure.
Once you have correctly deposited the bootstrap in memory, start the computer as follows:
1. Set the starting address, 001000, in the switch register.
2. Press the LOAD ADDR switch.
3. Set the ENABLE/HALT switch to ENABLE.
4. Press the START switch.
Table E-3: RX-11 Bootstrap Loader
---------------------------------
Location Contents
001000 005000
001002 012701
001004 177170
001006 105711
001010 001776
001012 012711
001014 000003
001016 005711
001020 001776
001022 100405
001024 105711
001026 100004
001030 116120
001032 000002
001034 000770
001036 000000
001040 005000
001042 000110
Loading the RX-11 Bootstrap Loader
----------------------------------
Any PDP-11 machine using built-in PCjs Debugger makes it easy to enter the bootstrap code above. Paste
the following commands into the Debugger's command buffer:
ew 1000 005000 012701 177170 105711 001776 012711 000003 005711 001776;
ew 1022 100405 105711 100004 116120 000002 000770 000000 005000 000110;
r pc 1000
You can then review (eg, disassemble) the bootstrap code:
>> u 1000 1044
001000: 005000 CLR R0
001002: 012701 177170 MOV #177170,R1
001006: 105711 TSTB @R1
001010: 001776 BEQ 001006
001012: 012711 000003 MOV #3,@R1
001016: 005711 TST @R1
001020: 001776 BEQ 001016
001022: 100405 BMI 001036
001024: 105711 TSTB @R1
001026: 100004 BPL 001040
001030: 116120 000002 MOVB 2(R1),(R0)+
001034: 000770 BR 001016
001036: 000000 HALT
001040: 005000 CLR R0
001042: 000110 JMP @R0
Last but not least, make sure you have successfully loaded an RX01 diskette image into drive DX0. Then execute the
bootstrap code with the Debugger's "g" command.
Of course, if the machine also includes the RX11 Boot control, then all you *really* need to is select an
RX01 diskette, click "Load", wait for the diskette image to be successfully loaded (i.e., downloaded) and then click
"Boot".

22
devices/pdp11/rx11/default.xml Normal file
View file

@ -0,0 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
<device id="rx11" type="rx11" pos="left" width="35%" padLeft="8px" padBottom="8px">
<name>Disk Drive Controls</name>
<control type="container">
<control type="list" binding="listDrives"/>
<control type="list" binding="listDisks">
<disk id="disk01" name="RT-11 V3 SYS (1 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-1.json"/>
<disk id="disk01" name="RT-11 V3 SYS (2 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-2.json"/>
<disk id="disk01" name="RT-11 V3 SYS (3 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-3.json"/>
<disk id="disk01" name="RT-11 V3 SYS (4 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-4.json"/>
<disk id="disk01" name="RT-11 V3 SYS (5 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-5.json"/>
<disk id="disk01" name="RT-11 V3 SYS (6 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-6.json"/>
<disk id="disk01" name="RT-11 V3 SYS (7 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-7.json"/>
<disk id="disk01" name="RT-11 V3 SYS (8 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-8.json"/>
<disk id="disk01" name="RT-11 V3 SYS (9 OF 9)" path="http://archive.pcjs.org/disks/dec/rx01/RX01-RT11-V03-9.json"/>
</control>
<control type="button" binding="loadDisk">Load</control>
<control type="button" binding="bootDisk">Boot</control>
<control type="description" binding="descDisk" padRight="8px"/>
<control type="file" binding="mountDisk"/>
</control>
</device>

5
disks/dec/README.md
View file

@ -12,9 +12,14 @@ The DEC disk images we have archived are organized by type:
* [RK03](rk03/)
* [RL01K](rl01k/)
* [RL02K](rl02k/)
* [RX01](rx01/)
RK03 (or more precisely, RK03-KA) disks are single-platter cartridges with a capacity of 2.38Mb.
They are used in RK05 disk drives in conjunction with an [RK11 Disk Controller](/devices/pdp11/rk11/).
RL01K and RL02K disks are single-platter cartridges with capacities of 5Mb and 10Mb, respectively,
They are used in RL01 and RL02 disk drives with an [RL11 Disk Controller](/devices/pdp11/rl11/).
RX01 diskettes are single-sided, with 77 tracks per side, 26 sectors per track, and a sector size of 128 bytes,
for a total capacity of 250Kb (256,256 bytes). They are used in RX01 disk drives in conjunction with an
[RX11 Disk Controller](/devices/pdp11/rx11/).

135
disks/dec/rx01/README.md Normal file
View file

@ -0,0 +1,135 @@
---
layout: page
title: DEC RX01 Disk Images
permalink: /disks/dec/rx01/
---
DEC RX01 Disk Images
--------------------
RX01 diskettes are single-sided, with 77 tracks per side, 26 sectors per track, and a sector size of 128 bytes,
for a total capacity of 250Kb (256,256 bytes). They are used in RX01 disk drives in conjunction with an
[RX11 Disk Controller](/devices/pdp11/rx11/).
Below is a summary of RX01 diskette images archived here.
### RT-11 V3 [[Source](http://www.headcrashers.org/comp/rx01/)]
#### RT-11 V3 SYS (1 OF 9)
DXMNSJ.SYS 86 14-Aug-77 TT .SYS 2 14-Aug-77
DP .SYS 2 14-Aug-77 DT .SYS 2 14-Aug-77
DX .SYS 2 14-Aug-77 RF .SYS 2 14-Aug-77
RK .SYS 2 14-Aug-77 DM .SYS 4 14-Aug-77
DS .SYS 2 14-Aug-77 LP .SYS 2 14-Aug-77
NL .SYS 2 14-Aug-77 STARTS.COM 1 11-Jul-77
PIP .SAV 16 14-Aug-77 DUP .SAV 17 14-Aug-77
DIR .SAV 17 14-Aug-77 SYSMAC.SML 37 14-Aug-77
EDIT .SAV 21 14-Aug-77 MACRO .SAV 45 14-Aug-77
CREF .SAV 6 14-Aug-77 LINK .SAV 29 16-Aug-77
LIBR .SAV 18 14-Aug-77 FILEX .SAV 18 14-Aug-77
SRCCOM.SAV 11 14-Aug-77 DUMP .SAV 7 14-Aug-77
PATCH .SAV 9 14-Aug-77 HELP .SAV 21 14-Aug-77
HELP .TEC 3 23-Jun-77 HELP .TXT 73 19-Jul-77
DEMOBG.MAC 4 01-Aug-77 DEMOFG.MAC 5 01-Aug-77
V2USER.TXT 2 13-Jul-77
31 Files, 468 Blocks
12 Free blocks
#### RT-11 V3 SYS (2 OF 9)
RKMNSJ.SYS 86 14-Aug-77 RKMNFB.SYS 96 14-Aug-77
RKMNXM.SYS 106 14-Aug-77 RKMNSJ.BL 82 14-Aug-77
DMMNSJ.SYS 87 14-Aug-77 ODT .OBJ 9 14-Aug-77
6 Files, 466 Blocks
14 Free blocks
#### RT-11 V3 SYS (3 OF 9)
DPMNXM.SYS 106 14-Aug-77 RFMNSJ.SYS 86 14-Aug-77
RFMNFB.SYS 96 14-Aug-77 RFMNXM.SYS 106 14-Aug-77
DTX .SYS 2 14-Aug-77 DPX .SYS 2 14-Aug-77
DXX .SYS 3 14-Aug-77 RFX .SYS 2 14-Aug-77
RKX .SYS 2 14-Aug-77 DMX .SYS 4 14-Aug-77
DSX .SYS 2 14-Aug-77 LPX .SYS 2 14-Aug-77
CR .SYS 3 14-Aug-77 CRX .SYS 3 14-Aug-77
MT .SYS 8 14-Aug-77 MTX .SYS 9 14-Aug-77
MTHD .SYS 3 14-Aug-77 MTHDX .SYS 4 14-Aug-77
BA .SYS 7 14-Aug-77 BAX .SYS 7 14-Aug-77
TT .MAC 9 14-Aug-77 DEMOED.TXT 1 09-May-77
22 Files, 467 Blocks
13 Free blocks
#### RT-11 V3 SYS (4 OF 9)
DMMNFB.SYS 98 14-Aug-77 DMMNXM.SYS 108 14-Aug-77
DXMNFB.SYS 97 14-Aug-77 DXMNXM.SYS 107 14-Aug-77
SYE .SAV 50 14-Aug-77 NLX .SYS 2 14-Aug-77
PC .SYS 2 14-Aug-77 PCX .SYS 2 14-Aug-77
DEMOF1.FOR 2 28-Jan-77
9 Files, 468 Blocks
12 Free blocks
#### RT-11 V3 SYS (5 OF 9)
DXMNSJ.BL 83 14-Aug-77 DTMNSJ.SYS 86 14-Aug-77
DTMNFB.SYS 96 14-Aug-77 DTMNSJ.BL 82 14-Aug-77
DSMNSJ.SYS 86 14-Aug-77 RF .MAC 6 14-Aug-77
DM .MAC 19 14-Aug-77 DEMOSP.MAC 11 01-Aug-77
8 Files, 469 Blocks
11 Free blocks
#### RT-11 V3 SYS (6 OF 9)
DSMNFB.SYS 96 14-Aug-77 DSMNXM.SYS 106 14-Aug-77
DPMNSJ.SYS 86 14-Aug-77 DPMNFB.SYS 97 14-Aug-77
DP .MAC 9 14-Aug-77 MUBRTE.OBJ 1 04-May-77
MUBTAB.OBJ 1 04-May-77 MUBZN1.OBJ 1 04-May-77
CT .MAC 32 14-Aug-77 TM .MAC 24 14-Aug-77
MMHD .SYS 4 14-Aug-77 MMHDX .SYS 4 14-Aug-77
PAT .SAV 7 14-Aug-77
13 Files, 468 Blocks
12 Free blocks
#### RT-11 V3 SYS (7 OF 9)
KMON .MAC 118 14-Aug-77 USR .MAC 59 14-Aug-77
RMONSJ.MAC 56 14-Aug-77 RMONFB.MAC 138 14-Aug-77
EL .MAC 18 14-Aug-77 LP .MAC 7 14-Aug-77
RK .MAC 7 14-Aug-77 DT .MAC 7 14-Aug-77
DS .MAC 7 14-Aug-77 PC .MAC 6 14-Aug-77
ERRUTL.SAV 6 14-Aug-77 MACFST.SAV 45 14-Aug-77
12 Files, 474 Blocks
6 Free blocks
#### RT-11 V3 SYS (8 OF 9)
KMOVLY.MAC 153 14-Aug-77 BSTRAP.MAC 41 14-Aug-77
MTTEMT.MAC 18 16-Aug-77 MTTINT.MAC 34 14-Aug-77
TJ .MAC 28 14-Aug-77 NL .MAC 3 14-Aug-77
DX .MAC 11 14-Aug-77 CR .MAC 14 14-Aug-77
FSM .MAC 31 14-Aug-77 BATCH .MAC 98 14-Aug-77
MUBET1.OBJ 1 04-May-77 MUBXT1.OBJ 1 04-May-77
MUBZ1 .OBJ 1 04-May-77 MUBS1D.OBJ 1 04-May-77
MUBLNK.COM 1 04-May-77 MM .SYS 9 14-Aug-77
MMX .SYS 9 14-Aug-77 BA .MAC 19 14-Aug-77
18 Files, 473 Blocks
7 Free blocks
#### RT-11 V3 SYS (9 OF 9)
SYSMAC.MAC 36 01-Aug-77 BATCH .SAV 25 14-Aug-77
MAC8K .SAV 52 14-Aug-77 PSE .SAV 13 14-Aug-77
SYSGEN.SAV 32 14-Aug-77 SYSGEN.CND 83 08-Aug-77
SYSTBL.CND 26 08-Aug-77 VTMAC .MAC 7 01-Aug-77
VTHDLR.OBJ 8 14-Aug-77 SYSF4 .OBJ 39 14-Aug-77
MDUP .SAV 9 14-Aug-77 MDUP .MM 48 14-Aug-77
MDUP .MT 48 14-Aug-77 MBOOT .BOT 1 14-Aug-77
MSBOOT.BOT 3 14-Aug-77 STARTF.COM 1 10-Jun-77
STARTX.COM 1 10-Jun-77 SJ .MAC 1 01-Aug-77
FB .MAC 1 01-Aug-77 XM .MAC 1 01-Aug-77
SYSDEV.MAC 1 24-Sep-76 CT .SYS 5 14-Aug-77
CTX .SYS 6 14-Aug-77 TECO .SAV 27 14-Aug-77
DEMOX1.MAC 5 01-Aug-77
25 Files, 479 Blocks
1 Free blocks

8
docs/pcx86/examples/pcx86-dbg.js
View file

File diff suppressed because one or more lines are too long

8
docs/pcx86/examples/pcx86.js
View file

File diff suppressed because one or more lines are too long

2
modules/pdp11/lib/computer.js
View file

@ -1410,7 +1410,7 @@ class ComputerPDP11 extends Component {
this.fReload = false;
} else {
this.reset();
if (this.cpu) this.cpu.autoStart();
if (this.cpu && !this.dbg) this.cpu.autoStart();
}
}

21
modules/pdp11/lib/cpustate.js
View file

@ -567,13 +567,15 @@ class CPUStatePDP11 extends CPUPDP11 {
}
/**
* setReset(addr, fStart)
* setReset(addr, fStart, bUnit, addrStack)
*
* @this {CPUStatePDP11}
* @param {number} addr
* @param {boolean|undefined} fStart (true if a "startable" image was just loaded, false if not)
* @param {boolean} [fStart] (true if a "startable" image was just loaded, false if not)
* @param {number} [bUnit] (boot unit #)
* @param {number} [addrStack]
*/
setReset(addr, fStart)
setReset(addr, fStart, bUnit, addrStack)
{
this.addrReset = addr;
@ -583,13 +585,10 @@ class CPUStatePDP11 extends CPUPDP11 {
this.resetCPU();
if (fStart) {
/*
* TODO: Review. I'm zeroing R2-R5 in the fStart case (ie, for boot code) simply because that's what I
* saw the PDP-11 Boot Monitor doing (see /apps/pdp11/boot/monitor/BOOTMON.mac).
*/
for (var i = 2; i <= 5; i++) {
this.regsGen[i] = 0;
}
this.regsGen[0] = bUnit || 0;
for (var i = 1; i <= 5; i++) this.regsGen[i] = 0;
this.regsGen[6] = addrStack || 0o2000;
if (!this.dbg) {
if (!this.flags.powered) {
this.flags.autoStart = true;
}
@ -597,6 +596,7 @@ class CPUStatePDP11 extends CPUPDP11 {
this.startCPU();
}
}
}
else {
if (this.dbg && this.flags.powered) {
/*
@ -2870,6 +2870,7 @@ class CPUStatePDP11 extends CPUPDP11 {
data = (data < 0? (this.regsGen[-data-1] & 0xff): data);
this.regsGen[reg] = (this.regsGen[reg] & ~writeFlags) | (((data << 24) >> 24) & writeFlags);
}
//noinspection JSUnresolvedFunction
fnFlags.call(this, data << 8);
} else {
var addr = this.getAddr(mode, reg, PDP11.ACCESS.WRITE_BYTE);

127
modules/pdp11/lib/defines.js
View file

@ -513,6 +513,8 @@ var PDP11 = {
RLMP: 0o174406, // RL11 Multi-Purpose Register
RLBE: 0o174410, // RL11 Bus (Address) Extension Register (RLV12 controller only)
DL11: 0o176500, // DL11 Additional Register Range (ends at 0o176676)
RXCS: 0o177170, // RX11 Command and Status Register
RXDB: 0o177172, // RX11 Data Buffer Register
RKDS: 0o177400, // RK11 Drive Status Register
RKER: 0o177402, // RK11 Error Register
RKCS: 0o177404, // RK11 Control Status Register
@ -662,29 +664,28 @@ var PDP11 = {
RVEC: 0o070, // reader vector
PVEC: 0o074, // punch vector
PRS: { // 177550: PC11 (and PR11) Reader Status Register
RE: 0x0001, // Reader Enable (W/O)
RIE: 0x0040, // Reader Interrupt Enable (allows the DONE and ERROR bits to trigger an interrupt)
DONE: 0x0080, // Done (R/O)
BUSY: 0x0800, // Busy (R/O)
ERROR: 0x8000, // Error (R/O)
CLEAR: 0x08C0, // bits cleared on INIT
RMASK: 0xFFFE, // bits readable (TODO: All I know for sure is that bit 0 is NOT readable; see readPRS())
WMASK: 0x0041, // bits writable
RE: 0x0001, // (000001) Reader Enable (W/O)
IE: 0x0040, // (000100) Reader Interrupt Enable (allows the DONE and ERROR bits to trigger an interrupt)
DONE: 0x0080, // (000200) Done (R/O)
BUSY: 0x0800, // (004000) Busy (R/O)
ERROR: 0x8000, // (100000) Error (R/O)
CLEAR: 0x08C0, // (004300) bits cleared on INIT
RMASK: 0xFFFE, // (177776) bits readable (TODO: All I know for sure is that bit 0 is NOT readable; see readPRS())
WMASK: 0x0041, // (000101) bits writable
BAUD: 3600
},
PRB: { // 177552: PC11 (and PR11) Reader Buffer Register
MASK: 0x00FF // Data
},
PPS: { // 177554: PC11 Punch Status Register
/*
* TODO: Flesh this out if/when we add Paper Tape Punch support
*/
IE: 0x0040, // Interrupt Enable
RDY: 0x0080, // Ready
ERROR: 0x8000, // Error (eg, no tape in punch, or punch has no power)
WMASK: 0x0040, // bits writable
BAUD: 600
},
PPB: { // 177556: PC11 Punch Buffer Register
/*
* TODO: Flesh this out if/when we add Paper Tape Punch support
*/
MASK: 0x00FF // Data
}
},
RK11: { // RK11 Disk Controller
@ -738,7 +739,7 @@ var PDP11 = {
SCP: 0x2000, // (020000) Search Complete (R/O)
HE: 0x4000, // (040000) Hard Error (R/O)
ERR: 0x8000, // (100000) Composite Error (R/O) (set when any RKER bit is set)
UNUSED: 0x1200, // (120000) unused
UNUSED: 0x1200, // (011000) unused
RMASK: 0xEFFE, // (167776) bits readable
WMASK: 0x0F7F, // (007577) bits writable
SHIFT: {
@ -772,6 +773,7 @@ var PDP11 = {
PRI: 5,
VEC: 0o160,
DRIVES: 4, // maximum of 4 drives
PREFIX: "DY",
RLCS: { // 174400: Control Status Register
DRDY: 0x0001, // Drive Ready (R/O)
FUNC: 0x000E, // Function Code (F2,F1,F0) (R/W)
@ -865,6 +867,76 @@ var PDP11 = {
RDNC: 0b1110 // Read Data without Header Check
}
},
RX11: { // RX11 Disk Controller
PRI: 5,
VEC: 0o264,
DRIVES: 2, // maximum of 2 drives
PREFIX: "DX",
RXCS: { // 177170: Command and Status Register
GO: 0x0001, // (000001) Go (W/O)
FUNC: 0x000E, // (000016) Function Code (F2,F1,F0) (W/O)
UNIT: 0x0010, // (000020) Unit Select (W/O)
DONE: 0x0020, // (000040) Done (R/O)
IE: 0x0040, // (000100) Interrupt Enable (R/W, cleared on INIT)
TR: 0x0080, // (000200) Transfer Request (R/O)
INIT: 0x4000, // (040000) RX11 Initialize (W/O)
ERR: 0x8000, // (100000) Error (R/O, cleared on INIT or command)
UNUSED: 0x3F00, // (037400) unused
RMASK: 0x80E0, // (100340) bits readable
WMASK: 0x405F // (040137) bits writable
},
RXDB: { // 177172: Data Buffer Register
},
RXTA: {
MASK: 0x007F
},
RXSA: {
MASK: 0x001F
},
RXES: {
/*
* The DRDY bit is only valid when retrieved via a Read Status function or at completion of Initialize when it indicates
* status of drive O. It is asserted if the unit currently selected exists, is properly supplied with power, has a diskette
* installed correctly, has its door closed, and has a diskette up to speed.
*
* If the Error bit was set in the RXCS but Error bits are not set in the RXES, then specific error conditions can be accessed via
* a Read Error Register function.
*/
CRC: 0x0001, // CRC error (RXES is moved to the RXDB, and Error and Done are asserted)
PARITY: 0x0002, // parity error (RXES is moved to the RXDB, and Error and Done are asserted)
ID: 0x0004, // Initialize Done (following a programmable or UNIBUS initialization, or a power failure)
DEL: 0x0040, // Deleted Data Detected
DRDY: 0x0080 // Drive Ready
},
FUNC: { // NOTE: These function codes are pre-shifted to read/write directly from/to RXCS.FUNC
FILL: 0b0000, // Fill Buffer
EMPTY: 0b0010, // Empty Buffer
WRITE: 0b0100, // Write Sector
READ: 0b0110, // Read Sector
UNUSED: 0b1000, // UNUSED
RDSTAT: 0b1010, // Read Status
WRDEL: 0b1100, // Write Deleted Data Sector
RDERR: 0b1110 // Read Error Register
},
ERROR: {
HOME0: 0o0010, // Drive 0 failed to see home on Initialize
HOME1: 0o0020, // Drive 1 failed to see home on Initialize
BAD_HOME: 0o0030, // Found home when stepping out 10 tracks for INIT
NO_TRACK: 0o0040, // Tried to access a track greater than 77
FOUND_HOME: 0o0050, // Home was found before desired track was reached
SELF_DIAG: 0o0060, // Self-diagnostic error
NO_SECTOR: 0o0070, // Desired sector could not be found after looking at 52 headers (2 revolutions)
NO_SEP: 0o0110, // More than 40us and no SEP clock seen
NO_PREAM: 0o0120, // A preamble could not be found
NO_IOMARK: 0o0130, // Preamble found but no I/O mark found within allowable time span
CRC_HEADER: 0o0140, // CRC error on what we thought was a header
BAD_TRACK: 0o0150, // The header track address of a good header does not compare with the desired track
NO_ID: 0o0160, // Too many tries for an IDAM (identifies header)
NO_DATA: 0o0170, // Data AM not found in allotted time
CRC_DATA: 0o0200, // CRC error on reading the sector from the disk (No code appears in the ERREG).
BAD_PARITY: 0o0210 // All parity errors
}
},
VECTORS: {
0o060: "DL11R",
0o064: "DL11X",
@ -872,12 +944,31 @@ var PDP11 = {
0o074: "PC11X",
0o100: "KW11",
0o160: "RL11",
0o220: "RK11"
0o220: "RK11",
0o264: "RX11"
}
};
PDP11.RK11.RK05 = [203, 2, 12, 512, PDP11.RK11.RKDS.RK05 | PDP11.RK11.RKDS.SOK | PDP11.RK11.RKDS.RRDY];
PDP11.RL11.RL02K = [512, 2, 40, 256, PDP11.RL11.RLMP.GS_ST.LOCKON | PDP11.RL11.RLMP.GS_BH | PDP11.RL11.RLMP.GS_HO];
PDP11.RX11.RX01 = [
"DX",
77, 1, 26, 128, // disk geometry (CHSN: cylinders, heads, sectors/track, and bytes/sector)
1, 0, 0, 128, // boot code location (cylinder, head, sector index (NOT sector number), and number of bytes)
0 // default drive status
];
PDP11.RK11.RK05 = [
"RK",
203, 2, 12, 512, // disk geometry (CHSN: cylinders, heads, sectors/track, and bytes/sector)
0, 0, 0, 512, // boot code location (cylinder, head, sector index (NOT sector number), and number of bytes)
PDP11.RK11.RKDS.RK05 | PDP11.RK11.RKDS.SOK | PDP11.RK11.RKDS.RRDY
];
PDP11.RL11.RL02K = [
"RL",
512, 2, 40, 256, // disk geometry (CHSN: cylinders, heads, sectors/track, and bytes/sector)
0, 0, 0, 256, // boot code location (cylinder, head, sector index (NOT sector number), and number of bytes)
PDP11.RL11.RLMP.GS_ST.LOCKON | PDP11.RL11.RLMP.GS_BH | PDP11.RL11.RLMP.GS_HO
];
PDP11.ACCESS.READ_WORD = PDP11.ACCESS.WORD | PDP11.ACCESS.READ; // formerly READ_MODE (2)
PDP11.ACCESS.READ_BYTE = PDP11.ACCESS.BYTE | PDP11.ACCESS.READ; // formerly READ_MODE (2) | BYTE_MODE (1)

5
modules/pdp11/lib/device.js
View file

@ -44,6 +44,7 @@ if (NODE) {
var PC11 = require("./pc11");
var RL11 = require("./rl11");
var RK11 = require("./rk11");
var RX11 = require("./rx11");
}
class DevicePDP11 extends Component {
@ -1204,6 +1205,10 @@ class DevicePDP11 extends Component {
device = new RK11(parmsDevice);
Component.bindComponentControls(device, eDevice, PDP11.APPCLASS);
break;
case 'rx11':
device = new RX11(parmsDevice);
Component.bindComponentControls(device, eDevice, PDP11.APPCLASS);
break;
}
}
}

72
modules/pdp11/lib/drive.js
View file

@ -376,7 +376,8 @@ class DriveController extends Component {
*/
getDriveName(iDrive)
{
return this.type.substr(0, 2) + iDrive;
var drive = this.aDrives[iDrive];
return drive.sName || "---";
}
/**
@ -554,11 +555,16 @@ class DriveController extends Component {
* NOTE: We initialize the following drive properties to their MAXIMUMs; disks may have
* these or SMALLER values (subject to the limits of what the controller supports, of course).
*/
drive.nCylinders = configDrive[0];
drive.nHeads = configDrive[1];
drive.nSectors = configDrive[2];
drive.cbSector = configDrive[3];
drive.status = configDrive[4];
drive.sName = configDrive[i++] + iDrive;
drive.nCylinders = configDrive[i++];
drive.nHeads = configDrive[i++];
drive.nSectors = configDrive[i++];
drive.cbSector = configDrive[i++];
drive.iCylinderBoot = configDrive[i++];
drive.iHeadBoot = configDrive[i++];
drive.iSectorBoot = configDrive[i++];
drive.cbSectorBoot = configDrive[i++];
drive.status = configDrive[i++];
/*
* The next group of properties are set by various controller command sequences.
@ -720,9 +726,9 @@ class DriveController extends Component {
{
if (!fRemount) this.cAutoMount = 0;
for (var sDrive in this.configMount) {
var configDrive = this.configMount[sDrive];
var sDiskPath = configDrive['path'] || "";
var sDiskName = configDrive['name'] || this.findDisk(sDiskPath);
var configDisk = this.configMount[sDrive];
var sDiskPath = configDisk['path'] || "";
var sDiskName = configDisk['name'] || this.findDisk(sDiskPath);
if (sDiskPath && sDiskName) {
var iDrive = this.getDriveNumber(sDrive);
if (iDrive >= 0 && iDrive < this.aDrives.length) {
@ -732,7 +738,7 @@ class DriveController extends Component {
continue;
}
}
this.notice("Incorrect auto-mount settings for drive " + sDrive + " (" + JSON.stringify(configDrive) + ")");
this.notice("Incorrect auto-mount settings for drive " + sDrive + " (" + JSON.stringify(configDisk) + ")");
}
return !!this.cAutoMount;
}
@ -814,8 +820,8 @@ class DriveController extends Component {
* expects the controller to be in a READY state; since setReset() triggers a call to our reset() handler,
* a READY state is assured, and the readData() call shouldn't do anything to change that.
*/
this.cpu.setReset(0, true);
var err = this.readData(drive, 0, 0, 0, 512, 0x0000, 2);
this.cpu.setReset(0, true, iDrive);
var err = this.readData(drive, drive.iCylinderBoot, drive.iHeadBoot, drive.iSectorBoot, drive.cbSectorBoot, 0x0000, 2);
if (err) {
this.notice("Unable to read the boot sector (" + err + ")");
}
@ -914,6 +920,11 @@ class DriveController extends Component {
drive.sDiskName = sDiskName;
drive.sDiskPath = sDiskPath;
/*
* Inform the controller implementation (eg, RX11) of the disk change.
*/
this.notifyLoad(drive.iDrive);
/*
* Adding local disk image names to the disk list seems like a nice idea, but it's too confusing,
* because then it looks like the "Mount" button should be able to (re)load them, and that can NEVER
@ -1117,6 +1128,11 @@ class DriveController extends Component {
this.sDiskSource = DriveController.SOURCE.NONE;
this.displayDisk(iDrive);
}
/*
* Inform the controller implementation (eg, RX11) of the disk removal.
*/
this.notifyUnload(iDrive);
}
}
@ -1217,10 +1233,34 @@ class DriveController extends Component {
}
}
/**
* notifyLoad(iDrive)
*
* Placeholder for subclasses. Called whenever DriveController has loaded a new disk into the specified drive.
*
* @this {RX11}
* @param {number} iDrive
*/
notifyLoad(iDrive)
{
}
/**
* notifyUnload(iDrive)
*
* Placeholder for subclasses. Called whenever DriveController has unloaded a disk from the specified drive.
*
* @this {RX11}
* @param {number} iDrive
*/
notifyUnload(iDrive)
{
}
/**
* readData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
*
* Placeholder for subclasses.
* Placeholder for subclasses. Implementation is optional, but the automatic BOOT feature will be unavailable.
*
* @this {DriveController}
* @param {Object} drive
@ -1236,13 +1276,13 @@ class DriveController extends Component {
*/
readData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
{
return false;
return -1;
}
/**
* writeData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
*
* Placeholder for subclasses.
* Placeholder for subclasses. Implementation is optional.
*
* @this {DriveController}
* @param {Object} drive
@ -1258,7 +1298,7 @@ class DriveController extends Component {
*/
writeData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
{
return false;
return -1;
}
}

10
modules/pdp11/lib/messages.js
View file

@ -48,10 +48,11 @@ var MessagesPDP11 = {
WRITE: 0x00008000,
RK11: 0x00010000,
RL11: 0x00020000,
DL11: 0x00040000,
SERIAL: 0x00040000,
KW11: 0x00080000,
TIMER: 0x00080000,
RX11: 0x00040000,
DL11: 0x00100000,
SERIAL: 0x00100000,
KW11: 0x00200000,
TIMER: 0x00200000,
SPEAKER: 0x01000000,
COMPUTER: 0x02000000,
LOG: 0x10000000,
@ -94,6 +95,7 @@ MessagesPDP11.CATEGORIES = {
"write": MessagesPDP11.WRITE,
"rk11": MessagesPDP11.RK11,
"rl11": MessagesPDP11.RL11,
"rx11": MessagesPDP11.RX11,
"dl11": MessagesPDP11.DL11,
"serial": MessagesPDP11.SERIAL,
"kw11": MessagesPDP11.KW11,

87
modules/pdp11/lib/pc11.js
View file

@ -64,7 +64,7 @@ class PC11 extends Component {
*/
constructor(parms)
{
super("PC11", parms);
super("PC11", parms, MessagesPDP11.PC11);
this.sDevice = "PTR"; // TODO: Make the device name configurable
@ -78,6 +78,8 @@ class PC11 extends Component {
this.regPRS = 0; // PRS register
this.regPRB = 0; // PRB register
this.regPPS = PDP11.PC11.PPS.ERROR; // PPS register (TODO: Stop signaling error once punch is implemented)
this.regPPB = 0; // PPB register
this.iTapeData = 0; // buffer index
this.aTapeData = []; // buffer for the PRB register
this.sTapeSource = PC11.SOURCE.NONE;
@ -434,6 +436,7 @@ class PC11 extends Component {
loadTape(sTapeName, sTapePath, nTapeTarget, fAutoMount, file)
{
var nResult = -1;
if (this.sTapePath.toLowerCase() != sTapePath.toLowerCase() || this.nTapeTarget != nTapeTarget) {
nResult++;
@ -493,7 +496,7 @@ class PC11 extends Component {
pc11.finishRead(sTapeName, sTapePath, nTapeTarget, reader.result);
};
reader.readAsArrayBuffer(file);
return true;
return false;
}
/*
@ -579,6 +582,7 @@ class PC11 extends Component {
this.parseTape(sTapeName, sTapePath, nTapeTarget, aBytes);
this.sTapeSource = PC11.SOURCE.LOCAL;
}
this.flags.busy = false;
this.displayTape();
}
@ -724,9 +728,12 @@ class PC11 extends Component {
this.status('Read tape "' + sTapeName + '"');
return;
}
this.iTapeData = 0;
this.aTapeData = aBytes;
this.status('Loaded tape "' + sTapeName + '"');
this.regPRS &= ~PDP11.PC11.PRS.ERROR;
this.status('Loaded tape "' + sTapeName + '" (' + aBytes.length + " bytes)");
this.displayProgress(0);
}
@ -820,17 +827,22 @@ class PC11 extends Component {
* (eg, -128 to 127, instead of 0 to 255). Both risks are good reasons to always mask
* the data assigned to PRB with 0xff.
*/
this.regPRB = this.aTapeData[this.iTapeData++] & 0xff;
this.regPRB = this.aTapeData[this.iTapeData] & 0xff;
if (this.messageEnabled()) this.printMessage(this.type + ".advanceReader(" + this.iTapeData + "): " + Str.toHexByte(this.regPRB), true);
this.iTapeData++;
this.displayProgress(this.iTapeData / this.aTapeData.length * 100);
}
else {
this.regPRS |= PDP11.PC11.PRS.ERROR;
}
this.regPRS |= PDP11.PC11.PRS.DONE;
this.regPRS &= ~PDP11.PC11.PRS.BUSY;
if (this.regPRS & PDP11.PC11.PRS.RIE) {
if (this.regPRS & PDP11.PC11.PRS.IE) {
this.cpu.setIRQ(this.irqReader);
}
}
}
}
}
/**
* readPRS(addr)
@ -868,7 +880,7 @@ class PC11 extends Component {
*/
if (this.regPRS & PDP11.PC11.PRS.ERROR) {
data &= ~PDP11.PC11.PRS.RE;
if (this.regPRS & PDP11.PC11.PRS.RIE) {
if (this.regPRS & PDP11.PC11.PRS.IE) {
this.cpu.setIRQ(this.irqReader);
}
} else {
@ -914,6 +926,63 @@ class PC11 extends Component {
writePRB(data, addr)
{
}
/**
* readPPS(addr)
*
* @this {PC11}
* @param {number} addr (eg, PDP11.UNIBUS.PPS or 177554)
* @return {number}
*/
readPPS(addr)
{
return this.regPPS;
}
/**
* writePPS(data, addr)
*
* NOTE: This was originally added ONLY because when RT-11 v4.0 copies from device "PC:" (the paper tape reader),
* it executes the following code:
*
* 016010: 005037 177550 CLR @#177550 ;history=2 PRS
* 016014: 005037 177554 CLR @#177554 ;history=1
*
* and as you can see, without this PPS handler, a TRAP to 4 would normally occur. I guess since we claim to be
* a PC11, that makes sense. But what about PDP-11 machines with only a PR11 (ie, a reader-only unit)?
*
* @this {PC11}
* @param {number} data
* @param {number} addr (eg, PDP11.UNIBUS.PPS or 177554)
*/
writePPS(data, addr)
{
this.regPPS = (this.regPPS & ~PDP11.PC11.PPS.WMASK) | (data & PDP11.PC11.PPS.WMASK);
}
/**
* readPPB(addr)
*
* @this {PC11}
* @param {number} addr (eg, PDP11.UNIBUS.PPB or 177556)
* @return {number}
*/
readPPB(addr)
{
return this.regPPB;
}
/**
* writePPB(data, addr)
*
* @this {PC11}
* @param {number} data
* @param {number} addr (eg, PDP11.UNIBUS.PPB or 177556)
*/
writePPB(data, addr)
{
this.regPPB = (data & PDP11.PC11.PPB.MASK);
}
}
/*
@ -944,7 +1013,9 @@ PC11.CSSCLASS = {
*/
PC11.UNIBUS_IOTABLE = {
[PDP11.UNIBUS.PRS]: /* 177550 */ [null, null, PC11.prototype.readPRS, PC11.prototype.writePRS, "PRS"],
[PDP11.UNIBUS.PRB]: /* 177552 */ [null, null, PC11.prototype.readPRB, PC11.prototype.writePRB, "PRB"]
[PDP11.UNIBUS.PRB]: /* 177552 */ [null, null, PC11.prototype.readPRB, PC11.prototype.writePRB, "PRB"],
[PDP11.UNIBUS.PPS]: /* 177554 */ [null, null, PC11.prototype.readPPS, PC11.prototype.writePPS, "PPS"],
[PDP11.UNIBUS.PPB]: /* 177556 */ [null, null, PC11.prototype.readPPB, PC11.prototype.writePPB, "PPB"]
};
if (NODE) module.exports = PC11;

40
modules/pdp11/lib/rk11.js
View file

@ -230,12 +230,12 @@ class RK11 extends DriveController {
*/
readData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
{
var err = 0;
var nError = 0;
var disk = drive.disk;
var sector = null, ibSector;
if (!disk) {
err = RK11.RKER.NXD;
nError = RK11.RKER.NXD;
nWords = 0;
}
@ -243,12 +243,12 @@ class RK11 extends DriveController {
while (nWords) {
if (!sector) {
if (iCylinder >= disk.nCylinders) {
err = RK11.RKER.NXC;
nError = RK11.RKER.NXC;
break;
}
sector = disk.seek(iCylinder, iHead, iSector + 1);
if (!sector) {
err = RK11.RKER.SKE;
nError = RK11.RKER.SKE;
break;
}
ibSector = 0;
@ -262,7 +262,7 @@ class RK11 extends DriveController {
}
var b0, b1;
if ((b0 = disk.read(sector, ibSector++)) < 0 || (b1 = disk.read(sector, ibSector++)) < 0) {
err = RK11.RKER.NXS;
nError = RK11.RKER.NXS;
break;
}
if (!fCheck) {
@ -277,7 +277,7 @@ class RK11 extends DriveController {
}
}
if (this.bus.checkFault()) {
err = RK11.RKER.NXM;
nError = RK11.RKER.NXM;
break;
}
}
@ -285,7 +285,7 @@ class RK11 extends DriveController {
addr += inc;
nWords--;
}
return done? done(err, iCylinder, iHead, iSector, nWords, addr) : err;
return done? done(nError, iCylinder, iHead, iSector, nWords, addr) : nError;
}
/**
@ -305,29 +305,29 @@ class RK11 extends DriveController {
*/
writeData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
{
var err = 0;
var nError = 0;
var disk = drive.disk;
var sector = null, ibSector;
if (!disk) {
err = RK11.RKER.NXD;
nError = RK11.RKER.NXD;
nWords = 0;
}
while (nWords) {
var data = this.bus.getWordDirect(this.cpu.mapUnibus(addr));
if (this.bus.checkFault()) {
err = RK11.RKER.NXM;
nError = RK11.RKER.NXM;
break;
}
if (!sector) {
if (iCylinder >= disk.nCylinders) {
err = RK11.RKER.NXC;
nError = RK11.RKER.NXC;
break;
}
sector = disk.seek(iCylinder, iHead, iSector + 1, true);
if (!sector) {
err = RK11.RKER.SKE;
nError = RK11.RKER.SKE;
break;
}
ibSector = 0;
@ -342,7 +342,7 @@ class RK11 extends DriveController {
if (fCheck) {
var b0, b1;
if ((b0 = disk.read(sector, ibSector++)) < 0 || (b1 = disk.read(sector, ibSector++)) < 0) {
err = RK11.RKER.NXS;
nError = RK11.RKER.NXS;
break;
}
/*
@ -356,12 +356,12 @@ class RK11 extends DriveController {
* trigger the RKCS HE (Hard Error) bit. This is all taken care of in updateErrors() now.
*/
if (data != (b0 | (b1 << 8))) {
err = RK11.RKER.WCE;
nError = RK11.RKER.WCE;
break;
}
} else {
if (!disk.write(sector, ibSector++, data & 0xff) || !disk.write(sector, ibSector++, data >> 8)) {
err = RK11.RKER.NXS;
nError = RK11.RKER.NXS;
break;
}
}
@ -369,14 +369,14 @@ class RK11 extends DriveController {
addr += inc;
nWords--;
}
return done? done(err, iCylinder, iHead, iSector, nWords, addr) : err;
return done? done(nError, iCylinder, iHead, iSector, nWords, addr) : nError;
}
/**
* doneReadWrite(err, iCylinder, iHead, iSector, nWords, addr)
* doneReadWrite(nError, iCylinder, iHead, iSector, nWords, addr)
*
* @this {RK11}
* @param {number} err
* @param {number} nError
* @param {number} iCylinder
* @param {number} iHead
* @param {number} iSector
@ -384,13 +384,13 @@ class RK11 extends DriveController {
* @param {number} addr
* @return {boolean}
*/
doneReadWrite(err, iCylinder, iHead, iSector, nWords, addr)
doneReadWrite(nError, iCylinder, iHead, iSector, nWords, addr)
{
this.regRKBA = addr & 0xffff;
this.regRKCS = (this.regRKCS & ~RK11.RKCS.MEX) | ((addr >> (16 - RK11.RKCS.SHIFT.MEX)) & RK11.RKCS.MEX);
this.regRKWC = (0x10000 - nWords) & 0xffff;
this.regRKDA = (this.regRKDA & ~RK11.RKDA.SA) | (iSector & RK11.RKDA.SA);
this.regRKER |= err;
this.regRKER |= nError;
this.updateErrors();
return true;
}

38
modules/pdp11/lib/rl11.js
View file

@ -227,13 +227,13 @@ class RL11 extends DriveController {
*/
readData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
{
var err = 0;
var nError = 0;
var checksum = 0;
var disk = drive.disk;
var sector = null, ibSector;
if (!disk) {
err = RL11.ERRC.HNF; // TODO: Review
nError = RL11.ERRC.HNF; // TODO: Review
nWords = 0;
}
@ -242,14 +242,14 @@ class RL11 extends DriveController {
if (!sector) {
sector = disk.seek(iCylinder, iHead, iSector + 1);
if (!sector) {
err = RL11.ERRC.HNF;
nError = RL11.ERRC.HNF;
break;
}
ibSector = 0;
}
var b0, b1, data;
if ((b0 = disk.read(sector, ibSector++)) < 0 || (b1 = disk.read(sector, ibSector++)) < 0) {
err = RL11.ERRC.HNF;
nError = RL11.ERRC.HNF;
break;
}
/*
@ -267,7 +267,7 @@ class RL11 extends DriveController {
}
}
if (this.bus.checkFault()) {
err = RL11.ERRC.NXM;
nError = RL11.ERRC.NXM;
break;
}
addr += 2;
@ -280,7 +280,7 @@ class RL11 extends DriveController {
if (++iHead >= disk.nHeads) {
iHead = 0;
if (++iCylinder >= disk.nCylinders) {
err = RL11.ERRC.HNF;
nError = RL11.ERRC.HNF;
break;
}
}
@ -292,7 +292,7 @@ class RL11 extends DriveController {
console.log("checksum: " + (checksum|0));
}
return done? done(err, iCylinder, iHead, iSector, nWords, addr) : err;
return done? done(nError, iCylinder, iHead, iSector, nWords, addr) : nError;
}
/**
@ -312,13 +312,13 @@ class RL11 extends DriveController {
*/
writeData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
{
var err = 0;
var nError = 0;
var checksum = 0;
var disk = drive.disk;
var sector = null, ibSector;
if (!disk) {
err = RL11.ERRC.HNF; // TODO: Review
nError = RL11.ERRC.HNF; // TODO: Review
nWords = 0;
}
@ -331,7 +331,7 @@ class RL11 extends DriveController {
*/
var data = this.bus.getWordDirect(this.cpu.mapUnibus(addr));
if (this.bus.checkFault()) {
err = RL11.ERRC.NXM;
nError = RL11.ERRC.NXM;
break;
}
if (DEBUG && this.messageEnabled(MessagesPDP11.WRITE)) {
@ -348,13 +348,13 @@ class RL11 extends DriveController {
if (!sector) {
sector = disk.seek(iCylinder, iHead, iSector + 1, true);
if (!sector) {
err = RL11.ERRC.HNF;
nError = RL11.ERRC.HNF;
break;
}
ibSector = 0;
}
if (!disk.write(sector, ibSector++, data & 0xff) || !disk.write(sector, ibSector++, data >> 8)) {
err = RL11.ERRC.HNF;
nError = RL11.ERRC.HNF;
break;
}
if (ibSector >= disk.cbSector) {
@ -364,7 +364,7 @@ class RL11 extends DriveController {
if (++iHead >= disk.nHeads) {
iHead = 0;
if (++iCylinder >= disk.nCylinders) {
err = RL11.ERRC.HNF;
nError = RL11.ERRC.HNF;
break;
}
}
@ -376,14 +376,14 @@ class RL11 extends DriveController {
console.log("checksum: " + (checksum|0));
}
return done? done(err, iCylinder, iHead, iSector, nWords, addr) : err;
return done? done(nError, iCylinder, iHead, iSector, nWords, addr) : nError;
}
/**
* doneReadWrite(err, iCylinder, iHead, iSector, nWords, addr)
* doneReadWrite(nError, iCylinder, iHead, iSector, nWords, addr)
*
* @this {RL11}
* @param {number} err
* @param {number} nError
* @param {number} iCylinder
* @param {number} iHead
* @param {number} iSector
@ -391,7 +391,7 @@ class RL11 extends DriveController {
* @param {number} addr
* @return {boolean}
*/
doneReadWrite(err, iCylinder, iHead, iSector, nWords, addr)
doneReadWrite(nError, iCylinder, iHead, iSector, nWords, addr)
{
this.regRLBA = addr & 0xffff;
this.regRLCS = (this.regRLCS & ~RL11.RLCS.BAE) | ((addr >> (16 - RL11.RLCS.SHIFT.BAE)) & RL11.RLCS.BAE);
@ -399,8 +399,8 @@ class RL11 extends DriveController {
this.regRLDA = (iCylinder << RL11.RLDA.SHIFT.RW_CA) | (iHead? RL11.RLDA.RW_HS : 0) | (iSector & RL11.RLDA.RW_SA);
this.tmpRLDA = this.regRLDA;
this.regRLMP = (0x10000 - nWords) & 0xffff;
if (err) {
this.regRLCS |= err | RL11.RLCS.ERR;
if (nError) {
this.regRLCS |= nError | RL11.RLCS.ERR;
}
return true;
}

593
modules/pdp11/lib/rx11.js Normal file
View file

@ -0,0 +1,593 @@
/**
* @fileoverview Implements the RX11 Disk Controller (for RX01 Diskettes)
* @author <a href="mailto:Jeff@pcjs.org">Jeff Parsons</a>
* @copyright © Jeff Parsons 2012-2017
*
* This file is part of PCjs, a computer emulation software project at <http://pcjs.org/>.
*
* It has been adapted from the JavaScript PDP 11/70 Emulator written by Paul Nankervis
* (paulnank@hotmail.com) at <http://skn.noip.me/pdp11/pdp11.html>. This code may be used
* freely provided the original authors are acknowledged in any modified source code.
*
* PCjs is free software: you can redistribute it and/or modify it under the terms of the
* GNU General Public License as published by the Free Software Foundation, either version 3
* of the License, or (at your option) any later version.
*
* PCjs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
* even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with PCjs. If not,
* see <http://www.gnu.org/licenses/gpl.html>.
*
* You are required to include the above copyright notice in every modified copy of this work
* and to display that copyright notice when the software starts running; see COPYRIGHT in
* <http://pcjs.org/modules/shared/lib/defines.js>.
*
* Some PCjs files also attempt to load external resource files, such as character-image files,
* ROM files, and disk image files. Those external resource files are not considered part of PCjs
* for purposes of the GNU General Public License, and the author does not claim any copyright
* as to their contents.
*/
"use strict";
if (NODE) {
var Str = require("../../shared/lib/strlib");
var PDP11 = require("./defines");
var MessagesPDP11 = require("./messages");
var DriveController = require("./drive");
}
class RX11 extends DriveController {
/**
* RX11(parms)
*
* The RX11 component has the following component-specific (parms) properties:
*
* autoMount: one or more JSON-encoded objects, each containing 'name' and 'path' properties
*
* The RX11 Disk Controller controls up to two RX01 disk drives, which in turn read/write
* disk cartridges. See [RX11 Disk Controller Configuration Files](/devices/pdp11/rx11/).
*
* RX01 diskettes are single-sided, with 77 tracks per side, 26 sectors per track, and a sector size
* of 128 bytes, for a total capacity of 250Kb (256,256 bytes). See [RX01 Disk Images](/disks/dec/rx01/).
*
* @param {Object} parms
*/
constructor(parms)
{
super("RX11", parms, MessagesPDP11.RX11, PDP11.RX11, PDP11.RX11.RX01, RX11.UNIBUS_IOTABLE);
/*
* Define all the registers required for this controller.
*/
this.regRXCS = this.regRXDB = 0;
this.regRXTA = this.regRXSA = this.regRXES = this.regError = 0;
/*
* Whenever a command is issued, we record the function code internally here, and when the command
* is completed, we set the internal function code back to UNUSED.
*/
this.funCode = RX11.FUNC.UNUSED; // no function in progress (device is idle)
this.iBuffer = 0;
/*
* We use the new ES6 fill() method to ensure that the buffer returns something reasonable if, for some
* strange reason, the first command we receive is an Empty Buffer command.
*/
this.abBuffer = new Array(128).fill(0);
}
/**
* initController(aRegs)
*
* @this {RX11}
* @param {Array} [aRegs]
* @return {boolean} true if successful, false if failure
*/
initController(aRegs)
{
if (!aRegs) {
this.regRXCS = 0;
this.regRXDB = 0;
this.regRXTA = 1;
this.regRXSA = 1;
this.regRXES = 0;
this.regError = 0;
this.funCode = RX11.FUNC.READ;
this.iBuffer = 0;
this.cpu.clearIRQ(this.irq);
this.readSector();
}
else {
/*
* ES6 ALERT: A handy destructuring assignment, which makes it easy to perform the inverse
* of what saveController() does when it collects a bunch of object properties into an array.
*/
[
this.regRXCS,
this.regRXDB,
this.regRXTA,
this.regRXSA,
this.regRXES,
this.regError,
this.funCode,
this.iBuffer,
this.abBuffer
] = aRegs;
}
return true;
}
/**
* saveController()
*
* Basically, the inverse of initController().
*
* @this {RX11}
* @return {Array}
*/
saveController()
{
return [
this.regRXCS,
this.regRXDB,
this.regRXTA,
this.regRXSA,
this.regRXES,
this.regError,
this.funCode,
this.iBuffer,
this.abBuffer
];
}
/**
* notifyLoad(iDrive)
*
* Called whenever DriveController has loaded a new disk into the specified drive.
*
* We're interested in this so that whenever a disk change occurs for drive 0, we can automatically
* refill the sector buffer with the data from sector 1 from track 1.
*
* @this {RX11}
* @param {number} iDrive
*/
notifyLoad(iDrive)
{
if (iDrive == 0) this.initController();
}
/**
* notifyUnload(iDrive)
*
* Called whenever DriveController has unloaded a disk from the specified drive.
*
* @this {RX11}
* @param {number} iDrive
*/
notifyUnload(iDrive)
{
}
/**
* processCommand()
*
* @this {RX11}
*/
processCommand()
{
this.funCode = this.regRXCS & RX11.RXCS.FUNC;
this.regRXCS &= ~(RX11.RXCS.GO | RX11.RXCS.TR | RX11.RXCS.DONE | RX11.RXCS.ERR);
this.cpu.clearIRQ(this.irq);
if (this.messageEnabled()) this.printMessage(this.type + ".processCommand(" + RX11.FUNCS[this.funCode >> 1]+ ")", true, true);
switch(this.funCode) {
case RX11.FUNC.FILL:
case RX11.FUNC.EMPTY:
case RX11.FUNC.READ:
case RX11.FUNC.WRITE:
case RX11.FUNC.WRDEL:
this.initCommand();
break;
case RX11.FUNC.RDSTAT:
this.readStatus();
break;
case RX11.FUNC.RDERR:
this.readError();
break;
default:
this.assert(this.funCode == RX11.FUNC.UNUSED);
break;
}
}
/**
* initCommand()
*
* @this {RX11}
*/
initCommand()
{
this.iBuffer = 0;
}
/**
* doneCommand(nError)
*
* @this {RX11}
* @param {number} [nError]
*/
doneCommand(nError)
{
if (nError) {
this.regError = nError;
this.regRXDB = this.regRXES;
this.regRXCS |= RX11.RXCS.ERR;
}
this.funCode = RX11.FUNC.UNUSED;
this.regRXCS |= RX11.RXCS.DONE;
if (this.regRXCS & RX11.RXCS.IE) this.cpu.setIRQ(this.irq);
}
/**
* readData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
*
* This function is required ONLY if we want to support DriveController's bootSelectedDisk() function (and we do).
*
* @this {RX11}
* @param {Object} drive
* @param {number} iCylinder
* @param {number} iHead
* @param {number} iSector
* @param {number} nWords
* @param {number} addr
* @param {number} inc (normally 2, unless inhibited, in which case it's 0)
* @param {boolean} [fCheck]
* @param {function(...)} [done]
* @return {boolean|number} true if complete, false if queued (or if no done() is supplied, the error code, if any)
*/
readData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
{
var nError = 0;
var disk = drive.disk;
var sector = null, ibSector;
if (this.messageEnabled()) this.printMessage(this.type + ".readData(" + iCylinder + ":" + iHead + ":" + iSector + ") " + Str.toOct(addr) + "--" + Str.toOct(addr + (nWords << 1)), true, true);
if (!disk) {
nError = drive.iDrive? RX11.ERROR.HOME1 : RX11.ERROR.HOME0;
nWords = 0;
}
var sWords = "";
while (nWords) {
if (!sector) {
if (iCylinder >= disk.nCylinders) {
nError = RX11.ERROR.NO_TRACK;
break;
}
sector = disk.seek(iCylinder, iHead, iSector + 1);
if (!sector) {
nError = RX11.ERROR.NO_SECTOR;
break;
}
ibSector = 0;
if (++iSector >= disk.nSectors) {
iSector = 0;
if (++iHead >= disk.nHeads) {
iHead = 0;
++iCylinder;
}
}
}
var b0, b1;
if ((b0 = disk.read(sector, ibSector++)) < 0 || (b1 = disk.read(sector, ibSector++)) < 0) {
nError = RX11.ERROR.NO_DATA;
break;
}
var data = b0 | (b1 << 8);
this.bus.setWordDirect(this.cpu.mapUnibus(addr), data);
if (DEBUG && this.messageEnabled(MessagesPDP11.READ)) {
if (!sWords) sWords = Str.toOct(addr) + ": ";
sWords += Str.toOct(data) + ' ';
if (sWords.length >= 64) {
console.log(sWords);
sWords = "";
}
}
if (ibSector >= disk.cbSector) sector = null;
addr += inc;
nWords--;
}
return done? done(nError, iCylinder, iHead, iSector, nWords, addr) : nError;
}
/**
* readSector()
*
* @this {RX11}
*/
readSector()
{
var nError = 0;
var iDrive = (this.regRXCS & RX11.RXCS.UNIT)? 1 : 0;
var drive = this.aDrives[iDrive];
var disk = drive && drive.disk;
var iCylinder = this.regRXTA & RX11.RXTA.MASK, iHead = 0, nSector = this.regRXSA & RX11.RXSA.MASK;
this.regRXES &= ~(RX11.RXES.CRC | RX11.RXES.PARITY | RX11.RXES.DEL | RX11.RXES.DRDY);
if (disk) {
this.regRXES |= RX11.RXES.DRDY;
if (this.messageEnabled()) this.printMessage(this.type + ".readSector(" + iCylinder + ":" + iHead + ":" + nSector + ")", true, true);
this.assert(nSector); // RX sector numbers (unlike RK and RL) are supposed to be 1-based
var sector = disk.seek(iCylinder, iHead, nSector, true);
if (sector) {
var i = 0, nBytes = this.abBuffer.length;
while (i < nBytes) {
var b = disk.read(sector, i);
if (b < 0) {
nError = RX11.ERROR.NO_DATA;
break;
}
this.abBuffer[i++] = b;
}
if (sector.deleted) this.regRXES |= RX11.RXES.DEL;
} else {
nError = RX11.ERROR.NO_SECTOR;
}
} else {
nError = iDrive? RX11.ERROR.HOME1 : RX11.ERROR.HOME0;
}
this.doneCommand(nError);
}
/**
* writeSector(fDeleted)
*
* @this {RX11}
* @param {boolean} fDeleted
*/
writeSector(fDeleted)
{
var nError = 0;
var iDrive = (this.regRXCS & RX11.RXCS.UNIT)? 1 : 0;
var drive = this.aDrives[iDrive];
var disk = drive && drive.disk;
var iCylinder = this.regRXTA & RX11.RXTA.MASK, iHead = 0, nSector = this.regRXSA & RX11.RXSA.MASK;
this.regRXES &= ~(RX11.RXES.CRC | RX11.RXES.PARITY | RX11.RXES.DEL | RX11.RXES.DRDY);
if (disk) {
this.regRXES |= RX11.RXES.DRDY;
if (this.messageEnabled()) this.printMessage(this.type + ".writeSector(" + iCylinder + ":" + iHead + ":" + nSector + ")", true, true);
this.assert(nSector); // RX sector numbers (unlike RK and RL) are supposed to be 1-based
var sector = disk.seek(iCylinder, iHead, nSector, true);
if (sector) {
if (fDeleted) sector.deleted = true;
var i = 0, nBytes = this.abBuffer.length;
while (i < nBytes) {
var data = this.abBuffer[i];
if (!disk.write(sector, i, data & 0xff)) {
nError = RX11.ERROR.NO_DATA;
break;
}
i++;
}
} else {
nError = RX11.ERROR.NO_SECTOR;
}
} else {
nError = iDrive? RX11.ERROR.HOME1 : RX11.ERROR.HOME0;
}
this.doneCommand(nError);
}
/**
* readStatus()
*
* @this {RX11}
*/
readStatus()
{
var iDrive = (this.regRXCS & RX11.RXCS.UNIT)? 1 : 0;
var drive = this.aDrives[iDrive];
this.regRXES &= ~RX11.RXES.DRDY;
if (drive && drive.disk) this.regRXES |= RX11.RXES.DRDY;
this.regRXDB = this.regRXES;
this.doneCommand();
}
/**
* readError()
*
* @this {RX11}
*/
readError()
{
this.regRXDB = this.regError;
this.doneCommand();
}
/**
* readRXCS(addr)
*
* @this {RX11}
* @param {number} addr (eg, PDP11.UNIBUS.RXCS or 177170)
* @param {boolean} [fPreWrite]
* @return {number}
*/
readRXCS(addr, fPreWrite)
{
var w = this.regRXCS;
if (!fPreWrite) {
w &= RX11.RXCS.RMASK;
switch (this.funCode) {
case RX11.FUNC.FILL:
case RX11.FUNC.EMPTY:
if (this.iBuffer < this.abBuffer.length) {
this.regRXCS |= RX11.RXCS.TR;
}
break;
case RX11.FUNC.READ:
case RX11.FUNC.WRITE:
case RX11.FUNC.WRDEL:
if (this.iBuffer < 2) {
this.regRXCS |= RX11.RXCS.TR;
}
break;
}
}
return w;
}
/**
* writeRXCS(data, addr)
*
* @this {RX11}
* @param {number} data
* @param {number} addr (eg, PDP11.UNIBUS.RXCS or 177170)
*/
writeRXCS(data, addr)
{
this.regRXCS = (this.regRXCS & ~RX11.RXCS.WMASK) | (data & RX11.RXCS.WMASK);
if (this.regRXCS & RX11.RXCS.INIT) {
this.initController();
return;
}
if ((this.regRXCS & RX11.RXCS.GO) && this.funCode == RX11.FUNC.UNUSED) {
this.processCommand();
return;
}
if (!(this.regRXCS & RX11.RXCS.IE)) {
this.cpu.clearIRQ(this.irq);
}
else if (this.regRXCS & RX11.RXCS.DONE) {
this.cpu.setIRQ(this.irq);
}
}
/**
* readRXDB(addr)
*
* @this {RX11}
* @param {number} addr (eg, PDP11.UNIBUS.RXDB or 177172)
* @param {boolean} [fPreWrite]
* @return {number}
*/
readRXDB(addr, fPreWrite)
{
if (!fPreWrite) {
switch (this.funCode) {
case RX11.FUNC.EMPTY:
if (this.regRXCS & RX11.RXCS.TR) {
this.regRXCS &= ~RX11.RXCS.TR;
this.assert(this.iBuffer < this.abBuffer.length);
this.regRXDB = this.abBuffer[this.iBuffer] & 0xff;
if (this.messageEnabled()) this.printMessage(this.type + ".readByte(" + this.iBuffer + "): " + Str.toHexByte(this.regRXDB), true, true);
if (++this.iBuffer >= this.abBuffer.length) {
this.doneCommand();
}
}
break;
}
}
return this.regRXDB;
}
/**
* writeRXDB(data, addr)
*
* @this {RX11}
* @param {number} data
* @param {number} addr (eg, PDP11.UNIBUS.RXDB or 177172)
*/
writeRXDB(data, addr)
{
switch(this.funCode) {
case RX11.FUNC.FILL:
if (this.regRXCS & RX11.RXCS.TR) {
this.regRXCS &= ~RX11.RXCS.TR;
this.assert(this.iBuffer < this.abBuffer.length);
this.abBuffer[this.iBuffer] = data & 0xff;
if (this.messageEnabled()) this.printMessage(this.type + ".writeByte(" + this.iBuffer + "," + Str.toHexByte(data) + ")", true, true);
if (++this.iBuffer >= this.abBuffer.length) {
this.doneCommand();
}
}
break;
case RX11.FUNC.READ:
case RX11.FUNC.WRITE:
case RX11.FUNC.WRDEL:
if (this.regRXCS & RX11.RXCS.TR) {
this.regRXCS &= ~RX11.RXCS.TR;
switch(this.iBuffer++) {
case 0:
this.regRXSA = data;
break;
case 1:
this.regRXTA = data;
if (this.funCode == RX11.FUNC.READ) {
this.readSector();
} else {
this.writeSector(this.funCode == RX11.FUNC.WRDEL);
}
break;
default:
this.assert(false);
break;
}
}
break;
}
this.regRXDB = data;
}
}
/*
* Alias RX11 definitions as class constants
*/
RX11.RXCS = PDP11.RX11.RXCS; // 177170: Command and Status Register
RX11.RXDB = PDP11.RX11.RXDB; // 177172: Data Buffer Register
RX11.RXTA = PDP11.RX11.RXTA;
RX11.RXSA = PDP11.RX11.RXSA;
RX11.RXES = PDP11.RX11.RXES;
RX11.FUNC = PDP11.RX11.FUNC;
RX11.ERROR = PDP11.RX11.ERROR;
RX11.FUNCS = [
"FILL", "EMPTY", "WRITE", "READ", "UNUSED", "RDSTAT", "WRDEL", "RDERR"
];
/*
* ES6 ALERT: As you can see below, I've finally started using computed property names.
*/
RX11.UNIBUS_IOTABLE = {
[PDP11.UNIBUS.RXCS]: /* 177170 */ [null, null, RX11.prototype.readRXCS, RX11.prototype.writeRXCS, "RXCS"],
[PDP11.UNIBUS.RXDB]: /* 177172 */ [null, null, RX11.prototype.readRXDB, RX11.prototype.writeRXDB, "RXDB"]
};
if (NODE) module.exports = RX11;

3
modules/shared/lib/diskapi.js
View file

@ -93,8 +93,9 @@ DiskAPI.DISK_FORMATS = {
*/
21368320:[615,4,17], // PC AT 20Mb hard drive (type 2)
/*
* Assorted DEC disk pack formats.
* Assorted DEC disk formats.
*/
256256: [77, 1,26,128], // RX01 single-platter diskette: 77 tracks, 1 head, 26 sectors/track, 128 bytes/sector, for a total of 256256 bytes
2494464: [203,2,12,512], // RK03 single-platter disk cartridge: 203 tracks, 2 heads, 12 sectors/track, 512 bytes/sector, for a total of 2494464 bytes
5242880: [256,2,40,256], // RL01K single-platter disk cartridge: 256 tracks, 2 heads, 40 sectors/track, 256 bytes/sector, for a total of 5242880 bytes
10485760:[512,2,40,256] // RL02K single-platter disk cartridge: 512 tracks, 2 heads, 40 sectors/track, 256 bytes/sector, for a total of 10485760 bytes

1
package.json
View file

@ -203,6 +203,7 @@
"./modules/pdp11/lib/drive.js",
"./modules/pdp11/lib/rk11.js",
"./modules/pdp11/lib/rl11.js",
"./modules/pdp11/lib/rx11.js",
"./modules/shared/lib/debugger.js",
"./modules/pdp11/lib/debugger.js",
"./modules/pdp11/lib/computer.js",

67
pubs/dec/pdp11/README.md
View file

@ -4,7 +4,7 @@ title: DEC PDP-11 Publications and Papers
permalink: /pubs/dec/pdp11/
---
DEC PDP-11 Publications
PDP-11 Hardware Publications
---
This page summarizes PDP-11 documentation that was useful in creating [PDPjs](/modules/pdp11/). In most cases,
@ -29,6 +29,35 @@ directory. If a PDF was not searchable, it was "OCR'ed" before being archived b
- [PDP-11/70 Handbook (1976)](http://archive.pcjs.org/pubs/dec/pdp11/1170/PDP1170_Handbook_1976.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/1170/PDP-11_70_Handbook_1977-78.pdf)]
- [PDP-11/70 Handbook (1979)](http://archive.pcjs.org/pubs/dec/pdp11/1170/PDP1170_Handbook_1979.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/handbooks/PDP11_Handbook1979.pdf)]
[PDP-11 KW11](kw11/)
- [KW11-L Line Time Clock Manual (Apr 1973)](http://archive.pcjs.org/pubs/dec/pdp11/kw11/KW11L_Apr73.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/unibus/DEC-11-HKWB-D_KW11L_Apr73.pdf)]
- [KW11-L Line Time Clock Manual (Jul 1974)](http://archive.pcjs.org/pubs/dec/pdp11/kw11/KW11L_Jul74.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/1140/EK-KW11L_TM-002_KW11-L_Line_Time_Clock_Manual_Jul74.pdf)]
[PDP-11 M9312](m9312/)
- [M9312 Bootstrap/Terminator Module Technical Manual (Oct 1979)](http://archive.pcjs.org/pubs/dec/pdp11/m9312/M9312_Bootstrap_Terminator_Module_Technical_Manual.pdf)
[PDP-11 RK11](rk11/)
- [CXRKAG0 DEC/X11 RK11 MODULE (Sep 1978)](http://archive.pcjs.org/pubs/dec/pdp11/rk11/AC-E676G-MC_CXRKAG0-RK11_Sep78.pdf)
- [RK11-D and RK11-E Moving Head Disk Drive Controller Manual (Feb 1975)](http://archive.pcjs.org/pubs/dec/pdp11/rk11/EK-RK11D-MM-002.pdf)
[PDP-11 RL11](rl11/)
- [RL01/RL02 User Guide (Sep 1981)](http://archive.pcjs.org/pubs/dec/pdp11/rl11/EK-RL012-UG-005_Sep81.pdf)
[PDP-11 RX11](rx11/)
- [RX8/RX11 floppy disk system user's manual (Nov 1976)](http://archive.pcjs.org/pubs/dec/pdp11/rx11/EK-RX01-OP-001_RX11UM_Nov76.pdf)
[Other PDP-11 Peripherals](other/)
- [PDP-11 Peripherals Handbook (1976)](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Peripherals_Handbook_1976.pdf)
PDP-11 Software Publications
---
[PDP-11 BASIC](basic/)
- [PDP-11 BASIC Programming Manual (1970)](http://archive.pcjs.org/pubs/dec/pdp11/basic/BASIC_Programming_Manual_Dec70.pdf)
@ -49,44 +78,26 @@ directory. If a PDF was not searchable, it was "OCR'ed" before being archived b
- [CEQKCE0 11/70 INSTRUCTION EXERCISER (May 1980)](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-7994E-MC_CEQKCE0_1170_INSTRUCTION_EXERCISER_May80.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/microfiche/ftp.j-hoppe.de/bw/gh/AH-7996E-MC__PDP11-70-74__11-70_INST_EXR__CEQKCE0__%28C%2975,80.pdf)]
- [CFKAAC0 11/34 BASIC INSTRUCTION TEST (Oct 1978)](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-8041C-MC_CFKAAC0_1134_BSC_INST_TST_Oct78.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/xxdp/diag_listings/1134/AC-8041C-MC_CFKAAC0-1134-Bsc-Inst-Tst_Oct78.pdf)]
- [CXCPAG0 INSTRUCTION TEST (Sep 1978)](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-E664G-MC_CXCPAG0_PROCESSOR_TEST_Sep78.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/xxdp/x11_listings/AC-E664G-MC_CXCPAG0-Processor-test_Sep78.pdf)]
- [CZQMCF0 0-124K MEM EXER 16K (Feb 1978)](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-9045F-MC_CZQMCFO_MEM_EXER_16K_Feb78.pdf)
- [PDP-11 DIAGNOSTIC HANDBOOK (1988)](http://archive.pcjs.org/pubs/dec/pdp11/diags/PDP11_DiagnosticHandbook_1988.pdf)
- [Notes for XXDP+ and XXDP V2 Operating Systems (Feb 1993)](http://archive.pcjs.org/pubs/dec/pdp11/diags/XXDP_Notes_Feb93.pdf)
[PDP-11 KW11](kw11/)
- [KW11-L Line Time Clock Manual (Apr 1973)](http://archive.pcjs.org/pubs/dec/pdp11/kw11/KW11L_Apr73.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/unibus/DEC-11-HKWB-D_KW11L_Apr73.pdf)]
- [KW11-L Line Time Clock Manual (Jul 1974)](http://archive.pcjs.org/pubs/dec/pdp11/kw11/KW11L_Jul74.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/1140/EK-KW11L_TM-002_KW11-L_Line_Time_Clock_Manual_Jul74.pdf)]
[PDP-11 M9312](m9312/)
- [M9312 Bootstrap/Terminator Module Technical Manual (Oct 1979)](http://archive.pcjs.org/pubs/dec/pdp11/m9312/M9312_Bootstrap_Terminator_Module_Technical_Manual.pdf)
[PDP-11 MACRO-11](macro11/)
[MACRO-11](macro11/)
- [MACRO-11 Reference Manual (Dec 1975)](http://archive.pcjs.org/pubs/dec/pdp11/macro11/MACRO11_Dec75.pdf)
- [MACRO-11 Language Reference Manual (Mar 1983)](http://archive.pcjs.org/pubs/dec/pdp11/macro11/MACRO11_Mar83.pdf)
[PDP-11 PC11](pc11/)
[RT-11](rt11/)
- [LISTING OF PDP-11 ABSOLUTE LOADER (June 1975)](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Absolute_Loader_Listing_Jun75.pdf)
- [CZQMCF0 0-124K MEM EXER 16K (Feb 1978)](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Mem-Exer-16k_Feb78.pdf)
- [PDP-11 Paper Tape Software Handbook (Apr 1976)](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Paper_Tape_Software_Handbook.pdf)
- [RT-11 v4.0 Installation and System Generation Guide (Mar 1980)](http://archive.pcjs.org/pubs/dec/pdp11/rt11/AA-H376A-TC_RT-11_V4.0_Installation_Manual_Mar81.pdf)
[PDP-11 RK11](rk11/)
- [CXRKAG0 DEC/X11 RK11 MODULE (Sep 1978)](http://archive.pcjs.org/pubs/dec/pdp11/rk11/AC-E676G-MC_CXRKAG0-RK11_Sep78.pdf)
- [RK11-D and RK11-E Moving Head Disk Drive Controller Manual (Feb 1975)](http://archive.pcjs.org/pubs/dec/pdp11/rk11/EK-RK11D-MM-002.pdf)
[PDP-11 RL11](rl11/)
- [RL01/RL02 User Guide (Sep 1981)](http://archive.pcjs.org/pubs/dec/pdp11/rl11/EK-RL012-UG-005_Sep81.pdf)
---
[Assorted PDP-11 Handbooks](other/)
[Other PDP-11 Software](other/)
- [LISTING OF PDP-11 ABSOLUTE LOADER (June 1975)](http://archive.pcjs.org/pubs/dec/pdp11/other/DEC-11-UABLA_ABSOLUTE_LOADER_LISTING_Jun75.pdf)
- [PDP-11 Paper Tape Software Handbook (1976)](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Paper_Tape_Software_Handbook_1976.pdf)
- [PDP-11 Peripherals Handbook (1976)](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Peripherals_Handbook_1976.pdf)
- [PDP-11 Software Handbook (1978)](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Software_Handbook_1978.pdf)
PDP-11 Research Papers
---
[Assorted PDP-11 Papers](papers/)

1
pubs/dec/pdp11/diags/README.md
View file

@ -22,6 +22,7 @@ PDPjs development and testing relied on the following PDP-11 diagnostic publicat
- [CEQKCE0 11/70 INSTRUCTION EXERCISER (May 1980)](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-7994E-MC_CEQKCE0_1170_INSTRUCTION_EXERCISER_May80.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/microfiche/ftp.j-hoppe.de/bw/gh/AH-7996E-MC__PDP11-70-74__11-70_INST_EXR__CEQKCE0__%28C%2975,80.pdf)]
- [CFKAAC0 11/34 BASIC INSTRUCTION TEST (Oct 1978)](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-8041C-MC_CFKAAC0_1134_BSC_INST_TST_Oct78.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/xxdp/diag_listings/1134/AC-8041C-MC_CFKAAC0-1134-Bsc-Inst-Tst_Oct78.pdf)]
- [CXCPAG0 INSTRUCTION TEST (Sep 1978)](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-E664G-MC_CXCPAG0_PROCESSOR_TEST_Sep78.pdf) [[Original PDF](http://bitsavers.org/pdf/dec/pdp11/xxdp/x11_listings/AC-E664G-MC_CXCPAG0-Processor-test_Sep78.pdf)]
- [CZQMCF0 0-124K MEM EXER 16K (Feb 1978)](http://archive.pcjs.org/pubs/dec/pdp11/diags/AC-9045F-MC_CZQMCFO_MEM_EXER_16K_Feb78.pdf)
The *MAINDEC-11-DZQAB MAINDEC USER REFERENCE MANUAL (Oct 1973)* was particularly useful for understanding DEC's
[Paper Tape Diagnostics](/apps/pdp11/tapes/diags/).

1
pubs/dec/pdp11/other/README.md
View file

@ -9,6 +9,7 @@ DEC PDP-11 Assorted Handbooks
PDPjs development and testing relied on the following PDP-11 publications:
- [LISTING OF PDP-11 ABSOLUTE LOADER (June 1975)](http://archive.pcjs.org/pubs/dec/pdp11/other/DEC-11-UABLA_ABSOLUTE_LOADER_LISTING_Jun75.pdf)
- [PDP-11 Paper Tape Software Handbook (1976)](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Paper_Tape_Software_Handbook_1976.pdf)
- [PDP-11 Peripherals Handbook (1976)](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Peripherals_Handbook_1976.pdf)
- [PDP-11 Software Handbook (1978)](http://archive.pcjs.org/pubs/dec/pdp11/other/PDP11_Software_Handbook_1978.pdf)

14
pubs/dec/pdp11/pc11/README.md
View file

@ -1,14 +0,0 @@
---
layout: page
title: DEC PDP-11 PC11 Paper Tape Reader
permalink: /pubs/dec/pdp11/pc11/
---
DEC PDP-11 PC11 Paper Tape Reader
---
PDPjs development and testing relied on the following PDP-11 publications:
- [LISTING OF PDP-11 ABSOLUTE LOADER (June 1975)](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Absolute_Loader_Listing_Jun75.pdf)
- [CZQMCF0 0-124K MEM EXER 16K (Feb 1978)](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Mem-Exer-16k_Feb78.pdf)
- [PDP-11 Paper Tape Software Handbook (Apr 1976)](http://archive.pcjs.org/pubs/dec/pdp11/pc11/Paper_Tape_Software_Handbook.pdf)

12
pubs/dec/pdp11/rt11/README.md Normal file
View file

@ -0,0 +1,12 @@
---
layout: page
title: DEC RT-11 Publications
permalink: /pubs/dec/pdp11/rt11/
---
DEC RT-11 Publications
---
### RT-11 v4.0
- [RT-11 Installation and System Generation Guide (Mar 1980)](http://archive.pcjs.org/pubs/dec/pdp11/rt11/AA-H376A-TC_RT-11_V4.0_Installation_Manual_Mar81.pdf)

12
pubs/dec/pdp11/rx11/README.md Normal file
View file

@ -0,0 +1,12 @@
---
layout: page
title: DEC PDP-11 RX11 Disk Controller
permalink: /pubs/dec/pdp11/rx11/
---
DEC PDP-11 RX11 Disk Controller
---
PDPjs development and testing relied on the following PDP-11 publications:
- [RX8/RX11 floppy disk system user's manual (Nov 1976)](http://archive.pcjs.org/pubs/dec/pdp11/rx11/EK-RX01-OP-001_RX11UM_Nov76.pdf)

8
versions/pcx86/1.33.1/pcx86-dbg.js
View file

File diff suppressed because one or more lines are too long

8
versions/pcx86/1.33.1/pcx86.js
View file

File diff suppressed because one or more lines are too long

683
versions/pdpjs/1.33.1/pdp11-dbg.js
View file

File diff suppressed because one or more lines are too long

500
versions/pdpjs/1.33.1/pdp11.js
View file

File diff suppressed because one or more lines are too long