mirror of
https://github.com/whscullin/apple2js.git
synced 2024-01-12 14:14:38 +00:00
829 lines
27 KiB
JavaScript
829 lines
27 KiB
JavaScript
/* Copyright 2010-2016 Will Scullin <scullin@scullinsteel.com>
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation. No representations are made about the suitability of this
|
|
* software for any purpose. It is provided "as is" without express or
|
|
* implied warranty.
|
|
*/
|
|
|
|
/*exported DiskII */
|
|
/*globals bytify: false, debug: false
|
|
base64_decode: false, base64_encode: false
|
|
Uint8Array: false
|
|
*/
|
|
|
|
function DiskII(io, slot, callbacks)
|
|
{
|
|
'use strict';
|
|
|
|
slot = slot || 6;
|
|
var _drives = [
|
|
{ // Drive 1
|
|
format: 'dsk',
|
|
volume: 254,
|
|
tracks: [],
|
|
track: 0,
|
|
head: 0,
|
|
phase: 0,
|
|
readOnly: false,
|
|
dirty: false
|
|
},
|
|
{ // Drive 2
|
|
format: 'dsk',
|
|
volume: 254,
|
|
tracks: [],
|
|
track: 0,
|
|
head: 0,
|
|
phase: 0,
|
|
readOnly: false,
|
|
dirty: false
|
|
}];
|
|
|
|
var _skip = 0;
|
|
var _latch = 0;
|
|
var _writeMode = false;
|
|
var _on = false;
|
|
var _drive = 1;
|
|
var _cur = _drives[_drive - 1];
|
|
|
|
var LOC = {
|
|
// Disk II Stuff
|
|
PHASE0OFF: 0x80,
|
|
PHASE0ON: 0x81,
|
|
PHASE1OFF: 0x82,
|
|
PHASE1ON: 0x83,
|
|
PHASE2OFF: 0x84,
|
|
PHASE2ON: 0x85,
|
|
PHASE3OFF: 0x86,
|
|
PHASE3ON: 0x87,
|
|
|
|
DRIVEOFF: 0x88,
|
|
DRIVEON: 0x89,
|
|
DRIVE1: 0x8A,
|
|
DRIVE2: 0x8B,
|
|
DRIVEREAD: 0x8C, // Q6L
|
|
DRIVEWRITE: 0x8D, // Q6H
|
|
DRIVEREADMODE: 0x8E, // Q7L
|
|
DRIVEWRITEMODE: 0x8F // Q7H
|
|
};
|
|
|
|
// var DO = [0x0,0x7,0xE,0x6,0xD,0x5,0xC,0x4,
|
|
// 0xB,0x3,0xA,0x2,0x9,0x1,0x8,0xF];
|
|
var _DO = [0x0,0xD,0xB,0x9,0x7,0x5,0x3,0x1,
|
|
0xE,0xC,0xA,0x8,0x6,0x4,0x2,0xF];
|
|
|
|
// var PO = [0x0,0x8,0x1,0x9,0x2,0xa,0x3,0xb,
|
|
// 0x4,0xc,0x5,0xd,0x6,0xe,0x7,0xf];
|
|
var _PO = [0x0,0x2,0x4,0x6,0x8,0xa,0xc,0xe,
|
|
0x1,0x3,0x5,0x7,0x9,0xb,0xd,0xf];
|
|
|
|
var _trans = [0x96, 0x97, 0x9a, 0x9b, 0x9d, 0x9e, 0x9f, 0xa6,
|
|
0xa7, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb2, 0xb3,
|
|
0xb4, 0xb5, 0xb6, 0xb7, 0xb9, 0xba, 0xbb, 0xbc,
|
|
0xbd, 0xbe, 0xbf, 0xcb, 0xcd, 0xce, 0xcf, 0xd3,
|
|
0xd6, 0xd7, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde,
|
|
0xdf, 0xe5, 0xe6, 0xe7, 0xe9, 0xea, 0xeb, 0xec,
|
|
0xed, 0xee, 0xef, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
|
|
0xf7, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff];
|
|
|
|
var _detrans = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
|
|
0x00, 0x00, 0x02, 0x03, 0x00, 0x04, 0x05, 0x06,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x08,
|
|
0x00, 0x00, 0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
|
|
0x00, 0x00, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13,
|
|
0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x1B, 0x00, 0x1C, 0x1D, 0x1E,
|
|
0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x20, 0x21,
|
|
0x00, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x2A, 0x2B,
|
|
0x00, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
|
|
0x00, 0x00, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
|
|
0x00, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F];
|
|
|
|
function _debug() {
|
|
// debug.apply(this, arguments);
|
|
}
|
|
|
|
function _init() {
|
|
debug('Disk ][ in slot', slot);
|
|
}
|
|
|
|
/**
|
|
* From Beneath Apple DOS
|
|
*/
|
|
|
|
function _fourXfour(val) {
|
|
var xx = val & 0xaa;
|
|
var yy = val & 0x55;
|
|
|
|
xx >>= 1;
|
|
xx |= 0xaa;
|
|
yy |= 0xaa;
|
|
|
|
return [xx, yy];
|
|
}
|
|
|
|
function _defourXfour(xx, yy) {
|
|
return ((xx << 1) | 0x01) & yy;
|
|
}
|
|
|
|
function _explodeSector(volume, track, sector, data) {
|
|
var checksum;
|
|
|
|
var buf = [], idx;
|
|
|
|
var gap;
|
|
|
|
/*
|
|
* Gap 1/3 (40/0x28 bytes)
|
|
*/
|
|
|
|
if (sector === 0) // Gap 1
|
|
gap = 0x80;
|
|
else { // Gap 3
|
|
gap = track === 0 ? 0x28 : 0x26;
|
|
}
|
|
|
|
for (idx = 0; idx < gap; idx++) {
|
|
buf.push(0xff);
|
|
}
|
|
|
|
/*
|
|
* Address Field
|
|
*/
|
|
|
|
checksum = volume ^ track ^ sector;
|
|
buf = buf.concat([0xd5, 0xaa, 0x96]); // Address Prolog D5 AA 96
|
|
buf = buf.concat(_fourXfour(volume));
|
|
buf = buf.concat(_fourXfour(track));
|
|
buf = buf.concat(_fourXfour(sector));
|
|
buf = buf.concat(_fourXfour(checksum));
|
|
buf = buf.concat([0xde, 0xaa, 0xeb]); // Epilog DE AA EB
|
|
|
|
/*
|
|
* Gap 2 (5 bytes)
|
|
*/
|
|
|
|
for (idx = 0; idx < 0x05; idx++) {
|
|
buf.push(0xff);
|
|
}
|
|
|
|
/*
|
|
* Data Field
|
|
*/
|
|
|
|
buf = buf.concat([0xd5, 0xaa, 0xad]); // Data Prolog D5 AA AD
|
|
|
|
var nibbles = [];
|
|
var ptr2 = 0;
|
|
var ptr6 = 0x56;
|
|
var idx2, idx6;
|
|
|
|
for (idx = 0; idx < 0x156; idx++) {
|
|
nibbles[idx] = 0;
|
|
}
|
|
|
|
idx2 = 0x55;
|
|
for (idx6 = 0x101; idx6 >= 0; idx6--) {
|
|
var val6 = data[idx6 % 0x100];
|
|
var val2 = nibbles[ptr2 + idx2];
|
|
|
|
val2 = (val2 << 1) | (val6 & 1);
|
|
val6 >>= 1;
|
|
val2 = (val2 << 1) | (val6 & 1);
|
|
val6 >>= 1;
|
|
|
|
nibbles[ptr6 + idx6] = val6;
|
|
nibbles[ptr2 + idx2] = val2;
|
|
|
|
if (--idx2 < 0)
|
|
idx2 = 0x55;
|
|
}
|
|
|
|
var last = 0;
|
|
for (idx = 0; idx < 0x156; idx++) {
|
|
var val = nibbles[idx];
|
|
buf.push(_trans[last ^ val]);
|
|
last = val;
|
|
}
|
|
buf.push(_trans[last]);
|
|
|
|
buf = buf.concat([0xde, 0xaa, 0xeb]); // Epilog DE AA EB
|
|
|
|
/*
|
|
* Gap 3
|
|
*/
|
|
|
|
buf.push(0xff);
|
|
|
|
return buf;
|
|
}
|
|
|
|
function _json_encode(drive, pretty) {
|
|
var cur = _drives[drive - 1];
|
|
var data = [];
|
|
var format = 'dsk';
|
|
for (var t = 0; t < cur.tracks.length; t++) {
|
|
data[t] = [];
|
|
if (cur.format === 'nib') {
|
|
format = 'nib';
|
|
data[t] = base64_encode(cur.tracks[t]);
|
|
} else {
|
|
for (var s = 0; s < 0x10; s++) {
|
|
data[t][s] = base64_encode(_readSector(drive, t, _DO[s]));
|
|
}
|
|
}
|
|
}
|
|
return JSON.stringify({'type': format,
|
|
'encoding': 'base64',
|
|
'volume': cur.volume,
|
|
'data': data},
|
|
null,
|
|
pretty ? ' ' : null);
|
|
}
|
|
|
|
function _json_decode(drive, data) {
|
|
var _cur = _drives[drive - 1];
|
|
var tracks = [];
|
|
var json = JSON.parse(data);
|
|
var v = json.volume;
|
|
for (var t = 0; t < json.data.length; t++) {
|
|
var track = [];
|
|
for (var s = 0; s < json.data[t].length; s++) {
|
|
var _s = 15 - s;
|
|
var d = base64_decode(json.data[t][_s]);
|
|
track = track.concat(_explodeSector(v, t, _DO[_s], d));
|
|
}
|
|
tracks[t] = bytify(track);
|
|
}
|
|
_cur.volume = v;
|
|
_cur.format = json.type;
|
|
_cur.tracks = tracks;
|
|
}
|
|
|
|
function _readNext() {
|
|
var result = 0;
|
|
if (_skip || _writeMode) {
|
|
var t = _cur.tracks[_cur.track >> 1];
|
|
if (t && t.length) {
|
|
if (_cur.head >= t.length)
|
|
_cur.head = 0;
|
|
|
|
if (_writeMode) {
|
|
t[_cur.head] = _latch;
|
|
} else
|
|
result = t[_cur.head];
|
|
|
|
++_cur.head;
|
|
}
|
|
}
|
|
_skip = (++_skip % 4);
|
|
return result;
|
|
}
|
|
|
|
function _writeNext(val) {
|
|
if (_writeMode) {
|
|
_latch = val;
|
|
if (!_cur.dirty) {
|
|
_updateDirty(_drive, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
function _readSector(drive, track, sector) {
|
|
var val, state = 0;
|
|
var idx = 0;
|
|
var retry = 0;
|
|
var cur = _drives[drive - 1].tracks[track];
|
|
|
|
function _readNext() {
|
|
var result = cur[idx++];
|
|
if (idx >= cur.length) {
|
|
idx = 0;
|
|
retry++;
|
|
}
|
|
return result;
|
|
}
|
|
function _skipBytes(count) {
|
|
idx += count;
|
|
if (idx >= cur.length) {
|
|
idx %= cur.length;
|
|
retry++;
|
|
}
|
|
}
|
|
var t = 0, s = 0, jdx, kdx;
|
|
var data = [];
|
|
while (retry < 4) {
|
|
switch (state) {
|
|
case 0:
|
|
val = _readNext();
|
|
state = (val === 0xd5) ? 1 : 0;
|
|
break;
|
|
case 1:
|
|
val = _readNext();
|
|
state = (val === 0xaa) ? 2 : 0;
|
|
break;
|
|
case 2:
|
|
val = _readNext();
|
|
state = (val === 0x96) ? 3 : (val === 0xad ? 4 : 0);
|
|
break;
|
|
case 3: // Address
|
|
_defourXfour(_readNext(), _readNext()); // Volume
|
|
t = _defourXfour(_readNext(), _readNext());
|
|
s = _defourXfour(_readNext(), _readNext());
|
|
_skipBytes(5); // Skip checksum and footer
|
|
state = 0;
|
|
break;
|
|
case 4: // Data
|
|
if (s === sector && t === track) {
|
|
var data2 = [];
|
|
var last = 0;
|
|
for (jdx = 0x55; jdx >= 0; jdx--) {
|
|
val = _detrans[_readNext() - 0x80] ^ last;
|
|
data2[jdx] = val;
|
|
last = val;
|
|
}
|
|
for (jdx = 0; jdx < 0x100; jdx++) {
|
|
val = _detrans[_readNext() - 0x80] ^ last;
|
|
data[jdx] = val;
|
|
last = val;
|
|
}
|
|
for (kdx = 0, jdx = 0x55; kdx < 0x100; kdx++) {
|
|
data[kdx] <<= 1;
|
|
if ((data2[jdx] & 0x01) !== 0) {
|
|
data[kdx] |= 0x01;
|
|
}
|
|
data2[jdx] >>= 1;
|
|
|
|
data[kdx] <<= 1;
|
|
if ((data2[jdx] & 0x01) !== 0) {
|
|
data[kdx] |= 0x01;
|
|
}
|
|
data2[jdx] >>= 1;
|
|
|
|
if (--jdx < 0) jdx = 0x55;
|
|
}
|
|
return data;
|
|
}
|
|
else
|
|
_skipBytes(0x159); // Skip data, checksum and footer
|
|
state = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return [];
|
|
}
|
|
|
|
var _phase_delta = [[ 0, 1, 2,-1],
|
|
[-1, 0, 1, 2],
|
|
[-2,-1, 0, 1],
|
|
[ 1,-2,-1, 0]];
|
|
|
|
function setPhase(phase, on) {
|
|
_debug('phase ' + phase + (on ? ' on' : ' off'));
|
|
if (on) {
|
|
_cur.track += _phase_delta[_cur.phase][phase];
|
|
_cur.phase = phase;
|
|
|
|
if (_cur.track > _cur.tracks.length * 2 - 1)
|
|
_cur.track = _cur.tracks.length * 2 - 1;
|
|
if (_cur.track < 0x0)
|
|
_cur.track = 0x0;
|
|
|
|
/* _debug('Drive ' + _drive +
|
|
', track ' + toHex(_cur.track >> 1) +
|
|
' (' + toHex(_cur.track) + ')' +
|
|
' [' + (_cur.track % 4) + '/' + phase + ']'); */
|
|
}
|
|
}
|
|
|
|
function _access(off, val) {
|
|
var result = 0;
|
|
switch (off & 0x8f) {
|
|
case LOC.PHASE0OFF:
|
|
setPhase(0, false);
|
|
break;
|
|
case LOC.PHASE0ON:
|
|
setPhase(0, true);
|
|
break;
|
|
case LOC.PHASE1OFF:
|
|
setPhase(1, false);
|
|
break;
|
|
case LOC.PHASE1ON:
|
|
setPhase(1, true);
|
|
break;
|
|
case LOC.PHASE2OFF:
|
|
setPhase(2, false);
|
|
break;
|
|
case LOC.PHASE2ON:
|
|
setPhase(2, true);
|
|
break;
|
|
case LOC.PHASE3OFF:
|
|
setPhase(3, false);
|
|
break;
|
|
case LOC.PHASE3ON:
|
|
setPhase(3, true);
|
|
break;
|
|
|
|
case LOC.DRIVEOFF:
|
|
_debug('Drive Off');
|
|
_on = false;
|
|
if (callbacks.driveLight) { callbacks.driveLight(_drive, false); }
|
|
break;
|
|
case LOC.DRIVEON:
|
|
_debug('Drive On');
|
|
_on = true;
|
|
if (callbacks.driveLight) { callbacks.driveLight(_drive, true); }
|
|
break;
|
|
|
|
case LOC.DRIVE1:
|
|
_debug('Disk 1');
|
|
_drive = 1;
|
|
_cur = _drives[_drive - 1];
|
|
if (_on && callbacks.driveLight) {
|
|
callbacks.driveLight(2, false);
|
|
callbacks.driveLight(1, true);
|
|
}
|
|
break;
|
|
case LOC.DRIVE2:
|
|
_debug('Disk 2');
|
|
_drive = 2;
|
|
_cur = _drives[_drive - 1];
|
|
if (_on && callbacks.driveLight) {
|
|
callbacks.driveLight(1, false);
|
|
callbacks.driveLight(2, true);
|
|
}
|
|
break;
|
|
|
|
case LOC.DRIVEREAD:
|
|
result = _readNext();
|
|
// _debug('read: ' + toHex(result));
|
|
break;
|
|
|
|
case LOC.DRIVEWRITE:
|
|
// _debug('write: ' + toHex(val));
|
|
if (val !== undefined) {
|
|
_writeNext(val);
|
|
}
|
|
break;
|
|
case LOC.DRIVEREADMODE:
|
|
_debug('Read Mode');
|
|
_writeMode = false;
|
|
result = (_readNext() & 0x7f) | (_cur.readOnly ? 0x80 : 0x00);
|
|
break;
|
|
case LOC.DRIVEWRITEMODE:
|
|
_debug('Write Mode');
|
|
_writeMode = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function _updateDirty(drive, dirty) {
|
|
_drives[drive - 1].dirty = dirty;
|
|
if (callbacks.dirty) { callbacks.dirty(_drive, dirty); }
|
|
}
|
|
|
|
var diskII = [
|
|
0xa2,0x20,0xa0,0x00,0xa2,0x03,0x86,0x3c,
|
|
0x8a,0x0a,0x24,0x3c,0xf0,0x10,0x05,0x3c,
|
|
0x49,0xff,0x29,0x7e,0xb0,0x08,0x4a,0xd0,
|
|
0xfb,0x98,0x9d,0x56,0x03,0xc8,0xe8,0x10,
|
|
0xe5,0x20,0x58,0xff,0xba,0xbd,0x00,0x01,
|
|
0x0a,0x0a,0x0a,0x0a,0x85,0x2b,0xaa,0xbd,
|
|
0x8e,0xc0,0xbd,0x8c,0xc0,0xbd,0x8a,0xc0,
|
|
0xbd,0x89,0xc0,0xa0,0x50,0xbd,0x80,0xc0,
|
|
0x98,0x29,0x03,0x0a,0x05,0x2b,0xaa,0xbd,
|
|
0x81,0xc0,0xa9,0x56,0x20,0xa8,0xfc,0x88,
|
|
0x10,0xeb,0x85,0x26,0x85,0x3d,0x85,0x41,
|
|
0xa9,0x08,0x85,0x27,0x18,0x08,0xbd,0x8c,
|
|
0xc0,0x10,0xfb,0x49,0xd5,0xd0,0xf7,0xbd,
|
|
0x8c,0xc0,0x10,0xfb,0xc9,0xaa,0xd0,0xf3,
|
|
0xea,0xbd,0x8c,0xc0,0x10,0xfb,0xc9,0x96,
|
|
0xf0,0x09,0x28,0x90,0xdf,0x49,0xad,0xf0,
|
|
0x25,0xd0,0xd9,0xa0,0x03,0x85,0x40,0xbd,
|
|
0x8c,0xc0,0x10,0xfb,0x2a,0x85,0x3c,0xbd,
|
|
0x8c,0xc0,0x10,0xfb,0x25,0x3c,0x88,0xd0,
|
|
0xec,0x28,0xc5,0x3d,0xd0,0xbe,0xa5,0x40,
|
|
0xc5,0x41,0xd0,0xb8,0xb0,0xb7,0xa0,0x56,
|
|
0x84,0x3c,0xbc,0x8c,0xc0,0x10,0xfb,0x59,
|
|
0xd6,0x02,0xa4,0x3c,0x88,0x99,0x00,0x03,
|
|
0xd0,0xee,0x84,0x3c,0xbc,0x8c,0xc0,0x10,
|
|
0xfb,0x59,0xd6,0x02,0xa4,0x3c,0x91,0x26,
|
|
0xc8,0xd0,0xef,0xbc,0x8c,0xc0,0x10,0xfb,
|
|
0x59,0xd6,0x02,0xd0,0x87,0xa0,0x00,0xa2,
|
|
0x56,0xca,0x30,0xfb,0xb1,0x26,0x5e,0x00,
|
|
0x03,0x2a,0x5e,0x00,0x03,0x2a,0x91,0x26,
|
|
0xc8,0xd0,0xee,0xe6,0x27,0xe6,0x3d,0xa5,
|
|
0x3d,0xcd,0x00,0x08,0xa6,0x2b,0x90,0xdb,
|
|
0x4c,0x01,0x08,0x00,0x00,0x00,0x00,0x00 ];
|
|
/*
|
|
var diskII_13 = [
|
|
0xa2,0x20,0xa0,0x00,0xa9,0x03,0x85,0x3c,
|
|
0x18,0x88,0x98,0x24,0x3c,0xf0,0xf5,0x26,
|
|
0x3c,0x90,0xf8,0xc0,0xd5,0xf0,0xed,0xca,
|
|
0x8a,0x99,0x00,0x08,0xd0,0xe6,0x20,0x58,
|
|
0xff,0xba,0xbd,0x00,0x01,0x48,0x0a,0x0a,
|
|
0x0a,0x0a,0x85,0x2b,0xaa,0xa9,0xd0,0x48,
|
|
0xbd,0x8e,0xc0,0xbd,0x8c,0xc0,0xbd,0x8a,
|
|
0xc0,0xbd,0x89,0xc0,0xa0,0x50,0xbd,0x80,
|
|
0xc0,0x98,0x29,0x03,0x0a,0x05,0x2b,0xaa,
|
|
0xbd,0x81,0xc0,0xa9,0x56,0x20,0xa8,0xfc,
|
|
0x88,0x10,0xeb,0xa9,0x03,0x85,0x27,0xa9,
|
|
0x00,0x85,0x26,0x85,0x3d,0x18,0x08,0xbd,
|
|
0x8c,0xc0,0x10,0xfb,0x49,0xd5,0xd0,0xf7,
|
|
0xbd,0x8c,0xc0,0x10,0xfb,0xc9,0xaa,0xd0,
|
|
0xf3,0xea,0xbd,0x8c,0xc0,0x10,0xfb,0xc9,
|
|
0xb5,0xf0,0x09,0x28,0x90,0xdf,0x49,0xad,
|
|
0xf0,0x1f,0xd0,0xd9,0xa0,0x03,0x84,0x2a,
|
|
0xbd,0x8c,0xc0,0x10,0xfb,0x2a,0x85,0x3c,
|
|
0xbd,0x8c,0xc0,0x10,0xfb,0x25,0x3c,0x88,
|
|
0xd0,0xee,0x28,0xc5,0x3d,0xd0,0xbe,0xb0,
|
|
0xbd,0xa0,0x9a,0x84,0x3c,0xbc,0x8c,0xc0,
|
|
0x10,0xfb,0x59,0x00,0x08,0xa4,0x3c,0x88,
|
|
0x99,0x00,0x08,0xd0,0xee,0x84,0x3c,0xbc,
|
|
0x8c,0xc0,0x10,0xfb,0x59,0x00,0x08,0xa4,
|
|
0x3c,0x91,0x26,0xc8,0xd0,0xef,0xbc,0x8c,
|
|
0xc0,0x10,0xfb,0x59,0x00,0x08,0xd0,0x8d,
|
|
0x60,0xa8,0xa2,0x00,0xb9,0x00,0x08,0x4a,
|
|
0x3e,0xcc,0x03,0x4a,0x3e,0x99,0x03,0x85,
|
|
0x3c,0xb1,0x26,0x0a,0x0a,0x0a,0x05,0x3c,
|
|
0x91,0x26,0xc8,0xe8,0xe0,0x33,0xd0,0xe4,
|
|
0xc6,0x2a,0xd0,0xde,0xcc,0x00,0x03,0xd0,
|
|
0x03,0x4c,0x01,0x03,0x4c,0x2d,0xff,0xff
|
|
];
|
|
*/
|
|
|
|
_init();
|
|
|
|
return {
|
|
ioSwitch: function disk2_ioSwitch(off, val) {
|
|
return _access(off, val);
|
|
},
|
|
|
|
read: function disk2_read(page, off) {
|
|
return diskII[off];
|
|
},
|
|
|
|
write: function disk2_write() {},
|
|
|
|
reset: function disk2_reset() {
|
|
if (_on) {
|
|
_writeMode = false;
|
|
_on = false;
|
|
callbacks.driveLight(_drive, false);
|
|
}
|
|
},
|
|
|
|
getState: function disk2_getState() {
|
|
function getDriveState(drive) {
|
|
var result = {
|
|
format: drive.format,
|
|
volume: drive.volume,
|
|
tracks: [],
|
|
track: drive.track,
|
|
head: drive.head,
|
|
phase: drive.phase,
|
|
readOnly: drive.readOnly,
|
|
dirty: drive.dirty
|
|
};
|
|
for (var idx = 0; idx < drive.tracks.length; idx++) {
|
|
result.tracks.push(base64_encode(drive.tracks[idx]));
|
|
}
|
|
return result;
|
|
}
|
|
var result = {
|
|
drives: [],
|
|
skip: _skip,
|
|
latch: _latch,
|
|
writeMode: _writeMode,
|
|
on: _on,
|
|
drive: _drive
|
|
};
|
|
_drives.forEach(function (drive, idx) {
|
|
var _drive = result.drives[idx] = getDriveState(drive);
|
|
callbacks.driveLight(idx, _drive.on);
|
|
callbacks.dirty(idx, _drive.dirty);
|
|
});
|
|
return result;
|
|
},
|
|
setState: function disk2_setState(state) {
|
|
function setDriveState(state) {
|
|
var result = {
|
|
format: state.format,
|
|
volume: state.volume,
|
|
tracks: [],
|
|
track: state.track,
|
|
head: state.head,
|
|
phase: state.phase,
|
|
readOnly: state.readOnly,
|
|
dirty: state.dirty
|
|
};
|
|
for (var idx = 0; idx < state.tracks.length; idx++) {
|
|
result.tracks.push(base64_decode(state.tracks[idx]));
|
|
}
|
|
return result;
|
|
}
|
|
state.drives.forEach(function(drive, idx) {
|
|
_drives[idx] = setDriveState(drive);
|
|
});
|
|
_skip = state.skip;
|
|
_latch = state.latch;
|
|
_writeMode = state.writeMode;
|
|
_on = state.on;
|
|
_drive = state.drive;
|
|
_cur = _drives[_drive - 1];
|
|
},
|
|
rwts: function disk2_rwts(disk, track, sector) {
|
|
return _readSector(disk, track, sector);
|
|
},
|
|
setDisk: function disk2_setDisk(drive, disk) {
|
|
var fmt = disk.type, readOnly = disk.readOnly;
|
|
|
|
var data, t, s;
|
|
if (disk.encoding == 'base64') {
|
|
data = [];
|
|
for (t = 0; t < disk.data.length; t++) {
|
|
if (fmt == 'nib') {
|
|
data[t] = base64_decode(disk.data[t]);
|
|
} else {
|
|
data[t] = [];
|
|
for (s = 0; s < disk.data[t].length; s++) {
|
|
data[t][s] = base64_decode(disk.data[t][s]);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
data = disk.data;
|
|
}
|
|
var cur = _drives[drive - 1];
|
|
|
|
// var v = (fmt === 'dsk' ? data[0x11][0x00][0x06] : 0xfe);
|
|
// if (v == 0x00) {
|
|
var v = disk.volume || 0xfe;
|
|
// }
|
|
|
|
cur.volume = v;
|
|
cur.readOnly = readOnly;
|
|
cur.format = fmt;
|
|
var tracks = [];
|
|
|
|
for (t = 0; t < data.length; t++) {
|
|
var track = [];
|
|
if (fmt === 'nib') {
|
|
track = data[t];
|
|
} else {
|
|
for (s = 0; s < data[t].length; s++) {
|
|
var _s = 15 - s;
|
|
if (fmt === 'po') { // ProDOS Order
|
|
track = track.concat(
|
|
_explodeSector(v, t, _PO[s], data[t][s])
|
|
);
|
|
} else if (fmt === 'dsk') { // DOS Order
|
|
track = track.concat(
|
|
_explodeSector(v, t, _DO[_s], data[t][_s])
|
|
);
|
|
} else { // flat
|
|
track = track.concat(
|
|
_explodeSector(v, t, s, data[t][s])
|
|
);
|
|
}
|
|
}
|
|
}
|
|
tracks[t] = bytify(track);
|
|
}
|
|
cur.tracks = tracks;
|
|
_updateDirty(_drive, false);
|
|
},
|
|
getJSON: function disk2_getJSON(drive, pretty) {
|
|
return _json_encode(drive, pretty);
|
|
},
|
|
setJSON: function disk2_setJSON(drive, data) {
|
|
_json_decode(drive, data);
|
|
return true;
|
|
},
|
|
setBinary: function disk2_setBinary(drive, name, fmt, data) {
|
|
var _cur = _drives[drive - 1];
|
|
var tracks = [];
|
|
var v = 254;
|
|
if (fmt === 'do') {
|
|
fmt = 'dsk';
|
|
}
|
|
_cur.readOnly = false;
|
|
if (fmt === '2mg') {
|
|
// Standard header size is 64 bytes. Make assumptions.
|
|
var prefix = new Uint8Array(data.slice(0, 64));
|
|
data = data.slice(64);
|
|
|
|
// Check image format.
|
|
// Sure, it's really 64 bits. But only 2 are actually used.
|
|
switch (prefix[0xc]) {
|
|
case 0:
|
|
fmt = 'dsk';
|
|
break;
|
|
case 1:
|
|
fmt = 'po';
|
|
break;
|
|
case 2:
|
|
fmt = 'nib';
|
|
break;
|
|
default: // Something hinky, assume 'dsk'
|
|
fmt = 'dsk';
|
|
break;
|
|
}
|
|
var flags =
|
|
prefix[0x10] | (prefix[0x11] << 8) |
|
|
(prefix[0x12] << 16) | (prefix[0x13] << 24);
|
|
_cur.readOnly = (flags & 0x80000000) !== 0;
|
|
if ((flags & 0x10) !== 0) {
|
|
_cur.volume = flags & 0xff;
|
|
} else {
|
|
_cur.volume = 254;
|
|
}
|
|
}
|
|
for (var t = 0; t < 35; t++) {
|
|
var track, off, d;
|
|
if (fmt === 'nib') {
|
|
off = t * 0x1a00;
|
|
track = new Uint8Array(data.slice(off, off + 0x1a00));
|
|
} else {
|
|
track = [];
|
|
for (var s = 0; s < 16; s++) {
|
|
var _s = 15 - s;
|
|
if (fmt == 'po') { // ProDOS Order
|
|
off = (16 * t + s) * 256;
|
|
d = new Uint8Array(data.slice(off, off + 256));
|
|
track = track.concat(
|
|
_explodeSector(v, t, _PO[s], d)
|
|
);
|
|
} else if (fmt == 'dsk') { // DOS Order
|
|
off = (16 * t + _s) * 256;
|
|
d = new Uint8Array(data.slice(off, off + 256));
|
|
track = track.concat(
|
|
_explodeSector(v, t, _DO[_s], d)
|
|
);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
tracks[t] = bytify(track);
|
|
}
|
|
_cur.volume = v;
|
|
_cur.format = fmt;
|
|
_cur.tracks = tracks;
|
|
|
|
_updateDirty(drive, true);
|
|
return true;
|
|
},
|
|
|
|
getBinary: function disk2_getBinary(drive) {
|
|
var cur = _drives[drive - 1];
|
|
var len = (16 * cur.tracks.length * 256);
|
|
var data = new Uint8Array(len);
|
|
var idx = 0;
|
|
|
|
for (var t = 0; t < cur.tracks.length; t++) {
|
|
if (cur.format === 'nib') {
|
|
data[idx++] = cur.tracks[t];
|
|
} else {
|
|
for (var s = 0; s < 0x10; s++) {
|
|
var sector = _readSector(drive, t, _DO[s]);
|
|
for (var b = 0; b < 256; b++) {
|
|
data[idx++] = sector[b];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return data;
|
|
},
|
|
|
|
getBase64: function disk2_getBase64(drive) {
|
|
var cur = _drives[drive - 1];
|
|
var data = [];
|
|
for (var t = 0; t < cur.tracks.length; t++) {
|
|
data[t] = [];
|
|
if (cur.format === 'nib') {
|
|
data += base64_encode(cur.tracks[t]);
|
|
} else {
|
|
for (var s = 0; s < 0x10; s++) {
|
|
data += base64_encode(_readSector(drive, t, _DO[s]));
|
|
}
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
};
|
|
}
|