460 lines
12 KiB
JavaScript
460 lines
12 KiB
JavaScript
"use strict";
|
|
|
|
/**
|
|
* @constructor
|
|
*
|
|
* @param {CPU} cpu
|
|
*/
|
|
function FloppyController(cpu, fda_image, fdb_image)
|
|
{
|
|
/** @const @type {IO|undefined} */
|
|
this.io = cpu.io;
|
|
|
|
/** @const @type {CPU} */
|
|
this.cpu = cpu;
|
|
|
|
/** @const @type {DMA} */
|
|
this.dma = cpu.devices.dma;
|
|
|
|
this.bytes_expecting = 0;
|
|
this.receiving_command = new Uint8Array(10);
|
|
this.receiving_index = 0;
|
|
this.next_command = null;
|
|
|
|
this.response_data = new Uint8Array(10);
|
|
this.response_index = 0;
|
|
this.response_length = 0;
|
|
|
|
/* const */
|
|
this.fda_image = fda_image;
|
|
|
|
/* const */
|
|
this.fdb_image = fdb_image;
|
|
|
|
|
|
this.status_reg0 = 0;
|
|
this.status_reg1 = 0;
|
|
this.status_reg2 = 0;
|
|
this.drive = 0;
|
|
|
|
this.last_cylinder = 0;
|
|
this.last_head = 0;
|
|
this.last_sector = 1;
|
|
|
|
// this should actually be write-only ... but people read it anyway
|
|
this.dor = 0;
|
|
|
|
if(!fda_image)
|
|
{
|
|
// Needed for CD emulation provided by seabios
|
|
cpu.devices.rtc.cmos_write(CMOS_FLOPPY_DRIVE_TYPE, 4 << 4);
|
|
|
|
this.sectors_per_track = 0;
|
|
this.number_of_heads = 0;
|
|
this.number_of_cylinders = 0;
|
|
}
|
|
else
|
|
{
|
|
var floppy_types = {
|
|
[ 160 * 1024] : { type: 1, tracks: 40, sectors: 8 , heads: 1 },
|
|
[ 180 * 1024] : { type: 1, tracks: 40, sectors: 9 , heads: 1 },
|
|
[ 200 * 1024] : { type: 1, tracks: 40, sectors: 10, heads: 1 },
|
|
[ 320 * 1024] : { type: 1, tracks: 40, sectors: 8 , heads: 2 },
|
|
[ 360 * 1024] : { type: 1, tracks: 40, sectors: 9 , heads: 2 },
|
|
[ 400 * 1024] : { type: 1, tracks: 40, sectors: 10, heads: 2 },
|
|
[ 720 * 1024] : { type: 3, tracks: 80, sectors: 9 , heads: 2 },
|
|
[1200 * 1024] : { type: 2, tracks: 80, sectors: 15, heads: 2 },
|
|
[1440 * 1024] : { type: 4, tracks: 80, sectors: 18, heads: 2 },
|
|
[1722 * 1024] : { type: 5, tracks: 82, sectors: 21, heads: 2 },
|
|
[2880 * 1024] : { type: 5, tracks: 80, sectors: 36, heads: 2 },
|
|
|
|
// not a real floppy type, used to support sectorlisp and friends
|
|
512: { type: 1, tracks: 1, sectors: 1, heads: 1 },
|
|
};
|
|
|
|
let floppy_size = fda_image.byteLength;
|
|
|
|
var number_of_cylinders,
|
|
sectors_per_track,
|
|
number_of_heads,
|
|
floppy_type = floppy_types[floppy_size];
|
|
|
|
if(!floppy_type)
|
|
{
|
|
floppy_size = fda_image.byteLength > 1440 * 1024 ? 2880 * 1024 : 1440 * 1024;
|
|
floppy_type = floppy_types[floppy_size];
|
|
|
|
dbg_log("Warning: Unkown floppy size: " + fda_image.byteLength + ", assuming " + floppy_size);
|
|
}
|
|
|
|
cpu.devices.rtc.cmos_write(CMOS_FLOPPY_DRIVE_TYPE, floppy_type.type << 4);
|
|
|
|
sectors_per_track = floppy_type.sectors;
|
|
number_of_heads = floppy_type.heads;
|
|
number_of_cylinders = floppy_type.tracks;
|
|
|
|
this.sectors_per_track = sectors_per_track;
|
|
this.number_of_heads = number_of_heads;
|
|
this.number_of_cylinders = number_of_cylinders;
|
|
}
|
|
|
|
this.io.register_read(0x3F0, this, this.port3F0_read);
|
|
this.io.register_read(0x3F2, this, this.port3F2_read);
|
|
this.io.register_read(0x3F4, this, this.port3F4_read);
|
|
this.io.register_read(0x3F5, this, this.port3F5_read);
|
|
this.io.register_read(0x3F7, this, this.port3F7_read);
|
|
|
|
this.io.register_write(0x3F2, this, this.port3F2_write);
|
|
this.io.register_write(0x3F5, this, this.port3F5_write);
|
|
}
|
|
|
|
FloppyController.prototype.get_state = function()
|
|
{
|
|
var state = [];
|
|
|
|
state[0] = this.bytes_expecting;
|
|
state[1] = this.receiving_command;
|
|
state[2] = this.receiving_index;
|
|
//state[3] = this.next_command;
|
|
state[4] = this.response_data;
|
|
state[5] = this.response_index;
|
|
state[6] = this.response_length;
|
|
|
|
state[8] = this.status_reg0;
|
|
state[9] = this.status_reg1;
|
|
state[10] = this.status_reg2;
|
|
state[11] = this.drive;
|
|
state[12] = this.last_cylinder;
|
|
state[13] = this.last_head;
|
|
state[14] = this.last_sector;
|
|
state[15] = this.dor;
|
|
state[16] = this.sectors_per_track;
|
|
state[17] = this.number_of_heads;
|
|
state[18] = this.number_of_cylinders;
|
|
|
|
return state;
|
|
};
|
|
|
|
FloppyController.prototype.set_state = function(state)
|
|
{
|
|
this.bytes_expecting = state[0];
|
|
this.receiving_command = state[1];
|
|
this.receiving_index = state[2];
|
|
this.next_command = state[3];
|
|
this.response_data = state[4];
|
|
this.response_index = state[5];
|
|
this.response_length = state[6];
|
|
|
|
this.status_reg0 = state[8];
|
|
this.status_reg1 = state[9];
|
|
this.status_reg2 = state[10];
|
|
this.drive = state[11];
|
|
this.last_cylinder = state[12];
|
|
this.last_head = state[13];
|
|
this.last_sector = state[14];
|
|
this.dor = state[15];
|
|
this.sectors_per_track = state[16];
|
|
this.number_of_heads = state[17];
|
|
this.number_of_cylinders = state[18];
|
|
};
|
|
|
|
FloppyController.prototype.port3F0_read = function()
|
|
{
|
|
dbg_log("3F0 read", LOG_FLOPPY);
|
|
|
|
return 0;
|
|
};
|
|
|
|
|
|
FloppyController.prototype.port3F4_read = function()
|
|
{
|
|
dbg_log("3F4 read", LOG_FLOPPY);
|
|
|
|
var return_byte = 0x80;
|
|
|
|
if(this.response_index < this.response_length)
|
|
{
|
|
return_byte |= 0x40 | 0x10;
|
|
}
|
|
|
|
if((this.dor & 8) === 0)
|
|
{
|
|
return_byte |= 0x20;
|
|
}
|
|
|
|
return return_byte;
|
|
};
|
|
|
|
FloppyController.prototype.port3F7_read = function()
|
|
{
|
|
dbg_log("3F7 read", LOG_FLOPPY);
|
|
return 0x00;
|
|
};
|
|
|
|
FloppyController.prototype.port3F5_read = function()
|
|
{
|
|
if(this.response_index < this.response_length)
|
|
{
|
|
dbg_log("3F5 read: " + this.response_data[this.response_index], LOG_FLOPPY);
|
|
this.cpu.device_lower_irq(6);
|
|
return this.response_data[this.response_index++];
|
|
}
|
|
else
|
|
{
|
|
dbg_log("3F5 read, empty", LOG_FLOPPY);
|
|
return 0xFF;
|
|
}
|
|
};
|
|
|
|
FloppyController.prototype.port3F5_write = function(reg_byte)
|
|
{
|
|
if(!this.fda_image) return;
|
|
|
|
dbg_log("3F5 write " + h(reg_byte), LOG_FLOPPY);
|
|
|
|
if(this.bytes_expecting > 0)
|
|
{
|
|
this.receiving_command[this.receiving_index++] = reg_byte;
|
|
|
|
this.bytes_expecting--;
|
|
|
|
if(this.bytes_expecting === 0)
|
|
{
|
|
if(DEBUG)
|
|
{
|
|
var log = "3F5 command received: ";
|
|
for(var i = 0; i < this.receiving_index; i++)
|
|
log += h(this.receiving_command[i]) + " ";
|
|
dbg_log(log, LOG_FLOPPY);
|
|
}
|
|
|
|
this.next_command.call(this, this.receiving_command);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(reg_byte)
|
|
{
|
|
// TODO
|
|
//case 2:
|
|
//this.next_command = read_complete_track;
|
|
//this.bytes_expecting = 8;
|
|
//break;
|
|
case 0x03:
|
|
this.next_command = this.fix_drive_data;
|
|
this.bytes_expecting = 2;
|
|
break;
|
|
case 0x04:
|
|
this.next_command = this.check_drive_status;
|
|
this.bytes_expecting = 1;
|
|
break;
|
|
case 0x05:
|
|
case 0x45:
|
|
case 0xC5:
|
|
this.next_command = function(args) { this.do_sector(true, args); };
|
|
this.bytes_expecting = 8;
|
|
break;
|
|
case 0xE6:
|
|
this.next_command = function(args) { this.do_sector(false, args); };
|
|
this.bytes_expecting = 8;
|
|
break;
|
|
case 0x07:
|
|
this.next_command = this.calibrate;
|
|
this.bytes_expecting = 1;
|
|
break;
|
|
case 0x08:
|
|
this.check_interrupt_status();
|
|
break;
|
|
case 0x4A:
|
|
this.next_command = this.read_sector_id;
|
|
this.bytes_expecting = 1;
|
|
break;
|
|
case 0x0F:
|
|
this.bytes_expecting = 2;
|
|
this.next_command = this.seek;
|
|
break;
|
|
case 0x0E:
|
|
// dump regs
|
|
dbg_log("dump registers", LOG_FLOPPY);
|
|
this.response_data[0] = 0x80;
|
|
this.response_index = 0;
|
|
this.response_length = 1;
|
|
|
|
this.bytes_expecting = 0;
|
|
break;
|
|
|
|
default:
|
|
dbg_assert(false, "Unimplemented floppy command call " + h(reg_byte));
|
|
}
|
|
|
|
this.receiving_index = 0;
|
|
}
|
|
};
|
|
|
|
FloppyController.prototype.port3F2_read = function()
|
|
{
|
|
dbg_log("read 3F2: DOR", LOG_FLOPPY);
|
|
return this.dor;
|
|
};
|
|
|
|
FloppyController.prototype.port3F2_write = function(value)
|
|
{
|
|
if((value & 4) === 4 && (this.dor & 4) === 0)
|
|
{
|
|
// reset
|
|
this.cpu.device_raise_irq(6);
|
|
}
|
|
|
|
dbg_log("start motors: " + h(value >> 4), LOG_FLOPPY);
|
|
dbg_log("enable dma: " + !!(value & 8), LOG_FLOPPY);
|
|
dbg_log("reset fdc: " + !!(value & 4), LOG_FLOPPY);
|
|
dbg_log("drive select: " + (value & 3), LOG_FLOPPY);
|
|
dbg_log("DOR = " + h(value), LOG_FLOPPY);
|
|
|
|
this.dor = value;
|
|
};
|
|
|
|
FloppyController.prototype.check_drive_status = function(args)
|
|
{
|
|
dbg_log("check drive status", LOG_FLOPPY);
|
|
|
|
this.response_index = 0;
|
|
this.response_length = 1;
|
|
this.response_data[0] = 1 << 5;
|
|
};
|
|
|
|
FloppyController.prototype.seek = function(args)
|
|
{
|
|
dbg_log("seek", LOG_FLOPPY);
|
|
dbg_assert((args[0] & 3) === 0, "Unhandled seek drive");
|
|
|
|
this.last_cylinder = args[1];
|
|
this.last_head = args[0] >> 2 & 1;
|
|
|
|
this.raise_irq();
|
|
};
|
|
|
|
FloppyController.prototype.calibrate = function(args)
|
|
{
|
|
dbg_log("floppy calibrate", LOG_FLOPPY);
|
|
|
|
this.raise_irq();
|
|
};
|
|
|
|
FloppyController.prototype.check_interrupt_status = function()
|
|
{
|
|
// do not trigger an interrupt here
|
|
dbg_log("floppy check interrupt status", LOG_FLOPPY);
|
|
|
|
this.response_index = 0;
|
|
this.response_length = 2;
|
|
|
|
this.response_data[0] = 1 << 5;
|
|
this.response_data[1] = this.last_cylinder;
|
|
};
|
|
|
|
FloppyController.prototype.do_sector = function(is_write, args)
|
|
{
|
|
var head = args[2],
|
|
cylinder = args[1],
|
|
sector = args[3],
|
|
sector_size = 128 << args[4],
|
|
read_count = args[5] - args[3] + 1,
|
|
|
|
read_offset = ((head + this.number_of_heads * cylinder) * this.sectors_per_track + sector - 1) * sector_size;
|
|
|
|
dbg_log("Floppy " + (is_write ? "Write" : "Read"), LOG_FLOPPY);
|
|
dbg_log("from " + h(read_offset) + " length " + h(read_count * sector_size), LOG_FLOPPY);
|
|
dbg_log(cylinder + " / " + head + " / " + sector, LOG_FLOPPY);
|
|
|
|
if(!args[4])
|
|
{
|
|
dbg_log("FDC: sector count is zero, use data length instead", LOG_FLOPPY);
|
|
}
|
|
|
|
if(!this.fda_image)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(is_write)
|
|
{
|
|
this.dma.do_write(this.fda_image, read_offset, read_count * sector_size, 2, this.done.bind(this, args, cylinder, head, sector));
|
|
}
|
|
else
|
|
{
|
|
this.dma.do_read(this.fda_image, read_offset, read_count * sector_size, 2, this.done.bind(this, args, cylinder, head, sector));
|
|
}
|
|
};
|
|
|
|
FloppyController.prototype.done = function(args, cylinder, head, sector, error)
|
|
{
|
|
if(error)
|
|
{
|
|
// TODO: Set appropriate bits
|
|
return;
|
|
}
|
|
|
|
sector++;
|
|
|
|
if(sector > this.sectors_per_track)
|
|
{
|
|
sector = 1;
|
|
head++;
|
|
|
|
if(head >= this.number_of_heads)
|
|
{
|
|
head = 0;
|
|
cylinder++;
|
|
}
|
|
}
|
|
|
|
this.last_cylinder = cylinder;
|
|
this.last_head = head;
|
|
this.last_sector = sector;
|
|
|
|
this.response_index = 0;
|
|
this.response_length = 7;
|
|
|
|
this.response_data[0] = head << 2 | 0x20;
|
|
this.response_data[1] = 0;
|
|
this.response_data[2] = 0;
|
|
this.response_data[3] = cylinder;
|
|
this.response_data[4] = head;
|
|
this.response_data[5] = sector;
|
|
this.response_data[6] = args[4];
|
|
|
|
this.raise_irq();
|
|
};
|
|
|
|
FloppyController.prototype.fix_drive_data = function(args)
|
|
{
|
|
dbg_log("floppy fix drive data " + args, LOG_FLOPPY);
|
|
};
|
|
|
|
FloppyController.prototype.read_sector_id = function(args)
|
|
{
|
|
dbg_log("floppy read sector id " + args, LOG_FLOPPY);
|
|
|
|
this.response_index = 0;
|
|
this.response_length = 7;
|
|
|
|
this.response_data[0] = 0;
|
|
this.response_data[1] = 0;
|
|
this.response_data[2] = 0;
|
|
this.response_data[3] = 0;
|
|
this.response_data[4] = 0;
|
|
this.response_data[5] = 0;
|
|
this.response_data[6] = 0;
|
|
|
|
this.raise_irq();
|
|
};
|
|
|
|
FloppyController.prototype.raise_irq = function()
|
|
{
|
|
if(this.dor & 8)
|
|
{
|
|
this.cpu.device_raise_irq(6);
|
|
}
|
|
};
|