1017 lines
35 KiB
TypeScript
1017 lines
35 KiB
TypeScript
import { base64_encode } from '../base64';
|
||
import type {
|
||
byte,
|
||
Card,
|
||
memory,
|
||
nibble,
|
||
rom,
|
||
} from '../types';
|
||
|
||
import {
|
||
FormatWorkerMessage,
|
||
FormatWorkerResponse,
|
||
NibbleFormat,
|
||
DISK_PROCESSED,
|
||
DRIVE_NUMBERS,
|
||
DriveNumber,
|
||
JSONDisk,
|
||
ENCODING_NIBBLE,
|
||
PROCESS_BINARY,
|
||
PROCESS_JSON_DISK,
|
||
PROCESS_JSON,
|
||
ENCODING_BITSTREAM,
|
||
MassStorageData,
|
||
} from '../formats/types';
|
||
|
||
import {
|
||
createDisk,
|
||
createDiskFromJsonDisk
|
||
} from '../formats/create_disk';
|
||
|
||
import { toHex } from '../util';
|
||
import { jsonDecode, jsonEncode, readSector } from '../formats/format_utils';
|
||
|
||
import { BOOTSTRAP_ROM_16, BOOTSTRAP_ROM_13 } from '../roms/cards/disk2';
|
||
import Apple2IO from '../apple2io';
|
||
|
||
/** Softswitch locations */
|
||
const LOC = {
|
||
// Disk II Controller Commands
|
||
// See Understanding the Apple IIe, Table 9.1
|
||
PHASE0OFF: 0x80, // Q0L: Phase 0 OFF
|
||
PHASE0ON: 0x81, // Q0H: Phase 0 ON
|
||
PHASE1OFF: 0x82, // Q1L: Phase 1 OFF
|
||
PHASE1ON: 0x83, // Q1H: Phase 1 ON
|
||
PHASE2OFF: 0x84, // Q2L: Phase 2 OFF
|
||
PHASE2ON: 0x85, // Q2H: Phase 2 ON
|
||
PHASE3OFF: 0x86, // Q3L: Phase 3 OFF
|
||
PHASE3ON: 0x87, // Q3H: Phase 3 ON
|
||
|
||
DRIVEOFF: 0x88, // Q4L: Drives OFF
|
||
DRIVEON: 0x89, // Q4H: Selected drive ON
|
||
DRIVE1: 0x8A, // Q5L: Select drive 1
|
||
DRIVE2: 0x8B, // Q5H: Select drive 2
|
||
DRIVEREAD: 0x8C, // Q6L: Shift while writing; read data
|
||
DRIVEWRITE: 0x8D, // Q6H: Load while writing; read write protect
|
||
DRIVEREADMODE: 0x8E, // Q7L: Read
|
||
DRIVEWRITEMODE: 0x8F // Q7H: Write
|
||
} as const;
|
||
|
||
/** Logic state sequencer ROM */
|
||
// See Understanding the Apple IIe, Table 9.3 Logic State Sequencer Commands
|
||
// CODE OPERATION BEFORE AFTER
|
||
// 0 CLR XXXXXXXX 00000000
|
||
// 8 NOP ABCDEFGH ABCDEFGH
|
||
// 9 SL0 ABCDEFGH BCDEFGH0
|
||
// A SR (write protected) ABCDEFGH 11111111
|
||
// (not write protected) ABCDEFGH 0ABCDEFG
|
||
// B LOAD XXXXXXXX YYYYYYYY
|
||
// D SL1 ABCDEFGH BCDEFGH1
|
||
|
||
const SEQUENCER_ROM_13 = [
|
||
// See Understanding the Apple IIe, Figure 9.10 The DOS 3.2 Logic State Sequencer
|
||
// Note that the column order here is NOT the same as in Figure 9.10 for Q7 H (Write).
|
||
//
|
||
// Q7 L (Read) Q7 H (Write)
|
||
// Q6 L (Shift) Q6 H (Load) Q6 L (Shift) Q6 H (Load)
|
||
// QA L QA H QA L QA H QA L QA H QA L QA H
|
||
// 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
|
||
0xD8, 0x18, 0x18, 0x08, 0x0A, 0x0A, 0x0A, 0x0A, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, // 0
|
||
0xD8, 0x2D, 0x28, 0x28, 0x0A, 0x0A, 0x0A, 0x0A, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, // 1
|
||
0xD8, 0x38, 0x38, 0x38, 0x0A, 0x0A, 0x0A, 0x0A, 0x39, 0x39, 0x39, 0x39, 0x3B, 0x3B, 0x3B, 0x3B, // 2
|
||
0xD8, 0x48, 0xD8, 0x48, 0x0A, 0x0A, 0x0A, 0x0A, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, // 3
|
||
0xD8, 0x58, 0xD8, 0x58, 0x0A, 0x0A, 0x0A, 0x0A, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, // 4
|
||
0xD8, 0x68, 0xD8, 0x68, 0x0A, 0x0A, 0x0A, 0x0A, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, // 5
|
||
0xD8, 0x78, 0xD8, 0x78, 0x0A, 0x0A, 0x0A, 0x0A, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, // 6
|
||
0xD8, 0x88, 0xD8, 0x88, 0x0A, 0x0A, 0x0A, 0x0A, 0x08, 0x08, 0x88, 0x88, 0x08, 0x08, 0x88, 0x88, // 7
|
||
0xD8, 0x98, 0xD8, 0x98, 0x0A, 0x0A, 0x0A, 0x0A, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, // 8
|
||
0xD8, 0x09, 0xD8, 0xA8, 0x0A, 0x0A, 0x0A, 0x0A, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, // 9
|
||
0xCD, 0xBD, 0xD8, 0xB8, 0x0A, 0x0A, 0x0A, 0x0A, 0xB9, 0xB9, 0xB9, 0xB9, 0xBB, 0xBB, 0xBB, 0xBB, // A
|
||
0xD9, 0x39, 0xD8, 0xC8, 0x0A, 0x0A, 0x0A, 0x0A, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, // B
|
||
0xD9, 0xD9, 0xD8, 0xA0, 0x0A, 0x0A, 0x0A, 0x0A, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, // C
|
||
0x1D, 0x0D, 0xE8, 0xE8, 0x0A, 0x0A, 0x0A, 0x0A, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, // D
|
||
0xFD, 0xFD, 0xF8, 0xF8, 0x0A, 0x0A, 0x0A, 0x0A, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, // E
|
||
0xDD, 0x4D, 0xE0, 0xE0, 0x0A, 0x0A, 0x0A, 0x0A, 0x88, 0x88, 0x08, 0x08, 0x88, 0x88, 0x08, 0x08 // F
|
||
] as const;
|
||
|
||
const SEQUENCER_ROM_16 = [
|
||
// See Understanding the Apple IIe, Figure 9.11 The DOS 3.3 Logic State Sequencer
|
||
// Note that the column order here is NOT the same as in Figure 9.11 for Q7 H (Write).
|
||
//
|
||
// Q7 L (Read) Q7 H (Write)
|
||
// Q6 L (Shift) Q6 H (Load) Q6 L (Shift) Q6 H (Load)
|
||
// QA L QA H QA L QA H QA L QA H QA L QA H
|
||
// 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
|
||
0x18, 0x18, 0x18, 0x18, 0x0A, 0x0A, 0x0A, 0x0A, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, // 0
|
||
0x2D, 0x2D, 0x38, 0x38, 0x0A, 0x0A, 0x0A, 0x0A, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, // 1
|
||
0xD8, 0x38, 0x08, 0x28, 0x0A, 0x0A, 0x0A, 0x0A, 0x39, 0x39, 0x39, 0x39, 0x3B, 0x3B, 0x3B, 0x3B, // 2
|
||
0xD8, 0x48, 0x48, 0x48, 0x0A, 0x0A, 0x0A, 0x0A, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, // 3
|
||
0xD8, 0x58, 0xD8, 0x58, 0x0A, 0x0A, 0x0A, 0x0A, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, // 4
|
||
0xD8, 0x68, 0xD8, 0x68, 0x0A, 0x0A, 0x0A, 0x0A, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, // 5
|
||
0xD8, 0x78, 0xD8, 0x78, 0x0A, 0x0A, 0x0A, 0x0A, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, // 6
|
||
0xD8, 0x88, 0xD8, 0x88, 0x0A, 0x0A, 0x0A, 0x0A, 0x08, 0x08, 0x88, 0x88, 0x08, 0x08, 0x88, 0x88, // 7
|
||
0xD8, 0x98, 0xD8, 0x98, 0x0A, 0x0A, 0x0A, 0x0A, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, // 8
|
||
0xD8, 0x29, 0xD8, 0xA8, 0x0A, 0x0A, 0x0A, 0x0A, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, // 9
|
||
0xCD, 0xBD, 0xD8, 0xB8, 0x0A, 0x0A, 0x0A, 0x0A, 0xB9, 0xB9, 0xB9, 0xB9, 0xBB, 0xBB, 0xBB, 0xBB, // A
|
||
0xD9, 0x59, 0xD8, 0xC8, 0x0A, 0x0A, 0x0A, 0x0A, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, // B
|
||
0xD9, 0xD9, 0xD8, 0xA0, 0x0A, 0x0A, 0x0A, 0x0A, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, // C
|
||
0xD8, 0x08, 0xE8, 0xE8, 0x0A, 0x0A, 0x0A, 0x0A, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, // D
|
||
0xFD, 0xFD, 0xF8, 0xF8, 0x0A, 0x0A, 0x0A, 0x0A, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, // E
|
||
0xDD, 0x4D, 0xE0, 0xE0, 0x0A, 0x0A, 0x0A, 0x0A, 0x88, 0x88, 0x08, 0x08, 0x88, 0x88, 0x08, 0x08 // F
|
||
] as const;
|
||
|
||
type LssClockCycle = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
|
||
type Phase = 0 | 1 | 2 | 3;
|
||
|
||
/**
|
||
* How far the head moves, in quarter tracks, when in phase X and phase Y is
|
||
* activated. For example, if in phase 0 (top row), turning on phase 3 would
|
||
* step backwards a quarter track while turning on phase 2 would step forwards
|
||
* a half track.
|
||
*
|
||
* Note that this emulation is highly simplified as it only takes into account
|
||
* the order that coils are powered on and ignores when they are powered off.
|
||
* The actual hardware allows for multiple coils to be powered at the same time
|
||
* providing different levels of torque on the head arm. Along with that, the
|
||
* RWTS uses a complex delay system to drive the coils faster based on expected
|
||
* head momentum.
|
||
*
|
||
* Examining the https://computerhistory.org/blog/apple-ii-dos-source-code/,
|
||
* one finds that the SEEK routine on line 4831 of `appdos31.lst`. It uses
|
||
* `ONTABLE` and `OFFTABLE` (each 12 bytes) to know exactly how many
|
||
* microseconds to power on/off each coil as the head accelerates. At the end,
|
||
* the final coil is left powered on 9.5 milliseconds to ensure the head has
|
||
* settled.
|
||
*
|
||
* https://embeddedmicro.weebly.com/apple-2iie.html shows traces of the boot
|
||
* seek (which is slightly different) and a regular seek.
|
||
*/
|
||
const PHASE_DELTA = [
|
||
[0, 1, 2, -1],
|
||
[-1, 0, 1, 2],
|
||
[-2, -1, 0, 1],
|
||
[1, -2, -1, 0]
|
||
] as const;
|
||
export interface Callbacks {
|
||
driveLight: (drive: DriveNumber, on: boolean) => void;
|
||
dirty: (drive: DriveNumber, dirty: boolean) => void;
|
||
label: (drive: DriveNumber, name?: string, side?: string) => void;
|
||
}
|
||
|
||
/** Common information for Nibble and WOZ disks. */
|
||
|
||
interface BaseDrive {
|
||
/** Current disk format. */
|
||
format: NibbleFormat;
|
||
/** Current disk volume number. */
|
||
volume: byte;
|
||
/** Displayed disk name */
|
||
name: string;
|
||
/** (Optional) Disk side (Front/Back, A/B) */
|
||
side?: string | undefined;
|
||
/** Quarter track position of read/write head. */
|
||
track: byte;
|
||
/** Position of the head on the track. */
|
||
head: byte;
|
||
/** Current active coil in the head stepper motor. */
|
||
phase: Phase;
|
||
/** Whether the drive write protect is on. */
|
||
readOnly: boolean;
|
||
/** Whether the drive has been written to since it was loaded. */
|
||
dirty: boolean;
|
||
}
|
||
|
||
/** WOZ format track data from https://applesaucefdc.com/woz/reference2/. */
|
||
interface WozDrive extends BaseDrive {
|
||
/** Woz encoding */
|
||
encoding: typeof ENCODING_BITSTREAM;
|
||
/** Maps quarter tracks to data in rawTracks; `0xFF` = random garbage. */
|
||
trackMap: byte[];
|
||
/** Unique track bitstreams. The index is arbitrary; it is NOT the track number. */
|
||
rawTracks: Uint8Array[];
|
||
}
|
||
|
||
/** Nibble format track data. */
|
||
interface NibbleDrive extends BaseDrive {
|
||
/** Nibble encoding */
|
||
encoding: typeof ENCODING_NIBBLE;
|
||
/** Nibble data. The index is the track number. */
|
||
tracks: memory[];
|
||
}
|
||
|
||
type Drive = WozDrive | NibbleDrive;
|
||
|
||
function isNibbleDrive(drive: Drive): drive is NibbleDrive {
|
||
return drive.encoding === ENCODING_NIBBLE;
|
||
}
|
||
|
||
function isWozDrive(drive: Drive): drive is WozDrive {
|
||
return drive.encoding === ENCODING_BITSTREAM;
|
||
}
|
||
|
||
interface DriveState {
|
||
format: NibbleFormat;
|
||
encoding: typeof ENCODING_BITSTREAM | typeof ENCODING_NIBBLE;
|
||
volume: byte;
|
||
name: string;
|
||
side?: string | undefined;
|
||
tracks: memory[];
|
||
track: byte;
|
||
head: byte;
|
||
phase: Phase;
|
||
readOnly: boolean;
|
||
dirty: boolean;
|
||
trackMap: number[];
|
||
rawTracks: Uint8Array[];
|
||
}
|
||
|
||
interface State {
|
||
drives: DriveState[];
|
||
skip: number;
|
||
latch: number;
|
||
writeMode: boolean;
|
||
on: boolean;
|
||
drive: DriveNumber;
|
||
}
|
||
|
||
function getDriveState(drive: Drive): DriveState {
|
||
const result: DriveState = {
|
||
format: drive.format,
|
||
encoding: drive.encoding,
|
||
volume: drive.volume,
|
||
name: drive.name,
|
||
side: drive.side,
|
||
tracks: [],
|
||
track: drive.track,
|
||
head: drive.head,
|
||
phase: drive.phase,
|
||
readOnly: drive.readOnly,
|
||
dirty: drive.dirty,
|
||
trackMap: [],
|
||
rawTracks: [],
|
||
};
|
||
|
||
if (isNibbleDrive(drive)) {
|
||
for (let idx = 0; idx < drive.tracks.length; idx++) {
|
||
result.tracks.push(new Uint8Array(drive.tracks[idx]));
|
||
}
|
||
}
|
||
if (isWozDrive(drive)) {
|
||
result.trackMap = [...drive.trackMap];
|
||
for (let idx = 0; idx < drive.rawTracks.length; idx++) {
|
||
result.rawTracks.push(new Uint8Array(drive.rawTracks[idx]));
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function setDriveState(state: DriveState) {
|
||
let result: Drive;
|
||
if (state.encoding === ENCODING_NIBBLE) {
|
||
result = {
|
||
format: state.format,
|
||
encoding: ENCODING_NIBBLE,
|
||
volume: state.volume,
|
||
name: state.name,
|
||
side: state.side,
|
||
tracks: [],
|
||
track: state.track,
|
||
head: state.head,
|
||
phase: state.phase,
|
||
readOnly: state.readOnly,
|
||
dirty: state.dirty,
|
||
};
|
||
for (let idx = 0; idx < state.tracks.length; idx++) {
|
||
result.tracks.push(new Uint8Array(state.tracks[idx]));
|
||
}
|
||
} else {
|
||
result = {
|
||
format: state.format,
|
||
encoding: ENCODING_BITSTREAM,
|
||
volume: state.volume,
|
||
name: state.name,
|
||
side: state.side,
|
||
track: state.track,
|
||
head: state.head,
|
||
phase: state.phase,
|
||
readOnly: state.readOnly,
|
||
dirty: state.dirty,
|
||
trackMap: [...state.trackMap],
|
||
rawTracks: [],
|
||
};
|
||
for (let idx = 0; idx < state.rawTracks.length; idx++) {
|
||
result.rawTracks.push(new Uint8Array(state.rawTracks[idx]));
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* Emulates the 16-sector and 13-sector versions of the Disk ][ drive and controller.
|
||
*/
|
||
export default class DiskII implements Card<State> {
|
||
|
||
private drives: Drive[] = [
|
||
{ // Drive 1
|
||
format: 'dsk',
|
||
encoding: ENCODING_NIBBLE,
|
||
volume: 254,
|
||
name: 'Disk 1',
|
||
tracks: [],
|
||
track: 0,
|
||
head: 0,
|
||
phase: 0,
|
||
readOnly: false,
|
||
dirty: false,
|
||
},
|
||
{ // Drive 2
|
||
format: 'dsk',
|
||
encoding: ENCODING_NIBBLE,
|
||
volume: 254,
|
||
name: 'Disk 2',
|
||
tracks: [],
|
||
track: 0,
|
||
head: 0,
|
||
phase: 0,
|
||
readOnly: false,
|
||
dirty: false,
|
||
}];
|
||
|
||
/**
|
||
* When `1`, the next nibble will be available for read; when `0`,
|
||
* the card is pretending to wait for data to be shifted in by the
|
||
* sequencer.
|
||
*/
|
||
private skip = 0;
|
||
/** Last data written by the CPU to card softswitch 0x8D. */
|
||
private bus = 0;
|
||
/** Drive data register. */
|
||
private latch = 0;
|
||
/** Drive off timeout id or null. */
|
||
private offTimeout: number | null = null;
|
||
/** Q6 (Shift/Load): Used by WOZ disks. */
|
||
private q6 = 0;
|
||
/** Q7 (Read/Write): Used by WOZ disks. */
|
||
private q7: boolean = false;
|
||
/** Q7 (Read/Write): Used by Nibble disks. */
|
||
private writeMode = false;
|
||
/** Whether the selected drive is on. */
|
||
private on = false;
|
||
/** Current drive number (1, 2). */
|
||
private drive: DriveNumber = 1;
|
||
/** Current drive object. */
|
||
private cur = this.drives[this.drive - 1];
|
||
|
||
/** Nibbles read this on cycle */
|
||
private nibbleCount = 0;
|
||
|
||
/** Q0-Q3: Coil states. */
|
||
private q = [false, false, false, false];
|
||
|
||
/** The 8-cycle LSS clock. */
|
||
private clock: LssClockCycle = 0;
|
||
/** Current CPU cycle count. */
|
||
private lastCycles = 0;
|
||
/** Current state of the Logic State Sequencer. */
|
||
private state: nibble = 0;
|
||
/**
|
||
* Number of zeros read in a row. The Disk ][ can only read two zeros in a
|
||
* row reliably; above that and the drive starts reporting garbage. See
|
||
* "Freaking Out Like a MC3470" in the WOZ spec.
|
||
*/
|
||
private zeros = 0;
|
||
|
||
/** Contents of the P5 ROM at 0xCnXX. */
|
||
private bootstrapRom: rom;
|
||
/** Contents of the P6 ROM. */
|
||
private sequencerRom: typeof SEQUENCER_ROM_16 | typeof SEQUENCER_ROM_13;
|
||
|
||
private worker: Worker;
|
||
|
||
/** Builds a new Disk ][ card. */
|
||
constructor(private io: Apple2IO, private callbacks: Callbacks, private sectors = 16) {
|
||
this.debug('Disk ][');
|
||
|
||
this.lastCycles = this.io.cycles();
|
||
this.bootstrapRom = this.sectors === 16 ? BOOTSTRAP_ROM_16 : BOOTSTRAP_ROM_13;
|
||
this.sequencerRom = this.sectors === 16 ? SEQUENCER_ROM_16 : SEQUENCER_ROM_13;
|
||
// From the example in UtA2e, p. 9-29, col. 1, para. 1., this is
|
||
// essentially the start of the sequencer loop and produces
|
||
// correctly synced nibbles immediately. Starting at state 0
|
||
// would introduce a spurrious 1 in the latch at the beginning,
|
||
// which requires reading several more sync bytes to sync up.
|
||
this.state = 2;
|
||
|
||
this.initWorker();
|
||
}
|
||
|
||
private debug(..._args: unknown[]) {
|
||
// debug(..._args);
|
||
}
|
||
|
||
public head(): number {
|
||
return this.cur.head;
|
||
}
|
||
|
||
/**
|
||
* Spin the disk under the read/write head for WOZ images.
|
||
*
|
||
* This implementation emulates every clock cycle of the 2 MHz
|
||
* sequencer since the last time it was called in order to
|
||
* determine the current state. Because this is called on
|
||
* every access to the softswitches, the data in the latch
|
||
* will be correct on every read.
|
||
*
|
||
* The emulation of the disk makes a few simplifying assumptions:
|
||
*
|
||
* * The motor turns on instantly.
|
||
* * The head moves tracks instantly.
|
||
* * The length (in bits) of each track of the WOZ image
|
||
* represents one full rotation of the disk and that each
|
||
* bit is evenly spaced.
|
||
* * Writing will not change the track length. This means
|
||
* that short tracks stay short.
|
||
* * The read head picks up the next bit when the sequencer
|
||
* clock === 4.
|
||
* * Head position X on track T is equivalent to head position
|
||
* X on track T′. (This is not the recommendation in the WOZ
|
||
* spec.)
|
||
* * Unspecified tracks contain a single zero bit. (A very
|
||
* short track, indeed!)
|
||
* * Two zero bits are sufficient to cause the MC3470 to freak
|
||
* out. When freaking out, it returns 0 and 1 with equal
|
||
* probability.
|
||
* * Any softswitch changes happen before `moveHead`. This is
|
||
* important because it means that if the clock is ever
|
||
* advanced more than one cycle between calls, the
|
||
* softswitch changes will appear to happen at the very
|
||
* beginning, not just before the last cycle.
|
||
*/
|
||
private moveHead() {
|
||
// TODO(flan): Short-circuit if the drive is not on.
|
||
const cycles = this.io.cycles();
|
||
|
||
// Spin the disk the number of elapsed cycles since last call
|
||
let workCycles = (cycles - this.lastCycles) * 2;
|
||
this.lastCycles = cycles;
|
||
|
||
if (!isWozDrive(this.cur)) {
|
||
return;
|
||
}
|
||
const track =
|
||
this.cur.rawTracks[this.cur.trackMap[this.cur.track]] || [0];
|
||
|
||
while (workCycles-- > 0) {
|
||
let pulse: number = 0;
|
||
if (this.clock === 4) {
|
||
pulse = track[this.cur.head];
|
||
if (!pulse) {
|
||
// More than 2 zeros can not be read reliably.
|
||
if (++this.zeros > 2) {
|
||
pulse = Math.random() >= 0.5 ? 1 : 0;
|
||
}
|
||
} else {
|
||
this.zeros = 0;
|
||
}
|
||
}
|
||
|
||
let idx = 0;
|
||
idx |= pulse ? 0x00 : 0x01;
|
||
idx |= this.latch & 0x80 ? 0x02 : 0x00;
|
||
idx |= this.q6 ? 0x04 : 0x00;
|
||
idx |= this.q7 ? 0x08 : 0x00;
|
||
idx |= this.state << 4;
|
||
|
||
const command = this.sequencerRom[idx];
|
||
|
||
this.debug(`clock: ${this.clock} state: ${toHex(this.state)} pulse: ${pulse} command: ${toHex(command)} q6: ${this.q6} latch: ${toHex(this.latch)}`);
|
||
|
||
switch (command & 0xf) {
|
||
case 0x0: // CLR
|
||
this.latch = 0;
|
||
break;
|
||
case 0x8: // NOP
|
||
break;
|
||
case 0x9: // SL0
|
||
this.latch = (this.latch << 1) & 0xff;
|
||
break;
|
||
case 0xA: // SR
|
||
this.latch >>= 1;
|
||
if (this.cur.readOnly) {
|
||
this.latch |= 0x80;
|
||
}
|
||
break;
|
||
case 0xB: // LD
|
||
this.latch = this.bus;
|
||
this.debug('Loading', toHex(this.latch), 'from bus');
|
||
break;
|
||
case 0xD: // SL1
|
||
this.latch = ((this.latch << 1) | 0x01) & 0xff;
|
||
break;
|
||
default:
|
||
this.debug(`unknown command: ${toHex(command & 0xf)}`);
|
||
}
|
||
this.state = (command >> 4 & 0xF) as nibble;
|
||
|
||
if (this.clock === 4) {
|
||
if (this.on) {
|
||
if (this.q7) {
|
||
track[this.cur.head] = this.state & 0x8 ? 0x01 : 0x00;
|
||
this.debug('Wrote', this.state & 0x8 ? 0x01 : 0x00);
|
||
}
|
||
|
||
if (++this.cur.head >= track.length) {
|
||
this.cur.head = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (++this.clock > 7) {
|
||
this.clock = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Only called for non-WOZ disks
|
||
private readWriteNext() {
|
||
if (!isNibbleDrive(this.cur)) {
|
||
return;
|
||
}
|
||
if (this.on && (this.skip || this.writeMode)) {
|
||
const track = this.cur.tracks[this.cur.track >> 2];
|
||
if (track && track.length) {
|
||
if (this.cur.head >= track.length) {
|
||
this.cur.head = 0;
|
||
}
|
||
|
||
if (this.writeMode) {
|
||
if (!this.cur.readOnly) {
|
||
track[this.cur.head] = this.bus;
|
||
if (!this.cur.dirty) {
|
||
this.updateDirty(this.drive, true);
|
||
}
|
||
}
|
||
} else {
|
||
this.latch = track[this.cur.head];
|
||
}
|
||
|
||
++this.cur.head;
|
||
}
|
||
} else {
|
||
this.latch = 0;
|
||
}
|
||
this.skip = (++this.skip % 2);
|
||
}
|
||
|
||
/**
|
||
* Sets whether the head positioning stepper motor coil for the given
|
||
* phase is on or off. Normally, the motor must be stepped two phases
|
||
* per track. Half tracks can be written by stepping only once; quarter
|
||
* tracks by activating two neighboring coils at once.
|
||
*/
|
||
private setPhase(phase: Phase, on: boolean) {
|
||
// According to Sather, UtA2e, p. 9-12, Drive On/Off and Drive
|
||
// Select:
|
||
// Turning a drive on ($C089,X) [...]:
|
||
// 1. [...]
|
||
// 5. [...] enables head positioning [...]
|
||
//
|
||
// Therefore do nothing if no drive is on.
|
||
if (!this.on) {
|
||
this.debug(`ignoring phase ${phase}${on ? ' on' : ' off'}`);
|
||
return;
|
||
}
|
||
|
||
this.debug(`phase ${phase}${on ? ' on' : ' off'}`);
|
||
if (on) {
|
||
this.cur.track += PHASE_DELTA[this.cur.phase][phase] * 2;
|
||
this.cur.phase = phase;
|
||
}
|
||
|
||
// The emulator clamps the track to the valid track range available
|
||
// in the image, but real Disk II drives can seek past track 34 by
|
||
// at least a half track, usually a full track. Some 3rd party
|
||
// drives can seek to track 39.
|
||
const maxTrack = isNibbleDrive(this.cur)
|
||
? this.cur.tracks.length * 4 - 1
|
||
: this.cur.trackMap.length - 1;
|
||
if (this.cur.track > maxTrack) {
|
||
this.cur.track = maxTrack;
|
||
}
|
||
if (this.cur.track < 0x0) {
|
||
this.cur.track = 0x0;
|
||
}
|
||
|
||
// debug(
|
||
// 'Drive', _drive, 'track', toHex(_cur.track >> 2) + '.' + (_cur.track & 0x3),
|
||
// '(' + toHex(_cur.track) + ')',
|
||
// '[' + phase + ':' + (on ? 'on' : 'off') + ']');
|
||
|
||
this.q[phase] = on;
|
||
}
|
||
|
||
private access(off: byte, val?: byte) {
|
||
let result = 0;
|
||
const readMode = val === undefined;
|
||
|
||
switch (off & 0x8f) {
|
||
case LOC.PHASE0OFF: // 0x00
|
||
this.setPhase(0, false);
|
||
break;
|
||
case LOC.PHASE0ON: // 0x01
|
||
this.setPhase(0, true);
|
||
break;
|
||
case LOC.PHASE1OFF: // 0x02
|
||
this.setPhase(1, false);
|
||
break;
|
||
case LOC.PHASE1ON: // 0x03
|
||
this.setPhase(1, true);
|
||
break;
|
||
case LOC.PHASE2OFF: // 0x04
|
||
this.setPhase(2, false);
|
||
break;
|
||
case LOC.PHASE2ON: // 0x05
|
||
this.setPhase(2, true);
|
||
break;
|
||
case LOC.PHASE3OFF: // 0x06
|
||
this.setPhase(3, false);
|
||
break;
|
||
case LOC.PHASE3ON: // 0x07
|
||
this.setPhase(3, true);
|
||
break;
|
||
|
||
case LOC.DRIVEOFF: // 0x08
|
||
if (!this.offTimeout) {
|
||
if (this.on) {
|
||
// TODO(flan): This is fragile because it relies on
|
||
// wall-clock time instead of emulator time.
|
||
this.offTimeout = window.setTimeout(() => {
|
||
this.debug('Drive Off');
|
||
this.on = false;
|
||
this.callbacks.driveLight(this.drive, false);
|
||
this.debug('nibbles read', this.nibbleCount);
|
||
}, 1000);
|
||
}
|
||
}
|
||
break;
|
||
case LOC.DRIVEON: // 0x09
|
||
if (this.offTimeout) {
|
||
// TODO(flan): Fragile—see above
|
||
window.clearTimeout(this.offTimeout);
|
||
this.offTimeout = null;
|
||
}
|
||
if (!this.on) {
|
||
this.debug('Drive On');
|
||
this.nibbleCount = 0;
|
||
this.on = true;
|
||
this.lastCycles = this.io.cycles();
|
||
this.callbacks.driveLight(this.drive, true);
|
||
}
|
||
break;
|
||
|
||
case LOC.DRIVE1: // 0x0a
|
||
this.debug('Disk 1');
|
||
this.drive = 1;
|
||
this.cur = this.drives[this.drive - 1];
|
||
if (this.on) {
|
||
this.callbacks.driveLight(2, false);
|
||
this.callbacks.driveLight(1, true);
|
||
}
|
||
break;
|
||
case LOC.DRIVE2: // 0x0b
|
||
this.debug('Disk 2');
|
||
this.drive = 2;
|
||
this.cur = this.drives[this.drive - 1];
|
||
if (this.on) {
|
||
this.callbacks.driveLight(1, false);
|
||
this.callbacks.driveLight(2, true);
|
||
}
|
||
break;
|
||
|
||
case LOC.DRIVEREAD: // 0x0c (Q6L) Shift
|
||
this.q6 = 0;
|
||
if (this.writeMode) {
|
||
this.debug('clearing _q6/SHIFT');
|
||
}
|
||
if (isNibbleDrive(this.cur)) {
|
||
this.readWriteNext();
|
||
}
|
||
break;
|
||
|
||
case LOC.DRIVEWRITE: // 0x0d (Q6H) LOAD
|
||
this.q6 = 1;
|
||
if (this.writeMode) {
|
||
this.debug('setting _q6/LOAD');
|
||
}
|
||
if (isNibbleDrive(this.cur)) {
|
||
if (readMode && !this.writeMode) {
|
||
if (this.cur.readOnly) {
|
||
this.latch = 0xff;
|
||
this.debug('Setting readOnly');
|
||
} else {
|
||
this.latch = this.latch >> 1;
|
||
this.debug('Clearing readOnly');
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case LOC.DRIVEREADMODE: // 0x0e (Q7L)
|
||
this.debug('Read Mode');
|
||
this.q7 = false;
|
||
this.writeMode = false;
|
||
break;
|
||
case LOC.DRIVEWRITEMODE: // 0x0f (Q7H)
|
||
this.debug('Write Mode');
|
||
this.q7 = true;
|
||
this.writeMode = true;
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
this.moveHead();
|
||
|
||
if (readMode) {
|
||
// According to UtAIIe, p. 9-13 to 9-14, any even address can be
|
||
// used to read the data register onto the CPU bus, although some
|
||
// also cause conflicts with the disk controller commands.
|
||
if ((off & 0x01) === 0) {
|
||
result = this.latch;
|
||
if (result & 0x80) {
|
||
this.nibbleCount++;
|
||
}
|
||
} else {
|
||
result = 0;
|
||
}
|
||
} else {
|
||
// It's not explicitly stated, but writes to any address set the
|
||
// data register.
|
||
this.bus = val;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private updateDirty(drive: DriveNumber, dirty: boolean) {
|
||
this.drives[drive - 1].dirty = dirty;
|
||
if (this.callbacks.dirty) {
|
||
this.callbacks.dirty(drive, dirty);
|
||
}
|
||
}
|
||
|
||
ioSwitch(off: byte, val?: byte) {
|
||
return this.access(off, val);
|
||
}
|
||
|
||
read(_page: byte, off: byte) {
|
||
return this.bootstrapRom[off];
|
||
}
|
||
|
||
write() {
|
||
// not writable
|
||
}
|
||
|
||
reset() {
|
||
if (this.on) {
|
||
this.callbacks.driveLight(this.drive, false);
|
||
this.writeMode = false;
|
||
this.on = false;
|
||
this.drive = 1;
|
||
this.cur = this.drives[this.drive - 1];
|
||
}
|
||
for (let idx = 0; idx < 4; idx++) {
|
||
this.q[idx] = false;
|
||
}
|
||
}
|
||
|
||
tick() {
|
||
this.moveHead();
|
||
}
|
||
|
||
getState(): State {
|
||
// TODO(flan): This does not accurately save state. It's missing
|
||
// all of the state for WOZ disks and the current status of the
|
||
// bus.
|
||
const result = {
|
||
drives: [] as DriveState[],
|
||
skip: this.skip,
|
||
latch: this.latch,
|
||
writeMode: this.writeMode,
|
||
on: this.on,
|
||
drive: this.drive
|
||
};
|
||
this.drives.forEach(function (drive, idx) {
|
||
result.drives[idx] = getDriveState(drive);
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
setState(state: State) {
|
||
this.skip = state.skip;
|
||
this.latch = state.latch;
|
||
this.writeMode = state.writeMode;
|
||
this.on = state.on;
|
||
this.drive = state.drive;
|
||
for (const d of DRIVE_NUMBERS) {
|
||
const idx = d - 1;
|
||
this.drives[idx] = setDriveState(state.drives[idx]);
|
||
const { name, side, dirty } = state.drives[idx];
|
||
this.callbacks.label(d, name, side);
|
||
this.callbacks.driveLight(d, this.on);
|
||
this.callbacks.dirty(d, dirty);
|
||
}
|
||
this.cur = this.drives[this.drive - 1];
|
||
}
|
||
|
||
getMetadata(driveNo: DriveNumber) {
|
||
const drive = this.drives[driveNo - 1];
|
||
return {
|
||
format: drive.format,
|
||
volume: drive.volume,
|
||
track: drive.track,
|
||
head: drive.head,
|
||
phase: drive.phase,
|
||
readOnly: drive.readOnly,
|
||
dirty: drive.dirty
|
||
};
|
||
}
|
||
|
||
// TODO(flan): Does not work on WOZ disks
|
||
rwts(disk: DriveNumber, track: byte, sector: byte) {
|
||
const cur = this.drives[disk - 1];
|
||
if (!isNibbleDrive(cur)) {
|
||
throw new Error('Can\'t read WOZ disks');
|
||
}
|
||
return readSector(cur, track, sector);
|
||
}
|
||
|
||
/** Sets the data for `drive` from `disk`, which is expected to be JSON. */
|
||
// TODO(flan): This implementation is not very safe.
|
||
setDisk(drive: DriveNumber, jsonDisk: JSONDisk) {
|
||
if (this.worker) {
|
||
const message: FormatWorkerMessage = {
|
||
type: PROCESS_JSON_DISK,
|
||
payload: {
|
||
drive,
|
||
jsonDisk
|
||
},
|
||
};
|
||
this.worker.postMessage(message);
|
||
return true;
|
||
} else {
|
||
const disk = createDiskFromJsonDisk(jsonDisk);
|
||
if (disk) {
|
||
const cur = this.drives[drive - 1];
|
||
Object.assign(cur, disk);
|
||
this.updateDirty(drive, false);
|
||
this.callbacks.label(drive, disk.name, disk.side);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
getJSON(drive: DriveNumber, pretty: boolean = false) {
|
||
const cur = this.drives[drive - 1];
|
||
if (!isNibbleDrive(cur)) {
|
||
throw new Error('Can\'t save WOZ disks to JSON');
|
||
}
|
||
return jsonEncode(cur, pretty);
|
||
}
|
||
|
||
setJSON(drive: DriveNumber, json: string) {
|
||
if (this.worker) {
|
||
const message: FormatWorkerMessage = {
|
||
type: PROCESS_JSON,
|
||
payload: {
|
||
drive,
|
||
json
|
||
},
|
||
};
|
||
this.worker.postMessage(message);
|
||
} else {
|
||
const cur = this.drives[drive - 1];
|
||
Object.assign(cur, jsonDecode(json));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
setBinary(drive: DriveNumber, name: string, fmt: NibbleFormat, rawData: ArrayBuffer) {
|
||
const readOnly = false;
|
||
const volume = 254;
|
||
const options = {
|
||
name,
|
||
rawData,
|
||
readOnly,
|
||
volume,
|
||
};
|
||
|
||
if (this.worker) {
|
||
const message: FormatWorkerMessage = {
|
||
type: PROCESS_BINARY,
|
||
payload: {
|
||
drive,
|
||
fmt,
|
||
options,
|
||
}
|
||
};
|
||
this.worker.postMessage(message);
|
||
|
||
return true;
|
||
} else {
|
||
const disk = createDisk(fmt, options);
|
||
if (disk) {
|
||
const cur = this.drives[drive - 1];
|
||
const { name, side } = cur;
|
||
Object.assign(cur, disk);
|
||
this.updateDirty(drive, true);
|
||
this.callbacks.label(drive, name, side);
|
||
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
initWorker() {
|
||
if (!window.Worker) {
|
||
return;
|
||
}
|
||
|
||
this.worker = new Worker('dist/format_worker.bundle.js');
|
||
|
||
this.worker.addEventListener('message', (message: MessageEvent<FormatWorkerResponse>) => {
|
||
const { data } = message;
|
||
switch (data.type) {
|
||
case DISK_PROCESSED:
|
||
{
|
||
const { drive, disk } = data.payload;
|
||
if (disk) {
|
||
const cur = this.drives[drive - 1];
|
||
Object.assign(cur, disk);
|
||
const { name, side } = cur;
|
||
this.updateDirty(drive, true);
|
||
this.callbacks.label(drive, name, side);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
});
|
||
}
|
||
|
||
// TODO(flan): Does not work with WOZ disks
|
||
getBinary(drive: DriveNumber): MassStorageData | null {
|
||
const cur = this.drives[drive - 1];
|
||
if (!isNibbleDrive(cur)) {
|
||
return null;
|
||
}
|
||
// TODO(flan): Assumes 16-sectors
|
||
const len = (16 * cur.tracks.length * 256);
|
||
const data = new Uint8Array(len);
|
||
|
||
let idx = 0;
|
||
for (let t = 0; t < cur.tracks.length; t++) {
|
||
if (cur.format === 'nib') {
|
||
data.set(cur.tracks[t], idx);
|
||
idx += cur.tracks[t].length;
|
||
} else {
|
||
for (let s = 0; s < 0x10; s++) {
|
||
const sector = readSector(cur, t, s);
|
||
data.set(sector, idx);
|
||
idx += sector.length;
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
ext: 'dsk',
|
||
name: cur.name,
|
||
data: data.buffer
|
||
};
|
||
}
|
||
|
||
// TODO(flan): Does not work with WOZ disks
|
||
getBase64(drive: DriveNumber) {
|
||
const cur = this.drives[drive - 1];
|
||
if (!isNibbleDrive(cur)) {
|
||
return null;
|
||
}
|
||
const data: string[][] | string[] = [];
|
||
for (let t = 0; t < cur.tracks.length; t++) {
|
||
if (cur.format === 'nib') {
|
||
data[t] = base64_encode(cur.tracks[t]);
|
||
} else {
|
||
const track: string[] = [];
|
||
for (let s = 0; s < 0x10; s++) {
|
||
track[s] = base64_encode(readSector(cur, t, s));
|
||
}
|
||
data[t] = track;
|
||
}
|
||
}
|
||
return data;
|
||
}
|
||
}
|