blob: 68652e9f4b4d3fc4adbcdcb35073a244ee35d57a [file] [log] [blame] [raw]
"use strict";
/** @param {number=} length */
function hex_dump(buffer, length)
{
var result = [];
length = length || buffer.byteLength;
var addr = 0;
var line, byt;
for(var i = 0; i < length >> 4; i++)
{
line = h(addr + (i << 4), 5) + " ";
for(var j = 0; j < 0x10; j++)
{
byt = buffer[addr + (i << 4) + j];
line += h(byt, 2) + " ";
}
line += " ";
for(j = 0; j < 0x10; j++)
{
byt = buffer[addr + (i << 4) + j];
line += (byt < 33 || byt > 126) ? "." : String.fromCharCode(byt);
}
result.push(line);
}
return "\n" + result.join("\n");
}
/** @const */
var CDROM_SECTOR_SIZE = 2048;
/** @const */
var HD_SECTOR_SIZE = 512;
/**
* @constructor
* @param {CPU} cpu
* @param {boolean} is_cd
* @param {number} nr
* @param {BusConnector} bus
* */
function IDEDevice(cpu, buffer, is_cd, nr, bus)
{
this.master = new IDEInterface(this, cpu, buffer, is_cd, nr, 0, bus);
this.slave = new IDEInterface(this, cpu, undefined, false, nr, 1, bus);
this.current_interface = this.master;
this.cpu = cpu;
// gets set via PCI in seabios, likely doesn't matter
if(nr === 0)
{
this.ata_port = 0x1F0;
this.irq = 14;
this.pci_id = 0x1E << 3;
}
else if(nr === 1)
{
this.ata_port = 0x170;
this.irq = 15;
this.pci_id = 0x1F << 3;
}
else
{
dbg_assert(false, "IDE device with nr " + nr + " ignored", LOG_DISK);
}
// alternate status, starting at 3f4/374
/** @type {number} */
this.ata_port_high = this.ata_port | 0x204;
/** @type {number} */
this.master_port = 0xB400;
this.pci_space = [
0x86, 0x80, 0x10, 0x70, 0x05, 0x00, 0xA0, 0x02,
0x00, 0x80, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
this.ata_port & 0xFF | 1, this.ata_port >> 8, 0x00, 0x00,
this.ata_port_high & 0xFF | 1, this.ata_port_high >> 8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, // second device
0x00, 0x00, 0x00, 0x00, // second device
this.master_port & 0xFF | 1, this.master_port >> 8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x43, 0x10, 0xD4, 0x82,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, this.irq, 0x01, 0x00, 0x00,
// 0x40
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x80
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
this.pci_bars = [
{
size: 8,
},
{
size: 4,
},
undefined,
undefined,
{
size: 0x10,
},
];
this.name = "ide" + nr;
/** @type {number} */
this.device_control = 2;
// status
cpu.io.register_read(this.ata_port | 7, this, function() {
dbg_log("lower irq", LOG_DISK);
this.cpu.device_lower_irq(this.irq);
return this.read_status();
});
cpu.io.register_read(this.ata_port_high | 2, this, this.read_status);
cpu.io.register_write(this.ata_port_high | 2, this, this.write_control);
cpu.io.register_read(this.ata_port | 0, this, function()
{
return this.current_interface.read_data(1);
}, function()
{
return this.current_interface.read_data(2);
}, function()
{
return this.current_interface.read_data(4);
});
cpu.io.register_read(this.ata_port | 1, this, function()
{
dbg_log("Read error: " + h(this.current_interface.error & 0xFF) +
" slave=" + (this.current_interface === this.slave), LOG_DISK);
return this.current_interface.error;
});
cpu.io.register_read(this.ata_port | 2, this, function()
{
dbg_log("Read bytecount: " + h(this.current_interface.bytecount & 0xFF), LOG_DISK);
return this.current_interface.bytecount & 0xFF;
});
cpu.io.register_read(this.ata_port | 3, this, function()
{
dbg_log("Read sector: " + h(this.current_interface.sector & 0xFF), LOG_DISK);
return this.current_interface.sector & 0xFF;
});
cpu.io.register_read(this.ata_port | 4, this, function()
{
dbg_log("Read 1F4: " + h(this.current_interface.cylinder_low & 0xFF), LOG_DISK);
return this.current_interface.cylinder_low & 0xFF;
});
cpu.io.register_read(this.ata_port | 5, this, function()
{
dbg_log("Read 1F5: " + h(this.current_interface.cylinder_high & 0xFF), LOG_DISK);
return this.current_interface.cylinder_high & 0xFF;
});
cpu.io.register_read(this.ata_port | 6, this, function()
{
dbg_log("Read 1F6", LOG_DISK);
return this.current_interface.drive_head;
});
cpu.io.register_write(this.ata_port | 0, this, function(data)
{
this.current_interface.write_data_port8(data);
}, function(data)
{
this.current_interface.write_data_port16(data);
}, function(data)
{
this.current_interface.write_data_port32(data);
});
cpu.io.register_write(this.ata_port | 1, this, function(data)
{
dbg_log("1F1/lba_count: " + h(data), LOG_DISK);
this.master.lba_count = (this.master.lba_count << 8 | data) & 0xFFFF;
this.slave.lba_count = (this.slave.lba_count << 8 | data) & 0xFFFF;
});
cpu.io.register_write(this.ata_port | 2, this, function(data)
{
dbg_log("1F2/bytecount: " + h(data), LOG_DISK);
this.master.bytecount = (this.master.bytecount << 8 | data) & 0xFFFF;
this.slave.bytecount = (this.slave.bytecount << 8 | data) & 0xFFFF;
});
cpu.io.register_write(this.ata_port | 3, this, function(data)
{
dbg_log("1F3/sector: " + h(data), LOG_DISK);
this.master.sector = (this.master.sector << 8 | data) & 0xFFFF;
this.slave.sector = (this.slave.sector << 8 | data) & 0xFFFF;
});
cpu.io.register_write(this.ata_port | 4, this, function(data)
{
dbg_log("1F4/sector low: " + h(data), LOG_DISK);
this.master.cylinder_low = (this.master.cylinder_low << 8 | data) & 0xFFFF;
this.slave.cylinder_low = (this.slave.cylinder_low << 8 | data) & 0xFFFF;
});
cpu.io.register_write(this.ata_port | 5, this, function(data)
{
dbg_log("1F5/sector high: " + h(data), LOG_DISK);
this.master.cylinder_high = (this.master.cylinder_high << 8 | data) & 0xFFFF;
this.slave.cylinder_high = (this.slave.cylinder_high << 8 | data) & 0xFFFF;
});
cpu.io.register_write(this.ata_port | 6, this, function(data)
{
var slave = data & 0x10;
var mode = data & 0xE0;
dbg_log("1F6/drive: " + h(data, 2), LOG_DISK);
if(slave)
{
dbg_log("Slave", LOG_DISK);
this.current_interface = this.slave;
}
else
{
this.current_interface = this.master;
}
this.master.drive_head = data;
this.slave.drive_head = data;
this.master.is_lba = this.slave.is_lba = data >> 6 & 1;
this.master.head = this.slave.head = data & 0xF;
});
/** @type {number} */
this.prdt_addr = 0;
/** @type {number} */
this.dma_status = 0;
/** @type {number} */
this.dma_command = 0;
cpu.io.register_write(this.ata_port | 7, this, function(data)
{
dbg_log("lower irq", LOG_DISK);
this.cpu.device_lower_irq(this.irq);
this.current_interface.ata_command(data);
});
cpu.io.register_read(this.master_port | 4, this, undefined, undefined, this.dma_read_addr);
cpu.io.register_write(this.master_port | 4, this, undefined, undefined, this.dma_set_addr);
cpu.io.register_read(this.master_port, this,
this.dma_read_command8, undefined, this.dma_read_command);
cpu.io.register_write(this.master_port, this,
this.dma_write_command8, undefined, this.dma_write_command);
cpu.io.register_read(this.master_port | 2, this, this.dma_read_status);
cpu.io.register_write(this.master_port | 2, this, this.dma_write_status);
cpu.io.register_read(this.master_port | 0x8, this, function() {
dbg_log("DMA read 0x8", LOG_DISK); return 0;
});
cpu.io.register_read(this.master_port | 0xA, this, function() {
dbg_log("DMA read 0xA", LOG_DISK); return 0;
});
cpu.devices.pci.register_device(this);
DEBUG && Object.seal(this);
}
IDEDevice.prototype.read_status = function()
{
if(this.current_interface.buffer)
{
var ret = this.current_interface.status;
dbg_log("ATA read status: " + h(ret, 2), LOG_DISK);
return ret;
}
else
{
return 0;
}
};
IDEDevice.prototype.write_control = function(data)
{
dbg_log("set device control: " + h(data, 2) + " interrupts " +
((data & 2) ? "disabled" : "enabled"), LOG_DISK);
if(data & 4)
{
dbg_log("Reset via control port", LOG_DISK);
this.cpu.device_lower_irq(this.irq);
this.master.device_reset();
this.slave.device_reset();
}
this.device_control = data;
};
IDEDevice.prototype.dma_read_addr = function()
{
dbg_log("dma get address: " + h(this.prdt_addr, 8), LOG_DISK);
return this.prdt_addr;
};
IDEDevice.prototype.dma_set_addr = function(data)
{
dbg_log("dma set address: " + h(data, 8), LOG_DISK);
this.prdt_addr = data;
};
IDEDevice.prototype.dma_read_status = function()
{
dbg_log("DMA read status: " + h(this.dma_status), LOG_DISK);
return this.dma_status;
};
IDEDevice.prototype.dma_write_status = function(value)
{
dbg_log("DMA set status: " + h(value), LOG_DISK);
this.dma_status &= ~(value & 6);
};
IDEDevice.prototype.dma_read_command = function()
{
return this.dma_read_command8() | this.dma_read_status() << 16;
};
IDEDevice.prototype.dma_read_command8 = function()
{
dbg_log("DMA read command: " + h(this.dma_command), LOG_DISK);
return this.dma_command;
};
IDEDevice.prototype.dma_write_command = function(value)
{
dbg_log("DMA write command: " + h(value), LOG_DISK);
this.dma_write_command8(value & 0xFF);
this.dma_write_status(value >> 16 & 0xFF);
};
IDEDevice.prototype.dma_write_command8 = function(value)
{
dbg_log("DMA write command8: " + h(value), LOG_DISK);
let old_command = this.dma_command;
this.dma_command = value & 0x9;
if((old_command & 1) === (value & 1))
{
return;
}
if((value & 1) === 0)
{
this.dma_status &= ~1;
return;
}
this.dma_status |= 1;
switch(this.current_interface.current_command)
{
case 0x25:
case 0xC8:
this.current_interface.do_ata_read_sectors_dma();
break;
case 0xCA:
case 0x35:
this.current_interface.do_ata_write_sectors_dma();
break;
case 0xA0:
this.current_interface.do_atapi_dma();
break;
default:
dbg_log("Spurious dma command write, current command: " +
h(this.current_interface.current_command), LOG_DISK);
dbg_assert(false);
}
};
IDEDevice.prototype.push_irq = function()
{
if((this.device_control & 2) === 0)
{
dbg_log("push irq", LOG_DISK);
this.dma_status |= 4;
this.cpu.device_raise_irq(this.irq);
}
};
IDEDevice.prototype.get_state = function()
{
var state = [];
state[0] = this.master;
state[1] = this.slave;
state[2] = this.ata_port;
state[3] = this.irq;
state[4] = this.pci_id;
state[5] = this.ata_port_high;
state[6] = this.master_port;
state[7] = this.name;
state[8] = this.device_control;
state[9] = this.prdt_addr;
state[10] = this.dma_status;
state[11] = this.current_interface === this.master;
state[12] = this.dma_command;
return state;
};
IDEDevice.prototype.set_state = function(state)
{
this.master = state[0];
this.slave = state[1];
this.ata_port = state[2];
this.irq = state[3];
this.pci_id = state[4];
this.ata_port_high = state[5];
this.master_port = state[6];
this.name = state[7];
this.device_control = state[8];
this.prdt_addr = state[9];
this.dma_status = state[10];
this.current_interface = state[11] ? this.master : this.slave;
this.dma_command = state[12];
};
/**
* @constructor
*/
function IDEInterface(device, cpu, buffer, is_cd, device_nr, interface_nr, bus)
{
this.device = device;
/** @const @type {BusConnector} */
this.bus = bus;
/**
* @const
* @type {number}
*/
this.nr = device_nr;
/** @const @type {CPU} */
this.cpu = cpu;
this.buffer = buffer;
/** @type {number} */
this.sector_size = is_cd ? CDROM_SECTOR_SIZE : HD_SECTOR_SIZE;
/** @type {boolean} */
this.is_atapi = is_cd;
/** @type {number} */
this.sector_count = 0;
/** @type {number} */
this.head_count = 0;
/** @type {number} */
this.sectors_per_track = 0;
/** @type {number} */
this.cylinder_count = 0;
if(this.buffer)
{
this.sector_count = this.buffer.byteLength / this.sector_size;
if(this.sector_count !== (this.sector_count | 0))
{
dbg_log("Warning: Disk size not aligned with sector size", LOG_DISK);
this.sector_count = Math.ceil(this.sector_count);
}
if(is_cd)
{
this.head_count = 1;
this.sectors_per_track = 0;
}
else
{
// "default" values: 16/63
// common: 255, 63
this.head_count = 16;
this.sectors_per_track = 63;
}
this.cylinder_count = this.sector_count / this.head_count / this.sectors_per_track;
if(this.cylinder_count !== (this.cylinder_count | 0))
{
dbg_log("Warning: Rounding up cylinder count. Choose different head number", LOG_DISK);
this.cylinder_count = Math.floor(this.cylinder_count);
//this.sector_count = this.cylinder_count * this.head_count *
// this.sectors_per_track * this.sector_size;
}
//if(this.cylinder_count > 16383)
//{
// this.cylinder_count = 16383;
//}
// disk translation: lba
var rtc = cpu.devices.rtc;
// master
rtc.cmos_write(CMOS_BIOS_DISKTRANSFLAG,
rtc.cmos_read(CMOS_BIOS_DISKTRANSFLAG) | 1 << this.nr * 4);
rtc.cmos_write(CMOS_DISK_DATA, rtc.cmos_read(CMOS_DISK_DATA) & 0x0F | 0xF0);
var reg = CMOS_DISK_DRIVE1_CYL;
rtc.cmos_write(reg + 0, this.cylinder_count & 0xFF);
rtc.cmos_write(reg + 1, this.cylinder_count >> 8 & 0xFF);
rtc.cmos_write(reg + 2, this.head_count & 0xFF);
rtc.cmos_write(reg + 3, 0xFF);
rtc.cmos_write(reg + 4, 0xFF);
rtc.cmos_write(reg + 5, 0xC8);
rtc.cmos_write(reg + 6, this.cylinder_count & 0xFF);
rtc.cmos_write(reg + 7, this.cylinder_count >> 8 & 0xFF);
rtc.cmos_write(reg + 8, this.sectors_per_track & 0xFF);
//rtc.cmos_write(CMOS_BIOS_DISKTRANSFLAG,
// rtc.cmos_read(CMOS_BIOS_DISKTRANSFLAG) | 1 << (nr * 4 + 2)); // slave
}
/** @const */
this.stats = {
sectors_read: 0,
sectors_written: 0,
bytes_read: 0,
bytes_written: 0,
loading: false,
};
this.buffer = buffer;
/** @type {number} */
this.is_lba = 0;
/** @type {number} */
this.bytecount = 0;
/** @type {number} */
this.sector = 0;
/** @type {number} */
this.lba_count = 0;
/** @type {number} */
this.cylinder_low = 0;
/** @type {number} */
this.cylinder_high = 0;
/** @type {number} */
this.head = 0;
/** @type {number} */
this.drive_head = 0;
/** @type {number} */
this.status = 0x50;
/** @type {number} */
this.sectors_per_drq = 0x80;
/** @type {number} */
this.error = 0;
/** @type {number} */
this.data_pointer = 0;
this.data = new Uint8Array(64 * 1024);
this.data16 = new Uint16Array(this.data.buffer);
this.data32 = new Int32Array(this.data.buffer);
/** @type {number} */
this.data_length = 0;
/** @type {number} */
this.data_end = 0;
/** @type {number} */
this.current_command = -1;
/** @type {number} */
this.current_atapi_command = -1;
/** @type {number} */
this.write_dest = 0;
Object.seal(this);
}
IDEInterface.prototype.device_reset = function()
{
if(this.is_atapi)
{
this.status = 0;
this.bytecount = 1;
this.error = 1;
this.sector = 1; // lba_low
this.cylinder_low = 0x14; // lba_mid
this.cylinder_high = 0xEB; // lba_high
}
else
{
this.status = 0x50 | 1;
this.bytecount = 1;
this.error = 1;
this.sector = 1; // lba_low
// 0, 0 needed by bochs bios
this.cylinder_low = 0; // lba_mid
this.cylinder_high = 0; // lba_high
}
};
IDEInterface.prototype.push_irq = function()
{
this.device.push_irq();
};
IDEInterface.prototype.ata_command = function(cmd)
{
dbg_log("ATA Command: " + h(cmd) + " slave=" + (this.drive_head >> 4 & 1), LOG_DISK);
if(!this.buffer)
{
dbg_log("abort: No buffer", LOG_DISK);
this.error = 4;
this.status = 0x41;
this.push_irq();
return;
}
this.current_command = cmd;
this.error = 0;
switch(cmd)
{
case 0x08:
dbg_log("ATA device reset", LOG_DISK);
this.data_pointer = 0;
this.data_end = 0;
this.data_length = 0;
this.device_reset();
this.push_irq();
break;
case 0x10:
// calibrate drive
this.status = 0x50;
this.cylinder_low = 0;
this.push_irq();
break;
case 0xF8:
// read native max address
this.status = 0x50;
var last_sector = this.sector_count - 1;
this.sector = last_sector & 0xFF;
this.cylinder_low = last_sector >> 8 & 0xFF;
this.cylinder_high = last_sector >> 16 & 0xFF;
this.drive_head = this.drive_head & 0xF0 | last_sector >> 24 & 0x0F;
this.push_irq();
break;
case 0x27:
// read native max address ext
this.status = 0x50;
var last_sector = this.sector_count - 1;
this.sector = last_sector & 0xFF;
this.cylinder_low = last_sector >> 8 & 0xFF;
this.cylinder_high = last_sector >> 16 & 0xFF;
this.sector |= last_sector >> 24 << 8 & 0xFF00;
this.push_irq();
break;
case 0x20:
case 0x24:
case 0x29:
case 0xC4:
// 0x20 read sectors
// 0x24 read sectors ext
// 0xC4 read multiple
// 0x29 read multiple ext
this.ata_read_sectors(cmd);
break;
case 0x30:
case 0x34:
case 0x39:
case 0xC5:
// 0x30 write sectors
// 0x34 write sectors ext
// 0xC5 write multiple
// 0x39 write multiple ext
this.ata_write_sectors(cmd);
break;
case 0x90:
// execute device diagnostic
this.push_irq();
this.error = 0x101;
this.status = 0x50;
break;
case 0x91:
// initialize device parameters
this.status = 0x50;
this.push_irq();
break;
case 0xA0:
// ATA packet
if(this.is_atapi)
{
this.status = 0x58;
this.data_allocate(12);
this.data_end = 12;
this.bytecount = 1;
this.push_irq();
}
break;
case 0xA1:
dbg_log("ATA identify packet device", LOG_DISK);
if(this.is_atapi)
{
this.create_identify_packet();
this.status = 0x58;
this.cylinder_low = 0x14;
this.cylinder_high = 0xEB;
this.push_irq();
}
else
{
this.status = 0x41;
this.push_irq();
}
break;
case 0xC6:
// set multiple mode
// Logical sectors per DRQ Block in word 1
dbg_log("Logical sectors per DRQ Block: " + h(this.bytecount & 0xFF), LOG_DISK);
this.sectors_per_drq = this.bytecount & 0xFF;
this.status = 0x50;
this.push_irq();
break;
case 0x25: // read dma ext
case 0xC8: // read dma
this.ata_read_sectors_dma(cmd);
break;
case 0x35: // write dma ext
case 0xCA: // write dma
this.ata_write_sectors_dma(cmd);
break;
case 0x40:
dbg_log("read verify sectors", LOG_DISK);
this.status = 0x50;
this.push_irq();
break;
case 0xDA:
dbg_log("Unimplemented: get media status", LOG_DISK);
this.status = 0x41;
this.error = 4;
this.push_irq();
break;
case 0xE0:
dbg_log("ATA standby immediate", LOG_DISK);
this.status = 0x50;
this.push_irq();
break;
case 0xE1:
dbg_log("ATA idle immediate", LOG_DISK);
this.status = 0x50;
this.push_irq();
break;
case 0xE7:
dbg_log("ATA flush cache", LOG_DISK);
this.status = 0x50;
this.push_irq();
break;
case 0xEC:
dbg_log("ATA identify device", LOG_DISK);
if(this.is_atapi)
{
this.status = 0x41;
this.error = 4;
this.push_irq();
return;
}
this.create_identify_packet();
this.status = 0x58;
this.push_irq();
break;
case 0xEA:
dbg_log("flush cache ext", LOG_DISK);
this.status = 0x50;
this.push_irq();
break;
case 0xEF:
dbg_log("set features: " + h(this.bytecount & 0xFF), LOG_DISK);
this.status = 0x50;
this.push_irq();
break;
case 0xF5:
dbg_log("security freeze lock", LOG_DISK);
this.status = 0x50;
this.push_irq();
break;
case 0xF9:
dbg_log("Unimplemented: set max address", LOG_DISK);
this.status = 0x41;
this.error = 4;
break;
default:
dbg_log(false, "New ATA cmd on 1F7: " + h(cmd), LOG_DISK);
this.status = 0x41;
// abort bit set
this.error = 4;
}
};
IDEInterface.prototype.atapi_handle = function()
{
dbg_log("ATAPI Command: " + h(this.data[0]) +
" slave=" + (this.drive_head >> 4 & 1), LOG_DISK);
this.data_pointer = 0;
this.current_atapi_command = this.data[0];
switch(this.current_atapi_command)
{
case 0x00:
dbg_log("test unit ready", LOG_DISK);
// test unit ready
this.data_allocate(0);
this.data_end = this.data_length;
this.status = 0x50;
break;
case 0x03:
// request sense
this.data_allocate(this.data[4]);
this.data_end = this.data_length;
this.status = 0x58;
this.data[0] = 0x80 | 0x70;
this.data[2] = 5; // illegal request
this.data[7] = 8;
break;
case 0x12:
// inquiry
var length = this.data[4];
this.status = 0x58;
dbg_log("inquiry: " + h(this.data[1], 2) + " length=" + length, LOG_DISK);
// http://www.t10.org/ftp/x3t9.2/document.87/87-106r0.txt
//this.data_allocate(36);
this.data.set([
0x05, 0x80, 0x01, 0x31,
// additional length
31,
0, 0, 0,
// 8
0x53, 0x4F, 0x4E, 0x59,
0x20, 0x20, 0x20, 0x20,
// 16
0x43, 0x44, 0x2D, 0x52,
0x4F, 0x4D, 0x20, 0x43,
0x44, 0x55, 0x2D, 0x31,
0x30, 0x30, 0x30, 0x20,
// 32
0x31, 0x2E, 0x31, 0x61,
]);
this.data_end = this.data_length = Math.min(36, length);
break;
case 0x1A:
// mode sense (6)
this.data_allocate(this.data[4]);
this.data_end = this.data_length;
this.status = 0x58;
break;
case 0x1E:
// prevent/allow medium removal
this.data_allocate(0);
this.data_end = this.data_length;
this.status = 0x50;
break;
case 0x25:
// read capacity
var count = this.sector_count - 1;
this.data_set(new Uint8Array([
count >> 24 & 0xFF,
count >> 16 & 0xFF,
count >> 8 & 0xFF,
count & 0xFF,
0,
0,
this.sector_size >> 8 & 0xFF,
this.sector_size & 0xFF,
]));
this.data_end = this.data_length;
this.status = 0x58;
break;
case 0x28:
// read
if(this.lba_count & 1)
{
this.atapi_read_dma(this.data);
}
else
{
this.atapi_read(this.data);
}
break;
case 0x42:
var length = this.data[8];
this.data_allocate(Math.min(8, length));
this.data_end = this.data_length;
dbg_log("read q subcode: length=" + length, LOG_DISK);
this.status = 0x58;
break;
case 0x43:
// read toc
var length = this.data[8] | this.data[7] << 8;
var format = this.data[9] >> 6;
this.data_allocate(length);
this.data_end = this.data_length;
dbg_log("read toc: " + h(format, 2) +
" length=" + length +
" " + (this.data[1] & 2) +
" " + h(this.data[6]), LOG_DISK);
if(format === 0)
{
var sector_count = this.sector_count;
this.data.set(new Uint8Array([
0, 18, // length
1, 1, // first and last session
0,
0x14,
1, // track number
0,
0, 0, 0, 0,
0,
0x16,
0xAA, // track number
0,
sector_count >> 24,
sector_count >> 16 & 0xFF,
sector_count >> 8 & 0xFF,
sector_count & 0xFF,
]));
}
else if(format === 1)
{
this.data.set(new Uint8Array([
0, 10, // length
1, 1, // first and last session
0, 0,
0, 0,
0, 0,
0, 0,
]));
}
else
{
dbg_assert(false, "Unimplemented format: " + format);
}
this.status = 0x58;
break;
case 0x46:
// get configuration
var length = this.data[8] | this.data[7] << 8;
length = Math.min(length, 32);
this.data_allocate(length);
this.data_end = this.data_length;
this.data[0] = length - 4 >> 24 & 0xFF;
this.data[1] = length - 4 >> 16 & 0xFF;
this.data[2] = length - 4 >> 8 & 0xFF;
this.data[3] = length - 4 & 0xFF;
this.data[6] = 0x08;
this.data[10] = 3;
this.status = 0x58;
break;
case 0x51:
// read disk information
this.data_allocate(0);
this.data_end = this.data_length;
this.status = 0x50;
break;
case 0x52:
dbg_log("Unimplemented ATAPI command: " + h(this.data[0]), LOG_DISK);
this.status = 0x51;
this.data_length = 0;
this.error = 5 << 4;
break;
case 0x5A:
// mode sense
var length = this.data[8] | this.data[7] << 8;
var page_code = this.data[2];
dbg_log("mode sense: " + h(page_code) + " length=" + length, LOG_DISK);
if(page_code === 0x2A)
{
this.data_allocate(Math.min(30, length));
}
this.data_end = this.data_length;
this.status = 0x58;
break;
case 0xBD:
// mechanism status
this.data_allocate(this.data[9] | this.data[8] << 8);
this.data_end = this.data_length;
this.data[5] = 1;
this.status = 0x58;
break;
case 0x4A:
this.status = 0x51;
this.data_length = 0;
this.error = 5 << 4;
dbg_log("Unimplemented ATAPI command: " + h(this.data[0]), LOG_DISK);
break;
default:
this.status = 0x51;
this.data_length = 0;
this.error = 5 << 4;
dbg_log("Unimplemented ATAPI command: " + h(this.data[0]), LOG_DISK);
dbg_assert(false);
}
this.bytecount = this.bytecount & ~7 | 2;
if((this.status & 0x80) === 0)
{
this.push_irq();
}
if((this.status & 0x80) === 0 && this.data_length === 0)
{
this.bytecount |= 1;
this.status &= ~8;
}
};
IDEInterface.prototype.do_write = function()
{
this.status = 0x50;
dbg_assert(this.data_length <= this.data.length);
var data = this.data.subarray(0, this.data_length);
//dbg_log(hex_dump(data), LOG_DISK);
dbg_assert(this.data_length % 512 === 0);
this.ata_advance(this.current_command, this.data_length / 512);
this.push_irq();
this.buffer.set(this.write_dest, data, function()
{
});
this.report_write(this.data_length);
};
IDEInterface.prototype.atapi_read = function(cmd)
{
// Note: Big Endian
var lba = cmd[2] << 24 | cmd[3] << 16 | cmd[4] << 8 | cmd[5];
var count = cmd[7] << 8 | cmd[8];
var flags = cmd[1];
var byte_count = count * this.sector_size;
var start = lba * this.sector_size;
dbg_log("CD read lba=" + h(lba) +
" lbacount=" + h(count) +
" bytecount=" + h(byte_count) +
" flags=" + h(flags), LOG_DISK);
this.data_length = 0;
var req_length = this.cylinder_high << 8 & 0xFF00 | this.cylinder_low & 0xFF;
dbg_log(h(this.cylinder_high, 2) + " " + h(this.cylinder_low, 2), LOG_DISK);
this.cylinder_low = this.cylinder_high = 0; // oak technology driver (windows 3.0)
if(req_length === 0xFFFF)
req_length--;
if(req_length > byte_count)
{
req_length = byte_count;
}
if(start >= this.buffer.byteLength)
{
dbg_assert(false, "CD read: Outside of disk end=" + h(start + byte_count) +
" size=" + h(this.buffer.byteLength), LOG_DISK);
this.status = 0xFF;
this.push_irq();
}
else if(byte_count === 0)
{
this.status = 0x50;
this.data_pointer = 0;
//this.push_irq();
}
else
{
byte_count = Math.min(byte_count, this.buffer.byteLength - start);
this.status = 0x50 | 0x80;
this.report_read_start();
this.buffer.get(start, byte_count, (data) =>
{
//setTimeout(() => {
dbg_log("cd read: data arrived", LOG_DISK);
this.data_set(data);
this.status = 0x58;
this.bytecount = this.bytecount & ~7 | 2;
this.push_irq();
req_length &= ~3;
this.data_end = req_length;
if(this.data_end > this.data_length)
{
this.data_end = this.data_length;
}
this.cylinder_low = this.data_end & 0xFF;
this.cylinder_high = this.data_end >> 8 & 0xFF;
this.report_read_end(byte_count);
//}, 10);
});
}
};
IDEInterface.prototype.atapi_read_dma = function(cmd)
{
// Note: Big Endian
var lba = cmd[2] << 24 | cmd[3] << 16 | cmd[4] << 8 | cmd[5];
var count = cmd[7] << 8 | cmd[8];
var flags = cmd[1];
var byte_count = count * this.sector_size;
var start = lba * this.sector_size;
dbg_log("CD read DMA lba=" + h(lba) +
" lbacount=" + h(count) +
" bytecount=" + h(byte_count) +
" flags=" + h(flags), LOG_DISK);
if(start >= this.buffer.byteLength)
{
dbg_assert(false, "CD read: Outside of disk end=" + h(start + byte_count) +
" size=" + h(this.buffer.byteLength), LOG_DISK);
this.status = 0xFF;
this.push_irq();
}
else
{
this.status = 0x50 | 0x80;
this.report_read_start();
this.buffer.get(start, byte_count, (data) =>
{
dbg_log("atapi_read_dma: Data arrived");
this.report_read_end(byte_count);
this.status = 0x58;
this.bytecount = this.bytecount & ~7 | 2;
this.data_set(data);
this.do_atapi_dma();
});
}
};
IDEInterface.prototype.do_atapi_dma = function()
{
if((this.device.dma_status & 1) === 0)
{
dbg_log("do_atapi_dma: Status not set", LOG_DISK);
return;
}
if((this.status & 0x8) === 0)
{
dbg_log("do_atapi_dma: DRQ not set", LOG_DISK);
return;
}
dbg_log("atapi dma transfer len=" + this.data_length, LOG_DISK);
var prdt_start = this.device.prdt_addr;
var offset = 0;
var data = this.data;
do {
var addr = this.cpu.read32s(prdt_start);
var count = this.cpu.read16(prdt_start + 4);
var end = this.cpu.read8(prdt_start + 7) & 0x80;
if(!count)
{
count = 0x10000;
}
dbg_log("dma read dest=" + h(addr) + " count=" + h(count) + " datalen=" + h(this.data_length), LOG_DISK);
this.cpu.write_blob(data.subarray(offset,
Math.min(offset + count, this.data_length)), addr);
offset += count;
prdt_start += 8;
if(offset >= this.data_length && !end)
{
dbg_log("leave early end=" + (+end) +
" offset=" + h(offset) +
" data_length=" + h(this.data_length) +
" cmd=" + h(this.current_command), LOG_DISK);
break;
}
}
while(!end);
dbg_log("end offset=" + offset, LOG_DISK);
this.status = 0x50;
this.device.dma_status &= ~1;
this.bytecount = this.bytecount & ~7 | 3;
this.push_irq();
};
IDEInterface.prototype.read_data = function(length)
{
if(this.data_pointer < this.data_end)
{
dbg_assert(this.data_pointer + length - 1 < this.data_end);
dbg_assert(this.data_pointer % length === 0, h(this.data_pointer) + " " + length);
if(length === 1)
{
var result = this.data[this.data_pointer];
}
else if(length === 2)
{
var result = this.data16[this.data_pointer >>> 1];
}
else
{
var result = this.data32[this.data_pointer >>> 2];
}
this.data_pointer += length;
var align = (this.data_end & 0xFFF) === 0 ? 0xFFF : 0xFF;
if((this.data_pointer & align) === 0)
{
dbg_log("Read 1F0: " + h(this.data[this.data_pointer], 2) +
" cur=" + h(this.data_pointer) +
" cnt=" + h(this.data_length), LOG_DISK);
}
if(this.data_pointer >= this.data_end)
{
this.read_end();
}
return result;
}
else
{
dbg_log("Read 1F0: empty", LOG_DISK);
this.data_pointer += length;
return 0;
}
};
IDEInterface.prototype.read_end = function()
{
dbg_log("read_end cmd=" + h(this.current_command) + " data_pointer=" + h(this.data_pointer) +
" end=" + h(this.data_end) + " length=" + h(this.data_length), LOG_DISK);
if(this.current_command === 0xA0)
{
if(this.data_end === this.data_length)
{
this.status = 0x50;
this.bytecount = this.bytecount & ~7 | 3;
this.push_irq();
}
else
{
this.status = 0x58;
this.bytecount = this.bytecount & ~7 | 2;
this.push_irq();
var byte_count = this.cylinder_high << 8 & 0xFF00 | this.cylinder_low & 0xFF;
if(this.data_end + byte_count > this.data_length)
{
this.cylinder_low = (this.data_length - this.data_end) & 0xFF;
this.cylinder_high = (this.data_length - this.data_end) >> 8 & 0xFF;
this.data_end = this.data_length;
}
else
{
this.data_end += byte_count;
}
dbg_log("data_end=" + h(this.data_end), LOG_DISK);
}
}
else
{
this.error = 0;
if(this.data_pointer >= this.data_length)
{
this.status = 0x50;
this.push_irq();
}
else
{
if(this.current_command === 0xC4 || this.current_command === 0x29)
{
var sector_count = Math.min(this.sectors_per_drq,
(this.data_length - this.data_end) / 512);
dbg_assert(sector_count % 1 === 0);
}
else
{
dbg_assert(this.current_command === 0x20 || this.current_command === 0x24);
var sector_count = 1;
}
this.ata_advance(this.current_command, sector_count);
this.data_end += 512 * sector_count;
this.status = 0x58;
this.push_irq();
}
}
};
IDEInterface.prototype.write_data_port = function(data, length)
{
dbg_assert(this.data_pointer % length === 0);
if(this.data_pointer >= this.data_end)
{
dbg_log("Redundant write to data port: " + h(data) + " count=" + h(this.data_end) +
" cur=" + h(this.data_pointer), LOG_DISK);
}
else
{
var align = (this.data_end & 0xFFF) === 0 ? 0xFFF : 0xFF;
if((this.data_pointer + length & align) === 0 || this.data_end < 20)
{
dbg_log("Data port: " + h(data >>> 0) + " count=" + h(this.data_end) +
" cur=" + h(this.data_pointer), LOG_DISK);
}
if(length === 1)
{
this.data[this.data_pointer++] = data;
}
else if(length === 2)
{
this.data16[this.data_pointer >>> 1] = data;
this.data_pointer += 2;
}
else
{
this.data32[this.data_pointer >>> 2] = data;
this.data_pointer += 4;
}
dbg_assert(this.data_pointer <= this.data_end);
if(this.data_pointer === this.data_end)
{
this.write_end();
}
}
};
IDEInterface.prototype.write_data_port8 = function(data)
{
this.write_data_port(data, 1);
};
IDEInterface.prototype.write_data_port16 = function(data)
{
this.write_data_port(data, 2);
};
IDEInterface.prototype.write_data_port32 = function(data)
{
this.write_data_port(data, 4);
};
IDEInterface.prototype.write_end = function()
{
if(this.current_command === 0xA0)
{
this.atapi_handle();
}
else
{
dbg_log("write_end data_pointer=" + h(this.data_pointer) +
" data_length=" + h(this.data_length), LOG_DISK);
if(this.data_pointer >= this.data_length)
{
this.do_write();
}
else
{
dbg_assert(this.current_command === 0x30 || this.current_command === 0x34);
// XXX: Should advance here, but do_write does all the advancing
//this.ata_advance(this.current_command, 1);
this.status = 0x58;
this.data_end += 512;
this.push_irq();
}
}
};
IDEInterface.prototype.ata_advance = function(cmd, sectors)
{
dbg_log("Advance sectors=" + sectors + " old_bytecount=" + this.bytecount, LOG_DISK);
this.bytecount -= sectors;
if(cmd === 0x24 || cmd === 0x29 || cmd === 0x34 || cmd === 0x39 ||
cmd === 0x25 || cmd === 0x35)
{
var new_sector = sectors + this.get_lba48();
this.sector = new_sector & 0xFF | new_sector >> 16 & 0xFF00;
this.cylinder_low = new_sector >> 8 & 0xFF;
this.cylinder_high = new_sector >> 16 & 0xFF;
}
else if(this.is_lba)
{
var new_sector = sectors + this.get_lba28();
this.sector = new_sector & 0xFF;
this.cylinder_low = new_sector >> 8 & 0xFF;
this.cylinder_high = new_sector >> 16 & 0xFF;
this.head = this.head & ~0xF | new_sector & 0xF;
}
else // chs
{
var new_sector = sectors + this.get_chs();
var c = new_sector / (this.head_count * this.sectors_per_track) | 0;
this.cylinder_low = c & 0xFF;
this.cylinder_high = c >> 8 & 0xFF;
this.head = (new_sector / this.sectors_per_track | 0) % this.head_count & 0xF;
this.sector = (new_sector % this.sectors_per_track + 1) & 0xFF;
dbg_assert(new_sector === this.get_chs());
}
};
IDEInterface.prototype.ata_read_sectors = function(cmd)
{
var is_lba48 = cmd === 0x24 || cmd === 0x29;
var count = this.get_count(is_lba48);
var lba = this.get_lba(is_lba48);
var is_single = cmd === 0x20 || cmd === 0x24;
var byte_count = count * this.sector_size;
var start = lba * this.sector_size;
dbg_log("ATA read cmd=" + h(cmd) +
" mode=" + (this.is_lba ? "lba" : "chs") +
" lba=" + h(lba) +
" lbacount=" + h(count) +
" bytecount=" + h(byte_count), LOG_DISK);
if(start + byte_count > this.buffer.byteLength)
{
dbg_assert(false, "ATA read: Outside of disk", LOG_DISK);
this.status = 0xFF;
this.push_irq();
}
else
{
this.status = 0x80 | 0x40;
this.report_read_start();
this.buffer.get(start, byte_count, (data) =>
{
//setTimeout(() => {
dbg_log("ata_read: Data arrived", LOG_DISK);
this.data_set(data);
this.status = 0x58;
this.data_end = is_single ? 512 : Math.min(byte_count, this.sectors_per_drq * 512);
this.ata_advance(cmd, is_single ? 1 : Math.min(count, this.sectors_per_track));
this.push_irq();
this.report_read_end(byte_count);
//}, 10);
});
}
};
IDEInterface.prototype.ata_read_sectors_dma = function(cmd)
{
var is_lba48 = cmd === 0x25;
var count = this.get_count(is_lba48);
var lba = this.get_lba(is_lba48);
var byte_count = count * this.sector_size;
var start = lba * this.sector_size;
dbg_log("ATA DMA read lba=" + h(lba) +
" lbacount=" + h(count) +
" bytecount=" + h(byte_count), LOG_DISK);
if(start + byte_count > this.buffer.byteLength)
{
dbg_assert(false, "ATA read: Outside of disk", LOG_DISK);
this.status = 0xFF;
this.push_irq();
return;
}
this.status = 0x58;
this.device.dma_status |= 1;
};
IDEInterface.prototype.do_ata_read_sectors_dma = function()
{
var cmd = this.current_command;
var is_lba48 = cmd === 0x25;
var count = this.get_count(is_lba48);
var lba = this.get_lba(is_lba48);
var byte_count = count * this.sector_size;
var start = lba * this.sector_size;
dbg_assert(lba < this.buffer.byteLength);
this.report_read_start();
var orig_prdt_start = this.device.prdt_addr;
this.buffer.get(start, byte_count, (data) =>
{
//setTimeout(function() {
dbg_log("do_ata_read_sectors_dma: Data arrived", LOG_DISK);
var prdt_start = this.device.prdt_addr;
var offset = 0;
dbg_assert(orig_prdt_start === prdt_start);
do {
var prd_addr = this.cpu.read32s(prdt_start);
var prd_count = this.cpu.read16(prdt_start + 4);
var end = this.cpu.read8(prdt_start + 7) & 0x80;
if(!prd_count)
{
prd_count = 0x10000;
dbg_log("dma: prd count was 0", LOG_DISK);
}
dbg_log("dma read transfer dest=" + h(prd_addr) +
" prd_count=" + h(prd_count), LOG_DISK);
this.cpu.write_blob(data.subarray(offset, offset + prd_count), prd_addr);
offset += prd_count;
prdt_start += 8;
}
while(!end);
dbg_assert(offset === byte_count);
this.ata_advance(this.current_command, count);
this.status = 0x50;
this.device.dma_status &= ~1;
this.current_command = -1;
this.push_irq();
this.report_read_end(byte_count);
//}.bind(this), 10);
});
};
IDEInterface.prototype.ata_write_sectors = function(cmd)
{
var is_lba48 = cmd === 0x34 || cmd === 0x39;
var count = this.get_count(is_lba48);
var lba = this.get_lba(is_lba48);
var is_single = cmd === 0x30 || cmd === 0x34;
var byte_count = count * this.sector_size;
var start = lba * this.sector_size;
dbg_log("ATA write lba=" + h(lba) +
" mode=" + (this.is_lba ? "lba" : "chs") +
" lbacount=" + h(count) +
" bytecount=" + h(byte_count), LOG_DISK);
if(start + byte_count > this.buffer.byteLength)
{
dbg_assert(false, "ATA write: Outside of disk", LOG_DISK);
this.status = 0xFF;
this.push_irq();
}
else
{
this.status = 0x58;
this.data_allocate_noclear(byte_count);
this.data_end = is_single ? 512 : Math.min(byte_count, this.sectors_per_drq * 512);
this.write_dest = start;
}
};
IDEInterface.prototype.ata_write_sectors_dma = function(cmd)
{
var is_lba48 = cmd === 0x35;
var count = this.get_count(is_lba48);
var lba = this.get_lba(is_lba48);
var byte_count = count * this.sector_size;
var start = lba * this.sector_size;
dbg_log("ATA DMA write lba=" + h(lba) +
" lbacount=" + h(count) +
" bytecount=" + h(byte_count), LOG_DISK);
if(start + byte_count > this.buffer.byteLength)
{
dbg_assert(false, "ATA DMA write: Outside of disk", LOG_DISK);
this.status = 0xFF;
this.push_irq();
return;
}
this.status = 0x58;
this.device.dma_status |= 1;
};
IDEInterface.prototype.do_ata_write_sectors_dma = function()
{
var cmd = this.current_command;
var is_lba48 = cmd === 0x35;
var count = this.get_count(is_lba48);
var lba = this.get_lba(is_lba48);
var byte_count = count * this.sector_size;
var start = lba * this.sector_size;
var prdt_start = this.device.prdt_addr;
var prdt_count = 0;
var prdt_write_count = 0;
var offset = 0;
dbg_log("prdt addr: " + h(prdt_start, 8), LOG_DISK);
do {
var prd_addr = this.cpu.read32s(prdt_start);
var prd_count = this.cpu.read16(prdt_start + 4);
var end = this.cpu.read8(prdt_start + 7) & 0x80;
if(!prd_count)
{
prd_count = 0x10000;
dbg_log("dma: prd count was 0", LOG_DISK);
}
dbg_log("dma write transfer dest=" + h(prd_addr) + " prd_count=" + h(prd_count), LOG_DISK);
var slice = this.cpu.mem8.subarray(prd_addr, prd_addr + prd_count);
dbg_assert(slice.length === prd_count);
//if(DEBUG)
//{
// dbg_log(hex_dump(slice), LOG_DISK);
//}
this.buffer.set(start + offset, slice, function()
{
prdt_write_count++;
});
offset += prd_count;
prdt_start += 8;
prdt_count++;
}
while(!end);
if(prdt_write_count === prdt_count)
{
//setTimeout(function() {
dbg_log("dma write completed", LOG_DISK);
this.ata_advance(this.current_command, count);
this.status = 0x50;
this.push_irq();
this.device.dma_status &= ~1;
this.current_command = -1;
//}, 10);
}
else
{
// fails when writes don't happen synchronously, which isn't currently
// the case, but might be in the future
dbg_assert(false, "dma write not completed", LOG_DISK);
}
this.report_write(byte_count);
};
IDEInterface.prototype.get_chs = function()
{
var c = this.cylinder_low & 0xFF | this.cylinder_high << 8 & 0xFF00;
var h = this.head;
var s = this.sector & 0xFF;
dbg_log("get_chs: c=" + c + " h=" + h + " s=" + s, LOG_DISK);
return (c * this.head_count + h) * this.sectors_per_track + s - 1;
};
IDEInterface.prototype.get_lba28 = function()
{
return this.sector & 0xFF |
this.cylinder_low << 8 & 0xFF00 |
this.cylinder_high << 16 & 0xFF0000 |
(this.head & 0xF) << 24;
};
IDEInterface.prototype.get_lba48 = function()
{
// Note: Bits over 32 missing
return (this.sector & 0xFF |
this.cylinder_low << 8 & 0xFF00 |
this.cylinder_high << 16 & 0xFF0000 |
(this.sector >> 8) << 24 & 0xFF000000) >>> 0;
};
IDEInterface.prototype.get_lba = function(is_lba48)
{
if(is_lba48)
{
return this.get_lba48();
}
else if(this.is_lba)
{
return this.get_lba28();
}
else
{
return this.get_chs();
}
};
IDEInterface.prototype.get_count = function(is_lba48)
{
if(is_lba48)
{
var count = this.bytecount;
if(count === 0) count = 0x10000;
return count;
}
else
{
var count = this.bytecount & 0xFF;
if(count === 0) count = 0x100;
return count;
}
};
IDEInterface.prototype.create_identify_packet = function()
{
// http://bochs.sourceforge.net/cgi-bin/lxr/source/iodev/harddrv.cc#L2821
if(this.drive_head & 0x10)
{
// slave
this.data_allocate(0);
return;
}
for(var i = 0; i < 512; i++)
{
this.data[i] = 0;
}
var cylinder_count = Math.min(16383, this.cylinder_count);
this.data_set([
0x40, this.is_atapi ? 0x85 : 0,
// 1 cylinders
cylinder_count, cylinder_count >> 8,
0, 0,
// 3 heads
this.head_count, this.head_count >> 8,
this.sectors_per_track / 512, this.sectors_per_track / 512 >> 8,
// 5
0, 512 >> 8,
// sectors per track
this.sectors_per_track, this.sectors_per_track >> 8,
0, 0, 0, 0, 0, 0,
// 10-19 serial number
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 15
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 20
3, 0,
0, 2,
4, 0,
// 23-26 firmware revision
0, 0, 0, 0, 0, 0, 0, 0,
// 27 model number
56, 118, 32, 54, 68, 72, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
// 47 max value for set multiple mode
0x80, 0,
1, 0,
//0, 3, // capabilities, 2: Only LBA / 3: LBA and DMA
0, 2, // capabilities, 2: Only LBA / 3: LBA and DMA
// 50
0, 0,
0, 2,
0, 2,
7, 0,
// 54 cylinders
cylinder_count, cylinder_count >> 8,
// 55 heads
this.head_count, this.head_count >> 8,
// 56 sectors per track
this.sectors_per_track, 0,
// capacity in sectors
this.sector_count & 0xFF, this.sector_count >> 8 & 0xFF,
this.sector_count >> 16 & 0xFF, this.sector_count >> 24 & 0xFF,
0, 0,
// 60
this.sector_count & 0xFF, this.sector_count >> 8 & 0xFF,
this.sector_count >> 16 & 0xFF, this.sector_count >> 24 & 0xFF,
0, 0,
// 63, dma supported mode, dma selected mode
this.current_command === 0xA0 ? 0 : 7, this.current_command === 0xA0 ? 0 : 4,
//0, 0, // no DMA
0, 0,
// 65
30, 0, 30, 0, 30, 0, 30, 0, 0, 0,
// 70
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 75
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 80
0x7E, 0, 0, 0, 0, 0, 0, 0x74, 0, 0x40,
// 85
0, 0x40, 0, 0x74, 0, 0x40, 0, 0, 0, 0,
// 90
0, 0, 0, 0, 0, 0, 1, 0x60, 0, 0,
// 95
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 100
this.sector_count & 0xFF, this.sector_count >> 8 & 0xFF,
this.sector_count >> 16 & 0xFF, this.sector_count >> 24 & 0xFF,
]);
this.data_length = 512;
this.data_end = 512;
};
IDEInterface.prototype.data_allocate = function(len)
{
this.data_allocate_noclear(len);
for(var i = 0; i < (len + 3 >> 2); i++)
{
this.data32[i] = 0;
}
};
IDEInterface.prototype.data_allocate_noclear = function(len)
{
if(this.data.length < len)
{
this.data = new Uint8Array(len + 3 & ~3);
this.data16 = new Uint16Array(this.data.buffer);
this.data32 = new Int32Array(this.data.buffer);
}
this.data_length = len;
this.data_pointer = 0;
};
IDEInterface.prototype.data_set = function(data)
{
this.data_allocate_noclear(data.length);
this.data.set(data);
};
IDEInterface.prototype.report_read_start = function()
{
this.stats.loading = true;
this.bus.send("ide-read-start");
};
IDEInterface.prototype.report_read_end = function(byte_count)
{
this.stats.loading = false;
var sector_count = byte_count / this.sector_size | 0;
this.stats.sectors_read += sector_count;
this.stats.bytes_read += byte_count;
this.bus.send("ide-read-end", [this.nr, byte_count, sector_count]);
};
IDEInterface.prototype.report_write = function(byte_count)
{
var sector_count = byte_count / this.sector_size | 0;
this.stats.sectors_written += sector_count;
this.stats.bytes_written += byte_count;
this.bus.send("ide-write-end", [this.nr, byte_count, sector_count]);
};
IDEInterface.prototype.get_state = function()
{
var state = [];
state[0] = this.bytecount;
state[1] = this.cylinder_count;
state[2] = this.cylinder_high;
state[3] = this.cylinder_low;
state[4] = this.data_pointer;
state[5] = 0;
state[6] = 0;
state[7] = 0;
state[8] = 0;
state[9] = this.drive_head;
state[10] = this.error;
state[11] = this.head;
state[12] = this.head_count;
state[13] = this.is_atapi;
state[14] = this.is_lba;
state[15] = this.lba_count;
state[16] = this.data;
state[17] = this.data_length;
state[18] = this.sector;
state[19] = this.sector_count;
state[20] = this.sector_size;
state[21] = this.sectors_per_drq;
state[22] = this.sectors_per_track;
state[23] = this.status;
state[24] = this.write_dest;
state[25] = this.current_command;
state[26] = this.data_end;
state[27] = this.current_atapi_command;
return state;
};
IDEInterface.prototype.set_state = function(state)
{
this.bytecount = state[0];
this.cylinder_count = state[1];
this.cylinder_high = state[2];
this.cylinder_low = state[3];
this.data_pointer = state[4];
this.drive_head = state[9];
this.error = state[10];
this.head = state[11];
this.head_count = state[12];
this.is_atapi = state[13];
this.is_lba = state[14];
this.lba_count = state[15];
this.data = state[16];
this.data_length = state[17];
this.sector = state[18];
this.sector_count = state[19];
this.sector_size = state[20];
this.sectors_per_drq = state[21];
this.sectors_per_track = state[22];
this.status = state[23];
this.write_dest = state[24];
this.current_command = state[25];
this.data_end = state[26];
this.current_atapi_command = state[27];
this.data16 = new Uint16Array(this.data.buffer);
this.data32 = new Int32Array(this.data.buffer);
};