560 lines
19 KiB
JavaScript
560 lines
19 KiB
JavaScript
/**
|
|
* @fileoverview Implements the RL11 Disk Controller (for RL01 and RL02 Disks)
|
|
* @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 RL11 extends DriveController {
|
|
/**
|
|
* RL11(parms)
|
|
*
|
|
* The RL11 component has the following component-specific (parms) properties:
|
|
*
|
|
* autoMount: one or more JSON-encoded objects, each containing 'name' and 'path' properties
|
|
*
|
|
* The RL11 Disk Controller controls up to four RL01 or RL02 disk drives, which in turn read/write RL01K or
|
|
* RL02K disk cartridges. See [RL11 Disk Controller Configuration Files](/devices/pdp11/rl11/).
|
|
*
|
|
* 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). See [RL01K Disk Images](/disks/dec/rl01k/).
|
|
*
|
|
* 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). See [RL02K Disk Images](/disks/dec/rl02k/).
|
|
*
|
|
* @param {Object} parms
|
|
*/
|
|
constructor(parms)
|
|
{
|
|
super("RL11", parms, MessagesPDP11.RL11, PDP11.RL11, PDP11.RL11.RL02K, RL11.UNIBUS_IOTABLE);
|
|
|
|
/*
|
|
* Define all the registers required for this controller.
|
|
*/
|
|
this.regRLCS = this.regRLBA = this.regRLDA = this.tmpRLDA = this.regRLMP = this.regRLBE = 0;
|
|
}
|
|
|
|
/**
|
|
* initController(aRegs)
|
|
*
|
|
* @this {RL11}
|
|
* @param {Array} [aRegs]
|
|
* @return {boolean} true if successful, false if failure
|
|
*/
|
|
initController(aRegs)
|
|
{
|
|
if (!aRegs) {
|
|
aRegs = [(RL11.RLCS.DRDY | RL11.RLCS.CRDY), 0, 0, 0, 0, 0];
|
|
}
|
|
|
|
/*
|
|
* 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.regRLCS,
|
|
this.regRLBA,
|
|
this.regRLDA,
|
|
this.tmpRLDA,
|
|
this.regRLMP,
|
|
this.regRLBE
|
|
] = aRegs;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* saveController()
|
|
*
|
|
* Basically, the inverse of initController().
|
|
*
|
|
* @this {RL11}
|
|
* @return {Array}
|
|
*/
|
|
saveController()
|
|
{
|
|
return [
|
|
this.regRLCS,
|
|
this.regRLBA,
|
|
this.regRLDA,
|
|
this.tmpRLDA,
|
|
this.regRLMP,
|
|
this.regRLBE
|
|
];
|
|
}
|
|
|
|
/**
|
|
* processCommand()
|
|
*
|
|
* @this {RL11}
|
|
*/
|
|
processCommand()
|
|
{
|
|
var fInterrupt = true;
|
|
var fnReadWrite, sFunc = "";
|
|
var iDrive = (this.regRLCS & RL11.RLCS.DS) >> RL11.RLCS.SHIFT.DS;
|
|
var drive = this.aDrives[iDrive];
|
|
var disk = drive.disk;
|
|
var iCylinder, iHead, iSector, nWords, addr;
|
|
|
|
/*
|
|
* The typical pattern of DRDY and CRDY:
|
|
*
|
|
* 1) Normally both set
|
|
* 2) CRDY is cleared to process a command
|
|
* 3) DRDY is cleared to indicate a command in process
|
|
*/
|
|
this.regRLCS &= ~RL11.RLCS.DRDY;
|
|
|
|
switch(this.regRLCS & RL11.RLCS.FUNC) {
|
|
|
|
case RL11.FUNC.NOP:
|
|
case RL11.FUNC.WCHK:
|
|
case RL11.FUNC.RDNC:
|
|
break;
|
|
|
|
case RL11.FUNC.STATUS:
|
|
if (this.regRLMP & RL11.RLMP.GS_BH) {
|
|
this.regRLCS &= (RL11.RLCS.DRDY | RL11.RLCS.FUNC | RL11.RLCS.BAE); // TODO: Review
|
|
}
|
|
/*
|
|
* The bit indicating whether or not the disk contains 256 or 512 cylinders is critical;
|
|
* for example, the first RSTS/E disk image we tried was an RL01K, which has only 256 cylinders,
|
|
* and the operating system would crash mysteriously if we didn't report the correct geometry.
|
|
*/
|
|
this.regRLMP = drive.status | (this.tmpRLDA & RL11.RLDA.RW_HS) | (disk && disk.nCylinders == 512? RL11.RLMP.GS_DT : 0);
|
|
break;
|
|
|
|
case RL11.FUNC.SEEK:
|
|
if ((this.regRLDA & RL11.RLDA.GS_CMD) == RL11.RLDA.SEEK_CMD) {
|
|
var darCA = (this.regRLDA & RL11.RLDA.RW_CA);
|
|
var darHS = (this.regRLDA & RL11.RLDA.SEEK_HS) << 2;
|
|
if (this.regRLDA & RL11.RLDA.SEEK_DIR) {
|
|
this.tmpRLDA += darCA;
|
|
} else {
|
|
this.tmpRLDA -= darCA;
|
|
}
|
|
this.regRLDA = this.tmpRLDA = (this.tmpRLDA & RL11.RLDA.RW_CA) | darHS;
|
|
}
|
|
break;
|
|
|
|
case RL11.FUNC.RHDR:
|
|
this.regRLMP = this.tmpRLDA;
|
|
break;
|
|
|
|
case RL11.FUNC.RDATA:
|
|
sFunc = "READ";
|
|
fnReadWrite = this.readData;
|
|
/* falls through */
|
|
|
|
case RL11.FUNC.WDATA:
|
|
if (!sFunc) sFunc = "WRITE";
|
|
if (!fnReadWrite) fnReadWrite = this.writeData;
|
|
|
|
iCylinder = this.regRLDA >> RL11.RLDA.SHIFT.RW_CA;
|
|
iHead = (this.regRLDA & RL11.RLDA.RW_HS)? 1 : 0;
|
|
iSector = this.regRLDA & RL11.RLDA.RW_SA;
|
|
if (!disk || iCylinder >= disk.nCylinders || iSector >= disk.nSectors) {
|
|
this.regRLCS |= RL11.ERRC.HNF | RL11.RLCS.ERR;
|
|
break;
|
|
}
|
|
nWords = (0x10000 - this.regRLMP) & 0xffff;
|
|
addr = (((this.regRLBE & RL11.RLBE.MASK)) << 16) | this.regRLBA; // 22 bit mode
|
|
|
|
if (this.messageEnabled()) this.printMessage(this.type + ": " + sFunc + "(" + iCylinder + ":" + iHead + ":" + iSector + ") " + Str.toOct(addr) + "--" + Str.toOct(addr + (nWords << 1)), true, true);
|
|
|
|
fInterrupt = fnReadWrite.call(this, drive, iCylinder, iHead, iSector, nWords, addr, 2, false, this.doneReadWrite.bind(this));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (fInterrupt) {
|
|
this.regRLCS |= RL11.RLCS.DRDY | RL11.RLCS.CRDY;
|
|
if (this.regRLCS & RL11.RLCS.IE) this.cpu.setIRQ(this.irq);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* readData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
|
|
*
|
|
* @this {RL11}
|
|
* @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 checksum = 0;
|
|
var disk = drive.disk;
|
|
var sector = null, ibSector;
|
|
|
|
if (!disk) {
|
|
nError = RL11.ERRC.HNF; // TODO: Review
|
|
nWords = 0;
|
|
}
|
|
|
|
var sWords = "";
|
|
while (nWords) {
|
|
if (!sector) {
|
|
sector = disk.seek(iCylinder, iHead, iSector + 1);
|
|
if (!sector) {
|
|
nError = RL11.ERRC.HNF;
|
|
break;
|
|
}
|
|
ibSector = 0;
|
|
}
|
|
var b0, b1, data;
|
|
if ((b0 = disk.read(sector, ibSector++)) < 0 || (b1 = disk.read(sector, ibSector++)) < 0) {
|
|
nError = RL11.ERRC.HNF;
|
|
break;
|
|
}
|
|
/*
|
|
* Apparently, this controller honors the UNIBUS Map registers, which means we must call mapUnibus()
|
|
* on the address REGARDLESS whether it is actually >= BusPDP11.UNIBUS_22BIT. TODO: This is inherited
|
|
* code, so let's review the documentation on this.
|
|
*/
|
|
this.bus.setWordDirect(this.cpu.mapUnibus(addr), data = b0 | (b1 << 8));
|
|
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 (this.bus.checkFault()) {
|
|
nError = RL11.ERRC.NXM;
|
|
break;
|
|
}
|
|
addr += 2;
|
|
nWords--;
|
|
checksum += data;
|
|
if (ibSector >= disk.cbSector) {
|
|
sector = null;
|
|
if (++iSector >= disk.nSectors) {
|
|
iSector = 0;
|
|
if (++iHead >= disk.nHeads) {
|
|
iHead = 0;
|
|
if (++iCylinder >= disk.nCylinders) {
|
|
nError = RL11.ERRC.HNF;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (DEBUG && this.messageEnabled(MessagesPDP11.READ)) {
|
|
console.log("checksum: " + (checksum|0));
|
|
}
|
|
|
|
return done? done(nError, iCylinder, iHead, iSector, nWords, addr) : nError;
|
|
}
|
|
|
|
/**
|
|
* writeData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
|
|
*
|
|
* @this {RL11}
|
|
* @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)
|
|
*/
|
|
writeData(drive, iCylinder, iHead, iSector, nWords, addr, inc, fCheck, done)
|
|
{
|
|
var nError = 0;
|
|
var checksum = 0;
|
|
var disk = drive.disk;
|
|
var sector = null, ibSector;
|
|
|
|
if (!disk) {
|
|
nError = RL11.ERRC.HNF; // TODO: Review
|
|
nWords = 0;
|
|
}
|
|
|
|
var sWords = "";
|
|
while (nWords) {
|
|
/*
|
|
* Apparently, this controller honors the UNIBUS Map registers, which means we must call mapUnibus()
|
|
* on the address REGARDLESS whether it is actually >= BusPDP11.UNIBUS_22BIT. TODO: This is inherited
|
|
* code, so let's review the documentation on this.
|
|
*/
|
|
var data = this.bus.getWordDirect(this.cpu.mapUnibus(addr));
|
|
if (this.bus.checkFault()) {
|
|
nError = RL11.ERRC.NXM;
|
|
break;
|
|
}
|
|
if (DEBUG && this.messageEnabled(MessagesPDP11.WRITE)) {
|
|
if (!sWords) sWords = Str.toOct(addr) + ": ";
|
|
sWords += Str.toOct(data) + ' ';
|
|
if (sWords.length >= 64) {
|
|
console.log(sWords);
|
|
sWords = "";
|
|
}
|
|
}
|
|
addr += 2;
|
|
nWords--;
|
|
checksum += data;
|
|
if (!sector) {
|
|
sector = disk.seek(iCylinder, iHead, iSector + 1, true);
|
|
if (!sector) {
|
|
nError = RL11.ERRC.HNF;
|
|
break;
|
|
}
|
|
ibSector = 0;
|
|
}
|
|
if (!disk.write(sector, ibSector++, data & 0xff) || !disk.write(sector, ibSector++, data >> 8)) {
|
|
nError = RL11.ERRC.HNF;
|
|
break;
|
|
}
|
|
if (ibSector >= disk.cbSector) {
|
|
sector = null;
|
|
if (++iSector >= disk.nSectors) {
|
|
iSector = 0;
|
|
if (++iHead >= disk.nHeads) {
|
|
iHead = 0;
|
|
if (++iCylinder >= disk.nCylinders) {
|
|
nError = RL11.ERRC.HNF;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (DEBUG && this.messageEnabled(MessagesPDP11.WRITE)) {
|
|
console.log("checksum: " + (checksum|0));
|
|
}
|
|
|
|
return done? done(nError, iCylinder, iHead, iSector, nWords, addr) : nError;
|
|
}
|
|
|
|
/**
|
|
* doneReadWrite(nError, iCylinder, iHead, iSector, nWords, addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} nError
|
|
* @param {number} iCylinder
|
|
* @param {number} iHead
|
|
* @param {number} iSector
|
|
* @param {number} nWords
|
|
* @param {number} addr
|
|
* @return {boolean}
|
|
*/
|
|
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);
|
|
this.regRLBE = (addr >> 16) & RL11.RLBE.MASK; // 22 bit mode
|
|
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 (nError) {
|
|
this.regRLCS |= nError | RL11.RLCS.ERR;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* readRLCS(addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLCS or 174400)
|
|
* @return {number}
|
|
*/
|
|
readRLCS(addr)
|
|
{
|
|
return this.regRLCS & RL11.RLCS.RMASK;
|
|
}
|
|
|
|
/**
|
|
* writeRLCS(data, addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} data
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLCS or 174400)
|
|
*/
|
|
writeRLCS(data, addr)
|
|
{
|
|
this.regRLCS = (this.regRLCS & ~RL11.RLCS.WMASK) | (data & RL11.RLCS.WMASK);
|
|
this.regRLBE = (this.regRLBE & 0x3C) | ((data & RL11.RLCS.BAE) >> RL11.RLCS.SHIFT.BAE);
|
|
if (!(this.regRLCS & RL11.RLCS.CRDY)) this.processCommand();
|
|
}
|
|
|
|
/**
|
|
* readRLBA(addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLBA or 174402)
|
|
* @return {number}
|
|
*/
|
|
readRLBA(addr)
|
|
{
|
|
return this.regRLBA;
|
|
}
|
|
|
|
/**
|
|
* writeRLBA(data, addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} data
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLBA or 174402)
|
|
*/
|
|
writeRLBA(data, addr)
|
|
{
|
|
this.regRLBA = data & RL11.RLBA.WMASK;
|
|
}
|
|
|
|
/**
|
|
* readRLDA(addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLDA or 174404)
|
|
* @return {number}
|
|
*/
|
|
readRLDA(addr)
|
|
{
|
|
return this.regRLDA;
|
|
}
|
|
|
|
/**
|
|
* writeRLDA(data, addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} data
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLDA or 174404)
|
|
*/
|
|
writeRLDA(data, addr)
|
|
{
|
|
this.regRLDA = data;
|
|
}
|
|
|
|
/**
|
|
* readRLMP(addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLMP or 174406)
|
|
* @return {number}
|
|
*/
|
|
readRLMP(addr)
|
|
{
|
|
return this.regRLMP;
|
|
}
|
|
|
|
/**
|
|
* writeRLMP(data, addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} data
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLMP or 174406)
|
|
*/
|
|
writeRLMP(data, addr)
|
|
{
|
|
this.regRLMP = data;
|
|
}
|
|
|
|
/**
|
|
* readRLBE(addr)
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLBE or 174410)
|
|
* @return {number}
|
|
*/
|
|
readRLBE(addr)
|
|
{
|
|
return this.regRLBE;
|
|
}
|
|
|
|
/**
|
|
* writeRLBE(data, addr)
|
|
*
|
|
* Curiously, we see RSTS/E v7.0 writing RLBE bits that aren't documented:
|
|
*
|
|
* R0=000000 R1=000000 R2=174410 R3=000000 R4=102076 R5=045166
|
|
* SP=052662 PC=067624 PS=034344 IR=000000 SL=000377 T0 N0 Z1 V0 C0
|
|
* 067624: 012712 000300 MOV #300,@R2
|
|
*
|
|
* @this {RL11}
|
|
* @param {number} data
|
|
* @param {number} addr (eg, PDP11.UNIBUS.RLBE or 174410)
|
|
*/
|
|
writeRLBE(data, addr)
|
|
{
|
|
this.regRLBE = data & RL11.RLBE.MASK;
|
|
this.regRLCS = (this.regRLCS & ~RL11.RLCS.BAE) | ((this.regRLBE & 0x3) << RL11.RLCS.SHIFT.BAE);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Alias RL11 definitions as class constants
|
|
*/
|
|
RL11.RLCS = PDP11.RL11.RLCS; // 174400: Control Status Register
|
|
RL11.RLBA = PDP11.RL11.RLBA; // 174402: Bus Address Register
|
|
RL11.RLDA = PDP11.RL11.RLDA; // 174404: Disk Address Register
|
|
RL11.RLMP = PDP11.RL11.RLMP; // 177406: Multi-Purpose Register
|
|
RL11.RLBE = PDP11.RL11.RLBE; // 174410: Bus (Address) Extension Register
|
|
RL11.ERRC = PDP11.RL11.ERRC; // NOTE: These error codes are pre-shifted to read/write directly from/to RLCS.ERRC
|
|
RL11.FUNC = PDP11.RL11.FUNC; // NOTE: These function codes are pre-shifted to read/write directly from/to RLCS.FUNC
|
|
|
|
/*
|
|
* ES6 ALERT: As you can see below, I've finally started using computed property names.
|
|
*/
|
|
RL11.UNIBUS_IOTABLE = {
|
|
[PDP11.UNIBUS.RLCS]: /* 174400 */ [null, null, RL11.prototype.readRLCS, RL11.prototype.writeRLCS, "RLCS"],
|
|
[PDP11.UNIBUS.RLBA]: /* 174402 */ [null, null, RL11.prototype.readRLBA, RL11.prototype.writeRLBA, "RLBA"],
|
|
[PDP11.UNIBUS.RLDA]: /* 174404 */ [null, null, RL11.prototype.readRLDA, RL11.prototype.writeRLDA, "RLDA"],
|
|
[PDP11.UNIBUS.RLMP]: /* 174406 */ [null, null, RL11.prototype.readRLMP, RL11.prototype.writeRLMP, "RLMP"],
|
|
[PDP11.UNIBUS.RLBE]: /* 174410 */ [null, null, RL11.prototype.readRLBE, RL11.prototype.writeRLBE, "RLBE"]
|
|
};
|
|
|
|
if (NODE) module.exports = RL11;
|